Lo bueno de esta página es que habla de que las cámaras foscam (y la zaapa ciprw es una de ellas con el modelo FI8901W) no mueren del todo, sino que tienen un puerto serie escondido al que se puede acceder y comunicarse con una consola para cargar un firmware. Yo me he comunicado con la cámara con un conversor serie TTL a USB:

La solución ya estaba, sólo tenía que conseguir el firmware de la zaapa (ya que otros no valen) y decirle a mi amigo que me dejase su cámara para arreglársela. Pero no ha sido así de fácil y he tenido que pelearme con varios frentes.

El primero es el servicio técnico de Foscam. En el comentario 101 del anterior enlace un tal David comentaba que Doris de Foscam había sido muy amable y que le había dado los ficheros de recuperación. Yo probé la misma suerte con el servicio técnico de Foscam y esta fué la primera respuesta que obtuve:

Hi,

We do not have a model No. FI8901W camera, could you please double check the model No.?

Es decir, que no saben ni los modelos que han fabricado. Le dije que si existía ese modelo de cámara en su marca y me contesto esto otro:

Hi,

Sorry for my mistake. We have stopped produce this product for a long time. We do not have the firmware now. Sorry for this.

Vamos que no querían ayudarme en nada (David, que suerte tuviste…).

Buscando por Internet unos ficheros de recupercación para la zaapa o para la FOSCAM FI8901W no encontré nada. Pero por suerte encontré esto otro. Una forma de extraer de una cámara que funcionase su firmware a través de la consola serie oculta. El proceso fue pesado: me tuve que bajar el kermit 95 y buscar cómo demonios abrir una consola serie, después esperé un rato largo a que se ejecutara el script, convertir con el jedit una salida en otro fichero y finalmente pasar el convertidor de hexadecimal a binario, el cual tuve que compilar, modificar y compilar de nuevo para que funcionase. Todo esto para que al final no se hubiera decargado correctamente el firmware linux.bin y romfs.img necesarios para reprogramar la cámara estropeada, dando esta errores nada más arrancar.

Parecía que no iba a dar con la solución, pero encontré un programa que te descargaba automáticamente los ficheros necesarios del firmware. Lo ejecuté y parecía que había hecho bien su trabajo, pero pasó lo mismo que en el anterior párrafo aunque esta vez sólo con el fichero linux.bin. Sin embargo gracias a esta otra página descubro que el fichero linux.bin es en realidad un archivo .zip y que lo que había hecho está aplicación es comerse los últimos 168 bytes, asi que leyendo la memoria de  la cámara que funcionaba recuperé esos 168 bytes.

Finalmente seguí paso por paso el proceso de nuevo pero cambiando los comandos fx por estos:

fx 6 romfs.img 0x7F0D0000 0x7F0D0000 -a
fx 7 linux.bin 0x7F020000 0x00008000 -acxz

Para Windows 7 como no existe el Hyperterminal, he usado el Tera Term.

Finalmente la cámara de mi amigo ha dejado de ser un pisapapeles y ha vuelto a funcionar, pudiéndola manejar ahora con Firefox, con su IPhone, etc.

Para evitaros las incomodidades por las que yo he pasado os dejo los enlaces de los ficheros de recuperación de la versión que le instalé a mi amigo y que es la última que proporciona Zaapa:

romfs.img

linux.bin

Embeded Web UI 2.0.0.16.bin

Lo cierto es que desde entonces dejé abandonado el tema y por necesidades he tenido que retomarlo para poder interactuar con ella. Poco tiempo después de escribir el último artículo se publicó en la página de Gadget Victims información sobre un nuevo firmware para las cámaras Foscam FI908W (La de Zaapa es la FI8901W) en septiembre de 2009 donde entre otras cosas se habla de la documentación oficial de FOSCAM para sus cámaras IP. Lo mejor de esto es que en esta documentación hay dos textos que pueden servirnos a los programadores para interactuar definitivamente con la cámara Zaapa y a los usuarios para poder ver sus cámaras en navegadores como Firefox, Chrome, Safari, etc.

Se trata del IPCAM CGI SDK 2.1 y del IPCAM Protocol. El primero es un documento PDF donde se explica cómo haciendo peticiones HTTP se puede descargar la imagen de la cámara y enviar ordenes a esta. El segundo es un documento de Word donde se explica el protocolo de la cámara para comunicarse con ella mediante socket. En este artículo me centraré en el primero por su facilidad de uso.

En el primer documento se explica qué peticiones hay que hacer para interactuar con la cámara. Se trata de acceder a páginas web CGI pasándole normalmente los parámetros mediante el método GET, que es como en realidad nosotros hacemos las llamadas desde un navegador web normalmente.

