Inicialmente, eu separaria este texto em vários módulos. Porém, optei por faer algo mais sucinto e criar apenas este módulo – que complementa o Módulo #0, sobre os comandos básicos do Linux.

Neste módulo, serão abordados vários temas da programação em Shell (Bash), desde variáveis e funções, até expansões, expressões regulares etc.

Sem mais delongas, vamos ao que interessa! :)

Sumário

0. Scripts Shell
1. Variáveis
1.1 Variáveis de Ambiente
1.2. Variáveis Especiais
2. Controle de Fluxo
2.1. Condicionais
2.1.1. if
2.1.2. case
2.1.3. select
2.2. Estruturas de Repetição (Loops)
2.2.1. for
2.2.2. while
2.2.3. until…do
2.2.4. break
2.2.5. continue
3. Padrão C/C++ em Expressões “(())”
4. Entrada/Saída
4.1. Redirecionamento
4.2. Usando Pipelines
5. Expansões
5.1. Expansão de Variáveis
6. Parâmetros de linha de comando
7. Definindo Funções
7.1. Retorno de Funções
8. Expressões Regulares em Bash
9. Expressões Matemáticas
10. O Arquivo .bashrc
11. Aliases (Apelidos)
12. Referências

0. Scripts Shell

Antes de mostrar os recursos do shell, vamos dar uma olhada na maneira como devemos criar scripts shell. Isso facilitará a compreensão do restante do artigo.

Todo arquivo com códigos shell deve ter, na primeira linha, o identificador do interpretador a ser utilizado. A “linha mágica” que chama o interpretado bash é:

#!/bin/bash

O mesmo vale para outras linguagens interpretadas, como PHP, Python, Ruby, Perl etc.

Tendo essa linha no início do arquivo, o segundo passo é dar permissão de execução ao arquivo:

$ chmod +x script.sh
<pre>
 
Feito isso, basta executar o script:
 
<pre lang="bash">
$ ./script.sh

Também é possível executar o script usando o comando bash:

$ bash script.sh

Assim não é necessário haver a “linha mágica” no início do script. Também não é preciso dar permissão de execução ao arquivo.

1. Variáveis

O Bash, assim como muitas outras linguagens, possui o conceito de variável. Para definir uma variável:

nome_da_variavel="valor da variável"

É importante ressaltar que não deve haver espaços entre o símbolo de atribuição, o nome da variável e seu valor, para que o bash interprete o comando como atribuição, não chamada de comandos.

Para exibir o valor de uma variável, basta usar echo da seguinte forma:

echo $nome_da_variavel

1.1 Variáveis de Ambiente

As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são: HOME, PATH, EDITOR, etc.

Para entender o seu uso, vejamos um exemplo: editores de texto, como Vi, possuem diferentes interfaces para os modos texto e gráfico e necessitam saber qual o tipo de terminal o usuário está usando. A variável de ambiente TERM é o modo pelo qual isto pode ser determinado. Outro exemplo são os programas de e-mail que permitem ao usuário editar mensagens com o editor de textos de sua preferência. Como estes programas sabem qual editor usar? É através da variável EDITOR ou VISUAL.

Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser “exportada”, com o comando export:

export <variável>

Também podemos exportar e atribuir valores a uma variável numa única linha de comando:

export <variável>=<valor>

Podemos verificar quais são as variáveis de ambiente já definidas e seus respectivos valores usando o comando abaixo:

export -p

Para visualizar todas as variáveis basta usar set ou env. Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na variável são separados pelo caractere dois-pontos (:).

Caso o usuário joao queira adicionar um outro diretório, digamos /home/joao/bin à variável PATH, deve proceder como mostrado a seguir:

$ export PATH=$PATH:/home/joao/bin   # adiciona o diretório
$ echo $PATH                         # verifica
/bin:/usr/bin:/usr/local/bin:/home/joao/bin

O primeiro comando faz com que a variável receba o seu valor atual, concatenado com o nome do diretório a ser acrescentado. Observe que existe um “:” antes do nome do diretório. O segundo comando é utilizado apenas para visualizarmos o resultado do primeiro.

1.2. Variáveis Especiais

Existem algumas variáveis especiais, normalmente utilizadas em script shell, para verificação de parâmetros, valores de retorno de comandos e funções etc.

2. Controle de Fluxo

Controle de fluxo permite interromper, continuar e deslocar o fluxo de execução do script. Isso envolve controles de decisão (condicionais) e estruturas de repetição (loops).

2.1. Condicionais

2.1.1. if

Sintaxe:

if <condicao>
then
    comandos
elif <condicao_2>
    comandos 
else
    comandos 
fi

O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.

Por exemplo:

if test 5 -lt 7
then
    echo '5 é menor que 7'
fi

Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:

if [ 5 -lt 7 ]
then
    echo '5 é menor que 7'
fi

O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador “<".

Outros possíveis operadores são:

Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)

Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)
-z: É nula (vazia)

Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)

Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)

2.1.2. case

Sintaxe:

case <string> in
    opcao1)
        comandos 
        ;;
    opcao2)
        comandos 
        ;;
    *)
        operação padrão
esac

Exemplo:

echo "Digite um número"
read x
 
case "$x" in 
    1)
        echo "Você digitou o número 1"
        ;;
    2)
        echo "Você digitou o número 2"
        ;;
    *)
        echo "Você digitou outro número"
esac

2.1.3. select

Sintaxe:

select <variavel> in <opcao1> <opcao2> ...
do 
    comandos 
done

O comando select é pouco utilizado, mas pode ser muito útil para montar menus. Esse comando exibe um menu, associando cada opção a um número. Quando o usuário seleciona o número da opção, o seu valor é associado à .

Exemplo:

select i in lista_arquivos lista_arquivos_tree
do
    case "$i" in 
        lista_arquivos)
            ls
            ;;
        lista_arquivos_tree)
            ls -R
            ;;
    esac
done

2.2. Estruturas de Repetição (Loops)

Loops são estruturas que permitem fazer iterações sobre algum dado.

2.2.1. for

Sintaxe:

for <var> in <lista>
do
    <comandos>
done

“var” é o nome da variável a ser usada no bloco de repetição. “lista” pode ser uma lista de dados, fixa ou retornada por outro comando (como o ls), uma sequência de números etc.

Exemplos:

Exibe uma sequência de números:

for i in 1 2 3 4 5
do
    echo $i
done

Lista os diretórios e arquivos da raiz do sistema de arquivos:

for i in $(ls /)
do
    echo $i
done

for i in $(seq 1 10)
do
    echo $i
done

for i in $(cat /etc/passwd)
do
    echo $i
done

2.2.2. while

Sintaxe:

while <condicao>
do
    <comandos>
done

Exemplos:

Exibe a sequência de 1 a 10:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Loop infinito que exibe “bash” na tela:

while true
do
    echo 'bash'
done

Lendo strings da entrada padrão:

while read i
do
    echo 'Voce digitou a string: ' $i
done

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read i
do
    echo $i
done

Esse exemplo facilita o trabalho com arquivos de texto, cujas linhas possuem espaços. Se fosse usado um loop for nesse caso, seria necessário alterar a variável de ambiente IFS, definindo o separador para quebra de linha (\n).

Uma variação do exemplo anterior é esta:

while read i
do
    echo $i
done < arquivo.txt

A principal diferença entre estes dois últimos exemplos é que, no primeiro, o loop while é executado num subshell, devido ao uso do pipe (|). No segundo exemplo, o while é executado no shell corrente.

Para ilustrar o problema, crie um arquivo chamado “arq.txt” com algumas linhas de texto. Crie este script e execute-o:

#!/bin/bash
 
FILE='arq.txt'
 
total=0
cat $FILE | while read i
do
	total=$((total+1))
done
echo 'Total de linhas: ' $total
 
total=0
while read i
do
	total=$((total+1))
done < $FILE
echo 'Total de linhas: ' $total

O primeiro loop é executado num subshell, fazendo com que a variável “total”, usada no corpo do loop, existe apenas nesse subshell. No segundo caso, isso não ocorre. Isso pode gerar grandes dores de cabeça… (como já ocorreu comigo)

2.2.3. until…do

Sintaxe:

until <condicao>
do
    <comandos>
done

Nesse loop, a condição é oposta à usada no while. Por exemplo:

Com while:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Com unitl:

i=0
until [ $i -ge 10 ]
do
    echo $i
    i=$((i+1))
done

Para fazer a mesma coisa, tivemos que usar expressões diferentes na condição do loop.

2.2.4. break

O comando break encerra um loop imediatamente.

Exemplos:

i=0
while true
do
    if [ $i -ge 10 ]
    then
        break
    fi
    i=$((i+1))
done

while read i
do
    if [ $i -eq 0 ]
    then
        break
    fi
done

2.2.5. continue

O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de repetição.

3. Padrão C/C++ em Expressões “(())”

É possível usar o padrão C em expressões do shell, como em condicionais de estruturas de controle. Para isso, basta colocar a expressão entre dois parênteses.

Exemplos;

i=0
while (( i < 10 ))
do
    echo $i
    ((i++))
done

É possível, inclusive, usar o padrão do loop for do C:

for ((i = 0; i < 10; i++)
do
    echo $i
done

4. Entrada/Saída

Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:

stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.

Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre abertos e que não devem ser fechados.
É possível brincar com eles no próprio shell. Experimentem dar um cat em /dev/stdin para ver o que acontece. :)

4.1. Redirecionamento

A entrada de um programa consiste nos dados que lhe são passados inicialmente, os quais são necessários para a execução do programa. A entrada de um programa pode vir do teclado ou de um arquivo, por exemplo. Argumentos passados à comandos constituem a sua entrada.
A saída é constituída pelas informações geradas pelo programa, ou seja, o resultado de sua execução. A saída pode ser mostrada na tela ou gravada em um arquivo de registro.

Muitos comandos do Linux têm sua entrada configurada para a entrada padrão e sua saída para a saída padrão. A entrada padrão é o teclado e a saída padrão é o monitor. Vejamos um exemplo usando o comando cat, que lê dados de todos os arquivos passados como parâmetros e os envia diretamente para a saída padrão. Usando o comando abaixo, veremos o conteúdo do arquivo “arq1″ seguido pelo conteúdo de “arq2″.

$ cat arq1 arq2

Entretanto, se nenhum nome de arquivo for dado como parâmetro, o comando cat lê dados da entrada padrão e os envia para a saída padrão. Para interromper, deve-se pressionar as teclas ctrl e d simultaneamente (ctrl+d).

$ cat 
Ola! Tem alguem ai?  # usuário 
Ola! Tem alguem ai?  # eco do sistema 
Ate mais!            # usuário 
Ate mais!            # eco do sistema
              # usuário pressiona ctrl+d

