Modo infraestructura extendido

octubre 17, 2010 by

Para mejorar estas deficiencias (las del modo infraestructura) en grandes redes se pueden colocar varios puntos de acceso conectados entre sí a través de un sistema de distribución. Esto es normalmente hecho a través de medios guiados como el cable, y muy rara vez se hace de manera inalámbrica.  Los puntos de acceso deberían tener el mismo ESSID. Un ejemplo de este tipo red sería eduroam. Además, si la red está configurada de manera correcta, el cliente podría pasar a estar conectado a un punto de acceso inalámbrico a otro sin tener que reconectar. A este proceso se le llama roaming o itinerancia.

El problema de este sistema es que es caro. Se necesitan varios AP y conectarlos todos en red mediante cables. Hay que pensar que esta instalación de cables tiene que cubrir toda la extesión inalámbrica.  La complejidad de la instalación y la configuración de la misma no es trivial, ni exenta de errores.

Más adelante hablaremos de como es una red de este tipo pero con sistema de distribución inalámbricos.

Anuncios

Redes inalámbricas en modo infraestructura

octubre 16, 2010 by

Esta es el tipo de red inalámbrica más extendida actualmente. Es una red tipo cliente-servidor, donde los clientes suelen ser los ordenadores personales que se conectan al servidor, llamado punto de acceso en este caso.

Un punto de acceso no es más que un dispositivo al que se conectan los clientes para poder comunicarse entre sí. Los puntos de acceso se identifican con su BSSID que coincide con la dirección MAC del dispositivo, y normalmente también por su ESSID o nombre de la red. El punto de acceso a veces también comunica con redes cableadas haciendo la función de puente entre las dos redes. A los clientes también se les suele llamar estaciones.

Para que pueda existir comunicación entre dos estaciones, ambos tienen que estar conectados al mismo punto de acceso y no tienen porque verse directamente entre ellos. Cuando un cliente quiere enviar un mensaje a otra estación lo envía al punto de acceso, y éste, lo reenvía hasta la estación destino; es decir, es un sistema completamente centralizado. La caída del punto de acceso inalámbrico provoca la desconexión total de la red. De aquí también podemos deducir que la zona de cobertura local es equivalente a la zona de cobertura que tenga el punto de acceso, que puede ir desde los treinta metros a cientos en las mejores condiciones posibles. Otra problemática es que ha medida que el número de estaciones crece llegando a un número considerable, el rendimiento disminuye considerablemente. Recordar que las redes inalámbricas son half-duplex, dos elementos de la red no pueden transmitir a la vez.

Fichero de configuracion II

octubre 15, 2010 by

La última vez dejé un problema sin resolver, que era la dificultad de parsear con scanf después de haber guardado el último dato que necesitas. La solución no es una solución general, es un simple truco para comprobar que después sólo haya espacios. El código es este:

#include <stdio.h>
#include <string.h>

#define SPACES " \n\t\r\v"
#define COMMENT '#'

int main()
{
    FILE* file;

    file = fopen("meshias.cfg", "r");

    if(!file)
    {
        perror("File couldn't not be opened");
        return -1;
    }

    char key[64], value[256];
    char line[512];

    int bytes = 0;
    int n_line = 0;
    char *pos = NULL;

    while(fgets(line, 511, file))
    {
        n_line++;
        printf("%d: ", n_line);

        // Eliminar el comentario
        if (pos = strchr(line, COMMENT))
        {
            *pos = '\0';
            printf("Hay un comentario. ");
        }

        if (strlen(line) == 0)
        {
            puts("Linea vacia.");
        }
        else if (strlen(line) == 1 && strncmp(line, "\n", 1) == 0)
        {
            puts("Linea vacia.");
        }
        else if (sscanf(line, " %63s = %255s%n", key, value, &bytes) == 2)
        {
            if (strspn(&line[bytes], SPACES) == strlen(&line[bytes]))
            {
                printf("Clave: %s, Valor: %s\n", key, value);
            }
            else
            {
                puts("Linea incorrecta.");
            }
        }
        else if (strspn(line, SPACES) == strlen(line))
        {
            puts("Linea con espacios.");
        }
        else
        {
            puts("Linea incorrecta.");
        }
    }

    if(!feof(file))
    {
        perror("Error leyendo el fichero");
        return -1;
    }

    puts("El programa acabo satisfactoriamente.");

    fclose(file);

    return 0;
}

