void* serviceConnection(void* psa) { int success; connection conn; http_server srv; http_request request; http_response response; meta_error e = meta_error_new(); conn = (connection)psa; srv = connection_arg2(conn); request = http_server_get_request(srv); response = http_server_get_response(srv); success = serviceConnection2(srv, conn, request, response, e); if(!success && is_tcpip_error(e)) { connection_discard(conn); } else { connection_close(conn); } http_server_recycle_request(srv, request); http_server_recycle_response(srv, response); meta_error_free(e); return (void*)success; }
/* delete a state object */ void delete_state(struct state *st) { struct connection *const c = st->st_connection; struct state *old_cur_state = cur_state == st? NULL : cur_state; openswan_log("deleting state #%lu (%s)", st->st_serialno, enum_show(&state_names, st->st_state)); /* * for most IKEv2 things, we may have further things to do after marking the state deleted, * so we do not actually free it here at all, but back in the main loop when all the work is done. */ if(st->st_ikev2) { /* child sa*/ if(st->st_clonedfrom != 0) { DBG(DBG_CONTROL, DBG_log("received request to delete child state")); if(st->st_state == STATE_CHILDSA_DEL) { DBG(DBG_CONTROL, DBG_log("now deleting the child state")); } else { /* Only send request if child sa is established * otherwise continue with deletion */ if(IS_CHILD_SA_ESTABLISHED(st)) { DBG(DBG_CONTROL, DBG_log("sending Child SA delete equest")); send_delete(st); change_state(st, STATE_CHILDSA_DEL); /* actual deletion when we receive peer response*/ return; } } } else { DBG(DBG_CONTROL, DBG_log("considering request to delete IKE parent state")); /* parent sa */ if(st->st_state == STATE_IKESA_DEL) { DBG(DBG_CONTROL, DBG_log("now deleting the IKE (or parent) state")); } else { /* Another check to verify if a secured * INFORMATIONAL exchange can be sent or not */ if(st->st_skey_ei.ptr && st->st_skey_ai.ptr && st->st_skey_er.ptr && st->st_skey_ar.ptr) { DBG(DBG_CONTROL, DBG_log("sending IKE SA delete request")); send_delete(st); change_state(st, STATE_IKESA_DEL); /* actual deletion when we receive peer response*/ return; } } } } /* If DPD is enabled on this state object, clear any pending events */ if(st->st_dpd_event != NULL) delete_dpd_event(st); /* if there is a suspended state transition, disconnect us */ if (st->st_suspended_md != NULL) { passert(st->st_suspended_md->st == st); DBG(DBG_CONTROL, DBG_log("disconnecting state #%lu from md", st->st_serialno)); st->st_suspended_md->st = NULL; } /* tell the other side of any IPSEC SAs that are going down */ if (IS_IPSEC_SA_ESTABLISHED(st->st_state) || IS_ISAKMP_SA_ESTABLISHED(st->st_state)) send_delete(st); delete_event(st); /* delete any pending timer event */ /* Ditch anything pending on ISAKMP SA being established. * Note: this must be done before the unhash_state to prevent * flush_pending_by_state inadvertently and prematurely * deleting our connection. */ flush_pending_by_state(st); /* if there is anything in the cryptographic queue, then remove this * state from it. */ delete_cryptographic_continuation(st); /* effectively, this deletes any ISAKMP SA that this state represents */ unhash_state(st); /* tell kernel to delete any IPSEC SA * ??? we ought to tell peer to delete IPSEC SAs */ if (IS_IPSEC_SA_ESTABLISHED(st->st_state) || IS_CHILD_SA_ESTABLISHED(st)) delete_ipsec_sa(st, FALSE); else if (IS_ONLY_INBOUND_IPSEC_SA_ESTABLISHED(st->st_state)) delete_ipsec_sa(st, TRUE); if (c->newest_ipsec_sa == st->st_serialno) c->newest_ipsec_sa = SOS_NOBODY; if (c->newest_isakmp_sa == st->st_serialno) c->newest_isakmp_sa = SOS_NOBODY; /* * fake a state change here while we are still associated with a * connection. Without this the state logging (when enabled) cannot * work out what happened. */ fake_state(st, STATE_UNDEFINED); st->st_connection = NULL; /* we might be about to free it */ cur_state = old_cur_state; /* without st_connection, st isn't complete */ connection_discard(c); change_state(st, STATE_UNDEFINED); release_whack(st); change_state(st, STATE_CHILDSA_DEL); }
int server(unsigned short port, int demarcaciones, int taxPorDemarcacion, int iters, int timeout_millis, int txdelay_millis, bool debug) { connection_t conn; packet_t outgoing; packet_t * incoming; if (!connection_server(&conn, port)) { fprintf(stderr, "Unable to spawn server on port %u: ", port); connection_error(&conn, stderr); fprintf(stderr, "\n"); return 1; } if (debug) { connection_debug(&conn, stderr); } gestion_taxi_t * taxis = calloc(demarcaciones * taxPorDemarcacion, sizeof(gestion_taxi_t)); if (taxis == NULL) { fprintf(stderr, "Failed to allocate memory for taxi stats structure: %s\n", strerror(errno)); return 1; } fprintf(stderr, "Waiting for clientes at port: [%d]\n", port); int connected = 0; int pendingAccAck = demarcaciones * taxPorDemarcacion; while (pendingAccAck > 0) { if (!connection_receive(&conn, &incoming, NULL)) { /* TODO: check how to safely implement a timeout here */ fprintf(stderr, "Error receiving login packet: "); connection_error(&conn, stderr); fprintf(stderr, "\n"); if (connection_dead(&conn)) { connection_close(&conn); free(taxis); return 1; } continue; } bool duplicate = false; int pos; switch (incoming->type) { case PACKET_TYPE_LOGIN: if (incoming->login.version != PACKET_VERSION) { fprintf(stderr, "Got LOGIN with version %08X but server version is %08X\n", incoming->login.version, PACKET_VERSION); connection_discard(&conn); continue; } connection_accept(&conn); for (pos = 0; pos < connected; pos++) { if (connection_cmp(&taxis[pos].conexionConTaxi, &conn)) { duplicate = true; fprintf(stderr, "Got duplicated login packet from taxi %d-%d. Re-sending acknowledgement\n", pos / taxPorDemarcacion, pos % taxPorDemarcacion); break; } } if (!duplicate) { if (connected == taxPorDemarcacion * demarcaciones) { fprintf(stderr, "Received new LOGIN but all taxis have been already registered\n"); continue; } fprintf(stderr, "Registered new taxi %d-%d\n", connected / taxPorDemarcacion, connected % taxPorDemarcacion); memcpy(&taxis[connected].conexionConTaxi, &conn, sizeof(conn)); connected++; } outgoing.type = PACKET_TYPE_ACCEPT; outgoing.accept.zone = pos / taxPorDemarcacion; outgoing.accept.id = pos % taxPorDemarcacion; outgoing.accept.neighbors = taxPorDemarcacion - 1; outgoing.accept.ticks = iters; outgoing.accept.timeout = timeout_millis; outgoing.accept.txdelay = txdelay_millis; if (!connection_send(&conn, &outgoing)) { fprintf(stderr, "Error replying to login packet: "); connection_error(&conn, stderr); fprintf(stderr, "\n"); connection_close(&conn); free(taxis); return 1; } break; case PACKET_TYPE_ACCACK: if (incoming->accack.zone >= demarcaciones || incoming->accack.id >= taxPorDemarcacion) { fprintf(stderr, "Received illegal accept acknowledgement from taxi %u-%u\n", incoming->accack.zone, incoming->accack.id); connection_discard(&conn); continue; } connection_accept(&conn); gestion_taxi_t * taxi = &taxis[incoming->accack.zone * taxPorDemarcacion + incoming->accack.id]; if (!taxi->hasAckdAccept) { taxi->hasAckdAccept = true; pendingAccAck--; } break; default: connection_discard(&conn); fprintf(stderr, "Unexpected packet %s during login phase. Discarding.\n", packet_name(incoming)); continue; } } outgoing.type = PACKET_TYPE_START; for (int pos = 0; pos < demarcaciones * taxPorDemarcacion; pos++) { if (!connection_send(&taxis[pos].conexionConTaxi, &outgoing)) { fprintf(stderr, "Error sending start packet: "); connection_error(&conn, stderr); fprintf(stderr, "\n"); connection_close(&conn); free(taxis); return 1; } } int statsRcv = 0; struct timeval defaulttimeout = { (timeout_millis * 2) / 1000, ((timeout_millis * 2) % 1000) * 1000 }; struct timeval timeout = defaulttimeout; while (statsRcv < demarcaciones * taxPorDemarcacion) { if (!connection_receive(&conn, &incoming, NULL)) { fprintf(stderr, "Error receiving packet in main loop: "); connection_error(&conn, stderr); fprintf(stderr, "\n"); if (conn.err == CONNERR_TIMEOUT) { break; } if (connection_dead(&conn)) { connection_close(&conn); free(taxis); return 1; } continue; } gestion_taxi_t * taxi; switch (incoming->type) { case PACKET_TYPE_ACCACK: outgoing.type = PACKET_TYPE_START; if (!connection_send(&conn, &outgoing)) { fprintf(stderr, "Failed to send start packet in main loop: "); connection_error(&conn, stderr); fprintf(stderr, "\n"); connection_close(&conn); return 1; } timeout = defaulttimeout; break; case PACKET_TYPE_POSITION: if (incoming->position.zone > demarcaciones || incoming->position.id > taxPorDemarcacion) { fprintf(stderr, "Received position from illegal taxi %u-%u\n", outgoing.position.zone, outgoing.position.id); connection_discard(&conn); continue; } for (int neighbor = 0; neighbor < taxPorDemarcacion; neighbor++) { if (neighbor == incoming->position.id) { continue; } if (!connection_send(&taxis[incoming->position.zone * taxPorDemarcacion + neighbor].conexionConTaxi, incoming)) { fprintf(stderr, "Error forwarding position packet: "); connection_error(&taxis[incoming->position.zone * taxPorDemarcacion + neighbor].conexionConTaxi, stderr); fprintf(stderr, "\n"); connection_close(&conn); free(taxis); return 1; } } timeout = defaulttimeout; connection_accept(&conn); break; case PACKET_TYPE_POSACK: if (incoming->posack.zone > demarcaciones || incoming->posack.id > taxPorDemarcacion) { fprintf(stderr, "Received acknowledgement from illegal taxi %u-%u\n", incoming->posack.zone, incoming->posack.id); break; } if (incoming->posack.neighbor > taxPorDemarcacion) { fprintf(stderr, "Received acknowledgement from %u-%u targeting out-of-bounds taxi %u-%u\n", incoming->posack.zone, incoming->posack.id, incoming->posack.zone, incoming->posack.neighbor); break; } taxi = &taxis[incoming->posack.zone * taxPorDemarcacion + incoming->posack.neighbor]; if (!connection_send(&taxi->conexionConTaxi, incoming)) { fprintf(stderr, "Error forwarding acknowledgement packet: "); connection_error(&taxi->conexionConTaxi, stderr); fprintf(stderr, "\n"); connection_close(&conn); free(taxis); return 1; } timeout = defaulttimeout; connection_accept(&conn); break; case PACKET_TYPE_STATS: taxi = &taxis[incoming->stats.zone * taxPorDemarcacion + incoming->stats.id]; if (!taxi->hasSentStats) { printf("%u, %u, %u, %u, %u, %u, %u, %u\n", incoming->stats.zone, incoming->stats.id, incoming->stats.ticks, incoming->stats.posrcv, incoming->stats.ackrcv, incoming->stats.itmin, incoming->stats.itavg, incoming->stats.itmax ); taxi->hasSentStats = true; statsRcv++; } outgoing.type = PACKET_TYPE_STATACK; if (!connection_send(&taxi->conexionConTaxi, &outgoing)) { fprintf(stderr, "Error sending stats acknowledgement packet: "); connection_error(&taxi->conexionConTaxi, stderr); fprintf(stderr, "\n"); connection_close(&conn); free(taxis); return 1; } timeout = defaulttimeout; connection_accept(&conn); break; default: fprintf(stderr, "Unexpected packet %s during main loop\n", packet_name(incoming)); connection_discard(&conn); continue; } } // TODO: Interpretar estadísticas return 0; }