En esta oportunidad les traigo una clase perteneciente al futuro framework PHP CodeFlyer, que nos permitirá autentificar usuarios de manera rápida y segura.

Es una clase que construí hace tiempo y que vengo usando hace varios años, pero la he ajustado para que todo el mundo pueda usarla.

Este artículo se basa en el logueo y autentificación de usuarios y no en la creación o registro de usuarios.

1. Instalando

Primeramente debemos crear la tabla en donde se almacenarán todos los usuarios de nuestro sitio. Para esto basta con ejecutar la siguiente consulta en tu base de datos:

CREATE TABLE `login` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(50) NOT NULL,
  `password` varchar(32) NOT NULL,
  `privilege` int(6) NOT NULL default '0',
  `cookie` binary(32) NOT NULL,
  `session` binary(32) NOT NULL,
  `lastactive` date NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Para usos prácticos podemos crear nuestro usuario desde MySQL:
Usuario: admin
Contraseña: admin

INSERT INTO `login` VALUES (1, 'admin', '21232f297a57a5a743894a0e4a801fc3', 1,'','','');

(El md5 de “admin” es “21232f297a57a5a743894a0e4a801fc3″)

Una vez creada la tabla “login” debes copiar el archivo login.php a tu carpeta de proyectos.

2. Inicializando la clase

El siguiente paso será crear un archivo llamado “config.php” en donde iniciaremos la clase login, y luego incluiremos este config.php en todos nuestros archivos del proyecto. Completa los campos ‘database’, ‘username’ y ‘password’ con los datos de acceso de tu base de datos MySQL:

config.php:

<?PHP
  include('login.php');

  $login = new login(array(
    'database' => 'dbexample',
    'table'    => 'login',
    'username' => 'root',
    'password' => '1234'
  ));
?>

3. Autentificando usuarios

Para loguear a un usuario usamos la función login:

    if($login->login('usuario', 'contraseña'))
    {
       // Welcome!
    }

Entonces de esta manera podemos crear nuestro formulario de inicio de sesión, al que llamaremos index.php

La idea es mostrar el formulario a los usuarios ‘no logueados’, y redirigir hacia “protected.php” a los usuarios correctamente logueados:

index.php:

<?PHP
  include('config.php');

  if ($_POST['submit'])
  {
    if($login->login($_POST['usn'], $_POST['pwd']))
    {
      header('location: protected.php');
    }
    else
    {
      echo "<strong>Login error</strong>";
    }
  }

  if (!$login->logged()) : ?>
    <form method="post">
      <p><label>Username: <input type="text"     name="usn" value="" /></label></p>
      <p><label>Password: <input type="password" name="pwd" value="" /></label></p>
      <p><input type="submit" name="submit" /></p>
    </form>
  <?PHP
  else:
    header('location: protected.php');
  endif;
?>

Entonces ya tenemos una manera para autentificar usuarios, pero ahora debemos proteger aquellas páginas que sólo deben ser vistas por usuarios registrados. Para ello vamos a crear una página protegida llamada “protected.php”:

protected.php:

<?PHP
  include('config.php');
  if (!$login->logged())
  {
    header("location: index.php");
    die();
  }
?>

<strong>Este contenido es privado</strong> <a href="logout.php">Salir de mi cuenta</a>

La función logged() nos devuelve true si el usuario está autentificado, o false si el usuario intenta ingresar con una sesión inválida.

Tán sólo nos falta un archivo más llamado “logout.php” que usaremos para destruir la sesión:

logout.php:

<?PHP
  include('config.php');

  $login->logout();
  header("location: index.php");
?>

4. Resumen de funciones

Entonces a modo de resumen podemos usar las siguientes funciones:

// Creamos la clase, enviando los datos de acceso a la base de datos MySQL:
$login = new login(array(
    'database' => 'dbexample',
    'table'    => 'login',
    'username' => 'root',
    'password' => '1234'
));

// Logueamos al usuario "username" con la contraseña "password"
$login->login("username", "password");

// Opcionalmente se puede utilizar un tercer parámetro bool, para utilizar cookies
// y recordar la visita del usuario, aún después de cerrar el navegador:
$login->login("username", "password", true);

// Preguntar si el usuario está correctamente autentificado. Devuelve false en caso de haber error:
$login->logged();

// Cerrar y destruir la sesión:
$login->logout();

5. Download

Haremos cosas interesantes con esta clase mas adelante