La primera diferencia es que tenemos un define donde definimos lo que queremos que aceptar como caracteres validos en una línea, en nuestro caso los ya mencionados espacios, tabulaciones y saltos de líneas. Si nos vamos a la línea 57, donde se comprueba si una línea está compuesta por SPACES, ha cambiado. Ahora se usa la función strspn. Esta función devuelve, empezando desde el principio, el número de caracteres consecutivos de la primera cadena compuestos por los caracteres de la segunda. Al comprobar que esa función devuelva el tamaño de la línea, estamos comprobando realmente que toda la línea esté compuesta por los caracteres SPACES. De está manera conseguimos suplir las carencias de scanf.

El otro caso era un poco más complejo. Necesitabamos saber si después de capturar el par clave valor, el resto de caracteres también fueran SPACES. Como vemos en la línea 46 capturamos con scanf el par, y además, el número de bytes leídos. ¿Y para qué lo hacemos? Muy sencillo. Luego comprobamos que la cadena a partir del último byte leído, también sea un conjunto de caracteres SPACES; de la misma manera que lo hicimos en el anterior caso.

Bueno y después de este pequeño truco ya podemos integrar esto en el código. Sólo hace falta comprobar un poco que ocurriría cuando se sobrepasa los buffer, pero por ahora voy a intentar centrarme en adelantar un poco el proyecto.

Fichero de configuración

octubre 13, 2010 by

Uno de los siguientes paso que quería dar en el proyecto es añadir un fichero de configuración. Las características eran muy sencillas:

  • La posibilidad de comentarios que empezarían con # y acabarían en final de línea.
  • Sentencias de tipo: clave = valor
  • Tanto la clave como el valor estarán compuestos por una sola palabra, ya sean números, letras o un conjunto de ellos sin espacios entre ellos.
  • Permitir líneas vacías.
  • Poder añadir espacios o tabulaciones en cualquier parte del fichero.
  • Detectar cualquier línea que no cumpla con lo anterior, o sea, erróneas y omitirlas.

Un primer código que realizado para parsear el fichero es el que viene a continuación. Obviamente hay que adaptarlo al código de Meshias, pero para empezar a hacer pruebas viene perfecto y puede ser ejecutado directamente.

#include <stdio.h>
#include <string.h>

#define COMMENT '#'
int main()
{
    FILE* file;

    file = fopen("meshias.cfg", "r");

    if(!file)
    {
        perror("File couldn't not be opened");
        return -1;
    }

    char key[64], value[256];
    char line[512];

    int bytes = 0;
    int n_line = 0;
    char *pos = NULL;

    while(fgets(line, 511, file))
    {
        n_line++;
        printf("%d: ", n_line);

        // Eliminar el comentario
        if (pos = strchr(line, COMMENT))
        {
            *pos = '\0';
            printf("Hay un comentario. ");
        }

        if (strlen(line) == 0)
        {
            puts("Linea vacia.");
        }
        else if (strlen(line) == 1 && strncmp(line, "\n", 1) == 0)
        {
            puts("Linea vacia.");
        }
        else if (sscanf(line, " %63s = %255s \n", key, value) == 2)
        {
            printf("Clave: %s, Valor: %s\n", key, value);
        }
        else if (sscanf(line, " \n%n", &bytes) == 0 && bytes)
        {
            puts("Linea con espacios.");
        }
        else
        {
            puts("Linea incorrecta.");
        }
    }

    if(!feof(file))
    {
        perror("Error leyendo el fichero");
        return -1;
    }

    puts("El programa acabo satisfactoriamente.");

    fclose(file);

    return 0;
}

