El arte de programar

Me cambio de vecindario

2008-01-26T20:43:00.000+01:00

Dejo blogger para publicar un blog en mi propio dominio. A partir de ahora escribiré en este y todos los artículos que hay en el actual los iré copiando al nuevo. Si quereis cambiar vuestros enlaces al nuevo, la url es:

http://www.sistemasorp.es

Wardriving con la fonera

2007-02-01T10:37:00.000+01:00

La fonera es para mi un ordenador con muchas posibilidades. La verdad es que tenerlo solo para compartir la conexión de internet me parece subestimar todo su potencial. Entre las muchas cosas que pueden hacerse con ella (la imaginación es el único limite), una de ellas es hacer wardriving. Hasta ahora el wardriving se hacía con un portatil o una pda que tuviese wifi y gps (ambos en módulos separados o integrados en el hardware) pero eso ha cambiado...

Antes de empezar quiero comentar que todo esto es experimental, y que no me hago responsable de los daños que pudierais ocasionaros a vosotros mismos o a cualquier cosa implicada en el proceso.

Pues bien, la principal ventaja del sistema de wardriving que he estado desarrollando es que es mucho más barato que las soluciones anteriormente citadas, por lo que paso a detallar lo necesario para fabricarse un sistema de wardriving con la fonera (los enlaces son méramente orientativos, no me llevo ninguna comisión por ellos):

Como es lógico, es necesario una fonera, que cuesta unos 30 € en fon (o menos si lo compras en ebay o incluso si te la regalan).

Un módulo gps que funcione a 3,3 voltios, que cuesta alrededor de 40 €. Aunque si se tiene ya un gps de mano con conexión serie se puede hacer un circuito con un chip max3232 (que no 232).

Una antena wifi omnidireccional con imán y conector rp-sma ideal para ponerla en el techo del coche, por unos 17 €. Aunque se puede usar la antena que viene en la fonera (con lo que habrá menos cobertura).

Finalmente un adaptador de mechero para el coche de 5 voltios y 2 amperios por unos 12 €. En mi caso me compré un adaptador de mechero para la PSP que también reúne las características necesarias y que modifiqué ligeramente para poder enchufarlo a la fonera.

Para unir el GPS al puerto serie de la fonera me fabriqué un pequeño cable que va unido a un circuito, y este a su vez a la fonera través de un cable IDE.

Al final uniendo todos los componentes quedaría así:

Para hacer funcionar el invento necesitáis instalar en la fonera el firmware OpenWRT Kamikaze, en La Fonera Developers Forum podeis encontrar un artículo estupendo de como hacerlo. Si no lo hago con el firmware que trae por defecto FON es simplemente porque la fonera no arranca si no encuentra una conexión de red válida (y en el coche no tendremos red alguna) además de que usa el led de WLAN que nosotros aprovecharemos para otro tema.

Ahora por la parte software programé un demonio el cual se encarga de escanear las redes wifi al mismo tiempo que va tomando la posición GPS. El demonio se llama fonerawd y guarda los resultados del escaneo en el directorio /www/wifispots, creando un fichero con la mac de cada red detectada y guardando dentro de este el SSID de la red, el tipo de conexión, si está encriptada o no y su latitud y longitud (si no existe GPS pondrá error, si no tiene señal será 0); todos estos campos están separados por el carácter barra "|".

El puerto serie de la fonera lo programé gracias a este artículo que explica como hacerlo en modo canónico, que es ideal para recibir las lineas de datos del protocolo NMEA del GPS. El escaneo de redes lo hice basándome en este artículo que aunque no explica como hacerlo, el código fuente es suficientemente descriptivo.

Este software esta bajo licencia GPL y lo podéis descargar aquí:

http://www.sistemasorp.net/blog/fonerawd.tar.gz

Aunque ya viene el ejecutable probablemente queráis compilarlo por vosotros mismos, por lo que además de seguir las instrucciones que publiqué en un reciente artículo, debéis compilarlo incluyendo una librería y un directorio de includes de la siguiente forma:

mips-linux-uclibc-gcc -I../fonera/staging_dir_mips/usr/include -L../fonera/staging_dir_mips/usr/lib -liw -o fonerawd fonerawd.c

Donde la ruta ../fonera la debéis cambiar a la ruta donde tengáis el toolchain.

Una vez compilado el ejecutable debéis descargarlo a la fonera en el directorio /usr/bin

wget http://xxx.xxx.xxx.xxx/fonerawd
mv fonerawd /usr/bin

donde xxx.xxx.xxx.xxx es la ip de un servidor web. Después hay que darle permisos de ejecución

chmod +x /usr/bin/fonerawd

Ahora debemos hacer unas modificaciones en el kamikaze:

1) Editar con el vi el fichero /etc/inittab y desactivar el entrada por consola comentado la linea tts/0::askfirst:/bin/ash --login con una almohadilla "#". Esto hará que los comandos NMEA del GPS enviados al puerto serie no provoquen el crear una sesión shell por el puerto serie ya que contienen un retorno de carro y el linux lo confundiría con la pulsación de la tecla ENTER.

2) Poner una ip fija en la fonera para luego poder entrar en ella sin tener que adivinar que IP tiene. Para ello editamos con el vi el fichero /etc/config/network y ponemos esto en la interfaz lan (la ip puede ser cualquier otra de vuestro segmento de red):

config interface lan
option ifname eth0
option proto static
option ipaddr 192.168.0.12
option netmask 255.255.255.0

3) Instalar el modulo proc_gpio citado en este artículo. Para ello debéis copiar el fichero proc_gpio.ko en el directorio /lib/modules/2.6.19.1 . Esto nos permitirá tener control sobre la luz WLAN de la fonera.

4) En el directorio /etc/init.d crear un fichero con el vi llamando red y le añadís las siguientes líneas:

#!/bin/sh /etc/rc.common

start () {
wlanconfig ath0 destroy
wlanconfig ath0 create wlandev wifi0 wlanmode sta
ifconfig ath0 up
insmod proc_gpio.ko
echo 1 > /proc/gpio/2_dir
echo 1 > /proc/gpio/2_out
/usr/bin/fonerawd
}

stop () {
echo "hola"
}

Y le damos permisos de ejecución. Finalmente debéis crear un enlace a este fichero desde el directorio /etc/rc.d de la siguiente forma:

ln -s /etc/init.d/red S76red

Esto hará que cuando se arranque la fonera y busque en el directorio rc.d que scripts deben ejecutarse, se ejecute el script llamado red. Este script crea una interfaz wireless llamada ath0 en modo cliente para poder escanear las redes wifi, luego el módulo proc_gpio hará que se encienda la luz de WLAN, señal que indica que el demonio fonerawd esta cargado y podemos conectar el gps al puerto serie de la fonera (y no antes).

El proceso a seguir sería el siguiente:

1) Ponéis la fonera en el salpicadero del vehículo.

2) Ponéis la antena en el techo del vehículo y pasais el cable al interior a través de la ventanilla conectándola a la fonera.

3) Enchufáis el adaptador al mechero del coche y el otro extremo de este a la fonera.

4) Cuando la luz de WLAN este encendida conectar el módulo GPS.

Un resultado de una de mis salidas haciendo wardriving se puede ver en http://www.sistemasorp.net/fonerawd

Hacer wardriving no conlleva que te conectes a las redes wifi necesariamente, simplemente se trata de listarlas, por eso este proyecto solo lista las redes y no hace nada más con ellas, siendo 100% legal.

El próximo proyecto que tengo en mente es hacer que la fonera con el firmware de FON pueda actuar como interfaz entre internet y un PIC 16F628 para hacer domótica.

Actualización 04/02/2007:

Añado un video sobre una sesión de wardriving con la fonera:

A pesar de que en el vídeo somos dos personas, en las sesiones de wardriving con la fonera solo es necesario el conductor, ya que la fonera se encarga de hacerlo todo ella sola (eso si, poned el gps cuando la luz de WLAN esté en verde y antes de movilizar el vehículo).

Creo que también es necesario un pequeño esquema de como se deben conectar los pines del gps que he utilizado para las sesiones con los pines de la fonera:

Sun Solaris 10 en mi casa

2006-12-28T22:53:00.000+01:00

Después de tres semanas de haber rellenado el formulario para que me enviasen los dvd del sistema operativo Solaris 10 (uno para SPARC y otro para 32 y 64 bits) y las herramientas de desarrollo Sun Studio 11, finalmente ha llegado:

Me gusta mucho linux, pero tener un unix en mis manos (y próximamente en mi ordenador) es un placer de informático :)

Fuentes del proyecto de domótica

2006-12-23T11:36:00.000+01:00

Como muchos me habéis pedido aquí dejo las fuentes del proyecto de domótica:

Esta obra está bajo una licencia de Creative Commons.

Luces: (Visual C++ 6.0) El corazón del sistema software. Este es el encargado de abrir el puerto tcp 1976 para recibir conexiones, validar usuarios, enviar por el puerto paralelo las ordenes que estos dicten entre otras cosas. Podeis descargar el programa compilado, con su base de datos y su fichero .ini aquí (Recordad que para ejecutarlo en windows NT, 2000, XP o 2003 debeis usar el allowio)

Web: (DHTML y ASP) Interfaz web para poder usar el sistema mediante un navegador o un móvil con WEP.

Applet: (Visual J++) Applet de java para la interfaz web, la cual muestra en tiempo real los cambios de los aparatos eléctricos.

Remoto: (Visual C++ 6.0) Aplicación para gestionar los comandos de un mando a distancia por infrarrojos.

SMS: (Visual C++ 6.0) Aplicación para gestionar los comandos de mensajes cortos por móvil.

Me hubiera gustado modificar los fuentes para dejarlos más claros, elegantes e incluso más eficientes, pero no he tenido tiempo hasta ahora y no lo tendré en un tiempo futuro, por lo que los pongo tal como los dejé.

Compilando programas para la fonera

2006-11-11T09:57:00.000+01:00

Hace poco leí un artículo en barrapunto donde descubrí (un poco tarde, ya lo sé) que la fonera tenía ssh (y por ende linux embebido).

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 ;)

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

2006-11-05T21:26:00.000+01:00