Como podemos ver, cada linha que o usuário digita é imediatamente ecoada pelo comando cat. Aqui um outro exemplo: o comando sort lê dados da entrada padrão – a menos que algum arquivo seja dado como parâmetro – e ordena os dados, enviando-os para a saída padrão:

$ sort 
bananas     # usuário
peras       # usuário
goiabas     # usuário
            # ctrl+d
bananas     # eco do sistema
goiabas     # eco do sistema
peras       # eco do sistema

Digamos que queremos enviar a saída do comando sort para um arquivo, gravando os dados digitados anteriormente. O shell nos permite redirecionar a saída para um arquivo usando o símbolo “>”.

$ sort > lista
bananas  # usuário
peras    # usuário
goiabas  # usuário
         # ctrl+d

Como se pode ver, o resultado do comando sort não é mostrado imediatamente após o se digitar ctrl+d. Ao invés disso, é salvo em um arquivo chamado “lista”. Vejamos o conteúdo desse arquivo:

$ cat lista
bananas
goiabas
peras

Com o redirecionamento de saída, temos uma maneira simples de criar arquivos de texto. Para isso, utilizamos o comando cat para ler a entrada padrão (teclado) e redirecionamos sua saída para um arquivo.

Ao usar “>” para redirecionar a saída para um arquivo, estamos realizando um redirecionamento destrutivo, ou seja, o comando “ls > lista” sobrescreve o conteúdo do arquivo “lista”. Isto é equivalente a dizer que todo o conteúdo anterior de “lista” é apagado.
Se, ao invés disso, redirecionarmos usando “>>”, a saída será concatenada ao final do arquivo e o conteúdo (se houver) de “lista” será preservado. Para melhor entender isso, experimente executar a seguinte seqüência de comandos:

ls >> listagem
ls >> listagem
less listagem

O redirecionamento neste exemplo, diferentemente do exemplo anterior, é denominado redirecionamento não-destrutivo.

4.2. Usando Pipelines

Nos exemplos para o filtro sort, os dados de entrada eram digitados pelo usuário ou estavam gravados em um arquivo. O que aconteceria se quiséssemos ordenar dados vindos do saída de outro comando ? Para listar os arquivos do diretório corrente em ordem alfabética invertida devemos fazer com que a saída do comando ls seja ordenada pelo comando sort. Usando a opção “-r”, este comando ordena os dados na ordem inversa.

$ ls
historia  notas     tese      testes 
$ ls > lista 
$ sort -r lista 
testes
tese
notas
lista                             # observe esse nome de arquivo
historia

Aqui, salvamos a saída do comando ls em um arquivo (lista) e usamos sort com a opção “-r”. Porém, isso faz com que tenhamos um arquivo temporário para armazenar os dados. Assim, toda vez que fizermos isso, teremos que, em seguida, remover o arquivo lista. A solução é usar o que chamamos de pipeline, outro recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.

No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo “|” (barra vertical) é usado para criar um pipe:

$ ls | sort -r 
testes
tese
notas
historia

Note que neste exemplo, nenhum nome de arquivo é usado na linha de comando, diferentemente do exemplo anterior que fazia o uso do arquivo intermediário lista. Outra diferença é que o nome desse arquivo intermediário aparece no resultado do penúltimo exemplo, mas não neste último. O comando é mais curto, mais fácil de digitar e o resultado é mais adequado pois não inclui nomes de arquivos intermediários.

É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem provê a sintaxe dos símbolos “>”, “<" e "|". Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar redirecionamento para especificar uma entrada para o seu programa.

5. Expansões

Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.

~: path à home do usuário corrente
~user: path à home do usuário “user”
{a,b,c}: presença do caractere “a”, “b” ou “c”. Podem ser usadas strings em vez de simplesmente caracteres.

Exemplos:

ls ~

ls ~root

ls /dev/std{in,out,err}

5.1. Expansão de Variáveis

6. Parâmetros de linha de comando

Assim como em outras linguagens, é possível passar parâmetros para scripts shell. Para isso, usam-se as variáveis $1, $2, … A variável $0 contém o comando chamado via linha de comando.

Exemplo:

Crie um arquivo “test.sh” com este conteúdo:

#!/bin/bash
 
echo '$0 = '$0
echo '$1 = '$1
echo '$2 = '$2

Veja as saídas das execuções abaixo:

$ ./test.sh 
$0 = ./test.sh
$1 = 
$2 = 
$ ./test.sh um
$0 = ./test.sh
$1 = um
$2 = 
$ ./test.sh um dois
$0 = ./test.sh
$1 = um
$2 = dois

7. Definindo Funções

Sintaxe:

function nome_da_funcao()
{
     <comandos>
}

Para chamar a função:

nome_da_funcao
 
# caso haja parâmetros
nome_da_funcao param1 param2 ...

Exemplo:

#!/bin/bash
 
function imprime()
{
	echo "Sou a função '${0}'"
	echo "Param 1: ${1}"
	echo "Param 2: ${2}"
	echo "Lista de parâmetros: ${*}"
}
 
imprime um dois tres quatro

Da mesma forma como foram usados $0, $1 etc anteriormente, aqui essas variáveis são usadas para retornar os parâmetros da função. Logo, percebe-se que, dentro de funções, não é possível acessar parâmetros de script, a menos que eles sejam passados por parâmetro para a função.

7.1. Retorno de Funções

Antes de tudo, é preciso diferenciar retorno de função e saída de função. Por exemplo, ao se executar o comando “cat /etc/passwd”, a saída é o conteúdo do arquivo; o retorno é 0 (ou outro valor, caso ocorra erro). O retorno de uma função shell é um valor inteiro, normalmente utilizado para definir o status da função, ou seja, se ocorreu algum erro ou e ela foi executada corretamente.

Para obter o valor de retorno de uma função, usa-se a variável “$?”. Ela exibe o retorno do último comando executado. Por exemplo:

$ cat /etc/passwd
echo $?

Para retornar valor (status) numa função, usa-se o comando return.

Exemplo:

#!/bin/bash
 
function retorna()
{
    echo "sou um valor"
    return 42
}
 
valor=$(retorna)
echo $?
echo $valor

Ao se executar a função, sua saída será “sou um valor”; seu retorno será 42.

Em shell, considera-se o valor 0 como execução bem sucedida. Qualquer outro valor representa erro. É por isso que recomenda-se que toda função main de um programa em C retorne o valor 0, desde que não ocorra algum erro.

8. Expressões Regulares em Bash

Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar comparações usando ER’s:

s="bash"
if [[ "$s" =~ ^b ]]
then
    echo 'começa com b'
fi

9. Expressões Matemáticas

O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas, mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:

$ a=$((1 + 1))
$ ((i++))
$ x=$((x*2))
...

10. O Arquivo .bashrc

Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):

$ vim ~/.bashrc

É possível usar outros editores, não apenas o vim.

11. Aliases (Apelidos)

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um alias pode ser definido na linha de comando da seguinte forma:

alias <nome>=<comando>

Observe que não pode haver espaços em branco antes ou depois do “=”.

Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por “comando”.

Exemplo:

$ alias lf='ls -F'

Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).

É possível definir aliases em seu .bashrc, para que eles estejam sempre disponíveis na sua sessão.

12. Referências

Linux Básico:
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico/ ou http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico.pdf

Linux Avançado

http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxAvancado.pdf

Canivete Suiço do Shell (Bash)

http://aurelio.net/shell/canivete/

Livro Shell Script Profissional (Livro físico):

http://www.shellscript.com.br/

Não adianta querer programar usando Shell sem conhecer os comandos básicos do Linux. Por isso o primeiro módulo do “curso” abordará os comandos básicos do Linux, que são fundamentais para a construção dos scripts.

Vamos analisar apenas alguns comandos, os mais conhecidos e usados, juntamente com algumas de suas opções. A maioria dos comandos permitem o uso de inúmeras opções, não sendo possível abordar todos elas neste texto.

Antes de iniciarmos, vale lembrar que os manuais de todos os comandos podem ser lidos usando o comando man nome_do_comando, por exemplo:

$ man echo

A maioria dos comandos também têm a opção -h, ou –help, que lista os parâmetros aceitos pelo programa.

Os comandos estão ordenados alfabeticamente, sem levar em consideração relevância ou complexidade de utilização.

Sumário

awk
cat
cd
chmod
cut
date
diff
echo
find
grep
head
kill
ls
printf
rev
scp
sed
seq
sort
ssh
tac
tail
top

awk

O AWK é uma linguagem de programação para processamento de textos. Ao lado do comando SED, é capaz de realizar muitos truques.

Um post exclusivo sobre AWK pode ser visto aqui:

http://www.rberaldo.com.br/blog/tutorial-awk

cat

Exibe o conteúdo de um arquivo.

Opções:
-n : numera as linhas

Exemplos:

$ cat /etc/hostname 
orion

$ cat -n /etc/hostname 
     1	orion

cd

Muda o diretório de trabalho, ou seja, entra em um determinado diretório.

Exemplo:

$ cd /tmp

$ cd ~

chmod

O chmod (change mode) muda as permissões de um arquivo ou diretório. O sistema de permissões em sistemas Unix-Like, como Linux ou Mac OS, é um dos pontos fortes desses sistemas. Porém, infelizmente, poucos usuários realmente sabem usá-lo.

Um post exclusivo ao chmod pode ser lido aqui:

http://www.rberaldo.com.br/blog/chmod-permissoes-em-sistemas-linux-e-unix-like

cut

Separa trechos ou campos de uma linha, por meio de um delimitador. Também trunca textos, exibindo apenas um número específico de caracteres.

Opções
-d : define o delimitador
-f : define o(s) campo(s) a ser(em) exibido(s)
-c : número do caractere a ser exibido ou intervalo de caracteres

Exemplos:

$ echo "um:dois:tres:quatro" | cut -d: -f 2
dois

$ echo "um:dois:tres:quatro" | cut -d: -f 2,3
dois:tres

Também é possível definir intervalo de valores para a opção -f:

$ echo "um:dois:tres:quatro" | cut -d: -f 1-3
um:dois:tres

$ echo "um:dois:tres:quatro" | cut -d: -f 2-
dois:tres:quatro

$ echo "1234567890" | cut -c 7
7

$ echo "1234567890" | cut -c 1,3,5
135

beraldo@orion:~$ echo "1234567890" | cut -c 1-7
1234567

$ echo "1234567890" | cut -c 8-
890

beraldo@orion:~$ echo "1234567890" | cut -c -5
12345

date

