void CargarPrueba::slotRowSelected(int row)
{
item = new QTableWidgetItem;
item = tablePrestamo->item(row,0);
QString strQuery = "SELECT * FROM prueba WHERE id = '"
+ item->text() + "'";
item = new QTableWidgetItem;
item = tablePrestamo->item(row,2);
QString strQuery2 = "SELECT * FROM protocolo WHERE id = " + item->text();
QSqlQuery query;
query.exec(strQuery);
QSqlQuery query2;
query2.exec(strQuery2);
if( query.next() && query2.next() ) {
emit enviarDatos(query,query2);
}
}
Ventanita::Ventanita(QWidget *parent) :
QDialog(parent),
ui(new Ui::Ventanita)
{
ui->setupUi(this);
//Los datos de puerto y IP se definen de manera directa aquí dada la sencillez del ejemplo, sin embargo en una
//buena implementación es aconsejable que sean ingresados por el usuario.
cliente = new Cliente(5500, QHostAddress("127.0.0.1"));
connect(ui->botonEnviar,SIGNAL(clicked()),SLOT(enviarDatos()));
connect(ui->botonCerrar,SIGNAL(clicked()),SLOT(close()));
}
void sig_handler(int signo) {
if (signo == SIGUSR1)
{
char * buffer = "Se ha recibido la senial SIGUSR1";
log_info(Log, "Se ha recibido la senial SIGUSR1");
if (operacion == NOTHING)
{
finalizarConexion(socket_PCP);
return;
}
cerrarCPU = true;
enviarDatos(socket_PCP, &buffer, strlen(buffer) + 1, SIGUSR);
log_debug(Log, "Se termina de ejecutar la rafaga actual y luego se cierra esta CPU");
}
}
void nuevoCliente(int servidor) {
t_clienteCPU *client;
char * estructuraInicialEnBuffer = malloc(sizeof(t_EstructuraInicial));
client = malloc(sizeof(t_clienteCPU));
client->socket = Aceptar_Conexion_Cliente(servidor);
client->ID = (uint32_t) list_size(listaClientes);
client->fueAsignado = false;
client->programaCerrado = false;
list_add(listaClientes, client);
estructuraInicialEnBuffer = serializar_EstructuraInicial(estructuraInicial);
enviarDatos(client->socket, &estructuraInicialEnBuffer,
sizeof(t_EstructuraInicial), NOTHING);
log_debug(log_pcp, "Cliente %d aceptado", client->ID);
log_debug(log_pcp, "Quantum y retardoQuantum enviado al cliente %d",
client->ID);
sem_post(&semClienteOcioso);
// Hago free del buffer
//free(quantumEnBuffer);
free(estructuraInicialEnBuffer);
return;
}
int main(int argc, char *argv[])
{
int errorArgumentos = 0;
int errorLogger = 0;
int errorConfig = 0;
int errorConexion = 0;
int errorEnvio = 0;
int statusRecepcion = 0;
//Variables para el script
FILE *script = NULL;
//Variables para el logger
t_log *logger = NULL;
//Variables para el socket
int unSocket = -1;
struct sockaddr_in socketInfo;
//Variables para la carga de la configuración
t_config *config = NULL;
errorArgumentos = checkArgs(argc);
errorLogger = crearLogger(&logger);
errorConfig = cargarConfig(&config);
if(errorArgumentos || errorLogger || errorConfig) {
goto liberarRecursos;
return EXIT_FAILURE;
}
int puerto = config_get_int_value(config, "Puerto");
char *ip_kernel = config_get_string_value(config, "IP");
if ((script = fopen(argv[1],"r")) != NULL) {
//Pudimos abrir el archivo correctamente
//Entonces creamos la conexión
log_info(logger, "Conectando a %s:%d ...", ip_kernel, puerto);
errorConexion = crear_conexion_saliente(&unSocket, &socketInfo, ip_kernel, puerto, logger, "PROGRAMA");
if (errorConexion) {
log_error(logger, "Error al conectar con el Kernel.");
goto liberarRecursos;
return EXIT_FAILURE;
}
log_info(logger, "Conexión establecida.");
log_info(logger, "Comenzando a enviar el script AnSISOP.");
errorEnvio = enviarDatos(script, unSocket, logger);
if (errorEnvio) {
goto liberarRecursos;
return EXIT_FAILURE;
} else {
finalizarEnvio(&unSocket);
log_info(logger, "Transmisión finalizada.");
}
//acá se abre la guarda para el modo debug
t_paquete_programa paq;
while(1){
statusRecepcion = recvAll(&paq, unSocket);
if(statusRecepcion == 0){
log_error(logger, "Hubo un error al recibir un mensaje del Kernel.");
} else {
if(ejecutarMensajeKernel(paq.mensaje)){ //Si es 0 era porque era un imprimir/imprimirTexto. Si es 1, hay que terminar.
log_info(logger, "Finalizó la ejecución del programa.");
free(paq.mensaje);
goto liberarRecursos;
break;
}
}
}
//acá se cierra la guarda para el modo debug
} else {
log_error(logger,"No se pudo abrir el script AnSISOP. Motivo: %s", strerror(errno));
goto liberarRecursos;
return EXIT_FAILURE;
}
goto liberarRecursos;
return EXIT_SUCCESS;
liberarRecursos:
if(unSocket != -1)
close(unSocket);
if(script)
fclose(script);
if(logger)
log_destroy(logger);
if(config)
config_destroy(config);
}
int deserializarYejecutar(char** package, int sock, int* tipoProceso,
int* procesoActivo) {
//int *operacion;
int operacion;
int offset = 0;
int respuestaINT;
char algo[1];
int i;
/*algo[0] = *package[0];
operacion = algo[0];*/
char * bufferRespuesta;
memcpy(&algo, (*package + offset), sizeof(uint32_t));
//log_debug(ptrLog, "Ejecutamos la operacion:%d", operacion);
operacion = algo[0];
char* respuestaOperacion = malloc(sizeof(int));
/*memory leak
*
* VERIFICAR
*
* deberia hacer un free de respuesOperacion cada vez que entra en cada case
*
*
* */
//Compruebo que me haya hecho el handshake
//if (*tipoProceso != KERNEL || *tipoProceso != CPU) {
//le asigno -1 para que cuando vaya al case, caiga en el default
//return -1;
//}
switch (operacion) {
case 1:
log_info(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Solicitar Bytes");
log_debug(ptrLog, "Operacion : %u ", *(*package));
log_debug(ptrLog, "Base : %u ", *(*package + sizeof(uint32_t)));
log_debug(ptrLog, "Offset : %u ",
*(*package + sizeof(uint32_t) + sizeof(uint32_t)));
log_debug(ptrLog, "Tamanio: %u ",
*(*package + sizeof(uint32_t) + sizeof(uint32_t)
+ sizeof(uint32_t)));
t_solicitarBytes *estructuraSolicitarBytes = deserializarSolicitarBytes(
package);
log_debug(ptrLog,
"Antes de ejecutar la fn solicitarBytes - Imprimiendo la estructura");
log_debug(ptrLog, "Base : %u ", estructuraSolicitarBytes->base);
log_debug(ptrLog, "Offset : %u ", estructuraSolicitarBytes->offset);
log_debug(ptrLog, "Tamanio : %u ", estructuraSolicitarBytes->tamanio);
if (*tipoProceso == KERNEL || *tipoProceso == CPU) {
//bufferRespuesta=malloc(estructuraSolicitarBytes->tamanio);
bufferRespuesta = solicitarBytes(estructuraSolicitarBytes,
procesoActivo);
if (bufferRespuesta[0] == -1) {
log_error(ptrLog, "SEGFAULT");
enviarDatos(sock, &bufferRespuesta,
estructuraSolicitarBytes->tamanio, 0);
} else {
enviarDatos(sock, &bufferRespuesta,
estructuraSolicitarBytes->tamanio, 0);
log_debug(ptrLog, "Lo que se obtuvo es: ");
for (i = 0; i < estructuraSolicitarBytes->tamanio; ++i)
log_debug(ptrLog, "%x ", bufferRespuesta[i]);
log_info(ptrLog, "SolicitarBytes en server correcto");
}
free(bufferRespuesta);
free(estructuraSolicitarBytes);
free(respuestaOperacion);
return 1;
}
else {
log_error(ptrLog,
"Se quiere ejecutar una operacion donde no hay una CPU o un Kernel");
log_error(ptrLog, "Se envia la respuesta fallida");
bufferRespuesta = malloc(4);
respuestaINT = -1;
memcpy(bufferRespuesta, &respuestaINT, sizeof(int));
enviarDatos(sock, &bufferRespuesta, sizeof(int), 0);
free(estructuraSolicitarBytes);
free(bufferRespuesta);
free(respuestaOperacion);
return 1; //VERIFICAR
}
case 2:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Enviar Bytes");
log_debug(ptrLog, "Operacion: %u", *(*package));
log_debug(ptrLog, "Base: %u", *(*package + sizeof(uint32_t)));
log_debug(ptrLog, "Offset: %u",
*(*package + sizeof(uint32_t) + sizeof(uint32_t)));
log_debug(ptrLog, "Tamanio: %u",
*(*package + sizeof(uint32_t) + sizeof(uint32_t)
+ sizeof(uint32_t)));
log_debug(ptrLog, "%u",
*(*package + sizeof(uint32_t) + sizeof(uint32_t)
+ sizeof(uint32_t) + sizeof(uint32_t)));
t_enviarBytes *estructuraEnviarBytes = deserializarEnviarBytes(package);
log_debug(ptrLog,
"Antes de ejecutar la fn enviarBytes - Imprimiendo la estructura");
log_debug(ptrLog, "Base: %u ", estructuraEnviarBytes->base);
log_debug(ptrLog, "Offset: %u ", estructuraEnviarBytes->offset);
log_debug(ptrLog, "Tamanio: %u ", estructuraEnviarBytes->tamanio);
log_debug(ptrLog, "Se recibio en el buffer lo siguiente:");
for (i = 0; i < estructuraEnviarBytes->tamanio; ++i)
log_debug(ptrLog, "%x ", estructuraEnviarBytes->buffer[i]);
bufferRespuesta = malloc(sizeof(int));
if (*tipoProceso == KERNEL || *tipoProceso == CPU) {
log_info(ptrLog, "Se procede a enviar bytes");
bufferRespuesta = enviarBytes(estructuraEnviarBytes,
*procesoActivo);
if (bufferRespuesta[0] == -1) {
log_error(ptrLog, "SEGFAULT");
enviarDatos(sock, &bufferRespuesta, sizeof(int), 0);
} else {
enviarDatos(sock, &bufferRespuesta, sizeof(int), 0);
log_info(ptrLog, "Se envio bytes");
}
free(bufferRespuesta);
free(estructuraEnviarBytes->buffer);
free(estructuraEnviarBytes);
free(respuestaOperacion);
return 1;
} else {
log_error(ptrLog,
"Se quiere ejecutar una operacion donde no hay una CPU o un Kernel");
log_error(ptrLog, "Se envia la respuesta fallida");
bufferRespuesta = malloc(4);
respuestaINT = -1;
memcpy(bufferRespuesta, &respuestaINT, sizeof(int));
enviarDatos(sock, &bufferRespuesta, sizeof(int), 0);
free(estructuraEnviarBytes);
free(estructuraEnviarBytes->buffer);
free(bufferRespuesta);
free(respuestaOperacion);
return 1; //VERIFICAR
}
case 3:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Handshake");
log_debug(ptrLog, "Tipo de cliente: %u",
*(*package + sizeof(uint32_t)));
//log_debug(ptrLog, "%u",
// *(*package + sizeof(uint32_t) + sizeof(uint32_t)));
handshake(deserializarHandshake(package), tipoProceso);
//Ejecutar funcion Handshake
free(respuestaOperacion);
return 1;
case 4:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Cambio de proceso activo");
log_debug(ptrLog, "PID: %u", **package + sizeof(uint32_t));
if (*tipoProceso == KERNEL || *tipoProceso == CPU) {
log_info(ptrLog, "Se procede a cambiar el PID activo");
cambiarProcesoActivo(deserializarCambiarProcesoActivo(package),
procesoActivo);
free(respuestaOperacion);
return 1;
} else {
log_error(ptrLog,
"Se quiere ejecutar una operacion donde no hay una CPU o un Kernel");
free(respuestaOperacion);
return 1;
}
case 5:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Crear segmento");
log_debug(ptrLog, "PID %u", *(*package + sizeof(uint32_t)));
//log_debug(ptrLog, "%u",
// *(*package + sizeof(uint32_t) + sizeof(uint32_t)));
if (*tipoProceso == KERNEL) {
log_info(ptrLog,
"Se procede a atender la solicitud de crear segmento del kernel");
respuestaINT = crearSegmento((deserializarCrearSegmento(package)));
memcpy(respuestaOperacion, &respuestaINT, sizeof(int));
//Envio tamaño de la respuesta de la funcion
enviarDatos(sock, &respuestaOperacion, sizeof(int), 0);
free(respuestaOperacion);
return 1;
} else {
respuestaINT = -1;
memcpy(respuestaOperacion, &respuestaINT, sizeof(int));
enviarDatos(sock, &respuestaOperacion, sizeof(int), 0);
log_error(ptrLog,
"Se quiere ejecutar una operacion donde no hay una CPU o un Kernel");
free(respuestaOperacion);
return 1;
}
case 6:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_debug(ptrLog, "Destruir segmento");
log_debug(ptrLog, "PID %u", *(*package + sizeof(uint32_t)));
if (*tipoProceso == KERNEL) {
respuestaINT = destruirSegmento(
deserializarDestruirSegmento(package));
memcpy(respuestaOperacion, &respuestaINT, sizeof(int));
enviarDatos(sock, &respuestaOperacion, sizeof(int), 0);
free(respuestaOperacion);
log_info(ptrLog, "Se realizo la destruccion del segmento");
return 1;
} else {
respuestaINT = -1;
memcpy(respuestaOperacion, &respuestaINT, sizeof(int));
enviarDatos(sock, &respuestaOperacion, sizeof(int), 0);
free(respuestaOperacion);
log_error(ptrLog,
"Se quiere ejecutar una operacion donde no hay una CPU o un Kernel");
return 1;
}
default:
log_debug(ptrLog, "En el case (SERVIDOR)");
log_error(ptrLog, "No llego la opción correcta. OPERACION INCORRECTA.");
return -1;
}
}