Jose Solares

Ya tenemos en nuestras manos la IP04, y como dice el titulo, el futuro es ahora, esta planta (pbx) esta basada enteramente en lo que se conoce como codigo libre/open source ya que tanto las especificaciones del hardware como el codigo del software que corre estan disponibles para cualquiera que quisiera hacer uso de los mismos.

Cuenta con 256MB de memoria flash, 64MB de RAM y un procesador blackfin BF532 de 400MHz.

Corre Linux y la telefonia esta a cargo de Asterisk

De esto es de lo que somos capaces cuando decidimos compartir.

Algunos recordaran la noticia acerca del proyecto OLPC o One Laptop Per Child (Una laptop por niño).

Bueno luego de darnos una vuelta por arstechnica, me entere que la laptop ya tiene nombre, CM1 (Children’s Machine 1). Luego de ir a la wiki del proyecto me lleve una grata sorpresa. Las especificaciónes técnicas.

Pantalla de 7.5″ de 1200×900 o un DPI de 200, una resolución mayor que el 95% de las laptops en el mercado. la cual tiene dos modos uno full color y otro el cual es legible bajo el sol. no solo eso, esto lo logra consumiendo 1 watt de poder en el modo full color y 0.2 watts en el otro. Una miseria.

El procesador es un AMD Geode de 400mhz mas que suficientes para la tarea, 128Mb de RAM y 512mb de memoria flash NAND.

El sistema operativo es full open source, un fedora a lo light. utilizara la interfaz llamada Sugar les dejo el link y una imagen para que miren unos screenshots de la misma.

Aparte trae tambien una camara de video y de fotografias, tres slots USB 2.0 y un slot para memoria SD. Tiene tambien soporte para VoIP, para lo cual cuenta con bocinas estereo integradas y de un microfono incorporados, asi como tambien puertos para equipo externo.

Aunque cuente con todo esto, la laptop utilizara nominalmente 2 watts, si solo 2 watts, ya hasta da pena si uno tiene todavia de las bombillas viejas de 100 watts.

El puerto del microfono ofrece ademas uno modo de sensor, por medio del cual los niños podrian las maquinas en termometros y osciloscopios.

El wireless estara diseñado para funcionar en un mesh, por lo que todas las computadoras en cierta area estaran conectadas entre si, y porque no hacia internet.

Que no hace esta cosa, y todo por 140$, no lograron el precio objetivo de 100$, pero por 140$ estas son una maravilla de laptop.

En septiembre estaran al parecer iniciando pruebas de campo con 500, y esperan que para noviembre empiezen a salir de las lineas de producción de Quanta.

Qué es Munin?

En Mitología Nórdica es uno de los cuervos del dios Odin. Significa Memoria.

En el ámbito de la tecnología es una herramienta que utiliza rrd para almacenar y graficar varios datos del equipo en el que lo utilicemos.

Tiene plugins para poder graficar la cantidad de accesos a nuestro servidor apache por ejemplo. o para ver cuantos canales de nuestro servidor asterisk están en uso.

Utiliza una arquitectura maestro/nodo, en el cual el maestro es el que se encarga de almacenar la información que lee periódicamente de los nodos.

La instalación y configuración son relativamente fáciles si estamos utilizando debian.

apt-get install munin munin-node

Este simple comando nos instalara lo necesario en la maquina maestra.

Luego debemos editar los archivos de configuración para agregar nodos e indicar el directorio hacia cual vamos a generar el html.

dbdir /var/lib/munin
htmldir /var/www/munin
logdir /var/log/munin
rundir /var/run/munin
tmpldir /etc/munin/templates

[www.myserver.com]
address 127.0.0.1
use_node_name yes

[www.myotherserver.com]
address 10.0.0.1
user_node_name yes

Luego simplemente necesitamos reiniciar el servicio de munin.

/etc/init.d/munin-node restart

Munin actualiza la información cada 5 minutos, luego de un tiempo de ejecución terminaremos con grafícas como estas:

Para lograr instalar munin en slackware utilicé los rpm’s que estan para suse10, los converti a tgz con rpm2tgz y los instalé en slackware. Luego tuve que crear un script de arranque especifico para slackware. También tuve que crear los links simbolicos de los plugins que deseaba utilizar e instalar algunos paquetes de perl para que funcionaran.

Lo anterior no lo detallo mucho, ya que cualquiera que haya instalado un servidor slackware para ofrecer servicios en producció sabra como realizar lo anterior.

Dave Miller ya logro arrancar al Sun Niagara utilizando el kernel de linux, este reconoce los 8 cores como 32 cpu’s. Esto ya que cada core consta de 4 threads de ejecución. Esto en una maquina con un solo procesador, a ver que tantos de estos mete Sun en una sola maquina.

Como podemos ver cada thread da un promedio de 300 bogomips, siendo 32 resultan en aproximadamente 9600 por el CPU entero, 3000 mas que nuestro Xeon de 3.0ghz. Es lo mejor en cpu que podemos conseguir si utilizamos aplicaciones con paralelismo.

Como por ejemplo Apache, lo unico malo es el bajo desempeño de punto flotante. Espero tener la oportunidad de verlo de cerca y talvez migrar nuestros servers de hosting hacia esto.

Hoy me toco a mi sufrir por los benditos inodes en una particion ext3. Asumimos que el tamaño de los archivos en promedio seria cercano a los 4mb. por lo que se creo el filesystem acorde. Ah pero no, hay una inmensa cantidad de archivos menores incluso a 1mb, por lo que tenemos la particion a uso de 50% en capacidad pero sin inodes…

A mover 80Gb de archivitos…

Como seria en ingles, Assume, making an ASS out of U and ME.

Ya esta disponible la version 2.6.15 del kernel la cual pueden descargar de kernel.org pueden ver el historial de cambios aquí uno de los cambios mas interesantes es mejor soporte para escrituras en particiones NTFS, lo que significa que ahora si podemos editar archivos en particiones NTFS y borrar o agregar informacion, pero lastimosamente todavia no se pueden crear/borrar archivos/directorios en la particion, pero que buen avance.

Desde OSNEWS nos llegan noticias de una imagen para usar con el VMWare player de SuSE Linux 10, el cual tiene ya actualizado KDE a la version 3.5, lo pueden encontrar aquí.

VMWare player es una version gratuita que podemos utilizar para ejecutar maquinas virtuales creadas con VMWare.

Note:This code expects to be using sockets blocking I/O request, to use non blocking I/O we should use libevent or a similar solution (like threads), this is outside of the scope of this code. It also assumes that we already have the server listening on a port and that we have already accepted a client connection `cliente_socket`. RCVBUFFER is 256.

char buffer[RCVBUFFER + 2];
buffer[RCVBUFFER] = 0;
char response[] = {2,6,1,0,7,1,0,2,1,6,0x81};
int  message_size,i,j;
char counter = 0;

if (( message_size = recv(client_socket, buffer,
        RCVBUFFER, 0)) < 0 )
   err_handler ("recv() failed");

if ( message_size == 17 ) {
   if ( send(client_socket, response, 11, 0) != 11 )
      err_handler ("send() failed");
} else {
   printf ( "- %d - \n", message_size );
   err_handler ("Protocol Error");
}

printf ("Starting...\n");