En otra entrada anterior –Validar E-mails con PHP– hablé de una clase (programada por mí) que permite saber si una dirección email es válida y existe. Ahora veremos su aplicación en linea y la forma de validar correos con xajax.

Básicamente lo que haremos, será introducir una dirección de correo en un campo de texto, el cual obtendremos y via xajax se la pasaremos a la clase en PHP, que se encargará de enviar los comandos al servidor mail correspondiente y devolver el resultado.

Nota: La clase, por el momento, no funciona con servidores SSL, tipo Gmail/Yahoo.

Resultado final

Validando email…
E-mail válido
E-mail inválido

Ejemplo online

Podemos apreciar el ejemplo funcionando aquí.

Descargar ejemplo
Si lo prefieres, puedes descargar el ejemplo…

Implementación.

Primero descargaremos la clase y descompactaremos el zip dentro de un directorio, en el cual incluiremos también el xajax.

Nota: La versión de xajax que yo uso es la 0.2.4, algo vieja pero servirá para los propósitos de demostración.

Modulo que usa clase de validacion

<?
/**
  *	Modulo para usar clase validmail y validar correos
  *	@author: Amir oswaldo Canto
  * 	@date 23/08/08
  */
  require($_SERVER[DOCUMENT_ROOT]."/xajax/xajax.inc.php");
  require("class.validmail.php");

  /*
    Declaramos xajax....
  */
  $xajax = new xajax();
  $xajax->registerFunction("isValidMail");
  $xajax->processRequests();

  function isValidMail($email)
  {
    $objResponse = new xajaxResponse();
    {/*	Comprobamos que el parámetro email se encuentre seteado con algun valor*/
      if(isset($email) && $email != "")
      {
        $validMail = new ValidEmail($email); // llamamos a la clase
        if(!$validMail->validString()  || !$validMail->validate() )
	 // comprobamos ahora sí el email
        {

          $objResponse->addAssign("verificacion","innerHTML","<img src='images/cross.png' alt='' /> El Email no es v&aacute;lido");
          $objResponse->addScript("document.getElementById('verificacion').className = 'redbox';");
        }
        else
        {
          $objResponse->addAssign("verificacion","innerHTML","<img src='images/accept.png' alt='' /> Email V&aacute;lido ");
          $objResponse->addScript("document.getElementById('verificacion').className = 'greenbox';");
        }
        $objResponse->addScript("document.getElementById('email').disabled = false;");
      }

    }
    return $objResponse;
  }
?>

Este código lo incluiremos dentro de un fichero llamado mod.valid.php o dentro de nuestro script donde se encuentra nuestro formulario y será el responsable de llamar a la clase de validación y procesar los requests y devolver el resultado.

Script JS

function isValidMail(email){

	if(email.value != "")
	{
		var htmlCode = "<img src='images/ajax-loader.gif' alt='' /> Validando E-mail...";
		var verificacion = document.getElementById('verificacion');
		verificacion.innerHTML = "";
		verificacion.innerHTML = htmlCode;
		verificacion.className = '';
		email.disabled = true;

		xajax_isValidMail(email.value);
	}
}

Implementación en el formulario

<?php
require("mod.valid.php");
?>
<html>
<head>
	<title>Validando email</title>
	<link rel="stylesheet" href="estilo.css" type="text/css" />
	<script language="javascript" type="text/javascript" src="mail.js"></script>
	<?php

		if(isset($xajax) && is_object($xajax))
		{
			$xajax->printJavascript("http://".$_SERVER[SERVER_NAME]."/xajax/");
		}

	?>
</head>
<body>

<form>
<label for="email">
	E-mail <input type="text" value="" onblur="isValidMail(this)" name="email" id="email" /> <span id="verificacion" />
</label>

</form>

</body>
</html>

El Campo mail

Despues de agregar los scripts CSS, JS y PHP en nuestro fichero donde se encuentra nuestro formulario, agregaremos el campo “email” como sigue:

<label for="email">
	E-mail <input type="text" value="" onblur="isValidMail(this)" name="email" id="email" /> <span id="verificacion" />
</label>

Notese que el nombre e id son iguales “email” y no deben cambiarse por ningún motivo, la funcion isValidMail envia al accionarse el evento onblur el mail al script PHP que comprobará y validará nuestro mail en tiempo real.

Descargar
Descarga la clase y el ejemplo aqui.

