Commit inicial

  - Código para Práctica 2.2
  - Simulación de procedimientos de predicción, interpolación
  - Librería básica para dibujos con Xlib

practica2.2/replicacion-chat/Chat.cc

@@ -0,0 +1,81 @@
+#include "Chat.h"
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+void ChatMessage::to_bin()
+{
+ alloc_data(MESSAGE_SIZE);
+
+ memset(_data, 0, MESSAGE_SIZE);
+
+ //Serializar los campos type, nick y message en el buffer _data
+}
+
+int ChatMessage::from_bin(char * bobj)
+{
+ alloc_data(MESSAGE_SIZE);
+
+ memcpy(static_cast<void *>(_data), bobj, MESSAGE_SIZE);
+
+ //Reconstruir la clase usando el buffer _data
+
+ return 0;
+}
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+void ChatServer::do_messages()
+{
+ while (true)
+ {
+ /*
+ * NOTA: los clientes están definidos con "smart pointers", es necesario
+ * crear un unique_ptr con el objeto socket recibido y usar std::move
+ * para añadirlo al vector
+ */
+
+ //Recibir Mensajes en y en función del tipo de mensaje
+ // - LOGIN: Añadir al vector clients
+ // - LOGOUT: Eliminar del vector clients
+ // - MESSAGE: Reenviar el mensaje a todos los clientes (menos el emisor)
+ }
+}
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+void ChatClient::login()
+{
+ std::string msg;
+
+ ChatMessage em(nick, msg);
+ em.type = ChatMessage::LOGIN;
+
+ socket.send(em, socket);
+}
+
+void ChatClient::logout()
+{
+ // Completar
+}
+
+void ChatClient::input_thread()
+{
+ while (true)
+ {
+ // Leer stdin con std::getline
+ // Enviar al servidor usando socket
+ }
+}
+
+void ChatClient::net_thread()
+{
+ while(true)
+ {
+ //Recibir Mensajes de red
+ //Mostrar en pantalla el mensaje de la forma "nick: mensaje"
+ }
+}
+

practica2.2/replicacion-chat/Chat.h

@@ -0,0 +1,137 @@
+#include <string>
+#include <unistd.h>
+#include <string.h>
+#include <vector>
+#include <memory>
+
+#include "Serializable.h"
+#include "Socket.h"
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
+/**
+ * Mensaje del protocolo de la aplicación de Chat
+ *
+ * +-------------------+
+ * | Tipo: uint8_t | 0 (login), 1 (mensaje), 2 (logout)
+ * +-------------------+
+ * | Nick: char[8] | Nick incluido el char terminación de cadena '\0'
+ * +-------------------+
+ * | |
+ * | Mensaje: char[80] | Mensaje incluido el char terminación de cadena '\0'
+ * | |
+ * +-------------------+
+ *
+ */
+class ChatMessage: public Serializable
+{
+public:
+ static const size_t MESSAGE_SIZE = sizeof(char) * 88 + sizeof(uint8_t);
+
+ enum MessageType
+ {
+ LOGIN = 0,
+ MESSAGE = 1,
+ LOGOUT = 2
+ };
+
+ ChatMessage(){};
+
+ ChatMessage(const std::string& n, const std::string& m):nick(n),message(m){};
+
+ void to_bin();
+
+ int from_bin(char * bobj);
+
+ uint8_t type;
+
+ std::string nick;
+ std::string message;
+};
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+/**
+ * Clase para el servidor de chat
+ */
+class ChatServer
+{
+public:
+ ChatServer(const char * s, const char * p): socket(s, p)
+ {
+ socket.bind();
+ };
+
+ /**
+ * Thread principal del servidor recive mensajes en el socket y
+ * lo distribuye a los clientes. Mantiene actualizada la lista de clientes
+ */
+ void do_messages();
+
+private:
+ /**
+ * Lista de clientes conectados al servidor de Chat, representados por
+ * su socket
+ */
+ std::vector<std::unique_ptr<Socket>> clients;
+
+ /**
+ * Socket del servidor
+ */
+ Socket socket;
+};
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+/**
+ * Clase para el cliente de chat
+ */
+class ChatClient
+{
+public:
+ /**
+ * @param s dirección del servidor
+ * @param p puerto del servidor
+ * @param n nick del usuario
+ */
+ ChatClient(const char * s, const char * p, const char * n):socket(s, p),
+ nick(n){};
+
+ /**
+ * Envía el mensaje de login al servidor
+ */
+ void login();
+
+ /**
+ * Envía el mensaje de logout al servidor
+ */
+ void logout();
+
+ /**
+ * Rutina principal para el Thread de E/S. Lee datos de STDIN (std::getline)
+ * y los envía por red vía el Socket.
+ */
+ void input_thread();
+
+ /**
+ * Rutina del thread de Red. Recibe datos de la red y los "renderiza"
+ * en STDOUT
+ */
+ void net_thread();
+
+private:
+
+ /**
+ * Socket para comunicar con el servidor
+ */
+ Socket socket;
+
+ /**
+ * Nick del usuario
+ */
+ std::string nick;
+};
+