Mostra a data atual ou uma data específica, com diversas opções para formatação da data.

Opções:
-d : especifica a data (Ex: tomorrow, 5 days ago)
+%? : define o padrão de formatação da data. A lista de opções pode ser lida no manual do comando (man date).

Exemplos:

$ date
Dom Mai  1 20:05:47 BRT 2011

$ date -d "yesterday"
Sáb Abr 30 20:05:59 BRT 2011

$ date -d "2 days ago"
Sex Abr 29 20:06:10 BRT 2011

beraldo@orion:~$ date -d "2 days"
Ter Mai  3 20:06:13 BRT 2011

$ date +"%d/%m/%Y"
01/05/2011

$ date -d "30 days" +"Daqui 30 dias será %d/%m/%Y"
Daqui 30 dias será 31/05/2011

diff

Exibe as diferenças entre dois arquivos.

Opções:
-i : case-insensitive (indiferente a maiúsculas e minúsculas)
-y : exibe as diferenças lado a lado
-E : ignora diferenças no tamanho do TAB
-B : ignora linhas vazias
-b : ignora quantidade de espaços

Outros comandos semelhantes muito úteis: vimdiff e diff3

O comando diff é muito útil para encontrar cópias de trabalhos de faculdade, por exemplo. :P

echo

Exibe um texto na saída padrão.

Opções:
-n : não pula linha no final do texto
-e : interpreta caracteres de escape

Exemplos:

$ echo "sou \n um \n texto"
sou \n um \n texto

$ echo -e "sou \n um \n texto"
sou 
 um 
 texto

find

Localiza arquivos no sistema de arquivos.

Esse comando possui diversas opções e truques. Por isso, merece um post específico para ele. Um post muito bom sobre o find pode ser encontrado aqui:

http://gerencievocemesmo.com.br/site/?p=56

grep

Localiza padrões dentro de um ou mais arquivos. A busca é feita usando Expressões Regulares.

Opções:
-i : case-insensitive
-v : inverte o critério de busca
-r : recursivo, busca em subdiretórios também
-n : mostra, também, o número da linha
-c : conta o número de linhas que casaram com o padrão
-l : exibe só o nome do arquivo onde o padrão foi encontrado
-A N : mostra N linhas após a linha onde o padrão foi encontrado
-B N : mostra N linhas antes da linha onde o padrão foi encontrado
-C N : mostra N linhas antes e depois da linha onde o padrão foi encontrado

$ seq 10 | grep -A2 -B3 "5"
2
3
4
5
6
7

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep "^[a-z]"
olá
sou
teste
para
grep

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep -v "^[a-z]"
1

Para usar todos os recursos das Expressões Regulares, use egrep em vez de grep, o que permite usar grupos, quantificadores “+” e “{quantificador}”.

head

Mostra o início de um arquivo. O limite pode ser estabelecido em número de linhas ou caracteres. É o inverso do comando tail.

Opções:
-n N : exibe as N primeiras linhas
-c N : exibe os N primeiros caracteres

Exemplos:

$ echo -e "olá, sou\num teste\npara o\ncomando head" | head -n 2
olá, sou
um teste

$ echo -e "ola, sou\num teste\npara o\ncomando head" | head -c 7
ola, so

kill

O comando kill “mata” processos, ou seja, encerra, ou força o encerramento, de um programa.

Opções:
-9 : força o encerramento da execução de um processo
-1 : mata todos os processos que o usuário pode matar

Exemplos:

Força o encerramento do processo 1234:

$ kill -9 1234

Encerra a sessão do usuário, ou seja, força o encerramento de todos os seus processos:

$ kill -1 -9

Os IDs dos processos (PID – Process ID) podem ser encontrados usando o comando ps, que é o gerenciador de processos. Com as opções “ux”, listam-se os processos do usuário. Com grep podemos filtrar a saída pelo processo desejado:

$ ps ux | grep skype
beraldo   2267  1.0  2.0 281508 82968 ?        Sl   09:58   0:41 skype
beraldo   5672  0.0  0.0  10128   848 pts/0    S+   11:04   0:00 grep --color=auto skype

O skype é o processo 2267. Para forçar seu encerramento, fazemos:

$ kill -9 2267

Como lição de casa, vale ler os manuais dos comandos killall e pkill. :)

ls

Lista o conteúdo de um diretório.

Opções:
-a : lista arquivos e diretórios ocultos
-l : mostra diversos atributos dos arquivos e diretórios, como data de criação, dono, permissões etc
-R : lista o conteúdo recursivamente

Exemplos:

$ ls

$ ls -a

$ ls -l

$ ls -la

$ ls -laR

printf

Exibe um texto na tela, com várias opções de formatação, semelhante à função printf(), da linguagem C.

As opções de formatação são praticamente as mesmas da linguagem C. A lista completa pode ser vista no manual (man printf).

Exemplos:

$ printf "%x\n" 15
f

$ printf "%o\n" 7
7

$ printf "%o\n" 8
10

$ printf "%05d\n" 70
00070

$ printf "%.2f\n" 70
70,00

rev

Esse comando inverte uma string.

Exemplos:

$ echo "texto" | rev
otxet

$ echo "duh" | rev
hud

scp

Copia arquivos e diretórios via ssh, ou seja, cópia segura entre máquinas remotas.

Opções:
-r : cópia recursiva

Sintaxe:

$ scp [opções] maquina:origem destino
$ scp [opções] origem maquina:destino

Exemplos:

$ scp 192.168.0.100:~/arquivo.txt .

$ scp arquivo.txt 192.168.0.102:~

sed

Linguagem para edição de arquivos e textos. Veja um post exclusivo a ela aqui:

http://www.rberaldo.com.br/blog/o-comando-sed-do-linux/

seq

Exibe uma sequência de números.

Opções:
-s : separador (padrão “\n”)
-f : formato (padrão “%g”)

Exemplos:

$ seq 3
1
2
3

$ seq 3 5
3
4
5

$ seq 3 2 10
3
5
7
9

$ seq 10 -2 0
10
8
6
4
2
0

$ seq -s, 10 -2 0
10,8,6,4,2,0

$ seq -s, -f"%04g" 10 -2 0
0010,0008,0006,0004,0002,0000

sort

Ordena linhas de um texto, alfabética ou numericamente.

Opções:
-n : ordena numericamente
-r : ordena inversamente (de Z para A e de 9 para 1)
-f : case-insensitive
-k N : ordena pela coluna N do texto
-t : separador de coluna para a opção -k (padrão TAB)
-o : define um arquivo para a saída do comando

Exemplos:

$ echo -e "um\ndois\ntres\nquatro" | sort
dois
quatro
tres
um

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2
um	dois
tres	quatro

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2 -r
tres	quatro
um	dois

$ echo -e "1\n10\n100\n2\n20\n200" | sort 
1
10
100
2
20
200

$ echo -e "1\n10\n100\n2\n20\n200" | sort -n
1
2
10
20
100
200

ssh

O SSH (Secure Shell) realiza acesso remoto a outras máquinas Linux. Um post exclusivo a SSH pode ser lido aqui:

http://www.rberaldo.com.br/blog/usando-o-ssh

tac

Inverso do comando cat. Exibe o conteúdo de um arquivo do fim para o início.

tail

Exibe o fim de um texto, exatamente o oposto do comando head

Opções:
-n N : número de linhas a exibir
-c N : número de caracteres a exibir

Exemplos semelhantes ao do comando head.

top

O comando top exibe os processos atualmente em execução. É semelhante ao ps, citado na seção do comando kill, mas atualiza-se automaticamente, além de possuir várias opções de ordenação.

Exemplo:

$ top

O comando “htop” é mais completo e user-friendly, mas normalmente não vem instalado nas distros Linux. É possível instalá-lo via gerenciador de pacotes. Por exemplo, em sistemas baseados em Debian:

# apt-get install htop

O Python possui bibliotecas para implementação de servidores WEB simples. Há versão de apenas uma thread (atende uma requisição por vez) ou multi-thread (atende diversas requisições simultaneamente).

Os exemplos abaixo apenas enviam al cliente uma mensagem “INICIO”, esperam 2 segundos, e enviam outra mensagem, “FIM”. A espera por 2 segundos será útil apenas para enfatizar a diferença entre as versões monothread e multi-thread.

Os códigos funcionam em qualquer Sistema Operacional com Python instalado, mas os exemplos de execução que mostrarei são voltados para Linux ou Mac OS, onde há um terminal com suporte a bash e curl. Porém, nada impede que os testes sejam feitos em navegadores.

Versão simples, com apenas uma thread, ou seja, atende apenas uma requisição por vez:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import BaseHTTPRequestHandler
import urlparse
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class GetHandler(BaseHTTPRequestHandler):
 
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write( "INICIO\n" )
        time.sleep( 2 )
        self.wfile.write( "FIM\n" )
 