Antes de empezar a probar hay que cerciorarse de que la cámara Zaapa tiene el último firmware y el último Embeded Web UI. Si en la sección Device Info del panel del administrador son distintos de 11.4.1.40 y 2.0.0.16 respectivamente, hay que actualizar. En la página del producto se pueden descargar pero hay que introducir el número de serie que aparece como código de barras en la parte inferior de la cámara. Una vez que empieza la descarga empieza lo gracioso y es que veremos algo raro en el fichero que descargamos pues no tiene extensión y que no sirve para actualizar ya que no es un .bin. Pues bien el fichero es un archivo .rar por lo que hay que renombrarlo, ponerle esa extensión y ya podemos abrirlo. Dentro de este veremos dos ficheros .bin y aquí esta lo segundo más gracioso ¡¡¡ están al revés !!! Embeded Web UI 11.4.1.40.bin tendría que ser Firmware 11.4.1.40.bin y Firmware 2.0.0.16.bin tendría que ser Embeded Web UI 2.0.0.16.bin. Una vez arreglado ese desaguisado ya podemos actualizarlo desde la sección Upgrade Device Firmware del panel de administrador y actualizar el firmware primero y el Web UI después (en ambos casos se reinicia la cámara).

Hay unos cuantos CGI y lo mejor es leerse la documentación, pero voy a explicar 3 de ellos que me parecen fundamentales:

• El primero de ellos es el snapshot.cgi. Sirve para capturar una imagen estática de la cámara. Si ponemos en un navegador web http://ip de la cámara/snapshot.cgi nos pedirá un usuario y una contraseña. Cuando la hayamos introducido veremos la imagen jpg. Podemos evitar que salga el recuadro que nos pide el usuario y la contraseña simplemente añadiendo los parámetros user y pwd a la url de la siguiente forma http://ip de la cámara/snapshot.cgi?user=usuario&pwd=contraseña para que ya directamente nos muestre la imagen. Tiene otro parámetro llamado next_url para indicar el nombre del fichero pero no lo veo útil.
• El segundo de ellos son en realidad dos: videostream.cgi y videostream.asf. Sirven para mostrar un flujo continuo de imagenes a modo de vídeo. El que tiene extensión .cgi envía imágenes jpg sucesivas (ideal para verlas con una navegador), el que tiene extensión asf envía las imágenes con el formato Advanced Streaming Format (ideal para verlas con el VLC o con el MPlayer). Si ponemos en un navegador web http://ip de la cámara/videostream.cgi?user=usuario&pwd=contraseña podemos ver el flujo continuo de lo que la cámara está enfocando en ese momento. Tiene otro parámetro llamado resolution para indicar con un 8 o un 32 si queremos que la imagen tenga de tamaño 320×240 o 640×480 respectivamente.
• El tecero de ellos es el decoder_control.cgi. Sirve para interactuar con la cámara. Si ponemos en el navegador web http://ip de la cámara/videostream.cgi?user=usuario&pwd=contraseña&command=comando donde comando sea un número que indica qué hacer a la cámara (0 = empezar a mover hacia arriba, 1 = parar de mover hacia arriba, 2 = empezar a mover hacia abajo, etc) veremos como se mueve esta.

Finalmente he creado una página HTML para probar los dos últimos CGIs que he explicado. La página muestra la sucesión de imágenes de la cámara y tiene unos botones que permiten mover la cámara. Para adecuarlo a la vuestra sólo teneis que cambiar en la sección javascript el usuario, la clave y la ruta a vuestra cámara:

<html>
<head>
	<style type="text/css">
		.comando {background-color:#FFFF00; border-radius: 10px; font-family:Arial; font-size:10pt; font-weight:bold; width:70px; text-align:center}
		#imagen {visibility:hidden; width:640px; height:480px;}
		#marco {visibility:hidden;}
	</style>
	<script type="text/javascript">
		var usuario = "usuario";
		var clave = "clave";
		var ruta = "http://192.168.0.12/";
 
		function cargado()
		{
			var imagen = document.getElementById("imagen");
			imagen.src = ruta + "videostream.cgi?user=" + usuario + "&pwd=" + clave + "&resolution=32";
			imagen.style.visibility = "visible";
		}
 
		function empieza_arriba()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=0";
		}
 
		function termina_arriba()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=1";
		}
 
		function empieza_abajo()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=2";
		}
 
		function termina_abajo()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=3";
		}
 
		function empieza_izquierda()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=4";
		}
 
		function termina_izquierda()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=5";
		}
 
		function empieza_derecha()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=6";
		}
 
		function termina_derecha()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=7";
		}
 
 
	</script>
