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