if __name__ == '__main__':
    from BaseHTTPServer import HTTPServer
    server = HTTPServer(('localhost', PORT), GetHandler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

Para executar:

$ python monothread.py

Ou, caso você dê permissão de execução ao script:

$ ./monothread.py

Para enviar solicitações ao servidor, sugiro este comando:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Você verá que cada requisição será atendida de cada vez. Ou seja, ao terminar a requisição 1, inicia-se o atendimento à requisição 2, mesmo que todas as 5 requisições tenham sido feitas “ao mesmo tempo” (note o & indicando que o cURL rodará em background).
Você verá que cada par “INICIO” e “FIM” aparecerão sequencialmente, mostrando que cada requisição é atendida individualmente.

Versão multi-thread, ou seja, atende várias requisições simultaneamente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import threading
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class Handler(BaseHTTPRequestHandler):
 
    def do_GET(self):
 
        self.send_response(200)
        self.end_headers()
        self.wfile.write('INICIO\n')
        time.sleep( 2 )
        self.wfile.write('FIM!\n')
        return
 
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    """Handle requests in a separate thread."""
 
if __name__ == '__main__':
    server = ThreadedHTTPServer(('localhost', PORT), Handler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

O procedimento para execução é o mesmo do anterior. Para testar, vamos usar o mesmo loop de requisições:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Dessa vez, todas as requisições serão atendidas ao mesmo tempo. A palavra “INICIO” aparecerá 5 vezes de uma só vez, e os logs de requisição do servidor aparecerão os 5 de uma só vez.

Os códigos acima foram adaptados deste link:
http://blog.doughellmann.com/2007/12/pymotw-basehttpserver.html

A extensão MySQLi necessita do servidor MySQL 4.1 ou superior.

Vale lembrar que há boatos de que a extensão MySQL deixe de existir no PHP 6. Logo, seja isso verdade ou não, é preferível usar MySQLi.

Vou mostrar aqui a forma de se trabalhar com a extensão MySQLi.

Para realizar a conexão com a base de dados, basta isto:

$MySQLi = new mysqli( 'servidor', 'usuario', 'senha', 'nome_da_db' );

Por exemplo:

$MySQLi = new mysqli( 'localhost', 'root', 'passwd', 'test' );

Se a conexão for bem sucedida, $MySQLi será um objeto, que será usado para consultas posteriores e outras ações com a base de dados.

Para realizar uma consulta, por exemplo, basta usar o método query() e percorrer com fetch_assoc(), muito semelhante ao que se faz usando a extensão mysql:

$exec = $MySQLi->query( 'select dados from tabela' );
 
while ( $f = $exec->fetch_assoc() )
{
    print_r( $f );
}

A lista completa de propriedades e métodos da classe MySQLi pode ser encontrada no link abaixo:

http://php.net/manual/pt_BR/book.mysqli.php

Por exemplo: em vez de executar:

INSERT INTO tabela(numero) VALUES (1);
INSERT INTO tabela(numero) VALUES (2);
...

Poderíamos executar:

INSERT INTO tabela(numero) VALUES (1), (2);

Vou mostrar uma maneira simples de se fazer isso dinamicamente, com quantidade indeterminada informações, que podem vir de qualquer tipo de fonte de dados.

Vamos considerar um array com números inteiros, de 1 a 10:

$valores = range( 1 , 10 );

Para inserir isso num banco de dados, muitos fariam isto:

$valores = range( 1 , 10 );
for ( $i = 0; $i < count( $valores ); $i++ )
{
    $DB->query( 'INSERT INTO tabela(numero) VALUES(' . $valores[ $i ] . ')' );
}

Isso funciona. Mas é lento e sobrecarrega o servidor. Imaginem um array com 100 mil valores.

O correto é gerar a string SQL com todos os valores a serem inseridos, separados por vírgula, de forma a executar a consulta apenas uma vez. Logo, podemos fazer isto:

$valores = range( 1 , 10 );
$sql = sprintf( 'INSERT INTO tabela(numero) VALUES (%s)', implode( '), (' , $valores ) );
$DB->query( $sql );

Se dermos um echo em $sql, teremos como saída:

INSERT INTO tabela(numero) VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)

Dessa forma só se executa a SQL uma vez, tornando a execução bem mais rápida.

Normalmente são usados em sistemas desktop, mas é possível usá-lo para qualqquer tipo de aplicação. O PHP possui uma função nativa destinada ao processamento desse tipo de arquivo.

Antes de tudo, é bom entender a formatação de um arquivo INI. O artigo sobre arquivos INI da Wikipedia explica muito bem essa formatação. Além disso, se você está lendo este post é porque tem familiaridade com o PHP e, consequentemente, com o arquivo php.ini, o arquivo de configuração do PHP, que é um arquivo INI.

Vamos considerar o arquivo INI abaixo, nomeado como config.ini.

; comentário da seção 1
[section 1]
config1 = "valor 1"

; comentário da seção 2
[section 2]
config2 = "valor 2"

Usaremos a função parse_ini_file, do PHP, para processarmos esse arquivo.

O protótipo da função é:

array parse_ini_file ( string $filename [, bool $process_sections = false]);

O primeiro parâmetro é o nome do arquivo a ser processado. O segundo, opcional, define se devem ser processadas as seções dos arquivos. O padrão é false. Caso passe-se o valor true, o array de retorno será multidimensional, sendo cada dimensão correspondente a cada seção do arquivo .ini.

Isso ficará mais claro ao rodarmos este script:

1
2
3
4
5

$config = parse_ini_file( 'config.ini' );
print_r( $config );
 
$configWithSections = parse_ini_file( 'config.ini', true );
print_r( $configWithSections );

A saída é:

Array
(
    [config1] => valor 1
    [config2] => valor 2
)
Array
(
    [section 1] => Array
        (
            [config1] => valor 1
        )

    [section 2] => Array
        (
            [config2] => valor 2
        )

)

O primeiro print_r exibe o array unidimensional, com todas as seções numa única dimensão do array. O segundo print_r exibe o array multidimensional, resultante do processamento que leva em conta as seções do arquivo .ini.

Com isso fica simples criar arquivos de inicialização que buscam configurações básicas em arquivos .ini.

Porém, tome cuidado ao usar arquivos .ini com informações sensíveis, como configurações de acesso a bancos de dados. Arquivos .ini podem ser acessados via URL, sendo possível visualizar seu conteúdo pelo navegador. Logo, opte por manter um arquivo ini fora do diretório público de sua aplicação (geralmente o public_html).

Porém, poucos programadores iniciantes analisam essas mensagens, seja por falta de conhecimento ou preguiça mesmo. Ou até medo…

Vou mostrar aqui as mensagens de erro mais frequentes do PHP, junto com suas principais causas e soluções.

Sumário

Habilitando todas as mensagens de erro
Retirar o Operador de Controle de Erros
Parse Error
Undefined Index
Undefined Variable
Cannot modify header information
Call to undefined function
Class not found
Call to undefined method
Call to a member function on a non-object
supplied argument is not a valid MySQL result resource
Invalid argument supplied for foreach()
Conclusão

Habilitando todas as mensagens de erro

Antes de tudo, é bom saber que o PHP é muito personalizável – o que às vezes pode ser um problema. É possível desabilitar todas as mensagens de erro, ou limitar somente a alguns níveis de erro. Não vou explicar os níveis de erro do PHP, pois não é o foco do texto. Porém deixarei links para referência.

Para habilitar todas as mensagens de erro do PHP, basta inserir este trecho no início do script:

1
2

ini_set( 'display_errors', 1 );
error_reporting( E_ALL | E_STRICT );

Documentação da função ini_set
Documentação da função error_reporting
Funções para manipulação de erros
Descrição da diretiva error_reporting do php.ini
Descrição da diretiva display_errors do php.ini

Retirar o Operador de Controle de Erros

Outro ponto a ser observado é que é possível omitir erros no pHP usando o Operador de Controle de Erros, o famoso arroba (@). Esse operador existe para ser usado, mas use-o com cautela, quando for realmente necessário.

Entenda quando usar o Operador de Controle de Erros (arroba – @)
Documentação do Operador de Controle de Erros

Parse Error

Parse Errors ocorrem quando seu código possui erros de formatação, como caractere faltando ou em excesso.

Por exemplo:

1
2
3

<?php
phpinfo);
?>

Retornará o erro:

Parse error:  syntax error, unexpected ')' in teste.php on line 2

A correção é sempre muito simples: analisar a linha onde o erro ocorre e procurar o acarctere indicado pelo erro. Pode estar faltando algo ou sobrando alguma coisa. Note que o erro pode não estra na linha indicada pela mensagem de erro. Pode estar na anterior. Por exemplo:

1
2
3
4

<?php
echo 'oi'
echo 'oi de novo';
?>

Mensagem de erro:

Parse error:  syntax error, unexpected T_ECHO, expecting ',' or ';' in teste.php on line 3

A mensagem diz que há erro na linha 3, mas é a linha 2 que gera problema, devido à falta do ponto-e-vírgula no final do echo.

Undefined Index

Esse erro ocorre quando tenta-se acessar um índice inexistente de um array. Esse erro é muito comum com iniciantes usando Query String. O famoso exemplo:

1
2
3

<?php
$pag = $_GET['pag'];
?>

Se não existe a variável “pag” na URL, dará este erro:

PHP Notice:  Undefined index: pag in teste.php on line 2

Para evitar esse erro, sempre verifique se o índice existe. A função isset resolve facilmente esse problema:

1
2
3
4
5
6
7
8

if ( isset( $_GET['pag'] ) )
{
    $pag = $_GET['pag'];
}
else
{
    $pag = 'valor padrão';
}

O código pode ser reescrito sda seguinte forma, usando o Operador Condicional Ternário:

1

$pag = isset( $_GET['pag'] ) ? $_GET['pag'] : 'valor_padrao';

Mais sobre o Operador Ternário aqui:
http://www.php.net/manual/pt_BR/language.operators.comparison.php

Undefined Variable

Como o erro mostra claramente, isso ocorre quando se tenta usar uma variável não declarada (ou definida, no caso do PHP).

1
2
3

<?php
echo $var;
?>

Erro:

PHP Notice:  Undefined variable: var in teste.php on line 2

A solução não poderia der outra: criar a variável antes de usá-la.
Logicamente, o erro pode ter ocorrido por um erro de digitação do nome da variável.

Cannot modify header information

Essa mensagem de erro está ligada a envio de cabeçalhos HTTP, o que envolve sessions, cookies, a própria função header, do PHP.

O envio de cabeçalhos HTTP devem ser realizados sempre antes de qualquer saída ao navegador, ou seja, sempre antes de códigos HTML e funções que exibam dados, como echo, print, print_r etc. Também não pode haver espaços vazios no código, antes da tag <?.

O membro hinom, do iMasters Fóruns, escreveu um excelente tutorial sobre isso, que pode ser visto no link abaixo:
http://forum.imasters.com.br/index.php?/topic/342563-dicas-para-uso-de-variaveis-de-sessao

Call to undefined function

Novamente, o erro é claro: foi feita uma chamada a uma função não definida.

1
2
3

<?php
beraldo();
?>

Erro:

Fatal error:  Call to undefined function beraldo() in teste.php on line 2

Para corrigir, defina a função. Pode ter havido erro de digitação do nome da função ou falta de inclusão do arquivo que a define.

Class not found

Ocorre quando o PHP não encontra a classe que se deseja instanciar.

<?php
$b = new Beraldo();
?>

Erro:

Fatal error:  Class 'beraldo' not found in teste.php on line 2

Como no erro anterior, a solução é declarar a classe, além de verificar se não houve erro de digitação ou falta de inclusão de arquivo.

Call to undefined method

Ocorre quando se chama um método inexistente de uma classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
 
class Beraldo
{
	public function darOi()
	{
		echo "oi";
	}
}
 
$Beraldo = new Beraldo();
$Beraldo->darTchau();
 
?>

Erro:

Fatal error:  Call to undefined method Beraldo::darTchau() in teste.php on line 12

Deve-se criar o método ou verificar se não houve erro de digitação do nome do método.

Call to a member function on a non-object

Isso ocorre quando se chama um método em uma variável que não é uma instância de um objeto.

1
2
3
4

<?php
$var = 'oi, sou uma string';
$var->metodo();
?>

Erro:

Fatal error:  Call to a member function metodo() on a non-object in teste.php on line 3

