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/

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

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. =)

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! =)

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.

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

Neste post mostrarei como criar alguns BBCodes mais usados, como [b] (negrito), [i] (itálico), [img] (imagem), [url] (link), [youtube] (para vídeos do youtube) e outros.

Basicamente, o que precisamos para montar o sistema de BBCode é usar funções de reposicionamento (replace) de textos, utilizando Expressões Regulares (ER’s), a fim de modificar apenas uma parte da string, sem perder o dado principal contido nela – o conteúdo a ser exibido com formatação.

Vamos começar com exemplos simples.

Negrito e Itálico

1
2
3
4
5
6
7
8
9

// exemplo 1
$str = 'exemplo de texto em [b]negrito[/b] para testar BBCode';
$str = preg_replace( "/\[b\](.*?)\[\/b\]/i", "<strong>$1</strong>", $str );
echo $str;
 
// exemplo 2
$str = 'exemplo de texto em [b]negrito[/b] para testar BBCode';
$str = preg_replace( "/\[(\/)?b\]/i", "<$1strong>", $str );
echo $str;

A vantagem do primeiro exemplo é que, se o usuário esquecer de fechar a tag, por exemplo, o texto não ficará totalmente em negrito. Teste o segundo exemplo com a string abaixo e veja o resultado.

1

$str = 'exemplo de texto em [b]negrito[/b para testar BBCode';

A ER irá casar (match) com “[b]“, inserindo a tag . Porém, não encontrará o fechamento “[/b]“, para inserir a tag . Assim, todo o texto seguinte ficará em negrito.

O BBCode para itálico é praticamente igual. Basta mudar [b] para [i] e para .

1

[img]http://url_da_imagem.jpg[/img]

1
2
3

$str = '[img]http://www.inf.ufpr.br/rbc08/linux_user_id.png[/img]';
$str = preg_replace( "/\[img\](.*?)\[\/img\]/i", "<img src=\"$1\" alt=\"texto_alternativo\" />", $str );
echo $str;

[url=http://url_desejada]Texto que será exibido como link[/url]

1
2
3

$str = '[url=http://www.rberaldo.com.br]Blog do Beraldo[/url]';
$str = preg_replace( "/\[url=(.*?)\](.*?)\[\/url\]/i", "<a href=\"$1\" target=\"blank\">$2</a>", $str );
echo $str;

1
2
3

$str = '[color=red]texto vermelho[/color]';
$str = preg_replace( "/\[color=(.*?)\](.*?)\[\/color\]/i", "<spen style=\"color: $1\">$2</span>", $str );
echo $str;

<object width="425" height="344">
	<param name="movie" value="http://www.youtube.com/v/codigo_do_video"></param>
	<param name="allowFullScreen" value="true"></param>
	<param name="allowscriptaccess" value="always"></param>
	<embed src="http://www.youtube.com/v/codigo_do_video" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed>
</object>

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

// string que será usada no reposicionamento
$replace = "
<object width=\"425\" height=\"344\">
	<param name=\"movie\" value=\"http://www.youtube.com/v/$1\"></param>
	<param name=\"allowFullScreen\" value=\"true\"></param>
	<param name=\"allowscriptaccess\" value=\"always\"></param>
	<embed src=\"http://www.youtube.com/v/$1\" type=\"application/x-shockwave-flash\" allowscriptaccess=\"always\" allowfullscreen=\"true\" width=\"425\" height=\"344\"></embed>
</object>";
 
$str = '[youtube]http://www.youtube.com/watch?v=YaXLlyEm4kQ&feature=rec-HM-r2[/youtube]';
$str = preg_replace( "/\[youtube\].+?watch\?v=([^&]+).*?\[\/youtube\]/i", $replace, $str );
echo $str;