int main(int argc, char **argv) {
init();
while (1) {
char str[256];
int len;
if (fgets(str, sizeof(str), stdin) == NULL) {
if (feof(stdin)) {
break;
} else {
if (errno != EINTR) {
perror("fgets");
break;
} else {
continue;
}
}
}
len = strlen(str);
/* trim newline */
if (str[len-1] == '\n') {
str[len-1] = 0;
}
if (strncmp(str, "/quit", 5) == 0) {
break;
}
multicast(str);
}
return 0;
}
int moveAllTo(user* conn, int* connTam, char* src, room* rooms, int dim, sqlite3* db, char* dst){
int i = 0;
int roomSRC = -1;
int roomDST = -1;
sms msj;
msj.flag = MSJ;
PDEBUG("INFO: Moviendo usuarios\n");
if((roomSRC = searchRoom(src, rooms, dim)) == -1 ||
(roomDST = searchRoom(dst, rooms, dim)) == -1){
PDEBUG("ERROR: Error al buscar los canales el canal ya que no se encontró\n");
return -1;
}else{
PDEBUG("INFO: Moviendo usuarios\n");
for(i = 0; i < *connTam; i++){
if((*(conn + i)).sock != 0 && (*(conn + i)).room == roomSRC){
(*(conn + i)).room = roomDST;
sprintf(msj.text, "Canal actual borrado, será movido a: %s\n", dst);
SSL_write((*(conn + i)).ssl, &msj, sizeof(sms));
sprintf(msj.text, "Usuario '%s' Conectado \n", (*(conn + i)).name);
multicast(conn, connTam, msj, 0, db, roomDST);
}
}
return 0;
}
}
bool QDmxE131Controler::listenToUniverse(quint32 u)
{
if(_listenedUniverse.contains(u))
return true;
QSharedPointer<QUdpSocket> inputSocket;
inputSocket.reset(new QUdpSocket(this));
inputSocket->setSocketOption(QAbstractSocket::MulticastLoopbackOption, true);
if(!inputSocket->bind(QHostAddress::AnyIPv4, E131_PORT, QUdpSocket::ShareAddress))
return false;
connect(inputSocket.data(), &QUdpSocket::readyRead, this, &QDmxE131Controler::readDatagram);
connect(inputSocket.data(), static_cast<void(QAbstractSocket::*)(QAbstractSocket::SocketError)>(&QAbstractSocket::error),
[=](QAbstractSocket::SocketError socketError){
qDebug() << "Socket Error! : " << socketError << inputSocket->errorString();
});
QHostAddress multicast("239.255.0." + QString::number(u+1));
if(inputSocket->joinMulticastGroup(multicast, _interface))
_listenedUniverse.insert(u, inputSocket);
else
return false;
qDebug() << "QDmxE131Plugin : " << multicast << " at entry " << _address;
return true;
}
void handle_normal(message_t* msg, node_t* sender) {
if(!is_already_in(delivered, msg)) {
// Message have not received yet
if(!is_already_in(already_received, msg)) {
GList* element = get_msg_from_list(not_received_yet, msg);
// Check is the message is already referenced in the not_received yet
if(element) {
message_element_t* msg_elmnt = (message_element_t*)element->data;
not_received_yet = g_list_remove(not_received_yet, msg_elmnt);
already_received = g_list_append(already_received, msg_elmnt);
add_ack(msg_elmnt, &my_id);
}
else {
// Completely new message
insert_message(msg, &already_received);
}
/* DEBUG_RECV("[%d][%d] Message received from [%s:%d][%d]\n", msg->node_id, msg->id, inet_ntoa(sender->inbox->infos.sin_addr), ntohs(sender->inbox->infos.sin_port), sender->inbox->fd); */
DEBUG_RECV("[%d][%d] Message received from [%d]\n", msg->node_id, msg->id, sender->id);
acknowledge(*msg);
multicast(msg, sizeof(message_t));
DEBUG_SEND("[%d][%d] Retransmited\n", msg->node_id, msg->id);
}
else {
// Message already received, we can drop it
free(msg);
msg = NULL;
}
}
else {
free(msg);
msg = NULL;
}
}
void GDMManager::startListener()
{
m_socket.bind(QHostAddress::AnyIPv4, 32412, QUdpSocket::ReuseAddressHint | QUdpSocket::ShareAddress);
QHostAddress multicast("239.0.0.250");
m_socket.joinMulticastGroup(multicast);
connect(&m_socket, &QUdpSocket::readyRead, this, &GDMManager::readData);
}
void sendservmsg(const char *msg) {
ENetPacket *packet = enet_packet_create(NULL, MAXDEFSTR+10, ENET_PACKET_FLAG_RELIABLE);
u8 *start = packet->data;
u8 *p = start+2;
putint(p, SV_SERVMSG);
sendstring(msg, p);
*(u16 *)start = ENET_HOST_TO_NET_16(int(p-start));
enet_packet_resize(packet, p-start);
multicast(packet, -1);
if (packet->referenceCount==0) enet_packet_destroy(packet);
}
int main(int argc, char *argv[]) {
int sock;
short port;
struct sockaddr_in echoserver;
struct sockaddr_in echoclient;
char buffer[BUFFSIZE];
unsigned int echolen, clientlen;
int received = 0;
if (argc != 3) {
fprintf(stderr, "USAGE: %s <server_ip> <word> \n", argv[0]);
exit(1);
}
port = multicast();
/* Create the UDP socket */
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
Die("Failed to create socket");
}
/* Construct the server sockaddr_in structure */
memset(&echoserver, 0, sizeof(echoserver)); /* Clear struct */
echoserver.sin_family = AF_INET; /* Internet/IP */
echoserver.sin_addr.s_addr = inet_addr(argv[1]); /* IP address */
echoserver.sin_port = port; /* server port */
/* Send the word to the server */
echolen = strlen(argv[2]);
if (sendto(sock, argv[2], echolen, MSG_DONTWAIT,
(struct sockaddr *) &echoserver,
sizeof(echoserver)) != echolen) {
Die("Mismatch in number of sent bytes");
}
/* Receive the word back from the server */
fprintf(stdout, "Received: ");
clientlen = sizeof(echoclient);
if ((received = recvfrom(sock, buffer, BUFFSIZE, 0,
(struct sockaddr *) &echoclient,
&clientlen)) != echolen) {
Die("Mismatch in number of received bytes");
}
/* Check that client and server are using same socket */
if (echoserver.sin_addr.s_addr != echoclient.sin_addr.s_addr) {
Die("Received a packet from an unexpected server");
}
buffer[received] = '\0'; /* Assure null-terminated string */
fprintf(stdout, buffer);
fprintf(stdout, "\n");
close(sock);
exit(0);
}
//
// UDP stuff
//
void sendUDPmessage( String msg, int port = 5100 )
{
IPAddress multicast( 225, 1, 1, 1 );
UDP server;
if ( server.begin( port ) )
{
server.beginPacket( multicast, port );
server.write( msg );
server.endPacket();
server.stop();
}
}
bool send_learn_message(char *ip, uint16_t port, acceptor_record* rec){
packet_header *head = generatebuffer(( sizeof(learn_msg) + size_decree(rec->value) ), accept_acks);
//size_decree(rec->value);
learn_msg *msg = (learn_msg*)head->data;
msg->acceptor_id = self_of_learners;
msg->iid = rec->iid;
msg->ballot = rec->ballot;
memcpy(&msg->value, rec->value, size_decree(rec->value));
// send to learners & proposer
mgroup send2proposer;
initmgroup(&send2proposer);
mnode proposer;
proposer.ip = ip;
proposer.port = port;
addmnode(&send2proposer, &proposer);
multicast(&acc.adaptor, &send2proposer, head);
multicast(&acc.adaptor, &mc2learner, head);
free(head);
return true;
}
void roomCheckIn(user* conn, int* connTam, int socketID, sms msj, sqlite3* db,
room* rooms, int dim){
int room = 0;
sms auxMsj;
PDEBUG("INFO: Buscando la sala\n");
room = searchRoom(msj.text, rooms, dim);
int aux = searchConn(conn, *connTam, socketID);
auxMsj.flag = MSJ;
strcpy(auxMsj.name, SERVER);
if(room < 0){ // sala no encontrada
PDEBUG("INFO: Solicitando el ingreso en una sala\n");
strcpy(auxMsj.text, "Sala inválida, Salas de chat...");
SSL_write((*(conn + aux)).ssl, &auxMsj, sizeof(sms));
sendRoomList((*(conn + aux)).ssl, rooms, dim);
PDEBUG("INFO: Pidiendo la sala\n");
auxMsj.flag = REQ_ROOM;
strcpy(auxMsj.text, "Seleccione la sala:");
SSL_write((*(conn + aux)).ssl, &auxMsj, sizeof(sms));
}else{ // sala encontrada
PDEBUG("INFO: Asignando sala y enviando mensaje de confirmación\n");
(*(conn + aux)).room = room;
auxMsj.flag = OK;
strcpy(auxMsj.text, "Conectado correctamente a la sala...");
SSL_write((*(conn + aux)).ssl, &auxMsj, sizeof(sms));
PDEBUG("INFO: Haciendo Multicast de la nueva conexión\n");
sprintf(auxMsj.text, "Usuario '%s' Conectado \n", (*(conn + aux)).name);
multicast(conn, connTam, auxMsj, socketID, db, room);
return;
}
}
/**
* Cierra una conexión dada por el socketID
*/
int closeConn(user* conn, int* connPos, int connTam, int socketID, fd_set* connList, sqlite3* db){
sms auxMsj;
int aux = searchConn(conn, connTam, socketID);
sprintf(auxMsj.text, "Usuario '%s' desconectado", (*(conn + aux)).name);
strcpy(auxMsj.name, SERVER);
auxMsj.flag = MSJ;
db_addLog(auxMsj, &db);
//cerramos el socket
PDEBUG("DESC: Cerrando el socket\n");
shutdown(socketID, SHUT_RDWR);
// borramos el descritor de nuesra lista de descriptores abiertos
PDEBUG("DESC: Eliminando el socket de la lista\n");
FD_CLR (socketID, connList);
// borramos el usuario de nuestro sistema
(*(conn + aux)).sock = 0;
*connPos = (aux < *connPos) ? socketID : *connPos;
PDEBUG("DESC: Socket cerrado\n");
multicast(conn, &connTam, auxMsj, 0, db, (*(conn + aux)).room);
return 1;
}
// server side processing of updates: does very little and most state is tracked
// client only could be extended to move more gameplay to server (at expense of
// lag)
void process(ENetPacket * packet, int sender) { // sender may be -1
const u16 len = *(u16*) packet->data;
if (ENET_NET_TO_HOST_16(len)!=packet->dataLength) {
disconnect_client(sender, "packet length");
return;
}
u8 *end = packet->data+packet->dataLength;
u8 *p = packet->data+2;
char text[MAXTRANS];
int cn = -1, type;
while (p<end) switch (type = getint(p)) {
case SV_TEXT:
sgetstr();
break;
case SV_INITC2S:
sgetstr();
strcpy_s(clients[cn].name, text);
sgetstr();
getint(p);
break;
case SV_MAPCHANGE: {
sgetstr();
int reqmode = getint(p);
if (reqmode<0) reqmode = 0;
if (smapname[0] && !mapreload && !vote(text, reqmode, sender)) return;
mapreload = false;
mode = reqmode;
minremain = mode&1 ? 15 : 10;
mapend = lastsec+minremain*60;
interm = 0;
strcpy_s(smapname, text);
resetitems();
sender = -1;
}
break;
case SV_ITEMLIST: {
int n;
while ((n = getint(p))!=-1) if (notgotitems) {
server_entity se = { false, 0 };
while (sents.size()<=n) sents.push_back(se);
sents[n].spawned = true;
}
notgotitems = false;
}
break;
case SV_ITEMPICKUP: {
const int n = getint(p);
pickup(n, getint(p), sender);
}
break;
case SV_PING:
send2(false, cn, SV_PONG, getint(p));
break;
case SV_POS: {
cn = getint(p);
if (cn<0 || cn>=clients.size() || clients[cn].type==ST_EMPTY) {
disconnect_client(sender, "client num");
return;
}
int size = msgsizelookup(type);
assert(size!=-1);
loopi(size-2) getint(p);
}
break;
case SV_SENDMAP: {
sgetstr();
const auto mapsize = getint(p);
sendmaps(sender, text, mapsize, p);
}
return;
case SV_RECVMAP:
send(sender, recvmap(sender));
return;
case SV_EXT: // allows for new features that require no server updates
for (int n = getint(p); n; n--) getint(p);
break;
default: {
const int size = msgsizelookup(type);
if (size==-1) { disconnect_client(sender, "tag type"); return; };
loopi(size-1) getint(p);
}
}
if (p>end) { disconnect_client(sender, "end of packet"); return; };
multicast(packet, sender);
}
void DataAggregatorActor::handleGlobalCount(const idgs::actor::ActorMessagePtr& msg) {
DVLOG_FIRST_N(2, 20) << "starting aggregator of handle count data to store.";
clientMsg = msg;
multicast(msg, ACTORID_STORE_SERVCIE, OP_INTERNAL_COUNT);
}
void DataAggregatorActor::handleGlobalTruncate(const idgs::actor::ActorMessagePtr& msg) {
DVLOG_FIRST_N(2, 20) << "multicast store truncate operation with actor id : " << getActorId();
clientMsg = msg;
resultCode = idgs::store::pb::SRC_SUCCESS;
multicast(msg, ACTORID_STORE_SERVCIE, OP_INTERNAL_TRUNCATE);
}
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
// <editor-fold defaultstate="collapsed" desc="Interpretado de parámetros de entrada">
//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;
}
}
//</editor-fold>
db = db_open(
(dbName == 0) ? "chat.db" : argv[dbName]
);
PDEBUG("INFO: Convertimos el proceso en un demonio\n");
//make_daemon();
/*******************************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);
}
// 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));
//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");
// <editor-fold defaultstate="collapsed" desc="Bucle de escucha">
//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);
}
// 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);
}
/************************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);
}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;
}
}else{ // hemos detectado una desconexión por el cerrado de la conexión
closeConn(conn, &connPos, connTam, i, &connList, db);
}
}
}
}
}//</editor-fold>
return 0;
}