for (;;) {
   if (( message_size = recv(client_socket, buffer,
         RCVBUFFER, 0)) < 0 )
      err_handler ("recv() failed");

   if (message_size > 5 &amp;&amp; bufer[0] == -128)
      counter = buffer[3];
   i = (buffer[0] == -128)? 5 : 0;
   buffer[message_size + 1] = '\0';
   buffer[message_size] = '\n';

   //printf ("Capturing %d bytes\n",message_size);
   fprintf (stderr, "%s",&amp;buffer[i]);
   //printf ("Current Counter : %d\n",counter);

   if (message_size == 1) {
       if (buffer[0] == 0x50) {
          char respond[] = {0x51};
          if ( send (client_socket, respond, 1, 0) != 1)
          err_handler("send() failed");
      }
   } else {
      i = message_size - 1;
      if (buffer[i-2] == 0x20 &amp;&amp; buffer[i-1] == 0x0d &amp;&amp; 
          buffer[i] == 0x0a) {
         char respond[] = {0x40, 0x05, 0x01, ++counter, 0x81};
         if ( send (client_socket, respond, 5, 0) != 5 )
            err_handler("send() failed");
      }
   }
/* Do Something with the Data we received */
}

Draft of the Avaya RDT Protocol as it’s used in RDTT

As i didnt find any GNU/Linux Applications that could speak RDT and i had a need for a proyect at work, armed with ethereal and RDTT i did a reverse engineering of the packets captured, this is what i learned of RDT.

This Draft specifies a Server, see example code using this information here

When we start listening the RDT client sends us a 17 byte packet, albeit it has a distinct structure from other packets received, at no other time did i get a 17 byte packet in all the time i captured packets so i just send a response when i receive 17 bytes, in order to start receiving the data we want, we need to send back a response:

byte response[] = {2, 6, 1, 0, 7, 1, 0, 2, 1, 6, 0x81};

Just then do we start receiving the data:

We define a checksum-like number that the client expects to get back so it knows that we have indeed received the data :

( buffer[ 0 ] == -128 && msize > 5 )?buffer[ 3 ]:0;
or
( buffer[ 0 ] == 0x80 && msize > 5 )?buffer[ 3 ]:0;

depending on the OS and data types you want to use

buffer is a char * where we store the data received with functions recv o read
msize is an int where recv/read return the quantity of data read

We send the above checksum when we get a `200d0a` at the end of a packet, using a char[]
{0x40, 0x05, 0x01, ++checksum, 0x81};

RDT has something similar to the ping on IRC, It periodically sends us a 1 byte packet with 0x50, expecting us to send a 1 byte packet with 0x51

I hope you find this information useful.

char buffer[RCVBUFFER + 2];
buffer[RCVBUFFER] = 0;
char response[] = {2,6,1,0,7,1,0,2,1,6,0x81};
int  message_size,i,j;
char counter = 0;

if (( message_size = recv(client_socket, buffer,
        RCVBUFFER, 0)) < 0 )
   err_handler ("recv() failed");

if ( message_size == 17 ) {
   if ( send(client_socket, response, 11, 0) != 11 )
      err_handler ("send() failed");
} else {
   printf ( "- %d - \n", message_size );
   err_handler ("Protocol Error");
}

printf ("Starting...\n");

for (;;) {
   if (( message_size = recv(client_socket, buffer,
         RCVBUFFER, 0)) < 0 )
      err_handler ("recv() failed");
   counter = ( buffer[0] == -128
             && message_size > 5 )? buffer[3] : counter;
   i = (buffer[0] == -128)? 5 : 0;
   buffer[message_size + 1] = '\0';
   buffer[message_size] = '\n';

   //printf ("Capturing %d bytes\n",message_size);
   fprintf (stderr, "%s",&buffer[i]);
   //printf ("Current Counter : %d\n",counter);

   if (message_size == 1) {
       if (buffer[0] == 0x50) {
          char respond[] = {0x51};
          if ( send (client_socket, respond, 1, 0) != 1)
          err_handler("send() failed");
      }
   } else {
      i = message_size - 1;
      if (buffer[i-2] == 0x20 && buffer[i-1] == 0x0d &&
          buffer[i] == 0x0a) {
         char respond[] = {0x40, 0x05, 0x01, ++counter, 0x81};
         if ( send (client_socket, respond, 5, 0) != 5 )
            err_handler("send() failed");
      }
   }
/* Do Something with the Data we received */
}