RUniforme::RUniforme(QWidget *parent, Imagen image) :
QWidget(parent),
ui(new Ui::RUniforme)
{
ui->setupUi(this);
setValues(image);
connect(ui->ButtonCancelar, SIGNAL(clicked()), this, SLOT(cancelar()));
connect(ui->ButtonAceptar, SIGNAL(clicked()), this, SLOT(aceptar()));
//cambios de spinbox cambian imagen directamente
connect(ui->doubleSpinBoxP, SIGNAL(editingFinished()), this, SLOT(cambiarImagen()));
connect(ui->spinBoxN1, SIGNAL(editingFinished()), this, SLOT(cambiarImagen()));
connect(ui->spinBoxN2, SIGNAL(editingFinished()), this, SLOT(cambiarImagen()));
connect(ui->checkBoxHistR, SIGNAL(pressed()), this, SLOT(verHistRuido()));
connect(ui->checkBoxImagenR, SIGNAL(pressed()), this, SLOT(verImagenRuido()));
connect(ui->spinBoxN1, SIGNAL(editingFinished()), this, SLOT(comprobarRango()));
connect(ui->spinBoxN2, SIGNAL(editingFinished()), this, SLOT(comprobarRango()));
//cambiarImagen(); //por defecto ya se ve un ruido hecho
//emit(changed());
}
Frmanalitica2::Frmanalitica2(QWidget *parent) :
QDialog(parent),
ui(new Ui::Frmanalitica2)
{
ui->setupUi(this);
connect(ui->btnAnadir,SIGNAL(clicked()),this,SLOT(aceptar()));
connect(ui->btnCancelar,SIGNAL(clicked()),this,SLOT(close()));
}
FrmTarifas::FrmTarifas(QWidget *parent) :
QDialog(parent),
ui(new Ui::FrmTarifas)
{
ui->setupUi(this);
ui->tabWidget->setCurrentIndex(0);
QSqlQueryModel *modelo = new QSqlQueryModel(this);
modelo->setQuery("Select descripcion from codigotarifa",Configuracion_global->groupDB);
ui->listaTarifa->setModel(modelo);
modelVolumenes = new QSqlQueryModel(this);
ui->tabla_volumenes->setModel(modelVolumenes);
this->id_volumen =0;
this->id_tarifa =0;
modelVolumenes->setQuery(QString("select id,desde,hasta,precio from articulos_volumen where id_tarifa = %1").arg(this->id_tarifa),
Configuracion_global->groupDB);
QStringList headers;
QVariantList sizes;
headers << "id" <<tr("Desde") << tr("Hasta") << tr("Precio");
sizes << 0 << 60 << 60 <<100;
for(int i=0;i<headers.size();i++)
{
ui->tabla_volumenes->setColumnWidth(i,sizes.at(i).toInt());
modelVolumenes->setHeaderData(i,Qt::Horizontal,headers.at(i));
if(i>0)
ui->tabla_volumenes->setItemDelegateForColumn(i,new MonetaryDelegate(this));
}
//-----------
// CONEXIONES
//-----------
connect(ui->listaTarifa,SIGNAL(clicked(QModelIndex)),this,SLOT(cargarDatosTarifa(QModelIndex)));
connect(ui->txtPVPDivisa,SIGNAL(editingFinished()),Configuracion_global,SLOT(format_text()));
connect(ui->txtPVPDivisa,SIGNAL(editingFinished()),this,SLOT(cambiar_precio_editingfinished()));
connect(ui->btnAceptar,SIGNAL(clicked()),this,SLOT(aceptar()));
connect(ui->spinMargen,SIGNAL(valueChanged(double)),this,SLOT(calcular_precio(double)));
//-------------------------------
// CAMBIO DIVISA
//-------------------------------
connect(Configuracion_global,SIGNAL(cambioReady(float)),this,SLOT(asignarcambiodivisa(float)));
// Configuracion_global->getCambio("EUR","USD",1);
ui->spinMargen->setValue(Configuracion_global->margen);
ui->spinmargen_minimo->setValue(Configuracion_global->margen_minimo);
}
void Servidor::ejecutar(unsigned int repeticiones) {
char filename[42], palabra[42], buffer[TAM_DGRAMA+1];
for (int i = 0; i < repeticiones; ++i) {
otro_descriptor = aceptar();
recibir_n();
for(int i = 0; i < n; ++i) {
sprintf(filename, "%d.txt", i);
archivos.push_back(Archivo(filename, O_RDONLY));
recibir(TAM_DGRAMA, buffer);
palabra_aleatoria(buffer, palabra);
archivos.back().escribe(palabra, strlen(palabra));
archivos.back().cerrar();
close(otro_descriptor);
}
}
}
void Usuarios::mostrarNuevo(){
lbApellido->setVisible(true);
lbApellido->move(490,180);
lbApellido->setText("Apellido: ");
lbCedula->setVisible(true);
lbCedula->move(270,230);
lbCedula->setText("Cedula: ");
leCedula->move(330,230);
lbNombre->setVisible(true);
lbNombre->move(260,180);
lbNombre->setText("Nombre: ");
leNombre->setVisible(true);
leNombre->move(330,180);
leNombre->setText("");
leApellido->setVisible(true);
leApellido->move(560,180);
leApellido->setText("");
leCedula->setVisible(true);
leCedula->setText("");
btnAceptar->setVisible(true);
disconnect(btnAceptar, SIGNAL(clicked()), 0, 0);
btnAceptar->move(450,320);
btnAceptar->setText("Aceptar");
btnAceptar->setIcon(QIcon(":/images/aceptar.png"));
btnAceptar->setIconSize(QSize(15,15));
connect(btnAceptar,SIGNAL(clicked()),this,SLOT(aceptar()));
rbEstu->setVisible(true);
rbEstu->move(540,260);
rbProf->move(540,230);
rbProf->setVisible(true);
lbTipo->setText("Tipo: ");
lbTipo->move(490,230);
lbTipo->setVisible(true);
}
/**
* Loop principal del algoritmo Simulated Annealing.
*
* @instance :: Instancia del BACP
* @iter :: Numero maximo de iteraciones para una temperatura t_current
* @t_current :: Temperatura inicial
* @t_min :: Temperatura minima (eps)
* @alpha :: Velocidad de decaimiento de la temperatura
*/
void run(struct bacp_instance *instance, int iter, float t_current, float t_min, float alpha)
{
unsigned short int i;
unsigned short int new_cost;
unsigned short int *s_c = instance->period;
unsigned short int old_cost = cost(instance);
unsigned short int best_cost = old_cost;
unsigned short int *s_best = copy_solution(instance->period, instance->n_courses);
instance->period = NULL;
while (t_current > t_min) {
i = 0;
while (++i <= iter) {
if (instance->period) free(instance->period);
instance->period = s_c;
instance->period = neighbour(instance);
new_cost = cost(instance);
if (new_cost < old_cost || (exp(-abs(new_cost - old_cost)/t_current) > aceptar())) {
free(s_c);
s_c = instance->period;
old_cost = new_cost;
instance->period = NULL;
}
if ( best_cost > new_cost ) {
if (s_best) free(s_best);
s_best = copy_solution(s_c, instance->n_courses);
best_cost = new_cost;
}
}
t_current = t_current * alpha;
}
if (instance->period) free(instance->period);
if (s_c) free(s_c);
instance->period = s_best;
}
void Libro::mostrarNuevo(){
lbCota->setText("(*)Cota: ");
lbCota->move(200,180);
lbCota->setVisible(true);
leCota->move(270,180);
leCota->setVisible(true);
lbAutor->setText("(*)Autor: ");
lbAutor->move(400,180);
lbAutor->setVisible(true);
leAutor->move(460,180);
leAutor->setVisible(true);
lbTitulo->setText("(*)Titulo: ");
lbTitulo->move(590,180);
lbTitulo->setVisible(true);
leTitulo->move(660,180);
leTitulo->setVisible(true);
lbMateria->setText("(*)Materia: ");
lbMateria->move(200,230);
lbMateria->setVisible(true);
leMateria->move(270,230);
leMateria->setVisible(true);
lbEditorial->move(400,230);
lbEditorial->setVisible(true);
leEditorial->move(460,230);
leEditorial->setVisible(true);
lbAnhoPublicacion->move(590,230);
lbAnhoPublicacion->setVisible(true);
leAnhoPublicacion->move(690,230);
leAnhoPublicacion->setVisible(true);
lbLugar->move(200,280);
lbLugar->setVisible(true);
leLugar->move(270,280);
leLugar->setVisible(true);
lbAdquisicion->move(400,280);
lbAdquisicion->setVisible(true);
comboAdquisicion->move(480,275);
comboAdquisicion->setCurrentIndex(0);
comboAdquisicion->setVisible(true);
lbVolumen->setText("Tomo: ");
lbVolumen->move(590,280);
lbVolumen->setVisible(true);
leVolumen->move(670,280);
leVolumen->setVisible(true);
lbEstado->move(200,330);
lbEstado->setVisible(true);
comboEstado->move(290,325);
comboEstado->setCurrentIndex(0);
comboEstado->setVisible(true);
btnAceptar->move(440,400);
btnAceptar->setVisible(true);
btnAceptar->setText("Aceptar");
btnAceptar->setIcon(QIcon(":/images/aceptar.png"));
comboAdquisicion->setEditable(false);
leCota->setReadOnly(false);
leAutor->setReadOnly(false);
leTitulo->setReadOnly(false);
leMateria->setReadOnly(false);
leEditorial->setReadOnly(false);
leAnhoPublicacion->setReadOnly(false);
leLugar->setReadOnly(false);
leVolumen->setReadOnly(false);
leEjemplar->setReadOnly(false);
disconnect(btnAceptar, SIGNAL(clicked()), 0, 0);
connect(btnAceptar,SIGNAL(clicked()),this,SLOT(aceptar()));
disconnect(btnCancelar,SIGNAL(clicked()),0,0);
connect(btnCancelar,SIGNAL(clicked()),this,SLOT(cancelar()));
}
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;
}