Para solucionar o erro, verifique se não usou a variável errada ou se não modificou o valor original da variável, de forma a ter perdido a instância do objeto.

supplied argument is not a valid MySQL result resource

Esse erro ocorre quando uma função espera, como parâmetro, um resource retornado por outra função do MySQL. O mais comum é ocorrer erro na linha onde há a função mysql_fetch_assoc(), mysql_fetch_array() e semlhantes. Isso quer dizer que o parâmetro passado não é um resource retornado por mysql_query(), o que indica que a consulta falhiou e mysql_query() retornou FALSE.

Mensagem de erro:

Warning: mysql_fetch_array(): supplied argument is not a valid MySQL result resource in ...

A solução é corrigir a query executada. Muitas vezes o erro é simples, apenas nome de tabela ou campo errados, ou erro de sintaxe. Para visualizar o erro retornado pelo MySQL, pode-se usar a função mysql_error(). Logo, deve-se executar a consulta desta maneira:

1

$exec = mysql_query( $sua_consulta_aqui ) or exit( mysql_error() );

Caso a consulta falhe, ou seja, mysql_query retorne FALSE, a função exit() finalizará a execução do script, mostrando o erro do MySQL, devido à função mysql_error(). Ler a mensagem de erro ajuda a encontrar o erro na consulta SQL.

OBS: Mostrei exemplo usando MySQL, mas recomendo fortemente que seja usada a extensão MySQLi, que é bem mais completa, além de prover recuersos novos do MySQL 4.1.

Invalid argument supplied for foreach()

Esse erro ocorre quando o argumento passado para o loop foreach não é um array.

1
2
3
4
5
6
7

<?php
$var = '';
foreach ( $var as $k )
{
	echo $k;
}
?>

Erro:

Warning:  Invalid argument supplied for foreach() in teste.php on line 3

Como $var é uma string, foi gerado o erro. Para corrigir, basta verificar se o parâmetro está correto ou se ele não foi modificado durante a execução do script, deixando de ser um array.

Conclusão

As mensagens de erros geralmente são muito claras. Portanto, leia-as atentamente antes de perguntar para alguém ou criar um tópico em um fórum só para isso. Muitas vezes os erros são de fácil correção, bastando ler com cuidado das mensagens de erro.

A fim de facilitar o envio de e-mails, foi criada a classe PHPMailer, que possui excelente configuração de cabeçalhos, além de facilitar tarefas meio chatas, como anexar arquivos nas mensagens.

A classe PHPMailer pode ser baixada em seu site oficial. O pacote baixado terá, dentre outros arquivos e diretórios, os arquivos class.phpmailer.php e class.smtp.php. O primeiro contém a classe PHPMailer, a qual instanciaremos para o envio da mensagem; o segundo contém a classe para envio de email por SMTP. Esse arquivo é automaticamente inclúido pela classe PHPMailer, caso opte-se por envio via SMTP, ou seja, não é necessário incluir esse arquivo, apenas o class.phpmailer.php.

Vou postar um exemplo simples, com comentário nas principais instruções. Usarei o SMTP do GMail, mas pode ser usado qualquer outro SMTP. Notem que o GMail usa SSL e porta diferente da padrão do SMTP (25).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

require 'phpmailer/class.phpmailer.php';
 
$PHPMailer = new PHPMailer();
 
// define que será usado SMTP
$PHPMailer->IsSMTP();
 
// envia email HTML
$PHPMailer->isHTML( true );
 
// codificação UTF-8, a codificação mais usada recentemente
$PHPMailer->Charset = 'UTF-8';
 
// Configurações do SMTP
$PHPMailer->SMTPAuth = true;
$PHPMailer->SMTPSecure = 'ssl';
$PHPMailer->Host = 'smtp.gmail.com';
$PHPMailer->Port = 465;
$PHPMailer->Username = 'seu_login';
$PHPMailer->Password = 'sua_senha';
 
// E-Mail do remetente (deve ser o mesmo de quem fez a autenticação
// nesse caso seu_login@gmail.com)
$PHPMailer->From = 'seu_login@gmail.com';
 
// Nome do rementente
$PHPMailer->FromName = 'Seu Nome';
 
// assunto da mensagem
$PHPMailer->Subject = 'Teste';
 
// corpo da mensagem
$PHPMailer->Body = '<p>Mensagem em HTML</p>';
 
// corpo da mensagem em modo texto
$PHPMailer->AltBody = 'Mensagem em texto';
 
// adiciona destinatário (pode ser chamado inúmeras vezes)
$PHPMailer->AddAddress( 'meu_amigo@dominio.com' );
 
// adiciona um anexo
$PHPMailer->AddAttachment( 'arquivo.pdf' );
 
// verifica se enviou corretamente
if ( $PHPMailer->Send() )
{
	echo "Enviado com sucesso";
}
else
{
	echo 'Erro do PHPMailer: ' . $PHPMailer->ErrorInfo;
}

É muito fácil mexer com o PHPMailer. Até anexar um arquivo é simples! :)

Site oficial do PHPMailer
Propriedades da classe PHPMailer
Métodos da classe PHPMailer

A solução é usar fgets, que limita o buffer de leitura.

Como a própria manpage da função gets informa, é preferível o uso de fgets. Leia o trecho presente na manpage de gets:

BUGS

Never use gets(). Because it is impossible to tell without knowing the data
in advance how many characters gets() will read, and because gets() will
continue to store characters past the end of the buffer, it is extremely
dangerous to use. It has been used to break computer security. Use fgets()
instead.

Vejamos um simples exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
 
#define STRSIZE 10
 
int main()
{
	char str[ STRSIZE ];
 
	gets( str );
	printf( "%s\n", str );
 
	return 0;
}

A própria compilação com o GCC já alerta sobre o problema de gets:

$ gcc teste.c
/tmp/ccCUw08x.o: In function `main':
teste.c:(.text+0x1f): warning: the `gets' function is dangerous and should not be used.

Dependendo da posição da memória em que o programa for executado, pode ocorrer o seguinte problema durante sua execução:

$ ./a.out
oi eu sou o beraldo
oi eu sou o beraldo
*** stack smashing detected ***: ./a.out terminated
======= Backtrace: =========
/lib/libc.so.6(__fortify_fail+0x37)[0x7f8b96f57537]
/lib/libc.so.6(__fortify_fail+0x0)[0x7f8b96f57500]
./a.out[0x4005fc]
/lib/libc.so.6(__libc_start_main+0xfe)[0x7f8b96e76d8e]
./a.out[0x4004f9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:03 403972                             /tmp/a.out
00600000-00601000 r--p 00000000 08:03 403972                             /tmp/a.out
00601000-00602000 rw-p 00001000 08:03 403972                             /tmp/a.out
00ca3000-00cc4000 rw-p 00000000 00:00 0                                  [heap]
7f8b96c42000-7f8b96c57000 r-xp 00000000 08:03 524368                     /lib/libgcc_s.so.1
7f8b96c57000-7f8b96e56000 ---p 00015000 08:03 524368                     /lib/libgcc_s.so.1
7f8b96e56000-7f8b96e57000 r--p 00014000 08:03 524368                     /lib/libgcc_s.so.1
7f8b96e57000-7f8b96e58000 rw-p 00015000 08:03 524368                     /lib/libgcc_s.so.1
7f8b96e58000-7f8b96fd2000 r-xp 00000000 08:03 546662                     /lib/libc-2.12.1.so
7f8b96fd2000-7f8b971d1000 ---p 0017a000 08:03 546662                     /lib/libc-2.12.1.so
7f8b971d1000-7f8b971d5000 r--p 00179000 08:03 546662                     /lib/libc-2.12.1.so
7f8b971d5000-7f8b971d6000 rw-p 0017d000 08:03 546662                     /lib/libc-2.12.1.so
7f8b971d6000-7f8b971db000 rw-p 00000000 00:00 0
7f8b971db000-7f8b971fb000 r-xp 00000000 08:03 526899                     /lib/ld-2.12.1.so
7f8b973d4000-7f8b973d7000 rw-p 00000000 00:00 0
7f8b973f7000-7f8b973fb000 rw-p 00000000 00:00 0
7f8b973fb000-7f8b973fc000 r--p 00020000 08:03 526899                     /lib/ld-2.12.1.so
7f8b973fc000-7f8b973fd000 rw-p 00021000 08:03 526899                     /lib/ld-2.12.1.so
7f8b973fd000-7f8b973fe000 rw-p 00000000 00:00 0
7fff0445e000-7fff0447f000 rw-p 00000000 00:00 0                          [stack]
7fff0454c000-7fff0454d000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Abortado

Isso nem sempre ocorre. Depende dos limites de memória alocados para a execução do programa.

Teoricamente, na string só deveria conter “oi eu sou “, que são os dez primeiros caracteres da string lida. Assim, os demais caracteres ficam além dessa última posição de memória, que pode estar em uso por outra aplicação, gerando o erro. Pior que isso, se for injetado um código malicioso, a outra aplicação poderá executá-lo. Essa é uma forma de “vírus”.

A solução é usar fgets, lendo de stdin, que é o arquivo que representa a entrada padrão:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
 
#define STRSIZE 10
 
int main()
{
	char str[ STRSIZE ];
 
	fgets( str, STRSIZE, stdin );
 
	printf( "%s\n", str );
 
	return 0;
}

Compilação e execução:

$ gcc teste.c
$ ./a.out
oi eu sou o beraldo
oi eu sou

O resultado foi o esperado.

Portanto, excluam gets de suas vidas. =)

Face a isso, muitos têm dúvidas em como converter do formato brasileiro para o ISO e vice-versa. É possível fazer isso de várias formas, mas pretendo mostrar aqui as principais delas, comparando o tempo de execução de cada uma, a fim de encontrar a mais eficiente.

Vamos a quatro exemplos.

O primeiro exemplo usa arrays, com as funções implode, explode, e array_reverse. É talvez o mais usado. Pelo menos é o que mais aparece por aí.

date1.php

$time = microtime( true );
 
$date = '2011-01-15';
echo implode( '/', array_reverse( explode( '-', $date ) ) ) . "\n";
 
var_dump( microtime( true ) - $time );

O segundo exemplo usa ER’s, utilizando a função preg_replace:

date2.php

$time = microtime( true );
 
$date = '2011-01-15';
echo preg_replace( '/([0-9]+)-([0-9]+)-([0-9]+)/', '$3/$2/$1', $date ) . "\n";
 
var_dump( microtime( true ) - $time );

O exemplo 3 usa printf e scanf (e semelhantes), sem usar variáveis auxiliares, ou seja, fazendo sscanf retornar um array, que é lido por vprintf.

