Jose Solares

Ya pueden descargar la version 0.4 de las voces de capatres para asterisk. Agregan un nuevo sonido “Para ser atendido en españ presione…”, muy util. Tambien corrige otros pequeños errores. Les dejo el link para Descargar.

La licencia de estas voces es Creative Commons de atribució y licenciar igual. por lo que unicamente deben de hacer disponibles de la misma manera cualquier cambio/mejora que realizen a estas voces. No hay restricción alguna para uso Comercial.

A ver si hay quien se anima a hacer una version con modismos guatemaltecos.

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.

Se que todavia es pronto para afirmalo, pero ellos dicen que se tardaran meses sino años en auditar y re-codificar todo lo que se presume puede estar comprometido…

Fue un gusto ReactOS te extrañaremos. Es una pena ver como el esfuerzo de muchos se va al caño por la posible idiotez de pocos. No es seguro siquiera que tenga o no codigo comprometido, unicamente que hay partes del binario que coinciden con partes de Windows.

Pero tienen razon, es preferible volver a hacer el codigo que tener problemas de cualquier indole, es posible incluso que salgan mejor de esta de lo que se espera, ya que pueden adquirir mas experiencia en el area.

Que significa esto para WINE?
Esto es lo que quiero saber yo, ya que hay varios desarrolladores en ambos equipos.

Para los que utilizan asterisk y SIP o IAX2 les recomiendo esta version del repositorio de SVN que incorpora mejoras para arreglar el bug 5374.

El problema con este bug es que asterisk en su version estable (1.0.10 / 1.2.1) genera de manera sincronica los frames de salida, esto en base a los frames entrantes.

Los aparatos no importando el protocolo que utilizan VAD conocido tambien como Audio Supression, no envian ningun frame de audio para ahorrar ancho de banda, pero por el mismo diseño de asterisk no puede generar los paquetes salientes. El tar.gz que les pongo aca resuelve este bug, tambien lo pueden bajar de svn del servidor de asterisk.

Nota: este no es mi codigo, YMMV.

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.

Ya salio la version 1.5 del mejor navegador disponible, lo pueden bajar de la pagina de mozilla, estaremos probandolo solo termine de bajar, a ver que tal funciona.

Estuve leyendo lo que Theo de Raadt puso en openbsd-misc acerca de los cambios hechos a malloc(3), pueden encontrar una traduccion de la mayoria del mensaje en GUUG

Ahora cuando un programa en OpenBSD trate de accesar a memoria que no le fue asignada recibira una señal SIGSEGV, el famoso Segmentation Fault. Debido a esto programas que utilizen bucles para recorrer punteros asignados con malloc y no tengan bien la comparacion del final del buffer, o incluso del inicio, terminaran con Segmentation Fault en lugar de ser vulnerable a un ataque de desbordamiento.

Esto en el futuro cercano le podria dar mas dolores de cabeza a los usuarios de OpenBSD pero tambien se podran encontrar estos problemas y parcharlos, haciendo mas seguro no solo a OpenBSD si no a todo sistema operativo que utilize estos programas.

Los usuarios de Linux estaremos a la espera de ver si hacen un port o implementan una solucion similar. Pero tenemos la fortuna de que los programas que se utilizan en OpenBSD ya no tendran estos errores.

Theo habla de un caso en X, donde encontraron gracias a este nuevo malloc un problema en el codigo que tenia mas de 10 años y provocaba que el proceso se terminara sin razon en varios sistemas operativos.

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, 0×81};

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[]
{0×40, 0×05, 0×01, ++checksum, 0×81};

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

I hope you find this information useful.