void deserialize_args(t_stack_entry **entry, void **serialized_data, int *serialized_data_size, int cant_args) {
int indice = 0;
t_arg * aux_arg = NULL;
if(cant_args > 0) {
for(indice = 0; indice < cant_args; indice++ ) {
aux_arg = calloc(1, sizeof(t_arg));
deserialize_data(&aux_arg->page_number, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_arg->offset, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_arg->tamanio, sizeof(int), serialized_data, serialized_data_size);
add_arg(entry, aux_arg);
}
}
}
void deserialize_ret_vars(t_stack_entry **entry, void **serialized_data, int *serialized_data_size, int cant_ret_vars) {
int indice = 0;
t_ret_var * aux_ret_var = NULL;
if(cant_ret_vars > 0) {
for(indice = 0; indice < cant_ret_vars; indice++ ) {
aux_ret_var = calloc(1, sizeof(t_ret_var));
deserialize_data(&aux_ret_var->page_number, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_ret_var->offset, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_ret_var->tamanio, sizeof(int), serialized_data, serialized_data_size);
add_ret_var(entry, aux_ret_var);
}
}
}
t_valor_variable obtenerValorCompartida(t_nombre_compartida variable){
if(status_check() != EXECUTING)
return ERROR;
//5 + 0 + nameSize + name (1+1+4+nameSize bytes)
void* buffer = NULL;
int value = 0, variable_name_length = (int) strlen(variable), buffer_index = 0;
char operation = SHARED_VAR_ID, action = GET_VAR;
// asprintf(&buffer, "%d%d%04d%s", atoi(SHARED_VAR_ID), atoi(GET_VAR), strlen(variable), variable);
serialize_data(&operation, sizeof(char), &buffer, &buffer_index);
serialize_data(&action, sizeof(char), &buffer, &buffer_index);
serialize_data(&variable_name_length, sizeof(int), &buffer, &buffer_index);
serialize_data(variable, (size_t) variable_name_length, &buffer, &buffer_index);
if(send(kernelSocketClient, buffer, (size_t) buffer_index, 0) < 0) {
log_error(cpu_log, "send of obtener variable compartida of %s failed", variable);
free(buffer);
return ERROR;
}
free(buffer);
buffer = calloc(1, sizeof(int));
if(recv(kernelSocketClient, buffer, sizeof(int), 0) <= 0) {
log_error(cpu_log, "recv of obtener variable compartida failed");
return ERROR;
}
int deserialize_index = 0;
deserialize_data(&value, sizeof(int), buffer, &deserialize_index);
log_info(cpu_log, "recv value %d of obtener variable %s", value, variable);
free(buffer);
return value;
}
struct data_t *deserialize_data(json_t *json_data) {
struct data_t *data = (struct data_t *)malloc(sizeof(struct data_t));
if(json_is_integer(json_data)) {
data->type = RPC_INT;
data->value = (json_int_t *)malloc(sizeof(json_int_t));
*(json_int_t *)data->value = json_integer_value(json_data);
} else if(json_is_real(json_data)) {
data->type = RPC_REAL;
data->value = (double *)malloc(sizeof(double));
*(double *)data->value = json_real_value(json_data);
} else if(json_is_string(json_data)) {
data->type = RPC_STRING;
data->value = private_strdup(json_string_value(json_data));
} else if(json_is_array(json_data)) {
data->type = RPC_VECTOR;
data->length = json_array_size(json_data);
data->child = (struct data_t **)malloc(sizeof(struct data_t *)*data->length);
for(int i = 0; i < data->length; i++) {
data->child[i] = deserialize_data(json_array_get(json_data, i));
}
} else {
return NULL;
}
return data;
}
void asignar(t_posicion direccion_variable, t_valor_variable valor) {
if(status_check() != EXECUTING)
return;
t_list * pedidos = NULL;
obtener_lista_operaciones_escritura(&pedidos, direccion_variable, ANSISOP_VAR_SIZE, valor);
char * umc_response_buffer = calloc(1, sizeof(char));
if(umc_response_buffer == NULL) {
log_error(cpu_log, "asignar umc_response_buffer mem alloc failed");
return;
}
int index = 0;
t_nodo_send * nodo = NULL;
int page, offset, size, print_index = 0;
char operation;
while (list_size(pedidos) > 0) {
nodo = list_remove(pedidos, index);
if(nodo != NULL) {
deserialize_data(&operation, sizeof(char), nodo->data, &print_index);
deserialize_data(&page, sizeof(int), nodo->data, &print_index);
deserialize_data(&offset, sizeof(int), nodo->data, &print_index);
deserialize_data(&size, sizeof(int), nodo->data, &print_index);
log_info(cpu_log, "Sending request op:%c (%d,%d,%d) for direccion variable %d with value %d", operation, page, offset, size, direccion_variable, valor);
// log_info(cpu_log, "sending request : %s for direccion variable %d with value %d", nodo->data , direccion_variable, valor);
if( send(umcSocketClient, nodo->data , (size_t ) nodo->data_length, 0) < 0) {
log_error(cpu_log, "UMC expected addr send failed");
break;
}
//EXITO (Se podria loggear de que la operacion fue exitosa)
if(check_umc_response(recv_umc_response_status()) == SUCCESS){
log_info(cpu_log, "Asignar variable operation to UMC with value %d was successful", valor);
} else {
log_error(cpu_log, "Asignar variable operation to UMC with value %d failed", valor);
break;
}
free(nodo);
}
}
list_destroy(pedidos); //Liberamos la estructura de lista reservada
free(umc_response_buffer);
log_info(cpu_log, "Finished asignar variable operations");
}
/*
* Deserializa un t_stack_entry de un conjunto de bytes.
*
* serialized_data format >> pos|cant_args|args|cant_vars|vars|cant_ret_vars|ret_vars
*
* **entry : Donde el stack_entry se almacenara.
* serialized_data : Conjunto de bytes serializados.
* serialized_data_size : Tamanio total del conjunto de bytes.
*/
void deserialize_stack_entry(t_stack_entry **entry, void **serialized_data, int *serialized_data_size) {
int cant_args= 0, cant_vars = 0, cant_ret_vars = 0;
deserialize_data(&(*entry)->pos, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&cant_args, sizeof(int), serialized_data, serialized_data_size);
//deserialize_data((*entry)->args, (size_t) (*entry)->cant_args, serialized_data, serialized_data_size);
deserialize_args(entry, serialized_data, serialized_data_size, cant_args);
deserialize_data(&cant_vars, sizeof(int), serialized_data, serialized_data_size);
//deserialize_data((*entry)->vars, (size_t) (*entry)->cant_vars, serialized_data, serialized_data_size);
deserialize_vars(entry, serialized_data, serialized_data_size, cant_vars);
deserialize_data(&cant_ret_vars, sizeof(int), serialized_data, serialized_data_size);
//deserialize_data((*entry)->ret_vars, (size_t) (*entry)->cant_vars, serialized_data, serialized_data_size);
deserialize_ret_vars(entry, serialized_data, serialized_data_size, cant_ret_vars);
deserialize_data(&(*entry)->ret_pos, sizeof(int), serialized_data, serialized_data_size);
}
char recv_umc_response_status() {
void * umc_response_status_buffer = calloc(1, sizeof(char));
char umc_response_status;
int umc_response_status_buffer_index = 0;
if( recv(umcSocketClient , umc_response_status_buffer, sizeof(char), 0) <= 0) {
log_error(cpu_log, "UMC bytes recv failed");
return ERROR;
}
deserialize_data(&umc_response_status, sizeof(char), umc_response_status_buffer, &umc_response_status_buffer_index);
free(umc_response_status_buffer);
return umc_response_status;
}
/*
* Deserializa un t_stack de un conjunto de bytes.
*
* serialized_data format >> cantidadLinks|[entrySize(0)|entry(0)...entrySize(cantidadLinks-1)|entry(cantidadLinks-1)]
*
* **stack : Donde el stack se almacenara.
* serialized_data : Conjunto de bytes serializados.
* serialized_data_size : Tamanio total del conjunto de bytes.
*/
void deserialize_stack(t_stack **stack, void **serialized_data, int *serialized_data_size) {
u_int32_t cantidad_links = 0, indice = 0;
t_stack_entry *stack_entry = NULL;
*stack = queue_create(); //Creo el stack
deserialize_data(&cantidad_links, sizeof(int), serialized_data, serialized_data_size);
for(indice = 0; indice < cantidad_links; indice++) {
stack_entry = create_new_stack_entry();
deserialize_stack_entry(&stack_entry, serialized_data, serialized_data_size);
queue_push(*stack, (void*) stack_entry); //Agrego elementos al stack
}
}
//deserializes the method which serialized at caller
//returns method name to be called and the params/nparams
//are the arguments to the method call
//returns NULL on error
struct method_t *deserialize_method_call(const char *serialized) {
json_t *root;
json_error_t parse_error;
root = json_loads(serialized, 0, &parse_error);
if(!root || !json_is_object(root)) {
if(root) json_decref(root);
return NULL;
}
json_t *json_method_name = json_object_get(root, METHOD_JSON_KEY);
json_t *json_method_params = json_object_get(root, PARAMS_JSON_KEY);
if(!json_method_name || !json_method_params) {
json_decref(root);
return NULL;
}
char *method_name = NULL;
if(!json_is_string(json_method_name)) {
json_decref(root);
return NULL;
}
method_name = private_strdup(json_string_value(json_method_name));
struct data_t *envelope = deserialize_data(json_method_params);
if(!envelope || envelope->type != RPC_VECTOR) {
free(method_name);
json_decref(root);
return NULL;
}
struct method_t *mtd = (struct method_t *)
malloc(sizeof(struct method_t));
if(!mtd) {
free(method_name);
free_data_t(envelope);
json_decref(root);
return NULL;
}
mtd->name = method_name;
mtd->params = envelope->child;
mtd->nparams = envelope->length;
free(envelope);
json_decref(root);
return mtd;
}
// method result is expected in following format
// {
// "result-type" : "<SUCCESS/ERROR>",
// "result" : <error string or actual result>
// }
// return value or error needs to be freed
struct data_t *deserialize_result(const char *serialized, char **error) {
json_t *root;
json_error_t parse_error;
root = json_loads(serialized, 0, &parse_error);
if(!root || !json_is_object(root)) {
if(root) json_decref(root);
return NULL;
}
json_t *result_type = json_object_get(root, RESULT_TYPE_JSON_KEY);
json_t *result = json_object_get(root, RESULT_JSON_KEY);
if(!result_type || !result) {
json_decref(root);
return NULL;
}
if(!json_is_string(result_type)) {
json_decref(root);
return NULL;
}
if(0 == strcmp("SUCCESS", json_string_value(result_type))) {
struct data_t *data = deserialize_data(result);
json_decref(root);
return data;
} else {
if(!json_is_string(result)) {
json_decref(root);
return NULL;
}
*error = private_strdup(json_string_value(result));
json_decref(root);
}
return NULL;
}
// TODO: Fix segmentation fault after receiving 42 packets...
void receive_packets_handler()
{
udp_pack packet;
char *buffer = (char *)malloc(MTU*sizeof(char));
int len, x, window_packets;
fd_set fds; // fd set declare
struct timeval time_out; // Struct for Timeout value
printf("\n-------- Data Packets transfer begins --------\n");
while(IS_TRANSFER_FIN == 0)
{
// This variable is used to count number of packets received in a window transmit from server.
window_packets = 0;
// Receive complete window.
for(x = 0; ((x < window_size) && (IS_TRANSFER_FIN == 0)); x++)
{
bzero(buffer, MTU);
// Receive Packet
FD_ZERO(&fds); // Clear the fd set
FD_SET(client_sfd, &fds); // Set the client fd for select
time_out.tv_sec = 0;
time_out.tv_usec = timeout;
// Waiting until timeout for next packet
if ( select(32, &fds, NULL, NULL, &time_out) == 0 )
{
printf("Packet receiving timed out. Expected packet with Seq. Number: %d\n", ordered_count + 1);
break;
}
else
{
len = recvfrom(client_sfd, buffer, MTU, 0, (struct sockaddr *) &server_addr, &clen);
if (len < 0)
{
printf("\nError while receiving Packet at current count = %d\n", ordered_count);
report_error("\nERROR: Socket could not be read for ACK\n");
}
packet = deserialize_data(buffer);
//printf("Serialized pack received: %s", buffer);
//printf("Packet received: Seq. Num = %d | Is_Fin = %d | Data = %s", packet.seq_num, packet.is_fin, packet.data);
printf("\nReceived Packet: Seq. Num: %d\n", packet.seq_num);
// Buffer all packets, including out of sequence.
int index = packet.seq_num - 1;
packet_buffer[index] = packet;
window_packets++;
if(check_sequence_fin() == 1) //Check if all packets in sequence until FIN
{
printf("\nAll packets received and placed in order, Transfer finished\n");
IS_TRANSFER_FIN = 1;
}
}
}
//Delay to simulate high latency
if(delays_enabled == 1)
{
// for every 3rd ack add a delay.
if(sequence_num % 3 == 0)
{
printf("\n!!! Adding delay of 1500 micro seconds!!!");
usleep(1500); // Delay of 1000 micro seconds.
}
}
//Update next expected window size, i.e. one more than received packets.
window_size = window_packets + 1;
send_ack(); //Send Cumulative ACK for entire window transferred by sender.
}
printf("\n-------- Data Packets transfer ends --------\n");
printf("\nReceived packet count: %d\n", ordered_count);
}
/*
* Function to establish handshake.
*/
int establish_handshake(char *req_file)
{
int success = 0, n;
udp_pack syn, synack, ack;
fd_set fds; // fd set declare
struct timeval time_out; // Struct for Timeout value
initialize_packet(&syn, 2222, sequence_num, 0);
char *synreq = (char *)malloc(MTU*sizeof(char));
bzero(synreq, MTU);
strcpy(synreq, serialize_packet(syn));
// SYN
//printf("\nSYN to send: %s", synreq);
n = sendto(client_sfd, synreq, strlen(synreq), 0, (struct sockaddr *) &server_addr, clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: writing to socket for SYN");
}
sequence_num++;
printf("\nHANDSHAKE SYN Sent\n");
//gettimeofday(&start_timev,NULL);
printf("\a");
char *buffer = (char *)malloc(MTU*sizeof(char));
bzero(buffer, MTU);
// SYN-ACK
FD_ZERO(&fds); // Clear the fd set
FD_SET(client_sfd, &fds); // Set the client fd for select
time_out.tv_sec = 0;
time_out.tv_usec = timeout;
// Waiting until timeout for SYNACK
if ( select(32, &fds, NULL, NULL, &time_out) == 0 )
{
printf("SYNACK receiving timed out...\n");
}
else
{
bzero(buffer, MTU);
n = recvfrom(client_sfd, buffer, MTU, 0, (struct sockaddr *) &server_addr, &clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: reading from socket for SYNACK");
}
//printf("\nSYNACK response: %s", buffer);
synack = deserialize_data(buffer);
if(synack.is_ack != 1)
{
report_error("HANDSHAKE ERR: SYNACK not received from server during handshake");
}
printf("\nHANDSHAKE SYNACK received\n");
ack = synack;
ack.seq_num = sequence_num;
ack.ack_num = ack.seq_num + 1;
ack.is_ack = 1;
memset(ack.data, 0, DATALEN);
strcpy(ack.data, req_file);
char *ackpack = (char *)malloc(MTU*sizeof(char));
bzero(ackpack, MTU);
strcpy(ackpack, serialize_packet(ack));
//printf("Filename sent : %s", ackpack);
// ACK
//printf("\nACK to send: %s", ackpack);
n = sendto(client_sfd, ackpack, strlen(ackpack), 0, (struct sockaddr *) &server_addr, clen);
if (n < 0)
{
report_error("HANDSHAKE ERR: writing to socket Handshake ACK");
}
printf("\nHANDSHAKE ACK Sent\n");
sequence_num++;
success = 1;
printf("\n-------- Handshake Successful --------\n");
}
return success;
}
int recibir_pcb(int kernelSocketClient, t_kernel_data *kernel_data_buffer) {
void * buffer = calloc(1,sizeof(int));
char * kernel_operation = calloc(1, sizeof(char));
int deserialized_data_index = 0;
if(buffer == NULL) {
log_error(cpu_log, "recibir pcb buffer mem alloc failed");
return ERROR;
}
printf(" .:: Waiting PCB from Kernel ::.\n");
if( recv(kernelSocketClient , kernel_operation , sizeof(char) , 0) <= 0) {
log_error(cpu_log, "KERNEL handshake response receive failed");
return ERROR;
}
if( *kernel_operation != '1') {
log_error(cpu_log, "Wrong KERNEL handshake response received");
return ERROR;
}
free(kernel_operation);
//Quantum data
if( recv(kernelSocketClient , buffer , sizeof(int) , 0) <= 0) {
log_error(cpu_log, "Q recv failed");
return ERROR;
}
deserialize_data(&kernel_data_buffer->Q , sizeof(int), buffer, &deserialized_data_index);
printf(ANSI_COLOR_BLUE);
log_info(cpu_log, "Q: %d", kernel_data_buffer->Q);
printf(ANSI_COLOR_RESET);
if( recv(kernelSocketClient , buffer , sizeof(int) , 0) <= 0) {
log_error(cpu_log, "QSleep recv failed");
return ERROR;
}
deserialized_data_index = 0;
deserialize_data(&kernel_data_buffer->QSleep , sizeof(int), buffer, &deserialized_data_index);
printf(ANSI_COLOR_BLUE);
log_info(cpu_log, "QSleep: %d", kernel_data_buffer->QSleep);
printf(ANSI_COLOR_RESET);
if( recv(kernelSocketClient ,buffer , sizeof(int) , 0) <= 0) {
log_error(cpu_log, "pcb_size recv failed");
return ERROR;
}
deserialized_data_index = 0;
deserialize_data(&kernel_data_buffer->pcb_size , sizeof(int), buffer, &deserialized_data_index);
log_info(cpu_log, "pcb_size: %d", kernel_data_buffer->pcb_size);
free(buffer);
kernel_data_buffer->serialized_pcb = calloc(1, (size_t ) kernel_data_buffer->pcb_size);
if(kernel_data_buffer->serialized_pcb == NULL) {
log_error(cpu_log, "serialized_pcb mem alloc failed");
return ERROR;
}
if( recv(kernelSocketClient , kernel_data_buffer->serialized_pcb , (size_t ) kernel_data_buffer->pcb_size , 0) <= 0) {
log_error(cpu_log, "serialized_pcb recv failed");
return ERROR;
}
return SUCCESS;
}
void catalog_object::deserialize(xptr p)
{
cs_stream stream((p == XNULL) ? (p = p_object) : (p_object = p), cs_stream::mode_read);
stream.seek(4);
deserialize_data(stream);
}
t_posicion definirVariable(t_nombre_variable variable) {
if(status_check() != EXECUTING)
return ERROR;
//1) Obtener el stack index actual
t_stack* actual_stack_index = actual_pcb->stack_index;
//2) Obtengo la primera posicion libre del stack
t_posicion actual_stack_pointer = (t_posicion) actual_pcb->stack_pointer;
//3) Armamos la logical address requerida
logical_addr* direccion_espectante = armar_direccion_logica_variable(actual_stack_pointer, setup->PAGE_SIZE);
int valor = 0;
t_list * pedidos = NULL;
//TODO: CAMBIAR ESTO PARA QUE LA LISTA DE PEDIDOS SEA DE NUMEROS, NO DE SPRINTF
obtener_lista_operaciones_escritura(&pedidos, actual_stack_pointer, ANSISOP_VAR_SIZE, valor);
int index = 0;
t_nodo_send * nodo = NULL;
char * umc_response_buffer = calloc(1, sizeof(char));
if(umc_response_buffer == NULL) {
log_error(cpu_log, "definirVariable umc_response_buffer mem alloc failed");
return ERROR;
}
char operation;
int page, offset, size, print_index = 0;
while (list_size(pedidos) > 0) {
nodo = list_remove(pedidos, index);
deserialize_data(&operation, sizeof(char), nodo->data, &print_index);
deserialize_data(&page, sizeof(int), nodo->data, &print_index);
deserialize_data(&offset, sizeof(int), nodo->data, &print_index);
deserialize_data(&size, sizeof(int), nodo->data, &print_index);
log_info(cpu_log, "Sending request op:%c (%d,%d,%d) to define variable '%c' with value %d", operation, page, offset, size, variable, valor);
if( send(umcSocketClient, nodo->data , (size_t ) nodo->data_length, 0) < 0) {
log_error(cpu_log, "UMC expected addr send failed");
return ERROR;
}
if(check_umc_response(recv_umc_response_status()) != SUCCESS) {
return ERROR;
}
}
list_destroy(pedidos); //Liberamos la estructura de lista reservada
free(umc_response_buffer);
//5) Si esta bien, agregamos la nueva t_var al stack
t_var * nueva_variable = calloc(1, sizeof(t_var));
nueva_variable->var_id = variable;
nueva_variable->page_number = direccion_espectante->page_number;
nueva_variable->offset = direccion_espectante->offset;
nueva_variable->tamanio = direccion_espectante->tamanio;
//6) Actualizo el stack pointer
actual_pcb->stack_pointer += nueva_variable->tamanio;
free(direccion_espectante);
t_stack_entry *last_entry = get_last_entry(actual_stack_index);
add_var( &last_entry, nueva_variable);
//7) y retornamos la t_posicion asociada
t_posicion posicion_nueva_variable = get_t_posicion(nueva_variable);
return posicion_nueva_variable;
}