El caso es que viendo páginas como la de radikalq3 me animé a solicitar a FON su preciado router wireless (cuando aún estaba de oferta a 5 ?) para hacer “pruebas y experimentos” y de paso unirme a la comunidad FON.

La recibí ayer, y por supuesto habilité el ssh mediante hardware (cables, condensadores, MAX232 y el puerto serie). Por cierto, una vez listado todo el proceso de arranque el usuario debe pulsar INTRO para activar la consola. Una vez abierto el puerto 22 monté de nuevo la fonera y me conecté por ssh. La primera vez que entras debes entrar como root y con password admin. Posteriormente cambié la clave de root desde la web de FON en Configura tu Router Social FON/Contraseña del Router

A continuación me bajé los fuentes de la fonera http://download.fon.com/firmware/fonera/latest/fonera.tar.bz2 (unos noventa megas), los guardé en mi carpeta personal de mi servidor con mandriva 2006, los descomprimí con tar xvjf fonera.tar.bz2, ejecuté make menuconfig sin modificar nada, grabé y posteriormente tecleé make. La primera vez no me compiló, por lo que tuve que instalar varios paquetes: urpmi flex, urpmi bison y urpmi byacc.

Una vez compilados los fuentes ya solo me quedaba saber como poder compilar un programa y subirlo a la fonera. La compilación se explica en la web de OpenWRT:
http://downloads.openwrt.org/docs/buildroot-documentation.html#using_toolchain. Así que me puse manos a la obra e hice este programa llamado prueba.c el cual simplemente abre le fichero /etc/passwd y muestra su contenido (en vez de hacer el típico hola mundo):

#include <stdio.h>
 
int main(void)
{
      FILE *fichero;
      char cadena[100];
      if((fichero=fopen("/etc/passwd","r"))!=NULL)
      {
              fgets(cadena,100,fichero);
              while(!feof(fichero))
              {
                      printf(cadena);
                      fgets(cadena,100,fichero);
              }
              fclose(fichero);
      }
      return 0;
}

Lo compilé con mips-linux-uclibc-gcc -o prueba prueba.c y se creó un ejecutable sin problemas. A continuación lo moví a /var/www/html para que estuviese disponible a través del servidor web apache y desde la fonera lo recuperé con wget http://192.168.0.11/prueba (notese que la ip del servidor será distinta en vuestro caso), le cambié los permisos para que se pudiera ejecutar chmod 755 prueba y finalmente lo probé funcionado perfectamente.

Espero que esto os anime a crear vuestros propios programas. Este ejecutable me ocupó unos 7 KBytes y aún tengo 7 megas de espacio libre en la fonera para añadirle nuevas cosas

Actualización 08/02/2007:

Dani, un lector del blog me comentó que la fonera solo tiene 4 megas libres de espacio de almacenamiento permanente (y no 7 megas como había escrito en el artículo). Después de hacer dos experimentos que podéis leer en los comentarios de este blog la capacidad real de la fonera con el firmware de FON es de 5 MB. Gracias Dani por forzarme a experimentar

Una de las posibilidades que ofrece la domótica es poder acceder a los aparatos aún cuando no se está presente en el hogar. Es por ello que necesitaba un medio por el cual poder acceder al sistema desde fuera de mi casa. Pues bién, aprovechando la infraestructura de Internet, y que el protocolo HTTP es el que esta más extendido, instalé un servidor web en casa e hice un portal al cual pudiera acceder desde cualquier sitio que tuviese acceso a Internet mediante un navegador.

En la imágen se puede observar el punto de entrada a la web. En su momento instalé un IIS e hice toda la programación con DHTML + ASP. Al ser una web se puede acceder a ella mediante proxy (seleccionando la opción de HTML) y sin proxy (seleccionando la opción de Java). El usuario y contraseña usa la misma base de datos de la que tira el programa Luces.

La sección de HTML es especial para proxys puesto que en muchos sitios se usan (sobre todo empresas) para compartir una conexión de Internet, mantener un registro de accesos, etc. El problema es que si hay proxy es muy posible que no haya otro medio de conectarse a Internet sin pasar por el y por tanto no pueda hacerse una conexión permanente al servidor. Por ello la interfaz esta diseñada para recibir información cuando se hace la petición http al servidor y no se refresca hasta que no se vuelva a seleccionar otro estado (eligiendo el aparato y pulsando Enviar) o ver el estado actual (pulsando el botón Ver Estado). Si el usuario es administrador, además de poder visualizar los aparatos e interactuar con ellos como otro usuario con permisos, también es capaz de manejar los comandos privilegiados además de poder hacer consultas sql a la base de datos. El fichero ASP es el encargado de hacer la conexión TCP/IP al programa Luces (tanto Luces como el IIS residen en la misma máquina), para ello usé un componente ActiveX llamado vbwinsock y que lo podeis descargar aquí.

La sección java es similar a la de HTML pero orientada a usuarios que tienen acceso directo a Internet. Se llama así porque la parte donde estan representados los aparátos es un applet de java con conexión directa al servidor de Luces (la seguridad de java solo deja conectarse al mismo dominio desde que se pidió la página). Por ello si pulsamos en cualquiera de los botones se actualiza rápidamente el estado, incluso si otro usuario cambia el estado de alguno de los aparatos también se vería reflejado. Sería como conectarse por telnet pero de una forma mucho más sencilla y amigable.

Ha habido gente que me ha preguntado por qué tardo tanto en escribir entre artículo y artículo, la razón es que tengo poco tiempo y otras veces no tengo ganas de salir del trabajo para ponerme otra vez en frente del ordenador, por eso os pido un poco de paciencia.

Otras personas me han preguntado si voy a dejar accesible el código fuente de las aplicaciones que aquí menciono, y si, efectivamente lo liberaré para que otros puedan hacer soluciones similares o basarse en esta para hacer algo nuevo. Además tengo pensado grabar un video del funcionamiento de todo el sistema de domótica.

Manejar aparatos eléctricos desde el PC: domótica (2/5) Manejar aparatos eléctricos desde el PC: domótica (4/5)

La solución se mostraba por sí sola: solo un programa accedería al módulo y los demás deberían comunicarse con este para lanzarle las peticiones y recibir el estado actual en que se encontraban los aparatos. De ahí salió el programa Luces, el cual era un simple servidor tcp que escuchaba por el puerto 1976 (mi año de nacimiento) y se comunicaba con sus clientes mediante un sencillo protocolo basado en números (al estilo del protocolo simple de transferencia de correo – SMTP). Los códigos que devuelve el servidor son los siguientes:

Por su parte el cliente envia los siguientes comandos (en mayúsculas o en minúsculas):

En primer lugar el orden que se debe seguir es:

