static void test_string_substring_until_end() {
char *original = "hola mundo!";
char *substring = string_substring_until(original, strlen(original));
CU_ASSERT_STRING_EQUAL(substring, original);
CU_ASSERT_PTR_NOT_EQUAL(substring, original);
free(substring);
}
static void test_string_substring_until_middle() {
char *original = "hola mundo!";
char *substring = string_substring_until(original, 5);
CU_ASSERT_STRING_EQUAL(substring, "hola ");
CU_ASSERT_PTR_NOT_EQUAL(substring, original);
free(substring);
}
char* obtenerDatoLimpioDelDiccionario(t_dictionary* diccionario, char* dato) {
char* datoProvisorio;
char* datoLimpio;
datoProvisorio = dictionary_get(diccionario, dato);
datoLimpio = string_substring_until(datoProvisorio,(string_length(datoProvisorio) - 1));
return datoLimpio;
}
char* depurarSentencia(char* sentencia){
int i = strlen(sentencia);
while (string_ends_with(sentencia, "\n")) {
i--;
sentencia = string_substring_until(sentencia, i);
}
return sentencia;
}
char* recuperarBloque(char* bloqueAVaciar){
char* bloque = string_new();
int i;
for (i = 0; i < string_length(bloqueAVaciar); ++i) {
if (bloqueAVaciar[i] == CARACTER_VACIO)
break;
}
bloque = string_substring_until(bloqueAVaciar,i);
return bloque;
}
t_puntero obtenerPosicionVariable(t_nombre_variable identificador_variable){
/*Se fija en el diccionario de variables la posicion la posicion va a ser el data del elemento*/
identificador_variable = es_numero_pasar_char(identificador_variable);
char *key = string_substring_until(&identificador_variable, 1);
int32_t *dir_mem = dictionary_get(dic_Variables,key);
int32_t ret = *dir_mem;
if (dir_mem == NULL)
printf(" ERROR no se ha podido encontrar la key:%s\n",key);
txt_write_in_file(cpu_file_log, "La posicion de la variable\n");
txt_write_in_file(cpu_file_log, "es\n");
printf(" La posicion de la variable: %s, es %i\n", key, ret);
free(key);
return ret;
}
void list(char* line,t_list* lista)
{
int credito;
t_persona* persona = persona = malloc(sizeof(t_persona));
char** array;
array = string_split(line,";");
strcpy(persona->region,array[0]);
strcpy(persona->NomAp, array[1]);
sscanf(array[2],"%d",&(persona->edad));
sscanf(array[3],"%d",&(persona->Tel));
sscanf(array[4],"%d",&(persona->DNI));
sscanf(array[5],"%d",&credito);
if (credito < 100)
{
log_info(logFile,string_substring_until(line,(strlen(line)-1)));
}
free(array);
list_add(lista,persona);
}
//Primitivas ANSISOP
t_puntero definirVariable(t_nombre_variable id_var){
int32_t base, offset, tam;
base = pcb->dir_seg_stack;
offset= pcb->dir_cont_actual - base + (pcb->cant_var_cont_actual*5);
tam = 5;
int32_t pos_mem = base + offset;
printf(" Definir la variable %c en la posicion %i, offset:%i\n",id_var, pos_mem,offset);
id_var = es_numero_pasar_char(id_var);
id_var = es_numero_pasar_char(id_var);
char *key = string_substring_until(&id_var, 1);
enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, key);
t_men_comun *r_alm = socket_recv_comun(socketUmv);
if(r_alm->tipo == R_ALM_BYTES){
int32_t *pos = malloc(sizeof(int32_t));
*pos = pos_mem;
dictionary_put(dic_Variables, key, pos);
free(key);
(pcb->cant_var_cont_actual) ++;
txt_write_in_file(cpu_file_log, "Definiar la variable \n");
txt_write_in_file(cpu_file_log, "en la posicion \n");
destruir_men_comun(r_alm);
return pos_mem;
}else{
finalizarContexto(SEGMEN_FAULT);
destruir_men_comun(r_alm);
free(key);
return -1;
}
}
int conectarAFilesystemYSubirArchivo(char *nombreArchivo, char *pathArchivoEnMDFS)
{
ConfiguracionNodo *config = obtenerConfiguracionNodo();
SocketConecta *conexion = newSocketConecta(config->ip_fs, config->puerto_fs);
conectarAServidor(conexion);
if (! estaConectado(conexion))
return SUBIDA_FALLO;
char pedidoSubidaArchivo = MENSAJE_PEDIDO_SUBIDA_ARCHIVO;
enviarMensaje(conexion, &pedidoSubidaArchivo, 1);
int contador = strlen(pathArchivoEnMDFS);
while(pathArchivoEnMDFS[contador] != '/')
contador--;
char *pathDirectorio;
if (contador == 0)
pathDirectorio = "/";
else
pathDirectorio = string_substring_until(pathArchivoEnMDFS, contador);
char *nombre = string_substring_from(pathArchivoEnMDFS, contador + 1);
int longitudMensaje = strlen(pathDirectorio);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, pathDirectorio, longitudMensaje);
longitudMensaje = strlen(nombre);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, nombre, longitudMensaje);
char *pathEspacioTemporal = obtenerPathEspacioTemporal();
char *rutaArchivo = malloc(strlen(pathEspacioTemporal) + strlen(nombreArchivo) + 2);
strcpy(rutaArchivo, pathEspacioTemporal);
strcat(rutaArchivo, "/");
strcat(rutaArchivo, nombreArchivo);
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subiendo archivo %s al MDFS en %s", rutaArchivo, pathArchivoEnMDFS);
FILE *contenidoArchivo = fopen(rutaArchivo, "r");
char buffer[SIZE_BLOQUE_DE_ENVIO + 1];
size_t bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
while(bytesLeidos > 0)
{
enviarTodo(conexion, buffer, bytesLeidos);
bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
char siguiente;
recibirMensaje(conexion, &siguiente, 1);
}
int cero = 0;
enviarMensaje(conexion, &cero, sizeof(int));
char resultadoSubida;
recibirMensaje(conexion, &resultadoSubida, 1);
if (resultadoSubida == MENSAJE_SUBIDA_OK)
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s finalizada", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_OK;
}
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s fallida", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_FALLO;
}
void mensajesConPlataforma(int32_t socketEscucha) {//ATIENDE LA RECEPCION Y POSTERIOR RESPUESTA DE MENSAJES DEL ORQUESTADOR
enum tipo_paquete unMensaje = PER_conexionNivel_ORQ;
char* elMensaje=NULL;
pthread_mutex_lock(&mutex_log);
log_info(logger,"Voy a esperar recibir un mensaje de %d", socketEscucha);
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes); //(matyx)
recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
pthread_mutex_unlock(&mutex_mensajes);
sleep(1);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Llego el tipo de paquete: %s .",obtenerNombreEnum(unMensaje));
log_info(logger, "Llego este mensaje: %s .",elMensaje);
pthread_mutex_unlock(&mutex_log);
switch (unMensaje) {
case PLA_movimiento_NIV: {//graficar y actualizar la lista RECIBE "@,1,3"
char ** mens = string_split(elMensaje,",");
char idPers = mens[0][0];
if(huboCambios==true){
pthread_mutex_lock(&mutex_log);
log_info(logger,"envio los cambios de configuracion");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketDeEscucha, NIV_cambiosConfiguracion_PLA,buffer1);
pthread_mutex_unlock(&mutex_mensajes);
huboCambios=false;
pthread_mutex_lock(&mutex_log);
log_info(logger,"me preparo para recibir el ok");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
pthread_mutex_unlock(&mutex_mensajes);
pthread_mutex_lock(&mutex_log);
log_info(logger,"deberia haber recibido el OK1");
pthread_mutex_unlock(&mutex_log);
if(unMensaje==OK1){
pthread_mutex_lock(&mutex_log);
log_info(logger,"ya envie el cambio de configuracion, y me dieron el ok");
pthread_mutex_unlock(&mutex_log);
if(existePersonajeEnListaItems(idPers)){
pthread_mutex_lock(&mutex_listas);
MoverPersonaje(items, idPers,atoi(mens[1]), atoi(mens[2]));
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
pthread_mutex_unlock(&mutex_mensajes);
} else {
pthread_mutex_lock(&mutex_log);
log_info(logger,"no recibi OK1,recibi cualquiera");
pthread_mutex_unlock(&mutex_log);
}
} else {
if(existePersonajeEnListaItems(idPers)){
pthread_mutex_lock(&mutex_listas);
MoverPersonaje(items, elMensaje[0],atoi(mens[1]), atoi(mens[2]));
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
pthread_mutex_lock(&mutex_log);
log_info(logger, "Confirmo que el personaje %s puede moverse",mens[0]);
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
pthread_mutex_unlock(&mutex_mensajes);
}
break;
}
case PLA_personajeMuerto_NIV:{ //RECIBE "@" MUERTE POR ENEMIGOS
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales); // tambien suma sus recursos a disponible
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto ",id);
pthread_mutex_unlock(&mutex_log);
break;
}
case PLA_nuevoPersonaje_NIV:{ //RECIBE "@" LA POSICION DE INICIO SERA SIEMPRE 0,0 POR LO QUE NO LA RECIBE
char * simbolo = malloc(strlen(elMensaje)+1);
strcpy(simbolo,elMensaje);
pthread_mutex_lock(&mutex_listas);
CrearPersonaje(items,elMensaje[0],0,0);
pthread_mutex_unlock(&mutex_listas);
//ACA CREO UNA LISTA DE PERSONAJES CON SUS RESPECTIVOS RECURSOS ASIGNADOS
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje->simbolo = string_substring_until(elMensaje,1);
personaje->recursosActuales = list_create();
personaje->recursoBloqueante = string_new();
personaje->posicion = posicion_create_pos(0,0);
personaje->ingresoSistema = ingresoAlSistema;
ingresoAlSistema++;
pthread_mutex_lock(&mutex_listas);
list_add(listaPersonajesRecursos,personaje);
pthread_mutex_unlock(&mutex_listas);
if(graficar)
nivel_gui_dibujar(items,nombre);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El nuevo personaje %c se dibujo en el mapa",elMensaje[0]);
pthread_mutex_unlock(&mutex_log);
break;
}
case PLA_posCaja_NIV:{ // RECIBE "F" SI ESTA SOLICITANDO UNA FLOR, POR EJEMPLO
char * pos = string_new();
ITEM_NIVEL * caja = buscarRecursoEnLista(items, elMensaje);
string_append(&pos, string_from_format("%d",caja->posx));
string_append(&pos, ",");
string_append(&pos, string_from_format("%d",caja->posy));
pthread_mutex_lock(&mutex_log);
log_info(logger,"enviare la posicion de la caja");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha, NIV_posCaja_PLA,pos); //"X,Y"
pthread_mutex_unlock(&mutex_mensajes);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Envio posicion del recurso %s coordenadas %s ",elMensaje,pos);
pthread_mutex_unlock(&mutex_log);
free(pos);
break;
}
case PLA_solicitudRecurso_NIV:{ // LE CONTESTO SI EL RECURSOS ESTA DISPONIBLE
// El mensaje de ejemplo es : "@,H"
char * rta;
bool hayRecurso = determinarRecursoDisponible (string_substring_from(elMensaje, 2)); //SI ESTA EL RECURSO TMB LO RESTA
t_personaje_niv1 * pers = buscarPersonajeListaPersonajes(listaPersonajesRecursos, string_substring_until(elMensaje,1));
if (hayRecurso){
rta = "0";
pthread_mutex_lock(&mutex_listas);
list_add(pers->recursosActuales, string_substring_from(elMensaje, 2));
pers->recursoBloqueante = string_new();
pthread_mutex_unlock(&mutex_listas);
}else{
pthread_mutex_lock(&mutex_listas);
pers->recursoBloqueante = string_substring_from(elMensaje, 2);
rta = "1";
pthread_mutex_unlock(&mutex_listas);
}
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha, NIV_recursoConcedido_PLA,rta);//"0" CONCEDIDO, "1" NO CONCEDIDO
pthread_mutex_unlock(&mutex_mensajes);
break;
}
case PLA_personajesDesbloqueados_NIV:{//"5,@,#,....." recorro lista personaje recursos y actualizo recBloqueante a vacio
char ** mens = string_split(elMensaje,",");
int i;
int cantPersonajes=atoi(mens[0]);
for(i=1;i<=cantPersonajes;i++){
char * unPersDesbloqueado=mens[i];
t_personaje_niv1 * unPers=buscarPersonajeListaPersonajes(listaPersonajesRecursos,unPersDesbloqueado);
pthread_mutex_lock(&mutex_listas);
unPers->recursoBloqueante=string_new();
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Personajes %s desbloqueados",mens[i]);
pthread_mutex_unlock(&mutex_log);
}
break;
}
case PLA_actualizarRecursos_NIV:{ //"3;F,1;C,3;....." actualizo la lista de recursos sumandole esas cantidades
char ** mens = string_split(elMensaje,";");
int cantRecursos= atoi(mens[0]);
int i;
pthread_mutex_lock(&mutex_log);
log_info(logger, "Recursos desbloqueados: %s",elMensaje);
pthread_mutex_unlock(&mutex_log);
for(i=1;i<=cantRecursos;i++){
char** mensajeIndividual= string_split(mens[i],",");
pthread_mutex_lock(&mutex_listas);
int cantidad=atoi(mensajeIndividual[1]);
sumarRecurso(items, mensajeIndividual[0][0],cantidad);
pthread_mutex_unlock(&mutex_listas);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
break;
}
case PLA_nivelFinalizado_NIV:{ //recibe personaje que termino el nivel ej: "@"
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items,id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha terminado el nivel ",id);
pthread_mutex_unlock(&mutex_log);
if(graficar){
nivel_gui_dibujar(items,nombre);
}
break;
}
case PLA_perMuereInterbloqueo_NIV:{
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items,id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto por interbloqueo ",id);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
break;
}
case PLA_perMuereNaturalmente_NIV: {
char id = elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje, 1));
pthread_mutex_lock(&mutex_listas);
liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items, id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos, elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto por causas externas", id);
pthread_mutex_unlock(&mutex_log);
if (graficar)
nivel_gui_dibujar(items, nombre);
break;
}
{
default:
pthread_mutex_lock(&mutex_log);
log_info(logger, "Recibi mensaje inexistente, la ejecucion del nivel finalizara");
pthread_mutex_unlock(&mutex_log);
eliminarEstructuras();
break;
}
free(elMensaje);
}
}
//Recibe y procesa un mensaje recibido
void receiptMessage(void * arguments)
{
args_receiptMessage * args = arguments;
int numbytes; /* bytes recibidos por cada lectura (0 = desconexion del cliente) */
char buffer[MAXDATASIZE]; /* buffer de lectura */
bool bufferUsed; /* determina si se analizo por lo menos una vez un nuevo set de datos */
unsigned int n = -1; /* cantidad de argumentos del packete que recibo */
int i = 0; /* ayuda a saber la ultima posicion de lectura en el buffer (tambien se usa como i en otros casos) */
int j = 0; /* j de for */
int seps = 0; /* cantidad de separadores ,(coma) contados en el encabezado del paquete */
char * packet_head; /* encabezado del paquete */
char * packet_body; /* cuerpo del paquete */
char * exceeded; /* datos excedidos del final del paquete */
char * str_tmp; /* temporar para operaciones de string */
bool isExceeded = false; /* determina si hay datos excedidos cargados en el buffer */
bool fullHead = false; /* determina si ya fue recibido el encabezado del paquete */
int bytesBody = 0; /* determina los bytes que contendrá el cuerpo del paquete */
char ** head = NULL; /* encabezado divido por n, name y bytes de los args */
char * b; /* utilizado para extraer bytes del buffer */
void (*fn)(); /* utilizado para guardar la funcion que hay que ejecutar del cliente */
char ** packet_args; /* Argumentos que se envian por la funcion */
//loopeo
while(1)
{
//si en la ultima lectura dejo informacion excedida la guardo
if(isExceeded)
exceeded = string_duplicate(buffer);
//Pongo en blanco el buffer
buffer[0] = '\0';
//Espero a recibir un mensaje del job, si se produce un error lo informo error y finalizo hilo
if ((numbytes=recv(args->connection->socket, buffer, MAXDATASIZE-1, 0)) == -1)
{
//perror("recv");
break;
}
//si en la ultima lectura dejo informacion excedida la agrego al inicio del buffer
if(isExceeded)
{
exceeded = string_new();
string_append(&exceeded, buffer);
buffer[sizeof(exceeded)] = '\0'; //mejor que memset?
strcpy(buffer, exceeded);
free(exceeded);
}
//finalizo el hilo
if(numbytes == 0)
break;
else
{
//Corta el bufer hasta donde recibe informacion
buffer[numbytes] = '\0';
//analizo el buffer si es la primera vez que lo voy a analizar o si queda informacion excedida para seguir analizando
//(Analizar significa, buscar paquetes completos y ejecutarlos)
bufferUsed = false;
while(!bufferUsed || isExceeded)
{
bufferUsed = true;
isExceeded = false;
i = 0;
//si comienzo a leer un nuevo paquete inicializo el head y el body
if(n == -1)
{
packet_head = string_new();
packet_body = string_new();
}
//recorro buffer hasta armar cabezal si no esta armado
if(!fullHead)
{
for(i = 0; i < strlen(buffer); i++)
{
b = buffer[i];
//primer caracter es [n] (cantidad de args)
if(n == -1)
n = atoi(&b);
//cuento comas
else if(b == ',')
seps++;
//voy completando cabezal
string_append(&packet_head, &b);
//fianlizo cuando llego al ultimo separador
if(n+2 == seps)
{
fullHead = true;
i++; //dejo posicion en el primer byte del cuerpo del paquete
break;
}
}
}
//cabezal completo
if(fullHead)
{
//si el cabezal no fue explodiado, le doy explode y calculo los bytes del cabezal
if(head == NULL)
{
//hago explode
head = string_n_split(packet_head, n+2, ",");
for(j = 2; j < n+2; j++)
bytesBody += atoi(head[j]);
}
//Agrego al cuerpo del packete todos los datos
str_tmp = string_substring_from(buffer, i);
string_append(&packet_body, str_tmp);
free(str_tmp);
//paquete completo
if(bytesBody <= strlen(packet_body))
{
//si el paquete esta excedido, corto el paquete en la posicion correspondiente y guardo el excedente sobre el buffer
if(bytesBody < strlen(packet_body))
{
isExceeded = true;
exceeded = string_substring_from(packet_body, bytesBody);
str_tmp = string_substring_until(packet_body, bytesBody);
free(packet_body);
packet_body = str_tmp;
buffer[0] = '\0';
strcpy(buffer, exceeded);
free(exceeded);
}
//llamo a la funcion que maneja los mensajes recibidos
if(args->fns_receipts != NULL)
{
i = 0;
//armo argumentos en array
packet_args = malloc(sizeof(char*)*n);
for(j = 2; j < n+2; j++)
{
char * part = string_substring(packet_body, i, atoi(head[j]));
packet_args[j-2] = part;
i += atoi(head[j]);
}
//Si n=0 el split no toma el vacio despues de la coma final.. quito ultima coma
if(n==0)
head[1][strlen(head[1])-1] = '\0';
//Ejecuto la función solicitada, si no existe la función muestro error
fn = dictionary_get(args->fns_receipts, head[1]);
if(fn != NULL)
fn(args->connection, packet_args);
else
printf("Cliente SOCK%d(%s:%d) intento ejecutar la función inexistente '%s'.\n", args->connection->socket, args->connection->ip, args->connection->port, head[1]);
//libero argumentos
for(i = 0; i < n; i++)
free(packet_args[i]);
free(packet_args);
}
free(packet_head);
free(packet_body);
for(i = 0; i < n+3; i++)
free(head[i]);
free(head);
n = -1;
seps = 0;
fullHead = false;
bytesBody = 0;
head = NULL;
}
}
}
}
}
//cierro socket
close(args->connection->socket);
//Informo a la funcion que maneja los cierres (si existe y la estructura de conexion lo permite)
if(args->connection->run_fn_connectionClosed && args->fn_connectionClosed != NULL)
args->fn_connectionClosed(args->connection);
//libero memoria
if(isExceeded)
free(exceeded);
if(n != -1)
{
free(packet_head);
free(packet_body);
}
free(args);
}