La programación es 50% construir – 50% arreglar. El arte de construir es algo maravilloso y lo que nos produce mayor satisfacción… Por el contrario, arreglar los errores (que nosotros mismos construimos) puede tornarse un trabajo más difícil que programar, puede hacer de tu vida un infierno, hasta el punto en que te haría dudar sobre si elegiste bien tu profesión o debiste ser veterinario (si lo sé, exagero ).

Arreglar errores es todo un tema aparte, pero… ¿Cómo poder arreglar algo que no sabemos por qué se produce, cuando se produce y dónde se produce?

Para eso se inventaron las descripciones de errores (junto con un número de identificación). Aunque algunas veces esas descripciones son tan útiles como un destornillador para zurdos. Es algo que yo llamo “errores ciegos”, errores que no dicen nada, errores que no aportan nada a la resolución y estorban o confunden.

Por ejemplo, errores como los que el WordPress da:

“Ha ocurrido un error sin identificar.” ¿que rayos ha pasado? Algunos podrían decir que “por lo menos me lo ha dicho en mi idioma”. Pero esta descripción de “sin identificar” no ayuda en nada, y simplemente deja una única opción al usuario: resignarse, y empezar a rezar para que no ocurra de nuevo.

Errores en PHP

Gracias a una función encontrada en los comentarios de la documentación de PHP, podemos conseguir que los errores mostrados digan algo más que un simple “ha ocurrido un error, jodete!” y así poder cercarlo y solucionarlo

La función en cuestión es la siguiente:

function my_error_handler($errno, $errstr, $errfile, $errline){
  $errno = $errno & error_reporting();
  if($errno == 0) return;
  if(!defined('E_STRICT'))            define('E_STRICT', 2048);
  if(!defined('E_RECOVERABLE_ERROR')) define('E_RECOVERABLE_ERROR', 4096);
  print "<pre>\n<b>";
  switch($errno){
    case E_ERROR:               print "Error";                  break;
    case E_WARNING:             print "Warning";                break;
    case E_PARSE:               print "Parse Error";            break;
    case E_NOTICE:              print "Notice";                 break;
    case E_CORE_ERROR:          print "Core Error";             break;
    case E_CORE_WARNING:        print "Core Warning";           break;
    case E_COMPILE_ERROR:       print "Compile Error";          break;
    case E_COMPILE_WARNING:     print "Compile Warning";        break;
    case E_USER_ERROR:          print "User Error";             break;
    case E_USER_WARNING:        print "User Warning";           break;
    case E_USER_NOTICE:         print "User Notice";            break;
    case E_STRICT:              print "Strict Notice";          break;
    case E_RECOVERABLE_ERROR:   print "Recoverable Error";      break;
    default:                    print "Unknown error ($errno)"; break;
  }
  print ":</b> <i>$errstr</i>\n";
  if(function_exists('debug_backtrace')){
    //print "backtrace:\n";
    $backtrace = debug_backtrace();
    array_shift($backtrace);
    foreach($backtrace as $i=>$l){
      print "[$i] in function <b>{$l['class']}{$l['type']}{$l['function']}</b>";
      if($l['file']) print " in <b>{$l['file']}</b>";
      if($l['line']) print " on line <b>{$l['line']}</b>";
      print "\n";
    }
  }
  print "\n</pre>";
  if(isset($GLOBALS['error_fatal'])){
    if($GLOBALS['error_fatal'] & $errno) die('fatal');
  }
}

function error_fatal($mask = NULL){
  if(!is_null($mask)){
      $GLOBALS['error_fatal'] = $mask;
  }elseif(!isset($GLOBALS['die_on'])){
      $GLOBALS['error_fatal'] = 0;
  }
  return $GLOBALS['error_fatal'];
}

¿Como se usa?

Muy fácil:

set_error_handler('my_error_handler');

set_error_handler se encarga de enviar todos los errores a la función my_error_handler, la cual parsea, formatea e imprime en pantalla los errores.

Veamos la diferencia:

Sin la función de errores:

Fatal error: Un extraño error ha ocurrido. No le daré más información. in C:\AppServ\www\errores\db.php on line 9

Con la función de errores:

User Error: Un extraño error ha ocurrido. No le daré más información.
[0] in function trigger_error in C:\AppServ\www\errores\db.php on line 9
[1] in function tierno_y_jugueton in C:\AppServ\www\errores\db.php on line 4
[2] in function dulce_conejito in C:\AppServ\www\errores\index.php on line 8

Los números iniciales, significan el grado de “profundidad” del error. En este ejemplo, trigger_error está dentro de la función tierno_y_jugueton, que a su vez está dentro de la función dulce_conejito, que fué llamada desde index.php en la línea 8.