Servidor: Mensaje de Saludo.
Cliente: Enviar USER: y el nombre de usuario.
Servidor: Mensaje de Usuario Introducido.
Cliente: Enviar PASS: y la contraseña del usuario.
Servidor: Mensaje de Contraseña Introducida.

• Si el usuario introduce una contraseña incorrecta el servidor le mostrará un fallo en la autentificación (302) y cerrará la conexión.
• Si el usuario introduce un comando no reconocido cuando se está validando el servidor le mostrará un comando no reconocido (301) y le cerrará la conexión, en cambio cuando este validado solo le mostrará el estado de los aparatos (101).
• Si el usuario introduce antes el comando PASS que el USER el servidor le mostrará estado no identificado (300) y le cerrará la conexión.

En segundo lugar cuando el usuario ya esta validado puede introducir o bién los comandos OPEN, CLOSE, QUIT y BYE; o bién un número de 0 a 15 que actuaría como máscara para encender o apagar los aparatos (si el número es mayor que 15 se usa el módulo de 16).

Haciendo un telnet, lo anterior comentado se vería de la siguiente forma:

Y en la aplicación Luces se vería así:

Si ahora cometemos un error (por ejemplo metemos mal el usuario) el resultado quedaría así:

Como se puede observar, la segunda conexión la he hecho a través de otro ordenador. Gracias a que se usa el protocolo el tcp/ip se puede conectar desde cualquier programa (independientemente del sistema operativo, arquitectura de ordenador, etc).

Por otro lado el sistema se basa en una base de datos para gestionar los usuarios, los eventos y los aparatos:

En mi caso usé una base de datos access, pero como es lógico pensar, se puede usar cualquier tipo de base de datos relacional. Las tablas son sólo 4 y se detallan a continuación:

Manejar aparatos eléctricos desde el PC: domótica (1/5) Manejar aparatos eléctricos desde el PC: domótica (3/5)

El gateway esta dado de baja (tuvo demasiado éxito), sin embargo el móvil que aparece en la imágen lo sigo usando en algunos de mis proyectos (pronto sabreis por qué estoy escribiendo artículos sobre aparatos). Se trata de un siemens m35i que en su día me cargué la pantalla y lo destiné como modem gsm para poder enviar y recibir sms. Este se comunica con un cable de datos por el puerto serie con el ordenador. Como el cable tiene que usar el mismo compartimento que la fuente de alimentación del móvil y necesitaba tener los dos al mismo tiempo, conecté los pines donde se conecta la batería del móvil a un pequeño circuito con un L7805C y dos condensadores, funcionando todo ello con una fuente de alimentación de 12 voltios.

En este caso el móvil al ser un modem gsm (como la inmensa mayoría) se puede manejar con comandos AT, aunque algunos son característicos de los móviles (como el de mandar sms).

Para trabajar con el, en mi caso, tengo que abrir el puerto serie a 19200 baudios, 8 bits, ninguna paridad y un bit de stop.

En mi caso, siempre me interesa usarlo como transmisor/receptor de sms, por lo que leyendo un poco la documentación del móvil veo que para enviar sms se usa el comando AT+CMGS. Sin embargo mi móvil no permite mensajes de texto de forma directa, sino que necesita enviarlos en formato estandar PDU (también cuando muestra los recibidos). Buscando por ahí no he encontrado mucho código fuente (en java smstools) por lo que me hice una rutina en C para pasar de texto a PDU y viceversa:

/* Transforma un texto normal (pchOriginal) en PDU (pchTransformado) devolviendo pchTransformado*/
char *formatoMensaje(char *pchOriginal, char *pchTransformado)
{ 
    char pchTablaHex[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    unsigned char chrCaracter; 
    int intContador; 
    int intIndice; 
    int intTamano; 
    int intMascara; 
    int intDesplaza;
 
    intTamano = strlen(pchOriginal); 
    intMascara = 1; 
    intContador = 0; 
    intIndice = 2; 
    strcpy(pchTransformado,"00"); 
    intDesplaza = 7;
 
    while(intContador < intTamano) 
    {  
        chrCaracter = ((*(pchOriginal + intContador + 1) & intMascara) << intDesplaza) + (*(pchOriginal + intContador) >> (7 - intDesplaza));  
        pchTransformado[intIndice] = pchTablaHex[(chrCaracter & 0xF0) >> 4];  
        intIndice++;  
        pchTransformado[intIndice] = pchTablaHex[chrCaracter & 0x0F];  
        intIndice++;  
        intContador++;  
        intMascara <<= 1;  
        intMascara++ ;  
        intDesplaza--;  
        if(intDesplaza == -1)  
        {   
            intMascara = 1;   
            intDesplaza = 7;   
            intIndice -= 2;  
        } 
    }
 
    pchTransformado[intIndice] = '';
 
    chrCaracter=(char)intTamano; 
    pchTransformado[0] = pchTablaHex[(chrCaracter & 0xF0) >> 4]; 
    pchTransformado[1] = pchTablaHex[chrCaracter & 0x0F];
 
    return pchTransformado;
}
 
/* Transforma un texto PDU (pchOriginal) en texto normal (pchTransformado) devolviendo pchTransformado*/
char *decodificaMensaje(char *pchOriginal, char *pchTransformado)
{ 
    char pchLetras[5];
    unsigned char chrCaracter; 
    int intTamano; 
    int intContador; 
    int intArrastre; 
    int intDesplaza; 
    int intIndice; 
    int intMascara;
 
    intMascara = 128; 
    intIndice = intContador = intArrastre = intDesplaza = 0;
 
    strcpy(pchLetras, "0x"); 
    strncat(pchLetras, pchOriginal + intIndice, 2); 
    sscanf(pchLetras, "%x", &intTamano);
 
    intIndice += 2;
 
    while(intContador < intTamano) 
    {  
        strcpy(pchLetras, "0x");  
        strncat(pchLetras, pchOriginal + intIndice, 2);  
        sscanf(pchLetras, "%x", &chrCaracter);  
        pchTransformado[intContador] = ((chrCaracter & ~intMascara) << intDesplaza) + intArrastre;  
        intArrastre=(chrCaracter & intMascara) >> (7 - intDesplaza);  
        intIndice += 2;  
        intMascara >>= 1;  
        intMascara += 128;  
        intDesplaza++;  
        if(intMascara == 255)  
        {   
            intContador++;   
            pchTransformado[intContador] = chrCaracter >> 1;   
            intMascara = 128;   
            intDesplaza = intArrastre = 0;  
        }
        ++intContador; 
    }
 
    pchTransformado[intContador] = '';
 
    return pchTransformado;
}

Básicamente consiste en obtener una identificación única a partir de la información de la tabla de contenidos de un CD (TOC). Una vez obtenida la identificación, solo hay que hacer una petición web al servidor de freedb con la misma para que nos devuelva el título del CD y la lista de títulos de canciones y sus respectivos autores de las distintas pistas que conforman el CD.

El algoritmo para hallar el identificador único consiste en:
-Sumar los números en segundos de lo que dura cada pista. Es decir, si una cancion dura 4:17, entónces son 257 segundos, luego la suma es 2+5+7=14.
-Una vez obtenido el sumatorio de todas las pistas con el anterior algoritmo, se le saca el módulo de 255 y a continuación se le multiplica por 16777216 (2^24); a este resultado se le suma el tiempo total del CD multiplicado por 256 (2^8) y finalmente a este resultado se le suma el número total de pistas que contiene el CD.

Una vez hallado el identificador único, se transforma a un número hexadecimal y se hace una peticion a freedb de la siguiente manera:

http://freedb.freedb.org/~cddb/cddb.cgi?cmd=cddb+read+misc+<ID UNICO>&hello=name+host.com+appname+1.0&proto=1

cddb read misc <ID UNICO> del parámetro cmd es el comando que indica que estamos haciendo una petición a la base de datos con el ID UNICO. Por ejemplo cddb read misc c510910d.

name host.com appname 1.0 del parámetro hello indica que persona, dominio, aplicación y versión de la misma esta solicitando la información. Por ejemplo: sistemasorp sistemasorp.blogspot.com testeoCDDB 1.0.

Y finalmente el 1 del parámetro proto indica que versión del protocolo queremos usar para hacer la petición a la base de datos, devolviendonos acorde a la versión una información formateada.

Así por ejemplo si lanzamos esta petición:

http://freedb.freedb.org/~cddb/cddb.cgi?cmd=cddb+read+misc+c510910d&hello=sistemasorp+sistemasorp.blogspot.com+testeoCDDB+1.0&proto=1

Nos devuelve lo siguiente (terminado en una linea con un punto, al estilo del SMTP):

210 misc c510910d CD database entry follows (until terminating `.’)
# xmcd CD database file
#
# Track frame offsets:
# 150
# 24460
# 45650
# 71127
# 98425
# 118997
# 146585
# 164707
# 188897
# 216340
# 240932
# 271642
# 297722
#
# Disc length: 4243 seconds
#
# Revision: 2
# Processed by: cddbd v1.5PL3 Copyright (c) Steve Scherf et al.
# Submitted via: CDex 1.40Beta9
#
DISCID=c510910d
DTITLE=Various / Rave Massacre [Disk 1]
TTITLE0=Raving Bastards – Love Time
TTITLE1=Chill’n Force – Move Raver (Kemo Mix)
TTITLE2=M.A.F. X-Perience – Dreamland
TTITLE3=Society for Psychical Research – Silversky
TTITLE4=Obsessiv – Tune In, Tune On, Drop Out
TTITLE5=Nettuno – I Cry
TTITLE6=Razor – Is It Love
TTITLE7=Sunbeam – Outside World
TTITLE8=Raver’s Nature – Tricky Symphony
TTITLE9=NIP Collective – I’m About
TTITLE10=RBM – Banyo Love
TTITLE11=Paranoia X – Party Program
TTITLE12=NR-Gizer – Raving Generation
EXTD= YEAR: 1994 ID3G: 31
EXTT0=
EXTT1=
EXTT2=
EXTT3=
EXTT4=
EXTT5=
EXTT6=
EXTT7=
EXTT8=
EXTT9=
EXTT10=
EXTT11=
EXTT12=
PLAYORDER=
.

Donde entre comentarios (con la almohadilla delante) da información sobre el disco, copyright y demás; continuando con una lista de parejas nombre/valor que contienen la información que queremos:

DISCID: El mismo identificador de disco que le hemos pasado
DTITLE: El autor y título del CD
TTITLEX: El título de canción que está en la pista X
EXTD: Información extendida sobre el disco
EXTTX: Información extendida sobre la canción que está en la pista X
PLAYORDER: El orden en el que se deberían reproducir las pistas
YEAR: El año de edición del disco
ID3G: La categoría o clase de música que contiene el CD

A continuación expongo dos codigos fuentes (el primero para windows y el segundo para linux) que muestran como recoger el identificador único de un cd y a continuación solicitar la información de ese cd a freedb. Ambos se ejecutan en la consola de texto pasandoles como parámetro la unidad o dispositivo de cd.

WINDOWS(ejecutable y fuentes)

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>
#include <windows.h>
 
#define IOCTL_CDROM_READ_TOC 0x00024000
 
typedef struct {
  UCHAR  Reserved;
  UCHAR  Control : 4;
  UCHAR  Adr : 4;
  UCHAR  TrackNumber;
  UCHAR  Reserved1;
  UCHAR  Address[4];
} TRACK_DATA;
 
typedef struct {
  UCHAR  Length[2];
  UCHAR  FirstTrack;
  UCHAR  LastTrack;
  TRACK_DATA  TrackData[100];
} CDROM_TOC;
 
/*
Funcion:
 lee_CDTOC
Parámetros:
 sDispositivo: ruta del dispositivo de CD.
 toc: estructura donde se almancena la tabla de contenidos del CD.
Descripción:
 Esta función se encarga de guardar en la variable toc la información de la tabla de contenidos del CD ubicado en el dispostivo lector de cdrom.
*/
void lee_CDTOC(char *sLetra,CDROM_TOC *toc)
{
 HANDLE manejador;
 DWORD nTamBuffer;
 char sUnidad[7];
 
 sprintf(sUnidad,"\\\\.\\%s",sLetra);
 
 manejador = CreateFile(sUnidad, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
 if(manejador == INVALID_HANDLE_VALUE)
 {
  fprintf(stderr,"No se pudo acceder al disco de la unidad de CD\n");
  return;
 }
 
 if (DeviceIoControl(manejador, IOCTL_CDROM_READ_TOC, NULL, 0, toc, sizeof(CDROM_TOC), &nTamBuffer, NULL) == FALSE)
  fprintf(stderr,"No se pudo leer el contenido del CD\n");
 
 CloseHandle(manejador);
}
 
/*
Funcion:
 lee_InfoCDDB: Devuelve una cadena con los resultados de la petición.
Parámetros:
 sIDDisco: identificador único del cd.
 sBuffer: buffer donde almacenar los resultados de la petición.
Descripción:
 Esta función se encarga de pedir a freedb la información relacionada con un identificador de cd determinado y devolver todo el contenido de la petición.
*/
char *lee_InfoCDDB(char *sIDDisco,char *sBuffer)
{
 WSAData data;
 SOCKET sock;
 struct hostent *servidor;
 struct sockaddr_in destino;
 char sPeticion[256];
 int nEnviados,nRecibidos;
 
 if(WSAStartup(MAKEWORD( 2, 2 ),&data) == 0)
 {
  if((sock=socket(PF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
   fprintf(stderr,"No se pudo crear la conexion");
  else
  {
   if((servidor=gethostbyname("freedb.freedb.org")) == NULL)
    fprintf(stderr,"No se pudo obtener la IP del servidor");
   else
   {
    destino.sin_family = AF_INET;
    destino.sin_port = htons(80);
    destino.sin_addr = *((struct in_addr *)servidor->h_addr_list[0]);
    memset(&(destino.sin_zero), '', 8);
    if(connect(sock, (struct sockaddr *)&destino, sizeof(struct sockaddr)) == SOCKET_ERROR)
     fprintf(stderr,"No se pudo conectar al servidor");
    else
    {
     sprintf(sPeticion,"GET /~cddb/cddb.cgi?cmd=cddb+read+misc+%s&hello=sistemasorp+sistemasorp.blogspot.com+testeoCDDB+1.0&proto=1 HTTP/1.0\r\n",sIDDisco);
     strcat(sPeticion,"Host: freedb.freedb.org\r\n\r\n");
     nEnviados=send(sock,sPeticion,strlen(sPeticion),0);
     if(nEnviados == SOCKET_ERROR)
      fprintf(stderr,"No se pudo enviar la peticion al servidor");
     nRecibidos=0;
     while(strstr(sBuffer,"\r\n.\r\n") == NULL)
     {
      nRecibidos+=recv(sock,sBuffer+nRecibidos,1024,0);
      sBuffer[nRecibidos]='';
     }
 
    }
   }
  }
  WSACleanup();
 }
 else
  fprintf(stderr,"No se puedo inicializar la conexion");
 return sBuffer;
}
 
/*
Funcion:
 cddb_Suma: Devuelve un número sacado a través de una suma de cifras.
Parámetros:
 nDuracion: Duración en segundos de una pista.
Descripción:
 Esta función se encarga de sumar todas las cifras de distinto peso entre si para posteriormente devolver el resultado.
*/
int cddb_Suma(int nDuracion)
{
 int nSuma = 0;
 
 while (nDuracion > 0) {
  nSuma = nSuma + (nDuracion % 10);
  nDuracion = nDuracion / 10;
 }
 
 return nSuma;
}
 
/*
Funcion:
 cddb_IDDisco: Devuelve en número que identifica al CD inequivocamente.
Parámetros:
 toc: Información de la tabla de contenidos del CD
Descripción:
 Esta función se encarga de calcular el identificador único de un CD a través de su tabla de contenidos
*/
unsigned long cddb_IDDisco(CDROM_TOC *toc)
{
 int nIndice=0,
  nTotalTiempo = 0,
  nSumatorio = 0;
 int nTotalPistas;
 
 nTotalPistas=toc->LastTrack-toc->FirstTrack+1;
 
 while (nIndice < nTotalPistas) {
  nSumatorio = nSumatorio + cddb_Suma((toc->TrackData[nIndice].Address[1] * 60) + toc->TrackData[nIndice].Address[2]);
  nIndice++;
 }
 
 nTotalTiempo = ((toc->TrackData[toc->LastTrack].Address[1] * 60) + toc->TrackData[toc->LastTrack].Address[2]) -
     ((toc->TrackData[0].Address[1] * 60) + toc->TrackData[0].Address[2]);
 
 return ((nSumatorio % 0xff) << 24 | nTotalTiempo << 8 | nTotalPistas);
}
 
int main(int argc, char *argv[ ])
{
 CDROM_TOC toc;
 char sIDDisco[9];
 char *sBuffer;
 
 if(argc==2)
 {
  memset(&toc,0,sizeof(CDROM_TOC));
 
  lee_CDTOC(argv[1],&toc);
  if(toc.LastTrack>0)
  {
   sprintf(sIDDisco,"%08x",cddb_IDDisco(&toc));
   printf("El ID del disco es %s\n",sIDDisco);
 
   sBuffer=(char *)malloc(4096);
   if(sBuffer == NULL)
   {
    fprintf(stderr,"No se pudo alojar memoria");
    return 1;
   }   
   *sBuffer='';
   lee_InfoCDDB(sIDDisco,sBuffer);
   if(*sBuffer=='')
    return 1;
   printf("La información del disco es:\n%s",sBuffer);
   free(sBuffer);
  }
  else
   return 1;
 }
 else
 {
  fprintf(stderr,"La sintaxis es: %s <unidad de cd>\nEjemplo: %s d:\n",argv[0],argv[0]);
  return 1;
 }
 
 return 0;
}

LINUX(ejecutable y fuentes)

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdarg.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
 
#if defined linux
#include <linux/cdrom.h>
#elif defined sun
#include <sys/cdio.h>
#endif
 
typedef struct {
 int minutos, segundos;
} TRACK_DATA;
 
typedef struct {
  unsigned char  FirstTrack;
  unsigned char LastTrack; 
  TRACK_DATA  TrackData[100];
} CDROM_TOC;
 
/*
Funcion:
 lee_CDTOC
Parámetros:
 sDispositivo: ruta del dispositivo de CD.
 toc: estructura donde se almancena la tabla de contenidos del CD.
Descripción:
 Esta función se encarga de guardar en la variable toc la información de la tabla de contenidos del CD ubicado en el dispostivo lector de cdrom.
*/
void lee_CDTOC(char *sDispositivo,CDROM_TOC *toc)
{
 struct cdrom_tochdr tochdr;
 struct cdrom_tocentry tocentry;
 int nIndice, manejador;
 
 manejador= open(sDispositivo, O_RDONLY | O_NONBLOCK);
 if(manejador == -1)
 {
  fprintf(stderr,"No se pudo acceder al disco de la unidad de CD\n");
  return;
 }
 
 if (ioctl(manejador, CDROMREADTOCHDR, &tochdr) == -1)
  fprintf(stderr,"No se pudo leer el contenido del CD\n");
 else
 {
  toc->FirstTrack=tochdr.cdth_trk0;
  toc->LastTrack=tochdr.cdth_trk1;
  for (nIndice = toc->FirstTrack; nIndice <= toc->LastTrack; nIndice++) 
  {
   tocentry.cdte_track = nIndice;
   tocentry.cdte_format = CDROM_MSF;
   ioctl(manejador, CDROMREADTOCENTRY, &tocentry);
   toc->TrackData[nIndice-1].minutos = tocentry.cdte_addr.msf.minute;
   toc->TrackData[nIndice-1].segundos = tocentry.cdte_addr.msf.second;
  }
  tocentry.cdte_track = 0xAA;
  tocentry.cdte_format = CDROM_MSF;
  ioctl(manejador, CDROMREADTOCENTRY, &tocentry);
  toc->TrackData[toc->LastTrack].minutos = tocentry.cdte_addr.msf.minute;
  toc->TrackData[toc->LastTrack].segundos = tocentry.cdte_addr.msf.second;
 }
 close(manejador);
}
 
/*
Funcion:
 lee_InfoCDDB: Devuelve una cadena con los resultados de la petición.
Parámetros:
 sIDDisco: identificador único del cd.
 sBuffer: buffer donde almacenar los resultados de la petición.
Descripción:
 Esta función se encarga de pedir a freedb la información relacionada con un identificador de cd determinado y devolver todo el contenido de la petición.
*/
char *lee_InfoCDDB(char *sIDDisco,char *sBuffer)
{
 int sock;
 struct hostent *servidor;
 struct sockaddr_in destino;
 char sPeticion[256];
 int nEnviados,nRecibidos;
 
 if((sock=socket(PF_INET,SOCK_STREAM,0)) == -1)
  fprintf(stderr,"No se pudo crear la conexion");
 else
 {
  if((servidor=gethostbyname("freedb.freedb.org"))==NULL)
   fprintf(stderr,"No se pudo obtener la IP del servidor");
  else
  {
   destino.sin_family = AF_INET;
   destino.sin_port = htons(80);
   destino.sin_addr = *((struct in_addr *)servidor->h_addr_list[0]);
   memset(&(destino.sin_zero), '', 8);
   if(connect(sock, (struct sockaddr *)&destino, sizeof(struct sockaddr)) == -1)
    fprintf(stderr,"No se pudo conectar al servidor");
   else
   {
    sprintf(sPeticion,"GET /~cddb/cddb.cgi?cmd=cddb+read+misc+%s&hello=sistemasorp+sistemasorp.blogspot.com+testeoCDDB+1.0&proto=1 HTTP/1.0\r\n",sIDDisco);
    strcat(sPeticion,"Host: freedb.freedb.org\r\n\r\n");
    nEnviados=send(sock,sPeticion,strlen(sPeticion),0);
    if(nEnviados == -1)
     fprintf(stderr,"No se pudo enviar la peticion al servidor");
    nRecibidos=0;
    while(strstr(sBuffer,"\r\n.\r\n") == NULL)
    {
     nRecibidos+=recv(sock,sBuffer+nRecibidos,1024,0);
     sBuffer[nRecibidos]='';
    }
 
   }
  }
 }
 return sBuffer;
}
 
/*
Funcion:
 cddb_Suma: Devuelve un número sacado a través de una suma de cifras.
Parámetros:
 nDuracion: Duración en segundos de una pista.
Descripción:
 Esta función se encarga de sumar todas las cifras de distinto peso entre si para posteriormente devolver el resultado.
*/
int cddb_Suma(int nDuracion)
{
 int nSuma = 0;
 
 while (nDuracion > 0) {
  nSuma = nSuma + (nDuracion % 10);
  nDuracion = nDuracion / 10;
 }
 
 return nSuma;
}
 
/*
Funcion:
 cddb_IDDisco: Devuelve en número que identifica al CD inequivocamente.
Parámetros:
 toc: Información de la tabla de contenidos del CD
Descripción:
 Esta función se encarga de calcular el identificador único de un CD a través de su tabla de contenidos
*/
unsigned long cddb_IDDisco(CDROM_TOC *toc)
{
 int nIndice=0,
  nTotalTiempo = 0,
  nSumatorio = 0;
 int nTotalPistas;
 
 nTotalPistas=toc->LastTrack-toc->FirstTrack+1;
 
 while (nIndice < nTotalPistas) {
  nSumatorio = nSumatorio + cddb_Suma((toc->TrackData[nIndice].minutos * 60) + toc->TrackData[nIndice].segundos);
  nIndice++;
 }
 
 nTotalTiempo = ((toc->TrackData[toc->LastTrack].minutos* 60) + toc->TrackData[toc->LastTrack].segundos) -
     ((toc->TrackData[0].minutos * 60) + toc->TrackData[0].segundos);
 
 return ((nSumatorio % 0xff) << 24 | nTotalTiempo << 8 | nTotalPistas);
}
 
int main(int argc, char *argv[ ])
{
 CDROM_TOC toc;
 char sIDDisco[9];
 char *sBuffer;
 
 if(argc==2)
 {
  memset(&toc,0,sizeof(CDROM_TOC));
 
  lee_CDTOC(argv[1],&toc);
  if(toc.LastTrack>0)
  {
   sprintf(sIDDisco,"%08x",cddb_IDDisco(&toc));
   printf("El ID del disco es %s\n",sIDDisco);
 
   sBuffer=(char *)malloc(4096);
   if(sBuffer == NULL)
   {
    fprintf(stderr,"No se pudo alojar memoria");
    return 1;
   }
   *sBuffer='';
   lee_InfoCDDB(sIDDisco,sBuffer);
   if(*sBuffer=='')
    return 1;
   printf("La información del disco es:\n%s",sBuffer);
   free(sBuffer);
  }
  else
   return 1;
 }
 else
 {
  fprintf(stderr,"La sintaxis es: %s <dispositivo de cd>\nEjemplo: %s /dev/cdrom\n",argv[0],argv[0]);
  return 1;
 }
 
 return 0;
}

El problema de los webchat es que la inmensa mayoría de los que existen se dedican a refrescar la página de la charla cada X tiempo o cuando el usuario ha escrito un mensaje. Esto es debido a que el protocolo HTTP esta diseñado para que una vez recibido los datos cierre la conexión, y si queremos recuperar datos nuevos tenemos que hacer una nueva petición.

Para lograr una interactividad y un realismo temporal cercanos al irc, messenger, etc. y seguir usando la web tenemos que usar un truco, y es crear una página que nunca termine de ejecutarse. Quizá os pregunteis que si nunca termina de ejecutarse, entónces no saldrá ningún resultado, pues bién, podemos desactivar el buffer del php desde el principio o hacer un volcado continuo para que cada dato nuevo se vaya enviando al navegador del cliente. Los navegadores muestran el contenido según les va llegando, por lo que una sentencia como esta (en pseudocodigo):

mientras verdadero
recupera mensajes nuevos
muestra mensajes nuevos
fin del mientras

haría que cada vez que un mensaje nuevo apareciese se enviase al navegador y este lo mostrara instantaneamente, con lo que habríamos conseguido que fuese el tiempo real.

Parar lograr este planteamiento en php tenemos que seguir los siguientes pasos (he reducido su código para simplificarlo):

ob_start();

Que activa el tratamiento del buffer en php

set_time_limit(0);

Indica al motor de php que el script nunca debe caducar a pesar de lo que dure.

for(;;)
{

Este es el bucle que constantemente se va repitiendo.

$rs=mysql_query(“SELECT * FROM chat_mensajes WHERE IDMensaje>’” . $id . “‘ AND WEEK(DatFecha,1)=WEEK(NOW(),1) AND YEAR(DatFecha)=YEAR(NOW()) ORDER BY IDMensaje”)
or die (“No se puede realizar la consulta”);

En mi caso guardo los mensajes en una base de datos mysql, por lo que con la consulta SQL compruebo aquellos mensajes cuyo ID sea mayor que el último ID de mensaje que se ha mostrado (solo aquellos dentro de la semana actual del año en curso).

if(mysql_num_rows($rs)>0)
{
while($fila=mysql_fetch_array($rs,MYSQL_ASSOC)) {

Compruebo si hay nuevos mensajes y los recorro.

$id=$fila["IDMensaje"];

Voy actualizando la variable id para que contenga al final el último ID y así en la siguiente pasada del bucle solo recoger los últimos mensajes escritos a partir del indicado.

echo “<div>\n”;
echo “<span>” . $fila["DatFecha"] . ” ” . “</span>”;
echo “<span>” . $fila["StrUsuario"] . “&gt;</span>”;
echo “<span>” . $fila["StrMensaje"] . “</span>”;
echo “</div>\n”;
}

Se va mostrando el contenido de los mensajes (fecha, remitente y mensaje).

echo “<script>scrollTo(0,999999999);</script>\n”;
ob_flush();
flush();
}

Con un pequeño truco en javascript logramos desplazar la ventana del navegador siempre hasta el final del contenido. A continuacuón vaciamos el buffer hacia el navegador del cliente.

sleep(1);
}

Para no recargar mucho el servidor mysql haciendo constantemente consultas, pausamos durante un segundo la ejecución para después continuar con la siguiente iteración del bucle.

Quizá penseis que esta solución recarga mucho el servidor (tanto el web como el de mysql), pero el impacto es mínimo y si teneis un hosting esto os ahorrará ancho de banda puesto que gasta más por usuario el estar haciendo peticiones al servidor web cada X tiempo que una sola petición que dure eternamente (solo gasta lo que envia, como una petición normal); en cuanto al servidor mysql si este esta en localhost (como el 99% de los hosting) el impacto es mínimo porque no consume ningún recurso de red, además de que el propio mysql es rapídisimo y eficiente haciendo las consultas y no mermará el rendimiento por estar haciendo una cada segundo por cada usuario. Sin embargo si no quereis usar mysql, podeis usar ficheros (fopen) o bién memoria compartida (Shmop). Por supuesto esto no es la panacea, pero para cosas pequeñas (20 personas a la vez) si puede ir bién tenerlo así montado.

En la web en la que colaboro tengo implementado este sistema, que aunque lo tengo bastante desarollado, todavía tengo que mejorar ciertos aspectos de funcionalidad.

El caso es que el hecho de tener un montón de imágenes almacenadas no es la mejor solución para un hosting si no tienes mucho espacio, por lo que se me ocurrió recurrir a la sección de imágenes de google. En esta sección se muestran en formato thumbnail (imágen pequeña de referencia) todas las imágenes de las páginas web que en su día indexó google, por lo que además de tener un vasto repertorio de imágenes, todas ellas estan asociadas al texto de la web a la que pertenecen. Así, si buscamos por palabras, podemos encontrar imágenes que concuerden con la búsqueda.

A mi me viene de lujo para mis intenciones, puesto que poniendo star wars en el cuadro de texto de la sección de imágenes de google aparecen algo menos de un millón de resultados. Añadiendo que la sección que quería poner en la web era más bién pequeña, las imágenes thumbnail de google son perfectas en cuanto a dimensiones para que quepa en la sección de la web.

Ahora bién, ¿como hacer para que los thumnails que google ha generado salgan en la web como propios?…Pues gracias a php puedo leer el contenido de las urls y mostrarlo con una cabecera apropiada como si fuera una imagen normal y corriente.

1-Una imagen en HTML se hace con la etiqueta IMG y el atributo src. En mi caso la imágen aletoria de la web debería apuntar siempre a un mismo sitio ya que es el propio php quien mostraría una imagen distinta cada vez. Por lo que en la web si os habeis fijado aparece:

<img src=”aleatorio.php” alt=”Imagen aleatoria (Gracias a Google Images)”>

Que indica al navegador que debe mostrar la imagen que genera la página aleatoria.php (con esto os podeis imaginar que los nombres de los ficheros le importan un pimiento al navegador, solo le interesa las cabeceras que devuelva el servidor)

2-Ahora tenemos que programar el código que recupere y muestre los bytes de la imagen que se quiere escoger al azar. Para ello debemos coger las imagenes de google, pero ¿como?. Pues antes de mostrar nada de código, voy a explicar muy por encima como funciona la sección de imágenes de google:

Voy a http://images.google.es/ y pongo como busqueda star wars

Me salen 20 imágenes, y unos enlaces para ir avanzando en el catálogo de imágenes. Sin embargo los thumbnails que aparecen son todavía un poco grandes para la sección de la web, por lo que elijo la opción Medianas, ahora pulsaremos por ejemplo sobre la página 3 del catálogo. Si os fijais a medida que he ido pulsando enlaces la url aparece con más datos:

http://images.google.es/images?q=star+wars&imgsz=small%7Cmedium%7Clarge%7Cxlarge&svnum=10&hl=es&lr=&start=40&sa=N

Esto es lo que nos servirá como primer punto para la busqueda de imágenes relacionadas con un tema determinado. Si os fiajis en los parámetros de la url está la letra q, donde se almacena el criterio de la búsqueda (en mi caso star+wars); imgsz, que indica el tamaño de las imágenes a buscar (puede ser también xxlarge e icon, aunque en mi caso es small%7Cmedium%7Clarge%7Cxlarge); svnum que no se para que sirve, ya que si lo quito funciona igual; hl para el idioma de los resultados; lr que tampoco sé para que sirve, start que indica desde que indice empezar, este es muy importante ya que aqui usaremos el primer número aleatorio; sa=N que no se para que sirve.

Como os comentaba, con start se puede indicar desde que índice de las imágenes empezar a mostrar: 0 sería desde la primera página, 20 desde la segunda página, 40 desde la tercera, etc. También podemos poner valores intermedios, pero yo sigo el camino de google con sus enlaces.

Una vez que ya podemos elegir que página de imágenes queremos cargar, ya solo queda elegir que imagen de las 20 que aparece en esa página mostrar, momento por el cual debemos usar el segundo número aleatorio. Pero claro, lo que nos interesa son las imágenes de google, no las originales a las que apunta el enlace de cada una de ellas. Por eso debemos recorrer el codigo fuente HTML de la página que hemos recuperado para ir etiqueta por etiqueta IMG hasta alcanzar el número aleatorio que habiamos solicitado. Sin embargo no podemos empezar desde el principio puesto que google tiene en su página un logo, unas imagenes de 1 pixel de grosor, etc. Es por ello que debemos comenzar a partir de un punto donde sepamos que a continuación todas las etiquetas IMG son las de los thumbnails. En mi caso uso la cadena “Solamente se muestran las“.

A partir de entónces, cuando ya obtengamos el atributo src de la etiqueta IMG requerida, ya podremos recuperar los bytes de la imagen thumbnail de google a través de su url. Posteriormente solo queda mostrarla a través del PHP.

El siguiente código fuente muestra como lo hacer lo que he comentado anteriormente desde una página php:

<?
// Hacemos que nunca se cachee ninguna imagen
header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("Cache-Control: no-store, no-cache, must-revalidate");
header("Cache-Control: post-check=0, pre-check=0", false);
header("Pragma: no-cache");
 
//elegimos una sección al azar de las imagenes de google
$texto="";
mt_srand((double)microtime()*1000000);
$inicio = mt_rand(0,20)*20;
$url="http://images.google.es/images?q=star+wars&imgsz=small%7Cmedium%7Clarge%7Cxlarge&hl=es&lr=&start=$inicio&sa=N";
 
// abrimos la url generada dinamicamente
$fichero=fopen($url,"r");
while(!feof($fichero))
$texto.=fread($fichero,1024);
fclose($fichero);
 
// dentro de la página devuelta, elegimos una imagen al azar
$indice = mt_rand(1,20);
// para ello debemos recorrer todas las etiquetas IMG desde una posición determinada
$posicion=strpos($texto,"Solamente se muestran las");
for($contador=0;$contador<$indice;$contador++)
$posicion=strpos($texto,"<img",$posicion)+4;
$posicion=strpos($texto,"src=",$posicion);
 
// cogemos la url de esa imagen de thumbnail de google
$url="http://images.google.es" . substr($texto,$posicion+4,strpos($texto," ",$posicion)-$posicion-4);
$texto="";
 
// la abrimos para recuperar su contenido
$fichero=fopen($url,"r");
while(!feof($fichero))
$texto.=fread($fichero,1024);
fclose($fichero);
 
// mostramos la cabecera acorde con el tipo de fichero
switch(substr($url,strrpos($url,".")))
{
case ".gif":
header("Content-type: image/gif");
break;
case ".png":
header("Content-type: image/png");
break;
default:
header("Content-type: image/jpeg");
break;
}
// y finalmente mostramos el contenido de la imágen recuperada
echo $texto;
?>

Podeis ver un ejemplo de su funcionamiento en la web que os indicaba arriba o directamente en este enlace http://www.starwarsspanishstuff.info/aleatorio.php.

Recomiendo poner en el texto alternativo un reconocimiento a google.

typedef unsigned int (*funcion)(const char *);
funcion pepe;
pepe=strlen;
printf("Longitud de hola:%d\n",pepe("hola"));

Pero que pasaría si en vez de asignarle una función le asignamos una variable? Pues
que el contenido de esa variable lo ejecutaría. Por supuesto, la variable no puede tener cualquier contenido; los bytes que contendría deberían ser codigo maquina. Por ejemplo el siguiente código en ensamblador:

MOV EAX,9
RET

traducido a codigo máquina del intel x86 sería:

B8 09 00 00 00
C3

Por lo que si ejecutamos las siguientes lineas:

typedef unsigned int (*funcion)(void);
funcion pepe;
unsigned char juan[]={0xb8,9,0,0,0,0xc3};
pepe=(unsigned int (*)(void))(void*)juan;
printf("Es un 9?:%d\n",pepe());

Lo que hemos hecho es llamar a una dirección de memoria que contenia una ristra de bytes, los cuales son significativos para el microprocesador. En el ejemplo hemos asignado al registro EAX (registro que almacena siempre lo que devuelve una función) el número 9 y a continuación ejecutamos un RET para retornar de la llamada de la función. Así hemos simulado una llamada a una función tal y como lo habría hecho el compilador, pudiendo incluso modificar el código (el contenido de la variable) en tiempo de ejecución sin problemas de violaciones de memoria o similares. Este código funciona tanto en Linux como en Windows siempre que sea un micro intel x86, aunque se puede usar en un motorola, power pc, o lo que querais siempre que conozcais el
lenguaje maquina del micro.

Este artículo dará pie a otro mucho más avanzado sobre como lograr que un programa original pueda acceder a un web service sin que otros se aprovechen de esa información (si usar contraseñas ni nada parecido).

¡¡¡ Estamos de Enhorabuena !!!

Esto no tiene ningún misterio, pero… ¿y si se trata de encenderlo?. Puede que con el solo hecho de pulsar el botón de encendido de la cpu nos sea suficiente (a veces con pulsar un botón del teclado o mover el ratón), sin embargo cuando no estamos físicamente presentes la cosa cambia: un cibercafe donde es más cómodo encender todos los ordenadores a la vez, o encender un ordenador remoto que por las noches se apaga para ahorrar electricidad, etc. Antiguamente los ordenadores se apagaban y punto, pero desde que irrumpió en el mercado el formato ATX de cajas y placas madre y con el estandar ACPI la cosa no ha hecho más que facilitarnos las cosas: ahora gracias a esos dos estandares somos capaces de apagar el ordenador por software, apagar el equipo ordenadamente por hardware, suspender, volver a reactivar, volver a encender, etc. En la parte que nos toca hay unos eventos que son capaces de encender un ordenador cuando este está apagado, y para la gestión remota de ese encendido se puede usar unos metodos denominados wake on ring, wake on modem (por modem) o wake on lan (por red).

Este artículo se centra en el método Wake On Lan (+ o – despertar por red). Este sistema se basa en que un ordenador cuando se apaga, no lo hace totalmente, sino que la fuente de alimentación sigue alimentando a la placa madre, y esta puede gestionar con muy bajo consumo los eventos que se den, como por ejemplo, encender el ordenador cuando recibe un paquete especial por la tarjeta de red. Este paquete, conocido como Magic Packet es muy simple y su formato consiste en 6 bytes con valor hexadecimal FF y otros 16 grupos de 6 bytes con la dirección MAC de la tarjeta de red. Da igual en que protocolo se envié ese paquete (IPX, TCP/IP, etc), con tal de que se envíe por toda la red. Así si se quiere encender un ordenador con una MAC 01:02:03.04:05:06 se enviaría un paquete con estos bytes en hexadecimal:

FFFFFFFFFFFF
010203040506010203040506010203040506010203040506
010203040506010203040506010203040506010203040506
010203040506010203040506010203040506010203040506
010203040506010203040506010203040506010203040506

El paquete debe enviarse a toda la red, por lo que hay que intentar que sea con el protocolo que se haga, este debe permitir enviar paquetes broadcast. Esto normalmente se puede conseguir con el protocolo IP, ya que poniendo como destinatario la dirección IP 255.255.255.255 debería llegar a todos los nodos de todas las redes que lo permitan. El TCP o UDP que venga por encima no es importante, aunque personalmente prefiero el UDP por no ser orientado a conexión. Por encima del UDP vendrá el magic packet. A continuación pongo un ejemplo de codigo fuente en varios lenguajes de programación para que podais probarlo (son tan cortos que no hacen falta comentarlos, tampoco tienen gestión de errores para su simplicidad), en vuestro caso solo tendrías que modificar el puerto (1976) y la dirección MAC (01:02:03:04:05:06):

C para Linux/Unix y Windows

#ifdef WIN32
 #include <stdio.h>
 #include <winsock2.h>
#else
        #include <sys/types.h>
        #include <sys/socket.h>
        #include <netinet/in.h>
#endif
void main(void)
{
 int conexion;
 struct sockaddr_in direccion;
 unsigned char buffer[102];
 unsigned char mac[]={0x01,0x02,0x03,0x04,0x5,0x06};
 int valor=1,contador;
#ifdef WIN32
    WSADATA wsaData;
    WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
#endif
 for(contador=0;contador<6;contador++)
  buffer[contador]=0xff;
 for(contador=6;contador<102;contador+=6)
  memmove(&buffer[contador],mac,6);
 memset(direccion.sin_zero,0,8);
 direccion.sin_family=AF_INET;
 direccion.sin_addr.s_addr=htonl(INADDR_BROADCAST);
 direccion.sin_port=htons(1976);
 conexion=socket(AF_INET,SOCK_DGRAM,0);
 valor=setsockopt(conexion, SOL_SOCKET, SO_BROADCAST, (char *)&valor, sizeof(int));
 sendto(conexion,(char *)buffer,102,0,(struct sockaddr *)&direccion,sizeof(struct sockaddr_in));
#ifdef WIN32
 WSACleanup();
#endif
}

Perl

use strict;
use IO::Socket::INET;
 
my $socket;
my $msg;
my $contador;
 
$socket=new IO::Socket::INET->new(PeerPort=>1976,
        Proto=>'udp',
        PeerAddr=>'255.255.255.255',
        Broadcast=>1
);
$msg="";
for($contador=0;$contador<6;$contador++)
{
        $msg.="\xff";
}
for($contador=0;$contador<16;$contador++)
{
        $msg.="\x01\x02\x03\x04\x05\x06";
}
$socket->send($msg);

Java

import java.net.*;
import java.io.IOException;
 
public class Wol
{
 public static void main(String args[])
 {
                byte mac[]={0x01,0x02,0x03,0x04,0x05,0x06};
  byte buffer[]=new byte[102];
  byte contador;
 
  for(contador=0;contador<6;contador++)
   buffer[contador]=(byte)0xff;
  for(contador=6;contador<102;contador+=6)
   System.arraycopy(mac,0,buffer,contador,6);
  try
  {
   DatagramSocket udp=new DatagramSocket();
   udp.setBroadcast(true);
   udp.send(new DatagramPacket(buffer,102,InetAddress.getByName("255.255.255.255"),1976));
  }
  catch(java.net.SocketException se)
  {
   System.err.println(se);
  }
  catch(java.net.UnknownHostException ue)
  {
   System.err.println(ue);
  }
  catch(java.io.IOException ie)
  {
   System.err.println(ie);
  }
 }
}

Visual Basic (Para que funcione debeis insertar un control Winsock)

Dim buffer() As Byte
Dim contador As Byte
 
ReDim buffer(101) As Byte
For contador = 0 To 5
 buffer(contador) = &HFF
Next
For contador = 6 To 101 Step 6
 buffer(contador) = &H1
 buffer(contador + 1) = &H2
 buffer(contador + 2) = &H3
 buffer(contador + 3) = &H4
 buffer(contador + 4) = &H5
 buffer(contador + 5) = &H6
Next
Winsock1.Protocol = sckUDPProtocol
Winsock1.RemoteHost = "255.255.255.255"
Winsock1.RemotePort = 1976
Winsock1.SendData buffer

Por supuesto no hay método que sirva para marcar todas las tarjetas a la vez, así que habrá que ir una por una mandando el magic packet para que se vaya encendiendo cada ordenador. La tarjeta de red de cada ordenador apagado compara todos los paquetes que le llegan del tráfico de red para ver si contiene 16 veces su dirección MAC y así mandar a la placa madre que encienda el ordenador.

Las tarjetas de red que vengan incorporadas ya de fábrica en la placa madre ya tienen esta función activada. Sin embargo las que estan sueltas en ranuras PCI o ISA, deben:
1) Permitir el wake on lan (no todas tienen un firware con esa posibilidad)
2) La placa madre debe tener un conector de 3 pines que permita este evento.
3) Un cable que vaya desde la tarjeta hasta la placa madre.
En ambos casos se debe activar en la BIOS el mantenimiento de energía y posteriormente el evento WAKE ON LAN.

En mi portatil no puedo probar esta característica (cuando se apaga este, la tarjeta ethernet incorporada también se apaga). En el ordenador de sobremesa no me ha funcionado (tampoco funcionan eventos como el de encender el ordenador con una pulsación del teclado) y con el servidor me ha funcionado perfectamente.

El Magic Packet también se puede hacer desde Internet:
Si teneis conexión directa solo debeis modificar vuestro programa para que apunte a vuestra IP pública de Internet (si no es fija podeis usar cosas como dyndns).
Si no teneis conexión directa o no quereis usar un programa, podeis hacerlo desde aquí.
Sin embargo, a no ser que tengais un router que este conectado a Internet y donde podais poner rutas estáticas con IP, puertos y direcciones MAC no podreis hacerlo funcionar, ya que el router (como el mio) borra de la tabla arp las relaciones MAC/IP cuando detecta que no hay tráfico en una tarjeta determinada, por lo que aunque reciba un paquete que luego deba reenviar a una ip interna, lo ignora al no encontrarlo en la tabla; tampoco tiene opción para redireccionarlo como broadcast dentro de la red si no sabe que hacer con el.