From 5335dcda0678ce5bcb06b6f4d90dc12ea9ba54aa Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Thu, 13 Oct 2011 13:15:59 +0000 Subject: [PATCH] sapi implemented --- src/ats/ats.h | 2 +- src/ats/ats_api_new.c | 473 ++++++++++++++++++++++++++++++++-- src/ats/ats_api_performance.c | 12 +- 3 files changed, 464 insertions(+), 23 deletions(-) diff --git a/src/ats/ats.h b/src/ats/ats.h index 317528cad..062ceffab 100644 --- a/src/ats/ats.h +++ b/src/ats/ats.h @@ -42,7 +42,7 @@ enum StartFlag -struct ClientStart +struct ClientStartMessage { struct GNUNET_MessageHeader header; diff --git a/src/ats/ats_api_new.c b/src/ats/ats_api_new.c index dc06d901d..d379edd77 100644 --- a/src/ats/ats_api_new.c +++ b/src/ats/ats_api_new.c @@ -18,13 +18,43 @@ Boston, MA 02111-1307, USA. */ /** - * @file include/gnunet_ats_service.h + * @file ats/ats_api_scheduling.c * @brief automatic transport selection and outbound bandwidth determination * @author Christian Grothoff * @author Matthias Wachs */ #include "platform.h" #include "gnunet_ats_service.h" +#include "ats.h" + + +/** + * Message in linked list we should send to the ATS service. The + * actual binary message follows this struct. + */ +struct PendingMessage +{ + + /** + * Kept in a DLL. + */ + struct PendingMessage *next; + + /** + * Kept in a DLL. + */ + struct PendingMessage *prev; + + /** + * Size of the message. + */ + size_t size; + + /** + * Is this the 'ATS_START' message? + */ + int is_init; +}; /** @@ -32,34 +62,355 @@ */ struct GNUNET_ATS_SchedulingHandle { + + /** + * Our configuration. + */ + const struct GNUNET_CONFIGURATION_Handle *cfg; + + /** + * Callback to invoke on suggestions. + */ + GNUNET_ATS_AddressSuggestionCallback suggest_cb; + + /** + * Closure for 'suggest_cb'. + */ + void *suggest_cb_cls; + + /** + * Connection to ATS service. + */ + struct GNUNET_CLIENT_Connection *client; + + /** + * Head of list of messages for the ATS service. + */ + struct PendingMessage *pending_head; + + /** + * Tail of list of messages for the ATS service + */ + struct PendingMessage *pending_tail; + + /** + * Current request for transmission to ATS. + */ + struct GNUNET_CLIENT_TransmitHandle *th; + + /** + * Array of session objects (we need to translate them to numbers and back + * for the protocol; the offset in the array is the session number on the + * network). Index 0 is always NULL and reserved to represent the NULL pointer. + * Unused entries are also NULL. + */ + struct Session **session_array; + + /** + * Size of the session array. + */ + unsigned int session_array_size; + }; +/** + * Re-establish the connection to the ATS service. + * + * @param sh handle to use to re-connect. + */ +static void +reconnect (struct GNUNET_ATS_SchedulingHandle *sh); + + +/** + * Transmit messages from the message queue to the service + * (if there are any, and if we are not already trying). + * + * @param sh handle to use + */ +static void +do_transmit (struct GNUNET_ATS_SchedulingHandle *sh); + + +/** + * We can now transmit a message to ATS. Do it. + * + * @param cls the 'struct GNUNET_ATS_SchedulingHandle' + * @param size number of bytes we can transmit to ATS + * @param buf where to copy the messages + * @return number of bytes copied into buf + */ +static size_t +transmit_message_to_ats (void *cls, + size_t size, + void *buf) +{ + struct GNUNET_ATS_SchedulingHandle *sh = cls; + struct PendingMessage *p; + size_t ret; + char *cbuf; + + sh->th = NULL; + ret = 0; + cbuf = buf; + while ( (NULL != (p = sh->pending_head)) && + (p->size <= size) ) + { + memcpy (&cbuf[ret], &p[1], p->size); + ret += p->size; + GNUNET_CONTAINER_DLL_remove (sh->pending_head, + sh->pending_tail, + p); + GNUNET_free (p); + } + do_transmit (sh); + return ret; +} + + +/** + * Transmit messages from the message queue to the service + * (if there are any, and if we are not already trying). + * + * @param sh handle to use + */ +static void +do_transmit (struct GNUNET_ATS_SchedulingHandle *sh) +{ + struct PendingMessage *p; + + if (NULL != sh->th) + return; + if (NULL == (p = sh->pending_head)) + return; + sh->th = GNUNET_CLIENT_notify_transmit_ready (sh->client, + p->size, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_YES, + &transmit_message_to_ats, sh); +} + + +/** + * Find the session object corresponding to the given session ID. + * + * @param sh our handle + * @param session_id current session ID + * @return the session object (or NULL) + */ +static struct Session* +find_session (struct GNUNET_ATS_SchedulingHandle *sh, + uint32_t session_id) +{ + if (session_id >= sh->session_array_size) + { + GNUNET_break (0); + return NULL; + } + return sh->session_array[session_id]; +} + + +/** + * Get the ID for the given session object. If we do not have an ID for + * the given session object, allocate one. + * + * @param sh our handle + * @param session session object + * @return the session id + */ +static uint32_t +get_session_id (struct GNUNET_ATS_SchedulingHandle *sh, + struct Session *session) +{ + unsigned int i; + unsigned int f; + + f = 0; + for (i=1;isession_array_size;i++) + { + if (session == sh->session_array[i]) + return i; + if ( (f == 0) && + (sh->session_array[i] == NULL) ) + f = i; + } + if (f == 0) + { + f = sh->session_array_size; + GNUNET_array_grow (sh->session_array, + sh->session_array_size, + sh->session_array_size * 2); + } + sh->session_array[f] = session; + return f; +} + + +/** + * Remove the session of the given session ID from the session + * table (it is no longer valid). + * + * @param sh our handle + * @param session_id identifies session that is no longer valid + */ +static void +remove_session (struct GNUNET_ATS_SchedulingHandle *sh, + uint32_t session_id) +{ + GNUNET_assert (session_id < sh->session_array_size); + sh->session_array[session_id] = NULL; +} + + +/** + * Type of a function to call when we receive a message + * from the service. + * + * @param cls the 'struct GNUNET_ATS_SchedulingHandle' + * @param msg message received, NULL on timeout or fatal error + */ +static void +process_ats_message (void *cls, + const struct GNUNET_MessageHeader *msg) +{ + struct GNUNET_ATS_SchedulingHandle *sh = cls; + const struct AddressSuggestionMessage *m; + const char *address; + const char *plugin_name; + uint16_t address_length; + + if (NULL == msg) + { + GNUNET_CLIENT_disconnect (sh->client, GNUNET_NO); + sh->client = NULL; + reconnect (sh); + return; + } + if ( (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION) || + (ntohs (msg->size) <= sizeof (struct AddressSuggestionMessage)) ) + { + GNUNET_break (0); + GNUNET_CLIENT_disconnect (sh->client, GNUNET_NO); + sh->client = NULL; + reconnect (sh); + return; + } + m = (const struct AddressSuggestionMessage*) msg; + address = (const char*) &m[1]; + address_length = ntohs (m->address_length); + plugin_name = &address[address_length]; + GNUNET_break (0 == ntohl (m->reserved)); + if ( (ntohs (m->address_length) + + ntohs (m->plugin_name_length) + + sizeof (struct AddressSuggestionMessage) != ntohs (msg->size)) || + (plugin_name[ntohs (m->plugin_name_length) - 1] != '\0') ) + { + GNUNET_break (0); + GNUNET_CLIENT_disconnect (sh->client, GNUNET_NO); + sh->client = NULL; + reconnect (sh); + return; + } + sh->suggest_cb (sh->suggest_cb_cls, + &m->peer, + plugin_name, + address, address_length, + find_session (sh, ntohl (m->session_id)), + m->bandwidth_out, + m->bandwidth_in); + GNUNET_CLIENT_receive (sh->client, + &process_ats_message, sh, + GNUNET_TIME_UNIT_FOREVER_REL); +} + + +/** + * Re-establish the connection to the ATS service. + * + * @param sh handle to use to re-connect. + */ +static void +reconnect (struct GNUNET_ATS_SchedulingHandle *sh) +{ + struct PendingMessage *p; + struct ClientStartMessage *init; + + GNUNET_assert (NULL == sh->client); + sh->client = GNUNET_CLIENT_connect ("ats", sh->cfg); + GNUNET_assert (NULL != sh->client); + GNUNET_CLIENT_receive (sh->client, + &process_ats_message, sh, + GNUNET_TIME_UNIT_FOREVER_REL); + if ( (NULL == (p = sh->pending_head)) || + (GNUNET_YES != p->is_init) ) + { + p = GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct ClientStartMessage)); + p->size = sizeof (struct ClientStartMessage); + p->is_init = GNUNET_YES; + init = (struct ClientStartMessage *) &p[1]; + init->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_START); + init->header.size = htons (sizeof (struct ClientStartMessage)); + init->start_flag = htonl (START_FLAG_SCHEDULING); + GNUNET_CONTAINER_DLL_insert (sh->pending_head, + sh->pending_tail, + p); + } + do_transmit (sh); +} + + /** * Initialize the ATS subsystem. * * @param cfg configuration to use - * @param alloc_cb notification to call whenever the allocation changed - * @param alloc_cb_cls closure for 'alloc_cb' + * @param suggest_cb notification to call whenever the suggestation changed + * @param suggest_cb_cls closure for 'suggest_cb' * @return ats context */ struct GNUNET_ATS_SchedulingHandle * GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_ATS_AddressSuggestionCallback alloc_cb, - void *alloc_cb_cls) + GNUNET_ATS_AddressSuggestionCallback suggest_cb, + void *suggest_cb_cls) { - return NULL; + struct GNUNET_ATS_SchedulingHandle *sh; + + sh = GNUNET_malloc (sizeof (struct GNUNET_ATS_SchedulingHandle)); + sh->cfg = cfg; + sh->suggest_cb = suggest_cb; + sh->suggest_cb_cls = suggest_cb_cls; + GNUNET_array_grow (sh->session_array, + sh->session_array_size, + 4); + reconnect (sh); + return sh; } /** * Client is done with ATS scheduling, release resources. * - * @param atc handle to release + * @param sh handle to release */ void -GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *atc) +GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh) { + struct PendingMessage *p; + + while (NULL != (p = sh->pending_head)) + { + GNUNET_CONTAINER_DLL_remove (sh->pending_head, + sh->pending_tail, + p); + GNUNET_free (p); + } + GNUNET_CLIENT_disconnect (sh->client, GNUNET_NO); + GNUNET_array_grow (sh->session_array, + sh->session_array_size, + 0); + GNUNET_free (sh); } @@ -67,13 +418,29 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *atc) * We would like to establish a new connection with a peer. ATS * should suggest a good address to begin with. * - * @param atc handle + * @param sh handle * @param peer identity of the peer we need an address for */ void -GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *atc, +GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_PeerIdentity *peer) { + struct PendingMessage *p; + struct RequestAddressMessage *m; + + p = GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct RequestAddressMessage)); + p->size = sizeof (struct RequestAddressMessage); + p->is_init = GNUNET_NO; + m = (struct RequestAddressMessage*) &p[1]; + m->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS); + m->header.size = htons (sizeof (struct RequestAddressMessage)); + m->reserved = htonl (0); + m->peer = *peer; + GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, + sh->pending_tail, + p); + do_transmit (sh); } @@ -85,7 +452,7 @@ GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *atc, * which case the call may be ignored or the information may be stored * for later use). Update bandwidth assignments. * - * @param atc handle + * @param sh handle * @param peer identity of the new peer * @param plugin_name name of the transport plugin * @param plugin_addr address (if available) @@ -95,7 +462,7 @@ GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *atc, * @param ats_count number of performance records in 'ats' */ void -GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *atc, +GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, @@ -103,13 +470,51 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *atc, const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count) { + struct PendingMessage *p; + struct AddressUpdateMessage *m; + struct GNUNET_TRANSPORT_ATS_Information *am; + char *pm; + size_t namelen; + size_t msize; + + namelen = (plugin_name == NULL) ? 0 : strlen (plugin_name) + 1; + msize = sizeof (struct AddressUpdateMessage) + plugin_addr_len + + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) + namelen; + if ( (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || + (plugin_addr_len >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || + (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || + (ats_count >= GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ) + { + GNUNET_break (0); + return; + } + p = GNUNET_malloc (sizeof (struct PendingMessage) + msize); + p->size = msize; + p->is_init = GNUNET_NO; + m = (struct AddressUpdateMessage*) &p[1]; + m->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE); + m->header.size = htons (msize); + m->ats_count = htonl (ats_count); + m->peer = *peer; + m->address_length = htons (plugin_addr_len); + m->plugin_name_length = htons (namelen); + m->session_id = htonl (get_session_id (sh, session)); + am = (struct GNUNET_TRANSPORT_ATS_Information*) &m[1]; + memcpy (am, ats, ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)); + pm = (char *) &am[ats_count]; + memcpy (pm, plugin_addr, plugin_addr_len); + memcpy (&pm[plugin_addr_len], plugin_name, namelen); + GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, + sh->pending_tail, + p); + do_transmit (sh); } /** * A session got destroyed, stop including it as a valid address. * - * @param atc handle + * @param sh handle * @param peer identity of the peer * @param plugin_name name of the transport plugin * @param plugin_addr address (if available) @@ -117,13 +522,49 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *atc, * @param session session handle that is no longer valid */ void -GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *atc, +GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, - const struct Session *session) + struct Session *session) { + struct PendingMessage *p; + struct AddressDestroyedMessage *m; + char *pm; + size_t namelen; + size_t msize; + uint32_t session_id; + + namelen = (plugin_name == NULL) ? 0 : strlen (plugin_name) + 1; + msize = sizeof (struct AddressUpdateMessage) + plugin_addr_len + + namelen; + if ( (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || + (plugin_addr_len >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || + (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ) + { + GNUNET_break (0); + return; + } + p = GNUNET_malloc (sizeof (struct PendingMessage) + msize); + p->size = msize; + p->is_init = GNUNET_NO; + m = (struct AddressDestroyedMessage*) &p[1]; + m->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED); + m->header.size = htons (msize); + m->reserved = htonl (0); + m->peer = *peer; + m->address_length = htons (plugin_addr_len); + m->plugin_name_length = htons (namelen); + m->session_id = htonl (session_id = get_session_id (sh, session)); + pm = (char *) &m[1]; + memcpy (pm, plugin_addr, plugin_addr_len); + memcpy (&pm[plugin_addr_len], plugin_name, namelen); + GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, + sh->pending_tail, + p); + do_transmit (sh); + remove_session (sh, session_id); } -/* end of ats_api_new.c */ +/* end of ats_api_scheduling.c */ diff --git a/src/ats/ats_api_performance.c b/src/ats/ats_api_performance.c index 0b0bd1042..e23c9bdf3 100644 --- a/src/ats/ats_api_performance.c +++ b/src/ats/ats_api_performance.c @@ -56,10 +56,10 @@ GNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg, /** * Client is done using the ATS performance subsystem, release resources. * - * @param atc handle + * @param ph handle */ void -GNUNET_ATS_performance_done (struct GNUNET_ATS_SchedulingHandle *atc) +GNUNET_ATS_performance_done (struct GNUNET_ATS_SchedulingHandle *ph) { } @@ -77,7 +77,7 @@ struct GNUNET_ATS_ReservationContext * the current amount of traffic we receive from the peer and ensure * that the peer could add 'amount' of data to its stream. * - * @param h core handle + * @param ph performance handle * @param peer identifies the peer * @param amount reserve N bytes for receiving, negative * amounts can be used to undo a (recent) reservation; @@ -87,7 +87,7 @@ struct GNUNET_ATS_ReservationContext * @deprecated will be replaced soon */ struct GNUNET_ATS_ReservationContext * -GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *h, +GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback info, @@ -113,12 +113,12 @@ GNUNET_ATS_reserve_bandwidth_cancel (struct * Change preferences for the given peer. Preference changes are forgotten if peers * disconnect. * - * @param cls closure + * @param ph performance handle * @param peer identifies the peer * @param ... 0-terminated specification of the desired changes */ void -GNUNET_ATS_change_preference (struct GNUNET_ATS_PerformanceHandle *h, +GNUNET_ATS_change_preference (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, ...) { -- 2.25.1