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;
}