</head>
<body onload="cargado()">
<img id="imagen">
<table>
<tr><td>&nbsp;</td><td class="comando" onmousedown="empieza_arriba()" onmouseup="termina_arriba()">Arriba</td><td>&nbsp;</td></tr>
<tr><td class="comando" onmousedown="empieza_izquierda()" onmouseup="termina_izquierda()">Izquierda</td><td>&nbsp;</td><td class="comando" onmousedown="empieza_derecha()" onmouseup="termina_derecha()">Derecha</td></tr>
<tr><td>&nbsp;</td><td class="comando" onmousedown="empieza_abajo()" onmouseup="termina_abajo()">Abajo</td><td>&nbsp;</td></tr>
</table>
<iframe id="marco" src=""></iframe>
</body>
</html>

El funcionamiento es muy sencillo. Una etiqueta img muestra el CGI videostream.cgi. Las celdas de la tabla tienen los eventos onmousedown y onmouseup para detectar cuando se pulsan y cargar en el marco oculto el CGI decoder_control.cgi con la orden correspondiente. Así es como se ve funcionando en un MAC y Safari:

Y de paso pongo otro vídeo de cómo se puede usar esta cámara con un móvil con las múltiples aplicaciones que hay en android market y en app store simplemente eligiendo en estas como marca de cámara la FOSCAM:

Como mi objetivo era hacerlo mediante fuerza bruta, la técnica de backtracking me pareció lo mejor para abordar el problema. Se crea un árbol donde cada nodo contendrá los números con los que se operan, la operación que ha generado ese nodo y el resultado de la misma (excepto el primer nodo que sólo contiene el conjunto de números original).

Vamos combinando uno por uno todos los números con todas las operaciones para encontrar el resultado que buscamos. El orden de las operaciones es suma, resta, multiplicación y división. Como esto puede generar una ingente cantidad de cálculos, podemos podar (acotar) el árbol para reducir estos y el tiempo empleado. Esto se consigue eliminando aquellos casos que no deben darse: En la resta que el resultado sea 0, en la división que el divisor sea 1 o que el resto sea distinto de 0 y que en la multiplicación uno de los factores sea 1. Para evitar números negativos en la resta o que el divsor sea mayor que el dividendo ponemos primero el mayor y después el menor en la operación.

A medida que vamos avanzando en la profundidad del árbol, el conjunto de números con los que operar se irá reduciendo ya que cada pareja de números se convertirá en uno por la operación matemática que se les aplique, siendo esto así recursivamente hasta que sólo haya un número, momento en el cual si el resultado no coincide con el esperado, se retrocede un nodo y se continúa con las siguientes combinaciones.

Para entenderlo mejor un gráfico donde dado un conjunto de tres números (1, 2 y 3) debemos operar con ellos hasta que obtengamos 7 como resultado:

En el ejemplo después de buscar varias combinaciones entre sumas y restas (puntos suspensivos en el gráfico) hemos llegado a las combinaciones de multiplicaciones. Existen tres combinaciones de multiplicaciones: Op: 1 * 2 (que no he puesto en el gráfico por simplificarlo), Op: 1 * 3 y Op: 2 * 3.

• En el nodo de la multiplicación de 1 * 3 el resultado (Res:) es 3 y no 7 como andamos buscando por lo que hay que seguir calculando. El conjunto de números de este nodo se ha reducido de Nu: 1, 2, 3 a Nu: 2, 3.
• A continuación hay que crear otro nodo con la suma de los únicos números que quedan: 2 + 3, pero el resultado es 5 con lo que volvemos al nodo anterior.
• Vamos a hacer la resta: 3-2, pero sigue sin servirnos el resultado, por tanto volvemos al nodo anterior.
• Hacemos la multiplicación: 2 * 3, pero seguimos igual, por lo que nos vamos al nodo anterior.
• La división se descarta porque 3 / 2 no dá como resto 0, con lo que no se crea ese nodo y se vuelve al anterior (que en este ejemplo es el principal).
• Continuamos con la creación del nodo de la multiplicación de 2 * 3 donde el resultado (Res:) es 6 y no 7 como andamos buscando por lo que hay que seguir calculando. El conjunto de números de este nodo se ha reducido de Nu: 1, 2, 3 a Nu: 1, 6.
• Hay que crear otro nodo con la suma de los únicos números que quedan: 1 + 6, y como el resultado es 7, que es el que buscábamos, ya no hacemos ninguna operación más y vamos retrocediendo por todo el árbol (que os recuerdo que se ha construido mediante una función recursiva) hasta salir de la función que lo ha generado.