date3.php

$time = microtime( true );
 
$date = '2011-01-15';
vprintf( "%d/%d/%d\n", array_reverse( sscanf( $date, "%d-%d-%d" ) ) );
 
var_dump( microtime( true ) - $time );

O exemplo 4 usa, novamente, printf e scanf (e semelhantes), mas usa variáveis auxiliares, para evitar o uso de array, da forma como é normalmente usada em linguagens como C e C++.

date4.php

$time = microtime( true );
 
$date = '2011-01-15';
 
sscanf( $date, "%d-%d-%d", $y, $m, $d );
printf( "%d/%d/%d\n", $d, $m, $y );
 
var_dump( microtime( true ) - $time );

Vamos executar os quatro scripts e analisar as saídas deles. Note que aparecerão a data convertida e o tempo de execução de cada um deles. Perceba que o tempo é um float em notação científica.

Saída:

date1.php
15/01/2011
float(4.4107437133789E-5)

date2.php
15/01/2011
float(0.0001068115234375)

date3.php
15/01/2011
float(5.1021575927734E-5)

date4.php
15/01/2011
float(3.9815902709961E-5)

Aparentemente, o date2.php foi mais rápido, mas, novamente, note a notação científica. Todos os demais estão multiplicados por 10^-5, enquanto o date2.php não está. Logo, ele é o mais lento, não o mais rápido. O mais rápido no teste acima foi o date4.php.

Ou seja, a melhor função para converter datas seria esta:

function converteData( $data )
{
        if ( ! strstr( $data, '/' ) )
        {
                // $data está no formato ISO (yyyy-mm-dd) e deve ser convertida
                // para dd/mm/yyyy
                sscanf( $data, '%d-%d-%d', $y, $m, $d );
                return sprintf( '%d/%d/%d', $d, $m, $y );
        }
        else
        {
                // $data está no formato brasileiro e deve ser convertida para ISO
                sscanf( $data, '%d/%d/%d', $d, $m, $y );
                return sprintf( '%d-%d-%d', $y, $m, $d );
        }
 
        return false;
}

O tempo de execução pode variar de máquina para máquina. Testei em um AMD Phenon X4 9550. Em alguns outros testes, date1.php ficou muito perto de date4.php, às vezes sendo até mais rápido. Porém na maioria das vezes o date4.php foi mais rápido.

Em Ciência da Computação, no contexto de armazenamento e transmissão de dados,
a serialização é o processo de salvar um objeto em um meio de armazenamento
(como um arquivo de computador ou um buffer de memória) ou transmiti-lo por uma
conexão de rede, seja em forma binária ou em formato de texto como o XML. Esta
série de bytes pode ser usada para recriar um objeto com o mesmo estado interno
que o original.

Fonte: http://pt.wikipedia.org/wiki/Serializa%C3%A7%C3%A3o

Essa técnica é muito útil quando se deseja salvar dados como arrays ou objetos em arquivos, cookies, sessões ou transmiti-los via sockets, por exemplo.

Vou dar um exemplo básico de serialização usando PHP e outro usando Python.

PHP

O PHP possui as funções serialize e unserialize, que funcionam de forma muito simples. Um exemplo prático é suficiente para compreender.

$arr = array( 'dado 1', 'dado 2' );
var_dump( $arr );
$serArr = serialize( $arr );
var_dump( $serArr );
$unSerArr = unserialize( $serArr );
var_dump( $unSerArr );

Saída:

array(2) {
  [0]=>
  string(6) "dado 1"
  [1]=>
  string(6) "dado 2"
}
string(40) "a:2:{i:0;s:6:"dado 1";i:1;s:6:"dado 2";}"
array(2) {
  [0]=>
  string(6) "dado 1"
  [1]=>
  string(6) "dado 2"
}

Veja que inicialmente o dado é um array. Após a serialização, vira uma string, que pode ser salva em arquivo, cookie, sessão ou transmitida byte a byte via socket. Após ser desserializada, volta a ser um array, da mesma forma como era antes.

Isso vale para qualquer tipo de dado: arrays, objetos, arrays de objetos, objetos com outros objetis intanciados…

Python

O Python possui o módulo pickle, que permite salvar a serialização direto num arquivo ou atribuí-la a uma variável. O mesmo vale para a desserialização: pode desserializar um dado direto de um arquivo ou a partir de dados de uma variável.

Vou mostrar um exemplo semelhante ao anterior, usando apenas variáveis:

#!/usr/bin/env python
 
import pickle;
 
arr = [ 'dado 1', 'dado 2' ];
print arr;
serArr = pickle.dumps( arr );
print serArr;
unSerArr = pickle.loads( serArr );
print unSerArr;

Saída:

['dado 1', 'dado 2']
(lp0
S'dado 1'
p1
aS'dado 2'
p2
a.
['dado 1', 'dado 2']

Novamente, iniciamos com um array (lista para os mais íntimos ao Python :P ), passando a uma string representando a lista serializada. Ao fim, temos a lista original.

Para usar arquivos, basta usar dump e load, em vez de dumps e loads. Mais exemplos podem ser vistos na documentação do módulo pickle.

Caso não tenha visto a primeira parte do artigo, leia-a aqui:
Segurança em SIstemas de Login: Senhas e Cookies

Sumário

1. Introdução
2. Magic Quotes
3. Soluções Especificas para cada SGBD
3.1. MySQL
3.2. PostgreSQL
3.3. Exemplos de códigos para MySQL e PostgreSQL
4. Apenas Isso Não Basta
5. Conclusão

1. Introdução

Neste segundo artigo sobre segurança em sistemas de login, abordarei formas de proteção contra SQL Injection.

Existem muitas discussões na Internet, em listas de discussão e fóruns, sobre qual seria a função perfeita para impedir ataque por SQL Injection SQL Injection. Alguns programadores até criam funções que removem, por segurança, palavras-chave da linguagem SQL, como SELECT, DROP, DELETE. Isso pode até resolver, mas não podemos danificar a informação; se permitirmos que o usuário escreva informações em nosso site, devemos permitir-lhe escrever
SELECT, DROP e DELETE também. Imagine, por exemplo, um fórum sobre programação: como poderíamos postar códigos SQL se o fórum removesse as palavras SELECT, DELETE etc? Logo, não podemos remover essas palavras.

A soluçãoo é muito simples! Sim, é simples, mesmo. Muitos querem complicar à toa, porém é muito simples: escapar caracteres especiais.

Esses caracteres especiais podem variar conforme o SGBD que se está utilizando. Normalmente são aspas simples e duplas, as quais delimitam strings em um comando SQL.

Vamos a um exemplo. Considere a SQL abaixo:

$sql = "SELECT id, nome, sobrenome FROM autores WHERE nome = '" . $nome . "'
		AND sobrenome = '" . $sobrenome . "'";

Supondo que $nome contenha jo’sé, e $sobrenome, silva, a SQL ficará assim:

SELECT id, nome, sobrenome FROM autores WHERE nome = 'jo'se' AND sobrenome = 'silva';

Isso gera um erro de sintaxe, sem comprometer o banco de dados. Porém, se mantivermos $sobrenome e definirmos $nome com o valor jo’; DROP TABLE autores ; –, teremos:

SELECT id, nome, sobrenome FROM autores WHERE nome = 'jo'; DROP TABLE autores ;
--'AND sobrenome = 'silva';

Dessa forma, selecionam-se os registros com nome igual a “jo”, remove-se a tabela “autores” e considera-se ‘ AND sobrenome = ‘silva’; como comentário. Isso caracteriza um ataque por SQL Injection.

2. Magic Quotes

Face aos possíveis grandes danos que SQL Injection pode causar, o PHP possui um mecanismo nativo automático para escapar caracteres especiais: o magic quotes. Porém, esse é um mecanismo genérico, que não pode ser aplicado a todos os SGBDs. Logo, não o utilize!

O próprio Manual do PHP não recomenda seu uso:

There is no reason to use magic quotes because they are no longer a supported
part of PHP. However, they did exist and did help a few beginners blissfully
and unknowingly write better (more secure) code. But, when dealing with code
that relies upon this behavior it's better to update the code instead of
turning magic quotes on. So why did this feature exist? Simple, to help prevent
SQL Injection. Today developers are better aware of security and end up using
database specific escaping mechanisms and/or prepared statements instead of
relying upon features like magical quotes.

Fonte: http://br3.php.net/manual/en/security.magicquotes.why.php

Como citado no trecho, é preferível adaptar seus códigos a fim de torná-los seguros e não vulneráveis a SQL Injection a habilitar o magic quotes. Portanto mantenha a diretiva magic_quotes_gpc, do , em off! Dê preferência a funções específicas para cada SGBD.

Leia o capítulo sobre Magic Quotes, do }Manual do PHP, no link abaixo:
http://br3.php.net/manual/en/security.magicquotes.php

3. Soluções Especificas para cada SGBD

3.1. MySQL

Vamos ao exemplo mais comum: MySQL: existe uma função específica do PHP para escapar caracteres especiais do MySQL: mysql_real_escape_string.

Ela deve ser usada com magic_quotes_gpc em off. Caso seu servidor mantenha essa diretiva ativa, desabilite-a por meio de htaccess ou, caso isso não seja possível, certifique-se de usar stripslashes antes de aplicar essa função. Veja o exemplo abaixo:

if ( get_magic_quotes_gpc() )
{
    $name = stripslashes( $name );
}
$name = mysql_real_escape_string( $name );
mysql_query( "SELECT * FROM users WHERE name=$name" );

Esse trecho de código e outras dicas sobre prevenção de SQL Injection com MySQL podem ser vistas no link abaixo, do próprio Manual do MySQL:
http://dev.mysql.com/tech-resources/articles/guide-to-php-security.html

3.2. PostgreSQL

O escape de caracteres no PostgreSQL não é feito com barra invertida; é feito com aspas simples. Ou seja, addslashes não funcionaria aqui.

O PHP também tem uma função específica para escape de caracteres especiais para PostgreSQL: pg_escape_string.

Mais informações sobre prevenção de SQL Injection em PostgreSQL podem ser vistas no link abaixo, do Wiki do PostgreSQL:
http://wiki.postgresql.org/wiki/Sql_injection

3.3. Exemplos de códigos para MySQL e PostgreSQL

mysql_connect( 'localhost', 'usuario', 'senha' );
$str = "There's no place like 127.0.0.1, the \"localhost\"";
echo "String:	" . $str . "<br />";
echo "MySQL:	" . mysql_real_escape_string( $str ) . "<br />";
echo "Postgre:	" . pg_escape_string( $str ) . "<br />";

