$arr = array('nome' => 'Joãozinho', 'idade' => 7);

E queremos converter para objeto:

$obj = (object) $arr;

Agora $obj é um objeto. Esse método de conversão que usamos se chama Cast, conversão de tipos.

Atalho:

$obj = (object) array('nome' => 'Joãozinho', 'idade' => 7);

Mas este é um objeto simples, é um objeto sem tipo. Não possui métodos porque não faz parte de uma classe.

Para converter os arrays em objetos mais específicos, pertencentes a uma classe vamos precisar mais que o Cast. A conversão de tipos do PHP não suporta outros tipos a não ser:

• (int), (integer) – molde para inteiro
• (bool), (boolean) – converte para booleano
• (float), (double), (real) – converte para número de ponto flutuante
• (string) – converte para string
• (binary) – converte para string binária (PHP 6)
• (array) – converte para array
• (object) – converte para objeto
• (unset) – converte para NULL (PHP 5)

Então não podemos usar:

$obj = (MinhaClasse) array('nome' => 'Joãozinho', 'idade' => 7);

A diversão

Vou colocar primeiro código e depois explicar.

function cast($data, $class_name, $construct=true) {
	$obj = unserialize('O:'. strlen($class_name) .':"'. $class_name .'"'. substr(serialize($data), 1));
	if ($construct && method_exists($obj, '__construct'))
		$obj->__construct();
	return $obj;
}

A função cast recebe três parâmetros:

• $data – o array a ser convertido
• $class_name – o nome da classe que o novo objeto deve assumir
• $constructor – se iniciamos o objeto da maneira tradicional executando o contrutor

O processo da função é:

1. Serializar o array
2. Enganar a string serializada substituindo o que indica que é um array pelo nome da classe
3. Fazer o processo inverso convertendo a string serializada de volta em um valor PHP
4. Verificar se é para executar o método construtor e se ele existe, então executar
5. Retornar objeto

Quando serializamos algo estamos criando uma representação que pode ser armazenada. Para poder ser armazenada precisa necessariamente ser uma string. Essa string, ou conjunto de caracteres precisa ter indicativos que digam o que ela foi no passado para no futuro quando convertida novamente poder ser a mesma coisa que já foi.

A função cast age na “genética” do objeto, altera suas propriedades dizendo que ele era o que nunca foi.

serialização:
serialize(array('nome' => 'Joãozinho', 'idade' => 7));

resultado:
a:2:{s:4:"nome";s:9:"Joãozinho";s:5:"idade";i:7;}

conversão:
O:11:"MinhaClasse":2:{s:4:"nome";s:9:"Joãozinho";s:5:"idade";i:7;}

O construtor (__constructor) é um método como um outro. A diferença é que quando o objeto é instanciado pela forma convencional o interpretador verifica se esse método existe e então o executa. Mas nada te impede de executar ele denovo, e denovo e denovo.

Quando o construtor é executado o objeto já tem suas propriedades, então se o nosso construtor for:

function __constructor() {
	echo $this->nome;
}

Não duvide que vai aparecer “Joãozinho”.

Antes do CSS era muito complicado e trabalhoso definir e modificar os estilos, como fonte, tamanhos, bordas, cores, etc.

Vejamos dois parágrafos:

<p>texto texto</p>
<p>texto texto</p>

Para definir a fonte Arial e tamanho de mais ou menos 12px nesses dois parágrafos sem CSS precisamos colocar logo no começado de cada parágrafo uma tag <font> com essas propriedades ficando:

<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>

Então se tivermos 10 parágrafos cada um precisa ter a tag <font>!

<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>
<p><font face="Arial" size="3">texto texto</font></p>

É um tremendo gasto de dedo, paciência e tempo ficar inserindo <font> em cada elemento.

Os sites geralmente tem de 6 a milhares de páginas. Vamos pensar em um site com 20 páginas. Em todos os parágrafos dessas 20 páginas definimos a fonte Arial e com o tamanho 3. Imagine que você precise mudar todos esses parágrafos para fonte Verdana. Lá se vai horas disperdiçadas a toa! Isso porque a nossa imaginação limitou-se apenas em mudar o tipo da fonte, mas poderia ser algo mais complicado e maior.

<font face=”" color=”" size=”">

