Ejemplo n.º 1
0
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);

    }

}
Ejemplo n.º 2
0
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()));
}
Ejemplo n.º 3
0
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");
	}
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
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;
	}

}