/

Para ver más imágenes ve al album England’10 de flickr.

Para empezar, este procesador de textos, no está basado en What You See Is What You Get (WYSIWYG), sino que está basado en What You See Is What You Mean (WYSIWYM), o en otras palabras, el editor le permite al usuario escribir el contenido centrándose en él, en lugar de en la apariencia del mismo, siendo lo único que tiene que hacer el escritor, marcar los textos como título, párrafo, enumeración, … de manera que se le deja la tarea de darle estilo al texto al propio editor a la hora de exportarlo. En el caso de que deseemos personalizar la apariencia final de nuestro escrito, lo único que hay que hacer es crear un nuevo estilo y aplicárselo al texto a la hora de procesarlo.

LyX se apoya en la tecnología TeX/LaTeX, dotando a estos lenguajes de una interfaz gráfica para trabajar con ellos y que no le haga falta al usuario tener conocimientos del lenguaje utilizado. Este tipo de lenguaje se utiliza en entornos profesionales, por ejemplo a la hora de crear una revista, escribir publicaciones, libros, … También es ampliamente utilizado en entornos científicos, ya que permite generar formulas matemáticas con una gran rapidez.

http://www.lyx.org/Screenshots

LyX, como ya hemos dicho, es un programa al cual se le pueden aplicar muchos estilos para dotar al texto con la apariencia deseada (sólo a la hora de exportarlo), por ejemplo, se pueden utilizar  los estilos estándar dados por los organismos pertinentes para publicaciones científicas entre otras cosas. De esta manera nos aseguramos que nuestro escrito cumple al 100% con los estándares sin tener que preocuparnos por ello lo más mínimo.

El programa nos da infinidad de opciones para crear textos, tablas, diagramas, importar imágenes, fórmulas matemáticas,… pero la cosa no acaba ahí, ya que posee una de las herramientas más importantes (a mi modo de ver) a la hora de escribir documentos profesionales de cualquier índole, y es que cuenta con un corrector que permitirá a terceras personas modificar nuestro texto sin que perdamos la versión anterior. Si bien no es el único programa en incorporar esta funcionalidad, es interesante saber que la posee, ya que no todos los procesadores de texto la tienen.

Entre los formatos en los que podemos exportar los documentos se encuentra un PDF, lo que pone el broche a una aplicación tremendamente versátil e interesante además de, ser gratuita por tratarse de un programa de código abierto.

Me explico, una vez nos registramos en la página web del servicio, hemos de bajarnos un pequeño programa que correrá como un demonio en nuestro ordenador. Este programa se encarga de monitorizar y enviar al servidor central en tiempo real los datos correspondientes al uso que le damos a nuestro equipo.

La aplicación le envía al servidor el sistema operativo usado, las aplicaciones que están corriendo en ese momento en el equipo y el tiempo de uso de cada aplicación.

Gracias a esto, si nos dirigimos a la página web de Wakoopa y nos logueamos con nuestro usuario y contraseña, seremos capaces de ver y analizar una serie de gráficas sobre el uso que le estamos dando al ordenador, tanto con aplicaciones en primer plano como con aplicaciones que se están ejecutando en segundo plano.

La página web hace a su vez de red social, y es que nos permite mantenernos en contacto con nuestros amigos y ver para qué utilizan ellos el ordenador a lo largo del día.

Una de las razones por las cuales podría vérsele a la aplicación una utilidad (más allá de la propia curiosidad personal) es que, dado que está analizando todas las aplicaciones que están corriendo en nuestro equipo, nos permitirá descubrir algunas aplicaciones que están corriendo y que un usuario inexperto podría no tener el conocimiento de que se están ejecutando. Pero la cosa va aun más allá, y es que contiene una micro-enciclopedia de programas, gracias  a la cual, podemos, de una manera muy sencilla, saber el cometido de dicha aplicación. Dicha enciclopedia está hecha al estilo de una Wikipedia, dado que cualquier usuario puede contribuir a ella, ahora bien, desconozco por completo si está utilizando el mismo motor o no. Por último mencionar que cuando estamos en la página del programa, ésta nos recomendará programas similares.

Durante este periodo de tiempo, he aprendido muchas cosas, como por ejemplo:

• Gran cantidad de programas.
• Mejoras en la programación MVC.
• Nuevas técnicas de programación en Java.
• Leves conocimientos de programación en Python y Perl.
• Nuevas culturas.
• Nuevas áreas tecnológicas de investigación y desarrollo.
• Escritura de documentos científicos.
• Nuevas culturas.
• etc.

Obviamente no todos son conocimientos que tengan cabida en este blog, pero, intentaré, a lo largo del tiempo, ir comentando aquellos temas que me parezcan de interés.

A día de hoy aun quedan unas cuantas semanaspara que salga a la luz el nuevo Ubuntu 10.10 Maverick Meerkat de forma oficial, pero no debe olvidársenos que tenemos a nuestra disposición las versiones alpha y beta de la misma para poder así, testear y reportar errores,… en definitiva poner nuestro granito de arena a tan gran proyecto. Pues bien, si tras pensarlo detenidamente (y obviamente, podemos permitirnos algunos fallos en el sistema) decidimos instalarnos la nueva versión, tenemos dos opciones:

1. Instalación nueva
2. Actualización

Dado que la nueva instalación no tiene mucho misterio, de hecho es bastante parecida a la de Debian Lenny que comentamos aquí hace unos meses, vamos a proceder a contar mediante capturas los pasos a seguir para realizar el upgrade (actualización), proceso que ya describimos anteriormente y más detenidamente en Actualizar a Ubuntu 10.04 Lucid Lynx. El primer paso a dar es escribir en consola:

~$ sudo -s

~$ update-manager -d

Con estos comandos nos conectaremos como superusuario, y ejecutaremos el gestor de actualizaciones, el cual nos indicará que está disponible para su descarga la versión 10.10, la darle al botón que cita Actualizar, nos saldrán listadas las notas de la nueva versión, las aceptamos y seguimos.

Acto seguido, el programa de actualización se preparará para la instalación y configurará las nuevas fuentes de software, tras lo cual nos informará de los paquetes que ya no tienen soporte y de los que se van a descargar, aceptamos en los dos casos.

Tras esto dará comienzo un proceso bastante largo de descarga de nuevos paquetes. El proceso de descarga puede tardar más o menos tiempo dependiendo del momento en el que hagas la actualización.

Tras la descarga e instalación de paquetes que convertirán nuestro Ubuntu en la versión 10.10. Durante el proceso de instalación es bastante probable que veamos cambios en la interfaz, es normal, a pesar de que estos no serán tan grandes que los que se pudieron observar en el proceso de actualización a Ubuntu 10.04 Lucid Lynx.

Siguiendo con la lista de acontecimientos que nos avisan en el cuadro de diálogo de las imágenes anteriores, ahora toca realizar una limpieza de los archivos del ordenador, pero como buen chico, Ubuntu nos pedirá que confirmemos el paso mediante un cuadro de diálogo similar al siguiente:

Y ya sólo nos queda reiniciar el equipo

¡Listo!, ya tenemos instalado y listo para aguantar nuestras trastadas el nuevo Ubuntu 10.10, a disfrutarlo toca.

La perfección se alcanza, no cuando no hay nada más que añadir, sino cuando ya no queda nada más que quitar.

Antoine de Saint-Exupéry

Merece la pena dedicarle un rato y leérselo…

En el artículo de hoy vamos a tratar el único tema que nos falta, el cual es el programa cliente que nos servirá a los usuarios para comunicarnos con el servidor y así, poder comunicarnos con el resto de usuarios que se encuentren conectados en un momento dado.

Si bien el cliente se basta de un sólo ejecutable, hoy vamos a tratar dicho ejecutable y otro que nos permita, mediante la redirección de descriptores de ficheros, añadirle una interfaz gráfica sencilla.

cli.c

Nos encontramos ante uno de los ficheros con la lógica esencial del cliente del chat, vamos a analizarlo paso a paso:

#include <stdio.h>
#include <stdlib.h>
// librería para manejo de strings
#include <string.h>
// librería para el uso de los sockets y las correspondientes constantes
#include <sys/socket.h>
// librería para el uso de la constante IPPROTO_TCP, in_addr, ...
#include <netinet/in.h>
// librería que nos permite hacer uso de la variable errno
#include <errno.h>
// librería de base de datos de red
#include <netdb.h>
// librería para el uso de primitivas unix
#include <unistd.h>
// librería para obtener acceso a variables como pid
#include <sys/types.h>
// librería para el manejo de señales
#include <signal.h>
// librería para mostrar la traza del programa
#include "trace.h"
// librería para gestionar los paquetes enviados y recibidos
#include "sms.h"
// librería con las flags que utilizaremos
#include "flags.h"
// incuimos la librería de tipos de datos
#include "type.h"
// incuimos la librería de herramientas para los echo
#include "tools.h"
// incluimos las librerías que nos permitirán hacer uso de SSL
#include "ssl.h"

#define DIM 1024 // definimos el tamaño de los array de textos

#define     READ    STDIN_FILENO
#define     WRITE    STDOUT_FILENO

Incluimos los archivos de cabecera o librerías necesarias para la ejecución del chat y realizamos las definiciones de tamaños, y ya puestos, definimos los descriptores de ficheros de entrada y salida con el nombre de las constantes genéricas en lugar de utilizar los números 0 para lectura y 1 para escritura.