Um outro grande problema é o quanto é limitado interagir na aparência de um site só com esses recursos. É impossível criar esses sites que vemos por ai sem CSS.

Ficar usando todas essas <font> e outras lambanças de HTML tem um peso. Um peso bem pesado para o tráfego de rede do servidor. Acessar um site é como ir no mercado, as compras fazem peso na hora de carregá-las de volta pra casa.

Digamos que cada caractere equivale a 1 byte. Então <font face=”Arial” size=”3″></font> são 35 bytes. Um página com um monte de parágrafos são um monte de 35 bytes a mais. Sites leves são bons para os visitantes e também para os responsáveis. Um site leve carrega mais rápido e quanto menor torna-se mais independente de conexões rápidas. Um site leve ocupa menos espaço, menos espaço gasto com backups, menos tráfego de rede, menos processamento do servidor e por ai vai.

Deus salve o inventor do CSS que nos tornou possível aproveitar melhor os dias e reduziu nosso trabalho. O que eu sempre digo é que o ser humano foi feito pra pensar, criar coisas inteligentes, fazer ferramentas pra facilitar nosso trabalho e não ficar fazendo trabalhos cansativos e repetitivos.

O CSS em sua grandeza nos permite separar o estilo da estrutura. CSS em um lugar, HTML em outro. Não precisamos misturar HTML com estilo, podemos deixar tudo separado. Esqueça de uma vez a tag <font>.

Como o CSS funciona?

O CSS pode ser definido num documento HTML dentro da tag

ou em arquivos separados.

Em geral, a visão do css é:

elemento {
	atributos
}

Exemplo:

alejandro {
	tamanho: 1,81m,
	largura: 90cm,
	peso: 94kg
}

Tudo que estiver entre as chaves são definições de estilo do elemento a esquerda da primeira chave.

Podemos ter vários elementos:

predio {
	andares: 9,
	idade: 40anos
}

carro {
	quilometragem: 0,
	cor: preto,
	rodas: 4
}

Os elementos tem atributos iguais e exclusivos. O color pode estar em parágrafos, links e tabelas, mas por exemplo, o atributo border-spacing é exclusivo para tabelas. Na maioria dos casos um atributo vale para vários elementos. É bem menor o número de atributos específicios.

No exemplo bem acima dos parágrafos, podemos resolver o problema de definição de fonte e tamanho com uma única linha sem “sujar” o HTML.

O parágrafos permanecem “limpos”, não há nenhum tag ou atributo definindo estilo:

<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>
<p>texto texto</p>

O CSS é:

p {
	font:12px Arial;
}

Eu disse em uma única linha porque podemos deixar:

p {font:12px Arial;}

E se tiver que mudar a fonte dos parágrafos mude apenas ali.

p {
	font:12px Verdana;
}

O que demoraria horas fazemos em segundos com CSS.

Não se preocupe em saber todos os atributos do CSS. Saiba apenas como funciona, o resto vem com o tempo e experiencia. Quando tiver que aplicar qualquer estilo e não souber como procure no Google como fazer. Pesquise sempre. E assim aos poucos o seu vocabulário CSS vai ir aumentando.

Faça o teste do exemplo acima:

<html>
<head>
<style type="text/css">
p {
	font:12px Arial;
}
</style>
</head>
<body>
<p>texto texto</p>
<p>texto texto</p>
</body>
</html>

Como eu havia dito e como o próprio nome diz, folhas de estilo em cascata, as regras definidas mais abaixo sobrescrevem as regras mais acima. Se você tiver:

p {
	font:12px Arial;
}

p {
	font:bold 14px Verdana;
}

Os parágrafos serão de fonte Verdana, 14 pixels e em negrito. A segunda regra está mais abaixo e sobrescreve a primeira. Mas não é sobrescrita do bloco e sim das propriedades, então definir o CSS do mesmo elemento várias vezes sem repetir complementa as regras acima.

p {
	font:12px Arial;
}

p {
	color: #00F;
}

p {
	text-decoration: underline;
}

No final teremos parágrafos de fonte Arial com 12 pixels, cor vermelha e com sublinhado. As regras se complementaram.

Hierarquia do CSS

O CSS segue hierarquia, assim como o HTML, afinal ele reflete os elementos HTML.

Pra entendermos isso melhor vamos pensar em duas situações: link sozinhos e links que ficam dentro de parágrafos:

