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;
}