Puedes descargar el ejemplo y comprobarlo tu mismo!

Realmente esto es muy útil de tener en cuenta para debuguear.

Muchas veces en nuestros desarrollos nos toca validar campos y uno de los más importantes es el campo de “Email”.

La típica forma “expresiones”

La típica forma de realizar esto es buscando caracteres inválidos dentro de la cadena…
Hace poco tiempo, salió en la red el sitio emailvalido.com, dentro del cual colocabas tu e-mail y te decía si era valido o no.

Me llamó mucho la atención, ¿Cómo hace esto?, estuve investigando y me acordé que los servidores smtp tienen dos comandos “vrfy” y “expn” pero por seguridad estos se encuentran deshabilitados, ¿entonces cómo verificar un mail?

mediante RCPT TO, cuando se introduce un email valido que existe en el sistema este responde con un código numérico (250).

Por eso me he montado una clase, que espero que les pueda ser útil a la hora de checar mails

/**
 * Clase para validar mails (http://www.coders.me - Coders community)
 *
 * Esta clase corre unicamente sobre Linux y  PHP5
 * (siempre  y cuando esté activado el modulo de sockets en PHP)
 * para más información relativa a este código visite: http://www.coders.me
 * http://www.rfc-es.org/rfc/rfc1869-es.txt
 *

 * @author 	Amir Canto Palomo <amircanto@hotmail.com>
 * @copyright  validEmail Class  2008-02-23
 * @version 1.3
 * @todo Hacer que la clase pueda contactar con servidores SMTP que soporten SSL
 * @license MIT

  The MIT License
  Copyright (c) 2008 www.coders.me 

  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
  files (the "Software"), to deal in the Software without
  restriction, including without limitation the rights to use,
  copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following
  conditions:

  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
 */

define("CRLF","\r\n");		// [ENTER]
define("PORT","25");  		// SMTP PORT.

Class ValidEmail
{
	private $mail;
	private $user;
	private $domain;

	public function validate()
	{
		if($sock = $this->connectSMTP())
		{
			if($this->getResponse($sock) == "220")
			{
				$this->writeData($sock,"EHLO ".$this->domain.CRLF);
				// echo "Mandando helo $this->domain\n";
				if($this->getResponse($sock) == "250")
				{
					$this->writeData($sock,"HELO ".$this->domain.CRLF);
					if($this->getResponse($sock) == "250")
					{
						$this->writeData($sock,"MAIL FROM: $this->user@".$this->domain.CRLF);
						if($this->getResponse($sock) == "250")
						{

							$this->writeData($sock,"RCPT TO: ".$this->user."@".$this->domain.CRLF);
							if($this->getResponse($sock) == "250")
							{
								// echo "email valido\n";
								$this->writeData($sock,"QUIT".CRLF);
								$this->socketClose($sock);
								return 1; // valid email
							}
						}
					}
				}
			}
		}
		return 0;
	}

	private function socketClose($socket)
	{
		socket_close($socket);
	}

	private function writeData($socket,$data)
	{
		if($socket)
		{
			if(socket_write($socket,$data,strlen($data)))
			{
				return 1;
			} 

		}
		return 0;
	}
	private function getResponse($socket)
	{
		if($socket)
		{
			// echo "Esperando respuesta\n";
			$response = socket_read($socket,2048);
			// echo "respuesta: $response\n";
			if(strlen($response) > 0 )
			{

				//echo $response;
				$rescode = $response[0].$response[1].$response[2];

				return $rescode;
			}
		}
	}
	private function connectSMTP()
	{

		if( function_exists("socket_create") && function_exists('socket_connect') )  //Ok.. existen las funciones..
		{

			if( empty($this->domain) || ($this->domain == "") ) $this->extractData();
			if($sock = socket_create(AF_INET,SOCK_STREAM,SOL_TCP))
			{

				$mxrecords = $this->getMxRecords();
				/*echo count($mxrecords)."\n";
				echo "records:".(int)$mxrecords."\n";
				print_r($mxrecords);*/
				if(isset($mxrecords) && (int)$mxrecords > 0 )
				{
					if($this->validString() )
					{
						foreach($mxrecords as $records)
						{
							if(isset($records) && $records != "")
							{
								// echo "Conectando con: $records \n";
								$address = gethostbyname($records);
								if($address != $records)
								{

									if(socket_connect($sock,$address,PORT))
									{
										// echo "conectado";
										return  $sock; //Conected   devolvemos el handle
									}
								}
							}

							}
					} else return 0;
				} else return 0;
			}

		}
		return 0; // no logramos conectar / something has failed.. we cannot connect.
	}
	public function validString()
	{

		$email = $this->mail;
		if( eregi( "^([a-z0-9._]+)@([a-z0-9.-_]+).([a-z]{2,4})$", $email) )
		{
			return 1;
		}
		return 0;
	}

	public function getMxRecords()
	{
		$dominio = $this->domain;
		if( isset($dominio) && ($dominio != "") )
		{
			if(getmxrr($dominio,$records))
			{
				if(count($records) > 0)	// hay mx records...
				{
					return $records;
				}
				else 	// NO hay MX records.. entonces usamos el dominio para conectar.
				{
					return $dominio; // retornamos el dominio tal cual..
				}
			} else
			{
				return 0; // algo fallo... no pudimos conectar
			}
		}
		return 0; // de nueva cuenta algo falló...
	}
	private function extractData()
	{
		$data = explode("@",strtolower($this->mail));
		$this->user = $data[0];
		$this->domain = $data[1];
	}

	function __construct($email)
	{
		$this->mail = $email;
		$this->extractData();
	}
}