<html>
<body>

<a href="#">Link fora de parágrafo</a>

<p>Link <a href="#">Dentro de parágrafo!</a></p>

</body>
</html>

Ao definir:

a {
	color:#00F;
}

Estamos dizendo que todos os links da página são de cor azul.

E ao definir:

p a {
	background:#EEE;
}

Estamos dizendo que todos os links que estiverem dentro de parágrafos tem fundo cinza claro.

Assim podemos construir CSS estilos com muitos mais delalhes sem dificuldade nenhuma.

No próximo artigo vou falar sobre o atributo class e nas diferentes formas de você incluir CSS nas suas páginas HTML.

function monetary($str) {
	$str = preg_split('#(?:\.|,)(\d{2})$#', $str, -1, PREG_SPLIT_DELIM_CAPTURE);
	return preg_replace('#[^0-9]#', '', $str[0]) . (!empty($str[1]) ? '.' . $str[1] : '');
}

Exemplos:

monetary('10 550,25');
//10550.25

monetary('23.250 469.23');
23250469.23

monetary('23.250.469,23');
23250469.23

monetary('4,75');
4.75

Javascript

function numBB(n, d) {
	for (var i=0, a=9, n = n.toString().split('').reverse(), s = 0; i < n.length; i++, a--)
		s += parseInt(n[i]) * a;

	if ((s %= 11) == 10)
		s = 'x';
	else if (s > 10)
		s = 0;

	return s == d.toString().toLowerCase();
}

PHP

function numBB($n, $d) {
	for ($n = (string) $n, $i=strlen($n), $a=9, $s=0; $i; $i--, $a--)
		$s += $n{$i-1} * $a;
	if (($s %= 11) == 10)
		$s = 'x';
	else if ($s > 10)
		$s = 0;

	return strcasecmp($s, $d) === 0 ? true : false;
}

Regras

Metodologia para cálculo do DÍGITO VERIFICADOR – DV de agência e conta corrente

a) Cada algarismo que compõe o número é multiplicado pelo respectivo multiplicador (peso).

I – Os multiplicadores (pesos) variam de 9 a 2, da direita para a esquerda;

II – O primeiro dígito da direita para a esquerda deverá ser multiplicado por 9, o segundo por 8 e assim

sucessivamente;

b) Os resultados das multiplicacoes são somados;

c) O total da soma é dívido por onze;

I – se o resto for menor que 10 (dez) o DV será igual ao resto;

II – se o resto for igual a 10 /dez/ o DV sera igual a X;

III – se o resto for igual a 0 /zero/ o DV sera igual a 0;

IV – no exemplo acima o digito verificador sera igual a 3;

e) Exemplo:

    0    1    1    2    9    0    0    4    5    9    0
    X    X    X    X    X    X    X    X    X    X    X
    7    8    9    2    3    4    5    6    7    8    9              

    .    .    .    .    .    .    .    .    .    ....00
    .    .    .    .    .    .    .   ..........72
    .    .    .    .    .    .    .  ......35
    .    .    .    .    .    .  ......24
    .    .    .    .    .........00
    .    .    .    .    ....00
    .    .    .   .....27
    .    .   .....04
    .  .....09
    ...08
..00
    Total...................................................179

a) Soma do resultado das multiplicações: 00 + 72 + 35 +8 + 0 = 179

b) Divisão do resultado da soma das multiplicações por 11: 179/11

c) Resto da divisão igual a 3:

d) Dígito Verificador = 3 (três)

Exemplos:

  AGE        CONTA
6510-2     003655-2
6507-2     024601-8
7009-2     022810-9
6746-6     006373-8
6605-2     461462-3
6845-4     100140-X

Referências

• PHP: Descreve possíveis modificadores no padrão regex – Manual. Disponível em: http://br2.php.net/manual/pt_BR/reference.pcre.pattern.modifiers.php

Por que apenas números não são o suficiente? É grande a chance de um usuário adivinhar a senha de outro usuário em um sistema onde as senhas geradas são numéricas de 5 dígitos.

Exemplos:

# números e letras minúsculas e maiúsculas, 10 caracteres
randstr();
//KfRNWnST2X

# números e letras minúsculas e maiúsculas, 20 caracteres
randstr(20);
// uP8HmZVzHlAGwetDMuPu

