t_socket * crear_sock_nivel(void)
{
t_socket * sock;
sock=malloc(sizeof(t_socket));
int puerto;
//puerto=PUERTO;
struct sockaddr_in dir_servidor;
int servidor;
servidor=crear_socket();
dir_servidor.sin_family = AF_INET;
dir_servidor.sin_addr.s_addr = INADDR_ANY;
//dir_servidor.sin_port = htons(PUERTO);
dir_servidor.sin_port = 0;
memset(&(dir_servidor.sin_zero), '\0', 8);
sock->descriptor=servidor;
sock->direccion=&dir_servidor;
escuchar(*sock);
/*while(escuchar(*sock)==EXIT_FAILURE)
{
puerto++;
dir_servidor.sin_port=htons(puerto);
}*/
return sock;
}
void* escuchar_conexiones(void* otro_ente){
sock_t* socket_principal = crear_socket_escuchador(puerto());
escuchar(socket_principal);
// Seteamos este como el socket mas grande
int32_t mayor_fd = socket_principal->fd;
FD_ZERO(&readfds);
FD_SET(socket_principal->fd, &readfds);
// Preparamos el SET
fd_set readfdset = readfds;
while(1){
// Escuchamos el universo
int rs = select(mayor_fd+1, &readfdset, NULL, NULL, NULL);
if(rs > 0){
// Si el socket se puede leer
if(FD_ISSET(socket_principal->fd, &readfdset)){
sock_t* nueva_conexion = aceptar_conexion(socket_principal);
pthread_t hilo_conexion;
pthread_create(&hilo_conexion, NULL, &_atiendo_hilo_conexion, nueva_conexion);
}
}
// Rearmamos el readfds
readfdset = readfds;
}
return NULL;
}
// Corre en un THREAD
void* escuchar_conexiones_entrantes_y_procesos(void* un_ente)
{
sock_t* principal = crear_socket_escuchador(puerto());
escuchar(principal);
// Seteamos el timer
struct timeval timer;
timer.tv_sec = 2;
timer.tv_usec = 0;
// Seteamos este como el socket mas grande
int32_t mayor_fd = principal->fd;
FD_ZERO(&READFDS_PROCESOS);
FD_SET(principal->fd, &READFDS_PROCESOS);
// Preparamos el SET
fd_set readfds = READFDS_PROCESOS;
while(1)
{
// Escuchamos el universo
int rs = select(mayor_fd+1, &readfds, NULL, NULL, &timer);
if(rs > 0)
{// Podemos leer
// Vemos si hay sockets para leer
int32_t i;
int32_t copia_mayor_fd = mayor_fd;
for(i = 0; i < (copia_mayor_fd+1); i++)
{
// Si el socket se puede leer
if(FD_ISSET(i, &readfds))
{
if(i == principal->fd)
{// Es el socket principal, new connection knocking
sock_t* nueva_conexion = NULL;
int32_t salida = _procesar_nueva_conexion(principal, &nueva_conexion);
if(salida == 1)
{// Es programa y salio all ok
_recalcular_mayor_fd(&mayor_fd, nueva_conexion->fd);
}
else if(salida == 2)
{// Es CPU
// Aca el quehacer cuando la conexion es CPU
_recalcular_mayor_fd(&MAYOR_FD_CPU, nueva_conexion->fd);
}
}
else
{// No es el socket principal, es un proceso
_atender_socket_proceso(buscar_proceso_por_fd(i));
}
}
}
}
// Rearmamos el readfds
readfds = READFDS_PROCESOS;
// Reseteamos el timer
timer.tv_sec = 2;
timer.tv_usec = 0;
}
return NULL;
}
main()
{
int sock_escucha = 0; // --> lo vamos a mantener todo el tiempo escuchando nuevas conexiones
int new_socket = 0; // --> es el que va a aceptar la nueva conexion
int exit = 1; // --> lo vamos a utilizar para salir del sistema
int i,fdmax; // --> los utilizamos para recorrer todos los sockets
//Los fd_set guardan informacion de los files descriptores (sock_escucha y new_socket
//asi podemos tener un control de cuantos clientes hay conectados y quienes son cada uno
fd_set read_fds;
fd_set master;
//ESCUCHAR--> Esta definida abajo, basicamente lo dividi solo hace el Bind y Listen para
// el sock escucha
sock_escucha=escuchar();
if(sock_escucha == -1)
{
printf("ERROR, error iniciando sockets. \n");
printf("ERROR, sock_escucha = %d \n", sock_escucha);
return -1;
}
//Estas funciones estan mejor explicadas en la Guia Beej, pero basicamente
//FD_ZERO --> limpia toda la "lista" de las conexiones que le pases los fd_set
//FD_SET --> añade un file descriptor al fd_set que le pases
//fdmax --> es una variable que la usamos para recorrer todos los sockets y saber cual es el max
FD_ZERO (&master);
FD_ZERO (&read_fds);
FD_SET (sock_escucha, &master);
fdmax=sock_escucha;
//Bucle infitio para seguir aceptando conexiones
while(exit==1)
{
//READ_FDS --> lee un file descriptor de la lista de fd_set
read_fds = master;
if (select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1)
{
printf("Error en funcion select");
return -1;
}
//Bucle por todos los sockets
for (i = 0; i <= fdmax; i++)
{
//pregunto si en algun socket hubo algun cambio
if (FD_ISSET(i, &read_fds))
{
if (i == sock_escucha)
{
//si es la consola es porque el listen recibio una nueva conexion
new_socket = escuchar_puerto(sock_escucha);
if(new_socket == -1)
{
//si es -1 fallo asi que continuo descartando esta
printf("No se pudo agregar una nueva conexion");
continue;
}
//lo agrego para que lo escuchen en el select
FD_SET(new_socket, &master);
//si es el mayor lo re asigno
if(fdmax < new_socket)
fdmax = new_socket;
continue;
}
}
}
}
}
void Vis_LCD ( volatile uint32_t Estado_LCD, volatile uint32_t AUX_LCD)
{
//volatile uint32_t Estado_LCD;
//volatile uint32_t AUX_LCD;
//Variable para el switch del E
uint8_t a=1;
//Estados de inicializacion y escritura
uint8_t estado_0=0;
uint8_t estado_1=0;
uint8_t estado_2=0;
uint8_t estado_3=0;
uint8_t estado_4=0;
uint8_t estado_5=0;
uint8_t estado_6=0;
//Contador de instrucciones LCD
uint8_t cont_0=1;
uint8_t cont_1=1;
uint8_t cont_2=1;
uint8_t cont_3=1;
uint8_t cont_4=1;
uint8_t cont_5=1;
uint8_t cont_6=1;
while(1) {
if(t()==a) {
////inicio
switch(Estado_LCD) { // corchete Estado_LCD
// Bienvenido Key_PI
case 0: //case 0 Estado_LCD
switch(estado_0) { //switch(estado_0)
case 0:
lcd_iniciar(cont_0);
cont_0=cont_0+1;
if(cont_0==5)estado_0=estado_0+1;
break; //break del case 0
case 1:
titulo1(cont_0);
cont_0=cont_0+1;
if(cont_0==16)estado_0=estado_0+1;
break; //break del case 1
default:
if (cont_0==16)
cont_0=16;
} // end switch(estado_0)
break; //break case 0 Estado_LCD
// Elegir cancion
case 1://case 1 Estado_LCD
switch (estado_1) { // //switch(estado_1)
case 0:
lcd_iniciar(cont_1);
cont_1=cont_1+1;
if(cont_1==5)estado_1=estado_1+1;
break; //break del case 0
case 1:
song(cont_1);
cont_1=cont_1+1;
if(cont_1==21)estado_1=estado_1+1;
break; //break del case 1
case 2:
lcd_linea2(cont_1);
cont_1=cont_1+1;
if(cont_1==22)estado_1=estado_1+1;
break; //break del case 2
case 3:
switch(AUX_LCD) {
case 0:
song1(cont_1); //cancion 1
cont_1=cont_1+1;
if(cont_1==25)estado_1=estado_1+1;
break; //0
case 1:
song2(cont_1); //cancion 2
cont_1=cont_1+1;
if(cont_1==25)estado_1=estado_1+1;
break; //1
case 2:
song3(cont_1); //cancion 3
cont_1=cont_1+1;
if(cont_1==25)estado_1=estado_1+1;
break; //2
case 3:
song4(cont_1); //cancion 4
cont_1=cont_1+1;
if(cont_1==25)estado_1=estado_1+1;
break; //3
case 4:
song5(cont_1); //cancion 5
cont_1=cont_1+1;
if(cont_1==25)estado_1=estado_1+1;
break; //4
default:
if (cont_1==25)
cont_1=25;
} // End switch AUX_LCD
break; //break del case 3
} //switch(estado_1)
break; //break case 1 Estado_LCD
//
//Case 2 Elegir nivel
case 2: //case 2 Estado_LCD
switch (estado_2) { // //switch(estado_2)
case 0:
lcd_iniciar(cont_2);
cont_2=cont_2+1;
if(cont_2==5)estado_2=estado_2+1;
break; //break del case 0
case 1:
elige(cont_2);
cont_2=cont_2+1;
if(cont_2==21)estado_2=estado_2+1;
break; //break del case 1
case 2:
lcd_linea2(cont_2);
cont_2=cont_2+1;
if(cont_2==22)estado_2=estado_2+1;
break; //break del case 2
case 3:
switch(AUX_LCD) {
case 0:
normal(cont_2);
cont_2=cont_2+1;
if(cont_2==25)estado_2=estado_2+1;
break; //break del case 0 normal()
case 1:
experto(cont_2);
cont_2=cont_2+1;
if(cont_2==25)estado_2=estado_2+1;
break; //break del case 1 experto
default:
if (cont_2==25)
cont_2=25;
} //end switch AUX_LCD
break; //break del case 3
} //end switch(estado_2)
break; // break //case 2 Estado_LCD
//
//Escuchar
// Escuchar cancion
case 3: //case 3 Estado_LCD
switch(estado_3) { //switch(estado_3)
case 0:
lcd_iniciar(cont_3);
cont_3=cont_3+1;
if(cont_3==5)estado_3=estado_3+1;
break; //break del case 0
case 1:
escuchar(cont_3);
cont_3=cont_3+1;
if(cont_3==13)estado_3=estado_3+1;
break; //break del case 1
default:
if (cont_3==13)
cont_3=13;
} //end //switch(estado_3)
break;//case 3 Estado_LCD
// Preparado?????????????''''''
case 4: //case 4 Estado_LCD
switch(estado_4) { //switch(estado_4)
case 0:
lcd_iniciar(cont_4);
cont_4=cont_4+1;
if(cont_4==5)estado_4=estado_4+1;
break; //break del case 0
case 1:
preparado(cont_4);
cont_4=cont_4+1;
if(cont_4==14)estado_4=estado_4+1;
break; //break del case 1
default:
if (cont_4==14)
cont_4=14;
} //end //switch(estado_4)
break;//case 4 Estado_LCD
// Adelante
case 5: //case 5 Estado_LCD
switch(estado_5) { //switch(estado_5)
case 0:
lcd_iniciar(cont_5);
cont_5=cont_5+1;
if(cont_5==5)estado_5=estado_5+1;
break; //break del case 0
case 1:
adelante(cont_5);
cont_5=cont_5+1;
if(cont_5==14)estado_5=estado_5+1;
break; //break del case 1
default:
if (cont_5==14)
cont_5=14;
} //end //switch(estado_5)
break;//case 5 Estado_LCD
//Again
case 6: //case 6 Estado_LCD
switch (estado_6) { // //switch(estado_6)
case 0:
lcd_iniciar(cont_6);
cont_6=cont_6+1;
if(cont_6==5)estado_6=estado_6+1;
break; //break del case 0
case 1:
again(cont_6);
cont_6=cont_6+1;
if(cont_6==21)estado_6=estado_6+1;
break; //break del case 1
case 2:
lcd_linea2(cont_6);
cont_6=cont_6+1;
if(cont_6==22)estado_6=estado_6+1;
break; //break del case 2
case 3:
switch(AUX_LCD) {
case 0:
si(cont_6);
cont_6=cont_6+1;
if(cont_6==26)estado_6=estado_6+1;
break; //break del case 0 normal()
case 1:
no(cont_6);
cont_6=cont_6+1;
if(cont_6==26)estado_6=estado_6+1;
break; //break del case 1 experto
default:
if (cont_6==26)
cont_6=26;
} //end switch AUX_LCD
break; //break del case 3
} //end switch(estado_6)
break; // break //case 6 Estado_LCD
default:
if (cont_6==0)
cont_6=0;
//
} //corchete Estado_LCD
//fin del switch estado LCD
a=0;
}
if(t()==0) a=1;
}
//return 0;
} //end main
int main (int argc, char* argv[])
{
int error,i,j,ronda;
int fdcliente;
key_t llave,llaved,llavedx,llavedy;
struct paketeSC packout;
signal(SIGINT,terminar);
//Valores por default
cant_niveles=10;
dificultad=5;
bots=0;
switch(argc)
{
case 1:
printf("Servidor de NkTron\nERROR: Faltan parametros\n");
printf("Uso: servidor Cant_Jugadores [Dificultad][Rondas][Bots]\n");
printf(" Cant_Jugadores=2..6 , Dificultad=1..10 (0=Especial) , ");
printf("Rondas=1..20 , Bots=1..6\n");
return 1;
break;
case 5:
bots=atoi(argv[4]);
if (bots<0 || bots >MAX_JUGADORES)
{ printf("Cantidad de bots invalida (0..%d)\n",MAX_JUGADORES);
return 1;
}
case 4:
cant_niveles=atoi(argv[3]);
if (cant_niveles<1 || cant_niveles>20)
{ printf("Cantidad de rondas invalida (1..20)\n");
return 1;
}
case 3:
dificultad=atoi(argv[2]);
if (dificultad<0 || dificultad>10)
{ printf ("Dificultad invalida (0..10) (0=Especial)\n");
return 1;
}
case 2:
jugadores=atoi(argv[1]);
if (jugadores<2 || jugadores>MAX_JUGADORES)
{ printf("Cantidad de jugadores invalida (2..%d)\n",MAX_JUGADORES);
return 1;
}
}
if (bots>jugadores)
{ printf("Cantidad de bots invalida, mayor a jugadores totales\n");
return 1;
}
llave=ftok("./cliente.c",33);
id_mem=shmget(llave,sizeof(int[80][23]),0777 | IPC_CREAT);
if(id_mem==-1)
{ printf("No consegui memoria!\n");return 1; }
shmatriz=(int **)shmat(id_mem,(char *)0,0);
if(!shmatriz)
{ printf("No consegui compartir memoria!\n");return 1; }
shmatriz=(int **)matriz;
llaved=ftok("./cliente.c",32);
id_memd=shmget(llaved,sizeof(int[MAX_JUGADORES]),0777 | IPC_CREAT);
if(id_memd==-1)
{ printf("No consegui memoria!\n");return 1; }
direcc=(int *)shmat(id_memd,(char *)0,0);
if(!direcc)
{ printf("No consegui compartir memoria!\n");return 1; }
llavedx=ftok("./cliente.c",31);
id_memdx=shmget(llavedx,sizeof(int[MAX_JUGADORES]),0777 | IPC_CREAT);
if(id_memdx==-1)
{ printf("No consegui memoria!\n");return 1; }
x=(int *)shmat(id_memdx,(char *)0,0);
if(!x)
{ printf("No consegui compartir memoria!\n");return 1; }
llavedy=ftok("./cliente.c",30);
id_memdy=shmget(llavedy,sizeof(int[MAX_JUGADORES]),0777 | IPC_CREAT);
if(id_memdy==-1)
{ printf("No consegui memoria!\n");return 1; }
y=(int *)shmat(id_memdy,(char *)0,0);
if(!y)
{ printf("No consegui compartir memoria!\n");return 1; }
printf("Servidor de NkTron listo y esperando conexiones...\n");
printf("Se jugaran %d rondas con nivel de dificultad %d\n",cant_niveles,dificultad);
printf("Jugaran %d jugadores, de los cuales %d seran bots\n\n",jugadores,bots);
for(i=0;i<MAX_JUGADORES;i++)
{ strcpy(vnombres[i],"NULL");
puntajes[i]=0;
}
fdlisten=escuchar(PUERTO);
if(fdlisten==-1)
{ printf ("No se pudo abrir puerto para escuchar\n");
return -1;;
}
for(i=0;i<bots;i++)
{ //crear proceso de bot
llave=ftok("./cliente.c",40+i);
sembot[i]=obtenersem(llave);
iniciasem(sembot[i],0); //1=verde
cont_clientes++;
strcpy(vnombres[i],"<Bot>");
if ( (j=fork())==0 )
{ char param[5];
sprintf(param,"%d",i);
char * args[] = { "bot", param , NULL };
execv("bot",args);
}
}
while (cont_clientes<jugadores)
{
fdcliente=aceptar(fdlisten);
if(fdcliente==-1)
{
printf ("no se pudo accept()\n");
return -1;
}
cont_clientes++;
error=pthread_create (&clientes[cont_clientes-1],NULL,atender,(void *)&fdcliente);
if (error)
//printf ("no se pudo crear el hilo %ld", (long)clientes[cont_clientes-1]);
//printf ("no se pudo crear el hilo %d", clientes[cont_clientes-1]);
printf ("no se pudo crear el hilo %d", cont_clientes-1);
}
sleep(2);
printf ("Comenzando la partida...\n");
//enviar a todos el pakete I
for(i=bots;i<jugadores;i++)
{ packout.cabecera='I';
packout.cantniv=cant_niveles;
for(j=0;j<MAX_JUGADORES;j++)
strcpy(packout.nombre[j],vnombres[j]);
packout.nrojugador=i+1;
enviar (fdclientes[i],(void*)&packout,sizeof(packout));
}
sleep(2);
for(ronda=1;ronda<cant_niveles+1;ronda++)
{
//enviar a todos el pakete N
packout.cabecera='N';
packout.cantniv=ronda;
//establecer posiciones y direcciones iniciales
switch (jugadores)
{
case 2:
direcc[0]=2;x[0]=6;y[0]=6;
direcc[1]=4;x[1]=70;y[1]=18;
break;
case 3:
direcc[0]=2;x[0]=4;y[0]=4;
direcc[1]=4;x[1]=76;y[1]=4;
direcc[2]=4;x[2]=72;y[2]=20;
break;
case 4:
direcc[0]=3;x[0]=37;y[0]=4;
direcc[1]=4;x[1]=76;y[1]=12;
direcc[2]=1;x[2]=37;y[2]=20;
direcc[3]=2;x[3]=4;y[3]=12;
break;
case 5:
direcc[0]=2;x[0]=4;y[0]=4;
direcc[1]=4;x[1]=75;y[1]=4;
direcc[2]=2;x[2]=4;y[2]=20;
direcc[3]=4;x[3]=75;y[3]=20;
direcc[4]=1;x[4]=37;y[4]=16;
break;
case 6:
direcc[0]=2;x[0]=4;y[0]=4;
direcc[1]=4;x[1]=75;y[1]=4;
direcc[2]=2;x[2]=4;y[2]=20;
direcc[3]=4;x[3]=75;y[3]=20;
direcc[4]=2;x[4]=8;y[4]=12;
direcc[5]=4;x[5]=71;y[5]=12;
}
llenardatos(&packout);
for(i=bots;i<jugadores;i++)
{ enviar(fdclientes[i],(void*)&packout,sizeof(packout)); }
printf("Empieza ronda %d...\n",ronda);
limpiamatriz();
ganador=0;
sleep(3);
while(alguienvive())
{
for(i=0;i<bots;i++)
semverde(sembot[i]);
if (dificultad==0)
usleep(300000/ronda);
else
usleep(500000/dificultad);
//cuando se cumple el tiempo
procesarmovimientos();
if(!alguienvive())
break;
fflush(stdout);
packout.cabecera='S';
llenardatos(&packout);
//for(i=0;i<jugadores;i++)
//printf("%d: <%d,%d;%d> ",i,x[i],y[i],direcc[i]);
//printf("\n");
for(i=bots;i<jugadores;i++)
{ enviar(fdclientes[i],(void*)&packout,sizeof(packout)); }
}
packout.cabecera='F'; //Fin de ronda
packout.ganador=ganador;
for(i=0;i<jugadores;i++)
packout.puntajes[i]=puntajes[i];
for(i=bots;i<jugadores;i++)
{ enviar(fdclientes[i],(void*)&packout,sizeof(packout)); }
sleep(5);
}
printf("FIN DE JUEGO\n");
for (i=bots;i<jugadores;i++)
pthread_join (clientes[i], NULL );
printf("Eliminando hilos...\n");fflush(stdout);
terminar();
return 0;
}
/*
============================================================================
Funcion principal
============================================================================
*/
int main(int argc, char *argv[]) {
stHeaderIPC *unHeaderIPC = NULL, *stHeaderSwitch = NULL;
stMensajeIPC unMensaje;
stPCB *unPCB = NULL;
t_UMCConfig UMCConfig;
pthread_t p_thread, p_threadCpu;
char* temp_file = "nucleo.log";
elEstadoActual.path_conf = argv[1];
uint32_t pid_desconectado = 0;
int unCliente = 0, maximoAnterior = 0, unSocket, agregarSock;
struct sockaddr addressAceptado;
/*Inicializacion de las colas del planificador*/
inicializar_pidCounter();
inicializar_cola_ready();
listaBlock = list_create();
consola_crear_lista();
log_create(temp_file, "NUCLEO", -1, LOG_LEVEL_INFO);
log_info("Arrancando el Nucleo");
if (elEstadoActual.path_conf == NULL) {
log_error("Falta el parametro de configuracion");
exit(-1);
}
/*Carga del archivo de configuracion*/
if (loadInfo(&elEstadoActual, 0)) {
log_error("Error al cargar la configuracion");
exit(-2);
}
log_info("Configuracion cargada satisfactoriamente...");
/*Se lanza el thread para identificar cambios en el archivo de configuracion*/
pthread_create(&p_thread, NULL, &monitor_configuracion, (void*) &elEstadoActual);
inicializarThreadsDispositivos(&elEstadoActual);
/*Inicializacion de listas de socket*/
FD_ZERO(&(fds_master));
FD_ZERO(&(read_fds));
/*Inicializacion de socket de escucha*/
elEstadoActual.salir = 0;
elEstadoActual.sockEscuchador = -1;
/*Iniciando escucha en el socket escuchador de Consola*/
elEstadoActual.sockEscuchador = escuchar(elEstadoActual.miPuerto);
FD_SET(elEstadoActual.sockEscuchador, &(fds_master));
log_debug("Se establecio conexion con el socket de escucha...");
/*Seteamos el maximo socket*/
elEstadoActual.fdMax = elEstadoActual.sockEscuchador;
/*Conexion con el proceso UMC*/
log_debug("Estableciendo conexion con la UMC...");
elEstadoActual.sockUmc = conectar(elEstadoActual.ipUmc, elEstadoActual.puertoUmc);
if (elEstadoActual.sockUmc != -1) {
//FD_SET(elEstadoActual.sockUmc, &(fds_master));
unHeaderIPC = nuevoHeaderIPC(ERROR);
if (!recibirHeaderIPC(elEstadoActual.sockUmc, unHeaderIPC)) {
log_error("UMC handshake error - No se pudo recibir mensaje de respuesta");
log_error("No se pudo conectar a la UMC");
elEstadoActual.salir = 1;
}
if (unHeaderIPC->tipo == QUIENSOS) {
unHeaderIPC = nuevoHeaderIPC(CONNECTNUCLEO);
if (!enviarHeaderIPC(elEstadoActual.sockUmc, unHeaderIPC)) {
log_error("UMC handshake error - No se pudo enviar mensaje de conexion");
log_error("No se pudo conectar a la UMC");
elEstadoActual.salir = 1;
}
}
liberarHeaderIPC(unHeaderIPC);
unHeaderIPC = nuevoHeaderIPC(OK);
if (!recibirHeaderIPC(elEstadoActual.sockUmc, unHeaderIPC)) {
log_error("UMC handshake error - No se pudo recibir mensaje de confirmacion");
log_error("No se pudo conectar a la UMC");
elEstadoActual.salir = 1;
} else {
if (recibirConfigUMC(elEstadoActual.sockUmc, &UMCConfig)) {
log_error("UMC error - No se pudo recibir la configuracion");
close(unCliente);
exit(-2);
}
agregar_master(elEstadoActual.sockUmc,maximoAnterior);
log_info("Paginas por proceso:[%d]", UMCConfig.paginasXProceso);
log_info("Tamanio de pagina:[%d]", UMCConfig.tamanioPagina);
elEstadoActual.tamanio_paginas = UMCConfig.tamanioPagina;
}
liberarHeaderIPC(unHeaderIPC);
} else {
log_error("No se pudo conectar a la UMC");
elEstadoActual.salir = 1;
}
/*Ciclo Principal del Nucleo*/
log_info(".............................................................................");
log_info("..............................Esperando Conexion.............................\n\n");
fflush(stdout);
while (elEstadoActual.salir == 0) {
read_fds = fds_master;
if (seleccionar(elEstadoActual.fdMax, &read_fds, 0) == -1) {
log_error("Error Preparando el Select");
break;
}
for (unSocket = 0; unSocket <= elEstadoActual.fdMax; unSocket++) {
if (FD_ISSET(unSocket, &read_fds)) {
/*Nueva conexion*/
if (unSocket == elEstadoActual.sockEscuchador) {
unCliente = aceptar(elEstadoActual.sockEscuchador, &addressAceptado);
unHeaderIPC = nuevoHeaderIPC(QUIENSOS);
if (!enviarHeaderIPC(unCliente, unHeaderIPC)) {
log_error("Cliente Handshake error - No se puede enviar el mensaje QUIENSOS");
liberarHeaderIPC(unHeaderIPC);
close(unCliente);
break;/*Sale del for*/
}
liberarHeaderIPC(unHeaderIPC);
unHeaderIPC = nuevoHeaderIPC(ERROR);
if (!recibirHeaderIPC(unCliente, unHeaderIPC)) {
log_error("Cliente Handshake error - No se puede recibir el mensaje");
liberarHeaderIPC(unHeaderIPC);
close(unCliente);
break;/*Sale del for*/
}
/*Identifico quien se conecto y procedo*/
switch (unHeaderIPC->tipo) {
case CONNECTCONSOLA:
stHeaderSwitch = nuevoHeaderIPC(OK);
if (!enviarHeaderIPC(unCliente, stHeaderSwitch)) {
log_error("Handshake Consola - No se pudo enviar el OK");
liberarHeaderIPC(stHeaderSwitch);
close(unCliente);
break;/*Sale del switch*/
}
liberarHeaderIPC(stHeaderSwitch);
log_info("Nueva consola conectada");
agregarSock = 1;
/*Agrego el socket conectado a la lista Master*/
if (agregarSock == 1) {
agregar_master(unCliente, maximoAnterior);
agregarSock = 0;
}
/* Recibo Programa */
if (!recibirMensajeIPC(unCliente, &unMensaje)) {
log_error("No se puede recibir el programa a procesar");
break;/*Sale del switch*/
} else {
if (unMensaje.header.tipo == SENDANSISOP) {
/*metadata_desde_literal hace un malloc adentro*/
int cantidadDePaginasCodigo = calcular_cantidad_paginas(unMensaje.header.largo, UMCConfig.tamanioPagina);
/***Creacion del PCB***/
unPCB = crear_pcb(unCliente, cantidadDePaginasCodigo, elEstadoActual.stackSize, &unMensaje);
if (unPCB == NULL) {
log_error("Error al crear el PCB... se cierra la consola\n");
quitar_master(unCliente, maximoAnterior);
close(unCliente);
break;/*Sale del switch*/
}
if (inicializar_programa(unPCB, (char *)unMensaje.contenido, elEstadoActual.sockUmc) == EXIT_FAILURE) {
log_error("No se pudo inicializar el programa");
quitar_master(unCliente, maximoAnterior);
close(unCliente);
break;/*Sale del switch*/
}
/* Inicializada la consola la agrego a consolas activas */
agregar_consola(unCliente, unPCB->pid);
/*Cuando se usa mensajeIPC liberar el contenido*/
free(unMensaje.contenido);
ready_productor(unPCB);
log_info("PCB [PID - %d] NEW a READY\n", unPCB->pid);
fflush(stdout);
}
}
break;
case CONNECTCPU:
stHeaderSwitch = nuevoHeaderIPC(OK);
if (!enviarHeaderIPC(unCliente, stHeaderSwitch)) {
liberarHeaderIPC(stHeaderSwitch);
log_error("CPU error - No se pudo enviar OK");
close(unCliente);
break;/*Sale del switch*/
}
liberarHeaderIPC(stHeaderSwitch);
if (pthread_create(&p_threadCpu, NULL, (void*) consumidor_cpu, (void*) &unCliente) != 0) {
log_error("No se pudo lanzar el hilo correspondiente al cpu conectado");
close(unCliente);
break;/*Sale del switch*/
}
log_info("Se lanza hilo de atencion a CPU conectado");
fflush(stdout);
break;
default:
break;
}
if (unHeaderIPC != NULL) {
liberarHeaderIPC(unHeaderIPC);
}
} else {
/*Conexion existente*/
log_debug("Recibi otro evento de un cliente ya conectado");
if (!recibirMensajeIPC(unSocket, &unMensaje)) {
log_info("Desconexion detectada");
// Desconexion de una consola
pid_desconectado = borrar_consola(unSocket);
// Desconexion de la UMC
if (unSocket == elEstadoActual.sockUmc) {
log_info("Se perdio conexion con la UMC...");
elEstadoActual.salir = 1;
cerrarSockets(&elEstadoActual);
}
if (unSocket == elEstadoActual.sockEscuchador) {
log_debug("Se perdio conexion...");
}
/*Saco el socket de la lista Master*/
quitar_master(unSocket, maximoAnterior);
fflush(stdout);
}
}
}
}
}
destruir_planificador();
destruir_lista_dispositivos(&elEstadoActual);
consola_destruir_lista(&elEstadoActual);
cerrarSockets(&elEstadoActual);
finalizarSistema(&unMensaje, unSocket, &elEstadoActual);
log_info("Fin del programa");
return 0;
}