Hola a todos de nuevo. La espera se ha hecho larga (¡¡¡ casi 7 meses !!!), pero es porque me enfrasqué en otros proyectos y he sacrificado el tiempo del blog para poder desarrollarlos, aunque siempre he estado pendiente de los comentarios. Uno de ellos (que no el único) ha sido el de crear Hora y Lugar: una web para crear recordatorios de citas y que ha quedado cuarta en el concurso de Google Maps España.

Como broche final a esta serie de artículos, expongo la interfaz por antonomasia que hace que la domótica cobre un nuevo sentido. Y esa es manejar el sistema mediante el móvil. Ya no se trata de estar en casa o de tener una conexión a internet, sino de prácticamente poder usar nuestros aparatos desde cualquier lugar (donde haya cobertura claro). En esta ocasión es a base de SMS, que todo el mundo sabe escribir y son relativamente baratos, aunque en un futuro añadiré la funcionalidad de centralita, donde una voz te pregunta e informa y tu envías comandos mendiante tonos DTMF (pulsando las teclas del teléfono) o bién mediante voz; todo ello usando TAPI.

Usando el móvil que ya todos conoceis desarrollé la interfaz para poder tratar los mensajes recibidos y traducirlos en comandos para el sistema. Para iniciarlo se carga el programa SMS indicandole en que puerto esta eschuchando el móvil y cual es la dirección del servidor.

Cuando queramos hacer algo, escribimos un mensaje sms con el formato usuario contraseña comando.

Cuando el móvil recibe el mensaje, el programa SMS que esta comprobando si ha recibido un mensaje cada cierto tiempo lo procesa, muestra el teléfono de origen, la fecha y la cadena enviada.

A continuación envía el comando al servidor y nos responde con otro mensaje sms indicando en que estado se encuentra el sistema después de haber procesado el comando.

De la aplicación se puede salir simplemente pulsando INTRO.

Aquí teneis un video donde podeis ver como funciona todo lo que he ido explicando en todos los artículos:

Si no podeis visualizarlo bién, el enlace es http://www.youtube.com/watch?v=-Y5wO0ydRxo

Y así acaba esta serie de artículos, esperando que os haya servido de utilidad y que os haya dado ideas de como implantarlo vosotros mismos (como ya muchos me habeis comentado). Mi idea es seguir desarrollandolo añadiendo nuevas funcionalidades como reconocimiento de voz, centralita (como ya he comentado más arriba) y más control en los aparatos (de ser un mero encender y apagar a poder manejar todas las funcionalidades).

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

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

2006-04-19T21:22:00.000+02:00

Después de un largo periodo de descanso empiezo a escribir el siguiente artículo sobre domótica.

Ya hemos tratado varias formas de acceder remotamente o localmente al sistema de domótica a través de TCP/IP. La cuestión es que hasta ahora las interfaces que necesitábamos para poder interactuar con el sistema necesitaban de un ordenador que se conectara al sistema central (que podía ser el mismo que contiene el sistema) para enviarle ordenes y recibir el estado. En este artículo trataremos una forma más "casera" de interactuar con el sistema.

Todo el mundo tiene un mando a distancia en su casa y/o sabe como usarlo, asi que con esta sencilla interfaz podemos interactuar con todos los aparatos del sistema de domótica simplemente interpretando las pulsaciones que recibe del mando a distancia (en mi caso mediante un puerto serie) y convirtiendolo en comandos del protocolo del sistema de domótica. Para ello cargamos el programa Remoto, que es una aplicación de consola, pasándole como parámetros el puerto serie, el servidor, el usuario y la contraseña. Este lo que hará es acceder mediante TCP/IP al servidor Luces con el usuario y contraseña dados y a continuación abrirá el puerto serie para empezar a recibir las señales infrarojas.

Cuando se pulsa el botón 1, 2, 3 o 4 del mando a distancia cambia el estado del aparato a encendido o apagado si se encuentra apagado o encendido respectivamente. Por supuesto tiene que haber visión directa entre el mando a distancia y el receptor (que puede no estar en la misma habitación que el ordenador al que esta enchufado).

De la aplicación podemos salir pulsando intro. El mando a distancia que tengo y el cable receptor lo obtuve de una capturadora de televisión, sin embargo si no teneis uno similar podeis comprar ya uno hecho de cualquier capturadora MIRO o AVERMEDIA o haceros vosotros mismos uno: http://www.tldp.org/linuxfocus/Castellano/March2000/article137.html.

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

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

2006-03-20T23:43:00.000+01:00

Al estar el sistema de domótica centralizado en un solo programa que escucha por un puerto TCP, se puede ampliar todo lo que sea necesario para cubrir todo tipo de necesidades de comunicación.

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)

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

2006-02-21T12:22:00.000+01:00

Para poder controlar el módulo por software se me planteaba una duda, ¿cómo hacer para que varios programas accediesen a este?. Todos tenían que ser ejecutables y ser lanzados con el Port Talk, sin embargo no era lo más optimo porque no había manera de saber que aparatos estaban encendidos y cuales no, además de que mi interés era controlar los aparatos no solo desde el propio ordenador donde estaba conectado el módulo, sino también a través de otros dispositivos.

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:

100	Saludo al nuevo cliente conectado
101	Estado en que se encuentran los aparatos (máscara)
200	Usuario introducido
201	Contraseña introducida
202	Permitir o denegar peticiones, cerrar programa o apagar equipo
300	Estado no identificado
301	Comando no reconocido
302	Fallo en la autentificación

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

USER:<usuario>	Usuario a validar
PASS:<contraseña>	Contraseña a validar
<Número>	Estado que se quiere aplicar a los aparatos (máscara)
OPEN	Permite a los usuarios no administradores manejar los aparatos
CLOSE	Deniega a los usuarios no administradores manejar los aparatos
QUIT	Cierra la aplicación
BYE	Apaga el equipo

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:

tblUsuarios	Donde se almacenan los usuarios del sistema y sus permisos
intID	Autonúmerico (o secuencia) que identifica al usuario inequivocamente
strNombre	Nombre del usuario
strApellidos	Apellido o apellidos del usuario
strLogin	Identificador del usuario para validarse en el sistema
strPassword	Contraseña del usuario para validarse en el sistema
blnActivo	Bandera que indica si un usuario puede validarse en el sistema o no
bytNivel	Nivel del usuario (100 administrador, 50 usuario normal, 0 visitante)
bytMascara	Máscara de permiso para aparatos: Si el usuario tiene por ejemplo 10 (1010 en binario) sólo puede utilizar los aparatos 2 y 4, en cambio los aparatos 1 y 3 únicamente puede ver su estado

tblAcciones	Donde se almacenan las distintas acciones del usuario
bytID	Autonúmerico (o secuencia) que identifica la acción inequivocamente
strAccion	Nombre de la acción (Usuario Validado, Usuario Desconectado, Orden y Comando)

tblLog	Donde se almacena la actividad que lleva a cabo el usuario
intID	Autonúmerico (o secuencia) que identifica la acción del usuario
intUsuario	Campo relacionado con el intID de la tabla tblUsuarios
bytAccion	Campo relacionado con el bytID de la tabla tblAcciones
datFecha	Fecha y hora de la acción
strIP	IP de la máquina donde se ordenó la acción
strDescripcion	Descripción de la acción

tblAparatos	Donde se almacenan los nombres de los aparatos a manejar
intID	Autonúmerico (o secuencia) que identifica el aparato inequivocamente
strNombre	Nombre del aparato

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

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

2006-02-12T19:14:00.000+01:00

Continuando la serie de artículos sobre aparatos que tengo, introduzco el último y más importante del sistema casero de domótica que he creado.

El kit o módulo que aparece en la fotografía pertenece a la familia de módulos a relé de la empresa CEBEK, cuyo código es T-1. Es un módulo que puede manejar hasta 4 relés a través de unos bornes de entrada. Tiene muchas ventajas, como que aisla la señal de entrada del resto del circuito con optoacopladores o como que usa un puente rectificador para la alimentación del circuito. El módulo se alimenta con una tensión de 12 voltios e intensidad de 200 mA (muchos transformadores pequeños de móvil u otros aparatos los proporcionan de sobra).

La idea es que con este circuito se puedan manejar aparatos eléctricos (incluidos electrodomesticos) desde el ordenador. Para ello, por una parte se usan los relés a modo de interruptor de un cable normal (en mi caso uso alargadores para no tener que pelar los de los aparatos eléctricos), por lo que en el circuito que uso podría manejar hasta cuatro aparatos distintos; por otra parte los cuatro bornes de entrada van conectados a cuatro de los ocho cables de datos de un cable paralelo.

Aprovechando que es muy sencillo acceder al puerto paralelo del ordenador y que las señales son de 5 voltios (más que suficiente para activar los optoacopladores) es posible mandar un byte al puerto de datos del paralelo (0x378) para que llegue a los bornes del circuito y posteriormente active los relés. ¿Como funciona la lógica de encender y apagar relés? pues cuando se manda un byte a través del puerto paralelo, los bits que esten a 1 hacen que los correspondientes pines del puerto paralelo se activen a 5 voltios, lo que en el circuito provoca finalmente que se activen los relés asociados. Asi por ejemplo si enviamos un 3, en binario es 0011, activándose los dos primeros relés. Con este sistema se pueden encender lámparas, calefacciones, microondas, lavadoras, persianas eléctricas, sistemas de riego, etc.

En windows 95, 98 y Millenium se puede acceder directamente al puerto paralelo, sin embargo en windows nt, 2000 y xp se necesita crear un driver que se ejecute en el nivel (ring) privilegiado 0, porque en el nivel 3 no se permite hacer directamente. Como tampoco quise perder tiempo en crear mi propio driver, usé un programa que ya hace todo eso de una forma muy sencilla: Port Talk, el cual, una vez instalado, da permiso a una aplicación (proceso) para que acceda a un puerto determinado (o a todos) desde la linea de comandos. Finalmente solo basta usar el método _outp en C para enviar datos al puerto paralelo:

_outp(0x378,3);

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

PC a móvil a PC

2006-01-26T23:07:00.000+01:00

Hace un tiempo desarrollé un gateway sms/mail/sms donde además del software, la pieza clave era esta:

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] = '\0';

 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] = '\0';

 return pchTransformado;
}