practica2.2/replicacion-chat/ChatClient.cc

@@ -0,0 +1,14 @@
+#include <thread>
+#include "Chat.h"
+
+int main(int argc, char **argv)
+{
+ ChatClient ec(argv[1], argv[2], argv[3]);
+
+ std::thread net_thread([&ec](){ ec.net_thread(); });
+
+ ec.login();
+
+ ec.input_thread();
+}
+

practica2.2/replicacion-chat/ChatServer.cc

@@ -0,0 +1,10 @@
+#include "Chat.h"
+
+int main(int argc, char **argv)
+{
+ ChatServer es(argv[1], argv[2]);
+
+ es.do_messages();
+
+ return 0;
+}

practica2.2/replicacion-chat/Makefile

@@ -0,0 +1,23 @@
+CC=g++
+CFLAGS=-g -I.
+DEPS = Socket.h Chat.h
+OBJ = Socket.o Chat.o
+LIBS=-lpthread
+
+%.o: %.cc $(DEPS)
+ $(CC) -g -c -o $@ $< $(CFLAGS)
+
+all: cs cc
+
+cs: $(OBJ) ChatServer.o
+ g++ -o $@ $^ $(CFLAGS) $(LIBS)
+
+cc: $(OBJ) ChatClient.o
+ g++ -o $@ $^ $(CFLAGS) $(LIBS)
+
+
+.PHONY: clean
+
+clean:
+ rm -f *.o cs cc
+

practica2.2/replicacion-chat/Serializable.h

@@ -0,0 +1,90 @@
+#ifndef SERIALIZABLE_H_
+#define SERIALIZABLE_H_
+
+#include <stdlib.h>
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+/**
+ * Este interfaz debe implementarlo aquellos objetos que se transmitan por red
+ * Define una serialización sencilla para la transmisión:
+ *
+ * +--------+
+ * | | Esta es la representación binaria del objeto. Cada objeto
+ * | | deberá implementar dos métodos:
+ * | data | - to_bin() para rellenar
+ * | | - from_bin() para reconstruirse a partir de data.
+ * | | - size es el tamaño total de la región data
+ * +--------+
+ */
+class Serializable
+{
+public:
+
+ Serializable():_size(0), _data(0){};
+
+ virtual ~Serializable()
+ {
+ if ( _data != 0 )
+ {
+ free(_data);
+ }
+ }
+
+ /**
+ * Genera la representación binaria de la clase. Debe inicializar
+ * el buffer interno con la función helper alloc_data.
+ */
+ virtual void to_bin() = 0;
+
+ /**
+ * Esta función recibe un objeto serializado y lo reconstruye.
+ * @param data representación binaria del objeto
+ * @return 0 si éxito -1 en caso contrario
+ */
+ virtual int from_bin(char * data) = 0;
+
+ /**
+ * Devuelve un puntero al buffer interno con la representación del objeto.
+ * Debe inicializarse previamente via Serializable::to_bin()
+ * @return objeto serializado
+ */
+ char * data()
+ {
+ return _data;
+ }
+
+ /**
+ * @return tamaño del objeto serializado
+ */
+ int32_t size()
+ {
+ return _size;
+ }
+
+protected:
+
+ int32_t _size;
+
+ char * _data;
+
+ /**
+ * Reserva memoria para el buffer del objeto serializado
+ */
+ void alloc_data(int32_t data_size)
+ {
+ if ( _data != 0 )
+ {
+ free(_data);
+ }
+
+ _data = (char *) malloc(data_size);
+ _size = data_size;
+ }
+};
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+
+#endif /* SERIALIZABLE_H_ */