# números, 5 caracteres
randstr(5, 1);
// 41626

# números e letras minúsculas, 12 caracteres
randstr(12, 2);
// 0dlae5sk70q9

# números, letras minúsculas e maiúsculas e caracteres especias, 10 caracteres
randstr(10, 4);
// D>2)GY1WW@

Código fonte comentado

A função foi implementada em PHP, mas você pode facilmente adaptá-la para outra linguagem.

function randstr($len=10, $level=3) {
	# une os elementos do array formando uma string
	$c = implode(
			# extrai uma parte do array
			array_slice(
				array(
					'1234567890', # level 1
					'abcdefghijklmnopqrstuvwxyz', # level 2
					'ABCDEFGHIJKLMNOPQRSTUVWXYZ', # level 3
					'!@$%*()[]{}<>,-_=+|' # level 3
				), 0, $level));

	# total de caracteres - 1,
	# máximo valor para a escolha aleatória de caracteres
	$l = strlen($c) - 1;

	# armazena os caracteres escolhidos
	$s = '';

	# sorteia caracteres até que o valor de $len seja 0
	for (; $len; $len--, $s .= $c{rand(0, $l)});

	# retorna os caracteres aleatórios
	return $s;
}

Nos caracteres especiais não inclui “?”, “&” e “#” para evitar o risco dos navegador e interpretadores acabarem confundindo esses caracteres com funcionalidades. Na prática, “?” separa o endereço das variáveis, “&” separa as variáveis e “#” indica ponteiros. Se você não for usar os caracteres aleatórios na transição de informações entre o cliente e navegador e quiser utilizá-los, inclua-os no quarto item do array.

Crie ou exclua níveis alterando os elementos do array de caracteres. Um novo elemento é um nível a mais.

Código fonte

/**
 * Gera strings aleatórias
 *
 * @author Alejandro Fernandez Moraga <moraga86@gmail.com>
 * @param int $len Quantidade de caracteres aleatórios
 * @param int $level Nível de dificuldade da string
 * @return string
 */
function randstr($len=10, $level=3) {
	$c = implode(
			array_slice(
				array(
					'1234567890',
					'abcdefghijklmnopqrstuvwxyz',
					'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
					'!@$%*()[]{}<>,-_=+|'
				), 0, $level));

	$l = strlen($c) - 1;
	$s = '';

	for (; $len; $len--, $s .= $c{rand(0, $l)});

	return $s;
}

Objeto é uma instância de uma classe. Classe é uma fábrica de objetos.

Os exemplos que encontramos por ai muitas vezes não fazem muito sentido com o contexto que programamos. Vou focar na web. Onde entraria o objeto ser humano e método correr em um site? Só se disséssemos que correr é o sair (logout) de uma área restrita, que não seria muito legal, mas andar, saltar e dormir continuariam sem fazer sentido. Esses métodos seriam bons para jogos e aplicações gráficas.

Agora, e se convertêssemos o objeto ser humano para usuário, suas propriedades fossem nome, sobrenome, e-mail e senha e métodos nome completo e logout. Faz sentido em um site, não? Se o site for um e-commerce poderíamos adicionar os métodos: adicionar item no carrinho, remover item do carrinho e finalizar compra.

Objetos interagem com outros objetos através de estados (atributos), entradas (parâmetros) e retornos de métodos. No exemplo anterior o objeto usuário adiciona itens em seu carrinho de compras, mas que itens? Objetos do tipo produto e estado tem no estoque.

Herança

Um dos três pilares da programação orientada a objetos é a herança, ou seja, um dia você vai ter que dominar esse conceito e mais dois pra poder dizer que realmente sabe programação orientada a objetos. Os outros dois conceitos, ou pilares são encapsulamento e polimorfismo.

Na herança um objeto herda atributos e métodos de outro objeto. Essa herança deve ser feita com cautela. Para um objeto herdar outro objeto deve haver uma forte relação entre eles. A classe produto, por exemplo, poderia ter os herdeiros CD de áudio, filme DVD e livro. O que esses objetos têm em comum é que todos são produtos, podem ser comprados e adicionados no carrinho, tem preço, peso e dimensões. Cada um desses objetos também tem suas especialidades, senão não justificaria sua existência, apenas um bastaria. O CD de áudio tem faixas, filme tem idiomas de áudio e legenda e duração e livro tem autor, editora e páginas.