Manejar un ordenador con un mando a distancia

2006-01-08T22:33:00.000+01:00

En el mercado de hoy en día se venden tarjetas sintonizadoras de televisión para el PC. Muchas de ellas tienen mando a distancia. Y en algunas de ellas el receptor de infrarojos que trae es para conectarlo a un puerto serie del PC.

Al ser el receptor de infrarojos un conector para el puerto serie, es muy sencillo comprobar que información le envía el mando a distancia y tomar esos datos para aprovecharlos en futuras aplicaciones, como por ejemplo:

-Apagar el equipo.
-Cargar una aplicación
-Simular pulsaciones del teclado predefinidas o mover el puntero ratón y simular pulsaciones de los botones.
-Escuchar música y subir el volúmen de los altavoces
...

La forma sencilla de saber que datos manda y en que formato sin tener que investigar mucho es usar un sniffer del puerto serie. En mi caso he usado el portmon, que es una excelente utilidad para rastrear la información que va y viene desde los puertos serie y paralelo.

Si os fijais en la imagen, se muestra como inicializa el puerto a 1200 baudios, 8 bits de datos, ninguna paridad y 1 bit de stop. A continuación vienen los datos propiamente dichos. Para la prueba he pulsado el botón 1 del mando a distancia y el resultado es FE 9F 31, si hubiese pulsado el 2 el resultado sería FE 3D 32. Si lo observamos veremos que el 1 y el 2 (y el resto de números) coinciden con su representación ASCII en hexadecimal (31 y 32). En otros casos como la pulsación de las teclas de subir (FE F1 3B) y bajar (FE 64 3D) volumen o subir (FE 17 3F)y bajar (FE C6 3E) de canal muestran otros caracteres. En el caso de que dejáramos una tecla pulsada los códigos varían ligeramente, como en la imágen, que aparece el triplete FE 77 71 cuando se deja pulsado el botón 1 del mando a distancia.

En definitiva, da igual que sea en linux o en windows, podemos capturar estos tripletes y actuar en consecuencia con cada pulsación recibida (si se pulsa el botón de off apagamos el equipo, si pulsamos los botones de subir y bajar el volumen y los canales podemos manejar el puntero del ratón, con el mute podemos apagar el altavoz del equipo, con el botón de play podemos enviar un tabulador, con los números podemos escribir letras estilo sms, etc). Por supuesto, que esa información venga así en mi receptor de infrarojos no significa que sea igual en otros, de ahi que haya que mirar como funciona con utilidades como el portmon.

Recuperar los títulos de las canciones de un CD con FREEDB

2005-11-06T23:03:00.000+01:00

Desde hace mucho tiempo estan disponibles dos servicios en Internet cuyo cometido es almacenar una gigantesca base de datos con los títulos de las canciones de cualquier CD de música que se haya editado. La primera es Gracenote (también conocida antes del 2000 por cddb), de la cual no hablaremos en este artículo por requerir licencia. La segunda es freedb la cual sigue siendo gratuita y con una simple página web podemos consultar la información que nos interesa. En la sección developers podreis encontrar la información necesaria para trabajar con esta tecnología.

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), '\0', 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]='\0';
     }

    }
   }
  }
  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='\0';
   lee_InfoCDDB(sIDDisco,sBuffer);
   if(*sBuffer=='\0')
    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), '\0', 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]='\0';
    }

   }
  }
 }
 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='\0';
   lee_InfoCDDB(sIDDisco,sBuffer);
   if(*sBuffer=='\0')
    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;
}

webchat en tiempo real con php y mysql

2005-11-01T15:23:00.000+01:00

Después de un pequeño descanso volvemos a las andadas. Esta vez voy a mostrar como crear un webchat en tiempo real.

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"] . "></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.

Generar imágenes aleatorias con php y google

2005-09-06T14:33:00.000+02:00

Hace poco me planteé meter una sección de imágenes aleatorias en la web que estoy administrando junto con un amigo sobre coleccionismo español de la guerra de las galaxias.

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.

Ejecutar una variable

2005-07-28T18:04:00.000+02:00

Tal como se lee puede parecer algo un tanto extraño. Todo el mundo que programa usa las variables para leer o introducir datos en ellas (aunque a veces lo que se esta haciendo por debajo es realmente llamar a una función). El caso es que el C, y por extensión el C++ (ignoro si el C# tiene esta caracteristica) puede crear punteros a funciones. Estos punteros, como el resto, son una variable que contiene una dirección de memoria; sin embargo, su uso normal es asignarle el nombre de una función en vez de una variable, tal que así:

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

Por fin nos libramos de las patentes de software

2005-07-06T21:25:00.000+02:00

Después de haber luchado incansablemente por que las patentes de software no salgan adelante, después de haber explicado sus contras, después de habernos llevado grandes disgustos y pequeñas alegrías, por fín puedo decir que la propuesta de patentes de software en Europa ha sido definitivamente derogada contundentemente por 648 votos a favor, 14 en contra y 18 abstenciones.

¡¡¡ Estamos de Enhorabuena !!!

Wake On LAN y Magic Packet

2005-06-13T20:07:00.000+02:00

Todos sabemos que podemos apagar el ordenador con un comando o bién con una combinación de pulsaciones de teclado o ratón, también hay programas que dado cierto evento hacen que se apague el sistema.

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.

Ejecutar un programa sin sistema operativo

2005-05-03T23:04:00.000+02:00

Todo pc ejecuta código máquina: Ya sea en el arranque (La bios no es más que código máquina), en la carga del sistema operativo (el kernel esta programado en su mayor parte en código maquina) y en la ejecución de programas (el código fuente compilado o interpretado se transforma de una u otra manera en código máquina). Esta forma de trabajar hace que realmente no sea necesario un sistema operativo para ejecutar aplicaciones (y si me lo poneis dificil, hasta tampoco haría falta la bios). Es por ello que hay aplicaciones como los gestores de arraque (lilo, grub, nt loader), virus, etc que no necesitan de un sistema operativo para funcionar.

Siguiendo este camino, cualquiera podría crear una aplicación que, manteniendola y añadiendola nuevas funcionalidades, podría convertirse en el kernel que Linus Torvalds desarrolló de minix y que posteriormente se transformaría en linux.

Mi intención esta lejos de desarrollar un sistema operativo propio... aún :-), sin embargo a continuación pongo una aplicación, que ejecutada desde un disquete nada más arrancar el pc, muestra un menú y realiza operaciones básicas (chorras). Necesitareis un disquete ya formateado, el programa debug del msdos (por defecto en todos los windows) y que como primera unidad de arranque del pc sea la disquetera (próximamente hablaremos de como pasarlo a un cd mediante el estandar "el torito"). Para los linuxeros de pc, próximamente pondré algo parecido al rawrite. Las instrucciones para hacerlo funcionar son las siguientes:

1-cargad una consola msdos (en windows 9x: inicio/ejecutar/command, en windows nt,2000 o xp: inicio/ejecutar/cmd)

2-Insertad un disquete ya formateado en la disquetera y que no tenga nada importante (ya que perdereis toda la información que contuviera)

3-copiad el siguiente texto a un fichero de texto en vuestro disco duro (dejad al final un retorno de carro), por ejemplo codigo.txt:

a
jmp 1f7
db 'Seleccione una opcion del menu'
db '1- Mostrar hora'
db '2- Coche Fantastico'
db '3- Salir'
db 'Desarrollado por Oscar Rodriguez Parra http://sistemasorp.blogspot.com'
db '00:00:00'
db 'Fijese en las luces del teclado'
db 'Retire el disco o cd de la unidad de arranque y pulse una tecla'
cli
xor ax,ax
mov ss,ax
mov sp,7c00
mov es,ax
mov ds,ax
sti
mov ah,0
mov dl,0
int 13h
mov ax,201
mov bx,7e00
mov cx,2
xor dx,dx
int 13h
mov ax,3
int 10h
mov ax,1001
mov bh,1
int 10h
mov ax,1300
mov bx,2
mov cx,1e
mov dx,0119
mov bp,7c03
int 10h
mov ax,1300
mov bx,2
mov cx,0f
mov dx,0519
mov bp,7c21
int 10h
mov ax,1300
mov bx,2
mov cx,13
mov dx,0619
mov bp,7c30
int 10h
mov ax,1300
mov bx,2
mov cx,8
mov dx,0719
mov bp,7c43
int 10h
mov ax,1300
mov bx,4
mov cx,46
mov dx,1705
mov bp,7c4b
int 10h
mov ah,0
int 16h
push ax
mov ax,700
mov bh,0
mov cx,0900
mov dx,094f
int 10h
pop ax
cmp ah,2
je 29f
cmp ah,3
je 2fd
cmp ah,4
jne 29d
jmp 32f
jmp 278
mov ah,2
int 1ah
push cx
mov bx,7c91
mov al,ch
mov cl,4
shr al,cl
add al,30
mov [bx],al
inc bx
mov al,ch
and al,0f
add al,30
mov [bx],al
add bx,2
pop cx
mov ch,cl
mov al,ch
mov cl,4
shr al,cl
add al,30
mov [bx],al
inc bx
mov al,ch
and al,0f
add al,30
mov [bx],al
add bx,2
mov al,dh
mov cl,4
shr al,cl
add al,30
mov [bx],al
inc bx
mov al,dh
and al,0f
add al,30
mov [bx],al
mov ax,1300
mov bx,7
mov cx,8
mov dx,0919
mov bp,7c91
int 10h
jmp 278
mov ax,1300
mov bx,7
mov cx,1f
mov dx,0919
mov bp,7c99
int 10h
mov cx,3
mov ah,2
call 346
mov ah,4
call 346
mov ah,1
call 346
mov ah,4
call 346
loop 311
mov ah,0
call 346
jmp 278
mov ax,1300
mov bx,7
mov cx,3f
mov dx,0908
mov bp,7cb8
int 10h
mov ah,0
int 16h
int 19h
push cx
cli
mov al,ed
out 60,al
in al,64
test al,2
loopnz 34c
mov al,ah
out 60,al
sti
mov ah,0
int 1ah
mov bx,dx
add bx,9
mov ah,0
int 1ah
cmp bx,dx
jnz 360
pop cx
ret