Pequeña explicación de la clase

Lo que hace esta clase es al crear el objeto y pasarle el mail para despues llamar a las funciones correspondientes es:

• Validar la cadena y verificar si tiene caracteres invalidos
• Buscar el servidor smtp usando los registros mx obtenidos mediante el dominio del mail.
• Conectar al servidor smtp si no puede intenta con el siguiente registor MX.
• Una vez conectado comienza a interactuar con el servidor y le manda el mail usando RCPT TO: y espera la respuesta con el código 250 (que significa que el servidor validó correctamente el e-mail)

Uso de la clase

$validar = new ValidEmail("correo@micorreo.com");
if($validar->validString())	 // el email tiene caracteres validos
{
	echo "el email tiene caracteres validos";
	if($validar->validate())	// Ahora comprobamos que exista la cuenta en el servidor.
	{
		echo "el dominio es valido";
	}
}

Las dos funciones aquí importantes son “validString()” y “validate()”

validString()

Si queremos validar solamente los caracteres del mail podemos usar unicamente esta funcion, si la cadena esta limpia devuelve true y si tiene caracteres invalidos devuelve false.

validate()

La función validate() será la forma de validar mediante el servidor smtp, devuelve true si el mail es invalido, false en caso contrario.

¿Por qué no usar la función validString() dentro de validate()?

Por que no todos vamos a querer validar mails de las dos formas de una sola vez, habrá quien solo quiera verificar los caracteres.

Errores

Hasta ahora solo he testeado la clase 2 o 3 veces. Por lo que si alguien encuentra algún error sería bueno que nos lo comente.

Errores conocidos

Por el momento la clase solo puede validar mails en los cuales los servidores smtp no estén configurados para usar SSL.

Descargar

Si quieres descargar el código fuente y los archivos de ejemplo puedes hacerlo aqui.

Actualizaciones:

Bugs fixeados:

• MX Records, cuando el dominio es invalido y no hay records devuelve 0 y el parámetro es pasado al foreach y por lo tanto falla

¿Qué es un socket?

Un socket es un punto de comunicación entre dos máquinas.

Modelo Cliente-Servidor

Tipicamente los sockets BSD consisten en dos niveles de procesos de aplicación separados; un proceso (el cliente) realiza una conexión mientras que el segundo proceso (servidor) las acepta, a esto se le conoce como Modelo Cliente – Servidor.

Tipos de Sockets

• Sockets STREAM
  

  Este tipo de socket permite trabajar realizando/esperando conexiones a puertos TCP.

• DATAGRAM
  

  Lo mismo que el anterior pero trabajando con paquetes UDP

• RAW
  

  O mejor conocidos como de bajo nivel, permiten trabajar con las cabeceras IP, TCP, UDP, construir nuestros propios packetes etc.. Por desgracia no veremos su implementación.

Implementación en PHP.

PHP no sólo nos ofrece la función “fsockopen” para tratar con sockets, también nos permite trabajar con Sockets BSD, del cuál he visto muy poca información.

Instalación en Linux

Por fortuna para los usuarios de Linux los sockets BSD ya vienen habilitados, y si no, tendremos que recompilar nuestro php con la opción “—socket”.

Instalación en Windows