Quando um objeto herda outro objeto o herdeiro passa a ter o tipo do objeto herdado. O que isso significa? Imaginemos o método adicionar item no carrinho do objeto usuário. Esse método precisa receber um objeto do tipo produto para então adicionar no carrinho de compras. Um CD de áudio é do tipo CD de áudio, mas a medida que um objeto herda outro objeto e assume o seu tipo, então CD de áudio também é do tipo produto e poderá ser adicionado no carrinho.

Se ainda ficou um pouco confuso, pense em um restaurante que somente aceite pessoas descendentes de sua avó. Sua mãe e você poderão entrar, mas eu não, a menos que sejamos parentes, minha mãe seja irmã de sua mãe ou filha. Isso é o tipo. Objetos herdam e carregam tipos de outros objetos.

E onde entra o produto herdar a classe de banco de dados? Não entra, não há relação nisso! Muitos programadores cometem esse erro por quererem facilitar consultas ou outras operações no banco de dados. Não comenta esse erro. Objetos na vida real herdam objetos quando há uma relação entre eles, faça o mesmo na programação.

is_tel é uma função que usa expressão regular para validar e separar números de telefone, levando em consideração o número, código de cidade/área e código de país. Retorna um array de índices country, city e number com seus valores caso a string de entrada seja validada pela expressão regular ou então retorna falso.

Exemplo:

if ($tel = is_tel('+55 11 1234-5678')) {
	echo 'telefone válido';
	print_r($tel);
}

array
(
	[country] => 55,
	[city] => 11,
	[number] => 1234-5678
)

Com esta função você pode validar campos livres para telefone e depois até mesmo armazenar os dados separadamente.

Bateria de testes

# número
is_tel('1234-5678');
// true - array(number => 1234-5678)

# número de 7 dígitos
is_tel('123-4567');
// true - array(number => 123-4567)

# código de cidade, área
is_tel('11 12345678');
// true - array(city => 11, number => 1234-5678)

# código de país e cidade
is_tel('55 11 1234.5678');
true - array(country => 55, city => 11, number => 1234-5678)

# código de país e cidade com número de 7 dígitos
is_tel('55 11 123-4567');
true - array(country => 55, city => 11, number => 123-4567)

# códigos de país e cidade com mais de 2 dígitos
is_tel('1024 680 1234 5678');
true - array(country => 1024, city => 680, number => 1234-5678)

# outras formatações
is_tel('(+55) (11) 1234-5678');
true - array(country => 55, city => 11, number => 1234-5678)

is_tel('+55 (11) 1234 5678');
true - array(country => 55, city => 11, number => 1234-5678)

# separador diferente de hífen
is_tel('1234-5678', '.');
true - array(number => 1234.5678);

# sem separador
is_tel('1234-5678', '');
true - array(number => 12345678)

# inválidos
is_tel('abcd-1234');
false

is_tel('1234-567a');
false

Código fonte

/**
 * Função para validar números de telefones.
 * Retorna um array com código do país, código da cidade e número de telefone.
 *
 * @author Alejandro Fernandez Moraga <moraga86@gmail.com>
 * @param string $str String de entrada
 * @param string $glue String usada para unir os números do telefone
 * @return array|false
 */

function is_tel($str, $glue='-') {
	return preg_match('#^(?:(?:\(?\+?(?P<country>\d{2,4})\)?\s*)?\(?(?P<city>\d{2,3})\)?\s*)?(?P<n1>\d{3,4})[-\s.]?(?P<n2>\d{4})$#', $str, $matches) ?
		array(
			'country' => $matches['country'],
			'city' => $matches['city'],
			'number' => $matches['n1'] . $glue . $matches['n2']
		)
		: false;
}

Encontrando telefones em strings

Você pode usar a expressão regular da função para buscar números de telefones em strings.

#(?:(?:\(?\+?(?P<country>\d{2,4})\)?\s*)?\(?(?P<city>\d{2,3})\)?\s*)?(?P<n1>\d{3,4})[-\s.]?(?P<n2>\d{4})#

Só não se esqueça de remover que marcam ínicio e término da string, ^ e $.

