/* * send_stats: * Accept a connection to the statistics port, and emit * the stats. */ static void send_stats(void) { FILE *fp; int s; struct sockaddr_in sockstruct; socklen_t socklen; /* Accept a connection to the statistics socket: */ socklen = sizeof sockstruct; s = accept4(Status, (struct sockaddr *) &sockstruct, &socklen, SOCK_NONBLOCK); if (s < 0) { if (errno == EINTR) return; logx(LOG_ERR, "accept"); return; } fp = fdopen(s, "w"); if (fp == NULL) { logit(LOG_ERR, "fdopen"); (void) close(s); return; } print_stats(fp); (void) fclose(fp); }
void agregar_lista_de_procesos_log(nodo_proceso **listaProcesos, nodo_proceso **listaAgregar,char *listaOrigen,char *listaDestino,int prioridad_FIFO_RR){ proceso proceso; nodo_proceso **listaAux = listaAgregar; char *mensaje = (char*)malloc(1024); char *pidProceso = (char*)malloc(1024); bzero(mensaje,1024); while( *listaAux != NULL){ proceso = sacar_proceso(listaAux); //printf("STS - Se saco el proceso PID=%d, de %s\n",proceso.pcb.pid,listaOrigen); prioridad_FIFO_RR++; proceso.prioridad_FIFO_RR=prioridad_FIFO_RR; agregar_proceso(listaProcesos,proceso); //printf("STS - Se agego el proceso PID=%d, de %s a %s\n",proceso.pcb.pid,listaOrigen,listaDestino); //Armo el mensaje a loguear. strcat(mensaje,"Se paso el proceso "); sprintf(pidProceso,"%d",proceso.pcb.pid); strcat(mensaje,pidProceso); strcat(mensaje," de "); strcat(mensaje,listaOrigen); strcat(mensaje," a "); strcat(mensaje,listaDestino); strcat(mensaje,".\n"); logx(proceso.pcb.pid,"STS",pthread_self(),"LSCH",mensaje); } free(mensaje); }
/* * send_stats: * Accept a connection to the statistics port, and emit * the stats. */ static void send_stats(void) { FILE *fp; int s; struct sockaddr_in sockstruct; socklen_t socklen; struct request_info ri; int flags; /* Accept a connection to the statistics socket: */ socklen = sizeof sockstruct; s = accept(Status, (struct sockaddr *) &sockstruct, &socklen); if (s < 0) { if (errno == EINTR) return; logx(LOG_ERR, "accept"); return; } /* Check for access permissions: */ request_init(&ri, RQ_DAEMON, "huntd", RQ_FILE, s, 0); fromhost(&ri); if (hosts_access(&ri) == 0) { logx(LOG_INFO, "rejected connection from %s", eval_client(&ri)); close(s); return; } /* Don't allow the writes to block: */ flags = fcntl(s, F_GETFL, 0); flags |= O_NDELAY; (void) fcntl(s, F_SETFL, flags); fp = fdopen(s, "w"); if (fp == NULL) { logit(LOG_ERR, "fdopen"); (void) close(s); return; } print_stats(fp); (void) fclose(fp); }
/* * play_at: * Return a pointer to the player at the given location */ PLAYER * play_at(int y, int x) { PLAYER *pp; for (pp = Player; pp < End_player; pp++) if (pp->p_x == x && pp->p_y == y) return pp; /* Internal fault: */ logx(LOG_ERR, "play_at: not a player"); abort(); }
/* * cleanup: * Exit with the given value, cleaning up any droppings lying around */ void cleanup(int eval) { PLAYER *pp; /* Place their cursor in a friendly position: */ cgoto(ALL_PLAYERS, HEIGHT, 0); /* Send them all the ENDWIN command: */ sendcom(ALL_PLAYERS, ENDWIN, LAST_PLAYER); /* And close their connections: */ for (pp = Player; pp < End_player; pp++) (void) fclose(pp->p_output); for (pp = Monitor; pp < End_monitor; pp++) (void) fclose(pp->p_output); /* Close the server socket: */ (void) close(Socket); /* The end: */ logx(LOG_INFO, "game over"); exit(eval); }
/* * init: * Initialize the global parameters. */ static void init(void) { int i; struct sockaddr_in test_port; int true = 1; socklen_t len; struct sockaddr_in addr; struct sigaction sact; struct servent *se; (void) setsid(); if (setpgid(getpid(), getpid()) == -1) err(1, "setpgid"); sact.sa_flags = SA_RESTART; sigemptyset(&sact.sa_mask); /* Ignore HUP, QUIT and PIPE: */ sact.sa_handler = SIG_IGN; if (sigaction(SIGHUP, &sact, NULL) == -1) err(1, "sigaction SIGHUP"); if (sigaction(SIGQUIT, &sact, NULL) == -1) err(1, "sigaction SIGQUIT"); if (sigaction(SIGPIPE, &sact, NULL) == -1) err(1, "sigaction SIGPIPE"); /* Clean up gracefully on INT and TERM: */ sact.sa_handler = cleanup; if (sigaction(SIGINT, &sact, NULL) == -1) err(1, "sigaction SIGINT"); if (sigaction(SIGTERM, &sact, NULL) == -1) err(1, "sigaction SIGTERM"); /* Handle INFO: */ sact.sa_handler = siginfo; if (sigaction(SIGINFO, &sact, NULL) == -1) err(1, "sigaction SIGINFO"); if (chdir("/") == -1) warn("chdir"); (void) umask(0777); /* Initialize statistics socket: */ addr.sin_family = AF_INET; addr.sin_addr.s_addr = Server_addr; addr.sin_port = 0; Status = socket(AF_INET, SOCK_STREAM, 0); if (bind(Status, (struct sockaddr *) &addr, sizeof addr) < 0) { logit(LOG_ERR, "bind"); cleanup(1); } if (listen(Status, 5) == -1) { logit(LOG_ERR, "listen"); cleanup(1); } len = sizeof (struct sockaddr_in); if (getsockname(Status, (struct sockaddr *) &addr, &len) < 0) { logit(LOG_ERR, "getsockname"); cleanup(1); } stat_port = ntohs(addr.sin_port); /* Initialize main socket: */ addr.sin_family = AF_INET; addr.sin_addr.s_addr = Server_addr; addr.sin_port = 0; Socket = socket(AF_INET, SOCK_STREAM, 0); if (bind(Socket, (struct sockaddr *) &addr, sizeof addr) < 0) { logit(LOG_ERR, "bind"); cleanup(1); } if (listen(Socket, 5) == -1) { logit(LOG_ERR, "listen"); cleanup(1); } len = sizeof (struct sockaddr_in); if (getsockname(Socket, (struct sockaddr *) &addr, &len) < 0) { logit(LOG_ERR, "getsockname"); cleanup(1); } sock_port = ntohs(addr.sin_port); /* Initialize minimal select mask */ FD_ZERO(&Fds_mask); FD_SET(Socket, &Fds_mask); FD_SET(Status, &Fds_mask); Num_fds = ((Socket > Status) ? Socket : Status) + 1; /* Find the port that huntd should run on */ if (Server_port == 0) { se = getservbyname("hunt", "udp"); if (se != NULL) Server_port = ntohs(se->s_port); else Server_port = HUNT_PORT; } /* Check if stdin is a socket: */ len = sizeof (struct sockaddr_in); if (getsockname(STDIN_FILENO, (struct sockaddr *) &test_port, &len) >= 0 && test_port.sin_family == AF_INET) { /* We are probably running from inetd: don't log to stderr */ Server_socket = STDIN_FILENO; conf_logerr = 0; if (test_port.sin_port != htons((u_short) Server_port)) { /* Private game */ should_announce = FALSE; Server_port = ntohs(test_port.sin_port); } } else { /* We need to listen on a socket: */ test_port = addr; test_port.sin_port = htons((u_short) Server_port); Server_socket = socket(AF_INET, SOCK_DGRAM, 0); /* Permit multiple huntd's on the same port. */ if (setsockopt(Server_socket, SOL_SOCKET, SO_REUSEPORT, &true, sizeof true) < 0) logit(LOG_ERR, "setsockopt SO_REUSEADDR"); if (bind(Server_socket, (struct sockaddr *) &test_port, sizeof test_port) < 0) { logit(LOG_ERR, "bind port %d", Server_port); cleanup(1); } /* Datagram sockets do not need a listen() call. */ } /* We'll handle the broadcast listener in the main loop: */ FD_SET(Server_socket, &Fds_mask); if (Server_socket + 1 > Num_fds) Num_fds = Server_socket + 1; /* Initialise the random seed: */ srandomdev(); /* Dig the maze: */ makemaze(); /* Create some boots, if needed: */ makeboots(); /* Construct a table of what objects a player can see over: */ for (i = 0; i < NASCII; i++) See_over[i] = TRUE; See_over[DOOR] = FALSE; See_over[WALL1] = FALSE; See_over[WALL2] = FALSE; See_over[WALL3] = FALSE; See_over[WALL4] = FALSE; See_over[WALL5] = FALSE; logx(LOG_INFO, "game started"); }
/* * Handle a UDP packet sent to the well known port. */ static void handle_wkport(int fd) { struct sockaddr fromaddr; socklen_t fromlen; u_int16_t query; u_int16_t response; struct request_info ri; request_init(&ri, RQ_DAEMON, "huntd", RQ_FILE, fd, 0); fromhost(&ri); fromlen = sizeof fromaddr; if (recvfrom(fd, &query, sizeof query, 0, &fromaddr, &fromlen) == -1) { logit(LOG_WARNING, "recvfrom"); return; } #ifdef DEBUG fprintf(stderr, "query %d (%s) from %s:%d\n", query, query == C_MESSAGE ? "C_MESSAGE" : query == C_SCORES ? "C_SCORES" : query == C_PLAYER ? "C_PLAYER" : query == C_MONITOR ? "C_MONITOR" : "?", inet_ntoa(((struct sockaddr_in *)&fromaddr)->sin_addr), ntohs(((struct sockaddr_in *)&fromaddr)->sin_port)); #endif /* Do we allow access? */ if (hosts_access(&ri) == 0) { logx(LOG_INFO, "rejected connection from %s", eval_client(&ri)); return; } query = ntohs(query); switch (query) { case C_MESSAGE: if (Nplayer <= 0) /* Don't bother replying if nobody to talk to: */ return; /* Return the number of people playing: */ response = Nplayer; break; case C_SCORES: /* Someone wants the statistics port: */ response = stat_port; break; case C_PLAYER: case C_MONITOR: /* Someone wants to play or watch: */ if (query == C_MONITOR && Nplayer <= 0) /* Don't bother replying if there's nothing to watch: */ return; /* Otherwise, tell them how to get to the game: */ response = sock_port; break; default: logit(LOG_INFO, "unknown udp query %d", query); return; } response = ntohs(response); if (sendto(fd, &response, sizeof response, 0, &fromaddr, sizeof fromaddr) == -1) logit(LOG_WARNING, "sendto"); }
void __dm_magic_assert_fail(const char *field, const void *ptr, unsigned int expected, unsigned int got, unsigned int line, const char *function) { logx(LOG_CRIT, "invalid magic at %s:%d, %s(%p): %08x != %08x", function, line, field, ptr, got, expected); abort(); }
void __dm_parity_assert_fail(unsigned int expected, unsigned int got, unsigned int line, const char *function) { logx(LOG_CRIT, "invalid parity at %s:%d, %08x != %08x", function, line, got, expected); abort(); }
void __dm_type_assert_fail(const char *expected, int got, unsigned int line, const char *function) { logx(LOG_CRIT, "assertion type=='%s' failed at %s:%d, got type==%X", expected, function, line, got); abort(); }
void __dm_assert_fail(const char *assertion, unsigned int line, const char *function) { logx(LOG_CRIT, "assertion '%s' failed at %s:%d", assertion, function, line); abort(); }
void * LTS_demorado(void * var){ char *buffer_2=(char *)malloc(1024); bzero(buffer_2,1024); char *prioridad=(char *)malloc(64); bzero(prioridad,64); char *paso_mensaje=(char *)malloc(256); while(1){ sem_wait(sem_lts_demorado); pthread_t id_hilo=pthread_self(); int retorno; int socket_demorado; proceso proceso; pthread_mutex_lock(&mutexListaDemorados); if((socket_demorado=sacar_conexion_demorada(listaConeccionesDemoradas))>0){ pthread_mutex_unlock(&mutexListaDemorados); pthread_mutex_lock(&mutexVarMMP); pthread_mutex_unlock(&mutexVarMMP); if( (retorno = validar_mmp_demorado(socket_demorado)) == 0){ enviar_mensaje("Enviame el codigo\n",socket_demorado); recibir_mensaje(&buffer_2,socket_demorado); recibir_mensaje(&prioridad,socket_demorado); //printf("Me llego la prioridad: %s\n",prioridad); proceso = crear_proceso(buffer_2,prioridad,socket_demorado); bzero(paso_mensaje,256); sprintf(paso_mensaje,"Se creo el proceso con PID=%d\n",proceso.pcb.pid); enviar_mensaje(paso_mensaje,socket_demorado); logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"INFO","El proceso ha sido creado."); char *log_text=(char *)malloc(127); sprintf(log_text,"La prioridad del proceso es %d.",proceso.prioridad); logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"DEBUG",log_text); // if ( buffer_2 != NULL ){ // free(buffer_2); // } pthread_mutex_lock(&mutexListaNuevos); agregar_proceso(listaProcesosNuevos,proceso); pthread_mutex_unlock(&mutexListaNuevos); sem_post(sem_sts); logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"LSCH","Agregue el proceso a la lista de Nuevos."); pthread_mutex_lock(&mutexVarMMP); mmp++; pthread_mutex_unlock(&mutexVarMMP); logx(proceso.pcb.pid,"LTS",id_hilo,"INFO","Se aumento el grado de multiprogramacion."); }else{ if( retorno == -2){ logx(proceso.pcb.pid,"LTS",id_hilo,"ERROR","Se sobrepaso el maximo grado de multiprogramacion."); logx(proceso.pcb.pid,"LTS",id_hilo,"INFO","Se aumento el grado de multiprogramacion."); } } //FD_CLR(socket_demorado,&(*master)); }else{ pthread_mutex_unlock(&mutexListaDemorados); } sleep(1); } return 0; }
void answer_first() { struct sockaddr sockstruct; int newsock; socklen_t socklen; int flags; struct request_info ri; struct spawn *sp; /* Answer the call to hunt: */ socklen = sizeof sockstruct; newsock = accept(Socket, (struct sockaddr *) &sockstruct, &socklen); if (newsock < 0) { logit(LOG_ERR, "accept"); return; } /* Check for access permissions: */ request_init(&ri, RQ_DAEMON, "huntd", RQ_FILE, newsock, 0); fromhost(&ri); if (hosts_access(&ri) == 0) { logx(LOG_INFO, "rejected connection from %s", eval_client(&ri)); close(newsock); return; } /* Remember this spawning connection: */ sp = (struct spawn *)malloc(sizeof *sp); if (sp == NULL) { logit(LOG_ERR, "malloc"); close(newsock); return; } memset(sp, '\0', sizeof *sp); /* Keep the calling machine's source addr for ident purposes: */ memcpy(&sp->source, &sockstruct, sizeof sp->source); sp->sourcelen = socklen; /* Warn if we lose connection info: */ if (socklen > sizeof Spawn->source) logx(LOG_WARNING, "struct sockaddr is not big enough! (%d > %zu)", socklen, sizeof Spawn->source); /* * Turn off blocking I/O, so a slow or dead terminal won't stop * the game. All subsequent reads check how many bytes they read. */ flags = fcntl(newsock, F_GETFL, 0); flags |= O_NDELAY; (void) fcntl(newsock, F_SETFL, flags); /* Start listening to the spawning connection */ sp->fd = newsock; FD_SET(sp->fd, &Fds_mask); if (sp->fd >= Num_fds) Num_fds = sp->fd + 1; sp->reading_msg = 0; sp->inlen = 0; /* Add to the spawning list */ if ((sp->next = Spawn) != NULL) Spawn->prevnext = &sp->next; sp->prevnext = &Spawn; Spawn = sp; }
int main(int argc, char *argv[]) { const struct rlimit rlim = { .rlim_cur = RLIM_INFINITY, .rlim_max = RLIM_INFINITY }; ev_signal signal_usr1; ev_signal signal_usr2; ev_signal signal_pipe; int c; /* unlimited size for cores */ setrlimit(RLIMIT_CORE, &rlim); logx_level = LOG_INFO; while (1) { int option_index = 0; static struct option long_options[] = { {"log", 1, 0, 'l'}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "hl:x", long_options, &option_index); if (c == -1) break; switch (c) { case 'h': usage(); break; case 'l': { struct in_addr addr; if (inet_aton(optarg, &addr) == 0) { fprintf(stderr, "Invalid IP address: '%s'\n", optarg); exit(EXIT_FAILURE); } else logx_remote(addr); break; } case 'x': logx_level = LOG_DEBUG; break; default: printf("?? getopt returned character code 0%o ??\n", c); } } logx_open(basename(argv[0]), 0, LOG_DAEMON); ev_signal_init(&signal_usr1, sig_usr1, SIGUSR1); ev_signal_start(EV_DEFAULT_ &signal_usr1); ev_signal_init(&signal_usr2, sig_usr2, SIGUSR2); ev_signal_start(EV_DEFAULT_ &signal_usr2); ev_signal_init(&signal_pipe, sig_pipe, SIGPIPE); ev_signal_start(EV_DEFAULT_ &signal_pipe); init_comm(EV_DEFAULT); logx(LOG_NOTICE, "startup %s %s (pid %d)\n", _ident, _build, getpid()); ev_run(EV_DEFAULT, 0); return 0; }
static void sig_pipe(EV_P_ ev_signal *w, int revents) { logx(LOG_DEBUG, "sig_pipe"); }
void * PROCER_funcion(){ id_hilo_procer=pthread_self(); while(1){ sem_wait(sem_procer); //printf("PROCER - Antes de sacar de listos hay %d procesos\n",cantidad_nodos(listaProcesosListos)); //mostrar_lista(listaProcesosListos); pthread_mutex_lock(&mutexListaListos); proceso proceso=sacar_proceso(listaProcesosListos); pthread_mutex_unlock(&mutexListaListos); //printf("Saque el proceso %d de listos\n",proceso.pcb.pid); //printf("Se saco el proceso PID:%d de listos\n",proceso.pcb.pid);//TODO:BORRAR logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"LSCH","Se saco el proceso de la lista de Listos."); unsigned int cant_instrucciones = cant_lineas(proceso.pcb.codigo); char *instruccion; unsigned int cont_quantum = 0; int retorno; seccion seccion_a_ejecutar; while( verificar_fin_ejecucion(proceso,cont_quantum,cant_instrucciones) != -1){ if( proceso.pcb.pc == 0 ){//Es la 1° vez que ejecuta agregar_a_pila_ejecucion(crear_seccion("fin_programa",&proceso.pcb.pc ),proceso.pila_ejecucion); } if( suspendido == 1){ pthread_mutex_lock(&mutexVarSuspendido); suspendido = 0; pthread_mutex_lock(&mutexVarMMP); mmp--; pthread_mutex_unlock(&mutexVarMMP); logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"INFO","Se suspendio el proceso."); pthread_mutex_lock(&mutexListaSuspendidos); agregar_proceso(listaProcesosSuspendidos,proceso); pthread_mutex_unlock(&mutexListaSuspendidos); sem_post(sem_lts_suspendido); logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"LSCH","Se agrego el proceso a la lista de Suspendidos."); pthread_mutex_unlock(&mutexVarSuspendido); break; }else{//No se suspendio la ejecucion seccion_a_ejecutar=sacar_primera_seccion(proceso.pila_ejecucion); //printf("La instruccion extraida de la pila es %s\n",seccion_a_ejecutar.nombre_seccion); if( strcmp(seccion_a_ejecutar.nombre_seccion,"") == 0){ logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"ERROR","Error al sacar la seccion a ejecutar, es nula."); break; } //Leemos la siguiente instruccion a ejecutar instruccion = leer_instruccion(proceso.pcb.codigo,*seccion_a_ejecutar.contador_instruccion); if( instruccion != NULL){ //Calculo la proxima instruccion a leer ++(*seccion_a_ejecutar.contador_instruccion); if( tengo_que_contar_quantum(instruccion) == 0){ cont_quantum++; } if( strcmp(instruccion,seccion_a_ejecutar.nombre_seccion) != 0){//No es el fin de la seccion a ejecutar agregar_a_pila_ejecucion(seccion_a_ejecutar,proceso.pila_ejecucion); } if( strcmp(instruccion,"fin_programa") != 0){ retorno = ejecutar_instruccion(instruccion,&proceso,&seccion_a_ejecutar); if( retorno == -1){ char *error="Error al ejecutar instruccion: "; strcat(error,instruccion); logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"ERROR",error); } if( retorno == 1){//Quiere decir que se ejecuto una entrada/salida logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"INFO","Se fue a E/S."); break; } }else{ logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"INFO","Finalizo la ejecucion"); pthread_mutex_lock(&mutexVarMMP); --mmp; pthread_mutex_unlock(&mutexVarMMP); pthread_mutex_lock(&mutexVarMPS); --mps; pthread_mutex_unlock(&mutexVarMPS); //mostrar_datos(proceso.pcb.datos); if ( enviar_proceso_terminado(proceso) == 0){ logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"INFO","Se enviao el estado del proceso al PI."); }else{ logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"ERROR","Error al enviar el estado del proceso al PI."); } liberar_proceso(&proceso); logx(proceso.pcb.pid,"PROCER",id_hilo_procer,"INFO","Se libero la memoria del proceso."); break; } } bzero(instruccion,strlen(instruccion)); } } cont_quantum=0; } return 0; }