Para los usuarios de Windows PHP no trae la extensión habilitada.
Para habilitar los sockets bsd seguir los siguientes 4 pasos:

1. Ir a la carpeta donde está instalado php y abrir el fichero “php.ini”.
2. Buscar la línea ;extension=php_sockets.dll y remover el punto y coma que tiene al principio.
3. Buscar la línea que contiene el directorio de extensiones php “extension_dir” y verificar que en la ruta declarada se encuentre la librería “php_sockets.dll”.
4. Salvar los cambios en el php.ini.

Ya que tenemos habilitados los sockets en PHP sea en Windows o Linux nos dedicaremos ahora a su implementación! (Lo que tanto hemos esperado muchachos!)

Ejemplo de Cliente.

Me pondría a explicar cada una de las funciones con sus prototipos para que todos pudieramos entender pero sería muy aburrido y pienso que es más fácil comprender/aprender con un buen código por lo tanto aquí les dejo un ejemplo de cómo conectar con algoritmatica

 $sock = socket_create(AF_INET,SOCK_STREAM,SOL_TCP);
// Creamos un socket con socket_create, le pasamos como primer parámetro la constante del tipo de dominio a utilizar, luego el tipo de socket (SOCK_STREAM, SOCK_DGRAM, SOCK_RAW) y por ultimo el protocolo
$result = socket_connect($sock,gethostbyname(“www.algoritmatica.com”),80);
// Pasamos como primer parámetro el descriptor del socket creado, usamos gethostbyname para resolver el nombre de dominio (host) y por último indicamos que queremos conectar al puerto 80
// Creamos la petición HTTP
$header .= “HEAD / HTTP/1.0\r\n”;
$header .= “Host: www.algoritmatica.com”;
$header .= “Connection:Close”;
socket_write($sock,$header,strlen($header));
// Pasamos como primer parámetro el descriptor de socket, la petición http y su tamaño en bytes usando la función strlen.
while($respuesta = socket_read($sock,2048))
// Esperamos la respuesta  y los datos.
{
echo $respuesta;
}
socket_close($sock);
// Cerramos socket y conexión.

Ejemplo de servidor

Este ejemplo está extraído de la referencia de PHP (que todos deberíamos tener a la hora de programar… agradezco el código!)

set_time_limit(0);
ob_implicit_flush();

$address = '192.168.1.3';
$port = 10000;

if (($sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) < 0) {
  echo "socket_create() failed: reason: " . socket_strerror($sock) . "\n";
}

if (($ret = socket_bind($sock, $address, $port)) < 0) {
  echo "socket_bind() failed: reason: " . socket_strerror($ret) . "\n";
}

if (($ret = socket_listen($sock, 5)) < 0) {
  echo "socket_listen() failed: reason: " . socket_strerror($ret) . "\n";
}

do {
  if (($msgsock = socket_accept($sock)) < 0) {
    echo "socket_accept() failed: reason: " . socket_strerror($msgsock) . "\n";
    break;
  }
  /* Send instructions. */
  $msg = "\nWelcome to the PHP Test Server. \n" .
  "To quit, type 'quit'. To shut down the server type 'shutdown'.\n";
  socket_write($msgsock, $msg, strlen($msg));

  do {
    if (false === ($buf = socket_read($msgsock, 2048, PHP_NORMAL_READ))) {
      echo "socket_read() failed: reason: " . socket_strerror($ret) . "\n";
      break 2;
    }
    if (!$buf = trim($buf)) {
      continue;
    }
    if ($buf == 'quit') {
      break;
    }
    if ($buf == 'shutdown') {
      socket_close($msgsock);
      break 2;
    }
    $talkback = "PHP: You said '$buf'.\n";
    socket_write($msgsock, $talkback, strlen($talkback));
    echo "$buf\n";
  } while (true);
  socket_close($msgsock);

} while (true);

socket_close($sock);

Fin

He dado una pequeña introducción a los sockets, el modelo cliente-servidor y sockets en PHP, sería interesante que para una próxima entrada escriba sobre sockets pero en C y su implementación en windows (winsockets).

¿Algún comentario o sugerencia? cualquier cosa será bienvenida! no dejes de comentar!
gracias.

Para mayor información:
http://www.php.net/manual/es/ref.sockets.php

Estilo de programación

¿Te imaginas el código fuente de Linux, sin comentar, con lineas y espacios a mansalva, y usando funciones que solo Dios sabe que hacen?
Proyectos grandes, y más los pequeños, se hacen difíciles de continuar por otras personas si el código no está lo suficientemente bonito como para leerlo. No hablamos de comentar el código, ya que he visto la exageración de comentar cada linea de código lo cual se torna en un infierno para leer xD.