preg_match_all(
	'#(?:(?:\(?\+?(?P<country>\d{2,4})\)?\s*)?\(?(?P<city>\d{2,3})\)?\s*)?(?P<n1>\d{3,4})[-\s.]?(?P<n2>\d{4})#',
	$string,
	$matches
);

Relatos de tentativas de fraude se mantiveram estáveis no trimestre; phishing aumentou 61% em um ano

O Centro de Estudos, Resposta e Tratamento de Incidentes de Segurança no Brasil (CERT.br), um dos serviços disponibilizados pelo Núcleo de Informação e Coordenação do Ponto BR (NIC.br), divulga as estatísticas de relatos enviados espontaneamente por administradores e usuários envolvendo redes brasileiras no primeiro trimestre de 2010. Segundo o CERT.br, o total de notificações de incidentes no primeiro trimestre de 2010 foi superior a 28 mil, representando um decréscimo de 8% em relação ao trimestre anterior e de 87% em relação ao mesmo período de 2009.

As notificações sobre ataques a servidores Web cresceram 13% em relação ao trimestre anterior e 42% em relação ao mesmo período de 2009. De acordo com Cristine Hoepers, analista de segurança do CERT.br, esses ataques possuem diversas intenções: “eles exploram diversas vulnerabilidades em aplicações Web e estão sendo utilizados para manter repositórios de ferramentas utilizadas em ataques a outros servidores Web e de scripts para envio de spam ou scam, além de visarem a hospedagem de páginas falsas de instituições financeiras e de cavalos de tróia”, afirma.

Relatos de tentativas de fraude foram superiores a 8 mil no primeiro trimestre de 2010, correspondendo a um decréscimo de 6% em relação ao trimestre anterior e a um decréscimo de 95% em relação ao mesmo período de 2009. O maior responsável pela redução em relação ao primeiro trimestre de 2009 foi a redução nas notificações de eventuais quebras de direitos autorais, através de distribuição de material em redes P2P.

O número de notificações de páginas falsas de bancos e sites de comércio eletrônico (phishing tradicional) sofreu um aumento de 9% em relação ao trimestre anterior e foi 61% maior em relação ao mesmo período de 2009. Para mitigar esse tipo de abuso, o NIC.br disponibiliza desde 2008 o Domínio de Primeiro Nível (DPN) “.b.br”, exclusivo para bancos e com DNSSec obrigatório. Relatos sobre cavalos de tróia, utilizados para furtar informações e credenciais, reduziram 9% em relação ao quarto trimestre de 2009, mas foram 12% maiores do que as notificações recebidas no mesmo período de 2009. As notificações referentes a varreduras reduziram 27% em relação ao trimestre anterior e cerca de 10% em relação ao mesmo período de 2009.

Os serviços que podem sofrer ataques de força bruta como SSH (22/TCP), FTP (21/TCP) e TELNET (23/TCP) ainda estão sendo muito visados nas varreduras, correspondendo a, respectivamente, 59%, 3% e 2% das notificações de varreduras.

As notificações de varreduras de SMTP (25/TCP) continuam em destaque atingindo 19% do total. As reclamações em sua maior parte foram referentes a computadores brasileiros, conectados via banda larga, que tentaram identificar relays abertos fora do Brasil, com intuito de posteriormente enviar spam.

Desde 2006, o CGI.br mantém o site: Antispam.br, para a ação e a educação dos internautas e administradores de rede contra o abuso no envio de e-mails não solicitados. Em 2009, foi publicada a resolução “Recomendação para Adoção de Gerência de Porta 25 em Redes de Caráter Residencial”, para a adoção de boas práticas anti-spam para o país.

As notificações de atividades relacionadas com a propagação de worms totalizaram quase 6 mil, correspondendo a um crescimento de 29% em relação ao trimestre anterior e decréscimo de 81% em relação ao mesmo período de 2009.

Ainda no primeiro trimestre de 2010 foram recebidos 1.861 relatos que se enquadraram na categoria “outros”, correspondendo ao acréscimo de 36% em relação ao quarto trimestre de 2009 e de 201% em relação ao mesmo período de 2009. Esta categoria está relacionada à hospedagem de scripts e toolkits, utilizados para comprometimento de sites de terceiros.

Spam