Este va a ser el fichero de configuración, con todos los casos posibles que se me han ocurrido y que nos van a servir de guía para testear el código:

# a
          a
nada =
todo

   numero=8 # hola    y adios

   # color = verde

un coche = ruedas motor chasis
cadena = pepito grillo
una cadena = manzana

# Bien hecho
 bien = hecho

Primeramente pensé en realizar el parseo sin usar fgets, usando simplemente fscanf. El problema es que la familia scanf tiene algunas carencias difíciles de solucionar. Por ejemplo un espacio dentro de la cadena de scanf representa cualquier conjunto de cero o más espacios, tabulaciones y saltos de líneas. Vamos que representa a la expresión regular [‘ ”\t”\v”\n’]*; lo cual está muy bien la mayoría de las veces y lo desconocía al principio. Sin embargo, un caso como el que se presenta en las líneas tres y cuatro del fichero de configuración lo daría como válido cuando no queremos que no sea así. Conseguí que permitiera cualquier combinación de uno ó más de espacios y tabulaciones, pero no de cero o más: “%*[ \t\v]”. Con esa expresión puesta en la cadena de scanf obviamos los espacios y tabulaciones. El uso del asterisco hace que la expresión se omita a la hora de ser guardada en una variable. Desde luego scanf tiene algunos casos particulares como este muy curiosos. Aun queda alguno por explicar.

Para evitarme dolores de cabeza preferí usar fgets ya que me ahorraba algunos problemas. fgets va cogiendo cada línea y la mete en un buffer. Luego el parseo es sencillo.

  1. Primero eliminamos el comentario. La forma más simple que se me ocurrió fue poner el carácter de fin de cadena en la posición del #; de esta manera todas las funciones pensarán que la línea acaba ahí, que es lo que realmente queremos.
  2. Luego si la cadena es de tamaño cero es porque el comentario está al principio de la línea (línea 36).
  3. Si solamente tiene el carácter de salto de linea es una linea vacía también (línea 40).
  4. Ahora vemos si cumple el caso de que haya una sentencia con clave y valor (línea 44). Para evitar desbordamientos de buffer ponemos la longitud máxima que pueden tener las cadenas. Además añadimos un salto de línea al final que acabe así… de poca utilidad como veremos más adelante.
  5. Por último vemos si la línea es una combinación de espacios y tabulaciones (línea 48). Aquí hay un pequeño truco de scanf que consiste en usar %n. Esto devuelve el numero de bytes leídos, y se puede colocar en cualquier parte de la cadena. Eso sí, hay que respetar el orden con otros posibles argumentos de la cadena, en este caso no existe el problema porque no guardamos ningún dato de la línea. Si es mayor de uno los bytes leido es que  ha ido bien la expresión.
  6. Si ningún caso anterior se cumple es que es una linea incorrecta.

Cuando ya creí dar con el código perfecto me topé con la línea dos y once del fichero de configuración. La línea dos tiene espacios y al final un carácter. Aunque ponga un salto de línea al final de la expresión de la línea 48, no tengo forma de saber si eso se cumple. Lo mismo pasa en la línea once: hay un valor, hay un igual y hay un valor… y varios más. La función scanf devuelve el número de elementos guardados a medida que va leyendo la cadena. Si se detiene por no coincidir la entrada con la cadena, devuelve el número que haya guardado hasta ese momento. En este caso, guarda la segunda palabra y ya no guardo más, por lo que no tengo forma de comprobar que lo que venga después sean sólo espacios, tabulaciones y al final el salto de línea, ya que, se cumpla o no, la función devolverá 2.

Finalmente lo he arreglado, pero con una función que poco tiene que ver con scanf. Pero lo dejo para el próximo post que esto ha quedado un poco largo… De mientras pueden sugerir soluciones, o algún truquito para hacer con scanf.

LaTeX para la documentación