w 100 0 0 2
q

4-Ejecutad el siguiente comando: debug < codigo.txt

5-Reiniciad el ordenador con el disquete dentro

Este proceso lo que hace es ejecutar tanto comandos del debug del msdos, como intrucciones en ensamblador. Con esto guardamos en el sector de arranque del disquete (no del disco duro) un programa que se ejecutará nada más reiniciar el ordenador, antes de que se cargue el sistema operativo. Este programa tiene un menú con 3 opciones:
1- Mostrar hora: Muestra la hora actual del sistema.
2- Coche Fantastico: Simula las luces del coche fantástico en los led del teclado
3- Salir: Sale del programa, cuando se retira el disquete carga el sector de arranque del disco duro.

Con este programa se muestra todo lo que que se puede necesitar de un pc:
-interfaz con el usuario de entrada (teclado)
-interfaz con el usuario de salida (monitor)
-lectura de disco (lectura del resto del programa en otro sector)
-gestión de memoria (las cadenas de texto y la pila)
-gestión de dispositivos (luces de teclado)

Las instrucciones del debug son:
a: introducir código en ensamblador.
w 100 0 0 2: escribir el programa en los primeros sectores de arranque del disquete desde la posicion de memoria 100.
q: salir del debug.

No voy a explicar que hace cada cosa en el programa, sin embargo si alguien tiene dudas puede preguntarme que significa cualquier parte del código en ensamblador. A grosso modo usa las funciones de la bios para poder funcionar: la interrupción 10h la uso para mostrar cadenas, la interrupción 13h para leer un segundo sector del disquete, la interrupción 16h para leer caracteres pulsados del teclado, la interrupción 19h para reiniciar el sistema sin tener que testearlo todo de nuevo, la interrupción 1ah para hacer retardos y averiguar la hora del sistema. Escribo en el puerto 60 para modificar el estado de los leds del teclado. Su arquitectura se basa en la peculiaridad de la bios de guardar nada más arrancar el primer sector del disquete en la zona de memoria 0000:7C00 y luego enviar la ejecución a ese punto.

El hecho de haber usado la herramienta debug es porque lo tiene todo el mundo en su windows. Sin embargo no esta orientada a usarse para programar sectores de arranque, más bién para editarlos, editar ficheros o crear ficheros ejecutables con extensión .COM; por este último motivo he tenido que ir jugando con los saltos relativos a pelo, es decir, como los programas en debug empiezan en el desplazamiento 100h de la memoria (típico de los ficheros .COM) he estado poniendo los destinos de los saltos en base a esa posición 100h, por lo que cuando he necesitado modificar una instrucción, he tenido que cambiarlos también. Por suerte al ser saltos relativos (e internamente el debug los convierte así) no influye en el resultado final.

Por último si teneis curiosidad por el mundo del pc y sus interioridades, saber como es el proceso de arranque del pc, cambiar las luces del teclado y muchísimo más, teneis el maravilloso y gratuito libro EL UNIVERSO DIGITAL DEL IBM PC, AT Y PS/2 de Ciriaco García de Celis, el cual explica con mucho detalle las tripas de los pcs.

Gateway SMS/EMAIL/SMS

2005-04-14T10:45:00.000+02:00

Bueno, pues hoy voy a enseñar un pequeño proyecto el cual ya hace tiempo que había terminado, pero que hoy doy a la luz pública (en fase beta) para que lo probeis a ver que os parece.

La idea de hacer un gateway sms2email y email2sms hacía tiempo que me rondaba la cabeza. Mi idéa era hacerlo bajo linux, ya que es el mejor sistema operativo que puede hacer de servidor y para este caso en concreto necesitaba un servidor POP3 y SMTP. Segundo necesitaba un aparato que enviase y recibiese sms, por lo que aproveché mi antiguo Siemens M35 y un cable de datos que ya tenía anteriormente para que hiciese las veces de servidor sms. Tercero necesitaba el software que gestionase los sms y los correos, por lo que para el primer caso usé la estupenda herramienta SMS server tools cuyo funcionamiento se reduce a guardar en un directorio un archivo con formato por cada sms nuevo del móvil, y enviar un sms por cada archivo con formato que encuentre en otro directorio; para el segundo caso he usado el perl con las librerias Net::POP3, Net::SMTP, MIME::Parser, MIME::Entity y MIME::Body.

El resultado final es el siguiente que os explico:

Para enviar un correo y que se transforme en sms:
-En el destinatario del correo poneis sms@sistemasorp.com
-En el asunto del correo poneis SOLO el número de teléfono con prefijo 34 o sin el (no acepta mensajes a móviles que no sean de España).
-En la primera línea del mensaje poneis el texto que querais siendo menor de 140 carácteres.

Para enviar un sms y que se transforme en mail:
-Poner la dirección de correo electrónico seguido de un espacio y el texto del mensaje.
-Enviadlo al número de móvil 699744630. Esto os costará lo que vuestro proveedor de telefonía móvil os cobre por un sms normal y corriente (normalmente 15 céntimos de euro).

En el caso de que sea mi sistema el que envíe el sms después de recibir un correo, me costará 15 céntimos de euro, aunque como estoy probando el sistema y el sim que tengo es de los que tienen dinero aún acumulado por la promoción de compra de un nuevo móvil, no me importa que se gaste. Más adelante lo pondré con contraseña para que solo yo o la gente que decida puedan usarlo.

El código fuente en perl no esta aún comentado, aunque si quereis una copia, podeis pedirmela sin problemas.

Los mensajes sms pueden recibirse o enviarse inmediatamente, tardiamente o nunca, eso ya depende de los proveedores de telecomunicaciones, de vuestro servidor de smtp tenga la última ip de mi dominioa través del DNS que use, etc.

Comprimir la salida de un php

2005-04-09T18:30:00.000+02:00

Cuando hacemos una página en php, normalmente la solemos hacer para que muestre contenido de texto ya formateado (en html si es para un navegador, en xml si es para un servicio web, etc). Cuando digo formateado me refiero a que no solo contiene contenido textual, sino que también contiene etiquetas de formato, etiquetas pertenecientes al tipo de documento, comentarios, códigos, etc. Esto al final provoca que haya mucha saturación en cuanto a contenido, o dicho de otra forma, se envían muchos bytes.

El problema radica en que por un lado se esta gastando un ancho de banda que pudiera servir para otras cosas (como es el caso de los hosting, donde tiene un limite de transferencia mensual) y al mismo tiempo provoca que se tarde más tiempo en descargar esa información (especialmente si estamos hablando de modems).

La solución pasa por comprimir la salida del php y que el navegador del cliente se encargue de descomprimirla. Para ello hace ya tiempo que se añadió al estardar HTTP 1.1 la cabecera Accept-Enconding. Esta cabecera es enviada por el navegador al servidor web y contiene una lista de métodos de codificación de contenido que el navegador puede tratar. En el caso del Firefox o del Internet Explorer esta lista es gzip y deflate. El gzip es el método que nos interesa, ya que con el, se comprime la salida. Así que si el navegador pide al servidor un página php (y esta permite comprimirla como veremos a continuación), el documento que el servidor entrega al navegador estará comprimido (con una cabecera a su vez denominada Content-Encoding), con el consecuente ahorro de tiempo de transferencia y cantidad de datos a transmitir. Teniendo en cuenta que casi siempre suele ser texto lo que se envía, la compresión se hace mucho mejor, ya que se repite mayor cantidad de carácteres.

Ejemplo de petición del navegador Firefox:
GET /divisas/divisas.php HTTP/1.1
Host: www.quejateportodo.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; es-AR; rv:1.7.5) Gecko/20041108 Firefox/1.0
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
Accept-Language: es-ar,es;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive

Ejemplo de petición del navegador Internet Explorer:
GET /divisas/divisas.php?idioma=es&fecha=09/04/2005&version=201&codigo=21988 HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)
Host: www.quejateportodo.com
Connection: Keep-Alive
Cookie: PHPSESSID=09b4f65e7adf47e857a309d5a9ef83e3

A lo que en mi caso el servidor devuelve esta respuesta similar en ambos casos:

HTTP/1.1 200 OK
Date: Sat, 09 Apr 2005 16:49:14 GMT
Server: Apache/1.3.33 (Unix) mod_gzip/1.3.26.1a mod_auth_passthrough/1.8 mod_log_bytes/1.2 mod_bwlimited/1.4 PHP/4.3.10 FrontPage/5.0.2.2635 mod_ssl/2.8.22 OpenSSL/0.9.7a
X-Powered-By: PHP/4.3.10
Expires: Mon, 26 Jul 1997 05:00:00 GMT
Cache-Control: no-store, no-cache, must-revalidate
Pragma: no-cache
Last-Modified: Sat, 09 Apr 2005 16:49:14 GMT
Cache-Control: post-check=0, pre-check=0
Content-Encoding: gzip
Vary: Accept-Encoding
Content-Type: text/xml
Age: 496
Connection: close

Y después de tanta teoría, la práctica:

<?
ob_start("ob_gzhandler");

... Aquí se mete toda la lógica del php ...

ob_end_flush();
?>

¿A que resulta muy curioso que sea tán extremadamente sencillo el hacerlo?. Primero ponemos al principio del todo de la página php la instrucción ob_start del php, que sirve para activar el modo "buffering", que no es otra cosa que primero genera la página y luego la envia en vez de irla enviando a medida que se va generando. Hay que pasarle el parámetro de texto ob_gzhandler para que al final comprima todo lo que tiene en el buffer antes de enviarlo. Finalmente ponemos ob_end_flush al final del todo de la página php, que sirve para cerrar el buffer y enviarlo todo.

Y para terminar, solo deciros que lo useis, ya que os supondrá un ahorro bastante efectivo. Si quereis comprobar si lo teneis instalado en vuestro servidor, buscad las librerias zlib, zend y la variable output_buffering a 1 en un phpinfo.

Detección de movimiento con una webcam

2005-03-30T09:19:00.000+02:00

En este proyecto mi intención no es otra que hacer un sistema de detección de movimiento (que no de reconocimiento de objetos).