Seguindo o forte aumento de 2009, o primeiro trimestre de 2010 contabilizou mais de 10 milhões de notificações referentes a spam. Em todo o ano de 2009, o CERT.br recebeu 17,2 milhões de notificações dessa categoria, a maior quantidade já registrada.

Estatísticas sobre incidentes de segurança estão disponíveis em: http://www.cert.br/stats/incidentes.

Estatísticas sobre spam estão disponíveis em: http://www.cert.br/stats/spam.

A lista de bancos que possuem domínios “.b.br” está disponível em: http://www.nic.br/atividades/dom-bbr.htm.

Sobre o CERT.br

O CERT.br é o Centro de Estudos, Resposta e Tratamento de Incidentes de Segurança no Brasil. Desde 1997, o grupo é responsável por tratar incidentes de segurança envolvendo redes conectadas à Internet no Brasil. O Centro também desenvolve atividades de análise de tendências, treinamento e conscientização, com o objetivo de aumentar os níveis de segurança e de capacidade de tratamento de incidentes no Brasil.

Mais informações em: http://www.cert.br.

Sobre o Núcleo de Informação e Coordenação (NIC.br)

O Núcleo de Informação e Coordenação do Ponto BR — NIC.br (http://www.nic.br) é uma entidade civil, sem fins lucrativos, que implementa as decisões e projetos do Comitê Gestor da Internet no Brasil. São atividades permanentes do NIC.br coordenar o registro de nomes de domínio — Registro.br (http://www.registro.br), estudar, responder e tratar incidentes de segurança no Brasil – CERT.br (http://www.cert.br), estudar e pesquisar tecnologias de redes e operações — CEPTRO.br (http://www.ceptro.br), produzir indicadores sobre as tecnologias da informação e da comunicação — CETIC.br (http://www.cetic.br) e abrigar o escritório do W3C no Brasil (http://www.w3c.br).

Sobre o Comitê Gestor da Internet no Brasil – CGI.br

O Comitê Gestor da Internet no Brasil coordena e integra todas as iniciativas de serviços Internet no país, promovendo a qualidade técnica, a inovação e a disseminação dos serviços ofertados.

Mais informações em: http://www.cgi.br.

Para mais informações, acesse: http://www.s2.com.br ou http://www.cgi.br.

Fonte: http://www.nic.br/imprensa/releases/2010/rl-2010-07.htm

Se você quer fazer upload de arquivos sem alterar o nome original do arquivo enviado move é uma ótima opção.

Exemplos:

Arquivo

// primeira vez
move('images/bg.jpg', 'images/background/bg.jpg');
// images/background/bg.jpg

// segunda vez, supondo que bg.jpg foi recolocado no diretório images
move('images/bg.jpg', 'images/background/bg.jpg');
// images/background/bg-1.jpg

// terceira vez
move('images/bg.jpg', 'images/background/bg.jpg');
// images/background/bg-2.jpg

Upload

move($_FILES['arquivo']['tmp_name'], 'uploads/'.$_FILES['arquivo']['name']);

Move substitui move_uploaded_file? Sim. Arquivos enviados são armazenados em um diretório temporário definido pelo servidor, como por exemplo no Linux o /tmp por padrão. Mover arquivos de /tmp ou de um outro diretório qualquer é a mesma coisa, sempre que o usuário tenha as permissões necessárias no diretório.

Código fonte

<php

/**
 * Move
 *
 * @author Alejandro Fernandez Moraga <moraga86@gmail.com>
 * @param string $filename Arquivo
 * @param string $destination Destino do arquivo
 * @return string|false
 */

function move($filename, $destination) {
	# separa diretório e nome do arquivo da extensão usando expressão regular
	$name = preg_split('#(?:\.([^\.]+))?$#', $destination, -1, PREG_SPLIT_DELIM_CAPTURE);
	# array com informações do arquivo
	$meta = array($name[0], '', $name[1] ? '.' : '', $name[1]);

	# laço percorre o diretório destino procurando por arquivos com mesmo nome
	# acrescenta um valor incremental entre o nome e extensão do arquivo
	# quando um arquivo de mesmo nome é encontrado
	for ($i=0; file_exists($file = implode($meta)); $meta[1]=--$i);

	# renomeia o arquivo
	# retorna o nome do arquivo movido ou falso
	return rename($filename, $file) ? $file : false;
}

?>