El nivel de profundidad de los árboles depende de la cantidad de números inicial. Si son un conjunto de 3 números la profundidad será de 3 niveles, si es de 6 pues … ya sabeis la respuesta

Como se trata de una estructura de árbol, cada nodo debe tener un puntero al siguiente nodo para trazar un camino desde el nodo inicial hasta el nodo que contiene el resultado que buscamos (en el cual el puntero estará vacío).  Dado que hemos aplicado la técnica de backtracking los nodos que previamente hayamos calculado y no pertenezcan a ese camino desaparecerán porque no nos sirven. Finalmente mediante un bucle recorreremos todos los nodos del camino mostrando por pantalla la operación que lo ha creado hasta el nodo final. Así en el ejemplo quedaría:

3 * 2 = 6
6 + 1 = 7

Sin embargo en el juego de cifras y letras si no se encuentra el número exacto se puntúa el número que más se acerque a este. La problemática aquí es que con el bactracking, si no se encuentra el número exacto, el camino que se habrá generado cuando retorne la función es el de la última operación, que con toda probabilidad no será el camino hacia el número que más se aproxime al original.

En este caso tenemos dos posibles formas de solucionarlo:

• A medida que vamos generando los nodos debemos comparar el resultado con el número que buscamos, si se acerca más que el anterior valor que hayamos comparado guardamos este resultado como el número que más se aproxima al buscado. Después cuando haya salido de la función y no se haya encontrado el exacto, se vuelve a llamar a esta misma pero buscando en esta ocasión el resultado aproximado (ya que tenemos la certeza de que se puede calcular) obteniendo así el camino hasta llegar al que más se acerca.
• El problema de la solución anterior es que tenemos que llamar dos veces a la función que genera el árbol: una para buscar el exacto y otra para buscar el aproximado. Lo ideal es ir guardando un camino alternativo hacia el número aproximado, para que, en caso de no hallar el exacto, recorrer el camino alternativo mediante un bucle para mostrar las operaciones que obtengan el número aproximado. Todo desde la misma llamada a la función. Esto provoca que también se necesite un puntero al nodo anterior.

Aquí dejo el código fuente en C# que pone en práctica todo lo comentado. Se trata de una aplicación de consola donde como parámetros se le pasa todo el conjunto de números separados por espacio y como último número el resultado que se desea averiguar.

Program.cs:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
 
namespace Cifras
{
    class Program
    {
        static int Main(string[] args)
        {
            // Ncesitamos como mínimo dos números para operar y un resultado
            if (args.Length < 3)
            {
                Console.Write("La sintaxis es " + System.AppDomain.CurrentDomain.FriendlyName + " <número 1>...<número n> <número buscado>");
                return 1;
            }
            Console.Write("Set de números: ");
            ArrayList posibilidades = new ArrayList();
            int indice = 0;
            // Creamos el conjunto de números a partir de la línea de comandos.
            for (; indice < args.Length - 1; indice++)
            {
                Console.Write(args[indice] + " ");
                posibilidades.Add(Int32.Parse(args[indice]));
            }
            int descubre = Int16.Parse(args[indice]);
            Console.WriteLine("\nNúmero buscado: " + descubre + "\n");
            // Creamos el primer nodo del árbol.
            Nodo encuentra = new Nodo(posibilidades, descubre);
            // Creamos un contador
            DateTime hora = DateTime.Now;
            TimeSpan tiempo;
            // Si se ha encontrado el exacto
            if (encuentra.busca() == true)
            {
                tiempo = DateTime.Now - hora;
                Console.WriteLine("Se encontró el exacto.\n");
            }
            // En caso de no encontrarse el exacto
            else
            {
                tiempo = DateTime.Now - hora;
                Console.WriteLine("No se ha encontrado el exacto.\n");
                // Sustituimos el camino original por el camino del aproximado
                encuentra = Nodo.Cercano;
            }
            Console.WriteLine("Número de nodos calculados: " + Nodo.NumeroNodos);
            Console.WriteLine("Tiempo en calcularlo: " + tiempo.TotalMilliseconds + " ms.\n");
            Console.WriteLine("Operaciones:");
            // Recorremos todos los nodos del camino para mostrar las operaciones que se han ido ejecutando.
            while (encuentra.Hijo != null)
            {
                encuentra = encuentra.Hijo;
                Console.WriteLine(encuentra.Valor1 + encuentra.Signo + encuentra.Valor2 + "=" + encuentra.Resultado);
            }
            return 0;
        }
    }
}