octubre 4, 2010 by

Para evitar acabar sin documentación o terminar escribiéndola en jornadas marathonianas al final del proyecto cuando todo este programado y acabado; me he propuesto ir creándola en las mismas dosis que voy avanzando en la programación. Para ello lo primero que me he propuesto ha sido aprender un poco de LaTeX. Luego he cogido la documentación de los proyecto de fin de carrera de danigm y edulix,  para hacerme una idea y crearme mi propia base. Les doy las gracias desde aquí por su trabajo.

Por ahora esa pequeña base está hecha y he escrito una minucia en la parte introductoria. A medida que vaya creando partes interesantes también las bloguearé aquí de manera que este más accesibles para todo el mundo; pero eso ya lo dejamos para otros posts.

Hasta la próxima.

Meshias en un Proyecto de Fin de Carrera

septiembre 24, 2010 by

Meshias desde hace un tiempo, aproximadamente desde Marzo del año pasado, ya cumple con las funciones básicas de descubrir rutas y responder. Aún no envía mensajes de error, ni tampoco sabemos si cumple escrupulosamente el RFC. Pero aún así es útil, de hecho le ha servido a Juan Sebastián Medina Martínez para su Proyecto de Fin de Carrera, alumno de I.T. Telecomunicaciones, esp. en Telemática, de la Universidad de Jaén. Desde aquí darle la enhorabuena por su sobresaliente en el proyecto. Utilizó Meshias como parte de su proyecto, en el que realizó muchas pruebas, que además nos sirvieron a nosotros para depurar algunos fallos.

Muchas gracias por tu colaboración, esperamos que haya sido útil y hayas disfrutado usándolo.

V Concurso Universitario de Software Libre

septiembre 23, 2010 by

¡El proyecto Meshias vuelve! por tercera o cuarta vez ya, y esperamos que esta vez sea para terminarse, si es que un proyecto de software se puede acabar. Después de muchos parones en el proyecto lo vuelvo a coger con mucha ilusión y esperanzado en sacar alguna versión útil a gran escala. En esta nueva etapa estoy yo solo, Alejandro Castaño del Castillo y es mi proyecto de fin de carrera; aunque espero que durante el desarrollo esto no siga siendo así. Me encantaría que la gente le interesase el proyecto y colaborara de cualquier manera posible: opinando, comentando, probando, programando, etc. ¡Cualquier manera es buena! Y que mejor forma de conseguir colaboración  que inscribiéndose en el  http://www.concursosoftwarelibre.org/. Aún estás a tiempo de inscribirte en http://www.concursosoftwarelibre.org/1011/inscripcion. Desde este blog deseamos un happing coding! a todos los participantes.

El blog será actualizado más asiduamente y será utilizado para algo más que para avisar de cambios en el código. Espero postear resultados de pruebas realizadas en entornos controlados y entornos reales, conclusiones obtenidas, mucha documentación creada de este proyecto y de otros similares, investigaciones sobre otros protocolos e implementaciones, etc.

Bueno esto es todo por ahora, pero tendrán noticias pronto.

Meshias 0.1 Resurrection

abril 12, 2009 by

Como lo prometido es deuda y porque más vale tarde que nunca, ya está disponible Meshias 0.1 “Resurrection”. Es la primera versión “estable” que sacamos. No pretendemos decir que no tenga bugs, pero lo hemos testeado y la funcionalidad básica está presente: ahora es el momento de que otros lo prueben y nos informen de los problemas que les surgen en sus configuraciones. Happy testing!

Comunicación por socket UNIX funcionando

abril 9, 2009 by

Pues el desarrollo del programa sigue su curso. Ya hemos completado la comunicación a través del socket unix. Ahora podemos ejecutar el demonio meshias en un terminal, y en otro distinto ejecutamos meshias-tools comunicamos con él interactivamente. Por ahora la comunicación es pobre pero es fácilmente ampliable. Por ahora nos muestra las estadísticas que se han producido, las limpia y mata al demonio, y dentro de poco también la tabla de rutas.