Detectar movimiento no es una cosa sencilla como pueda parecer a priori, ya que la imágen que pueda dar una camara (en este caso un webcam) no es de una calidad suficiente como para que dos imágenes tomadas en distintos momentos puedan considerarse iguales. Esto es debido a que las cámaras suelen introducir ruido en las imágenes que captan, o dicho de otra forma, un pixel de una posición determinada de la imágen nº1 no suele coincidir casi nunca (por no decir nunca) con un pixel de la misma posición de la imágen nº2 (aún siendo estas tomadas con una diferencia de milisegundos). Es por ello que hay que pensar que nivel de tolerancia hay que permitir para que aunque las imágenes no sean iguales exactamente, la información que contienen si sea similar en gran medida; sin detrimentro por supuesto de que si hay algún movimiento de un objeto o de un ser vivo sea tomado como informaciones distintas y provoque un evento o acción.

Existen varias formas de trabajar con esta tolerancia: algoritmos de detección de bordes (gradientes, derivadas gausianas, transformada de Hough, etc), filtrados descriptores de Fourier, clasificador Bayesiano, etc), etc. Todos ellos sirven, pero no son iguales de rápidos. Es por ello que me decanté por el metodo estadístico de hacer medias de pixeles con los de su alrededor, un metodo sencillo para fijar una tolerancia en escaso tiempo (aunque quizá con un poco de penalización en cuanto a acierto en detección).

El método consiste en tomar cada pixel de la imágen nº1 y sumar su valor con los 8 pixeles que le rodean (una matriz de 3x3) y luego dividir el resultado por 9, por lo que nos da un valor medio. El mismo proceso lo hacemos con los mismo pixeles pero de la segunda imágen, y así obtenemos otro valor medio. Al compararlos podemos detectar cuanto % de diferencia hay entre uno y otro, momento por el cual, gracias a que hemos configurado que nivel de sensibilidad en la diferencia, o se admite como que no es un valor a tomar en cuenta, o sin embargo el valor es distinto y por lo tanto se toma en cuenta. Si se sobrepasa una cantidad determinada de pixeles que se toman en cuenta (sensibilidad por puntos), entónces es que las imágenes no son completamente iguales en cuanto a información y se supone que se ha producido un movimiento (cambio de posicion de entidades en la imágen o aparación de otras nuevas). La idea es que se tome una imágen de referencia (una del entorno estático), y se comparen las restantes con ella, para poder así saber con respecto al origen si ha habido algún cambio. Más tarde se toma otra imagen de referencia eliminando así los problemas que pudieran causar otros agentes (como un cambio atenuado de luz por el sol).

Siguiendo esta idea, he desarrollado una aplicación en visual c++ 6.0 llamada DETECTOR donde he aplicado los conceptos anteriormente citados. Podeis descargar el ejecutable y/o su código fuente en esta dirección (esta bajo licencia creative commons): http://www.quejateportodo.com/detemovi

Otro sistema más para combatir el antispam

2005-03-23T13:33:00.000+01:00

Hace ya tiempo que le estuve dando vueltas a como combatir el spam de una vez por todas...

Es de sobra conocido que los filtros anti-spam tienen dos defectos, por un lado filtran muchas veces correos spam como legítimos, y viceversa, correos que estamos esperando no los recibimos porque el filtro los considera spam.

La solución de tener listas negras de ips (los dominios no sirven porque los spammers pueden poner el que quieran como remitente) no es en absoluto fiable, ya que por ejemplo un usuario puede enviar spam desde una linea adsl (ya sea conscientemente o sin saber que esta infectado por un troyando o virus) y al ser ip dinámica, otro usuario que la tome posteriormente no podrá enviar emails; o aún peor, meter a todo un rango de ips en una lista negra (como pasó con telefonica) y fastidiando a todos los usuarios de ese ISP que quieran enviar emails.

El sistema que hace google (y desarrollado por yahoo) de firmar los emails esta bién, pero aún no esta implantado masivamente y tardará aún mucho que todos los programas servidores y clientes de SMTP lo implanten (y peor aún cuando Microsoft no lo tome como estandar y se invente el suyo propio).

Mi solución, a falta de cubrir ciertos aspectos técnicos se presenta en el siguiente diagrama:

Básicamente consiste en pedir confirmación de los emails a su remitente antes de tomarlos como buenos en futuras ocasiones. Faltarían detalles como listas de correos o publicidad requerida, pero este sistema funcionaría con la tecnología actual y funcionaría como puente entre el servidor POP3 y el cliente de correo.

¿Buscas un código fuente?

2005-01-16T20:57:00.000+01:00

Pues en www.koders.com seguramente encuentres algo parecido a lo que estés buscando. Se trata de un buscador de código fuente donde como criterios de busqueda puedes filtrar por lenguaje de programación o licencia de uso del mismo. La única pega es que para encontrar lo que andabas buscando tengas que leer un chorro de codigo de otra persona que tenga una forma curiosa (horrible) de hacer las cosas, cosa por la cual ya he tenido que pasar en algún que otro trabajo donde he estado :).

Configurar Linux como Router

2004-12-20T16:45:00.000+01:00

Recientemente he adquirido un ordenador de 2º mano en mi empresa. La utilidad que le voy a dar es la de tener un ordenador en la casa donde voy de veraneo en Cercedilla. Pero claro, durante estos días lo he estado configurando y metiendole todos los programas necesarios y los que preveía que tarde o temprano usaré. Con este ya suman 4 los ordenadores que tengo, a saber:

Servidor: VIA EPIA 800, 128 MB RAM, linux
Uso diario: AMD XP, 2.4 Ghz., 512 MB RAM, 280 GB HD, linux, windows xp
Portatil: AMD XP Mobile, 2.4 Ghz, 512 MB RAM, 40 GB HD, windows xp
Nueva adquisición: Pentium IV 2.4 Ghz, 768 MB RAM, 20 GB HD, windows xp

Pues con estos equipos el otro día se me ocurrió hacer dos redes, una del tipo 192.168.0.0/24 y otra del tipo 10.0.0.0/8 que estuviesen unidas al nuevo equipo, actuando este como router. En la red 192* tenía el ordenador de uso diario y el router ADSL, y en la red 10* tenía al portatil. Mi intención era que todos los ordenadores se vieran entre si y también tuviesen acceso a Internet. El ordenador nuevo tenía dos tarjetas y corría el linux knoppix. Una tarjeta tenía la ip 10.0.0.254 y la otra tenía la ip 192.168.0.4. En linux ambas se configuran así a través de la shell o linea de comandos:

ifconfig eth0 192.168.0.4 netmask 255.255.255.0 up
ifconfig eth1 10.0.0.254 netmask 255.0.0.0 up

En este ordenador, la puerta de enlace o gateway estaba configurado para 192.168.0.254, o lo que es lo mismo, la ip que tiene mi router ADSL:

route add default gw 192.168.0.254

El portatil y el ordenador de uso diario ejecutaban windows xp y tenian como ip 10.0.0.1 y 192.168.0.1 respectivamente. El portatil estaba conectado a un switch (con puerta de enlace 10.0.0.254) al igual que una de las tarjetas del ordenador nuevo; el ordenador de uso diario estaba conectado al router ADSL (como es un hub al fin y al cabo; con puerta de enlace 192.168.0.254) al igual que la otra tarjeta del ordenador nuevo.

Una vez ya todo conectado puse en el linux del ordenador nuevo esta sentencia desde la shell:

echo "1" > /proc/sys/net/ipv4/ip_forwarding

que permitia reenviar los paquetes tcp/ip por las redes que tenia acceso este ordenador (se puede ver poniendo un simple route en linux)

Pero hay triste de mi que los ordenadores host no se veian entre ellos, ya que haciendo ping de uno a otro no se veian, sin embargo si veian al ordenador nuevo, aunque curiosamente si veían al router y también podían navegar por Internet (en ambos estaban puestas ya las DNS correctas), por lo que pensé que algo había hecho mal. Asi que pensando, pensando, cambié la puerta de enlace del ordenador de uso diario que estaba como he comentado antes a 192.168.0.254 a 192.168.0.4 y ¡¡¡ voila !!! ya se veían entre ellos. Había creado dos redes con casi nada de esfuerzo. Luego ya me entretuve con el iptables para configurar accesos desde el shell como:

iptables -A FORWARDING -p tcp --destination-port 80 -j DROP

que no permite el paso de paquetes por el puerto http o

iptables -A FORWARDING -s 192.168.0.0/24 -d 10.0.0.0/8 -j DROP

que no permite el flujo de daots entre una red y otra.

El dibujo de la red sería tal que así:

y muestra como aunque el ordenador de uso diario y el router ADSL estan en la misma red, los paquetes entre uno y otro deben pasar por el ordenador nuevo.

Transparencias con Windows y GDI en Visual Basic

2004-11-29T13:15:00.000+01:00

En el trabajo me surgió la problematica de hacer que una imágen tenga un grado de transparencia sobre otra. Esto, aunque parezca una trivialidad, no lo es puesto que aunque la solución original es generar una mascara para hacer la transparencia, el permitir que existan varios grados lo complica un poco. Sin embargo al final he conseguido compactarlo todo en un procedimiento para que pasandole como parametros el dispositivo de contexto de origen, el dispositivo de contexto de destino (y donde se almacenará el resultado de la transparencia), las dimensiones de la imagen (en mi caso suelo poner las dimensiones en pixeles del picturebox) y el grado porcentual de transparencia, se genera de un modo casi inmediato el efecto deseado. Aqui os dejo el código:

' AUTOR: Oscar Rodríguez
' NOMBRE: Transparenta
' FUNCIONAMINETO: Esta función permite fusionar una imágen de frente con otra de fondo
' dado un grado de transparencia
' PARÁMETROS:
' -OrigenDC: Dispositivo de Contexto de la imágen de frente
' -DestinoDC: Dispositivo de Contexto de la imágen de fondo y resultado de la operación
' -Anchura: Anchura de las imágenes
' -Altura: Altura de las imágenes
' -Transparencia: Grado de transparencia medida en %
Public Sub Transparenta(ByVal OrigenDC As Long, ByVal DestinoDC As Long, ByVal Anchura As Long, ByVal Altura As Long, ByVal Transparencia As Byte)
Dim bitmap_info As BITMAPINFO
Dim indice As Long, tamano As Long
Dim pixels() As Byte
Dim TemporalDC As Long, TemporalDC2 As Long, MascaraDC As Long
Dim BitMap As Long, AntiguoBitMap As Long, BitMap2 As Long
Dim AntiguoBitMap2 As Long, MascaraBitMap As Long, AntiguoMascaraBitMap As Long
Dim recta As RECT
Dim brocha As Long