Nodo.cs:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
 
namespace Cifras
{
    class Nodo
    {
        private enum OPERACIONES { SUMA, RESTA, MULTIPLICACION, DIVISION };
        private static int buscado; // El número exacto que debemos encontrar.
        private ArrayList numeros; // El conjunto de números con los que pueden operar los hijos del nodo.
 
        private Nodo padre; // El nodo padre del nodo actual.
 
        private Nodo hijo; // El nodo hijo del nodo actual.
 
        public Nodo Hijo
        {
            get { return hijo; }
        }
 
        private int valor1; // El primer operando.
 
        public int Valor1
        {
            get { return valor1; }
        }
        private int valor2; // El segundo operando.
 
        public int Valor2
        {
            get { return valor2; }
        }
 
        private string signo; // El signo de la operación.
 
        public string Signo
        {
            get { return signo; }
        }
 
        private int resultado; // El resultado de la operación.
 
        public int Resultado
        {
            get { return resultado; }
        }
 
        private static Nodo cercano; // Camino donde se llega al número más aproximado al buscado.
 
        public static Nodo Cercano
        {
            get { return Nodo.cercano; }
        }
 
        private static int aproximado; // Variable que va guardando qué número es el más aproximado.
 
        private static int numeroNodos; // Número total de nodos creados.
 
        public static int NumeroNodos
        {
            get { return Nodo.numeroNodos; }
        }
 
        // Contructor para crear el primer nodo del arbol
        public Nodo(ArrayList numeros, int buscado)
        {
            this.numeros = numeros;
            Nodo.buscado = buscado;
            padre = null;
            hijo = null;
            Nodo.cercano = null;
            Nodo.aproximado = 0;
            Nodo.numeroNodos = 0;
        }
 
        // Constructor para crear los restantes nodos del arbol.
        private Nodo(ArrayList numeros, int valor1, int valor2, int resultado, string signo, Nodo padre)
        {
            this.numeros = numeros;
            this.valor1 = valor1;
            this.valor2 = valor2;
            this.resultado = resultado;
            this.signo = signo;
            this.padre = padre;
            this.hijo = null;
            // Para saber cuantos nodos se han creado.
            Nodo.numeroNodos++;
            // Vamos guardando el número cercano más próximo al buscado.
            if (Math.Abs(buscado - resultado) < Math.Abs(buscado - aproximado))
            {
                // Creamos un camino alternativo duplicando los nodos.
                // Esto es necesario porque en backtracking los nodos que no sirven se eliminan y necesitamos
                // tener un camino hacia el resultado aproximado que perdure en toda la ejecución de la función.
                Nodo historico = this;
                Nodo copia = (Nodo)this.MemberwiseClone();
                while (historico.padre != null)
                {
                    copia.padre = (Nodo)historico.padre.MemberwiseClone();
                    copia.padre.hijo = copia;
                    historico = historico.padre;
                    copia = copia.padre;
                }
                cercano = copia;
                aproximado = resultado;
            }
 
        }
 