Hablamos de crear “código para lectura”, no sólo hacer que funcione sino también hacer que pueda ser leido fácilmente por los programadores.

A veces nos acostumbramos a programar y a hacer código a la ligera, olvidando la importancia de mantener un orden inteligente a través de las tabulaciones, los espacios y los saltos de línea. Este orden debe hacerse costumbre para aquellos programadores que deseen alcanzar la perfección (juaz).

En este artículo hablaré exclusivamente de PHP ya que es uno de los lenguajes en el que más me molesta ver código mal formateado. Aunque como bien ustedes saben, se puede (se debe)(y frecuentemente es aplicado ) a otros lenguajes de programación similares como C y sus descendientes.

Haciendo código más bonito?

¿Por qué deberías embellecer tus creaciones?
Sin duda es un paso importante para entender tu código y poder leerlo a “simple vista”. No hablamos sólo comentar el código, sino también de crear una correcta indentación y formateo de nuestro código.

Los buenos codes se leen tan fácilmente como si fueran un libro para niños. (creo que estoy exagerando )

Embellecer el código es tan importante como escribirlo. Es más útil aún cuando trabajas en grupo, sobre todo cuando necesitas que algún compañero (más experto) “pueda ver tu código” y decirte donde está el error.

Se trata sobre todo de entender una manía que nos afecta a la mayoria de los programadores (incluyendome). No podemos leer un código (que no es nuestro) sin antes empezar a darle una indentacion correcta.

Es importante destacar, por si no sabias, que la indentación no es obligatoria ni necesaria para que un código funcione, ya que los compiladores rara vez le dan importancia a esto. Pero no por eso es menos importante.

¿Que es la indentación?

Según la wikipedia:

Por indentación se entiende mover un bloque de texto hacia la derecha insertando espacios o tabuladores para separarlo del texto adyacente.

Para dar un ejemplo, veamos un código no indentado, y uno correctamente indentado:

if(a == b){
echo "a y b son iguales";
}

El mismo código, pero aplicando indentación:

if(a == b){
    echo "a y b son iguales";
}

Se han creado “reglas” o “estándares” de código para “insertar esos espacios” en la derecha del código fuente ya que, si indentar supone solo agregar espacios a la derecha, cualquier diablo agregaria espacios a mansalva haciendo aún mas dificil la lectura de un código “indentado”.

Existen varios estilos mundialmente reconocidos, y propongo navegar por algunos de ellos para resaltar sus diferencias y poder elegir el que más nos guste.

Estilo K&R y BSD KNF

El estilo K&R es el más usado en el lenguaje C y PHP. Se trata de abrir la llave en la misma línea de declaración de la orden, indentando los siguientes pasos al mismo nivel que la llave y cerrando la llave en el mismo nivel que la declaración. Normalmente las tabulaciones en windows son de 4 espacios, cuando las tabulaciones tienen 8 espacios se trata del estilo BSD o KNF, muy usado en Linux.

Se entiende mejor con el siguiente ejemplo:

function saludar($val){
    if($val == 1) {
        echo "Hola!";
    } else {
        echo "Chau!";
    }
}

El código fuente del kernel de Unix y Linux está escrito en este estilo.

La ventaja de usar este estilo es que las llaves iniciales no necesitan ninguna línea extra para ellas solas, por lo que se ahorra espacio vertical de lectura.
La desventaja de este estilo es que las llaves de cierre si necesitan una línea exclusiva para ellas.
Resulta difícil identificar el comienzo de las llaves de un bloque. Sin embargo es fácil identificar el comienzo de un bloque debido a la indentación a la derecha.

Estilo Allman

Se trata de crear una nueva línea para las llaves, e identar el código debajo de ellas. La llave de cierre tiene el mismo identado que la de inicio.

function saludar($val)
{
    if($val == 1)
    {
        echo "Hola!";
    }
    else
    {
        echo "Chau!";
    }
}

Este estilo mantiene un código limpio y claro. Las llaves de inicio y fin coinciden en la misma columna, haciendo más fácil la identificación de cada bloque. Además, es más difícil olvidarse cerrar una llave cuando se identifica claramente la llave inicial.
Personalmente uso este estilo en mis creaciones .