' Creamos el DC y bitmap de la mascara
MascaraDC = CreateCompatibleDC(OrigenDC)
MascaraBitMap = CreateCompatibleBitmap(OrigenDC, Anchura, Altura)
AntiguoMascaraBitMap = SelectObject(MascaraDC, MascaraBitMap)
' Copiamos la imágen de frente a la mascara
BitBlt MascaraDC, 0, 0, Anchura, Altura, OrigenDC, 0, 0, SRCCOPY

' Establecemos las propiedades de la cabecera bitmap
With bitmap_info.bmiHeader
.biSize = 40
.biWidth = Anchura
.biHeight = Altura
.biPlanes = 1
.biBitCount = 32
.biCompression = BI_RGB
End With
' Creamos el buffer donde almacenaremos los bytes de la imágen de la mascara
tamano = 4 * Anchura * Altura
ReDim pixels(tamano) As Byte
' Guardamos en el buffer los bytes de la imágen de la mascara
GetDIBits MascaraDC, MascaraBitMap, _
0, Altura, pixels(0), _
bitmap_info, DIB_RGB_COLORS

' Calculamos la transparencia según el % que nos han pasado
Transparencia = Transparencia * 255 / 100
' Recorremos todo el buffer para sustituir los colores distintos de blanco por
' el de la transparencia
For indice = 0 To tamano - 1 Step 4
If pixels(indice) <> 255 Or pixels(indice + 1) <> 255 Or pixels(indice + 2) <> 255 Then
pixels(indice) = Transparencia
pixels(indice + 1) = Transparencia
pixels(indice + 2) = Transparencia
End If
Next

' Copiamos los bytes modifcados del buffer de nuevo a la imágen de la mascara
SetDIBits MascaraDC, MascaraBitMap, _
0, Altura, pixels(0), _
bitmap_info, DIB_RGB_COLORS

' Establecemos los valores del rectangulo para que coincida con las dimensiones
' de las imágenes
recta.Top = 0
recta.Left = 0
recta.Right = Anchura
recta.Bottom = Altura

' Creamos una brocha blanca para pintar los DC temporales con ese color
brocha = CreateSolidBrush(&HFFFFFF)

' Creamos el DC y bitmap de la imágen temporal nº1
TemporalDC = CreateCompatibleDC(OrigenDC)
BitMap = CreateCompatibleBitmap(OrigenDC, Anchura, Altura)
AntiguoBitMap = SelectObject(TemporalDC, BitMap)
' Pintamos de blanco la imágen temporal nº1
FillRect TemporalDC, recta, brocha
' Copiamos la imágen de la mascara invertida en colores a la imágen temporal nº1
BitBlt TemporalDC, 0, 0, Anchura, Altura, MascaraDC, 0, 0, SRCINVERT
' Mezclamos la imágen de frente con la imágen temporal nº1
BitBlt TemporalDC, 0, 0, Anchura, Altura, OrigenDC, 0, 0, SRCAND

' Creamos el DC y bitmap de la imágen temporal nº2 y lo pintamos de blanco
TemporalDC2 = CreateCompatibleDC(DestinoDC)
BitMap2 = CreateCompatibleBitmap(DestinoDC, Anchura, Altura)
AntiguoBitMap2 = SelectObject(TemporalDC2, BitMap2)
' Pintamos de blanco la imágen temporal nº2
FillRect TemporalDC2, recta, brocha
' Copiamos la imágen de la mascara a la imágen temporal nº2
BitBlt TemporalDC2, 0, 0, Anchura, Altura, MascaraDC, 0, 0, SRCCOPY
' Mezclamos la imágen de fondo con la imágen temporal nº2
BitBlt TemporalDC2, 0, 0, Anchura, Altura, DestinoDC, 0, 0, SRCAND

' Copiamos la imágen temporal nº2 a la imágen de fondo
BitBlt DestinoDC, 0, 0, Anchura, Altura, TemporalDC2, 0, 0, SRCCOPY
' Sumamos la imágen temporal nº1 a la imágen de fondo
BitBlt DestinoDC, 0, 0, Anchura, Altura, TemporalDC, 0, 0, SRCPAINT

'Limpiamos el sistema
SelectObject TemporalDC, AntiguoBitMap
SelectObject TemporalDC2, AntiguoBitMap2
SelectObject MascaraDC, AntiguoMascaraBitMap
DeleteObject BitMap
DeleteObject BitMap2
DeleteObject MascaraBitMap
DeleteDC TemporalDC
DeleteDC TemporalDC2
DeleteDC MascaraDC
End Sub

Actualización 07/07/2005:
El código de aquí arríba es más limitado de lo que yo pensaba y hace cosas que no debiera, por lo que hoy que hemos estado probandolo lo hemos descartado y en su lugar he encontrado algo mucho más sencillo... La función AlphaBlend de la API de windows 98, Me, 2000 y XP:

Private Declare Function AlphaBlend _
Lib "msimg32" ( _
ByVal hDestDC As Long, _
ByVal x As Long, ByVal y As Long, _
ByVal nWidth As Long, _
ByVal nHeight As Long, _
ByVal hSrcDC As Long, _
ByVal xSrc As Long, _
ByVal ySrc As Long, _
ByVal widthSrc As Long, _
ByVal heightSrc As Long, _
ByVal dreamAKA As Long) _
As Long

.
.
.
dim numero as Long
numero=127
numero=vbBlue - CLng(numero) * (vbYellow + 1)
AlphaBlend picture2.hDC, 0, 0, picture2.ScaleWidth, picture2.ScaleHeight, picture1.hDC, 0, 0, picture2.ScaleWidth, picture2.ScaleHeight, numero

Primero colocais en la variable número un valor entre 0 (transparente) y 255 (opaco) para definir el nivel de transparencia de la imagen origen con respecto a la de destino, posteriormente con una sencilla formula (no os calenteis mucho la cabeza, ya que es una regla nemotécnica para darle un valor) se saca el valor a pasar al último parámetro de la función. Luego ya en la función le pasais el hdc de destino, el punto x e y del empiece a trabajar del destino y el ancho y alto del destino, posteriormente los mismos parámetros pero esta vez los del origen.

Funciona bastante bién y estará en todos los windows modernos.

A tortas con el MFC y los cursores e iconos

2004-10-04T17:53:00.000+02:00

Bueno, hoy he estado haciendo pruebas sobre como crear un control estático donde maneje a mi antojo lo que dibuje en el con MFC para windows, y entre otras cosas se me ha ocurrido meterle un icono como dibujo y que cuando el ratón pase por una zona del control se cambie el cursor (el puntero).

Para el primero he tenido varios problemas puesto que no esta muy depurada la API de windows para manejar cursores y dejarlos en 16x16 pixeles, haciendo cosas raras, menos mal que dentro del oceano de Internet uno puede ir recopilando informaciones cuando no se encuentra todo en un documento para saber como hacerlo. Tan sencillo como esto:

HICON icono=(HICON)LoadImage(AfxGetInstanceHandle(),
MAKEINTRESOURCE(IDI_SEMAFOROVERDE),
IMAGE_ICON,
16,16,
LR_DEFAULTCOLOR);
DrawIconEx(fondo.GetSafeHdc(),10,10,icono,16,16,0,NULL,DI_NORMAL);
DestroyIcon(icono);

-Primero cargo el icono con la función LoadImage, donde le paso como parámetros la instancia de la aplicación donde se encuentra el icono (la misma aplicación donde se ejecuta), el identificador del recurso del icono pasado a cadena con la macro MAKEINTRESOURCE, el tipo de imagen que es (un icono), la anchura y la altura del mismo y finalmente que lo coja con los colores por defecto.

-Segundo dibujo el icono en el dispositivo de contexto que nos ofrece windows para dibujar en el control CStatic, no uso la función DrawIcon del objeto de dispositivo contexto por que no consigue adaptar bién el icono a 16x16 pixeles, por lo que uso la función win32 DrawIconEx que si me lo permite, pasandole como parámetros el manejeador del dispositivo de contexto, la posición x e y donde quiero dibujar el icono, el icono, su achura y altura, ningúna brocha (no es necesario) y le digo que es una imagen con transparencias (DI_NORMAL indica todo eso).

-Tercero lo destruyo porque en esto de la programación en C es bueno la "limpieza".

Para el segundo caso, siendo aún más sencillo me he partido más los cuernos, simplemente porque el evento que se debe usar para cambiar el cursor no tiene mucha lógica con lo que uno quiere hacer. Mi idea es que cuando moviese el ratón por una zona del CStatic, se cambiase el cursor, sin embargo usando el evento OnMouseMove no funciona para nada la función SetCursor. He de decir que cuando digo CStatic, en realidad es una clase que he derivado de esa para poder interceptar los eventos. Por lo visto para que funcione lo que queremos hacer debemos usar el vento OnSetCursor, que funciona a semejanza del OnMouseMove, pero que no te da las coordenadas dentro del control donde se encuentre el puntero del ratón, sino que se activa cuando se pasa el ratón por el control. Esto no funcionaría si no tuviesemos activado la opción "notify" de los estilos del control. Aquí dejo mi solución de como lo he conseguido al final:

POINT point;
GetCursorPos(&point);
ScreenToClient(&point);

if(point.y>=10 && point.y<66)
{
::SetCursor(LoadCursor(AfxGetInstanceHandle(),
MAKEINTRESOURCE(IDC_CURSOR)));

return TRUE;
}

return CStatic::OnSetCursor(pWnd, nHitTest, message);

-Primero declaro una variable POINT, luego pregunto con GetCursorPos que me diga la posición relativa a pantalla donde se encuentra el ratón, y a continuación lo transformo a coordenadas del control gracias a la función ScreenToClient. Con todo esto logramos saber en que posición de nuestro control esta el cursor ya que el OnSetCursor no nos la da como parámetro como lo hicera el OnMouseMove.

