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; }
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; }
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; }
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; }
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"); }
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; }
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; }
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),¶meters); //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),¶meters); //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; }
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; }
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),¶meters_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; } } }
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; }
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; }