        // La función principal que busca el resultado combinando el conjunto de números del nodo con las
        // operaciones de suma, resta, multiplicación y división.
        public bool busca()
        {
            // Si el nodo actual contiene el número buscado ya no hacemos más búsquedas
            if (resultado == buscado)
            {
                return true;
            }
 
            // Vamos recorriendo cada elemento del conjunto de números operándolo con los demás.
            for (int indice1 = 0; indice1 < numeros.Count; indice1++)
            {
                for (int indice2 = indice1 + 1; indice2 < numeros.Count; indice2++)
                {
                    if (calculos(indice1, indice2, OPERACIONES.SUMA) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.RESTA) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.MULTIPLICACION) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.DIVISION) == true)
                    {
                        return true;
                    }
                }
            }
            // Si llegamos aquí es que todos los cálculos en esta rama del arbol han sido infructuosos.
            return false;
        }
 
        // Esta función crea un nuevo nodo después de operar los números. Le asigna un nuevo conjunto de números, 
        // el resultado de la operación, y los números involucrados.
        private bool calculos(int indice1, int indice2, OPERACIONES operacion)
        {
            int resultado = 0;
            string signo = "";
            int valor1 = (int)numeros[indice1];
            int valor2 = (int)numeros[indice2];
 
            // Hacemos que en la resta, división y multiplicación el primer operando sea mayor que el segundo
            if ((operacion == OPERACIONES.RESTA) || (operacion == OPERACIONES.DIVISION) || (operacion == OPERACIONES.MULTIPLICACION))
            {
                if (valor1 < valor2)
                {
                    int valor3 = valor1;
                    valor1 = valor2;
                    valor2 = valor3;
                }
            }
            // Calculamos la operación con los números, haciendo la poda del arbol si es necesario.
            switch (operacion)
            {
                case OPERACIONES.SUMA:
                    resultado = valor1 + valor2;
                    signo = "+";
                    break;
                case OPERACIONES.RESTA:
                    if ((valor1 - valor2) == 0) // Un número que da cero no sirve para seguir
                    {
                        return false;
                    }
                    resultado = valor1 - valor2;
                    signo = "-";
                    break;
                case OPERACIONES.MULTIPLICACION:
                    if (valor2 == 1) // Una multiplicación que por 1 da el mismo resultado no sirve
                    {
                        return false;
                    }
                    resultado = valor1 * valor2;
                    signo = "*";
                    break;
                case OPERACIONES.DIVISION:
                    if ((valor2 == 1) || ((valor1 % valor2) != 0)) // Un división que por 1 da el mismo resultado o que tiene decimales no sirve
                    {
                        return false;
                    }
                    resultado = valor1 / valor2;
                    signo = "/";
                    break;
            }
            // Generamos el nuevo conjunto de números sobre los que operar.
            ArrayList posibilidades = new ArrayList();
            posibilidades.Add(resultado);
            for (int indice = 0; indice < numeros.Count; indice++)
            {
                // No permitimos que se incluyan los números que ya se han operado.
                if ((indice != indice1) && (indice != indice2))
                {
                    posibilidades.Add(numeros[indice]);
                }
            }
            // Creamos el nuevo nodo.
            Nodo opcion = new Nodo(posibilidades, valor1, valor2, resultado, signo, this);
            // Hacemos la búsqueda recursiva. Si lo encontramos vamos generando el camino hacia el nodo con el
            // número exacto.
            if (opcion.busca() == true)
            {
                hijo = opcion;
                return true;
            }
            else
            {
                return false;
            }
        }
 
    }
}

También podéis descargaros el ejecutable del programa para poder hacer las pruebas.

Así por ejemplo este reto:

Se resuelve como:

int *born1941 = malloc(70);
int *die2011 = born1941;
free(die2011);
printf("bye world\n");

(Fuente: chw.net)

Toda la documentación de mi charla (presentación, código fuente, esquemáticos, etc.) lo podeis descargar aquí.

Agradecer a los organizadores su tiempo, esfuerzo y ganas por sacar adelante algo tan novedoso y pionero. También dignos de mención son los ponentes que de forma altruista hemos hecho realidad este fantástico evento. Por supuesto no nos olvidemos de los patrocinadores que han permitido que este evento tuviese un nivel alto y de calidad.

A todos, nos vemos en la OSHWCON 2012.

En la página de Voice Age he encontrado una librería gratuita para windows con ejemplos y ejecutables de cómo extraer el audio comprimido con un codec G729A. Si se va a usar comercialmente se debe pedir una licencia a sipro que es quien tiene los derechos de licenciamiento.

El problema con los ejecutables de Voice Age es que convierte de formato G729A a formato RAW, pero ni el origen tiene los datos por sí sólo (están embebidos en un fichero .wav) ni en la conversión se pasa a un fichero .wav reproducible en windows.

Por ello he creado un programa de consola en Visual C++ 6.0 que hace uso de la librería .lib que ofrece VoiceAge para hacer esos dos pasos. La idea es leer unos datos del fichero wav y moverse hasta el byte 44 del fichero wav de origen, accediendo así a los datos de audio directamente; crear un fichero .wav de destino,  introduciendo en este la cabecera de un fichero .wav con el tamaño de los datos de audio descomprimido e indicando que tiene formato PCM; finalmente leer los datos de audio comprimido, descomprimirlos con la librería y escribirlos en el fichero de destino.

Este es el código fuente del mismo:

#include "stdafx.h"
#include "va_g729.h"
#include <stdio.h>
#include <memory.h>
 