-Segundo comparo si el cursor esta dentro de un rango en el eje de la altura y si es así ya uso la función SetCursor (de la api de win32 no del objeto), pasandole como parámetro el cursor que me devuelve la función LoadCursor, a la cual se le pasan como parámetros la instancia donde se encuentra el cursor (la nuestra en este caso) y el identificador del cursor pasado a cadena con la macro explicada antes. Después salimos de la función delvolviendo un valor TRUE indicando que no hay que hacer nada más.

-Tercero, si llega hasta aquí significa que no ha pasado por el if y que llama al manejador por defecto devolviendo el valor que a su vez este devuelve, esta linea la incorpora automáticamente el Editor de Visual C++ cuando añadimos el evento OnSetFocus.

Como veis la programación de Windows es apasionante, pero muchas veces me encuentro con cosas que no funcionan como deben o se manejan de forma ilógica, pero bueno, menos mal que ya hay mucho escrito sobre eso. Por cierto, sigo pendiente de aprender programar linux, estoy por el capítulo de programación avanzada de ficheros y en siguiente ya son los demonios, y aún así me queda mucho libro por leer :)

Navegación anónima

2004-09-20T21:33:00.000+02:00

Después de las vacaciones de verano ya va siendo hora que postee de nuevo en el blog, aunque me da a mi que nadie o casi nadie lo lee, pero bueno, aquí estamos.

Muchas veces hemos navegado por Internet con nuestro navegador favorito y sabemos que vamos dejando nuestro rastro allá por donde vamos, o bién queremos opinar en algún foro como una persona distinta, o bién queremos votar más de una vez en alguna votación, mandar un correo electrónico y que no se sepa el origen, etc etc etc.

Pues bién, la solución a todos estos problemas son los proxys abiertos, los cuales son proxys mal configurados por administradores o usuarios particulares que los tienen para compartir una conexión a Internet y por tanto cualquiera puede usar ese mismo proxy desde fuera de la red donde se encuentra.

Configurando la conexión en nuestro navegador web para que pase a través de un proxy abierto, se elimina la ip que poseemos y se sustituye por la ip del proxy (en algunos casos se pasa como cabecera de la petición a la página con lo que no se elimina del todo), pudiendo asi interactuar con la web que hayamos visitado sin que sepa realmente quienes somos (normalmente no se sabe quienes somos, y menos si tenemos ip dinámica, pero con esto se dobla el anonimato en la navegación).

Se puede acceder a ftp, http, https desde un proxy (siempre que este configurado para permitirlo) y conectarnos a otros puertos si usamos la tecnología SOCKS v4 o v5 (igualmente debe estar configurado para permitirlo), con lo que prácticamente se
puede hacer de todo en internet a través de un proxy. Es más, si estas en tu empresa y te capan todos los puertos menos el puerto 80 para salir a Internet, con un proxy podrás acceder al resto de puertos sin mayor peoblema.

Hay muchas listas de proxys abiertos por Internet, yo suelo usar Open Proxies, pero hay muchas listas más o menos públicas para llevar a cabo tu intimidad y anonimato.

Programación TCP/IP

2004-07-31T09:21:00.000+02:00

Creo que a estas alturas todo el mundo sabe que es internet, y lo que aporta a la comunidad, lo que no creo que sepa tanta gente es que como la información se transmite y como hace para llegar a su destino sin errores, diferenciando tantos servicios como existen en internet y demás. Dentro de este último grupo seguro que también hay gente que además de saber lo que son los protocolos TCP e IP, les gustaría saber qué pasos seguir para programar un cliente o un servidor de red para Internet o para intranets basadas en TCP/IP. Pues bién, hay una guia estupenda llamada Beej's Guide to Network Programming que te explica todo lo que tienes que saber para empezar a programar sockets, que no son otra cosa que los descriptores de "fichero" para la red. Tiene traducción al castellano y además, aunque esta orientado a sistemas linux/unix, también te explica como hacerlo en windows. Yo ya hice mis pinitos hace tiempo con esta guia, y entre otras cosas hice este juego para windows del conecta 4 para dos jugadores (tiene sus bugs escondidos, asi que no le trateis mal :-)

Futuro proyecto

2004-07-07T10:48:00.000+02:00

No se si os habeis dado cuenta ya que me gusta experiementar con tecnologías sms y email. Pues bién, mi futuro proyecto es crear un gateway email/sms/email, el cual alguien puede enviar un mensaje desde cualquier móvil al celular del gateway con el formato <dirección de email> <mensaje>, por lo que enviará ese mensaje a la dirección de correo que se solicita. Para el proceso contrario, se debe meter el número de teléfono en el asunto y el texto en el cuerpo del mensaje, con lo que se enviará ese texto al número de teléfono que se indica.

De momento lo estoy desarollando, sin embargo tengo una utilidad instalada en mi servidor linux particular (http://www.sistemasorp.com) llamada smstools que es capaz guardar los mensajes entrantes de un movil conectado por el puerto serie en una carpeta denominada incoming, como de enviar los mensajes que se encuentren en una carpeta denomiada outgoing al mismo.

La idea es que tenga un demonio corriendo bajo linux que sea quien lea la cuenta de correo habilitada a tal efecto (sms@sistemasorp.com) enviando el sms si el email es correcto, y que a su vez comprueba la carpeta incoming para enviar el email si el sms es correcto.

De momento tengo que aprender un poco más de programación en linux para hacer demonios y demás cosillas, espero que pronto este finalizado este proyecto para que podais disfrutarlo.

Edición 31/7/2004:
Buscando cosas por internet me he encontrado los mailtuils, que es básicamente una serie de utilidades y librerias para lidiar con el correo. A mi me viene de perlas, porque así puedo recoger los mensajes, interpretar las cabeceras MIME del mensaje, enviar emails, etc. desde el código de la aplicación, y sin tener que hacer llamadas al sistema a "mail" y similares como tenía pensado. Ahora solo me queda ponerme con la programación de demonios en linux para tener a punto el gateway.

Envio de sms con cualquier remitente

2004-06-22T11:32:00.000+02:00

Y ya puestos después de publicar el anterior artículo, os comentaré como enviar mensajes SMS con un remitente cualquiera. Esta posibilidad es aún más creible que los correos electrónicos, puesto que cuando un usuario de móvil recibe un mensaje de texto en su móvil, creerá que el remitente del mismo es quien le ha enviado tal mensaje, ya que la
gran mayoría no sabrá que los sms se pueden falsificar.

Esto no es como lo del e-mail, es costoso: Si os haceis una cuenta en www.truesenses.com y comprais una cantidad de mensajes, su interfaz te permite poner además del destinatario y el mensaje, el remitente del mismo. Por lo que puedes poner como origen cadenas de texto o ún número de móvil (cuando el destinatario reciba el mensaje si tiene ese número en la agenda le aparecerá con el nombre con el que lo hubiera guardado).

Así de sencillo, 300 mensajes cuestan unos 30 euros, sin embargo al ser un operador suizo y al hacer roaming, cuando se envía un mensaje a España se cuenta como si hubieras enviado 2.

Sin embargo, y por tiempo limitado, aquí os dejo un formulario donde podreis probar este tipo de característica. Que os divirtais.

Edición 06/08/2004:
Después de haber tenido el servicio levantado durante 1 mes y 15 días aprox. lo cierro con la satisfacción de que ha sido una gran experiencia para todos los que lo han usado con cerca de 160 mensajes enviados desde este formulario. Quién sabe, a lo mejor me animo y lo vuelvo a activar desde www.sistemasorp.com (no lo probeis ya que tiene el movil sin batería)

Envio de mails con cualquier remitente

2004-06-21T18:18:00.000+02:00

No se si lo sabíais, pero es relativamente fácil falsificar un remitente de una dirección de correo electrónico. Para ello solo teneis que saber lo básico del protocolo SMTP de internet, o lo que es lo mismo, el protocolo que recibe los emails para luego enviarlos, ya sea a destinatarios del mismo dominio (correo local), o bién a destinatarios de otros dominios (distribución, aunque en este último caso si no eres del mismo dominio que el servidor SMTP es bastante improbable que puedas poner un remitente y un destinatario diferentes que el dominio del propio servidor).

El caso es que queremos enviar un mensaje a un conocido con un remitente distinto al nuestro. Aunque configurasemos nuestro cliente de correo con una cuenta ficticia, probablemente nuestro servidor de correo SMTP no nos dejase enviarlo por lo que he explicado en el anterior párrafo. Sin embargo con unos pocos conocimientos podemos ser nosotros mismos quienes depositemos en mensaje trucado en el buzón del destinatario.

El proceso a seguir es el siguiente:

1 - Averiguar el servidor de correo del destinatario, para ello en la linea de comandos ponemos:
(en windows nt, 2000, xp o Linux) nslookup -q=MX dominio

Donde "dominio" es el del propio del destinatario, por ejemplo pepito@yahoo.es el dominio es "yahoo.es", con lo que al final queda nslookup -q=MX yahoo.es. Entónces cogemos la direccion que aparece a la derecha de mail exchanger; en el caso de yahoo me han salido varios, yo cojo el primero, es decir, mx2.mail.yahoo.com

2 - Poner luego en la misma linea de comandos lo siguiente:
(en windows o Linux) telnet servidor 25

Donde "servidor" es la dirección a la que haciamos referencia en el punto 1, con lo que al final queda telnet mx2.mail.yahoo.com 25. Si ponemos 25 es porque ese es el puerto por donde habitualmente escucha el servidor SMTP de correo del dominio al que queremos conectarnos.

3 - Una vez conectados veremos un mensaje de bienvenida con un código numérico y un texto, nosotros solo nos centraremos en los códigos numéricos. Si todo funciona correctamente debemos haber recibido un 220.

Lo primero que haremos es poner HELO dominio y pulsaremos enter, donde "dominio" se supone que es el dominio del remitente del mensaje, si nosotros queremos enviar el mensaje como billgates@microsoft.com sería HELO microsoft.com

Si todo va bien, recibiremos un código 250. Ahora pondremos la dirección de correo del remitente de la siguiente forma MAIL FROM: <remitente> y pulsaremos enter, donde "remitente" en nuestro ejemplo sería billgates@microsoft.com y quedaría así MAIL FROM: <billgates@microsoft.com>

Si todo fué bién, volveremos a recibir un código 250. Ahora pondremos la dirección de correo del destinatario de la siguiente forma RCPT TO: <destinatario> y pulsaremos enter, donde "destinatario" en nuestro ejemplo sería pepito@yahoo.es y quedaría así RCPT TO: <pepito@yahoo.es>. En el caso de que haya varios destinatarios en el mismo dominio repetir el mismo proceso con todos ellos.

Si hemos recibido otro código 250 es que esto va como la seda. Ahora ponemos DATA y pulsamos enter, si recibimos un código 354 es que ya podemos poner el correo en sí.
Primero vienen las cabeceras, luego una linea en blanco, luego el texto y luego una linea con un punto, asi que si queremos poner el nombre del remitente, el del destinatario, el título como "Hola colega" y el mensaje "¿Que tál estas?", debemos escribir las siguientes lineas a continuación:

From:"Bill Gates" <billgates@microsoft.com>
To:"Pepito Perez" <pepito@yahoo.es>
Subject:Hola colega
Content-type:text/plain;charset="iso-8859-1"

¿Que tal estás?
.

La linea Content-type:text/plain;charset="iso-8859-1" de la cabecera sirve para indicar que el texto contiene caracteres occidentales como acentos y demás. Si recibimos un código 250 significa que el mensaje ha sido enviado satisfactoriamente y que el usuario lo recibirá en cuanto recoja el correo. Ahora si tecleais QUIT saldreis de la sesión.

Os animo a que lo probeis con vuestras cuentas de correo para que comprobeis que funciona y coger experiencia para luego probarlo con otras cuentas ;). Una cosa
importante es que vuestra dirección IP se queda reflejada en la cabecera del mensaje,
asi que o bién os buscais un proxy con socks o un wingate para ocultarla, o bien dejais que vuestra ip permanezca en la cabecera si veis que el destinatario no sabrá encontrarla u os da igual que este en la cabecera.

