From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/core/gnunet-service-core_sessions.c | 814 ++++++++++++++++---------------- 1 file changed, 409 insertions(+), 405 deletions(-) (limited to 'src/core/gnunet-service-core_sessions.c') diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c index daca22aef..503d4600f 100644 --- a/src/core/gnunet-service-core_sessions.c +++ b/src/core/gnunet-service-core_sessions.c @@ -43,7 +43,8 @@ * Message ready for encryption. This struct is followed by the * actual content of the message. */ -struct SessionMessageEntry { +struct SessionMessageEntry +{ /** * We keep messages in a doubly linked list. */ @@ -88,7 +89,8 @@ struct SessionMessageEntry { /** * Data kept per session. */ -struct Session { +struct Session +{ /** * Identity of the other peer. */ @@ -156,7 +158,8 @@ GNUNET_NETWORK_STRUCT_BEGIN /** * Message sent to confirm that a typemap was received. */ -struct TypeMapConfirmationMessage { +struct TypeMapConfirmationMessage +{ /** * Header with type #GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP. */ @@ -190,11 +193,11 @@ static struct GNUNET_CONTAINER_MultiPeerMap *sessions; * session handle */ static struct Session * -find_session(const struct GNUNET_PeerIdentity *peer) +find_session (const struct GNUNET_PeerIdentity *peer) { if (NULL == sessions) return NULL; - return GNUNET_CONTAINER_multipeermap_get(sessions, peer); + return GNUNET_CONTAINER_multipeermap_get (sessions, peer); } @@ -205,53 +208,53 @@ find_session(const struct GNUNET_PeerIdentity *peer) * @param pid identity of peer to kill session with */ void -GSC_SESSIONS_end(const struct GNUNET_PeerIdentity *pid) +GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid) { struct Session *session; struct GSC_ClientActiveRequest *car; struct SessionMessageEntry *sme; - session = find_session(pid); + session = find_session (pid); if (NULL == session) return; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Destroying session for peer `%s'\n", - GNUNET_i2s(session->peer)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Destroying session for peer `%s'\n", + GNUNET_i2s (session->peer)); if (NULL != session->cork_task) - { - GNUNET_SCHEDULER_cancel(session->cork_task); - session->cork_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (session->cork_task); + session->cork_task = NULL; + } while (NULL != (car = session->active_client_request_head)) - { - GNUNET_CONTAINER_DLL_remove(session->active_client_request_head, - session->active_client_request_tail, - car); - GSC_CLIENTS_reject_request(car, GNUNET_NO); - } + { + GNUNET_CONTAINER_DLL_remove (session->active_client_request_head, + session->active_client_request_tail, + car); + GSC_CLIENTS_reject_request (car, GNUNET_NO); + } while (NULL != (sme = session->sme_head)) - { - GNUNET_CONTAINER_DLL_remove(session->sme_head, session->sme_tail, sme); - GNUNET_free(sme); - } + { + GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); + GNUNET_free (sme); + } if (NULL != session->typemap_task) - { - GNUNET_SCHEDULER_cancel(session->typemap_task); - session->typemap_task = NULL; - } - GSC_CLIENTS_notify_clients_about_neighbour(session->peer, - session->tmap, - NULL); - GNUNET_assert( + { + GNUNET_SCHEDULER_cancel (session->typemap_task); + session->typemap_task = NULL; + } + GSC_CLIENTS_notify_clients_about_neighbour (session->peer, + session->tmap, + NULL); + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(sessions, session->peer, session)); - GNUNET_STATISTICS_set(GSC_stats, - gettext_noop("# peers connected"), - GNUNET_CONTAINER_multipeermap_size(sessions), - GNUNET_NO); - GSC_TYPEMAP_destroy(session->tmap); + GNUNET_CONTAINER_multipeermap_remove (sessions, session->peer, session)); + GNUNET_STATISTICS_set (GSC_stats, + gettext_noop ("# peers connected"), + GNUNET_CONTAINER_multipeermap_size (sessions), + GNUNET_NO); + GSC_TYPEMAP_destroy (session->tmap); session->tmap = NULL; - GNUNET_free(session); + GNUNET_free (session); } @@ -262,29 +265,29 @@ GSC_SESSIONS_end(const struct GNUNET_PeerIdentity *pid) * @param cls the `struct Session *` */ static void -transmit_typemap_task(void *cls) +transmit_typemap_task (void *cls) { struct Session *session = cls; struct GNUNET_MessageHeader *hdr; struct GNUNET_TIME_Relative delay; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending TYPEMAP to %s\n", - GNUNET_i2s(session->peer)); - session->typemap_delay = GNUNET_TIME_STD_BACKOFF(session->typemap_delay); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending TYPEMAP to %s\n", + GNUNET_i2s (session->peer)); + session->typemap_delay = GNUNET_TIME_STD_BACKOFF (session->typemap_delay); delay = session->typemap_delay; /* randomize a bit to avoid spont. sync */ delay.rel_value_us += - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 1000 * 1000); + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000 * 1000); session->typemap_task = - GNUNET_SCHEDULER_add_delayed(delay, &transmit_typemap_task, session); - GNUNET_STATISTICS_update(GSC_stats, - gettext_noop("# type map refreshes sent"), - 1, - GNUNET_NO); - hdr = GSC_TYPEMAP_compute_type_map_message(); - GSC_KX_encrypt_and_transmit(session->kx, hdr, ntohs(hdr->size)); - GNUNET_free(hdr); + GNUNET_SCHEDULER_add_delayed (delay, &transmit_typemap_task, session); + GNUNET_STATISTICS_update (GSC_stats, + gettext_noop ("# type map refreshes sent"), + 1, + GNUNET_NO); + hdr = GSC_TYPEMAP_compute_type_map_message (); + GSC_KX_encrypt_and_transmit (session->kx, hdr, ntohs (hdr->size)); + GNUNET_free (hdr); } @@ -294,14 +297,14 @@ transmit_typemap_task(void *cls) * @param session session to restart typemap transmission for */ static void -start_typemap_task(struct Session *session) +start_typemap_task (struct Session *session) { if (NULL != session->typemap_task) - GNUNET_SCHEDULER_cancel(session->typemap_task); + GNUNET_SCHEDULER_cancel (session->typemap_task); session->typemap_delay = GNUNET_TIME_UNIT_SECONDS; - session->typemap_task = GNUNET_SCHEDULER_add_delayed(session->typemap_delay, - &transmit_typemap_task, - session); + session->typemap_task = GNUNET_SCHEDULER_add_delayed (session->typemap_delay, + &transmit_typemap_task, + session); } @@ -312,30 +315,30 @@ start_typemap_task(struct Session *session) * @param kx key exchange that completed */ void -GSC_SESSIONS_create(const struct GNUNET_PeerIdentity *peer, - struct GSC_KeyExchangeInfo *kx) +GSC_SESSIONS_create (const struct GNUNET_PeerIdentity *peer, + struct GSC_KeyExchangeInfo *kx) { struct Session *session; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Creating session for peer `%s'\n", - GNUNET_i2s(peer)); - session = GNUNET_new(struct Session); - session->tmap = GSC_TYPEMAP_create(); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating session for peer `%s'\n", + GNUNET_i2s (peer)); + session = GNUNET_new (struct Session); + session->tmap = GSC_TYPEMAP_create (); session->peer = peer; session->kx = kx; - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multipeermap_put( - sessions, - session->peer, - session, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); - GNUNET_STATISTICS_set(GSC_stats, - gettext_noop("# peers connected"), - GNUNET_CONTAINER_multipeermap_size(sessions), - GNUNET_NO); - GSC_CLIENTS_notify_clients_about_neighbour(peer, NULL, session->tmap); - start_typemap_task(session); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multipeermap_put ( + sessions, + session->peer, + session, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_STATISTICS_set (GSC_stats, + gettext_noop ("# peers connected"), + GNUNET_CONTAINER_multipeermap_size (sessions), + GNUNET_NO); + GSC_CLIENTS_notify_clients_about_neighbour (peer, NULL, session->tmap); + start_typemap_task (session); } @@ -347,18 +350,18 @@ GSC_SESSIONS_create(const struct GNUNET_PeerIdentity *peer, * @param peer peer that is now connected */ void -GSC_SESSIONS_reinit(const struct GNUNET_PeerIdentity *peer) +GSC_SESSIONS_reinit (const struct GNUNET_PeerIdentity *peer) { struct Session *session; - session = find_session(peer); + session = find_session (peer); if (NULL == session) - { - /* KX/session is new for both sides; thus no need to restart what - has not yet begun */ - return; - } - start_typemap_task(session); + { + /* KX/session is new for both sides; thus no need to restart what + has not yet begun */ + return; + } + start_typemap_task (session); } @@ -370,51 +373,51 @@ GSC_SESSIONS_reinit(const struct GNUNET_PeerIdentity *peer) * @param msg confirmation message we received */ void -GSC_SESSIONS_confirm_typemap(const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *msg) +GSC_SESSIONS_confirm_typemap (const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *msg) { const struct TypeMapConfirmationMessage *cmsg; struct Session *session; - session = find_session(peer); + session = find_session (peer); if (NULL == session) - { - GNUNET_break(0); - return; - } - if (ntohs(msg->size) != sizeof(struct TypeMapConfirmationMessage)) - { - GNUNET_break_op(0); - return; - } - cmsg = (const struct TypeMapConfirmationMessage *)msg; - if (GNUNET_YES != GSC_TYPEMAP_check_hash(&cmsg->tm_hash)) - { - /* our typemap has changed in the meantime, do not - accept confirmation */ - GNUNET_STATISTICS_update(GSC_stats, - gettext_noop( - "# outdated typemap confirmations received"), - 1, - GNUNET_NO); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got outdated typemap confirmated from peer `%s'\n", - GNUNET_i2s(session->peer)); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got typemap confirmation from peer `%s'\n", - GNUNET_i2s(session->peer)); + { + GNUNET_break (0); + return; + } + if (ntohs (msg->size) != sizeof(struct TypeMapConfirmationMessage)) + { + GNUNET_break_op (0); + return; + } + cmsg = (const struct TypeMapConfirmationMessage *) msg; + if (GNUNET_YES != GSC_TYPEMAP_check_hash (&cmsg->tm_hash)) + { + /* our typemap has changed in the meantime, do not + accept confirmation */ + GNUNET_STATISTICS_update (GSC_stats, + gettext_noop ( + "# outdated typemap confirmations received"), + 1, + GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got outdated typemap confirmated from peer `%s'\n", + GNUNET_i2s (session->peer)); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got typemap confirmation from peer `%s'\n", + GNUNET_i2s (session->peer)); if (NULL != session->typemap_task) - { - GNUNET_SCHEDULER_cancel(session->typemap_task); - session->typemap_task = NULL; - } - GNUNET_STATISTICS_update(GSC_stats, - gettext_noop( - "# valid typemap confirmations received"), - 1, - GNUNET_NO); + { + GNUNET_SCHEDULER_cancel (session->typemap_task); + session->typemap_task = NULL; + } + GNUNET_STATISTICS_update (GSC_stats, + gettext_noop ( + "# valid typemap confirmations received"), + 1, + GNUNET_NO); } @@ -427,17 +430,17 @@ GSC_SESSIONS_confirm_typemap(const struct GNUNET_PeerIdentity *peer, * @return #GNUNET_OK (continue to iterate) */ static int -notify_client_about_session(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +notify_client_about_session (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct GSC_Client *client = cls; struct Session *session = value; - GSC_CLIENTS_notify_client_about_neighbour(client, - session->peer, - NULL, /* old TMAP: none */ - session->tmap); + GSC_CLIENTS_notify_client_about_neighbour (client, + session->peer, + NULL, /* old TMAP: none */ + session->tmap); return GNUNET_OK; } @@ -448,12 +451,12 @@ notify_client_about_session(void *cls, * @param client the new client */ void -GSC_SESSIONS_notify_client_about_sessions(struct GSC_Client *client) +GSC_SESSIONS_notify_client_about_sessions (struct GSC_Client *client) { /* notify new client about existing sessions */ - GNUNET_CONTAINER_multipeermap_iterate(sessions, - ¬ify_client_about_session, - client); + GNUNET_CONTAINER_multipeermap_iterate (sessions, + ¬ify_client_about_session, + client); } @@ -464,7 +467,7 @@ GSC_SESSIONS_notify_client_about_sessions(struct GSC_Client *client) * @param session session to transmit messages from */ static void -try_transmission(struct Session *session); +try_transmission (struct Session *session); /** @@ -477,31 +480,31 @@ try_transmission(struct Session *session); * have been invoked on it */ void -GSC_SESSIONS_queue_request(struct GSC_ClientActiveRequest *car) +GSC_SESSIONS_queue_request (struct GSC_ClientActiveRequest *car) { struct Session *session; - session = find_session(&car->target); + session = find_session (&car->target); if (NULL == session) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Dropped client request for transmission (am disconnected)\n"); - GNUNET_break(0); /* should have been rejected earlier */ - GSC_CLIENTS_reject_request(car, GNUNET_NO); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Dropped client request for transmission (am disconnected)\n"); + GNUNET_break (0); /* should have been rejected earlier */ + GSC_CLIENTS_reject_request (car, GNUNET_NO); + return; + } if (car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) - { - GNUNET_break(0); - GSC_CLIENTS_reject_request(car, GNUNET_YES); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received client transmission request. queueing\n"); - GNUNET_CONTAINER_DLL_insert_tail(session->active_client_request_head, - session->active_client_request_tail, - car); - try_transmission(session); + { + GNUNET_break (0); + GSC_CLIENTS_reject_request (car, GNUNET_YES); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received client transmission request. queueing\n"); + GNUNET_CONTAINER_DLL_insert_tail (session->active_client_request_head, + session->active_client_request_tail, + car); + try_transmission (session); } @@ -512,23 +515,23 @@ GSC_SESSIONS_queue_request(struct GSC_ClientActiveRequest *car) * the caller (CLIENTS sysbsystem) */ void -GSC_SESSIONS_dequeue_request(struct GSC_ClientActiveRequest *car) +GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car) { struct Session *session; - if (0 == memcmp(&car->target, - &GSC_my_identity, - sizeof(struct GNUNET_PeerIdentity))) + if (0 == memcmp (&car->target, + &GSC_my_identity, + sizeof(struct GNUNET_PeerIdentity))) return; - session = find_session(&car->target); - GNUNET_assert(NULL != session); - GNUNET_CONTAINER_DLL_remove(session->active_client_request_head, - session->active_client_request_tail, - car); + session = find_session (&car->target); + GNUNET_assert (NULL != session); + GNUNET_CONTAINER_DLL_remove (session->active_client_request_head, + session->active_client_request_tail, + car); /* dequeueing of 'high' priority messages may unblock transmission for lower-priority messages, so we also need to try in this case. */ - try_transmission(session); + try_transmission (session); } @@ -540,7 +543,7 @@ GSC_SESSIONS_dequeue_request(struct GSC_ClientActiveRequest *car) * @param msize how many bytes do we have already */ static void -solicit_messages(struct Session *session, size_t msize) +solicit_messages (struct Session *session, size_t msize) { struct GSC_ClientActiveRequest *car; struct GSC_ClientActiveRequest *nxt; @@ -550,33 +553,33 @@ solicit_messages(struct Session *session, size_t msize) so_size = msize; pmax = GNUNET_MQ_PRIO_BACKGROUND; for (car = session->active_client_request_head; NULL != car; car = car->next) - { - if (GNUNET_YES == car->was_solicited) - continue; - pmax = GNUNET_MAX(pmax, car->priority & GNUNET_MQ_PRIORITY_MASK); - } + { + if (GNUNET_YES == car->was_solicited) + continue; + pmax = GNUNET_MAX (pmax, car->priority & GNUNET_MQ_PRIORITY_MASK); + } nxt = session->active_client_request_head; while (NULL != (car = nxt)) - { - nxt = car->next; - if (car->priority < pmax) - continue; - if (so_size + car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) - break; - so_size += car->msize; - if (GNUNET_YES == car->was_solicited) - continue; - car->was_solicited = GNUNET_YES; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Soliciting message with priority %u\n", - car->priority); - GSC_CLIENTS_solicit_request(car); - /* The above call may *dequeue* requests and thereby - clobber 'nxt'. Hence we need to restart from the - head of the list. */ - nxt = session->active_client_request_head; - so_size = msize; - } + { + nxt = car->next; + if (car->priority < pmax) + continue; + if (so_size + car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) + break; + so_size += car->msize; + if (GNUNET_YES == car->was_solicited) + continue; + car->was_solicited = GNUNET_YES; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Soliciting message with priority %u\n", + car->priority); + GSC_CLIENTS_solicit_request (car); + /* The above call may *dequeue* requests and thereby + clobber 'nxt'. Hence we need to restart from the + head of the list. */ + nxt = session->active_client_request_head; + so_size = msize; + } } @@ -587,12 +590,12 @@ solicit_messages(struct Session *session, size_t msize) * @param cls `struct Session` with the messages to transmit now */ static void -pop_cork_task(void *cls) +pop_cork_task (void *cls) { struct Session *session = cls; session->cork_task = NULL; - try_transmission(session); + try_transmission (session); } @@ -604,7 +607,7 @@ pop_cork_task(void *cls) * @param session session to transmit messages from */ static void -try_transmission(struct Session *session) +try_transmission (struct Session *session) { struct SessionMessageEntry *pos; size_t msize; @@ -620,13 +623,13 @@ try_transmission(struct Session *session) /* if the peer has excess bandwidth, background traffic is allowed, otherwise not */ if (MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE <= - GSC_NEIGHBOURS_get_queue_length(session->kx)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Transmission queue already very long, waiting...\n"); - return; /* queue already too long */ - } - excess = GSC_NEIGHBOURS_check_excess_bandwidth(session->kx); + GSC_NEIGHBOURS_get_queue_length (session->kx)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmission queue already very long, waiting...\n"); + return; /* queue already too long */ + } + excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx); if (GNUNET_YES == excess) maxp = GNUNET_MQ_PRIO_BACKGROUND; else @@ -635,98 +638,99 @@ try_transmission(struct Session *session) pos = session->sme_head; while ((NULL != pos) && (msize + pos->size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)) - { - GNUNET_assert(pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); - msize += pos->size; - maxp = GNUNET_MAX(maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK); - min_deadline = GNUNET_TIME_absolute_min(min_deadline, pos->deadline); - pos = pos->next; - } - GNUNET_log( + { + GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); + msize += pos->size; + maxp = GNUNET_MAX (maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK); + min_deadline = GNUNET_TIME_absolute_min (min_deadline, pos->deadline); + pos = pos->next; + } + GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, "Calculating transmission set with %u priority (%s) and %s earliest deadline\n", maxp, (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth", - GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining( - min_deadline), - GNUNET_YES)); + GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining ( + min_deadline), + GNUNET_YES)); if (maxp < GNUNET_MQ_PRIO_CRITICAL_CONTROL) + { + /* if highest already solicited priority from clients is not critical, + check if there are higher-priority messages to be solicited from clients */ + if (GNUNET_YES == excess) + maxpc = GNUNET_MQ_PRIO_BACKGROUND; + else + maxpc = GNUNET_MQ_PRIO_BEST_EFFORT; + for (car = session->active_client_request_head; NULL != car; + car = car->next) { - /* if highest already solicited priority from clients is not critical, - check if there are higher-priority messages to be solicited from clients */ - if (GNUNET_YES == excess) - maxpc = GNUNET_MQ_PRIO_BACKGROUND; - else - maxpc = GNUNET_MQ_PRIO_BEST_EFFORT; - for (car = session->active_client_request_head; NULL != car; - car = car->next) - { - if (GNUNET_YES == car->was_solicited) - continue; - maxpc = GNUNET_MAX(maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK); - } - if (maxpc > maxp) - { - /* we have messages waiting for solicitation that have a higher - priority than those that we already accepted; solicit the - high-priority messages first */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Soliciting messages based on priority (%u > %u)\n", - maxpc, - maxp); - solicit_messages(session, 0); - return; - } + if (GNUNET_YES == car->was_solicited) + continue; + maxpc = GNUNET_MAX (maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK); } - else + if (maxpc > maxp) { - /* never solicit more, we have critical messages to process */ - excess = GNUNET_NO; - maxpc = GNUNET_MQ_PRIO_BACKGROUND; + /* we have messages waiting for solicitation that have a higher + priority than those that we already accepted; solicit the + high-priority messages first */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Soliciting messages based on priority (%u > %u)\n", + maxpc, + maxp); + solicit_messages (session, 0); + return; } - now = GNUNET_TIME_absolute_get(); + } + else + { + /* never solicit more, we have critical messages to process */ + excess = GNUNET_NO; + maxpc = GNUNET_MQ_PRIO_BACKGROUND; + } + now = GNUNET_TIME_absolute_get (); if (((GNUNET_YES == excess) || (maxpc >= GNUNET_MQ_PRIO_BEST_EFFORT)) && ((0 == msize) || ((msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) && (min_deadline.abs_value_us > now.abs_value_us)))) + { + /* not enough ready yet (tiny message & cork possible), or no messages at all, + and either excess bandwidth or best-effort or higher message waiting at + client; in this case, we try to solicit more */ + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n", + excess, + maxpc, + (unsigned int) msize, + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_remaining ( + min_deadline), + GNUNET_YES)); + solicit_messages (session, msize); + if (msize > 0) { - /* not enough ready yet (tiny message & cork possible), or no messages at all, - and either excess bandwidth or best-effort or higher message waiting at - client; in this case, we try to solicit more */ - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n", - excess, - maxpc, - (unsigned int)msize, - GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining( - min_deadline), - GNUNET_YES)); - solicit_messages(session, msize); - if (msize > 0) - { - /* if there is data to send, just not yet, make sure we do transmit - * it once the deadline is reached */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Corking until %s\n", - GNUNET_STRINGS_relative_time_to_string( - GNUNET_TIME_absolute_get_remaining(min_deadline), - GNUNET_YES)); - if (NULL != session->cork_task) - GNUNET_SCHEDULER_cancel(session->cork_task); - session->cork_task = - GNUNET_SCHEDULER_add_at(min_deadline, &pop_cork_task, session); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Queue empty, waiting for solicitations\n"); - } - return; + /* if there is data to send, just not yet, make sure we do transmit + * it once the deadline is reached */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Corking until %s\n", + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_remaining (min_deadline), + GNUNET_YES)); + if (NULL != session->cork_task) + GNUNET_SCHEDULER_cancel (session->cork_task); + session->cork_task = + GNUNET_SCHEDULER_add_at (min_deadline, &pop_cork_task, session); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Queue empty, waiting for solicitations\n"); } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Building combined plaintext buffer to transmit message!\n"); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Building combined plaintext buffer to transmit message!\n"); /* create plaintext buffer of all messages (that fit), encrypt and transmit */ { @@ -737,33 +741,33 @@ try_transmission(struct Session *session) used = 0; while ((NULL != (pos = session->sme_head)) && (used + pos->size <= msize)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Adding message of type %d (%d/%d) to payload for %s\n", - ntohs(((const struct GNUNET_MessageHeader *)&pos[1])->type), - pos->is_typemap, - pos->is_typemap_confirm, - GNUNET_i2s(session->peer)); - GNUNET_memcpy(&pbuf[used], &pos[1], pos->size); - used += pos->size; - GNUNET_CONTAINER_DLL_remove(session->sme_head, session->sme_tail, pos); - GNUNET_free(pos); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Adding message of type %d (%d/%d) to payload for %s\n", + ntohs (((const struct GNUNET_MessageHeader *) &pos[1])->type), + pos->is_typemap, + pos->is_typemap_confirm, + GNUNET_i2s (session->peer)); + GNUNET_memcpy (&pbuf[used], &pos[1], pos->size); + used += pos->size; + GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, pos); + GNUNET_free (pos); + } /* compute average payload size */ total_bytes += used; total_msgs++; if (0 == total_msgs) - { - /* 2^32 messages, wrap around... */ - total_msgs = 1; - total_bytes = used; - } - GNUNET_STATISTICS_set(GSC_stats, - "# avg payload per encrypted message", - total_bytes / total_msgs, - GNUNET_NO); + { + /* 2^32 messages, wrap around... */ + total_msgs = 1; + total_bytes = used; + } + GNUNET_STATISTICS_set (GSC_stats, + "# avg payload per encrypted message", + total_bytes / total_msgs, + GNUNET_NO); /* now actually transmit... */ - GSC_KX_encrypt_and_transmit(session->kx, pbuf, used); + GSC_KX_encrypt_and_transmit (session->kx, pbuf, used); } } @@ -778,36 +782,36 @@ try_transmission(struct Session *session) * @return always #GNUNET_OK */ static int -do_restart_typemap_message(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +do_restart_typemap_message (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { const struct GNUNET_MessageHeader *hdr = cls; struct Session *session = value; struct SessionMessageEntry *sme; uint16_t size; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Restarting sending TYPEMAP to %s\n", - GNUNET_i2s(session->peer)); - size = ntohs(hdr->size); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Restarting sending TYPEMAP to %s\n", + GNUNET_i2s (session->peer)); + size = ntohs (hdr->size); for (sme = session->sme_head; NULL != sme; sme = sme->next) + { + if (GNUNET_YES == sme->is_typemap) { - if (GNUNET_YES == sme->is_typemap) - { - GNUNET_CONTAINER_DLL_remove(session->sme_head, session->sme_tail, sme); - GNUNET_free(sme); - break; - } + GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); + GNUNET_free (sme); + break; } - sme = GNUNET_malloc(sizeof(struct SessionMessageEntry) + size); + } + sme = GNUNET_malloc (sizeof(struct SessionMessageEntry) + size); sme->is_typemap = GNUNET_YES; - GNUNET_memcpy(&sme[1], hdr, size); + GNUNET_memcpy (&sme[1], hdr, size); sme->size = size; sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL; - GNUNET_CONTAINER_DLL_insert(session->sme_head, session->sme_tail, sme); - try_transmission(session); - start_typemap_task(session); + GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme); + try_transmission (session); + start_typemap_task (session); return GNUNET_OK; } @@ -819,13 +823,13 @@ do_restart_typemap_message(void *cls, * @param msg message to transmit */ void -GSC_SESSIONS_broadcast_typemap(const struct GNUNET_MessageHeader *msg) +GSC_SESSIONS_broadcast_typemap (const struct GNUNET_MessageHeader *msg) { if (NULL == sessions) return; - GNUNET_CONTAINER_multipeermap_iterate(sessions, - &do_restart_typemap_message, - (void *)msg); + GNUNET_CONTAINER_multipeermap_iterate (sessions, + &do_restart_typemap_message, + (void *) msg); } @@ -837,17 +841,17 @@ GSC_SESSIONS_broadcast_typemap(const struct GNUNET_MessageHeader *msg) * @param pid identity of peer ready to receive data */ void -GSC_SESSIONS_solicit(const struct GNUNET_PeerIdentity *pid) +GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid) { struct Session *session; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Transport solicits for %s\n", - GNUNET_i2s(pid)); - session = find_session(pid); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transport solicits for %s\n", + GNUNET_i2s (pid)); + session = find_session (pid); if (NULL == session) return; - try_transmission(session); + try_transmission (session); } @@ -860,43 +864,43 @@ GSC_SESSIONS_solicit(const struct GNUNET_PeerIdentity *pid) * @param priority how important is this message */ void -GSC_SESSIONS_transmit(struct GSC_ClientActiveRequest *car, - const struct GNUNET_MessageHeader *msg, - enum GNUNET_MQ_PriorityPreferences priority) +GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, + const struct GNUNET_MessageHeader *msg, + enum GNUNET_MQ_PriorityPreferences priority) { struct Session *session; struct SessionMessageEntry *sme; struct SessionMessageEntry *pos; size_t msize; - session = find_session(&car->target); + session = find_session (&car->target); if (NULL == session) return; - msize = ntohs(msg->size); - sme = GNUNET_malloc(sizeof(struct SessionMessageEntry) + msize); - GNUNET_memcpy(&sme[1], msg, msize); + msize = ntohs (msg->size); + sme = GNUNET_malloc (sizeof(struct SessionMessageEntry) + msize); + GNUNET_memcpy (&sme[1], msg, msize); sme->size = msize; sme->priority = priority; if (0 != (GNUNET_MQ_PREF_CORK_ALLOWED & priority)) - { - sme->deadline = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_MAX_CORK_DELAY); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Mesage corked, delaying transmission\n"); - } + { + sme->deadline = + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Mesage corked, delaying transmission\n"); + } pos = session->sme_head; while ((NULL != pos) && (pos->priority >= sme->priority)) pos = pos->next; if (NULL == pos) - GNUNET_CONTAINER_DLL_insert_tail(session->sme_head, - session->sme_tail, - sme); - else - GNUNET_CONTAINER_DLL_insert_after(session->sme_head, + GNUNET_CONTAINER_DLL_insert_tail (session->sme_head, session->sme_tail, - pos->prev, sme); - try_transmission(session); + else + GNUNET_CONTAINER_DLL_insert_after (session->sme_head, + session->sme_tail, + pos->prev, + sme); + try_transmission (session); } @@ -908,54 +912,54 @@ GSC_SESSIONS_transmit(struct GSC_ClientActiveRequest *car, * @param msg typemap update message */ void -GSC_SESSIONS_set_typemap(const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *msg) +GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *msg) { struct Session *session; struct GSC_TypeMap *nmap; struct SessionMessageEntry *sme; struct TypeMapConfirmationMessage *tmc; - nmap = GSC_TYPEMAP_get_from_message(msg); + nmap = GSC_TYPEMAP_get_from_message (msg); if (NULL == nmap) - { - GNUNET_break_op(0); - return; /* malformed */ - } - session = find_session(peer); + { + GNUNET_break_op (0); + return; /* malformed */ + } + session = find_session (peer); if (NULL == session) - { - GSC_TYPEMAP_destroy(nmap); - GNUNET_break(0); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received TYPEMAP from %s\n", - GNUNET_i2s(session->peer)); + { + GSC_TYPEMAP_destroy (nmap); + GNUNET_break (0); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received TYPEMAP from %s\n", + GNUNET_i2s (session->peer)); for (sme = session->sme_head; NULL != sme; sme = sme->next) + { + if (GNUNET_YES == sme->is_typemap_confirm) { - if (GNUNET_YES == sme->is_typemap_confirm) - { - GNUNET_CONTAINER_DLL_remove(session->sme_head, session->sme_tail, sme); - GNUNET_free(sme); - break; - } + GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); + GNUNET_free (sme); + break; } - sme = GNUNET_malloc(sizeof(struct SessionMessageEntry) + - sizeof(struct TypeMapConfirmationMessage)); - sme->deadline = GNUNET_TIME_absolute_get(); + } + sme = GNUNET_malloc (sizeof(struct SessionMessageEntry) + + sizeof(struct TypeMapConfirmationMessage)); + sme->deadline = GNUNET_TIME_absolute_get (); sme->size = sizeof(struct TypeMapConfirmationMessage); sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL; sme->is_typemap_confirm = GNUNET_YES; - tmc = (struct TypeMapConfirmationMessage *)&sme[1]; - tmc->header.size = htons(sizeof(struct TypeMapConfirmationMessage)); - tmc->header.type = htons(GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP); - tmc->reserved = htonl(0); - GSC_TYPEMAP_hash(nmap, &tmc->tm_hash); - GNUNET_CONTAINER_DLL_insert(session->sme_head, session->sme_tail, sme); - try_transmission(session); - GSC_CLIENTS_notify_clients_about_neighbour(peer, session->tmap, nmap); - GSC_TYPEMAP_destroy(session->tmap); + tmc = (struct TypeMapConfirmationMessage *) &sme[1]; + tmc->header.size = htons (sizeof(struct TypeMapConfirmationMessage)); + tmc->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP); + tmc->reserved = htonl (0); + GSC_TYPEMAP_hash (nmap, &tmc->tm_hash); + GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme); + try_transmission (session); + GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap); + GSC_TYPEMAP_destroy (session->tmap); session->tmap = nmap; } @@ -969,21 +973,21 @@ GSC_SESSIONS_set_typemap(const struct GNUNET_PeerIdentity *peer, * @param type type of the message */ void -GSC_SESSIONS_add_to_typemap(const struct GNUNET_PeerIdentity *peer, - uint16_t type) +GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer, + uint16_t type) { struct Session *session; struct GSC_TypeMap *nmap; - if (0 == memcmp(peer, &GSC_my_identity, sizeof(struct GNUNET_PeerIdentity))) + if (0 == memcmp (peer, &GSC_my_identity, sizeof(struct GNUNET_PeerIdentity))) return; - session = find_session(peer); - GNUNET_assert(NULL != session); - if (GNUNET_YES == GSC_TYPEMAP_test_match(session->tmap, &type, 1)) + session = find_session (peer); + GNUNET_assert (NULL != session); + if (GNUNET_YES == GSC_TYPEMAP_test_match (session->tmap, &type, 1)) return; /* already in it */ - nmap = GSC_TYPEMAP_extend(session->tmap, &type, 1); - GSC_CLIENTS_notify_clients_about_neighbour(peer, session->tmap, nmap); - GSC_TYPEMAP_destroy(session->tmap); + nmap = GSC_TYPEMAP_extend (session->tmap, &type, 1); + GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap); + GSC_TYPEMAP_destroy (session->tmap); session->tmap = nmap; } @@ -992,9 +996,9 @@ GSC_SESSIONS_add_to_typemap(const struct GNUNET_PeerIdentity *peer, * Initialize sessions subsystem. */ void -GSC_SESSIONS_init() +GSC_SESSIONS_init () { - sessions = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES); + sessions = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES); } @@ -1008,13 +1012,13 @@ GSC_SESSIONS_init() * @return #GNUNET_OK (continue to iterate) */ static int -free_session_helper(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +free_session_helper (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { /* struct Session *session = value; */ - GSC_SESSIONS_end(key); + GSC_SESSIONS_end (key); return GNUNET_OK; } @@ -1023,16 +1027,16 @@ free_session_helper(void *cls, * Shutdown sessions subsystem. */ void -GSC_SESSIONS_done() +GSC_SESSIONS_done () { if (NULL != sessions) - { - GNUNET_CONTAINER_multipeermap_iterate(sessions, - &free_session_helper, - NULL); - GNUNET_CONTAINER_multipeermap_destroy(sessions); - sessions = NULL; - } + { + GNUNET_CONTAINER_multipeermap_iterate (sessions, + &free_session_helper, + NULL); + GNUNET_CONTAINER_multipeermap_destroy (sessions); + sessions = NULL; + } } /* end of gnunet-service-core_sessions.c */ -- cgit v1.2.3