La desventaja de este estilo, es que las llaves ocupan enteramente una línea, ocupando más espacio vertical de lectura. En monitores con resoluciones bajas (24 líneas) resulta difícil leer código fuente con este estilo aunque esto poco afecta en monitores con resoluciones mas grandes.

Estilo GNU

Parecido al estilo Allman, se trata de poner las llaves en una nueva línea. La diferencia es que las llaves, deben estar indentadas por 2 espacios, y el código dentro de ellas debe estarlo por 2 espacios más.

function saludar($val)
{
    if($val == 1)
      {
        echo "Hola!";
      }
    else
      {
        echo "Chau!";
      }
}

Algunas aplicaciones (como GNU Emacs) formatean el código a este estilo automáticamente. Es usado por los proyectos de software GNU debido a que se ha declarado un estándar dentro de esta comunidad.

¿Y tu, que estilo usas?

Comentanos cual es el estilo que usas para tu proyectos, y si tienes la mania (como yo) de indentar el código de otros a nuestro estilo .

Herramienta de indentación automática

Por suerte disponemos de una herramienta gratuita y online para indentar código en el estilo que más nos guste. Esta herramienta se puede encontrar en el siguiente enlace:
http://formatter.gerbenvv.nl/version3/index.php

Además de separar los bloques en nuestro estilo preferido, formatea el código agregando color, quitando comentarios y líneas vacías. Una herramienta que sin duda merece estar en nuestros favoritos.

Las opciones son muy intuitivas, aunque en breve voy a explicar que significa la opción “Comment after control structures”.

Otra herramienta para indentar código online, pero esta vez para HTML y CSS, puedes encontrarla aqui:
http://tools.arantius.com/tabifier

Cierres de bloques

En ocasiones tenemos estructuras de control muy grandes (verticalmente) tanto es asi que al leer el final de ellas, perdemos de vista el principio obligándonos a tener que subir y bajar la página para poder leer el código.
Por ello una buena costumbre es la de comentar al final de cada bloque, escribiendo en el comentario la misma declaración del inicio.

function saludar($val)
{
    if($val == 1)
    {
        echo "Hola!";
    }
    else
    {
        echo "Chau!";
    }//($val == 1)
}//function saludar($val)

Aunque esto es exagerado para bloques pequeños, es de extrema utilidad para bloques con un tamaño considerablemente grande.
La desventaja es que nos obliga a escribir el código dos veces (pero repito, solo es a modo de lectura, no afecta en nada el funcionamiento).

La opción “Comment after control structures” del indentador online, justamente realiza esta operación automáticamente con todas las estructuras de control.

Personalmente hago uso de estos comentarios cuando los if o bucles, son muy grandes y muy complicados.

¿Indentar seteo de variables?

Esto no es un estandar, mas bien es una recomendación personal, ustedes pueden decirme que les parece .

Antes:

$nombre_temporal = $_FILES['Filedata']['tmp_name'];
$tamano_de_archivo = $_FILES['Filedata']['size'];
$realname = $_FILES['Filedata']['name'];

Despues [Indentado]:

$nombre_temporal    = $_FILES['Filedata']['tmp_name'];
$tamano_de_archivo  = $_FILES['Filedata']['size'];
$realname           = $_FILES['Filedata']['name'];

Sin duda se lee mejor de la segunda manera, queda más bonito, y se distinguen mejor las variables.
También podemos hacer lo mismo con los parametros de funciones, cuando las lineas se repiten:

$site->set("descripcion", $descripcion);
$site->set("titulo"     , $titulo);
$site->set("enabled"    , $enabled);
$site->set("notenabled" , $notenabled);

Creando bloques de código

Otra recomendación mia, es la de usar bloques de código para identificar rápidamente el significado de unas lineas de proceso. En el siguiente ejemplo, se verifica si el usuario tiene los permisos para acceder a la pagina. Nótese como se han encerrado las lineas entre corchetes {} sin pertenecer estas, a un condicional.

{//Login Check
    if(!$login->logged() && !$login->isadmin())
    {
        $site->template('login');
        exit(0);
    }
}//End Login Check

Recomiendo hacer uso de esta técnica siempre que se pueda, ayuda bastante a la hora de leer el código.

¿Y tu como mejoras tu código?

Cúentanos que haces para poder leer mejor tus códigos, y si tienes sugerencias o manías como nosotros xD.

Bibliografía

Indentación automática (autotabulacion de código php): http://formatter.gerbenvv.nl/version3/index.php
http://en.wikipedia.org/wiki/Indent_style
http://es.wikipedia.org/wiki/Estilo_de_programación