¿Formato de un fichero?

2004-06-03T19:04:00.000+02:00

Supongo que todos los que nos dedicamos a programar siempre nos hemos preguntado cual sería el formato de un fichero, como poder leerlo, interpretar sus cabeceras, escribir uno por nuestra cuenta y que pueda ser leido por otras herramientas ajenas a la nuestra, etc. El problema es que siempre que queramos conseguir la descripción de cualquier formato de fichero que tengamos que usar nos tocará buscarlo por Internet , y muchas veces uno se desespera porque hay muchas refrencias a un tipo de fichero pero ninguna que nos interese. Sin embargo, esto se soluciona en gran medida gracias a wotsit's format: una web donde podrás buscar casi cualquier tipo de fichero y leer sus especificaciones. Esta organizado por función, tiene busquedas y en general es bastante sencillo de usar, ¿que quieres saber cual es el formato del fichero .DOC, .XLS. PDF, .JPG, .CAD, etc? pues aqui lo encontrarás, por lo que es el sitio ideal siempre que quieras buscar un formato de fichero.

Las patentes

2004-05-20T10:50:00.000+02:00

Recientemente se ha aprobado en la Unión Europea las patentes de software al más puro estilo Yankee. Esto, lejos de ser beneficioso, provoca que las grandes corporaciones se hagan aún más fuertes en el mercado del software. Hay gente que dice que si tu has desarrollado un algoritmo de software, debes patentarlo para respetar tu autoría y poder explotarlo económicamente. Sin embargo esto no es tan bonito como parece, puesto que el principal perjudicado sería el software libre que ahora estaba empezando a pegar fuerte tanto en empresas como en los hogares. Hace muy poco tiempo Microsoft patentó en los E.E.U.U un sistema de ejecución de programas basado en tiempos a través de un hardware específico, encubriendo así el famoso click y doble click del ratón. Esto podría repercutir en cualquier sistema Mac, Linux/Unix, OS/400, VMS, etc. porque Microsoft podría cobrarles sumas millonarias a aquellos que lo implementen, pudiendo provocar la ruina a muchos de ellos de tal forma que al final M$ consiguiese quedarse como único proveedor de software y posteriormente subiendo los precios como se le antojase sin tener competencia ninguna. Alguno puede que diga que ya se inventará otro sistema para hacer lo mismo, pero el problema es que no es lo único que se puede patentar y un sistema lo conforman muchas cosas.

El mundo de XSL

2004-05-12T13:21:00.000+02:00

Como primer artículo comentaré que labor estoy desarrollando ahora mismo en mi trabajo. Para poneros en antecedentes os diré que estoy desarrollando (e investigando) en un proyecto para la Comunidad de Madrid. No os comentaré mucho de que trata porque no creo que sin haber salido a la luz les guste a los responsables del mismo que se le de publicidad. Sin embargo si os puedo comentar algo de lo que estoy haciendo:

Dentro del proyecto hay un apartado donde se generan unas cedulas informativas. El objetivo es poder generar cedulas en formato PDF, sin embargo no es moco de pavo, porque dependiendo del municipio habrá distintos tipos de información y se tendrá que representar de forma igualmente distinta. El caso es que como es un proceso que posiblemente tenga que atender cientos de peticiones no es un simple "imprime en la impresora pdf" como podría ser en word o similares.

Hay una cosa clara, y es que la información que se baraja tiende a ser la misma, pero no así la presentación (¿os suena esto a la programación a tres capas?). El caso es que existe una herramienta denominada FOP la cual te permite pasarle un fichero XML, un fichero XSL (XSL + FO) y te genera un pdf en un santiamen. El proceso es el siguiente, el XML solo tiene los datos estructuradamente, el XSL contiene el pseudocodigo que manejará los datos XML. Luego cuando se ejecuta el fop, se interpreta el XSL que le dice donde poner los datos del fichero XML y a continuación genera un PDF interpretando las directrices del FO. El resultado es bastante bueno, aunque la generación del XSL la hago de momento a mano y suele ser un poco laborioso, sin embargo es gratificante ver sus resultados.

Un ejemplo muy cortito sería este:

--------------------------------------------------------------------------------
Fichero XML
--------------------------------------------------------------------------------

<?xml version="1.0" encoding="ISO-8859-1"?>
<RAIZ>
<NOMBRE>Oscar Rodríguez</NOMBRE>
</RAIZ>

--------------------------------------------------------------------------------
Fichero XSL
--------------------------------------------------------------------------------

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:fo="http://www.w3.org/1999/XSL/Format">
<xsl:template match="/">
<fo:root>
<fo:layout-master-set>
<fo:simple-page-master master-name="pagina" page-width="210mm" page-height="297mm">
<fo:region-body margin="1cm"/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="pagina">
<fo:flow flow-name="xsl-region-body">
<xsl:apply-templates select="//NOMBRE"/>
</fo:flow>
</fo:page-sequence>
</fo:root>
</xsl:template>
<xsl:template match="NOMBRE">
<fo:block font-family="Times" font-size="8pt" color="blue">Hola, soy <xsl:value-of select="."/></fo:block>
</xsl:template>
</xsl:stylesheet>

--------------------------------------------------------------------------------

Si os fijais, como comentaba antes el XML es una chorrada, sin embargo el XSL es más laborioso porque al fin y al cabo hay que tratar tanto la información del XML (aquellas etiquetas que empiecen por xsl) como indicar como se va a presentar (las etiquetas que empiecen por fo). En este ejemplo se esta diciendo que se genere una página DIN A4 con margen por todos los lados de 1 centimetro; que procese la etiqueta NOMBRE (o lo que sería como llamar a la función NOMBRE) para que saque al final la frase "Hola, soy Oscar Rodríguez" con un tipo de letra Times New Romans de 8 puntos y de color azul.

EL FOP al ejecutarlo de la siguiente forma:
fop -xsl oscar.xsl -xml oscar.xml -pdf oscar.pdf

muestra lo siguiente:
[INFO] Using org.apache.xerces.parsers.SAXParser as SAX2 Parser
[INFO] FOP 0.20.5
[INFO] Using org.apache.xerces.parsers.SAXParser as SAX2 Parser
[INFO] building formatting object tree
[INFO] setting up fonts
[INFO] [1]
[INFO] Parsing of document complete, stopping renderer

Y el resultado final queda así

Luego se puede complicar más poniendo cabeceras, números de página, imágenes, etc. Yo aún sigo investigando para ver todas las posibilidades del XSL (y su hermano menor el FO).

Hay que darle vidilla a esto

2004-05-12T12:56:00.000+02:00

Mi iniciativa de crear un blog se quedó poco menos que en el aire después de que haya pasado casi un año desde la primera (y única) publicación en blogger, pero hasta aquí hemos llegado. Mi idea era la de desarrollar yo mismo un sistema de weblogging, pero visto los cambios que ha hecho blogger me quedaré con el sistema actual (la excusa extra-oficial es la pereza que me da hacerlo de nuevo).

Este fenómeno de los weblogs es creciente, tanto que para un tio como yo que le apasiona tanto la informática no puede pasarme desapercibido. Es cierto que esto exige una constancia en cuanto a la publicación, tanta que muchos han desistido o los dejan medio abandonados. Este abandono para mi es quedar mal con los leyentes, por lo que sin pillarme las manos, seré un escritor + o - asiduo si a alguien le interesa mi bitácora.

¿De que va a tratar? De programación, de informática y demás. Estos tres puntos intentaré diferenciarlos bién, porque yo soy desarrollador, pero también me gustaría escribir sobre cosas relacionadas con el mundo de la informática, y por supuesto, como no es un sistema cerrado también escribiré sobre otros temas que no tengan que ver con los anteriores.

Mi objetivo es compartir mis experiencias, mis opiniones, mis logros, mis decepciones, etc. por lo que todos los artículos tendrán tinte personal (para eso es un weblog ¿no?), y quien sabe si algún día compartiré con más gente.

Si has llegado hasta aquí y no te has aburrido, te doy las gracias y te animo a que leas el resto de publicaciones en este blog.

Remitente (una cadena o número internacional de móvil de 12 caracteres como máximo)
Destinatario (un número internacional de móvil de 12 caracteres como máximo)
Mensaje (130 caractéres máximo)