pack_and_data_t * process_client_balance(pack_and_data_t *pin) { packet_head_t *cb_bal = pin->ph; uint32_t cid = cb_bal->card_id; uint32_t acd = cb_bal->auth_code; uint32_t txn_id = cb_bal->transaction_id; acct_txn_entry_t * aet = get_acct_txn_reg(cid, acd, txn_id); if(aet == NULL) { return NULL; } pack_and_data_t *pad = create_basic_response(cid, acd, txn_id, OPS, BALANCE, OK, sizeof(packet_data_balance_t)); packet_head_t * ph = pad->ph; packet_data_balance_t *inline_bal = get_payload(ph); if(inline_bal == NULL) { ERRNO = ERRNO_MP_UNK; return NULL; } inline_bal->balance = aet->ae->balance; txn_entry_t * te = add_transaction_log_entry(aet->ae, pad); free(aet); return pad; }
pack_and_data_t * generate_error(packet_head_t *ph) { uint32_t cid = ph->card_id; uint32_t acd = ph->auth_code; uint32_t txn_id = ph->transaction_id; if(ERRNO == ERRNO_MP_ALLOC) { _terminate(1); } size_t m_sz = cgc_strlen(ERROR_MSGS[ERRNO]); size_t pay_sz = sizeof(packet_data_error_t) + m_sz - sizeof(char *) ; pack_and_data_t *pad = create_basic_response(cid, acd, txn_id, ph->pkt_type, ph->op_code, ERRNO, pay_sz); packet_head_t * resp = pad->ph; packet_data_error_t * e = (packet_data_error_t *) get_payload(resp); e->length = m_sz; cgc_memcpy(&(e->msg), ERROR_MSGS[ERRNO], m_sz); return pad; }
int main(int argc, char **argv) { int ret = EXIT_FAILURE; char *payload = NULL; if (!parse_options(argc, argv)) { goto fail; } if (version_p) { g_print(PACKAGE_VERSION "\n"); goto success; } if (!validate_opts()) { goto fail; } if (!get_payload(&payload)) { goto fail; } if (!send_record(payload)) { goto fail; } success: ret = EXIT_SUCCESS; fail: free_glib_strings(); return ret; }
void do_server(char **source_addr, char **recv_payload) { struct sockaddr_in si_me, si_other; int s, b, size; socklen_t slen=sizeof(si_other); char buffer[BUFLEN]; while(1) { s = socket(AF_INET, SOCK_RAW, IPPROTO_UDP); if (s<0) fatal("socket"); memset((char *) &si_me, 0, sizeof(si_me)); si_me.sin_family = AF_INET; si_me.sin_port = htons(APPPORT); si_me.sin_addr.s_addr = htonl(INADDR_ANY); b = bind(s, (struct sockaddr *) &si_me, sizeof(si_me)); if (b < 0) fatal("bind"); size = recvfrom(s, buffer, BUFLEN, 0, (struct sockaddr *) &si_other, &slen); if (size < 0) fatal("recvfrom()"); if (verify_port(buffer)){ print_ip_header(buffer); *source_addr = get_source_addr(buffer); *recv_payload = get_payload(buffer); break; } close(s); } }
static void process_pkts(struct rte_mbuf *buf[], int n) { int i; uint8_t *pkt; int ret; uint32_t ft[5]; unsigned char *payload; int len; for(i = 0; i < n; i++) { #ifdef EXEC_MBUF_PA_CNT uint32_t lcoreid = rte_lcore_id(); uint32_t *count; struct rte_hash *h = lcore_args[lcoreid].pa_ht; if(rte_hash_lookup_data(h, (const void *)&(buf[i]->buf_physaddr), (void**)&count) >= 0) { *count = *count + 1; } else { if(pacnt_hash_add(h, (const void *)&(buf[i]->buf_physaddr), 1) < 0) { rte_exit(EINVAL, "pacnt hash add failed in lcore %d\n", lcoreid); } } #endif #if defined(EXEC_PC) || defined(EXEC_HASH) parse_packet_to_tuple(buf[i], ft); #ifdef EXEC_PC ret = packet_classifier_search(ft); if(ret < 0) { fprintf(stderr, "packet classifing failed!\n"); } #else ret = hash_table_lkup((void*)ft); #endif #endif #ifdef EXEC_CRC calc_chk_sum(buf[i]); #endif #ifdef EXEC_DPI ret = get_payload(buf[i], &payload, &len); if(ret < 0) { fprintf(stderr, "packet get payload failed!\n"); continue; } ret = dpi_engine_exec(payload, len); #endif } }
unsigned char * get_payload_proxy(size_t * len) { mute(); unsigned char * ret = get_payload(len); unmute(); // CR: use getenv stack_ptr("get_payload"); StoreBuf(&ret); readenv(ret, len, "payload"); return ret; }
void udp_server_function(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port){ struct pbuf pnew; int k1; int k; int i; int packet_type; int packet_internal_ID; int packet_internal_ID_offset; int timer=0; float tmp_float; xcore.Bus_a_BaseAddress = 0x43c00000; xcore.IsReady = XIL_COMPONENT_IS_READY; // Only respond when the packet is the correct length if (p->len == (ETH_PACKET_LENGTH)*sizeof(int32_t)){ /* Pick up a pointer to the payload */ payload_ptr = (unsigned char *)p->payload; //Free the packet buffer pbuf_free(p); // Get the payload out for(k1=0;k1<ETH_PACKET_LENGTH;k1++){ get_payload(); inputvec[k1] = payload_temp; } if (FLOAT_FIX==1){//fixed point //extract informations form the input packet packet_type=inputvec[ETH_PACKET_LENGTH-2] & 0x0000FFFF; packet_internal_ID=(inputvec[ETH_PACKET_LENGTH-2] & 0xFFFF0000) >> 16; //if write packet_type, packet_num is the data vector ID packet_internal_ID_offset=inputvec[ETH_PACKET_LENGTH-1]; //if write packet_type, packet_num is the data vector ID }
void bc_dump(FILE *fptr, byte *pc) { intptr_t begin = (intptr_t) pc; while (true) { fprintf(fptr, "%d: ", (int) ((intptr_t) pc - begin)); int bc = get_bytecode(pc); switch (bc) { case BC_INVALID: fprintf(fptr, "invalid"); break; case BC_SHIFT: fprintf(fptr, "shift [delta = %d]", get_payload(pc, 0)); break; case BC_ADD: fprintf(fptr, "add [value = %d]", get_payload(pc, 0)); break; case BC_MOVE_VALUE: fprintf(fptr, "move_value [value = %d]", get_payload(pc, 0)); break; case BC_ZERO: fprintf(fptr, "zero"); break; case BC_OUTPUT: fprintf(fptr, "output"); break; case BC_INPUT: fprintf(fptr, "input"); break; case BC_LOOP_BEGIN: fprintf(fptr, "loop-begin [counter-idx = %d] [length = %d]", get_payload(pc, 0), get_payload(pc, 1)); break; case BC_LOOP_END: fprintf(fptr, "loop-end [length = %d]", get_payload(pc, 0)); break; case BC_COMPILED_LOOP: fprintf(fptr, "compiled-loop"); break; case BC_HLT: fprintf(fptr, "hlt"); goto end; } fprintf(fptr, "\n"); pc += get_total_length(bc); } end: fprintf(fptr, "\n"); }
static void send_connect(uint64_t state_key, connection_status_t *c, void *pri_work, const ip_report_t *r) { union { void *ptr; send_pri_workunit_t *w; uint8_t *inc; } w_u; union { uint64_t state_key; struct { uint32_t dhost; uint16_t sport; uint16_t dport; } s; } k_u; uint32_t pay_size=0; uint8_t *pay_ptr=NULL; int (*create_payload)(uint8_t **, uint32_t *, void *)=NULL; int32_t na=0; int dyn=0; k_u.state_key=state_key; c->tseq++; if (get_payload(0, IPPROTO_TCP, k_u.s.sport, &pay_ptr, &pay_size, &na, &create_payload, s->payload_group) == 1) { int err=0; /* payload trigger */ DBG(M_CON, "pay size %u ptr %p conv %d create_payload %p", pay_size, pay_ptr, na, create_payload); if ((pay_size < 1 && pay_ptr == NULL) && create_payload == NULL) { ERR("pay size %u pay_ptr %p and create payload %p", pay_size, pay_ptr, create_payload); err++; } if (create_payload != NULL) { DBG(M_CON, "running create tcp payload at %p", create_payload); /* XXX */ if (create_payload(&pay_ptr, &pay_size, (void *)r) < 0) { ERR("create payload for port %u fails", k_u.s.sport); err++; } dyn++; } if (pay_size > 1460) { ERR("payload too big"); err++; } if (err == 0 && pay_size) { /* XXX if the payload is small use the 3-way handshake to send data */ w_u.ptr=xmalloc(sizeof(send_pri_workunit_t) + pay_size); w_u.w->magic=PRI_4SEND_MAGIC; w_u.w->dhost=k_u.s.dhost; w_u.w->dport=k_u.s.sport; w_u.w->sport=k_u.s.dport; w_u.w->shost=c->send_ip; w_u.w->tseq=c->tseq; w_u.w->mseq=c->mseq; w_u.w->window_size=c->window; w_u.w->flags=TH_ACK; w_u.w->doff=0; w_u.w->t_tstamp=c->t_tstamp; w_u.w->m_tstamp=c->m_tstamp; memcpy(w_u.inc + sizeof(send_pri_workunit_t), pay_ptr, pay_size); s->stats.stream_segments_sent++; fifo_push(pri_work, w_u.ptr); w_u.ptr=xmalloc(sizeof(send_pri_workunit_t) + pay_size); w_u.w->magic=PRI_4SEND_MAGIC; w_u.w->dhost=k_u.s.dhost; w_u.w->dport=k_u.s.sport; w_u.w->sport=k_u.s.dport; w_u.w->shost=c->send_ip; w_u.w->tseq=c->tseq; w_u.w->mseq=c->mseq; w_u.w->window_size=c->window; w_u.w->flags=TH_ACK|TH_PSH; w_u.w->doff=pay_size; w_u.w->t_tstamp=c->t_tstamp; w_u.w->m_tstamp=c->m_tstamp; memcpy(w_u.inc + sizeof(send_pri_workunit_t), pay_ptr, pay_size); /* PSH is set, lets increment our seq */ fifo_push(pri_work, w_u.ptr); c->ack_pending=0; s->stats.stream_segments_sent++; s->stats.stream_triggers_sent++; if (dyn) { s->stats.stream_dynamic_triggers_sent++; } c->mseq += pay_size; DBG(M_CON, "sending trigger to port %u", w_u.w->dport); w_u.ptr=NULL; } else { /* no payload so well just ack the connection */ w_u.ptr=xmalloc(sizeof(send_pri_workunit_t) + pay_size); w_u.w->magic=PRI_4SEND_MAGIC; w_u.w->dhost=k_u.s.dhost; w_u.w->dport=k_u.s.sport; w_u.w->sport=k_u.s.dport; w_u.w->shost=c->send_ip; w_u.w->tseq=c->tseq; w_u.w->mseq=c->mseq; w_u.w->window_size=c->window; w_u.w->flags=TH_ACK; w_u.w->doff=0; w_u.w->t_tstamp=c->t_tstamp; w_u.w->m_tstamp=c->m_tstamp; memcpy(w_u.inc + sizeof(send_pri_workunit_t), pay_ptr, pay_size); fifo_push(pri_work, w_u.ptr); s->stats.stream_segments_sent++; c->ack_pending=0; DBG(M_CON, "sending trigger to port %u", w_u.w->dport); w_u.ptr=NULL; } } /* get_payload */ else { w_u.ptr=xmalloc(sizeof(send_pri_workunit_t)); w_u.w->magic=PRI_4SEND_MAGIC; w_u.w->dhost=k_u.s.dhost; w_u.w->dport=k_u.s.sport; w_u.w->sport=k_u.s.dport; w_u.w->shost=c->send_ip; w_u.w->tseq=c->tseq + 1; /* SYN incs */ w_u.w->mseq=c->mseq; w_u.w->window_size=c->window; w_u.w->flags=TH_ACK; w_u.w->doff=0; w_u.w->t_tstamp=c->t_tstamp; w_u.w->m_tstamp=c->m_tstamp; c->m_tstamp++; fifo_push(pri_work, w_u.ptr); s->stats.stream_segments_sent++; c->ack_pending=0; w_u.ptr=NULL; } return; }
void* thread_fwd_routine(void *arg) { odp_packet_t pkt_tbl[PACKET_IO_BURST]; int rv_nb, sd_nb; int thr_id; int out_port; int tuple[5]; int i; thr_id = odp_thread_id(); printf("fwd thread %d start(on cpu %d)\n", thr_id, odp_cpu_id()); //match to port id thr_id--; memset(&port_stat.stat[thr_id], 0 , 3 * sizeof(uint64_t)); for(;;) { rv_nb = odp_pktio_recv(thr_data.nic_hdl[thr_id], pkt_tbl, PACKET_IO_BURST); port_stat.stat[thr_id].recv += rv_nb; #ifdef EXECUTE_CLASSIFICATION for(i = 0; i < rv_nb; i++) { if(extract_tuple(pkt_tbl[i], tuple) == 0) { int res; res = packet_classifier_search(tuple); } } #endif #ifdef EXECUTE_HASH_LOOKUP for(i = 0; i < rv_nb; i++) { if(extract_tuple(pkt_tbl[i], tuple) == 0) { int res; res = odph_hash_lookup(hs_tbl, (void*)tuple); } } #endif #ifdef EXECUTE_DPI unsigned char *payload; int payload_len; for(i = 0; i < rv_nb; i++) { if(get_payload(pkt_tbl[i], (unsigned char**)&payload, &payload_len) == 0) { int res; //printf("%d %d %s\n", thr_id, strlen(payload), payload); res = sm_search(sm_hdl, payload, payload_len); //printf("search res: %d\n", res); } } #endif if((thr_id & 1) == 1) { out_port = thr_id - 1; } else { out_port = thr_id + 1 == glb_param.nic.num ? thr_id : thr_id + 1; } sd_nb = odp_pktio_send(thr_data.nic_hdl[out_port], pkt_tbl, rv_nb); port_stat.stat[thr_id].send += sd_nb; while(sd_nb < rv_nb) { odp_packet_free(pkt_tbl[sd_nb++]); port_stat.stat[thr_id].drop++; } } return NULL; }
/* * La cola RR solo la agregamos por compatibilidad, * siempre va a ser un puntero a NULL. */ uint32_t atender_peticion_orquestador(uint32_t cliente, t_stream *pedido, t_queue_rr *cola_rr){ /*t_stream *pedido; recibir(cliente, (void*)&pedido); */ t_header header; deserializar_header(pedido, &header); int32_t pos_payload = sizeof(t_header); //char personajeElegido; switch (header.type){ case HANDSHAKE_NUEVO_NIVEL:{ uint32_t nro_nivel; uint32_t puerto; t_stream *payload = get_payload(pedido); memcpy(&nro_nivel,&payload[0],4); memcpy(&puerto,&payload[4],4); t_planificador *nodo_planificador; nodo_planificador = get_nodo_nivel(nro_nivel); //log_debug(logger_orq, "Hand_nuevo_nivel: dir nodo_planificador = %d", nodo_planificador); if(nodo_planificador == NULL){ nodo_planificador = malloc(sizeof(t_planificador)); nodo_planificador->tid=malloc(sizeof(pthread_t)); nodo_planificador->nivel.direccion = malloc(sizeof(struct sockaddr_in)); log_info(logger_orq, "Handshake_nuevo_nivel: Nueva conexión, nivel %d.", nro_nivel); completar_datos_nivel(nro_nivel, cliente, nodo_planificador); nodo_planificador->planificador.descriptor = 0; (nodo_planificador->nivel.direccion)->sin_port=htons(puerto); list_mutex_add(planificadores, (void*) nodo_planificador); sem_post(&semaforo_nodos_nuevos); free(pedido); return EXIT_SUCCESS; } log_info(logger_orq, "Se reconecta en nivel %d.", nro_nivel); completar_datos_nivel(nro_nivel, cliente, nodo_planificador); (nodo_planificador->nivel.direccion)->sin_port=htons(puerto); free(pedido); return EXIT_SUCCESS; } case HANDSHAKE_NUEVO_PJ:{ int8_t simbolo_pj; t_stream *payload =get_payload(pedido); simbolo_pj = (int8_t)payload[0]; log_info(logger_orq, "Handshake_nuevo_pj: Nueva conexión, pj %c", simbolo_pj); t_personaje_finalizado *pj; int pos_pj; pos_pj = get_pos_pj_finalizado(simbolo_pj); //Si todavía no está en la lista lo metemos. if(pos_pj == -1){ log_debug(logger_orq, "Handshake_nuevo_pj: El pj no existía así que lo guardo en listo personajes_finalizados."); pj = malloc(sizeof(t_personaje_finalizado)); pj->simbolo_pj = simbolo_pj; pj->termino_plan_de_niveles = false; log_debug(logger_orq, "Handshake_nuevo_pj: Guardo: Simbolo = %c bool_fin = %d", pj->simbolo_pj, pj->termino_plan_de_niveles); list_mutex_add(personajes_finalizados, (void*)pj); t_personaje_finalizado *test_pj = list_mutex_get(personajes_finalizados, 0); log_debug(logger_orq,"Handshake_nuevo_pj: Guardé simbolo = %c, bool_fin = %d ", test_pj->simbolo_pj, test_pj->termino_plan_de_niveles); } else{ pthread_mutex_lock(&personajes_finalizados->mutex); pj = list_get(personajes_finalizados->list, pos_pj); pj->termino_plan_de_niveles = false; pthread_mutex_unlock(&personajes_finalizados->mutex); } t_stream *stream_senial_ok; stream_senial_ok = serializar_senial(OK); log_debug(logger_orq, "Handshake_nuevo_pj: Envío OK al pj recién conectado"); enviar(cliente, stream_senial_ok); free(stream_senial_ok); free(pedido); return EXIT_SUCCESS; } case SOLICITUD_DATOS_NIVEL:{ t_stream *payload = get_payload(pedido); int8_t simbolo_pj = payload[0]; int8_t nro_nivel = payload[1]; t_datos_nivel datos_nivel; datos_nivel.direccion_nivel[0] = '\0'; datos_nivel.direccion_planificador[0]='\0'; int resultado = get_datos_nivel(nro_nivel, &datos_nivel); //Si el nivel no existe o si todavía no se lanzó su planificador asociado. if(resultado == EXIT_FAILURE){ char cadena_vacia = 'a'; t_stream *stream_nivel_no_existe = serializar_solicitud(NO_EXISTE_EL_NIVEL, sizeof(cadena_vacia), (t_stream*)&cadena_vacia); log_info(logger_orq, "Sol_datos_nivel: El pj %c solicitó los datos del nivel %d pero el nivel aún no fue cargado.", simbolo_pj, nro_nivel); enviar(cliente, (void*) stream_nivel_no_existe); free(pedido); free(stream_nivel_no_existe); return EXIT_SUCCESS; } t_stream *stream_datos_nivel; //En esta linea tira stream_datos_nivel = serializar_datos_nivel(&datos_nivel); log_debug(logger_orq,"Sol_datos_nivel: Datos del nivel solicitado: %s",datos_nivel.direccion_nivel); log_debug(logger_orq, "Sol_datos_nivel: Datos del planificador solicitado: %s",datos_nivel.direccion_planificador); log_info(logger_orq, "Sol_datos_nivel: El pj %c solicitó los datos del nivel %d. Se responde con los datos solicitados.", simbolo_pj, nro_nivel); enviar(cliente, stream_datos_nivel); free(stream_datos_nivel); free(pedido); return EXIT_SUCCESS; } case RECURSOS_LIBERADOS:{ //Los recursos vienen en un string con formato HHHHFFFFMMMM, char *recursos = (char*) &pedido[pos_payload]; uint32_t nro_nivel = get_nro_nivel(cliente); log_debug(logger_orq,"Recursos_liberados: Obteniendo socket_pair del planificador."); int32_t socket_pair_planificador = get_socket_pair_planificador(nro_nivel); log_debug(logger_orq,"Recursos_liberados: El socket pair es: %d", socket_pair_planificador); int32_t indice_recurso = 0; int8_t personaje_recurso[2]; int8_t personaje_nro_nivel[2]; log_info(logger_orq, "Recursos_liberados: El nivel %d liberó los recursos: %s ", nro_nivel, recursos); while(recursos[indice_recurso] != '\0'){ //La función pasa a un pj de bloqueados a personajes_listos. int8_t simbolo_pj_desbloqueado = desbloquear_personaje(recursos[indice_recurso], nro_nivel); if (simbolo_pj_desbloqueado>0) log_info(logger_orq,"Recursos_liberados: PJ elegido para desbloquear: %c, recurso: %c", simbolo_pj_desbloqueado, recursos[indice_recurso]); else log_info(logger_orq,"Recursos_liberados: Ningún pj esperaba el recurso %c", recursos[indice_recurso]); //Si no hay un pj que necesite ese recurso, en lugar del símbolo del pj envía -1. personaje_recurso[0] = simbolo_pj_desbloqueado; personaje_recurso[1] = recursos[indice_recurso]; t_stream *stream_pj_recurso = serializar_solicitud(DESBLOQUEAR_PERSONAJE, 2*sizeof(int8_t), (t_stream*) personaje_recurso); //Aviso al planificador para que lo saque de personajes_listo y lo ponga en cola_rr if(simbolo_pj_desbloqueado != -1){ personaje_nro_nivel[0] = simbolo_pj_desbloqueado; personaje_nro_nivel[1] = (int8_t) nro_nivel; log_debug(logger_orq,"Recursos_liberados: Envio al planificador pj: %c, nro_nivel: %d", personaje_nro_nivel[0], personaje_nro_nivel[1]); t_stream *stream_pj_nro_nivel = serializar_solicitud(DESBLOQUEAR_PERSONAJE, 2*sizeof(int8_t), (t_stream*) personaje_nro_nivel); int test_result_sock_pair = enviar(socket_pair_planificador, (void*) stream_pj_nro_nivel); if(test_result_sock_pair == EXIT_FAILURE) log_error(logger_orq,"Recursos_liberados: Error al enviar mensaje al socket_pair (nro %d)del planificador ", socket_pair_planificador); else log_debug(logger_orq,"Recursos_liberados: Se envió el msj al socket_pair nro %d", socket_pair_planificador); free(stream_pj_nro_nivel); } log_debug(logger_orq,"Recursos_liberados: Envio al nivel pj: %c, recurso: %c ", personaje_recurso[0], personaje_recurso[1]); enviar(cliente, (void*)stream_pj_recurso); free(stream_pj_recurso); //simbolo_pj_desbloqueado = desbloquear_personaje(recursos[indice_recurso], nro_nivel); indice_recurso++; } free(pedido); return EXIT_SUCCESS; } case FIN_PLAN_NIVELES:{ t_stream *payload = get_payload(pedido); int8_t simbolo_pj = payload[0]; log_info(logger_orq,"Fin_plan_niveles: El pj %c terminó su plan de niveles ", simbolo_pj); int pos_pj = get_pos_pj_finalizado(simbolo_pj); log_debug(logger_orq,"Fin_plan_niveles: Pos del pj finalizado = %d", pos_pj); t_personaje_finalizado *pj_finalizado = list_mutex_get(personajes_finalizados, pos_pj); pj_finalizado->termino_plan_de_niveles = true; if(todos_los_pj_terminaron()){ log_info(logger_orq,"Fin_plan_niveles: Todos los pj finalizaron su plan de niveles."); solicitar_fin_ejecucion_planificadores(); //Variable global que está en el while principal de todos los hilos. keep_running = false; estado_plataforma = false; sem_post(&semaforo_nodos_nuevos); } log_debug(logger_orq, "Fin_plan_niveles: FIN_PLAN_DE_NIVELES,case: retorno EXIT_SUCCESS;"); free(pedido); return EXIT_SUCCESS; } case RECOVERY:{ log_info(logger_orq, "Llegó pedido de recovery."); int8_t * personajesEnDeadlock = (int8_t*) &pedido[pos_payload]; printf("Llegó string: %s \n", personajesEnDeadlock); log_info(logger_orq, "Los PJs involucrados en el interbloqueo son %s", personajesEnDeadlock); t_personaje_listo *personajeElegido; int index_pj = 0; //Este while es solo por contención, se supone el pj[0] siempre va a estar bloqueado. while(personajesEnDeadlock[index_pj] != '\0'){ int8_t simbolo_pj = personajesEnDeadlock[index_pj]; personajeElegido= list_remove_personaje(personajes_bloqueados, simbolo_pj); if(personajeElegido != NULL){ log_info(logger_orq, "Recovery: Se da muerte al pj %c y se notifica al nivel.", personajeElegido->simbolo_pj); notificarPersonajeAsesinado(cliente, personajeElegido); if(index_pj != 0) log_info(logger_orq, "El pj asesinado estaba en la posición %d", index_pj); free(pedido); return EXIT_SUCCESS; } index_pj++; } log_error(logger_orq, "No se encontró ningún personaje para asesinar."); free(pedido); return EXIT_SUCCESS; } case HUBO_UNA_DESCONEXION:{ log_info(logger_orq, "Hubo una desconexión."); free(pedido); return EXIT_SUCCESS; } log_warning(logger_orq, "Hubo_desconexión: Recibo petición de tipo desconocida"); return EXIT_SUCCESS; } /* case RECOVERY:{//todo: agregar al serializador //todo: matar_personaje, func q devuelve el nombre de pj asesinado. //char *nombre_personaje = matar_personaje(); notificacion_pj_asesinado(cliente, nombre_personaje); free(nombre_personaje); free(pedido); //todo: poner free pedido fuera de atender_peticion()? return EXIT_SUCCESS; }*/ return EXIT_SUCCESS; }