int connect_inter(int *sock, sockaddr_in *inter) {
hostent *he;
if(!preparar(sock, inter, he, 10500)) return 0;
if(!conectar(*sock, inter)) return 0;
return 1;
}
int main ()
{
// long long int val=pow(10,64);
// WSADATA wsa;
BOARD Board;
int saida[4];
//struct sockaddr_in *server;
char *name="",retorno[10000];
Board=conectar(name,&Board);
puts(Board.board);
int tamanho;
while(Board.winner==0 && Board.draw==0)
{
BITBOARD bitB = BoardParser(whoMoves,Board.board);
max_move(bitB, 4);
print_board(bitB.allyBoard);
print_board(finalBoard.allyBoard);
//DumpBitBoard(bitB);
//printf("FINAL\n");
//DumpBitBoard(finalBoard);
PegarCoordenadas(bitB, finalBoard,saida);
printf("Jogada: %d,%d - %d,%d\n",saida[0],saida[1],saida[2],saida[3]);
Board = enviaPosicao(saida[0],saida[1],saida[2],saida[3],&Board);
}
name=NULL;
return 0;
}
bool conectarUMV()
{
socketUMV = conectar(config_get_string_value(config, "IP_UMV"), config_get_int_value(config, "PUERTO_UMV"), logplp);
if (socketUMV == -1) {
log_error(logplp, "No se pudo establecer la conexion con la UMV");
return false;
}
log_info(logplp, "Conectado con la UMV");
socket_header handshake;
handshake.size = sizeof(socket_header);
handshake.code = 'k'; //Kernel
if( send(socketUMV, &handshake, sizeof(socket_header), 0) <= 0 )
{
log_error(logplp, "No se puedo enviar Handshake a la UMV");
sem_post(&semKernel);
return false;
}
return true;
}
int menu(Peer** peer)
{
while(1)
{
int op;
printf("\n1 - Conectar\n0 - sair\n- ");
rewind(stdin);
scanf("%d", &op);
switch(op)
{
case 1:
if(conectar(peer))
{
printf("Conectado.\n");
return 1;
}
break;
case 0:
return 0;
break;
default:
printf("Opcao invalida. tente novamente\n");
}
}
printf("Oacacacacac\n");
}
int hiloCPU() {
t_cpu* cpu = crearCPU();
list_add(procCPU->listaCPU, cpu);
pthread_mutex_lock(&mutexCPULogs);
log_info(logger, identificaCPU(queHiloSoy()));
log_info(logger, "comienza ejecucion de un HILO ");
log_info(logger,
string_from_format("Me estoy levantando soy la cpu , %s \n",
cpu->nombre));
pthread_mutex_unlock(&mutexCPULogs);
// printf("Me estoy levantando soy la cpu , %s", cpu->nombre);
// printf("Creando CPU la id del hilo es %lu \n", cpu->idCPU);
//conexiones = dictionary_create();
int socketPlanificador;
int socketMemoria;
int resultConexion_mem = 0;
int resultConexion_planif = 0;
resultConexion_planif = conectar(configuracion->vg_ipPlanificador,
string_itoa(configuracion->vg_puertoPlanificador),
&socketPlanificador);
if (resultConexion_planif == -1)
pthread_mutex_lock(&mutexCPULogs);
log_info(logger, identificaCPU(queHiloSoy()));
log_error(logger, "[ERROR]no se conecto el CPU al Planificador");
pthread_mutex_unlock(&mutexCPULogs);
//dictionary_put(conexiones, "Planificador", string_itoa(socketPlanificador));
cpu->socketPlanificador = socketPlanificador;
enviarStruct(socketPlanificador, HANDSHAKE_CPU, getNombre());
resultConexion_mem = conectar(configuracion->vg_ipMemoria,
string_itoa(configuracion->vg_puertoMemoria), &socketMemoria);
if (resultConexion_mem == -1)
log_info(logger, identificaCPU(queHiloSoy()));
log_error(logger, "[ERROR]no se conecto el CPU a la memoria");
//dictionary_put(conexiones, "Memoria", string_itoa(socketMemoria));
cpu->socketMemoria = socketMemoria;
escucharConexiones("0", socketPlanificador, socketMemoria, 0,
procesarMensajes, NULL, logger);
return 0;
}
//-----------------------------------------------------------
void ConexaoBD::operator = (ConexaoBD &conex)
{
if(this->conexaoEstabelecida())
this->fechar();
this->params_conexao=conex.params_conexao;
this->str_conexao=conex.str_conexao;
conectar();
}
void buscar_registro(char *tabla,char *nombre,char *valor,void *callback,void *extra)
{
conectar(BASE);
char consulta[255];
sprintf(consulta,BUSCAR_REGISTRO,tabla,nombre,valor);
sqlite3_exec(conexion,consulta,callback,0,&error);
}
void do_echo(int *sock, char *buf, sockaddr_in *serv, hostent *he, int port) {
if(!port) {
port = get_porta();
}
if(!preparar(sock, serv, he, port)) return 0;
if(!conectar(*sock, serv)) return 0;
if(!enviar(*sock, buf)) return 0;
return 1;
}
//-----------------------------------------------------------
ConexaoBD::ConexaoBD(const QString &servidor, const QString &porta, const QString &usuario, const QString &senha, const QString &nome_bd)
{
//Configura os parâmetros básicos de conexão
definirParamConexao(PARAM_FQDN_SERVIDOR, servidor);
definirParamConexao(PARAM_PORTA, porta);
definirParamConexao(PARAM_USUARIO, usuario);
definirParamConexao(PARAM_SENHA, senha);
definirParamConexao(PARAM_NOME_BD, nome_bd);
//Estabelece a conexão
conectar();
}
void agregar_proveedor(PROVEEDOR *proveedor)
{
char *error;
char consulta[255]="";
sprintf(consulta,AGREGAR_PROVEEDOR,proveedor->proveedor_id,
proveedor->nombre,proveedor->telefono,
proveedor->direccion,proveedor->email);
printf(consulta);
sqlite3* conexion=conectar(BASE);
// sqlite3_exec(conexion,consulta,mostrar,NULL,&error);
sqlite3_exec(conexion,consulta,0,0,&error);
printf("%s",error);
}
void probarReduceNodo(){
int socket = conectar("127.0.0.1", "6000");
char* mensaje = string_new();
string_append(&mensaje, "21/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/red.sh,1_/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/tmp/asd*2_/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/tmp/asdpruebaparamerge,/reduceout");
if( enviar(socket, mensaje, strlen(mensaje)) != -1)
printf("MENSAJE ENVIADO: 21/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/red.sh,1_/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/tmp/asd*2_/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/tmp/asdpruebaparamerge,/reduceout \n \n ---------------------------------------------------- \n \n");
// char* mensaje2 = string_new();
// string_append(&mensaje2, "20/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/count2.sh,1,/asd");
//
// if( enviar(socket, mensaje2, strlen(mensaje2)) != -1)
// printf("MENSAJE ENVIADO: 20/home/utnso/git/tp-2015-1c-souvenir-jackitos/Nodo/count.sh,1,/asd \n \n ---------------------------------------------------- \n \n");
}
bool crearConexionUMV() {
log_debug(logger, "Conectando a la UMV en %s:%d", config_get_string_value(config, "IPUMV"), config_get_int_value(config, "PUERTOUMV"));
socketUMV = conectar(config_get_string_value(config, "IPUMV"), config_get_int_value(config, "PUERTOUMV"), logger);
if (socketUMV < 0) {
log_error(logger, "No se pudo conectar al UMV");
close( socketUMV );
return false;
}
socket_header handshake;
handshake.code = 'c';
handshake.size = sizeof(socket_header);
if(send(socketUMV, &handshake, handshake.size, 0 ) > 0 ) {
return true;
}
log_error(logger, "Error al enviar el handshake a la UMV");
return false;
}
int main(void) {
int opcion;
printf("\n \n1)Probar map nodo \n2)Probar reduce nodo \n3)Libre\n");
scanf("%d", &opcion);
if(opcion == 1)
probarMapNodo();
if(opcion == 2)
probarReduceNodo();
if(opcion == 3){
printf("\n \n ---------------------------------------------------- \n \n");
char* ip = string_new();
char* puerto = string_new();
char* mensaje = string_new();
printf("INGRESAR IP \n");
scanf("%s", ip);
printf("INGRESAR PUERTO \n");
scanf("%s", puerto);
int socket = conectar(ip, puerto);
printf("INGRESAR MENSAJE \n");
scanf("%s", mensaje);
if( enviar(socket, mensaje, strlen(mensaje)) != -1)
printf("MENSAJE ENVIADO \n \n ---------------------------------------------------- \n \n");
}
return EXIT_SUCCESS;
}
int main (int argc, char *argv[]){
struct sigaction sa_sigint;
struct sigaction sa_sigchld;
sa_sigint.sa_handler = sig_handler;
sa_sigint.sa_flags = SA_RESTART;
if(sigaction(SIGINT, &sa_sigint, NULL) == -1)
{
printf("No se pudo registrar el manejador para Ctrl-C\n");
}
sa_sigchld.sa_handler = SIG_IGN;
sa_sigchld.sa_flags = SA_NOCLDSTOP || SA_NOCLDWAIT;
if(sigaction(SIGCHLD, &sa_sigchld, NULL) == -1)
{
printf("No se pudo registrar el manejador para SIGCHLD\n");
}
puerto = 6666;
ip = "192.168.1.66";
struct sockaddr_in addin;
printf("Conectando al servidor...\n");
sckdes=crear_socket_cliente(puerto, ip, (struct sockaddr *)&addin);
if(conectar(sckdes, (struct sockaddr *)&addin) != -1)
{
printf(">>> Conexion establecida con el servidor\n");
char comando[MAX_LINE];
while(leer_socket(sckdes,comando,MAX_LINE) > 0)
{
if(*comando == '\0') continue;
printf(">> %s\n",comando);
exec_cmd(comando);
}
}else
{
printf("[*] No se ha podido conectar con el servidor\n");
}
cerrar_cliente();
}
void principal () {
int id_proceso, i, se_desconecto;
int fin = false;
int sockPlataforma = -1;
header_t header;
fd_set master;
fd_set read_fds;
FD_ZERO(&master);
FD_ZERO(&read_fds);
int max_desc = 0;
char buffer[BUF_LEN];
id_proceso = getpid();
log_info(LOGGER,"************** Iniciando Nivel '%s' (PID: %d) ***************\n", NOMBRENIVEL, id_proceso);
// Conectar con proceso Plataforma
conectar(configNivelPlataformaIp(), configNivelPlataformaPuerto(), &sockPlataforma);
if (enviarMSJNuevoNivel(sockPlataforma) != EXITO) {
log_error(LOGGER, "ERROR en conexion con Plataforma");
finalizarNivel();
exit(EXIT_FAILURE);
}
// Agrego descriptor del socket de conexion con plataforma
agregar_descriptor(sockPlataforma, &master, &max_desc);
// Agrego descriptor del inotify
agregar_descriptor(notifyFD, &master, &max_desc);
// Agrego descriptor de comunicacion con hilo de interbloqueo por pipe
agregar_descriptor(hiloInterbloqueo.fdPipeI2N[0], &master, &max_desc);
// Agrego fd del pipe con hilos enemigos
agregarFDPipeEscuchaEnemigo(&master, &max_desc);
// Lanzo Hilo de Interbloqueo
pthread_create (&hiloInterbloqueo.tid, NULL, (void*) interbloqueo, NULL);
while(!fin) {
FD_ZERO (&read_fds);
read_fds = master;
if((select(max_desc+1, &read_fds, NULL, NULL, NULL)) == -1) {
log_error(LOGGER, "NIVEL_MAIN ERROR en el select");
} else {
for(i = 0; i <= max_desc; i++)
{
if (FD_ISSET(i, &read_fds))
{
if (i == sockPlataforma)
{
log_debug(LOGGER, "1) recibo mensaje socket %d", i);
initHeader(&header);
recibir_header(i, &header, &master, &se_desconecto);
if(se_desconecto)
{
log_info(LOGGER, "Se desconecto el socket %d ", i);
quitar_descriptor(i, &master, &max_desc);
} else {
log_debug(LOGGER, "Llego mensaje %d (fd:%d)", header.tipo, i);
switch(header.tipo) {
case NIVEL_CONECTADO:
log_info(LOGGER, "Llego mensaje '%d' NIVEL_CONECTADO (fd:%d)", header.tipo, i);
break;
case NUEVO_PERSONAJE:
log_info(LOGGER, "Llego mensaje '%d' NUEVO_PERSONAJE (fd:%d)", header.tipo, i);
tratarNuevoPersonaje(i, header, &master);
break;
case SOLICITUD_UBICACION:
log_info(LOGGER, "Llego mensaje '%d' SOLICITUD_UBICACION (fd:%d)", header.tipo, i);
tratarSolicitudUbicacion(i, header, &master);
break;
case SOLICITUD_RECURSO:
log_info(LOGGER, "Llego mensaje '%d' SOLICITUD_RECURSO (fd:%d)", header.tipo, i);
tratarSolicitudRecurso(i, header, &master);
break;
case MOVIMIENTO_REALIZADO:
log_info(LOGGER, "Llego mensaje '%d' MOVIMIENTO_REALIZADO (fd:%d)", header.tipo, i);
tratarMovimientoRealizado(i, header, &master);
break;
case PLAN_NIVEL_FINALIZADO:
log_info(LOGGER, "Llego mensaje '%d' PLAN_NIVEL_FINALIZADO (fd:%d)", header.tipo, i);
tratarPlanNivelFinalizado (i, header, &master);
break;
case MUERTE_PERSONAJE:
log_info(LOGGER, "Llego mensaje '%d' MUERTE_PERSONAJE (fd:%d)", header.tipo, i);
tratarMuertePersonaje (i, header, &master);
break;
case PERSONAJE_DESBLOQUEADO:
log_info(LOGGER, "Llego mensaje '%d' PERSONAJE_DESBLOQUEADO (fd:%d)", header.tipo, i);
desbloquearPersonaje(i, header, &master);
break;
default: log_error(LOGGER, "Llego mensaje '%d' NO RECONOCIDO (fd:%d)", header.tipo, i);
break;
}
}
} else if (i == notifyFD) {
log_info(LOGGER, "Hubo un cambio en el archivo de configuracion (fd:%d)", i);
read(notifyFD, buffer, BUF_LEN);
levantarCambiosArchivoConfiguracionNivel();
log_info(LOGGER, "Nuevos Valores: algoritmo=%s - quantum=%d - retardo=%d", configNivelAlgoritmo(), configNivelQuantum(), configNivelRetardo());
enviarMsjCambiosConfiguracion(sockPlataforma);
} else if ( i == hiloInterbloqueo.fdPipeI2N[0]) {
// Llega mensaje desde hilo interbloqueo por Pipe
log_info(LOGGER, "NivelMain: Recibo mensaje desde Interbloqueo por Pipe: %d", i);
initHeader(&header);
read (i, &header, sizeof(header_t));
log_debug(LOGGER, "NivelMain: mensaje recibido '%d'", header.tipo);
switch (header.tipo)
{
case MUERTE_PERSONAJE_XRECOVERY: log_debug(LOGGER, "'%d' ES MUERTE_PERSONAJE_XRECOVERY", header.tipo);
// TODO Mover personaje a una lista de fiambres??
// informar al planificador
enviarMsjMuertexRecovery(sockPlataforma);
break;
}
} else {
// NO ES NI notifyFD NI mi Planificador Ni el hilo de Interbloqueo
// Entonces debe ser un hilo Enemigo
log_debug(LOGGER, "NivelMain: actividad en el socket %d", i);
log_info(LOGGER, "NivelMain: Recibo mensaje desde Enemigo por Pipe: %d", i);
initHeader(&header);
read (i, &header, sizeof(header_t));
log_debug(LOGGER, "NivelMain: mensaje recibido '%d'", header.tipo);
switch (header.tipo)
{
case MUERTE_PERSONAJE_XENEMIGO: log_debug(LOGGER, "'%d' ES MUERTE_PERSONAJE_XENEMIGO", header.tipo);
// TODO mover personaje a lista de fiambres ??
// informar al planificador
enviarMsjMuertexEnemigo(sockPlataforma);
break;
}
// if(se_desconecto)
// {
// log_info(LOGGER, "Se desconecto el socket %d", i);
// quitar_descriptor(i, &master, &max_desc);
//
// } else {
// log_debug(LOGGER, "2) Llego mensaje del socket %d: %d NO RECONOCIDO", i, header.tipo);
// }
}
}
}
}
} // Cierro while
pthread_join (hiloInterbloqueo.tid, NULL); //espera que finalice el hilo de interbloqueo para continuar
close (sockPlataforma);
return;
}
/*
============================================================================
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;
}