int main(int argc, char* argv[])
{
	FILE *entrada;
	FILE *salida;
	unsigned char	serial[L_FRAME_COMPRESSED];
	short			synth[L_FRAME];
	int				bfi;
	unsigned char cabecera[] = {0x52,0x49,0x46,0x46,0x00,0x00,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x80,0x3E,0x00,0x00,0x02,0x00,0x10,0x00,0x64,0x61,0x74,0x61,0x00,0x00,0x00,0x00};
	unsigned long longitud;
	unsigned long *puntero;
 
	puts("SISTEMAS O.R.P.\nConvertidor de WAVs G729A a PCM\n");
 
	// Se comprueban los parámetros
	if(argc != 3)
	{
		puts("Debe introducir el archivo wav de origen y el archivo wav de destino.");
		return 1;
	}
 
	// Se abre el fichero de origen
	entrada = fopen(argv[1], "rb");
	if(entrada == NULL)
	{
		puts("No se pudo abrir el fichero de origen");
		return 2;
	}
 
	// Se abre el fichero de destino
	salida = fopen(argv[2], "wb");
	if(salida == NULL)
	{
		puts("No se pudo abrir el fichero de destino");
		fclose(entrada);
		return 2;
	}
 
	// Se comprueba que el fichero origen es un .wav
	fread(serial, sizeof(char), 4, entrada);
	if(memcmp(serial, "RIFF", 4) != 0)
	{
 
		puts("El fichero de entrada no es un wav");
		fclose(entrada);
		fclose(salida);
		return 3;
	}
 
	// Se lee el tamaño de los datos de audio del fichero origen
	// y se calcula el tamaño de los datis de audio del fichero destino
	fread(&longitud, sizeof(unsigned long), 1, entrada);
	puntero = (unsigned long *)(cabecera + 4);
	*puntero = 36 + (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	puntero = (unsigned long *)(cabecera + 40);
	*puntero = (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	// Se escribe la cabecera wav al fichero de destino
	fwrite(cabecera, sizeof(char), sizeof(cabecera), salida);
	// Saltamos al byte 44 donde se encuentran los datos de audio comprimido
	fseek(entrada, 44, SEEK_SET);
 
	// Se inicializa el descompresor
	va_g729a_init_decoder();
 
	// Se lee un grupo de bytes comprimidos y se escriben descomprimidos
	while (fread(serial, sizeof(char), L_FRAME_COMPRESSED, entrada) == L_FRAME_COMPRESSED)
	{
		bfi = 0;
		va_g729a_decoder(serial, synth, bfi);
		fwrite(synth, sizeof(short), L_FRAME, salida);
	}
 
	fclose(entrada);
	fclose(salida);
 
	puts("Proceso terminado");
 
	return 0;
}

Y aquí dejo el fichero ejecutable:

G729AtoPCM

El prototipo de la función es:

bool ClipCursor(RECT *rectangulo);

Asi por ejemplo si queremos restringirlo a la ventana de la calculadora podemos hacerlo de la siguiente forma:

RECT retangulo;
HWND ventana = FindWindow(NULL, "Calculadora");
GetClientRect(ventana, &rectangulo);
ClipCursor(&rectangulo);

En concreto voy a comentar sobre un sitio que ofrece este servicio gratis y es mantenido por donaciones. Se llama IPInfoDB. Provee varios servicios:

• Búsqueda por formulario.
• Búsqueda mediante API mediante XML o JSON.
• Descarga de base de datos en formato CSV o querys SQL y una precisión a nivel de país o de ciudad.

Los usos que se le pueden dar son muchos: Saber desde donde te envían los comentarios, crear un servicio en internet destinado a un país o ciudad en concreto, conocer donde están ubicados los datacenters de un dominio determinado, personalizar el idioma de una página al usuario que la visita, etc.

La información se actualiza a principios de cada mes.

Ente sus multiples opciones, una de ellas es permitir realizar una acción al recibir un correo y esto se puede aprovechar (como se verá más adelante) para ejecutar un script o programa al recibir un correo.

La ventaja con respecto a estar comprobando cada cierto tiempo un buzón de correo es que el script se ejecuta inmediatamente al recibir un correo , no hace falta tener un servidor pop3 y no hace falta borrar el mensaje porque postfix se lo pasa a la aplicación y no lo guarda en ningún sitio.

Para explicar como configurarlo, parto de la base de que ya se tiene configurado el postfix con un dominio y recibe correos en ese dominio. En mi caso tengo el dominio sistemasorp.com dirigido a mi servidor casero.

Como no quiero que interfiera con el correo de mi dominio actual, he de crear un nuevo registro MX en mi servidor DNS para añadir un subdominio, por ejemplo servicios.sistemasorp.com (esto también me dá una ventaja que comentaré más adelante).

El siguiente paso es acceder como root a la consola y entrar en el directorio /etc/postfix (o donde se encuentre el directorio de configuración del postfix).

Editar el fichero main.cf y añadirlas siguientes lineas (si no existían ya)

transport_maps = hash:/etc/postfix/transport

local_recipient_maps=

Editar el fichero master.cf y añadir la siguiente linea:

XXX unix    -       n       n       -       1       pipe  flags= user=YYY argv=ZZZ ${sender} ${recipient}

• XXX indica el nombre de una alias, en mi caso servicios
• YYY es el usuario del sistema con el que se ejecutará el script (escoge uno que tenga persmisos para lo que quieras hacer)
• ZZZ es la ruta del script o programa que quieres que se ejecute, en mi caso /usr/local/bin/emailprueba.sh
• ${sender} y ${recipient} son dos variables que le pasamos por parámetros al script.

Editar el fichero transport y añadir la siguiente linea:

subdominio      XXX:localhost

• subdominio es la parte entera del dominio, en mi caso servicios.sistemasorp.com
• XXX indica el nombre del alias que usamos en el fichero master.cf, en mi caso servicios

Finalmente ejecutar postmap /etc/postfix/transport para crear la base de datos de transportes de postfix.

Con esto, cualquier correo que se dirija al subdominio que hemos creado se pasará directamente a nuestro script. De ahí nuestra ventaja que comentaba antes: da igual el nombre que aparezca a la izquierda de la arroba, no hace falta que esté dado de alta como usuario en linux, por lo que podemos usarlo como un identificador de servicio, el número de un móvil, etc.

Postfix lo que hace es ejecutar el script pasándole por la entrada estandar todo el contenido del mensaje (cabeceras y cuerpo) y como parámetros los que se le indiquen en el master.cf : la variable ${sender} es la cuenta de correo electrónico del remitente y ${recipient} es el nombre que aparece a la izquierda de la arroba, aunque hay muchos más.

Así por ejemplo si queremos tener un servicio de envío de sms podemos crear un mensaje dirigido a 699999999@servicios.sistemasorp.com desde nuestra cuenta google@gmail.com, por lo que el script además de recibir el mensaje entero recibe como parámetros google@gmail.com y 699999999.

Otro ejemplo es tener un servicio de envío de ficheros y uno de traducción de palabras. En el primer caso si enviamos un correo desde nuestra cuenta google@gmail.com a enviame@servicios.sistemasorp.com y como asunto ponemos una URL nos enviaría de vuelta como fichero adjunto el indicado en la URL. En el segundo caso si enviamos un correo desde nuestra cuenta google@gmail.com a traduce@servicios.sistemasorp.com y como asunto ponemos una palabra en inglés nos enviaría de vuelta la traducción del termino. En ambos casos el script es el mismo y se encarga de saber qué servicio estas solicitando por el nombre de la cuenta de correo al que va dirigido y actuar en consecuencia.

Un script sencillo para ir probando los conceptos es este:

#!/bin/bash
 
while read linea
do
 cabecera=`echo $linea | cut -d':' -f1`
 if [ "$cabecera" = Subject ]
 then
  mensaje=`echo $linea | cut -d':' -f2`
  echo $mensaje $2 | mail -s "Esto es lo que enviaste y a quien" $1
  echo $1 $2 $mensaje >> /tmp/pruebamail
 fi
done

Simplemente recibe un correo y vuelve a enviar al remitente otro correo con los datos que envió. Lo podeis probar enviando un mensaje a pepe@servicios.sistemasorp.com, prueba_de_concepto@servicios.sistemasorp.com, asdfhasdjlfhasdjkfhjkdfh@servicios.sistemasorp.com o el destinatario que querais@servicios.sistemasorp.com y un asunto cualquiera (si no lo recibis mirad que no se haya puesto en vuestra carpeta de spam).

Uno de ellos es quejateportodo.com. Este es muy antiguo y data de 2001. Su función principal fue albergar una especie de foro donde la gente expusiera sus quejas sobre los temas que quisieran. Estába organizado por secciones para poder clasificar mejor las quejas. Como anécdota os puedo contar que una vez me llamó la Policía Local de Granada por una denuncia que había puesto el dueño de unos parkings por unas criticas feroces a su gestión publicadas en la web; como le pedí una orden judicial para darle los logs del servidor web se calló y no volví a saber nada de el (¿Sería el propio dueño de los parkings haciendose pasar por la policía?). Finalmente como hice varios cambios y veía que no tenía mucho éxito lo dediqué a otras cosas.

El segundo es horaylugar.com. Una web donde podías crear citas, eventos, reuniones, etc y localizarlas en un mapa para después enviarselo a quien quisieras. Lo presenté al único concurso de mashups de Google Maps y quedó 4º, pero debido a su poco éxito lo abandoné a su suerte.

Actualmente ya sólo tengo los dominios sistemasorp.com (el dominio que apunta a mi servidor casero basado el linux), sistemasorp.es (el dominio asociado a mi cuenta de hosting) y sistemasorp.es (este blog)