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

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

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

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

Vamos começar com um simples exemplo, acessando o site do Google e exibindo o conteúdo obtido.

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

// página que desejamos acessar
$pagina = 'http://www.google.com.br';
 
// iniciamos uma instância do cURL
$ch = curl_init();
 
// definimos a URL a ser acessada
curl_setopt( $ch, CURLOPT_URL, $pagina );
 
// executamos a ação
curl_exec( $ch );
 
// encerramos a instância do cURL
curl_close( $ch );

Caso queira, em vez de exibir o conteúdo, retorná-lo a uma variável, para um tratamento de string, por exemplo, basta usar a opção RETURNTRANSFER. O código ficará assim:

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

$pagina = 'http://www.google.com.br';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
 
// define que o conteúdo obtido deve ser retornado em vez de exibido
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
 
$retorno = curl_exec( $ch );
 
curl_close( $ch );
 
// trocamos a palavra "Google" por "Beraldo"
echo preg_replace( "/google/i", "Beraldo", $retorno );

Será exibido o conteúdo, porém, com a palavra “Beraldo” substituindo todas as palavras “Google”.

Há diversas opções para usar com a função curl_setopt. Veja a lista completa no link da documentação dessa função.

Por padrão, o cURL não segue redirecionamentos. Por exemplo, se houver um header(“Location: url”);, o redirecionamento não será feito. Para contornar isso, usamos a opção CURLOPT_FOLLOWLOCATION. Usarei o site www.google.com para testar. Experimente retirar esta última opção inserida e veja que a página em português não e exibida.

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

$pagina = 'http://www.google.com';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
 
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
 
// define que deve-se seguir redirecionamentos
curl_setopt( $ch, CURLOPT_FOLLOWLOCATION, true );
 
$retorno = curl_exec( $ch );
 
curl_close( $ch );
 
echo preg_replace( "/google/i", "Beraldo", $retorno );

Os exemplos acima poderiam perfeitamente funcionar com funções de manipulação de arquivos, como file_get_contents. Porém, essas funções não podem executar requisições com método POST. É aí que entra o cURL! :)

A opção CURLOPT_POST define que a requisição será pelo método POST. Para definir os campos da requisição, usaremos CURLOPT_POSTFIELDS. Vamos a um exemplo simples:

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

// campos da requisição POST
$postfields = array(
						'nome' => 'Beraldo',
						'site' => 'www.rberaldo.com.br'
					);
 
// página que receberá a requisição post
$pagina = 'http://localhost/tmp/curl/post.php';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $postfields );
 
curl_exec( $ch );
 
curl_close();

Código do arquivo post.php:

1

print_r( $_POST );

Isso mostrará os campos que definimos no nosso script de cURL.

Podemos usar a opção CURLOPT_HEADER para incluir na saída o cabeçalho da página. Por exemplo:

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

// campos da requisição POST
$postfields = array(
						'nome' => 'Beraldo',
						'site' => 'www.rberaldo.com.br'
					);
 
// página que receberá a requisição post
$pagina = 'http://localhost/tmp/curl/post.php';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $postfields );
 
// define que o cabeçalho deve ser incluso na saída da requisição
curl_setopt( $ch, CURLOPT_HEADER, true );
 
curl_exec( $ch );
 
curl_close();

É possível, inclusive, enviar arquivos por cURL, via POST. Basta incluir mais um campo e inserir o arroba (@) antes do caminho completo do arquivo. Por exemplo:

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

// campos da requisição POST
$postfields = array(
						'nome' => 'Beraldo',
						'site' => 'www.rberaldo.com.br',
						'arquivo' => '@/tmp/imagem.jpg'
					);
 
// página que receberá a requisição post
$pagina = 'http://localhost/tmp/curl/post.php';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $postfields );
curl_setopt( $ch, CURLOPT_HEADER, true );
 
curl_exec( $ch );
 
curl_close( $ch );

Se você inserir um print_r( $_FILES ); no post.php, verá os dados do arquivo enviado. ;)

Unindo as duas últimas opções (POST e HEADER), podemos falar sobre login usando cURL. Sim, é possível, inclusive, fazer login em sites usnado cURL. Afinal, essa biblioteca pode perfeitamente simular um navegador ou um bot de busca.

Primeiro vamos incluir a criação de um cookie no nosso arquivo post.php, deixando-o da seguinte forma:

1
2

setcookie( "test", "valor do cookie de teste", time() + 3600 );
print_r( $_POST );

E o nosso script de cURL passará a receber o valor do cookie que deve ser salvo no navegador.

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

// campos da requisição POST
$postfields = array(
						'nome' => 'Beraldo',
						'site' => 'www.rberaldo.com.br'
					);
 
// página que receberá a requisição post
$pagina = 'http://localhost/tmp/curl/post.php';
 
$ch = curl_init();
 
curl_setopt( $ch, CURLOPT_URL, $pagina );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $postfields );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_HEADER, true );
 
$retorno = curl_exec( $ch );
 
curl_close( $ch );
 
preg_match( "/Set-Cookie:([^\n]+)/i", $retorno, $matches );
$cookie = $matches[1];
echo $cookie;

A variável $cookie conterá o valor do cookie que deve ser salvo no navegador. Para salvar esse cookie, usamos a opção CURLOPT_COOKIE. Tendo esse valor salvo numa variável, basta fazer isto no script que se conecta a uma página que exija esse cookie:

1

curl_setopt( $ch, CURLOPT_COOKIE, $cookie );

Na documentação das funções cURL (especialmente na da função curl_setopt) é possível encontrar muitas outras funcionalidades para a cURL. É possível definir cabeçalhos de navegador, idioma, usar SSL, proxy e muito mais.

Lista de funções da cURL:
http://www.php.net/manual/pt_BR/ref.curl.php

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;