* Para usar mysql\_real\_escape\_string, é necessário uma conexão MySQL ativa.\\

Saída:

String:	There's no place like 127.0.0.1, the "localhost"
MySQL:	There\'s no place like 127.0.0.1, the \"localhost\"
Postgre:	There''s no place like 127.0.0.1, the "localhost"

4. Apenas Isso Não Basta

Apenas escapar caracteres não é suficiente, uma vez que não existem apenas strings. Também temos dados numéricos, como inteiros, floats e outros tipos de ponto flutuante, que não são envolvidos por aspas em consultas SQL.

Considere a seguinte SQL:

$sql = "SELECT id, nome, sobrenome FROM autores WHERE id=" . $id;

Se $id tiver o valor 0; DROP TABLE autores; –, a SQL final será:

SELECT id, nome, sobrenome FROM autores WHERE id=0; DROP TABLE autores; --;

Isso removeria a tabela “autores”.

A solução é, novamente, muito simples: basta fazer casting, ou coerção, convertendo o parâmetro para um tipo numérico.

No exemplo acima, bastaria isto:

$id = (int) $id;

O mesmo vale para float, double e os demais tipos de dados.

5. Conclusão

SQL Injection é um problema muito grave, que muitos programadores iniciantes deixam passar despercebido, principalmente por falta de conhecimento.

Apesar disso, sua prevenção é muito simples. Basta entender o funcionamento do ataque para saber como se defender dele.

Abraços,

Beraldo

Na verdade, “criptografia” não é a palavra correta aqui. Na verdade usaremos hashes, que é uma forma de codificação unidirecional, ou seja, não há como, a partir de um hash, obter o dado original. Afinal, não temos para que saber a senha do usuário. Criptografia é uma forma de codificação usando chaves, de forma que é possível obter o dado original, desde que tenha-se a chave com a qual o dado foi codificado.

Sumário

Codificando senhas para salvá-las no banco de dados
Usando Salt Number
Salvando a senha em cookie de forma segura
Conclusão

Codificando senhas para salvá-las no banco de dados

Nos exemplos aqui mostrados usarei a linguagem PHP, mas os conceitos podem ser usados com qualquer linguagem de programação.

Por incrível que possa parecer, há muitas pessoas que salvam senhas puras no banco de dados, sem qualquer tipo de criptografia! Isso é um crime! Se alguém tiver acesso ao banco de dados, todos os usuários do sistemas estarão em risco. As senhas devem ser salvas criptografadas ou, como no nosso caso, em hashes.

Normalmente usa-se o MD5, que gera uma saída de 32 caracteres. Porém, toda segurança é pouca. Temos o SHA-1, que gera uma saída de 40 caracteres. A fim de evitar colisões, devemos dar preferência ao SHA-1, uma vez que ele gera mais possibilidades de saídas.

Mas também podemos unir as duas! Uma possibilidade é esta:

function hashPasswd( $passwd )
{
	return sha1( md5( $passwd ) );
}

A função codifica com MD5 e depois codifica o resultado do MD5 com SHA-1. É uma segurança a mais, já que uma dicionário de senhas codificadas em SHA-1 provavelmente não contém hashes MD5 de senhas para serem testados.

Para ficar ainda mais seguro, você pode usar uma “chave” – não exatamente com o significado de uma chave de criptografia. Na verdade é uma string que concatenamos com a senha, a fim de gerar uma senha mais complexa:

define( 'HASH_KEY', md5( 'chave secreta' ) );
 
function hashPasswdWithKey( $passwd )
{
	return sha1( md5( $passwd . HASH_KEY ) );
}

HASH_KEY é uma constante com o hash MD5 de uma string. Prefira usar uma string relativamente complexa, com números e caracteres maiúsculos e minúsculos no lugar de “chave secreta”.

O hash retornado é o valor que deve ser salvo no banco de dados.

Quando o usuário efetuar login, com nome de usuário e senha, basta pegarmos a senha informada, codificá-la com a nossa função e compará-la com o valor salvo no banco de dados.

Usando Salt Number

O uso de Salt Number dificulta a realização de ataques por brute force, uma vez que aumenta exponencialmente as possibilidades de hash para uma mesma palavra.

Os links abaixo explicam detalhadamente como funcionam os salt numbers:
http://www.vivaolinux.com.br/artigo/Armazenamento-de-senhas-no-Linux/?pagina=7
http://gravatai.ulbra.tche.br/~elgio/senhas.html

O Salt Numbeer é semelhante à HASH_KEY, que criamos anteriormente. Porém, em vez de usarmos uma constante, criamos um código aleatório para cada usuário. Esse valor fica salvo no banco de dados e é concatenado à senha do usuário, da mesma forma que fizemos com a constante HASH_KEY.

Uma possível forma de gerar códigos aleatórios para o Salt Number em PHP é esta:

// Número de caracteres do Salt Number
define( 'SALT_SIZE', 15 );
 
// Array com os 62 caracteres (a-z, A-Z, 0-9)
$amostra = array_merge( range( 'a', 'z' ), range( 'A', 'Z' ), range( 0, 9 ) );
 
// Embaralha o array
shuffle( $amostra );
 
$index = array_rand( $amostra, SALT_SIZE );
 
$salt = '';
for ( $i = 0; $i < SALT_SIZE; $i++ )
{
	$salt .= $amostra[ $i ];
}

Assim, $salt contém o salt number gerado, para que seja usado na autenticação de um novo usuário recém-cadastrado.

Salvando a senha em cookie de forma segura

A fim de permitirmos o login automático, muito comum em fóruns e lojas virtuais, precisamos usar cookies. Neles devem estar salvos os dados do usuário para autenticação no sistema.

Porém, não podemos colocar a senha do usuário no cookie. Mesmo que seja o hash da senha, pois fornecer acesso à hash salva no banco de dados é uma falha de segurança, já que ter um hash em mãos torna muito mais fácil um ataque por brute force. Por isso, vamos criar outro hash, baseado no hash da senha e no horário em que o usuário fez o último login.

define( 'HASH_KEY', md5( 'chave secreta' ) );
define( 'HASH_PATTERN', HASH_KEY . '%d' . '%s' );
 
function hashForCookie( $str )
{
	$strHash = sprintf( HASH_PATTERN, time(), $str );
	return sha1( $strHash );
}

Novamente temos a HASH_KEY, utilizada anteriormente. Criamos outra constante, a HASH_PATTERN, que é o padrão que será usado no hash. Aqui uso a chave (HASH_KEY), à qual são concatenados um “%d” e um “%s”, que serão substituídos pelo timestamp corrente e pelo hash da senha, respectivamente, usando sprintf(). A função retorna o SHA-1 da string final.

Essa função deve ser usada quando o usuário efetuar login. Assim que ele logar, salve no banco de dados (num campo diferente do da senha, claro) o hash gerado por hashForCookie. Esse é o dado que deverá ser salvo no cookie, além do nome do usuário, evitando salvar o hash da senha na máquina no usuário.

Para autenticar, verifique se o hash lido do cookie é o mesmo do salvo no banco de dados. Se for, autenticado, senão remova o cookie e solicite nome de usuário e senha. Assim que fizer login, gere o novo hash para o cookie, salvando-o no cookie, como citado anteriormente.

Uma forma simples de salvar esses dados num cookie usando PHP:

$user = 'Beraldo';
$hash = '2f9a922f0401476cd7089c235d76de5bb61150b9'; 
$dados = array( 'user' => $user, 'passwd' => $hash );
setcookie( 'nome_do_cookie', serialize( $dados ), time() + 86400 );

A função serialize serializa um objeto, retornando uma representação em string do mesmo. O caminho oposto pode ser feito com unserialize:

$cookie = $_COOKIE['nome_do_cookie'];
$dados = unserialize( $cookie );

Assim, $dados é o array que definimos no código anterior.

Conclusão

Essas não são soluções finais para os dois casos apresentados. São apenas sugestões. É possível criar suas próprias funções, próprias criptografias etc.

O importante é procurar formas seguras de desenvolver sistemas.

Abraços,

Beraldo

Realmente a linguagem é excelente. Passei alguns scripts de PHP para Python e notei um desempenho bem melhor. Foi muito fácil e rápido aprender a linguagem. Apenas um dia de estudo já é suficiente para aprender o essencial, desde que já haja conhecimentos sobre programação, claro.

Encontrei alguns problemas com threads e a interrupção delas, com CTRL+C (SIGINT), mas isso não vem ao caso. =P

Gostaria de deixar aqui alguns links que me foram muito úteis para aprender Python. Espero que sejam úteis para quem quiser aprender a linguagem.

Aprenda Python em 10 minutos (em inglês):
http://www.korokithakis.net/tutorials/python

Livro Dive Into Python (em inglês):
http://diveintopython.org/

Tutorial do site oficial (em inglês):
http://docs.python.org/tutorial/

Diversos links sobre Python no site brasileiro sobre a linuagem:
http://www.python.org.br/wiki/DocumentacaoPython

Divirtam-se! =)

Veja um exemplo, retirado do site oficial:

<?php
require 'pdml.php';
?>
<pdml>
<body>
<font face="Arial" size="16pt">Hello, World</font>
</body>
</pdml>

A geração da saída pode ser vista no link abaixo:
http://www.pdml-pdf.net/demo/index.php?page=create&example=1

Na documentação oficial há todas as tags que podem ser usadas.

Divirtam-se! =)

Site Oficial do PDML

Neste artigo, vou mostrar algumas das utilidades dessa classe. Eu nunca a usei antes, estou aprendendo-a agora, enquanto monto o post. Logo, contribuições serão muito bem-vindas.

Vamos iniciar mostrando como funciona o construtor da classe.

Índice:
1. Construtor da classe
2. Formatando datas
3. Adicionando períodos a datas
4. Subtraindo períodos de uma data
5. Calculando diferença entre datas
6. Modificando a data e a hora do objeto

1. Construtor da classe

Sintaxe do construtor:

DateTime::__construct ([ string $time = "now" [, DateTimeZone $timezone = NULL ]] )

Esse método aceita dois parâmetros, ambos opcionais. O primeiro é a data/hora, no mesmo formato aceito pela função strftime(). O segundo consiste no timezone que deve ser utilizado. Ele deve ser uma instância da classe DateTimeZone. Outra maneira de definir o timezone é por meio da função date_default_timezone_set().

Ambas as classes DateTime e DateTimeZone disparam uma exceção se seus construtores receberem parâmetro inválidos. Logo, podemos usar blocos try/catch para instanciar essas classes.