Se pueden crear varios clientes con distintas características y el demonio sea programado pensando en esa futuras características y poder pasar todo tipo de información. Dos clientes que nos gustaría implementar, además del básico de meshias-tools, sería un servidor web y un cliente con QT.

El servidor web podría estar hecho en python y podríamos verificar el estado del demonio desde cualquier ordenador con cualquier sistema operativo, incluso modificar parámetros propios del demonio meshias u otros, como el ESSID, ajenos a éste. De esta manera podríamos configurar sistemas sin teclado y ratón a través de la propia red, un ejemplo de ellos, son los mini-sistemas que tenemos para empezar a hacer pruebas que nos han subvencionado gracias a Pablo Neira. Placas bases pequeñas con procesador de bajo consumo (AMD Geode), memorias flash y tarjetas inalámbricas. Sería útil cargar en las memorias además del meshias, su interfaz web para poder configurarlo a través de un portátil con firefox.

El cliente QT sería una aplicación orientada al ordenador personal. En él, además de poder configurar parámetros, se podría visualizar la arquitectura de la red, que ordenadores existen en él, posibilidad de seguir explorando la red, eliminar enlaces permanentemente, ver el flujo de la red, etc. todo integrado para el escritorio KDE. Por supuesto se podría hacer para Gnome, pero tenemos más “amistad” con el de KDE.

Bueno esto ha sido todo por hoy, seguiremos avanzando para sacar meshias “resurrection”.

Nuevo logo, virtualbox

abril 7, 2009 by

Hoy he enviado por fin la revisión 100 de meshias, y como ha contado Alejandro en el post anterior, ahora prácticamente todos los bugs conocidos han sido arreglados. He estado toda esta mañana trabajando en ello. La versión 0.1 cada vez está más cerca. Danigm no sólo nos ha cedido un espacio web y nos ha montado un wiki en él sino también se ha currado un nuevo logo, cuyas semejanzas con el todopoderoso FSM no hay que menospreciar. Personalmente me parece que está genial: Meshias logo

El logo ya aparece en el wiki de meshias. En el wiki no sólo pondremos tutoriales e información para desarrolladores sino también muy pronto lo reorganizaremos para que enlace al blog, que enlace al sitio de launchpad, etc, en definitiva será un portal completo y fácil de usar que será la plataforma de entrada del proyecto en Internet.

Otra cosa de la que aun no he hablado en el blog es del nuevo método para testear Meshias que he implementado: usando máquinas virtuales que hagan de nodos de la red.

El sábado pasado estuve todo el dia configurando una máquina virtual con VirtualBox para que sirva de nodo en una red mesh virtual de sólo dos nodos (mi máquina física y la virtual), de manera que puedo usar tan solo un netbook de poca potencia como mi Acer Aspire One y usarlo para desarrollar meshias durante las vacaciones, desde el tren, desde la casa de la playa, cuando me vaya mañana a Madrid, etc.

En trunk/ hay un fichero con información para desarrolladores donde se cuenta cómo configurar el virtualbox, y he subido la imagen de la máquina virtual a los servidores de SUGUS para que quien quiera pueda probar este cómodo método para testear meshias.

Ahora el siguiente paso es usar más máquinas virtuales (por ahora sólo uso uno) y conseguir que ciertos nodos se vean entre ellos pero que no se vean todos entre todos, de manera que algunos nodos tengan que hacer de enrutadores forzosamente. Para eso Alejandro me ha sugerido usar Channel bonding / unión de interfaces, y mañana testearé eso. Si lo consigo, añadiré al tutorial cómo hacerlo. De todas formas lo ideal sería que VirtualBox permitiese decir qué máquinas ven a cuales otras, así que me he bajado el código de VirtualBox y voy a bichearlo a ver si consigo hacer un parche para conseguir eso. Sí, estoy loco por intentarlo, pero ese es el espíritu :D.