int main(void) {

	tipoConfigCPU* configuracion = cargarArchivoDeConfiguracionDeCPU("cfgCPU");

	socketCpu = crearSocket();

	conectarAServidor(socketCpu,configuracion->ipMemoria,configuracion->puertoMemoria);

	pid=19;
/*
	ejecutarInstruccion(INICIAR,4,"");
	ejecutarInstruccion(ESCRIBIR,1,"negro");
	ejecutarInstruccion(ESCRIBIR,3,"blanco");
	ejecutarInstruccion(LEER,3,"");*/

	/*ejecutarInstruccion(INICIAR,1,"");
	ejecutarInstruccion(ESCRIBIR,0,"loboNegro");
	ejecutarInstruccion(ESCRIBIR,1,"javiGorro");*/

	ejecutarInstruccion(INICIAR,3,"");
	ejecutarInstruccion(ESCRIBIR,0,"todoOk");
	ejecutarInstruccion(LEER,1,"javiGorro");

	getchar();

	liberarSocket(socketCpu);

	destruirConfigCPU(configuracion);

	return EXIT_SUCCESS;
}
int main(void) {

	tipoConfigSWAP* configuracion = cargarArchivoDeConfiguracionDeSWAP("cfgSWAP");

	int socketSwap = crearSocket();

	t_list* listaPaginas = list_create();

	asociarAPuerto(socketSwap,configuracion->puertoDeEscucha);

	escucharConexiones(socketSwap,1);

	int socketMemoria = crearSocketParaAceptarSolicitudes(socketSwap);

	while(ejecutando){

	tipoInstruccion* instruccionRecibida = recibirInstruccion(socketMemoria);

	tipoRespuesta* respuestaAMemoria = atenderInstruccion(instruccionRecibida,listaPaginas);

	enviarRespuesta(socketMemoria,respuestaAMemoria);

	}

	liberarSocket(socketMemoria);

	liberarSocket(socketSwap);

	destruirConfigSWAP(configuracion);

	return EXIT_SUCCESS;
}
Example #3
0
void* conectarseConWorkerRedGlobal(void* params){
	parametrosReduccionGlobal* parametrosConexion= malloc(sizeof(parametrosReduccionGlobal));
	respuestaReduccionGlobal* infoRedGlobal =(respuestaReduccionGlobal*) params;
	respuesta confirmacionWorker;

	int socketWorker = crearSocket();
	struct sockaddr_in direccion = cargarDireccion(infoRedGlobal->ip.cadena,infoRedGlobal->puerto);
	if(!conectarCon(direccion, socketWorker, 2)){//2 id master
		mandarFalloEnReduccion();
		return 0;
	}

	log_trace(loggerMaster, "Inicio Red. Global con Worker %d para Job %d", infoRedGlobal->numero, infoRedGlobal->job);

	struct stat fileStat;
	if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
		printf("No se pudo abrir el archivo\n");
		return 0;
	}

	int fd = open(miJob->rutaReductor.cadena,O_RDWR);
	int size = fileStat.st_size;

	parametrosConexion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
	parametrosConexion->contenidoScript.longitud = size;
	parametrosConexion->archivoTemporal.cadena = strdup(infoRedGlobal->archivoTemporal.cadena);
	parametrosConexion->archivoTemporal.longitud = infoRedGlobal->archivoTemporal.longitud;
	parametrosConexion->infoWorkers = list_create();
	list_add_all(parametrosConexion->infoWorkers,infoRedGlobal->parametros->infoWorkers);

	empaquetar(socketWorker, mensajeProcesarRedGlobal, 0, parametrosConexion);

	confirmacionWorker = desempaquetar(socketWorker);

	if (munmap(parametrosConexion->contenidoScript.cadena, parametrosConexion->contenidoScript.longitud) == -1){
		perror("Error un-mmapping the file");
		exit(EXIT_FAILURE);
	}
	close(fd);

	switch(confirmacionWorker.idMensaje){
		case mensajeOk:
		case mensajeRedGlobalCompleta:
			log_trace(loggerMaster, "Informo YAMA fin de Reduccion Global en nodo %i",infoRedGlobal->numero);
			empaquetar(socketYama, mensajeRedGlobalCompleta, 0 , 0);
			estadisticas->cantTareas[RED_GLOBAL]++;
			finalizarTiempo(estadisticas->tiempoFinRedGlobal,infoRedGlobal->numero);
			break;

		case mensajeDesconexion:
		case mensajeFalloRedGlobal:
			log_trace(loggerMaster, "Informo a  YAMA fallo en Reduccion Global del nodo %d.",infoRedGlobal->numero);
			estadisticas->cantFallos++;
			mandarFalloEnReduccion();
			break;
	}

	return 0;
}
Example #4
0
void* conectarseConWorkersTransformacion(void* params) {
	parametrosTransformacion* infoTransformacion= (parametrosTransformacion*)params;
	respuesta confirmacionWorker;
	bloqueYNodo* bloqueOK;

	int socketWorker = crearSocket();
	struct sockaddr_in direccion = cargarDireccion(infoTransformacion->ip.cadena,infoTransformacion->puerto);
	if(!conectarCon(direccion, socketWorker, 2)){//2 id master
		mandarAReplanificar(infoTransformacion);
		return 0;

	}

	log_trace(loggerMaster, "Conexion con Worker %d para bloque %d", infoTransformacion->numero, infoTransformacion->bloquesConSusArchivos.numBloque);

	struct stat fileStat;
	if(stat(miJob->rutaTransformador.cadena,&fileStat) < 0){
		printf("No se pudo abrir el archivo\n");
		return 0;
	}

	int fd = open(miJob->rutaTransformador.cadena,O_RDWR);
	int size = fileStat.st_size;

	infoTransformacion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
	infoTransformacion->contenidoScript.longitud = size;

	empaquetar(socketWorker, mensajeProcesarTransformacion, 0, infoTransformacion);

	confirmacionWorker = desempaquetar(socketWorker);

	if (munmap(infoTransformacion->contenidoScript.cadena, infoTransformacion->contenidoScript.longitud) == -1){
		perror("Error un-mmapping the file");
		exit(EXIT_FAILURE);
	}
	close(fd);

	switch(confirmacionWorker.idMensaje){

		case mensajeTransformacionCompleta:
			log_trace(loggerMaster, "Informo a YAMA fin Transformacion para bloque %d en nodo %d.",infoTransformacion->bloquesConSusArchivos.numBloque,infoTransformacion->numero);
			bloqueOK = malloc(sizeof(bloqueYNodo));
			bloqueOK->workerId = infoTransformacion->numero;
			bloqueOK->bloque = infoTransformacion->bloquesConSusArchivos.numBloque;
			empaquetar(socketYama, mensajeTransformacionCompleta, 0 , bloqueOK);
			finalizarTiempo(estadisticas->tiempoFinTrans,bloqueOK->bloque);
			estadisticas->cantTareas[TRANSFORMACION]++;
			free(bloqueOK);
			break;

		case mensajeDesconexion:
			mandarAReplanificar(infoTransformacion);
			break;


	}
	return 0;
}
Example #5
0
void* conectarseConWorkersRedLocal(void* params){
	parametrosReduccionLocal* infoRedLocal= (parametrosReduccionLocal*)params;
	respuesta confirmacionWorker;
	int numeroNodo;

	int socketWorker = crearSocket();
	struct sockaddr_in direccion = cargarDireccion(infoRedLocal->ip.cadena,infoRedLocal->puerto);
	if(!conectarCon(direccion, socketWorker, 2)){//2 id master
		mandarFalloEnReduccion();
		return 0;

	}

	log_trace(loggerMaster, "Conexion con Worker %d para estos tmp %d", infoRedLocal->numero, list_size(infoRedLocal->archivosTemporales));

	struct stat fileStat;
	if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
		printf("No se pudo abrir el archivo\n");
		return 0;
	}

	int fd = open(miJob->rutaReductor.cadena,O_RDWR);
	int size = fileStat.st_size;

	infoRedLocal->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
	infoRedLocal->contenidoScript.longitud = size;

	empaquetar(socketWorker, mensajeProcesarRedLocal, 0, infoRedLocal);

	confirmacionWorker = desempaquetar(socketWorker);

	if (munmap(infoRedLocal->contenidoScript.cadena, infoRedLocal->contenidoScript.longitud) == -1){
		perror("Error un-mmapping the file");
		exit(EXIT_FAILURE);
	}
	close(fd);

	switch(confirmacionWorker.idMensaje){

	case mensajeRedLocalCompleta:
		log_trace(loggerMaster, "Informo a  YAMA fin Reduccion Local en nodo %d.",infoRedLocal->numero);
		numeroNodo = *(int*)confirmacionWorker.envio;
		empaquetar(socketYama, mensajeRedLocalCompleta, 0 , &numeroNodo);
		finalizarTiempo(estadisticas->tiempoFinRedLocal,numeroNodo);
		estadisticas->cantTareas[RED_LOCAL]++;
		break;

	case mensajeDesconexion:
	case mensajeFalloRedLocal:
		log_trace(loggerMaster, "Informo a  YAMA fallo en Reduccion Local en nodo %d.",infoRedLocal->numero);
		estadisticas->cantFallos++;
		mandarFalloEnReduccion();
		break;
	}
	return 0;
}
Example #6
0
void conectarseConYama(char* ip, int port) {
	socketYama = crearSocket();
	struct sockaddr_in direccion = cargarDireccion(ip, port);
	conectarCon(direccion, socketYama, 2); //2 id master
	respuesta respuestaHandShake = desempaquetar(socketYama);

	if(respuestaHandShake.idMensaje != mensajeOk){
		log_error(loggerMaster, "Conexion fallida con YAMA");
		perror("Conexion fallida con YAMA");
		log_destroy(loggerMaster);
		exit(1);
	}
	log_trace(loggerMaster, "Conexion con Yama establecida");
}
Example #7
0
SocketHandler::SocketHandler
(struct sockaddr_in * addr, Lobby * lob, MyDatabase * data){
	this->db = data;
	this->lobby = lob;
	//Se crea el socket
	int * sck = crearSocket();
	this->sock_listener = sck;
	//getPort es valido solo cuando se crea, desp de acceptar una
	//conexion cambia el numero del port
	this->port = ntohs(addr->sin_port);
	this->addr = addr;
	this->keep_accepting = true;
	//bindeo, asocia sockaddr con el socket
	bind(*sock_listener, (struct sockaddr *)addr, sizeof(struct sockaddr));
}
void conectar_maestroCPU(){

	socketEscucha = crearSocket();

	asociarAPuerto(socketEscucha,puerto);

	printf(BLANCO "\n\n             Esperando Conexion de CPU...\n\n" FINDETEXTO);

	// me pongo a escuchar conexiones
	escucharConexiones(socketEscucha,5); //se bloquea hasta q haya cpus nuevas

	socketMaestro = crearSocketParaAceptarSolicitudes(socketEscucha); //


}
int main(void) {
	int socketEscuchaCPU = crearSocket();
	asociarAPuerto(socketEscuchaCPU, PUERTOCPU);
	escucharConexiones(socketEscuchaCPU, 1);
	int socketCPU = crearSocketParaAceptarSolicitudes(socketEscuchaCPU);

	while(1)
	{
		tipoInstruccion* instruccion = recibirInstruccion(socketCPU);
		printf("INSTRUCCION RECIBIDA | pID: %i | instruccion: %c | numeroDePagina: %i | texto: %s\n", instruccion->pid, instruccion->instruccion, instruccion->nroPagina, instruccion->texto);

		tipoRespuesta respuesta;
		respuesta.respuesta = 'p';
		respuesta.informacion = "contenido de la pagina";
		enviarRespuesta(socketCPU, &respuesta);
		printf("RESPUESTA ENVIADA | respuesta: %c | informacion: %s\n", respuesta.respuesta, respuesta.informacion);
	}
	liberarSocket(socketCPU);
	liberarSocket(socketEscuchaCPU);
	return EXIT_SUCCESS;
}
int conectarAServidor(char *ipDestino, unsigned short puertoDestino) {
	int socketDestino;
	tSocketInfo infoSocketDestino;
	infoSocketDestino.sin_family = AF_INET;
	infoSocketDestino.sin_port = htons(puertoDestino);
	inet_aton(ipDestino, &infoSocketDestino.sin_addr);
	memset(&(infoSocketDestino.sin_zero), '\0', 8);

	if ((socketDestino = crearSocket()) == EXIT_FAILURE) {
		perror("Error al crear socket");
		return -1;
	}

	if (connect(socketDestino, (struct sockaddr*) &infoSocketDestino, sizeof(infoSocketDestino)) == -1) {
		perror("Error al conectar socket");
		close(socketDestino);
		return -1;
	}

	return socketDestino;
}
Example #11
0
void* conectarseConWorkerAlmacenamiento(void* params){
	parametrosAlmacenamiento* parametrosConexion= malloc(sizeof(parametrosAlmacenamiento));
	respuestaAlmacenamiento* almacenamiento =(respuestaAlmacenamiento*) params;
	respuesta confirmacionWorker ;

	int socketWorker = crearSocket();
	struct sockaddr_in direccion = cargarDireccion(almacenamiento->ip.cadena,almacenamiento->puerto);
	if(!conectarCon(direccion, socketWorker, 2)){//2 id master
		mandarFalloEnReduccion();
		return 0;
	}

	log_trace(loggerMaster, "Inicio Almacenamiento Final con Worker %d", almacenamiento->nodo);

	parametrosConexion->rutaAlmacenamiento.longitud = miJob->rutaResultado.longitud;
	parametrosConexion->rutaAlmacenamiento.cadena= strdup(miJob->rutaResultado.cadena);
	parametrosConexion->archivoTemporal.cadena = strdup(almacenamiento->archivo.cadena);
	parametrosConexion->archivoTemporal.longitud = almacenamiento->archivo.longitud;

	empaquetar(socketWorker, mensajeProcesarAlmacenamiento, 0, parametrosConexion);

	confirmacionWorker = desempaquetar(socketWorker);

	switch(confirmacionWorker.idMensaje){
		case mensajeAlmacenamientoCompleto:
			log_trace(loggerMaster, "Informo YAMA fin de Almacenamiento Final en nodo.",almacenamiento->nodo);
			empaquetar(socketYama, mensajeAlmacenamientoCompleto, 0 , 0);
			break;
		case mensajeFalloAlmacenamiento:
		case mensajeDesconexion:
			log_trace(loggerMaster, "Informo a YAMA fallo en Almacenamiento Final del nodo %d.",almacenamiento->nodo);
			estadisticas->cantFallos++;
			empaquetar(socketYama, mensajeFalloAlmacenamiento, 0 , 0);
			break;
	}

	return 0;
}
int escuchar(int puertoEscucha, int socketServer, int (*funcionParaProcesarMensaje)(int, header_t*, void*, t_log*), void* extra,  t_log* logger) {

	int miPID = process_get_thread_id();
	log_info(logger, "************** Comenzamos el proceso de escucha (PID: %d) ***************", miPID);

	//Logica principal para administrar conexiones
	fd_set masterFDList; //file descriptor list
	fd_set readFDList; //file descriptor list temporal para el select()
	int maxFDNumber; //maximo numero de file descriptor para hacer las busquedas en comunicaciones

	int socketEscucha;//socket escucha
	int nuevoFD;//file descriptor del cliente aceptado
	struct sockaddr_storage remoteaddr; //dirección del cliente
	socklen_t addrlen;

	char remoteIP[INET6_ADDRSTRLEN];

	int socketActual;

	struct addrinfo hints;

	FD_ZERO(&masterFDList);	//limpiamos la lista principal
	FD_ZERO(&readFDList); //limpiamos la lista de lectura

	 //Lleno la estructura de tipo addrinfo
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	t_socket_info socketInfo;
	socketInfo.sin_addr.s_addr = INADDR_ANY;
	socketInfo.sin_family = AF_INET;
	socketInfo.sin_port = htons(puertoEscucha);
	memset(&(socketInfo.sin_zero), '\0', 8);

	socketEscucha = crearSocket();

	bindearSocketYLoguear(socketEscucha, socketInfo, logger);

	// el socket se pone en modo server
	if (listen(socketEscucha, 10) == -1) {
		log_info(logger, "listen: %s", strerror(errno));
		exit(3);
	}

	// agregamos el socket a la lista principal
	FD_SET(socketEscucha, &masterFDList);


	// guardamos el maximo numero de descriptor
	maxFDNumber = socketEscucha;
	if (socketServer > -1) {
		FD_SET(socketServer, &masterFDList);
		if (socketServer > maxFDNumber) {    // grabamos el mayor FD
			maxFDNumber = socketServer;
		}
	}

//	log_info(logger, "socketEscucha %d", socketEscucha);
//	log_info(logger, "socketServer %d", socketServer);
//	log_info(logger, "maxFDNumber %d", maxFDNumber);

	for(;;){

		readFDList = masterFDList; // copy it

		if (select(maxFDNumber+1, &readFDList, NULL, NULL, NULL) == -1) {
			log_info(logger, "select: %s", strerror(errno));
			exit(4);
		}

		// recorremos las conexiones viendo si hay datos para leer
		for(socketActual = 0; socketActual <= maxFDNumber; socketActual++) {
//			log_debug(logger, "Reviso socket %d", socketActual);
			if (FD_ISSET(socketActual, &readFDList)) { // checkeamos si hay datos

				if (socketActual == socketEscucha) {

					// manejamos conexiones nuevas
					addrlen = sizeof remoteaddr;
					nuevoFD = accept(socketEscucha, (struct sockaddr *) &remoteaddr, &addrlen);

					if (nuevoFD == -1) {
						log_error(logger, string_from_format( "Hubo un error en el accept para el fd: %i", socketActual));
					} else {
						FD_SET(nuevoFD, &masterFDList); // agregamos a la lista principal
						if (nuevoFD > maxFDNumber) {    // grabamos el mayor FD
							maxFDNumber = nuevoFD;
						}
						void* inAddr = get_in_addr((struct sockaddr*) &remoteaddr);

						log_info(logger, string_from_format("Se recibe una nueva conexion desde %s en el socket %d\n",
								inet_ntop(remoteaddr.ss_family, inAddr, remoteIP, INET6_ADDRSTRLEN), nuevoFD));
					}

				} else {

					header_t mensaje;
					int respRecibir = recibir_header_simple(socketActual, &mensaje);
					header_t* pMensaje = &mensaje;

					//if (pMensaje->tipo == ERR_CONEXION_CERRADA) {
					if (respRecibir == ERROR) {
						//Removes from master set and say good bye! :)
						close(socketActual); // bye!

						FD_CLR(socketActual, &masterFDList); // remove from master set
						log_info(logger, "El socket %d cerró la conexion.", socketActual);

					} else {
						log_debug(logger, "Recibi un header tipo: %d, tamanio: %d", pMensaje->tipo, pMensaje->largo_mensaje);
						FD_CLR(socketActual, &masterFDList); // remove from master set
						int result = funcionParaProcesarMensaje(socketActual, &mensaje, extra, logger);

						if(result == ERROR) {
							//Removes from master set and say good bye! :)
							close(socketActual); // bye!

							log_info(logger, "El socket %d cerró la conexion.", socketActual);
						} else {
							FD_SET(socketActual, &masterFDList); // agregamos a la lista principal
						}
						//FD_CLR(socketActual, &readFDList); //HACK faltaba limpiar, sino me traia los mensajes infinitamente
					}


				}
				//FD_CLR(socketActual, &readFDList); //HACK faltaba limpiar, sino me traia los mensajes infinitamente
			}
		}
	}
	return 0;
}
Example #13
0
int main (int argc,char* argv[])
{
    TPDU parameters;
    int stcp,sudp;
    char data[BUFLEN];
    struct hostent *hp;
    int fd;
    int protocol;
    sigset_t mask;
    int ret;
    int efiport;
    int addrlen;
    struct sockaddr_in myaddr_in;
    int fp;
    char titulo[50]="";

    //Comprobracion de parametros de entrada
    if(argc != 4)
    {
        fprintf(stderr,"\nError! How to use it: %s [hostname] [protocol TCP|UDP] [ordenes.txt|ordenes1.txt|ordenes2.txt]\n",argv[0]);
    }
    else
    {
        if(strcmp(argv[2],"UDP") != 0 && strcmp(argv[2],"TCP") != 0)
        {
            fprintf(stderr,"\nError! The protocol has to be TCP or UDP\n");
        }

        if(strcmp(argv[3],"ordenes.txt") != 0 && strcmp(argv[3],"ordenes1.txt") != 0 && strcmp(argv[3],"ordenes2.txt") != 0 )
        {
            fprintf(stderr,"\nError! The archive has to be ordenes.txt or ordenes1.txt or ordenes2.txt \n");
        }
    }

    //Comprobamos que protocolo es
	if(strcmp(argv[2],"UDP") == 0)
	{
        protocol = IPPROTO_UDP;
	}
	else
	{
	    protocol = IPPROTO_TCP;
	}

	memset ((char *)&myaddr_in, 0, sizeof(struct sockaddr_in));

    //Obtenemos los datos del host
    hp = gethostbyname (argv[1]);
    if (hp == NULL)
    {
        fprintf(stderr, "%s not found in /etc/hosts\n",argv[1]);
        return 1;
    }

    //Rellenamos los parametros de configuracion
    if(protocol == IPPROTO_UDP)
    {
        parameters.protocol = IPPROTO_UDP;
    }
    else
    {
        parameters.protocol = IPPROTO_TCP;
    }

    parameters.port = htons(PORT);
    parameters.server = *((struct in_addr *)(hp->h_addr));

    //creamos el socket dependiendo del protocolo
    if(protocol == IPPROTO_UDP)
    {
        //creamos el socket UDP
        sudp = crearSocket(parameters,CLIENT);
		if(sudp == -1)
		{
		    return 1;
		}

        //aqui obtenemos la informacion del socket, buscamos el puerto efimero
		addrlen = sizeof(struct sockaddr_in);
        if(getsockname(sudp, (struct sockaddr *)&myaddr_in, &addrlen) == -1)
        {
            fprintf(stderr, "%s: unable to read socket address\n", argv[0]);
            exit(1);
        }
        efiport = myaddr_in.sin_port;
    }
    else
    {
        //creamos el socket TCP
		stcp = crearSocket(parameters,CLIENT);
		if(stcp == -1)
		{
		    return 1;
		}

		//aqui obtenemos la informacion del socket, buscamos el puerto efimero
		addrlen = sizeof(struct sockaddr_in);
        if(getsockname(stcp, (struct sockaddr *)&myaddr_in, &addrlen) == -1)
        {
            fprintf(stderr, "%s: unable to read socket address\n", argv[0]);
            exit(1);
        }
        efiport = myaddr_in.sin_port;
    }

    //abrimos el fichero que hemos pasado por parametros para lectura
    fd = fopen(argv[3],"r");
    if(fd==NULL)
    {
        fprintf(stderr,"\nCan't open text file\n");
        return 1;
    }

    //nombramos al fichero con el nombre del puerto efimero
    sprintf(titulo,"%d.txt",efiport);

    //abrimos el fichero para el log
    fp = fopen(titulo, "a");
    if(fp==NULL)
    {
        fprintf(stderr,"\nCan't open log file\n");
        return 1;
    }

    //recorrer el fichero e ir enviado y recibiendo los datos contenidos en el
    while(1)
    {
        //obtenemos una frase del fichero
        fgets(data,BUFLEN,fd);

        //protocolo UDP
        if(protocol == IPPROTO_UDP)
        {
            //enviamos la frase al servidor
            ret =Enviar(sudp,data,sizeof(data),parameters);

            //comprobamos si hay problemas en el envio
            if(ret < 0)
            {
                writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,0,data);
            }
            else
            {
                //comprobamos si enviamos la palabra FIN para finalizar el cliente
                if(strcmp(data,"FIN\n") == 0 || strcmp(data,"FIN") == 0)
                {
                    close(sudp);
                    close(fd);
                    close(fp);
                    return 0;
                }

                writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,0,data);

                //recibimos los datos
                ret =Recibir(sudp,&data,sizeof(data),&parameters);

                //comprobamos si se ha producido algun error en el envio
                if(ret < 0)
                {
                    writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,1,data);

                }
                else
                {
                    writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,1,data);
                }
            }
        }

        //protocolo TCP
        if(protocol == IPPROTO_TCP)
        {
            //enviamos los datos
            ret =Enviar(stcp,data,sizeof(data),parameters);

            //comprobamos si se ha producido algun error en el envio
            if(ret < 0)
            {
                writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,0,data);
            }
            else
            {
                //comprobamos si enviamos FIN para finalizar el cliente
                if(strcmp(data,"FIN\n") == 0 || strcmp(data,"FIN") == 0)
                {
                    close(sudp);
                    close(fd);//fichero del cual obtenemos los datos
                    close(fp);//fichero del log
                    return 0;
                }

                writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,0,data);

                //recibimos los datos
                ret =Recibir(stcp,&data,sizeof(data),&parameters);

                //comprobamos si se ha producido algun error en la recepcion
                if(ret < 0)
                {
                    writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,1,data);
                }
                else
                {
                    writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,1,data);
                }
            }
        }
    }
}
void escucha(int puerto) {

	int myPID = process_get_thread_id();
	log_info(LOGGER, "************** Comienza a escuchar MaRTA a los Jobs (PID: %d) ***************",myPID);

	//Logica principal para administrar conexiones
	fd_set master; //file descriptor list
	fd_set read_fds; //file descriptor list temporal para el select()
	int fdmax; //maximo numero de file descriptor para hacer las busquedas en comunicaciones

	int listener;//socket escucha
	int newfd;//file descriptor del cliente aceptado
	struct sockaddr_storage remoteaddr; //dirección del cliente
	socklen_t addrlen;

	char remoteIP[INET6_ADDRSTRLEN];

	int i; // socket entrante

	struct addrinfo hints;

	FD_ZERO(&master);	//clear the master
	FD_ZERO(&read_fds); //clear the temp set

	 //Lleno la estructura de tipo addrinfo
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	t_socket_info socketInfo;
	socketInfo.sin_addr.s_addr = INADDR_ANY;
	socketInfo.sin_family = AF_INET;
	socketInfo.sin_port = htons(puerto);
	memset(&(socketInfo.sin_zero), '\0', 8);

	listener = crearSocket();

	bindearSocket(listener, socketInfo);

	// listen turns on server mode for a socket.
	if (listen(listener, 10) == -1) {
		perror("listen");
		exit(3);
	}

	// add the listener to the master set
	FD_SET(listener, &master);

	// keep track of the biggest file descriptor
	fdmax = listener; // so far, it's this one

	for(;;){

		read_fds = master; // copy it

		if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
			perror("select");
			exit(4);
		}

		// run through the existing connections looking for data to read
		for(i = 0; i <= fdmax; i++) {

			if (FD_ISSET(i, &read_fds)) { // we got one!!

				if (i == listener) {

					// handle new connections
					addrlen = sizeof remoteaddr;
					newfd = accept(listener, (struct sockaddr *) &remoteaddr,
							&addrlen);

					if (newfd == -1) {
						log_error(LOGGER, string_from_format( "Hubo un error en el accept para el fd: %i", i));
					} else {
						FD_SET(newfd, &master); // add to master set
						if (newfd > fdmax) {    // keep track of the max
							fdmax = newfd;
						}

						//Shows the new connection administrated
						log_info(LOGGER,
								string_from_format(
										"selectserver: new connection from %s on socket %d\n",
										inet_ntop(remoteaddr.ss_family,
												get_in_addr( (struct sockaddr*) &remoteaddr), remoteIP, INET6_ADDRSTRLEN), newfd));
					}

				} else {

					header_t header;
					initHeader(&header);

					log_info(LOGGER, "Esperamos recibir mensajes de los Jobs");
					if(recibir_header_simple(i, &header) != EXITO){
						log_error(LOGGER, "Error al recibir header. Considero que viene de un cliente que se cayó");
						header.tipo = ERR_CONEXION_CERRADA;
					}
					log_info(LOGGER, "Mensaje recibido! Header: %s", getDescription(header.tipo));

					switch(header.tipo){

						case ERR_CONEXION_CERRADA:
							close(i);
							FD_CLR(i, &master);
							job_eliminar(i, header);
							break;

						case JOB_TO_MARTA_FILES:
							// agrego el job a la lista sincronizada, gestiono las estructuras y blah
							job_agregar(i, header);
							// le pido al fs los bloques de los archivos del job y actualizo el job de la lista
							procesarArchivos(i, header);
							break;

						case JOB_TO_MARTA_MAP_OK:
							notificarMapOk(i, header);
							break;

						case JOB_TO_MARTA_MAP_ERROR:
							notificarMapError(i, header);
							break;

						case JOB_TO_MARTA_REDUCE_OK:
							notificarReduceOk(i, header);
							break;

						case JOB_TO_MARTA_REDUCE_ERROR:
							notificarReduceError(i, header);
							break;

						default: log_error(LOGGER, "ERROR mensaje NO RECONOCIDO (%d) !!\n",  header);
					}
				}
			}
		}
	}
}
int main (int argc,char** argv)
{
	 //Abrir el script que voy a interpretar

	 FILE* script = fopen( argv[1], "r");

	 if ( script == NULL )
	 {
	 	printf("No se encontro el archivo \n");
	 	return -1;
	 }

	 else
	 {
		 if(feof (script) == 0)
		 {
			 int32_t tamanioDePath = strlen(argv[0]) + (sizeof(char)*3);
			 char linea[tamanioDePath];
			 fgets(linea,tamanioDePath,script);
		 }
		 else
		 {
			 puts("Script vacio");
			 return -1;
		 }

		 char* stream;
		 size_t tamanio= 0;
		 size_t offset = 0;
		 stream = malloc(0);

		 while( feof (script) == 0 )
		 {
		 	char linea[50]="";
		 	fgets(linea,50,script);
		 	tamanio = strlen(linea);
		 	stream = realloc(stream,tamanio+offset);
		 	memcpy(stream+offset,linea,tamanio);
		 	offset += tamanio;
		 }

		 stream = realloc(stream,tamanio+offset+1);
		 memcpy(stream+offset,"\0",1);

		 fclose(script);

		 char* ip = getenv("PP_IP");
		 char* port = getenv("PP_Puerto");

		 if( (ip == NULL) || (port == NULL) )
		 {
			 puts("Variables PP_IP o PP_Puerto no especificadas");
			 return -1;
		 }

		 uint16_t puerto = (uint16_t) Stoi(port,"%u");

		 t_socket* socketCliente = crearSocket("127.0.0.1",3001);

		 puts("Conectando con servidor...");
		 printf("IP: %s\nPUERTO:%u\n",ip,puerto);

		 if( conectarSocket(socketCliente,ip,puerto) == -1)
		 {
		 	puts("Error al conectar con servidor");
		 	return -1;
		 }

		 if( enviarSocket(socketCliente,stream,strlen(stream)) == -1 )
		 {
		 	puts("Error al enviar mensaje");
		 	return -1;
		 }

		 free(stream);

		 destruirSocket(socketCliente);
	 }

	 return 0;
}
Example #16
0
int main (int argc,char *argv[]){
	extern int   socketKernel;
	extern int   puertoKernel;
	extern char  ipKernel[16];
	t_msg mensaje;
	mensaje.flujoDatos=NULL;

	//int       descriptorArch;
	FILE      *script;
	//struct     stat infoArchivo;
	int        tamanio=0;
	char      *data=NULL;
	//char       data2[610];
	char      *ip_prog;
	t_config  *configPrograma;
	char       c;
	//t_log    *logger;

	//INICIALIZANDO EL LOG
	//logger=crearLog(argv[0]);

	//--------------------------------------->METODO LARGO<------------------------------------------------
 	//ABRIENDO EL ARCHIVO DEL SCRIPT A EJECUTAR
	if((script=fopen(argv[1],"r"))==NULL){
		printf("No se encontro el archivo");//----->nunca deberia llegar aca
	}else{
		printf("archivo encontrado\n");
		while((c=fgetc(script))!=EOF){
			tamanio++;
			data=realloc(data,tamanio);
			data[tamanio-1]=c;
		}
	}
	fclose(script);
	//-------------------------------------->FIN METODO LARGO<----------------------------------------------


	//---------------------------------------->METODO CORTO<-------------------------------------------------
	/*descriptorArch=open(argv[1],O_RDONLY);
	//EXTRAYENDO INFO DEL ARCHIVO EN infoArchivo
	fstat(descriptorArch,&infoArchivo);
	tamanio=infoArchivo.st_size;
	data=malloc(tamanio);
	//LEYENDO EL CONTENIDO DEL ARCHIVO ENTERO Y ALOJANDOLO EN data
	read(descriptorArch,data,tamanio);
	close(descriptorArch);
	//log_debug(logger,"Se abrio el script a ejecutar de tamanio:%i con el contenido:\n%s",tamanio,data);
	  */
	//-------------------------------------->FIN METODO CORTO<----------------------------------------------

	//LEVANTANDO ARCHIVO DE CONFIGURACION
	configPrograma=config_create(ARCHIVO_CONFIG);
	puertoKernel  =config_get_int_value(configPrograma,"Puerto-Kernel");
	ip_prog       =config_get_string_value(configPrograma,"IP-Kernel");
    strcpy(ipKernel,ip_prog);
    printf("se conectara a ip-kernel:%s puerto-kernel:%i...\n",ip_prog,puertoKernel);
 	config_destroy(configPrograma);
 	//log_debug(logger,"Se levanto el archivo de configuracion con puerto-kernel:%i ip-kernel:%s",puertoKernel,ipKernel);
 	//CONECTANDOSE AL KERNEL
	socketKernel=crearSocket();
	conectarseCon(ipKernel,puertoKernel,socketKernel);
	//log_debug(logger,"Se conectara con kernel...");
	printf("se hizo la conexion\n");

	//HACIENDO HANDSHAKE CON KERNEL
	mensaje.encabezado.codMsg=K_HANDSHAKE;
	mensaje.encabezado.longitud=0;
	enviarMsg(socketKernel,mensaje);
	printf("handshake mandado\n");
	free(mensaje.flujoDatos);mensaje.flujoDatos=NULL;
	//log_debug(logger,"Se mando mensaje a kernel con codigo:K_HANDSHAKE...");

	while(1){
		printf("entrando al while esperando mensaje...\n");
		recibirMsg(socketKernel,&mensaje);
		printf("llego mensaje\n");

		if(mensaje.encabezado.codMsg==P_ENVIAR_SCRIPT){
			printf("se recibio enviar-script\n");
			//log_debug(logger,"Se recibio un mensaje de kernel con el codigo: P_ENVIAR_SCRIPT y se enviara el script...");
			mensaje.encabezado.codMsg=K_ENVIO_SCRIPT;
			mensaje.encabezado.longitud=tamanio;
			printf("tamanio del script%i\n",tamanio);
			mensaje.flujoDatos=malloc(tamanio);
			memcpy(mensaje.flujoDatos,data,tamanio);
			enviarMsg(socketKernel,mensaje);
		}
		if(mensaje.encabezado.codMsg==P_IMPRIMIR_VAR){
			//log_debug(logger,"Se recicibio un mensaje de kernel con el valor a imprimir de una variable");
			printf("********************************************\n");
			printf("-------------RESULTADO: %i\n",(int)*(mensaje.flujoDatos));
			printf("********************************************\n");
			free(mensaje.flujoDatos);mensaje.flujoDatos=NULL;
		}
		if(mensaje.encabezado.codMsg==P_IMPRIMIR_TXT){
			//log_debug(logger,"Se recibio un mensaje de kernel con un texto a imprimir");
			printf("********************************************\n");
			printf("-------------TEXTO: %s\n",mensaje.flujoDatos);
			printf("********************************************\n");
			free(mensaje.flujoDatos);mensaje.flujoDatos=NULL;
		}
		if(mensaje.encabezado.codMsg==P_DESCONEXION){
			//log_debug(logger,"Se recibio un mensaje de kernel para desconectarse, el programa finalizo, chauuu...");
			printf("FINALIZO EL PROGRAMA..\n");
			//sleep(2);//-------------------------->sleep porque sino apenas cierra el socket manda basura -el kernel recibe basura
			//seguir=false;
			free(mensaje.flujoDatos);mensaje.flujoDatos=NULL;
			break;
		}
		if(mensaje.encabezado.codMsg==P_SERVICIO_DENEGADO){
			//log_debug(logger,"Se recibio un mensaje de kernel para desconectarse, el programa tiene errores de manejo de memoria, chauuu...");
			printf("SERVICIO DENEGADO (memory overload)...\n");
			//seguir=false;
			free(mensaje.flujoDatos);mensaje.flujoDatos=NULL;
			break;
		}
	}
	/*recibirMsg(socketKernel,&mensaje);
	if(mensaje.encabezado.codMsg==P_DESCONEXION){
		printf("desconexion definitiva\n");
	}/*/
	//sleep(4);
	//close(socketKernel);

	//free(mensaje.flujoDatos);
	return EXIT_SUCCESS;
}
Example #17
0
io_handler()
{
    fd_set readmask;
    char    buf[BUFLEN];
    int numfds;
    struct timeval timeout;

    int addrlen;
    int stcpnew;
    int sudpnew;
    char datos[BUFLEN];
    char datosmorse[BUFLEN];
    int ret;

    memset (buf, 0, BUFLEN);

    /* Notify operator of SIGIO interrupt */

    /* setup the masks */
    FD_ZERO(&readmask);
    FD_SET(stcp, &readmask);
    FD_SET(sudp, &readmask);

    /* set the timeout value    */
    timeout.tv_sec = 0;
    timeout.tv_usec = 0;

    /* select on socket descriptors */
    if ( (numfds=select(getdtablesize(), &readmask, (fd_set *)0,(fd_set *)0, &timeout)) < 0)
    {
        fprintf(stderr,"\nSelect failed\n");
        exit(1);
    }

    //Se ha seleccionado el socket UDP
    if (FD_ISSET(sudp, &readmask))
    {
        //recibimos los datos
        ret=Recibir(sudp,&datos,sizeof(datos),&parameters_udp);

        //comprobamos que no se produzca un error en la recepcion
        if(ret < 0)
        {
            fprintf(stderr,"\nError receiving data\n");
            fflush(stdout);
        }
        else
        {
            //vemos si nos ha llegado fin para terminar
            if(strcmp(datos,"FIN\n") == 0 || strcmp(datos,"FIN") == 0)
            {
                writeLog("UDP",parameters_udp,0,0);
            }
            else
            {
                //la ip esta en peeraddr_in.sin_addr y viene de la funcion accept

                /*printf("\n[Server UDP from %s:%d] I've receive: %s",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datos);
                fflush(stdout);*/

                //traducimos a morse
                translate_morse(datos,datosmorse);

                 /*
                Creamos el nuevo socket para la nueva peticion (gracias a esto podremos llevar cuenta del numero de peticiones
                de cada cliente en particlar, si no lo hicieramos asi, no podriamos llevar esa cuenta. Por tanto estamos
                imitando de cierta manera el comportamiento de TCP.

                Si no quisiesemos llevar la cuenta no haria falta crear un socket nuevo, con el mismo socket atenderiamos
                todas las nuevas peticiones
                */

                sudpnew = crearSocket(parameters_udp,CLIENT);

                //enviamos por el nuevo socket
                ret=Enviar(sudpnew,datosmorse,sizeof(datosmorse),parameters_udp);

                //comprobamos que no haya ocurrido ningun error en el envio
                if(ret < 0)
                {
                    fprintf(stderr,"Error sending data\n");
                    fflush(stdout);
                }
                /*else
                {
                    printf("\n[Server UDP to %s:%d] I've send: %s",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datosmorse);
                    fflush(stdout);
                }*/
            }
        }

        /*
        Ahora si creamos un nuevo hijo que se encargara de mantener esa "conversacion" con el cliente.
        Antes no hemos podido hacerlo porque hasta que no hemos recibido la informacion no conociamos los datos
        del cliente, una vez conocidos, delegamos el trabajo de "conversacion" a un hijo, como en TCP,
        */
        switch(fork())
        {
			case -1:
				fprintf(stderr,"\nError fork\n");
            break;

			case 0:
                close(sudp);
				imudp(sudpnew);
            break;

			default:
                close(sudpnew);
            break;
		}
    }

    //TCP
    if (FD_ISSET(stcp, &readmask))
    {
        addrlen = sizeof(struct sockaddr_in);

        /* another program requests connection */
        //aqui obtenemos la direccion del cliente con el que conectamos!
        stcpnew = accept(stcp, (struct sockaddr *) &peeraddr_in, &addrlen);
        if (stcpnew == -1 )
        {
            fprintf(stderr,"\nAccept call failed\n");
            exit(1);
        }

        /*
        Creamos un hijo que se ocupara unica y exclusivamente de la "conversacion" con el cliente
        y que morira una vez finalizada dejando constancia de ello en un log
        */
        switch(fork())
        {
			case -1:
				fprintf(stderr,"\nError fork\n");
            break;

			case 0:
                close(stcp);
				imtcp(stcpnew);
            break;

			default:
                close(stcpnew);
            break;
		}
    }
}
Example #18
0
int asyncServer(int argc, char*argv[])
{
        struct sigaction vec1,vec2;
        sigset_t suspend_mask;
        int io_handler();  //función manejadora de la interrupción SIGIO

        //Registrar SIGIO para la notificación asíncrona de eventos en sockets
        vec1.sa_handler = (void *) io_handler;
        vec1.sa_flags = 0;
        if ( sigaction(SIGIO, &vec1, (struct sigaction *) 0) == -1)
        {
            fprintf(stderr,"%s: unable to register the SIGIO signal\n", argv[0]);return -1;
        }

        //Registrar SIGTERM para la finalizacion ordenada del programa servidor
        vec2.sa_handler = (void *) finalizar;
        vec2.sa_flags = 0;
        if ( sigaction(SIGTERM, &vec2, (struct sigaction *) 0) == -1)
        {
            fprintf(stderr,"%s: unable to register the SIGTERM signal\n", argv[0]);return -1;
        }

        //para que ninguna señal interfiera en el servidor menos SIGIO y SIGTERM
        sigfillset(&suspend_mask);
        sigdelset(&suspend_mask, SIGIO);
        sigdelset(&suspend_mask, SIGTERM);

        //configurar servidor UDP
        parameters_udp.protocol   = IPPROTO_UDP;
        parameters_udp.port = htons(PORT);
        parameters_udp.server.s_addr = htonl(INADDR_ANY);

        //crear socket UDP
        sudp=crearSocket(parameters_udp,SERVER);
        if (stcp == -1)
        {
            fprintf(stderr, "\nUnable to create socket UDP\n");return 1;
        }

        //configurar servidor TCP
        parameters_tcp.protocol   = IPPROTO_TCP;
        parameters_tcp.port = htons(PORT);
        parameters_tcp.server.s_addr = htonl(INADDR_ANY);


        //crear socket TCP
        stcp=crearSocket(parameters_tcp,SERVER);
        if (stcp == -1)
        {
            fprintf(stderr, "\nUnable to create socket TCP\n");return 1;
        }

        //hacemos asincronos los sockets
        hacer_asincrono(sudp);
        hacer_asincrono(stcp);

        //entramos en el bucle infinito
        while (!fin)
        {
            sigsuspend(&suspend_mask);
        }

        //cerramos los sockets
        close(stcp);
        close(sudp);

        printf("\nEl servidor asincrono termino correctamente.\n");

        return 0;
}
Example #19
0
int main(void) {

//////////////////////////INICIALIZACION DE VARIABLES////////////////////////////////

	tipoConfigMemoria* configuracion = cargarArchivoDeConfiguracionDeMemoria("cfgMemoria");

	int socketParaCpus = crearSocket();

	int socketParaSwap = crearSocket();

	int socketCpuEntrante;

	bool memoriaActiva = true;

//--------------ACA EMPIEZA FERNILANDIA--------------------------
	//t_list* listaRAM = list_create();
	//t_list* listaTLB = list_create();
	//t_list* listaAdministracionPaginas = list_create();

	fd_set listaPrincipal;
	fd_set listaFiltrada;

	FD_ZERO(&listaPrincipal);
	FD_ZERO(&listaFiltrada);
	FD_SET(socketParaCpus,&listaPrincipal);

	tipoEstructuraMemoria* datosMemoria = malloc(sizeof(tipoEstructuraMemoria));

	//datosMemoria->listaRAM = listaRAM;

	//datosMemoria->listaTLB = listaTLB;

	datosMemoria->socketSWAP = socketParaSwap;

	datosMemoria->maximoSocket = socketParaCpus;

	datosMemoria->configuracion = configuracion;

	datosMemoria->cpusATratar = &listaFiltrada;

	//datosMemoria->administradorPaginas = listaAdministracionPaginas;

	datosMemoria->memoriaActiva = &memoriaActiva;

	datosMemoria->socketCpus = socketParaCpus;

	setearEstructuraMemoria(datosMemoria);

//-------------END OF FERNILANDIA-----------------------------------

	asociarAPuerto(socketParaCpus,configuracion->puertoDeEscucha);

	conectarAServidor(socketParaSwap,configuracion->ipSWAP,configuracion->puertoSWAP);

	escucharConexiones(socketParaCpus,maxConexionesEntrantes);

	pthread_t hiloSignals;

	crearThread(&hiloSignals,funcionPrueba,datosMemoria);


/////////////////////////////////////////////////////////////////////////////////////


	while(memoriaActiva){

		FD_ZERO(&listaFiltrada);

		listaFiltrada = listaPrincipal;

		select(datosMemoria->maximoSocket+1,&listaFiltrada,NULL,NULL,NULL);

		if(FD_ISSET(socketParaCpus,&listaFiltrada)){
			socketCpuEntrante = crearSocketParaAceptarSolicitudes(socketParaCpus);
			FD_SET(socketParaCpus,&listaPrincipal);
			FD_SET(socketCpuEntrante,&listaFiltrada);
			datosMemoria->maximoSocket = maximoEntre(datosMemoria->maximoSocket,socketCpuEntrante);
		}

		tratarPeticiones(&datosMemoria);

	}

	destruirConfigMemoria(configuracion);

	return EXIT_SUCCESS;
}
int fs_nodos(){

	//Logica principal para administrar conexiones
	fd_set master; //file descriptor list
	fd_set read_fds; //file descriptor list temporal para el select()
	int fdmax; //maximo numero de file descriptor para hacer las busquedas en comunicaciones

	int listener;//socket escucha
	int newfd;//file descriptor del cliente aceptado
	struct sockaddr_storage remoteaddr; //dirección del cliente
	socklen_t addrlen;

	char remoteIP[INET6_ADDRSTRLEN];

	int i; // socket entrante

	struct addrinfo hints;

	FD_ZERO(&master);	//clear the master
	FD_ZERO(&read_fds); //clear the temp set

	 //Lleno la estructura de tipo addrinfo
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	t_socket_info socketInfo;
	socketInfo.sin_addr.s_addr = INADDR_ANY;
	socketInfo.sin_family = AF_INET;
	socketInfo.sin_port = htons(7000);
	memset(&(socketInfo.sin_zero), '\0', 8);

	listener = crearSocket();

	bindearSocket(listener, socketInfo);

	// listen turns on server mode for a socket.
	if (listen(listener, 10) == -1) {
		perror("listen");
		exit(3);
	}

	// add the listener to the master set
	FD_SET(listener, &master);

	// keep track of the biggest file descriptor
	fdmax = listener; // so far, it's this one

	for(;;){

		read_fds = master; // copy it

		if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
			perror("select");
			exit(4);
		}

		// run through the existing connections looking for data to read
		for(i = 0; i <= fdmax; i++) {


			if (FD_ISSET(i, &read_fds)) { // we got one!!

				if (i == listener) {

					// handle new connections
					addrlen = sizeof remoteaddr;
					newfd = accept(listener, (struct sockaddr *) &remoteaddr,
							&addrlen);

					if (newfd == -1) {
						log_error(logger, string_from_format( "Hubo un error en el accept para el fd: %i", i));
					} else {
						FD_SET(newfd, &master); // add to master set
						if (newfd > fdmax) {    // keep track of the max
							fdmax = newfd;
						}

						//Shows the new connection administrated
						log_info(logger,
								string_from_format(
										"selectserver: new connection from %s on socket %d\n",
										inet_ntop(remoteaddr.ss_family,
												get_in_addr( (struct sockaddr*) &remoteaddr), remoteIP, INET6_ADDRSTRLEN), newfd));
					}

				} else {

					t_mensaje* mensaje_recibido = NULL;

					recibirDeserializado(logger, false, i, mensaje_recibido);

					tratarMensaje(i, mensaje_recibido);

					freeMensaje(mensaje_recibido);
				}
			}
		}
	}

	return EXIT_SUCCESS;
}