int main(int argc, char** argv){

 int sock = 0; // declaración del socket e inicializado a 0
 int error = 0; /** declaramos una variable que nos servirá para detectar
 * errores
 */
 int serverTalk = 0;
 //socklen_t length = (socklen_t) sizeof (struct sockaddr_in); // tamaño del paquete
 //struct sockaddr_in addr; // definimos el contenedor de la dirección
 unsigned int port = 5678; /** creamos la variable que identifica el puerto
 * de conexión, siendo el puerto por defecto 5678
 */
 char dir[DIM] = "localhost"; /** definimos la cadena que contendrá a la
 * dirección del servidor, la cual, será por
 * defecto localhost
 */
 //struct hostent*  server; // estructura utilizada para la gestión de direcciones
 sms auxMsj;
 char name[DIM] = {0};
 int nbytes = 0; // contador de bytes leidos y escritos
 char aux[DIM] = {0};
 // inicializamos las variables de SSL
 BIO* bio = NULL;
 SSL_CTX* ctx = NULL;
 SSL* ssl = NULL;
 char cert[DIM] = "/usr/share/doc/libssl-dev/demos/sign/cert.pem";

Realizamos la declaración de las variables de las que vamos a hacer uso durante la ejecución del cliente, de manera que, al menos las que son genéricas las tenemos al inicio y si lo necesitamos, podemos encontrar fácilmente su definición.

//analizamos los parámetros de entrada
 int i = 0;
 for(; i < argc; i++){
 if(strcmp(argv[i], "-p") == 0){ // leemos el puerto
 if(argc <= i + 1 || isNum(argv[i+1]) == 0){
 perror("Se esperaba un número después de -p");
 exit(-1);
 }else{
 PDEBUG("INFO: Puerto identificado\n");
 i++;
 port = atoi(argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-d") == 0){ // dirección de destino
 if(argc <= i + 1){
 perror("Se esperaba una dirección después de -d");
 exit(-1);
 }else{
 PDEBUG("INFO: Destino identificado");
 i++;
 strcpy(dir, argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-cert") == 0){ // dirección de destino
 if(argc <= i + 1){
 perror("Se esperaba una ruta de certificado después de -cert");
 exit(-1);
 }else{
 PDEBUG("INFO: Destino identificado");
 i++;
 strcpy(cert, argv[i]);
 }
 continue;
 }
 }

Analizamos los parámetros de entrada, para un mayor detalle de lo que hace cada uno de los parámetros de entrada, sería conveniente hacer una lectura del archivo README.

/***********************************SSL************************************/
 PDEBUG("INFO: Iniciamos la librería SSL\n");
 SSL_load_error_strings(); // strings de error
 SSL_library_init(); // iniciams la libreria en sí
 ERR_load_BIO_strings(); // strings de error de BIO
 OpenSSL_add_all_algorithms(); // inicializamos los algoritmos de la librería

 PDEBUG("INFO: Conectando...\n");
 PDEBUG("INFO: Inicializando los punteros\n");
 ctx = SSL_CTX_new(SSLv23_client_method());
 ssl = NULL;
 PDEBUG("INFO: Cargamos el certificado\n");
 if(SSL_CTX_load_verify_locations(ctx, cert, NULL) == 0){
 char aux[] = "ERROR: No se pudo comprobar el certificado\n";
 write(WRITE, aux, strlen(aux));
 exit(-1);
 }
 PDEBUG("INFO: Inicializando BIO\n");
 bio = BIO_new_ssl_connect(ctx);
 BIO_get_ssl(bio, &ssl);
 if(ssl == 0){
 char aux[] = "ERROR: Error al crear el objeto ssl\n";
 write(WRITE, aux, strlen(aux));
 exit(-1);
 }
 PDEBUG("INFO: Estableciendo el modo de trabajo, no queremos reintentos\n");
 SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
 PDEBUG("INFO: Intentando realizar la conexión\n");
 PDEBUG("INFO: Conectando a -> ");
 sprintf(aux, "%s:%i", dir, port);
 PDEBUG(aux);PDEBUG("\n");
 BIO_set_conn_hostname(bio, aux);
 PDEBUG("INFO: Verificando la conexión\n");
 if (BIO_do_connect(bio) < 1){
 char aux[] = "ERROR: al conectar el BIO\n";
 write(WRITE, aux, strlen(aux));
 exit(-1);
 }

 PDEBUG("INFO: Conectado\n");
 PDEBUG("INFO: Esperando mensaje de bienvenida\n");

Comenzamos con la parte divertida de la película, llegados a este punto, y una vez que ya hemos leído los parámetros necesarios para la ejecución del chat, vamos a proceder a conectarnos al servidor mediante SSL, para lo cual iniciamos la librería openssl y más concretamente las funciones de SSL, creamos una nueva conexión apoyándonos en los certificados que tenemos e intentamos establecer la conexión entre el cliente y el servidor del chat proporcionando la dirección del servidor y el puerto en el cual está escuchando.

memset(&auxMsj, 0, sizeof(sms));
 if(client_read(bio, &auxMsj, sizeof(sms)) <= 0){
 PDEBUG("INFO: El socket está cerrado\n");
 perror("Error al leer contenido del socket porque está cerrado\n");
 perror("El cliente se parará\n");
 exit(-1);
 }

 // atendemos la autentificación del cliente
 do{
 bzero(aux, DIM);
 sprintf(aux, "%s ~$> %s\n", auxMsj.name, auxMsj.text);
 write(WRITE, aux, DIM);
 bzero(&auxMsj.text, SMS_LEN);

 if(auxMsj.flag == MSJ){ // si es un mensaje, solo imprimimos por la salida estandar

 memset(&auxMsj, 0, sizeof(sms));
 if(client_read(bio, &auxMsj, sizeof(sms)) <= 0){
 PDEBUG("INFO: El socket está cerrado\n");
 perror("Error al leer contenido del socket porque está cerrado\n");
 perror("El cliente se parará\n");
 exit(-1);
 }
 continue;

 }

 if(auxMsj.flag == REQ_PASS){ // si es password desactivamos el echo
 echo_off();
 }
 nbytes = read(READ, &auxMsj.text, SMS_LEN);
 if(auxMsj.flag == REQ_PASS){// si es password activamos el echo
 echo_on();
 }
 auxMsj.text[nbytes - 1] = '\0'; // eliminamos el retorno de carro

 // nos salimos?
 if(strcmp(auxMsj.text, "-x") == 0){
 PDEBUG("EXIT: Cerrando el cliente, avisando al servidor...\n");
 auxMsj.flag = CLI_EXIT;
 client_write(bio, &auxMsj, sizeof(sms));
 PDEBUG("EXIT: Cerrando el socket\n");
 shutdown(sock, 2);
 PDEBUG("EXIT: Cerrando el cliente\n");
 exit(0);
 }else{ // es un mensaje
 strcpy(name, auxMsj.text); // hacemos una copia del nombre introducido para no perderlo
 if(auxMsj.flag == REQ_TEXT){
 auxMsj.flag = REQ_AUTH;
 }else if(auxMsj.flag == REQ_PASS){ // entonces REQ_PASS
 auxMsj.flag = CHECK_PASS;
 }else if(auxMsj.flag == REQ_ROOM){ // entonces REQ_ROOM
 auxMsj.flag = CHECK_ROOM;
 }
 client_write(bio, &auxMsj, sizeof(sms));
 memset(&auxMsj, 0, sizeof(sms));
 if(client_read(bio, &auxMsj, sizeof(sms)) <= 0){
 PDEBUG("INFO: El socket está cerrado\n");
 perror("Error al leer contenido del socket porque está cerrado\n");
 perror("El cliente se parará\n");
 exit(-1);
 }
 }
 }while(auxMsj.flag != OK);

Tras recibir el mensaje de bienvenida del servidor, nos tocará autenticarnos, por lo que le enviamos al servidor nuestro usuario, la contraseña (sólo la pide si nos estamos intentando conectar con un usuario dado de alta en el chat y que por tanto es capaz de ejecutar órdenes en el servidor como apagarlo por ejemplo) y por último le indicamos en qué sala deseamos entrar para iniciar la conversación.

PDEBUG("INFO: Usuario conectado\n");
 printf("Usuario conectado...\n");

 fd_set desc, descCopy; // definimos un descriptor que contendrá nuestros descriptores
 //inicializamos la lista de conexiones
 FD_ZERO(&desc);
 // Inicio del bit descriptor sock con el valor de sock
 int fd;
 if(BIO_get_fd(bio, &fd) < 0){
 write(WRITE, "ERROR: crear le descriptor %s\n", DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }
 FD_SET (fd, &desc);
 // Inicio del bit descriptor connList con el valor del descriptor de entrada estándar
 FD_SET (READ, &desc);

Con el fin de poder atender en un sólo hilo de ejecución tanto el socket que se encuentra escuchando posibles mensajes con el servidor, como detectar nuevas entradas de texto por la entrada estándar, creamos un multiplexor, al igual que hicimos en el servidor con un par de descriptores de fichero.

while(1){
 // hacemos una copia de seguridad para asegurarnos de no perder los datos
 descCopy = desc;
 // ¿Hay algún socket listo para leer?
 PDEBUG("INFO: ¿Hay algún socket listo para leer?\n");
 error = select(fd + 1, &descCopy, NULL, NULL, NULL);
 //Comprobamos si ha ocurrido un error al ponernos a escuchar
 if(error < 0){
 write(WRITE, "ERROR: al realizar la selección {{select()}}: %s\n", DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }

 // recorriendo los sockets para ver los que están activos
 PDEBUG("INFO: recorriendo los sockets para ver los que están activos\n");
 if(FD_ISSET(fd, &descCopy)){
 PDEBUG("INFO: Nuevo mensaje recibido\n");
 if(client_read(bio, &auxMsj, sizeof(sms)) <= 0){
 PDEBUG("INFO: El socket está cerrado\n");
 perror("Error al leer contenido del socket porque está cerrado\n");
 perror("El cliente se parará\n");
 exit(-1);
 }

 switch(auxMsj.flag){
 case OK: // mensaje de aceptacion, mismo comportamiento que msj
 case MSJ:  // mensaje recibido
 if(serverTalk != 1 || strcmp(auxMsj.name, SERVER) == 0){
 PDEBUG("INFO: Recibido mensaje\n");
 sprintf(aux, "%s ~$> %s\n", auxMsj.name, auxMsj.text);
 write(WRITE, aux, strlen(aux));
 sync();
 }
 break;
 case SERV_EXIT: // el servidor se va a cerrar
 PDEBUG("EXIT: El servidor se está cerrando, se dejará de leer\n");
 shutdown(sock, SHUT_RDWR);
 sprintf(aux, "%s ~$> Servidor desconectado\n", SERVER);
 write(WRITE, aux, strlen(aux));
 sprintf(aux, "El proceso cliente se cerrará\n");
 write(WRITE, aux, strlen(aux));
 exit(0);
 break;
 default:
 sprintf(aux, "Recibido un mensaje mal formado\n");
 write(WRITE, aux, strlen(aux));
 sync();
 break;
 }
 }else if(FD_ISSET(READ, &descCopy)){
 PDEBUG("INFO: Nuevo mensaje escrito\n");

 bzero(&auxMsj.text, SMS_LEN); // inicializamos el array
 nbytes = read(READ, &auxMsj.text, SMS_LEN); // leemos de la entrada estándar
 auxMsj.text[nbytes - 1] = 0; // eliminamos el retorno de carro

 // nos salimos?
 if(strcmp(auxMsj.text, "-x") == 0 && serverTalk != 1){

 PDEBUG("EXIT: Cerrando el cliente, avisando al servidor...\n");
 auxMsj.flag = CLI_EXIT;

 }else if(strcmp(auxMsj.text, "--serv") == 0){ // queremos hablar con el servidor

 PDEBUG("SERV_ADMIN: Iniciando la comunicación directa con el servidor\n");
 sprintf(aux, "%s ~$> Iniciada conversación con el servidor\n", SERVER);
 write(WRITE, aux, strlen(aux));
 serverTalk = 1;
 continue;

 }else if(sscanf(auxMsj.text, "--mp %s", aux) == 1){ // queremos hablar con el servidor

 PDEBUG("MP: Mensaje privado detectado\n");
 strcpy(auxMsj.to, aux);
 sprintf(aux, "%s ~$> Inserte el mensaje privado\n", SERVER);
 write(WRITE, aux, strlen(aux));
 auxMsj.flag = MP;
 nbytes = read(READ, &auxMsj.text, SMS_LEN); // leemos de la entrada estándar
 auxMsj.text[nbytes - 1] = 0; // eliminamos el retorno de carro

 }else{ // es un mensaje

 if(serverTalk == 1){

 PDEBUG("SERV_ADMIN: Enviando mensaje al servidor\n");
 auxMsj.flag = SERV_ADMIN;

 if(strcmp(auxMsj.text, "exit") == 0){

 serverTalk = 0;
 sprintf(aux, "%s ~$> Envio de mensajes de configuración terminada:\n", SERVER);
 write(WRITE, aux, strlen(aux));
 continue;

 }

 }else{

 auxMsj.flag = MSJ;

 }
 }

 strcpy(auxMsj.name, name); // hacemos una copia del nombre introducido para no perderlo
 PDEBUG("INFO: Enviando mensaje...\n");
 client_write(bio, &auxMsj, sizeof(sms));
 PDEBUG("INFO: Mensaje Enviado\n");

 // nos salimos?
 if(auxMsj.flag == CLI_EXIT){

 PDEBUG("EXIT: Cerrando el socket\n");
 shutdown(sock, SHUT_RDWR);
 PDEBUG("EXIT: Cerrando el cliente\n");
 exit(0);

 }
 }
 }

 return 0;
}

Esta parte, a pesar de ser la más larga de todas con diferencia, no ha de preocuparnos demasiado, y es que lo único que hace es leer mensajes indefinidamente bien del socket o de la entrada estándar y actúa en consecuencia al descriptor de entrada de datos y en caso de ser un mensaje al Flag que tenga el mensaje, por lo que a mi modo de ver, no vale la pena detenerse demasiado en su funcionamiento.

interfaz.c

Como último fichero que creo que merece la pena comentar el interfaz.c, y es que este es un archivo gracias al cual podremos ejecutar el proceso cliente sin tocar una sola línea de código, y es que, aunque el binario cliente es autónomo por sí mismo, vale la pena decir que es un poco feo porque se ejecuta en consola, por lo que apoyándonos en un sencillo programa en java cuyo código puedes encontrar en el primer artículo de la serie, seremos capaces de añadirle una interfaz gráfica al chat gracias a la redirección de los flujos de entrada-salida.

Así que si más rollo vamos a analizar el código de este interesante programa:

int pipe_chat[2];       // definimos el pipe que va del chat a la interfaz
 int pipe_interfaz[2];   // definimos el pipe que va de la interfaz al chat

 if(
 pipe(pipe_chat) == -1 ||
 pipe(pipe_interfaz) == -1
 ){
 perror("ERROR: ocurrión un error al crear los pipes\n");
 exit(-1);
 }

 if((pid = fork()) < (pid_t)0){
 perror("ERROR: ocurrió un error al crear el proceso hijo\n");
 exit(-1);
 }

Por ahora lo único que hemos hecho es crear un par de pipes y crear un segundo proceso.

else if(pid == (pid_t)0){  // proceso hijo, es el que albergará la interfaz
 close(pipe_chat[1]);    // cerramos el descriptor de escritura del chat
 close(pipe_interfaz[0]); // cerramos el descriptor de lectura de la interfaz

 // cerramos los descriptores de entrada salida estandar
 close(STDIN_FILENO);
 close(STDOUT_FILENO);

 // redireccionamos la entrada y la salida
 dup2(pipe_chat[0], STDIN_FILENO);
 dup2(pipe_interfaz[1], STDOUT_FILENO);

 // cerramos los descriptores ya que no vamos a utilizarlos
 close(pipe_chat[0]);
 close(pipe_interfaz[1]);

 execl("/usr/bin/java", "java", "-jar", "chat.jar", (char*) 0);
 }

En el caso de que el proceso en cuestión sea el proceso hijo, le cerramos los descriptores de salida estándar, y se los reasignamos a los descriptores de nuestras pipes, de manera que ahora los descriptores de entrada-salida de la interfaz escribirán, no en consola, sino en las pipes asignadas. Por último hacemos que este hilo de ejecución, se encargue de correr la interfaz gráfica.

else{ // proceso padre
 close(pipe_interfaz [1]);    // cerramos el descriptor de escritura de la interfaz
 close(pipe_chat[0]); // cerramos el descriptor de lectura del chat

 // cerramos los descriptores de entrada salida estandar
 close(STDIN_FILENO);
 close(STDOUT_FILENO);

 // redireccionamos la entrada y la salida
 dup2(pipe_interfaz[0], STDIN_FILENO);
 dup2(pipe_chat[1], STDOUT_FILENO);

 // cerramos los descriptores ya que no vamos a utilizarlos
 close(pipe_chat[0]);
 close(pipe_interfaz[1]);

 execv("./cli5", argv);
 //execl("./cli5", "cli5", (char*) 0);

 }

En el proceso padre hacemos exactamente lo mismo que en el proceso hijo, la única diferencia es que ahora la entrada-salida estándar es asignada a los otros extremos de las pipes y que ahora ejecutamos el binario cliente.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

Database.c

Éste es un archivo de código fuente que sólo será incluido en el programa del servidor (en realidad también va a ser incluido en el programa que nos ayudará a crear la base de datos desde cero, pero la importancia de ese ejecutable es mínima y la comentaremos más adelante.

En este caso hemos decidido hacer uso del sistema de bases de dados SQLite dado que es una base de datos ligera portable y con características más que suficientes para utilizarla en nuestra pequeña aplicación.

sqlite3* db_open(char*);

El cometido de esta función es simple, simplemente abrirá la base de datos situada en el fichero que se le ha de pasar como argumento.

int db_prepare(sqlite3**);

Esta función no se utilizará en el servidor, pero será la que utilizará la aplicación que creará la base de datos en caso de que esta no exista, y su única función es la de crear las tablas necesarias en la base de datos así como el usuario administrador del chat.

int db_exec(sqlite3**, char*, int);

Esta función se encargará de ejecutar una sentencia SQL y de actuar en consecuencia dependiendo del flag que se le pase como último argumento.

int db_userExists(char*, sqlite3**);

Esta función comprueba si un usuario existe en la base de datos.

int db_checkUser(char*, char*, sqlite3**);

Esta función comprueba si un usuario asociado a una contraseña existe en la base de datos.

int db_addUser(char*, char*, int, sqlite3**);

Crea un nuevo usuario.

int db_deleteUser(char*, sqlite3**);

Elimina un usuario de la base de datos.

int db_listUser(int, sqlite3**);

Lista los usuarios en la base de datos

void db_close(sqlite3**);

Cierra la base de datos y todos los descriptores asociados a ella.

int db_addLog(sms, sqlite3**);

Añade a la tabla de logs un mensaje.

int db_getLog(int, sqlite3**);

Lista el contenido del log de la base de datos

int db_getLogPar(int, sqlite3**, char*);

Tiene un comportamiento similar al de la función anterior, sólo que esta admite parámetros para personalizar la búsqueda, como por ejemplo buscar entre dos fechas dadas.

static int callback(void*, int, char**, char**);

Función que será llamada para cada una de las filas obtenidas de una sentencia SELECT.

servFunctions.c

Este fichero es el que contiene las principales funciones del servidor de nuestro chat, en este caso el comentario de cada función está situado justo encima de su definición en un comentario.

// indica la siguiente posición libre del array de conexiones
 void nextPos(user*, int*, int*, int);
 // hace un broadcast de 'sms'
 void broadcast(user*, int*, sms, int, sqlite3*);
 // hace un multicast de 'sms'
 void multicast(user*, int*, sms, int, sqlite3*, int room);
 // autenticación
 void auth(user*, int*, int, sms, sqlite3*, room*, int);
 // autenticación con contraseña
 void authPassword(user*, int*, int, sms, sqlite3*, room*, int);
 // chequea si un nombre e usurio está en uso
 int checkName(user*, int, char*);
 // busca una conexión en el array dado un socket
 int searchConn(user*, int, int);
 // cierra una conexión dado un socket
 int closeConn(user*, int*, int, int, fd_set*, sqlite3*);
 // ejecuta el comando indicado en el servidor
 int execParams(user*, int, char*, int, int, sqlite3*, room*, int);
 //cierra todas las conexiones
 void closeAll(user*, int*);
 // enviando mesaje privado
 void mp(user*, int*, sms, int, sqlite3*);
 // buscar socket por nombre
 int searchName(user*, int, char*);
 // listar salas de chat
 void sendRoomList(SSL*, room*, int);
 // selección de una sala de chat
 void roomCheckIn(user*, int*, int, sms, sqlite3*, room*, int);
 // buscador de salas en el array
 int searchRoom(char*, room*, int);
 // añadimos una sala
 int addRoom(char*, room*, int);
 // borramos una sala
 int deleteRoom(char*, room*, int);
 // movemos todos los usuarios de una sala a otra
 int moveAllTo(user*, int*, char*, room*, int, sqlite3*, char*);

La función más extensa de este archivo es la función:

int execParams(user*, int, char*, int, int, sqlite3*, room*, int);

Esta función se encargad de, una vez comprobado que el usuario en cuestión tiene permisos para darle órdenes al servidor, analiza la petición y la ejecuta comparando el string que recibe en el campo del mensaje de la estructura sms que vimos recientemente.

serv5.c

El archivo serv5.c es uno de los pocos que vamos a analizar por completo, y es que en él podremos ver un ejemplo de servidor en c utilizando SSL mientras nos apoyamos en la librería openssl.h; a pesar de que voy a exponer todo el código de este archivo, este lo voy a poner en partes mientras añado comentarios entre medias para mejorar su comprehensión. Si quieres ejecutarlo para ver como se comporta, te recomiendo que te dirijas al primer artículo de la “saga” y te descargues el proyecto completo en lugar de copiar y pegar del código que voy a poner a continuación, pero como dicen por ahí, eres libre de hacer lo que quieras siempre y cuando cumplas con los términos de la licencia.

/**
 * @File: serv5.c
 * @Description: implements the server
 * @Group: 1
 * @Members:    Alejandro Escario Méndez
 */

#include <stdio.h>
#include <stdlib.h>
// librería para manejo de strings
#include <string.h>
// librería para el uso de los sockets y las correspondientes constantes
#include <sys/socket.h>
// librería para el uso de la constante IPPROTO_TCP, in_addr, ...
#include <netinet/in.h>
// librería para el uso de primitivas unix
#include <unistd.h>
// librería que nos permite hacer uso de la variable errno
#include <errno.h>
// librería para mostrar la traza del programa
#include "trace.h"
// librería para gestionar los paquetes enviados y recibidos
#include "sms.h"
// librería para gestionar las conexiones
#include "socket.h"
// librería con las flags que utilizaremos
#include "flags.h"
// librería con las funciones del servidor
#include "servFunctions.h"
// incuimos la librería de tipos de datos
#include "type.h"
// incluimos la librería que va a controlar la base de datos
#include "database.h"
// incluimos la librería que va a convertir el proceso en un demonio
#include "tools.h"
// incluimos las librerias de ssl
#include <openssl/ssl.h>
#include <openssl/err.h>

//tamaño de la cola de peticiones
#define Q_DIM 5 // es el valor recomendado por defecto

#define DIM 1024

Incluimos las librerías necesarias para una compilación correcta del programa y definimos un par de constantes, Q_DIM contiene el número de usuarios que puede haber en la cola de conexiones a ser aceptadas mientras que DIM nos servirá, simplemente para hacer que todos nuestros arrays de texto tengan las mismas dimensiones.

int main(int argc, char** argv){

 int sock = 0; // declaración del socket e inicializado a 0
 int error = 0; /** declaramos una variable que nos servirá para detectar
 * errores
 */
 socklen_t length = (socklen_t) sizeof (struct sockaddr_in); // tamaño del paquete
 struct sockaddr_in addr; // definimos el contenedor de la dirección
 unsigned int port = 5678; /** creamos la variable que identifica el puerto
 * de conexión, siendo el puerto por defecto 5678
 */
 int connPos = 0; // primera posición libre en el array de conexiones
 int connTam = 10; // tamaño actual del array de conexiones
 int connGrow = 10; // factor de crecimiento del array
 user* conn = NULL; // array de conexiones con los clientes
 room rooms[DIM];
 user auxConn;   // conexion auxiliar
 sms auxMsj;
 fd_set connList, connListCopy; // definimos un descriptor que contendrá nuestros sockets
 int nbytes = 0; // contador de bytes leidos y escritos
 int dbName = 0; // variable que nos permitirá configurar el nombre de la base de datos
 sqlite3* db = NULL; // descriptor de la base de datos

 char cert[DIM] = "cert"; // nombre del certificado del servidor
 char pkey[DIM] = "pkey"; // nombre del archivo con la clave privada

Declaramos una serie de variables que utilizaremos para hacer que el servidor funcione como deseemos.

La funcionalidad de cada una de las variables está más o menos explicada en los comentarios, aunque si tienes alguna duda, no dudes en preguntar.

 //analizamos los parámetros de entrada
 int i = 0;
 for(; i < argc; i++){
 if(strcmp(argv[i], "-p") == 0){ // leemos el puerto
 if(argc <= i + 1 || isNum(argv[i+1]) == 0){
 perror("Se esperaba un número después de -p");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó un puerto\n");
 i++;
 port = atoi(argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-ls") == 0){ // leemos el tamaño inicial de la lista
 if(argc <= i + 1 || isNum(argv[i+1]) == 0){
 perror("Se esperaba un número después de -ls");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó un tamaño inicial\n");
 i++;
 connTam = atoi(argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-lg") == 0){ // leemos el factor de creciemiento de la lista de conexiones
 if(argc <= i + 1 || isNum(argv[i+1]) == 0){
 perror("Se esperaba un número después de -lg\n");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó un crecimiento\n");
 i++;
 connGrow = atoi(argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-db") == 0){ // leemos el nombre de la base de datos que queremos utilizar
 if(argc <= i + 1){
 perror("Se esperaba una cadena depués de -db\n");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó un crecimiento\n");
 i++;
 dbName = i;
 }
 continue;
 }else if(strcmp(argv[i], "-cert") == 0){ // leemos el nombre del archivo del certificado
 if(argc <= i + 1){
 perror("Se esperaba una cadena depués de -cert\n");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó un certificado\n");
 i++;
 strcpy(cert, argv[i]);
 }
 continue;
 }else if(strcmp(argv[i], "-pkey") == 0){ // leemos el nombre del archivo de que contiene la clave privada
 if(argc <= i + 1){
 perror("Se esperaba una cadena depués de -pkey\n");
 exit(-1);
 }else{
 PDEBUG("ARGS: Se detectó una clave privada\n");
 i++;
 strcpy(pkey, argv[i]);
 }
 continue;
 }
 }
 

Analizamos los parámetros de entrada, la forma en la cual lo analizamos es un poco burda pero funciona que a fin de cuentas es lo que nos interesa en este manual. Para una mayor especificación del comportamiento de cada uno de los comandos puedes dirigirte al archivo README y que cuyo contenido ya hemos comentado con anterioridad.

db = db_open(
 (dbName == 0) ? "chat.db" : argv[dbName]
 );

Creamos la conexión con la base de datos, la cual se llamará de una manera u otra en función de los parámetros que le hayamos pasado al ejecutable

PDEBUG("INFO: Convertimos el proceso en un demonio\n");
 make_daemon();

Creamos un demonio según el concepto Unix, esta función puedes analizarla en el post anterior en el archivo tools.c.

 /*******************************SSL****************************************/
 PDEBUG("INFO: Inicializando la libreria SSL\n");
 SSL_library_init();
 PDEBUG("INFO: Cargamos los algoritmos SSL y los mensajes de error\n");
 OpenSSL_add_all_algorithms();
 SSL_load_error_strings();
 PDEBUG("INFO: Seleccionamos SSLv2, SSLv3 y TLSv1\n");
 SSL_METHOD *method;
 method = SSLv23_server_method();
 PDEBUG("INFO: Creamos el nuevo contexto\n");
 SSL_CTX *ctx;
 ctx = SSL_CTX_new(method);
 if(ctx == NULL) { // error
 ERR_print_errors_fp(stderr);
 _exit(-1);
 }

PDEBUG("INFO: Comprobando el certificado\n");
 if ( SSL_CTX_use_certificate_chain_file(ctx, cert) <= 0) {
 ERR_print_errors_fp(stderr);
 _exit(-1);
 }

PDEBUG("INFO: Comprobando la clav eprivada\n");
 if ( SSL_CTX_use_PrivateKey_file(ctx, pkey, SSL_FILETYPE_PEM) <= 0) {
 ERR_print_errors_fp(stderr);
 _exit(-1);
 }

PDEBUG("INFO: Comprobando que las claves pueden trabajar juntas\n");
 if ( !SSL_CTX_check_private_key(ctx) ) {
 fprintf(stderr, "Clave privada incorrecta.\n");
 _exit(-1);
 }

/*******************************SSL****************************************/
 //Creamos el socket
 PDEBUG("INFO: Creando el socket\n");
 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 //Comprobamos si ha ocurrido un error al crear el socket
 if(sock < 0){
 write(2, strcat("ERROR: creación del socket {{socket()}}: %s\n", strerror(errno)), DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }

PDEBUG("INFO: Estableciendo el puerto, origenes,...\n");
 addr.sin_family = AF_INET; // familia AF_INET
 addr.sin_port = htons(port); // definimos el puerto de conexión
 addr.sin_addr.s_addr = htonl(INADDR_ANY); // permitimos conexion de cualquiera

/* hacemos este "apaño" porque según hemos leido, http://www.wlug.org.nz/EADDRINUSE
 * hay un timeout para liberar el socket
 */
 unsigned int opt = 1;
 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))==-1) {
 write(2, "ERROR: al permitir la reutiización del puerto {{setsockopt()}}\n", DIM);
 exit(-1);
 }

// le asignamos una dirección al socket
 PDEBUG("INFO: Asignando una dirección al socket\n");
 error = bind(sock, (struct sockaddr *)&addr, length);
 //Comprobamos si ha ocurrido un error al hacer el bind
 if(error < 0){
 write(2, strcat("ERROR: {{bind()}}: %s\n", strerror(errno)), DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }

//Ponemos el servidor a escuchar para buscar nuevas conexiones
 PDEBUG("INFO: Comenzamos la escucha de l programa\n");
 error = listen(sock, Q_DIM);
 //Comprobamos si ha ocurrido un error al ponernos a escuchar
 if(error < 0){
 write(2, strcat("ERROR: al iniciar la escucha{{listen()}}: %s\n", strerror(errno)), DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }

En este último bloque de código, lo que hemos hecho es, a grandes rasgos, inicializar las librerías SSL, asignarle un certificado al servidor para que este pueda identificarse y que los clientes puedan comunicarse con él, hemos creado la conexión y le hemos asignado un puerto para la escucha de nuevas conexiones y de los mensajes de los clientes.

// realizamos la asignación inicial de memoria
 PDEBUG("INFO: Realizando asignación inicial de memoria, tamaño inicial 10\n");
 connTam = 10;
 conn = malloc(connTam * sizeof(user));
 // rellenamos el array con -1
 memset(conn, 0, connTam * sizeof(user));

Creamos y asignamos la memoria necesaria para mantener un listado de todos los clientes conectados al servidor.

//inicializamos la lista de conexiones
 FD_ZERO(&connList);
 // Inicio del bit descriptor connList con el valor de sock
 FD_SET (sock, &connList);

 PDEBUG("INFO: Creamos la sala de chat general\n");
 bzero(rooms, DIM * sizeof(room));
 strcpy(rooms[0].name, "general");

Creamos el multiplexor gracias al cual, apoyándonos en la función select(), seremos capaces de hacer escuchas de más de un descriptor de fichero ( en este caso sockets ) con un único proceso y sin tener que preocuparnos de hacer pulling.

//comenzamos a analizar conexiones
 PDEBUG("INFO: Comenzamos a analizar los sockets\n");
 while(1){
 // hacemos una copia de seguridad para asegurarnos de no perder los datos
 connListCopy = connList;
 // ¿Hay algún socket listo para leer?
 PDEBUG("INFO: ¿Hay algún socket listo para leer?\n");
 error = select(connTam + 1, &connListCopy, NULL, NULL, NULL);
 //Comprobamos si ha ocurrido un error al ponernos a escuchar
 if(error < 0){
 write(2, strcat("ERROR: al realizar la selección {{select()}}: %s\n"
 , strerror(errno)), DIM);
 // terminamos la ejecución del programa
 exit(-1);
 }

Llamamos a la función select(); para ver si hay algún descriptor de fichero listo para lectura ( también se puede ejecutar select(); para ver si hay algún descriptor de fichero listo para la escritura de datos en él, así como de otro tipo de descriptores, para más detalles visita la documentación de la función y de tu sistema operativo.

// recorriendo los sockets para ver los que están activos
 PDEBUG("INFO: recorriendo los sockets para ver los que están activos\n");
 int i = 0; // definimos un índice
 for (; i <= connTam; i++){
 // este socket está preparado para leer los datos
 if(FD_ISSET(i, &connListCopy)){
 // vemos si el socket preparado para leer es el de aceptar peticiones
 if(i == sock){
 PDEBUG("INFO: Nuevo cliente detectado, comprobando...\n");
 auxConn.sock = accept(sock, (struct sockaddr *) &addr, &length);
 if(auxConn.sock < 0){
 write(2, "ERROR: al realizar la aceptación {{accept()}}: %s\n"
 , *strerror(errno));
 // terminamos la ejecución del programa
 exit(-1);
 }

Para cada socket, comprobamos si éste es uno de los que están listos para ser leídos

/************************SSL*******************************/
 PDEBUG("INFO: Creando conexion ssl\n");
 PDEBUG("INFO: Creando conexion SSL\n");
 auxConn.ssl = SSL_new(ctx);
 PDEBUG("INFO: Asignando la conexión a SSL\n");
 SSL_set_fd(auxConn.ssl, auxConn.sock);
 PDEBUG("INFO: Aceptando la conexión SSL\n");
 error = SSL_accept(auxConn.ssl);
 if(error < 0){
 ERR_print_errors_fp(stderr);
 exit(-1);
 }
 /************************SSL*******************************/

 PDEBUG("INFO: Conexión establecida, autenticando...\n");

 memset(&auxMsj, 0, sizeof(auxMsj)); // incializamos la estructura

 PDEBUG("INFO: Solicitando autenticación\n");
 strcpy(auxMsj.text, "Usuario: "); // establecemos el texto que queremos que se muestre
 auxMsj.flag = REQ_TEXT;  // le indicamos que requerimos una respuesta con texto
 strcpy(auxMsj.name, SERVER); // nos identificamos como el servidor
 SSL_write(auxConn.ssl, &auxMsj, sizeof(sms)); // enviamos la información

 // metemos los datos de la conexión en nuestro array de conexiones
 strcpy((*(conn + connPos)).name, auxMsj.text);
 (*(conn + connPos)).sock = auxConn.sock;
 (*(conn + connPos)).ssl = auxConn.ssl;
 (*(conn + connPos)).prov = PROV;

 // Añadimos el socket a nuestra lista
 PDEBUG("INFO: Insertando socket en la lista de monitoreo\n");
 FD_SET (auxConn.sock, &connList);

 // como la peticion se ha aceptado incrementamos el contador de conexiones
 PDEBUG("INFO: Cálculo del nuevo offset\n");
 nextPos(conn, &connPos, &connTam, connGrow);

Si el socket que está listo para la lectura es el que hemos creado al levantar el servidor, quiere decir que hay un cliente que quiere conectarse, por lo que aceptamos la petición, añadimos el socket del cliente a la lista de clientes y le enviamos un mensaje de bienvenida a través de SSL.

}else{ // si no, es un cliente ya registrado

 PDEBUG("DATA: Nuevo mensaje detectado\n");
 nbytes = SSL_read((*(conn+searchConn(conn, connTam, i))).ssl, &auxMsj, sizeof(sms));
 if(nbytes > 0){ // si hemos leido más d eun byte...

 switch(auxMsj.flag){

 case CLI_EXIT: // desconexión del cliente
 closeConn(conn, &connPos, connTam, i, &connList, db);
 break;
 case SERV_ADMIN: // parámetros que ha de ejecutr el servidor
 execParams(conn, connTam, auxMsj.text, i, sock, db, rooms, DIM);
 break;
 case MSJ:  // mensaje
 multicast(conn, &connTam, auxMsj, i, db,
 (*(conn+searchConn(conn, connTam, i))).room);
 break;
 case REQ_AUTH: // vamos a leer el nombre de usuario
 auth(conn, &connTam, i, auxMsj, db, rooms, DIM);
 break;
 case CHECK_ROOM: // vamos a leer el nombre de usuario
 roomCheckIn(conn, &connTam, i, auxMsj, db, rooms, DIM);
 break;
 case CHECK_PASS:
 authPassword(conn, &connTam, i, auxMsj, db, rooms, DIM);
 break;
 case MP:
 mp(conn, &connTam, auxMsj, i, db);
 break;
 default:
 write(2, "ERROR: Recibido un mensaje mal formado\n", 39);
 break;

 }

Si el valor del descriptor no es el que se corresponde con el del socket del servidor, quiere decir que es un cliente el que nos está hablando, por lo que hemos de analizar que es lo que quiere hacer (en función del flag que nos haya llegado en el mensaje) y actuar en consecuencia.

}else{ // hemos detectado una desconexión por el cerrado de la conexión

 closeConn(conn, &connPos, connTam, i, &connList, db);

 }
 }
 }
 }
 }

 return 0;
}

Por último, en caso de que recibamos un número inferior a 0 quiere decir que ha habido un error con la conexión por lo que el socket que estamos analizando se ha caído y podemos darlo de baja en nuestra lista de clientes activos.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

A diferencia de lo que hemos hecho en el artículo anterior, en este, no vamos a comentar el código a menos que se vea necesario y que sea difícil de entender sin una mínima explicación, sino que vamos a analizar las funciones de cada uno de los ficheros de código fuente de funciones auxiliares.

type.c

En este archivo nos encontramos con una serie de funciones que nos permitirán tratar fácilmente tipos de datos como enteros, strings,… quizá el nombre del archivo no sea el más adecuado, pero es lo que hay.

int isNum(char[]);

Ésta es una de las funciones más sencillas y a la vez más útiles de las que podemos encontrarnos, y si bien es bastante probable que la implementación no sea ninguna maravilla, funciona, que para el caso es lo que nos importa, y su cometido principal es determinar si el String que se le pasa como argumento es un número entero o no lo es.

char* ltrim(char*);

char* rtrim(char*);

char* trim(char*);

Estas tres funciones las vamos a comentar juntas, ya que su cometido es muy similar, y es que la primera elimina los espacios en blanco sobrantes a la izquierda del array de caracteres que se le pasa por argumento, la segunda hace lo propio pero por la derecha, y la tercera función llama a las dos anteriormente definidas para, eliminar los espacios en blanco sobrantes a ambos lados de la cadena que se le pasa como argumento.

int addslahses(char*, int, char*);

Esta función es una burda imitación del addslashes de PHP y otros lenguajes para escapar una serie de caracteres antes de almacenar los datos en la base de datos. En este caso concreto la función sólo escapa el carácter de “comilla simple” (‘). Es una función que debería ser mejorada.

void md5_sum(unsigned char*, int, int, char*);

Por último en este archivo tenemos una función muy interesante, y es que es una función que dado un array de caracteres, es capaz de calcular su suma MD5, algo muy útil para comprobar que los datos transmitidos no han sido corrompidos o, simplemente para crear un sencillo sistema de cifrado de contraseñas en la base de datos y que no puede ser descifrado.

tools.c

En este archivo se definen una serie de funciones que nos servirán para tratar con la consola o bash desde la que ejecutamos nuestro programa.

void echo_on(void);

Esta función habilita el echo por pantalla de todo aquello que tecleemos en la pantalla.

void echo_off(void);

A la inversa que la función descrita anteriormente, ésta se encarga de hacer que lo que se teclee en la bash justo después de haber sido llamada, no se haga echo por pantalla.

void make_daemon(void);

Por último tenemos una función bastante útil y que nos va a permitir desligar el programa en ejecución de la consola y hacer que se ejecute como un demonio según el concepto Unix.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

Dado que en el artículo anterior hemos explicado como hacer que un archivo de cabecera sólo se añada una vez en nuestro proyecto (evitando posibles errores de redefiniciones, …), en este artículo vamos a obviar esas partes en la explicación de  los archivos de código fuente.

Código – flags.h:

Éste es un fichero en el que no hay código, no tienen nada especial para explicar, lo único digno de mención de este fichero es que, gracias a él, seremos capaces de identificar fácilmente los tipos de mensajes, clientes,…

Código – socket.h:

Este archivo sí que tiene un poco más de “chicha” como quien dice, en este archivo de cabecera se describen, además de una serie de constantes para identificar el tipo de usuario, el tamaño de algunos campos y variables, se definen una serie de nuevos tipos de datos, el tipo de datos user y el tipo de datos room.

typedef struct usr{
 char name[NAME_LEN];    // nombre del usuario asociado al socket
 int sock;               // información referente al socket de conexión
 SSL *ssl;
 int prov;               // Flag que indica si es provisional o no la conexión
 int rol;                // flag que nos indicará el rol que le hemos asignado
 int room;               // número de la sala a la que está conectado
 }user;

En esta estructura almacenaremos el nombre del usuario asociado a un determinado socket, el socket en cuestión, un objeto de dato que nos permitirá hacer uso de métodos para la comunicación mediante SSL, el indicador de si el usuario se ha identificado, el rol que éste tiene y en qué sala de chat se encuentra.

typedef struct r{
 char name[DIM];
 }room;

Nos encontramos ante un nuevo, pequeño y extensible tipo de datos, y es que gracias a él podemos mantener un registro de las salas de chat activas.

Cabe mencionar que si bien podría ser interesante haber declarado el objeto directamente con un

typedef char name[DIM] room;

se ha hecho así para permitir posibles extensiones de la estructura.

Código – sms.h:

Por último vamos a analizar el contenido de sms.h. Este archivo contiene la definición de una de la estructura que es crucial para el desarrollo del chat, y es que es la estructura que se va utilizar para transmitir entre el cliente y el servidor y viceversa los mensajes.

typedef struct message{
 char text[SMS_LEN];     //mensaje
 time_t time;            //hora del mensaje
 char name[NAME_LEN];    //nombre del que envía el mensaje
 char to[NAME_LEN];       // nombre del destinatario
 int flag;               // flags para comunicar acciones a reaizar
 }sms;

Como puede verse fácilmente, en esta estructura se envía el contenido del mensaje, la fecha y hora en la que se envía el mensaje, el nombre del usuario que envía el mensaje, el nombre del destinatario del mensaje, en caso de que este sea un mensaje privado y un campo flag con el que seremos capaces de indicar que tipo de mensaje es el que se está transmitiendo, esto nos servirá por ejemplo para utilizar la misma estructura para hablar con varios usuarios, un único usuario o incluso directamente con el servidor.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

En este caso la macro definida tiene tres posibles comportamientos:

• No hacer nada.
• Imprimir por la salida estándar el mensaje especificado.
• Imprimir en el mensaje en cuestión en el log del sistema para poder tener constancia de qué está pasando en cada momento en el chat

Código – trace.h:

#ifndef __TRACE_H
 #define __TRACE_H

Éste es un archivo de cabecera, por lo que sólo nos interesa incluirlo una vez en nuestro proyecto, para ello comprobamos si una constante ha sido previamente definida, en este caso esa constante se llama __TRACE_H, si esta está definida previamente, no hacemos nada, mientras que si no lo está, procedemos a definirla e incluir los datos de la cabecera.

#ifndef DEBUG
 #define DEBUG 0
 #endif // DEBUG defined

Dado que para determinar el comportamiento de nuestra macro hemos de tener definida la constante DEBUG, comprobamos si está definida, y si no, le damos un valor cualquiera en este caso, un valor para que las macros se sustituyan por un “;“, es decir que tengan un comportamiento nulo.

#if DEBUG == 1
 // librería para el uso de primitivas unix
 #include <unistd.h>

 /**
 * PDEBUG(x)
 * x string
 */

 #define PDEBUG(x) \
 printf("%s", x); \
 sync();

En el caso de que la variable DEBUG valga 1, lo que haremos es imprimir por la salida estándar los mensajes de log, esto es especialmente útil para tener constancia durante el desarrollo de qué es lo que está ocurriendo en cada instante de la ejecución.

La función sync(); se encarga de limpiar los bufferes y escribir el contenido de forma definitiva el contenido en el dispositivo en cuestión. OJO al utilizar esta función, hace que también se sincronice el contenido de los discos duros, lo que puede hacer que simplemente, nos carguemos las cabeceras del mismo.

#elif DEBUG == 2
 #include <syslog.h>

 /**
 * PDEBUG(x)
 * x string
 */
 // cat /var/log/syslog
 #define PDEBUG(x) \
 syslog(LOG_DEBUG, "%s", x);

En el caso de que DEBUG tenga un valor igual a 2,  vamos a imprimir el contenido de la macro en el log del sistema con la función syslog();

 #else
 #define PDEBUG(x) ;
 #endif    // DEBUG == 1
#endif    // __TRACE_H

Y por último definimos el comportamiento por defecto de la macro, que es vaciarlo todo.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

En este artículo vamos a comentar el contenido de los ficheros de especificación y compilación del programa:

README:

Archivo en el que se especifica el funcionamiento del chat a grandes rasgos y comentando todas las funcionalidades del mismo.

El objetivo de este programa consite en el desarrollo de un chat mediante el uso de sockets
de internet TCP, por lo que en este caso seremos capaces de comunicarnos mediante
una conexión fiable entre el cliente y el servidor, siendo en este caso el cliente
un cliente múltiple que deberá recibir la información correspondiente a los mensajes
que han enviado el resto de clientes.

MANUAL DE USO

CLIENTE

El cliente es un programa que tras ejecutarlo, nos permite escribir
mensajes y al cliente, los cuales, dependiendo de la sintaxis utilizada
se comportarán en el mismo de una u otra manera, por ejemplo, si escibimos
un mensaje cualquiera, se enviará el mensaje como un mensaje de texto
normal, es decir que deseamos que se envíe al resto de usuarios del chat,
por contra si se escribe uno de los comandos en ejecución se ejecutará
la acción correspondiente y descrita en las siguientes lineas.

Al mismo tiempo, mientras el proceso nos permite enviarle mensajes al
servidor, éste está leyendo constantemente los datos que le llegan desde
el servidor.

Para ejecutar el cliente basta con ejecutar en consola:

./cli5

Si por el contrario deseamos ejecutar el cliente con una interfaz
gráfica, basta con ejecutar, para ejecutarlo hace falta la máquina
virtual java.

./interfaz

Cuando un usuario se conecte, se le mostrarán los nombres de las diferentes
salas a las que puede acceder con cadenas de la siguiente manera

– %s –

Siendo %s, el nombre de la sala, una vez que sepamos a que sala deseamos
conectarnos, tendremos que escribir el nombre de la sala tal cual aparece,
es decir el equivalente a %s

FLAGS

-p indica el puerto por el que nos conectaremos con el servidor

./cli5 -p 12345

-d indica la dirección por la que nos conectaremos con el servidor

./cli5 -d localhost

-cert indica la ruta del certificado a utilizar para conectarse con
el servidor
./cli5 -cert /usr/share/doc/libssl-dev/demos/sign/cert.pem

COMANDOS EN EJECUCIÓN

-x comando aplicable en cualquier momento, es el único comando aplicable
en el proceso de autenticación.

-x # cierra el cliente

–serv lo que se esciba en el siguiente comando, se le envia directamente
al servidor

–serv # nos indica que ahora estamos hablando con el servidor
-x # le enviamos el comando -x al servidor

Para salir del modo de conversación con el servidor (modo durante
el cual no se recibirán los mensajes enviados por el chat) habremos
de escribir ‘exit’, y volveremos al modo de chat tradicional.

SERVIDOR

El servidor es un programa que es capaz de interactuar n clientes, de
manera que estos se conectan a él y este retransmite la información.

Su uso es muy sencillo, ya que una vez ejecutado, podemos olvidarnos de
él, de hecho en el caso de que deseemos ejecutar un comando en ejecución,
hemos de, cargar un cliente y mediante el previo uso del comando
–serv, enviarle uno de los comandos permitidos durante la ejecución
y cuyo comportamiento se detalla a continuación.

En el caso de que al ejecutar el servidor, no se encuentre el fichero con
la base de datos, se creará uno y se solicitarán las credenciales del
administrador en el servidor, tras esto, todo se hará desde el cliente.

Al conectarse con el servidor, y escoger un nombre, si este no está en la
base de datos, el usuario se conectará como invitado, pudiendo sólo
enviar mensajes, si por el contrario el usuario está registrado, se le
solicitará la contraseña y tendrá el rol asignado en la base de datos

Si al ejecutar el cliente nos dice que la base de datos no existe, el
proceso terminará con un error (-1), por lo que deberemos crear dicha
base de datos ejecutando ‘./createdb nombre de la base de datos’.

ROLES
GUEST – invitado, sólo puede enviar mensajes y a su nombre se le
concaternará la cadena de texto ‘-guest’

USER – usuario, sólo puede enviar mensajes

ADMIN – administrador, además de enviar mensajes, es capaz de enviarle
comandos al servidor

FLAGS

-p indica el puerto por la que habrán de conectarse los clientes

./serv5 -p 12345

-ls indica el tamaño inicial de la lista de clientes

./serv5 -ls 100

-lg indica el factor de crecimiento de la cola

./serv5 -lg 10

-db indica el nombre de la base de datos con la que se va a interactuar

./serv5 -db chat.db

-cert indica la ruta del certificado a utilizar para conectarse con
el servidor
./serv5 -cert cert

-pkey indica la ruta de la clave privada de la que hará uso el servidor

./serv5 -pkey pkey

COMANDOS EN EJECUCIÓN estos comandos vienen desde el cliente, sólo será
capaz de comunicarse con el servidor aquellos usuarios que tengan el
rango de administrador.

-x cierra el servidor

–add-user name password [rol]
Este comando, creará un usuario con nombre ‘name’, contraseña
‘password’ y el rol indicado, por ahora se admiten los roles de
‘admin’ y ‘user’, en caso de no especificar el campo rol, el
usuario creado le srá asignado el rol ‘user’. No se podrán
crear dos usuarios con el mismo nombre.

–delete-user name
Este comando borra el usuario cuyo nombre coincida con el valor
‘name’

–list-user
Este comando lista todos los usuarios registrados en el chat

–log
Este comando imprime todas las ocurrencias del log si no se le
pasan parámetros

Se le pueden pasar dos parámetros, fecha de inicio y fecha de fin

–log dd/mm/YYYY dd/mm/YYYY

en cuyo caso se listarán sólo los log entre dos fechas

–mp [nombre]
Este comando le envía un mensaje privado al usuario llamado nombre,
el mensaje se escribirá después de haber pulsado intro después
de esta cadena.

–mp admin
mensaje para el administrador

Le envia un mensaje privado al administrador cuyo contenido es
‘mensaje para el administrador’

–add-room [nombre]
Este comando añade una nueva sala de chat llamada [nombre]

–list-room
Este comando lista todas las salas de chat

–delete-room [nombre]
Este comando borra una sala de chat llamada [nombre] y mueve los
usuarios que se encontraban en esta a la sala general

CREATEDB

Proceso que crea la base de datos con un usuario administrador.

Sólo admite un parámetro que es obligatorio y que tiene el nombre de
la base de datos a crear, es aconsejable llamar a la base de datos
chat.db ya que es el nombre por defecto de la base de datos a la que
intenta conectarse el servidor

./createDB chat.db

INSTALL:

En este fichero comentamos los requisitos mínimos para poder compilar y ejecutar el chat, así como la metodología para compilarlo.

REQUISITOS
libssl-dev
libsqlite3-dev

máquina virtual java para ejecutar la interfaz, hay que dejar claro que no es obligatoria
para el funcionamiento básico de la práctica

INSTALACION
Para compilar los fuentes en los que se entrega el código fuente,
basta con ejecutar desde consola el comando ‘make’, el cual ejecutará
por nosotros:

gcc -lpthread -ldl -lssl -lcrypto -lsqlite3 -Wall -o serv5 serv5.c servFunctions.c database.c type.c tools.c
gcc -Wall -o cli5 cli5.c type.c tools.c
gcc -lpthread -ldl -lssl -lcrypto -lsqlite3 -Wall -o createDB createDB.c database.c tools.c type.c
gcc -Wall -o interfaz interfaz.c type.c

Compilando por nosotros los programas cliente (cli5) y servidor
(serv5)

ARCHITECTURE:

Éste es un fichero en el que especificaremos la estructura de nuestro programa, orientado sobre todo a gente que tenga un poco de conocimiento a la estructura de capas y comentando de manera superficial el funcionamiento de las cosas.

***********
** CAPAS **
***********
En estas primeras entregas, nuestra aplicación consta de 2 capas, una de
presentación y una lógica, correspodiéndose la capa lógica con el servidor y la
capa de presentación de la aplicación cliente.

CLIENTE

El cliente, se encarga de, dado un mensaje que lee de teclado, encapsular el
mensaje y enviárselo al servidor, así como de realizar el proceso inverso, es
decir, partiendo de un paquete, extraer la información y presentársela al
usuario mostrando una interfaz relativamente amigable y clara.

El intercambio de mensajes entre cliente y servidor se realiza mediante paquetes
que aceptan una serie de parámetros que los programas se encargan de encapsular
y desencapsular.

SERVIDOR

En el servidor, se encuentra la parte lógica de la aplicación, es el lugar desde
el cual se controlan los usuarios conectados, revisando que en ningún momento
haya más de un usuario con el mismo nick, que los mensajes que recibe están bien
formados, así como de hacer un reparto de los mensajes que recibe del cliente
hacia el resto de clientes.

SQLITE

El servidor interactua con SQLite para obtener datos de un sistema de almacenamiento
masivo.

********************
** IMPLEMENTACIÓN **
********************

Tanto cliente como servidor están implementados en el lenguaje de programación
C y, disponibles hasta el momento sólo para equipos Unix

CLIENTE

El cliente está compuesto por los archivos cli5.c, y una serie de librerías
que comparte con el servidor, en este caso, sms.h, trace.h, socket.h y flags.h

SERVIDOR

El servidor, al igual que el cliente, está programado en c y su código está
repartido por varios ficheros, serv5.c y servFunctions.c, y se apoya en las
mismas librerias que el programa cliente y, además en el archivo de cabecera
denominado servFuctions.h, el cual contiene la declaración de las funciones
contenidas en servFunctions.c

BASE DE DATOS

Hacemos uso de SQLite para almacenar los datos que han de persistir entre sesiones

LIBRERÍAS COMUNES

sms.h – contiene la estructura que se utiliza para la comunicación entre los
diferentes procesos

socket.h – contiene la estructura con la que identificaremos las diferentes
conexiones

flags.h – contiene los flags que se utilizarán en nuestros mensajes

trace.h – contiene una macro para imprimir mensajes en el caso de estar aun en
fase de desarrollo, de manera que si se desean habilitar los mensajes de
depuración, basta con definir la constante DEBUG con un valor de 1

Makefile:

Este es el primero fichero de gran importancia que vamos a analizar, y es que es el fichero que nos permitirá compilar todos los programas con un único comando:

~$ make

El contenido del fichero es el siguiente:

do: console

console:
gcc -lpthread -ldl -lssl -lcrypto -lsqlite3 -Wall -o serv5 serv5.c servFunctions.c database.c type.c tools.c
gcc  -lssl -Wall -o cli5 cli5.c type.c tools.c ssl.c
gcc -lpthread -ldl -lssl -lcrypto -lsqlite3 -Wall -o createDB createDB.c database.c tools.c type.c
gcc -Wall -o interfaz interfaz.c type.c

Aquí, lo que estamos especificando, es que queremos ejecutar lo que hay en la etiqueta Console.

Gracias al uso de este tipo de archivos, somos capaces de compilar, en este caso, cuatro programas con un solo comando.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

Estableciendo un entorno de desarrollo

Para que el chat funcione correctamente y que podamos reutilizar tanto código como sea posile, vamos a definir la estructura de nuestro programa.

Vale la pena mencionar que si bien es una estructura en la que en un inicio puede parecer que nos sobran muchas cosas, más adelante agradeceremos enormemente haberla utilizado, tanto si hacemos público el código fuente de la aplicación como si no.

Archivos:

ARCHITECTURE: fichero en el que vamos a definir la arquitectura de nuestro chat, es decir, de qué capas consta, qué comunicación hay entre ellas,…

INSTALL: es un fichero en el que indicaremos qué pasos hay que seguir para instalar nuestra aplicación de la forma más genérica posible en una serie de máquinas, además especificaremos también las dependencias necesarias para realizar la instalación.

README: el famoso archivo que no se lee nadie, aunque parezca mentira, resulta ser de más utilidad de la que en un principio podría parecer, esto es así porque es un fichero en el que se detallan todas las funcionalidades de una aplicación o proceso (en caso de no tener un archivo man a mano), además, en este fichero podemos indicar como hemos de proceder ante determinadas situaciones.

Archivos fuente: aunque en este ejemplo no vamos a crear una estructura jerarquizada, para proyectos medianamente grandes, en cualquier lenguaje, conviene crear una jerarquía mediante el uso de carpetas, separando los ficheros por funcionalidades.

Makefile: éste es un archivo que nos permitirá compilar y ejecutar todo lo que nos sea necesario simplemente ejecutando en consola el comando “make”.

A continuación, os pongo una captura de la carpeta con los archivos que vamos a tratar a lo largo de este tutorial si es que se le puede llamar así:

• La Carpeta chat, es la que tiene los ficheros correspondientes con la interfaz gráfica de la que ya hablamos en el artículo anterior.
• Los archivos ARCHITECTURE, README, INSTALL y Makefile, ya los hemos comentado anteriormente en este mismo artículo.
• El archivo Cert.pem  es un certificado, el certificado que utilizaremos para identificar a los miembros que intervienen en la comunicación.
• chat.db es una base de datos con el log de los eventos que suceden en el servidor.
• chat.jar es el ejecutable de la interfaz gráfica.
• cli5.c es el fichero principal para el manejo del clinete.
• createDB.c es el fichero principal y que se encarga de la creación de una base de datos compatible con el programa por primera vez.
• database.c es un fichero que contiene los métodos para tratar con la base de datos.
• flags.h es un fichero de cabecera que contiene los flags para la comunicación entre cliente y servidor.
• serv5.c es el fichero principal para el manejo del servidor.
• interfaz.c es el fichero principal para el manejo de la interfaz.
• servFunctions.c y *.h son los ficheros con las funciones genéricas del servidor.
• sms.h y socket.h son unos ficheros de cabecera que contienen las estructuras necesarias para la comunicación.
• tools.c y .h, y type.c y .h contienen una serie de funciones genéricas.
• trace.h contiene una serie de macros un tanto precarias para hacer un seguimiento de qué es lo que ocurre en el chat.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

¿Cómo funciona un chat?

La respuesta es muy sencilla, al menos si no profundizamos en el tema, y es que, un chat es algo tan sencillo como dos procesos que intercambian datos entre sí. Comúnmente, estos procesos están situados en diferentes lugares, por ejemplo tenemos un proceso en el cliente, que es o debe ser una mera interfaz que se encargue de enviarle datos al otro proceso (servidor) y dejarle que este haga lo que tenga que hacer con ellos.

¿Porqué hablamos de SSL en un chat?

Muchos chats de los que utilizamos hoy en día, envían datos  por la red sin cifrar, lo que permite que un usuario malintencionado y que se sitúe entre el cliente y el servidor, sea capaz de, sin mucho problema, recoger los paquetes que pasen por ese puntos y leer su contenido.

¿Qué hay que tener en cuenta a la hora de implementar un chat?

Como ya hemos mencionado con anterioridad, vamos a trabajar con un mínimo de dos procesos, un proceso cliente y un proceso servidor, el primero de ellos viene a ser lo que un navegador a una aplicación web, ha de ser capaz de, en la medida de lo posible, dedicarse exclusivamente a mostrar los datos recibidos desde el mismo, mientras que el proceso servidor, es el que, en un principio habría de dedicarse a recibir peticiones, procesarlas y devolver una respuesta con el resultado si es que ha de hacer esto, en nuestro caso, el servidor, al recibir una petición ( un mensaje en este caso ), la analiza, detecta a quién va dirigida y se la envía a los destinatarios, los cuales estarán corriendo otros procesos cliente.

¿Qué tipos de comunicación se pueden dar en un chat?

Un usuario con los privilegios suficientes, habría de ser capaz de darle órdenes directas al servidor, de manera que así, el proceso servidor se pueda ejecutar como un demonio, en este caso, la comunicación sería unicast y unidireccional o bidireccional, dependiendo de lo que se desee hacer.

Un usuario que desee enviarle un mensaje privado a otro usuario conectado al chat, en este caso el usuario A le enviaría un mensaje al servidor con un identificador del usuario al que quiere enviarle el mensaje, el servidor, una vez haya comprobado que el usuario existe y que puede recibir mensajes privados, debe enviarle el mensaje que ha recibido del cliente A al cliente B.

Un usuario que desee enviarle un mensaje a una serie de usuarios que estén conectados al mismo, como por ejemplo en el caso de que se encuentre en una sala de chat específica.

Un usuario desea hacer un broadcast (enviarle un mensaje a todo el mundo) con un determinado mensaje.

En estos dos últimos casos, el mensaje se le envía al servidor con los flags (indicadores de la actividad que se realiza) necesarios activados para que sepa qué hacer con cada mensaje y se reenvía el mensaje a los destinatarios seleccionados.

¿Como podemos ver el funcionamiento de un chat de este estilo?

Tanto Microsoft, Google como otras empresas y usaurios han desarrollado unas estupendas herramientas para mantenernos conectados en tiempo real, pero dado que o bien no tenemos acceso al código funete de determinadas aplicaciones ( cliente/servidor ), o que no utilizan un protocolo abierto, o que son muy complicados para empezar a trabajar sobre ellos, para aprender de una manera superficial como funcionan, vamos a crear nuestro propio chat, a continuación os pongo una copia del archivo README para que veáis las funcionalidades del mismo y si os compensa seguir leyendo esta serie de artículos:

El objetivo consite en el desarrollo de un chat mediante el uso de sockets
de internet TCP, por lo que en este caso seremos capaces de comunicarnos mediante
una conexión fiable entre el cliente y el servidor, siendo en este caso el cliente
un cliente múltiple que deberá recibir la información correspondiente a los mensajes
que han enviado el resto de clientes.

MANUAL DE USO

CLIENTE

El cliente es un programa que tras ejecutarlo, nos permite escribir
mensajes y al cliente, los cuales, dependiendo de la sintaxis utilizada
se comportarán en el mismo de una u otra manera, por ejemplo, si escibimos
un mensaje cualquiera, se enviará el mensaje como un mensaje de texto
normal, es decir que deseamos que se envíe al resto de usuarios del chat,
por contra si se escribe uno de los comandos en ejecución se ejecutará
la acción correspondiente y descrita en las siguientes lineas.

Al mismo tiempo, mientras el proceso nos permite enviarle mensajes al
servidor, éste está leyendo constantemente los datos que le llegan desde
el servidor.

Para ejecutar el cliente basta con ejecutar en consola:

./cli5

Si por el contrario deseamos ejecutar el cliente con una interfaz
gráfica, basta con ejecutar, para ejecutarlo hace falta la máquina
virtual java.

./interfaz

Cuando un usuario se conecte, se le mostrarán los nombres de las diferentes
salas a las que puede acceder con cadenas de la siguiente manera

– %s –

Siendo %s, el nombre de la sala, una vez que sepamos a que sala deseamos
conectarnos, tendremos que escribir el nombre de la sala tal cual aparece,
es decir el equivalente a %s

FLAGS

-p indica el puerto por el que nos conectaremos con el servidor

./cli5 -p 12345

-d indica la dirección por la que nos conectaremos con el servidor

./cli5 -d localhost

-cert indica la ruta del certificado a utilizar para conectarse con
el servidor
./cli5 -cert /usr/share/doc/libssl-dev/demos/sign/cert.pem

COMANDOS EN EJECUCIÓN

-x comando aplicable en cualquier momento, es el único comando aplicable
en el proceso de autenticación.

-x # cierra el cliente

–serv lo que se esciba en el siguiente comando, se le envia directamente
al servidor

–serv # nos indica que ahora estamos hablando con el servidor
-x # le enviamos el comando -x al servidor

Para salir del modo de conversación con el servidor (modo durante
el cual no se recibirán los mensajes enviados por el chat) habremos
de escribir ‘exit’, y volveremos al modo de chat tradicional.

SERVIDOR

El servidor es un programa que es capaz de interactuar n clientes, de
manera que estos se conectan a él y este retransmite la información.

Su uso es muy sencillo, ya que una vez ejecutado, podemos olvidarnos de
él, de hecho en el caso de que deseemos ejecutar un comando en ejecución,
hemos de, cargar un cliente y mediante el previo uso del comando
–serv, enviarle uno de los comandos permitidos durante la ejecución
y cuyo comportamiento se detalla a continuación.

En el caso de que al ejecutar el servidor, no se encuentre el fichero con
la base de datos, se creará uno y se solicitarán las credenciales del
administrador en el servidor, tras esto, todo se hará desde el cliente.

Al conectarse con el servidor, y escoger un nombre, si este no está en la
base de datos, el usuario se conectará como invitado, pudiendo sólo
enviar mensajes, si por el contrario el usuario está registrado, se le
solicitará la contraseña y tendrá el rol asignado en la base de datos

Si al ejecutar el cliente nos dice que la base de datos no existe, el
proceso terminará con un error (-1), por lo que deberemos crear dicha
base de datos ejecutando ‘./createdb nombre de la base de datos’.

ROLES
GUEST – invitado, sólo puede enviar mensajes y a su nombre se le
concaternará la cadena de texto ‘-guest’

USER – usuario, sólo puede enviar mensajes

ADMIN – administrador, además de enviar mensajes, es capaz de enviarle
comandos al servidor

FLAGS

-p indica el puerto por la que habrán de conectarse los clientes

./serv5 -p 12345

-ls indica el tamaño inicial de la lista de clientes

./serv5 -ls 100

-lg indica el factor de crecimiento de la cola

./serv5 -lg 10

-db indica el nombre de la base de datos con la que se va a interactuar

./serv5 -db chat.db

-cert indica la ruta del certificado a utilizar para conectarse con
el servidor
./serv5 -cert cert

-pkey indica la ruta de la clave privada de la que hará uso el servidor

./serv5 -pkey pkey

COMANDOS EN EJECUCIÓN estos comandos vienen desde el cliente, sólo será
capaz de comunicarse con el servidor aquellos usuarios que tengan el
rango de administrador.

-x cierra el servidor

–add-user name password [rol]
Este comando, creará un usuario con nombre ‘name’, contraseña
‘password’ y el rol indicado, por ahora se admiten los roles de
‘admin’ y ‘user’, en caso de no especificar el campo rol, el
usuario creado le srá asignado el rol ‘user’. No se podrán
crear dos usuarios con el mismo nombre.

–delete-user name
Este comando borra el usuario cuyo nombre coincida con el valor
‘name’

–list-user
Este comando lista todos los usuarios registrados en el chat

–log
Este comando imprime todas las ocurrencias del log si no se le
pasan parámetros

Se le pueden pasar dos parámetros, fecha de inicio y fecha de fin

–log dd/mm/YYYY dd/mm/YYYY

en cuyo caso se listarán sólo los log entre dos fechas

–mp [nombre]
Este comando le envía un mensaje privado al usuario llamado nombre,
el mensaje se escribirá después de haber pulsado intro después
de esta cadena.

–mp admin
mensaje para el administrador

Le envia un mensaje privado al administrador cuyo contenido es
‘mensaje para el administrador’

–add-room [nombre]
Este comando añade una nueva sala de chat llamada [nombre]

–list-room
Este comando lista todas las salas de chat

–delete-room [nombre]
Este comando borra una sala de chat llamada [nombre] y mueve los
usuarios que se encontraban en esta a la sala general

CREATEDB

Proceso que crea la base de datos con un usuario administrador.

Sólo admite un parámetro que es obligatorio y que tiene el nombre de
la base de datos a crear, es aconsejable llamar a la base de datos
chat.db ya que es el nombre por defecto de la base de datos a la que
intenta conectarse el servidor

./createDB chat.db

El ejemplo de chat que vamos a crear está desarrollado en C bajo un entorno Unix, más concretamente Linux, y para dotarle de una interfaz gráfica, nos hemos aprovechado de las bondades del sistema de pipes unix para implementarla rápidamente en java.

Descarga:

Link: Chat C (3288)