try
{
	$DateTime = new DateTime( 'now', new DateTimeZone( 'America/Sao_Paulo') );
}
catch( Exception $e )
{
	echo 'Erro ao instanciar objeto.<br />';
	echo $e->getMessage();
	exit();
}

Experimente trocar o “now” por um valor não aceito pelo método, como uma string qualquer. Uma exceção será disparada.

2. Formatando datas

Para formatar datas, usamos o método format, que aceita um parâmetro, correspondente a uma formatação de data aceita pela função date().

$DateTime = new DateTime();
 
echo $DateTime->format( "d/m/Y H:i:s" ) . '<br />';
echo $DateTime->format( "Y-m-d H:i:s" ) . '<br />';
echo $DateTime->format( "Y/m/d H:i:s" ) . '<br />';

3. Adicionando períodos a datas

Com o método add(), podemos adicionar períodos à data salva no objeto DateTime. É possível adicionar períodos de dias, períodos de tempo ou ambos, seguindo a formatação aceita pelo método, que recebe um único parâmetro, o qual é uma instância da classe DateInterval, responsável por manipular os dados do período especificado.

Os períodos são especificados da seguinte maneira: períodos de dias são precedidos pela letra “P”, seguidas de inteiros e seus respectivos identificadores de tempo (“D” para dias, “M” para meses e “Y” para anos). Períodos de tempo são precedidos pela letra “T” e seguidos de inteiros e seus respectivos identificadores de unidade (“H” para horas, “M” para minutos e “S” para segundos).

$DateTime = new DateTime();
 
$DateTime->add( new DateInterval( "P30D" ) ); // adiciona 30 dias
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->add( new DateInterval( "P2M" ) ); // adiciona 2 meses
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->add( new DateInterval( "P5Y" ) ); // adiciona 5 anos
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->add( new DateInterval( "P5Y2M30D" ) ); // adiciona 30 dias, 2 meses e 5 anos
echo $DateTime->format( "d/m/Y" ) . '<br />';

Note que cada adição é feita com base na adição anterior, uma vez que cada soma modifica a data armazenada no objeto.

4. Subtraindo períodos de uma data

O método sub funciona da mesma forma que o add, com a mesma lista de parâmetros, mas, logicamente, em vez de adicionar períodos, ele os subtrai.

$DateTime = new DateTime();
 
$DateTime->sub( new DateInterval( "P30D" ) ); // subtrai 30 dias
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->sub( new DateInterval( "P2M" ) ); // subtrai 2 meses
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->sub( new DateInterval( "P5Y" ) ); // subtrai 5 anos
echo $DateTime->format( "d/m/Y" ) . '<br />';
 
$DateTime->sub( new DateInterval( "P5Y2M30D" ) ); // subtrai 30 dias, 2 meses e 5 anos
echo $DateTime->format( "d/m/Y" ) . '<br />';

5. Calculando diferença entre datas

Usando o método diff, podemos calcular o intervalo entre duas datas, com precisão de dias, meses, anos, horas, minutos e segundos. Esse método retorna uma instância da classe DateInterval, já citada anteriormente neste artigo.

$DateTime = new DateTime();
 
$diff = $DateTime->diff( new DateTime( '2009-02-14' ) );
 
echo "Diferença de:<br />
" . $diff->d . " dias<br />
" . $diff->m . " meses<br />
" . $diff->y . " anos<br />
" . $diff->h . " horas<br />
" . $diff->i . " minutos<br />
" . $diff->s . " segundos<br />
";

6. Modificando a data e a hora do objeto

Para modificar a data e a hora armazenadas no objeto, utilizamos os métodos setDate e setTime.

$DateTime = new DateTime();
 
echo $DateTime->format( "d/m/Y H:i" ) . '<br />';
 
$DateTime->setDate( 2007, 07, 07 );
$DateTime->setTime( 07, 27 );
 
echo $DateTime->format( "d/m/Y H:i" ) . '<br />';

Espero que tenha ficado tudo claro para todos. A utilização das classes não é difícil. Mais informações podem ser obtidas na documentação oficial.

Link úteis:
Documentação da classe DateTime
Documentação da classe DateTimeZone
Documentação da classe DateTimeInterval
Funções de data e hora do PHP

Para exemplificar, vou usar um simples array com alguns estados brasileiros e uma variável que armazenará o dado que deve aparecer selecionado.

A exibição do combo, juntamente com o dado selecionado, será realizada por uma função, que percorre o array de dados e compara se o registro corrente é igual ao que deve ser selecionado. Se a comparação retornar TRUE, insere-se o atributo “selected” na tag “option”.

$estados = array( 'PR', 'SP', 'RJ', 'SC', 'RS' );
$padrao = 'PR';
 
echo MontaSelect( $estados, $padrao );
 
 
function MontaSelect( $dados, $selected = NULL )
{
	$str = "<select name=\"uf\" id=\"uf\">\n";
 
	$total= count( $dados );
 
	for ( $i = 0; $i < $total; $i++ )
	{
		$str .= "<option value=\"" . $dados[$i] . "\"" . ( ( $dados[$i] == $selected ) ? " selected=\"true\"" : "" ) . ">" . $dados[$i] . "</option>\n";
	}
 
	$str .= "</select>\n";
 
	return $str;
}

A solução é simples, apesar de ser fonte de dúvida frequente em fóruns pela Internet.

Lembrando que é sempre bom efetuar verificação nos tipos de parâmetros da função. Não inseri isso no código, mas é recomendável usar is_array() para verificar a variável $dados, por exemplo, a fim de evitar geração de erros e warnings.

A melhor codificação a ser usada é a UTF-8, que suporta diversos idiomas, e tem sido adotada como codificação padrão em diversas aplicações.

E importante manter todas as codificações iguais, ou seja, todas em UTF-8. Para um site, é preciso atentar para as seguintes codificações:

Codificação do arquivo propriamente dito

É a codificação do arquivo dentro do sistema operacional. Ela pode ser modificada por meio do seu editor de textos. Por exemplo:

Exemplo de alteração de codificação no editor Gedit

Exemplo de alteração de codificação no editor Eclipse

Codificação do HTML

A codificação do HTML é definida por meio de meta tag ou da função header(), do PHP.

Definição por meio de meta tag:

<meta http-equiv="content-type" content="text/html; charset=utf-8" />

Definição por meio da função header(), do PHP:

1

header( 'Content-Type: text/html; charset=utf-8' );

Codificação do banco de dados e das tabelas

Se a sua aplicação usa um banco de dados, ele precisa, também, estar na codificação usada – UTF-8 no nosso caso. Ela é definida quando se criam o banco de dados e as tabelas. Por exemplo, com MySQL, podemos definir as codificação assim:

Codificação do banco de dados:

CREATE DATABASE bancodedados DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

Codificação das tabelas:

CREATE TABLE tabela(
	id SMALLINT(5) UNSIGNED NOT NULL auto_incre3ment,
	nome VARCHAR(20) NOT NULL,
	sobrenome VARCHAR(50) NOT NULL,
	PRIMARY KEY (id)
) DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

Assim, todos os campos do tipo string estarão na codificação utf8.

Problemas persistentes

Se você usava codificações diferentes, e, depois, modificou apenas a codificação do banco de dados, as acentuações, provavelmente, continuarão erradas. Não basta apenas mudar a codificação, nesse caso; será necessário passar os dados para outra tabela, que esteja, inicialmente, na codificação correta. É possível fazer essa transferência de dados por meio de apenas uma consulta. Para MySQWL, por exemplo, é possível usar um INSERT INTO… SELECT.

Usei um ótimo tutorial para iniciantes e gostaria de compartilhar o link com vocês. O post é constantemente atualizado, conforme saem novas versões do Zend Framework.

Getting Started With Zend Framework

Como o nome diz, é apenas um tutorial para mostrar o funcionamento básico. Mas é o suficiente para desenvolver uma aplicação simples e perder o medo do Zend Framework, que parece complexo logo de cara.

Espero que o link lhes seja útil.

Vamos a um exemplo simples e explicado.

Definimos o caminho à imagem a ser reduzida:

1
2

// imagem a ser reduzida
$foto = 'foto2.jpg';

Definimos as dimensões máximas da imagem

1
2

// dimensões máximas da imagem, em pixels (largura e altura)
$tamMax = array( 200, 240 );

Usando a função getimagesize(), do PHP, obtemos a largura, a altura e o tipo da imagem:

1
2
3
4

// 0 => largura
// 1 => Altura
// 2 => Formato da imagem
list( $imgLarg, $imgAlt, $imgTipo ) = getimagesize( $foto );

Esta parte faz o cálculo das novas dimensões da imagem

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// verifica se a imagem é maior que o máximo permitido
if ( $imgLarg > $tamMax[0] || $imgAlt > $tamMax[1] )
{
	// verifica se a largura é maior que a altura
	if ( $imgLarg > $imgAlt )
	{
		$novaLargura = $tamMax[0];
		$novaAltura = round( ($novaLargura / $imgLarg) * $imgAlt );
	}
	// se a altura for maior que a largura
	elseif ( $imgAlt > $imgLarg )
	{
		$novaAltura = $tamMax[1];
		$novaLargura = round( ($novaAltura / $imgAlt) * $imgLarg );
	}
	// altura == largura
	else
	{
		$novaAltura = $novaLargura = max( $tamMax );
	}
}
else
{
	echo "não é necessário redimensionar";
	exit();
}

Por fim, criamos as imagens, fazemos o redimensionamento e exibimos a imagem desejada no navegador:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// cria a imagem baseada na imagem original
$srcImg = imagecreatefromjpeg( $foto );
 
// cria a nova imagem
$destImg = imagecreatetruecolor( $novaLargura, $novaAltura );
 
// copia para a imagem de destino a imagem original redimensionada
imagecopyresampled( $destImg, $srcImg, 0, 0, 0, 0, $novaLargura, $novaAltura, $imgLarg, $imgAlt );
 
// cabeçalho para exibir a imagem no navegador.
// se for salvar em arquivo, não é necessário
header('content-type: image/jpeg' );
 
// exibe a imagem
imagejpeg( $destImg );
 
// destrói as imagens geradas
imagedestroy( $destImg );
imagedestroy( $srcImg );

Usei funções específicas para jpeg pois, nesse caso, usei uma imagem definida no script. Para criar um script genérico, você pode usar o terceiro elemento do array retornado por getimagesize(), a fim de chamar uma função conforme o tipo da imagem. Isso pode ser feito com o auxílio da função call_user_func.

Post simples. Apenas para sanar uma dúvdia recorrente por aí.
Solução simples. :)

Links úteis:
Referência das funções da biblioteca GD
Documentação da função call_user_func