X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Ftransport_api_address_lookup.c;h=9ae9b403103e99091c15063a53ace8687093fcc5;hb=f181f6eaf8cdb1fdb47dc98cf171ad1be842b441;hp=a760f47750b5f490f0465f693691f71d20e9a1c6;hpb=39589dd2116957e3265c8bd55cf1b9633b1e0b1a;p=oweals%2Fgnunet.git diff --git a/src/transport/transport_api_address_lookup.c b/src/transport/transport_api_address_lookup.c index a760f4775..9ae9b4031 100644 --- a/src/transport/transport_api_address_lookup.c +++ b/src/transport/transport_api_address_lookup.c @@ -17,6 +17,18 @@ Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/** + * @file transport/transport_api_peer_address_lookup.c + * @brief given a peer id, get all known addresses from transport service + * + * This api provides the ability to query the transport service about + * the status of connections to a specific peer. Calls back with a + * pretty printed string of the address, as formatted by the appropriate + * transport plugin, and whether or not the address given is currently + * in the 'connected' state (according to the transport service). + */ + #include "platform.h" #include "gnunet_client_lib.h" #include "gnunet_arm_service.h" @@ -30,12 +42,12 @@ /** * Context for the address lookup. */ -struct GNUNET_TRANSPORT_AddressLookupContext +struct GNUNET_TRANSPORT_PeerIterateContext { /** - * Function to call with the human-readable address. + * Function to call with the binary address. */ - GNUNET_TRANSPORT_AddressLookUpCallback cb; + GNUNET_TRANSPORT_PeerIterateCallback cb; /** * Closure for cb. @@ -57,112 +69,150 @@ struct GNUNET_TRANSPORT_AddressLookupContext /** * Function called with responses from the service. * - * @param cls our 'struct GNUNET_TRANSPORT_AddressLookupContext*' + * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*' * @param msg NULL on timeout or error, otherwise presumably a * message with the human-readable address */ static void -address_response_processor (void *cls, const struct GNUNET_MessageHeader *msg) +peer_address_response_processor (void *cls, + const struct GNUNET_MessageHeader *msg) { - struct GNUNET_TRANSPORT_AddressLookupContext *alucb = cls; - const char *address; + struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx = cls; + struct AddressIterateResponseMessage *air_msg; + struct GNUNET_HELLO_Address *address; + const char *addr; + const char *transport_name; uint16_t size; + size_t alen; + size_t tlen; if (msg == NULL) { - alucb->cb (alucb->cb_cls, NULL); - GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO); - GNUNET_free (alucb); + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); return; } - GNUNET_break (ntohs (msg->type) == - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); size = ntohs (msg->size); + GNUNET_break (ntohs (msg->type) == + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE); if (size == sizeof (struct GNUNET_MessageHeader)) { /* done! */ - alucb->cb (alucb->cb_cls, NULL); - GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO); - GNUNET_free (alucb); + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); + return; + } + + if ((size < + sizeof (struct GNUNET_MessageHeader) + + sizeof (struct AddressIterateResponseMessage)) || + (ntohs (msg->type) != + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE)) + { + GNUNET_break (0); + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); return; } - address = (const char *) &msg[1]; - if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0') + + air_msg = (struct AddressIterateResponseMessage *) msg; + tlen = ntohl (air_msg->pluginlen); + alen = ntohl (air_msg->addrlen); + + if (size != sizeof (struct AddressIterateResponseMessage) + tlen + alen) { - /* invalid reply */ GNUNET_break (0); - alucb->cb (alucb->cb_cls, NULL); - GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO); - GNUNET_free (alucb); + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); + return; + } + + addr = (const char *) &air_msg[1]; + transport_name = &addr[alen]; + + if (transport_name[tlen - 1] != '\0') + { + GNUNET_break_op (0); + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); return; } + /* expect more replies */ - GNUNET_CLIENT_receive (alucb->client, &address_response_processor, alucb, - GNUNET_TIME_absolute_get_remaining (alucb->timeout)); - alucb->cb (alucb->cb_cls, address); + GNUNET_CLIENT_receive (pal_ctx->client, &peer_address_response_processor, + pal_ctx, + GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout)); + + /* notify client */ + address = + GNUNET_HELLO_address_allocate (&air_msg->peer, transport_name, addr, + alen); + pal_ctx->cb (pal_ctx->cb_cls, &air_msg->peer, address); + GNUNET_HELLO_address_free (address); } /** - * Convert a binary address into a human readable address. + * Return all the known addresses for a specific peer or all peers. + * Returns continously all address if one_shot is set to GNUNET_NO + * + * CHANGE: Returns the address(es) that we are currently using for this + * peer. Upon completion, the 'AddressLookUpCallback' is called one more + * time with 'NULL' for the address and the peer. After this, the operation must no + * longer be explicitly cancelled. * * @param cfg configuration to use - * @param address address to convert (binary format) - * @param addressLen number of bytes in address - * @param numeric should (IP) addresses be displayed in numeric form - * (otherwise do reverse DNS lookup) - * @param nameTrans name of the transport to which the address belongs + * @param peer peer identity to look up the addresses of, CHANGE: allow NULL for all (connected) peers + * @param one_shot GNUNET_YES to return the current state and then end (with NULL+NULL), + * GNUNET_NO to monitor the set of addresses used (continuously, must be explicitly cancelled) * @param timeout how long is the lookup allowed to take at most - * @param aluc function to call with the results - * @param aluc_cls closure for aluc - * @return handle to cancel the operation, NULL on error + * @param peer_address_callback function to call with the results + * @param peer_address_callback_cls closure for peer_address_callback */ -struct GNUNET_TRANSPORT_AddressLookupContext * -GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg, - const char *address, size_t addressLen, - int numeric, const char *nameTrans, - struct GNUNET_TIME_Relative timeout, - GNUNET_TRANSPORT_AddressLookUpCallback aluc, - void *aluc_cls) +struct GNUNET_TRANSPORT_PeerIterateContext * +GNUNET_TRANSPORT_peer_get_active_addresses (const struct + GNUNET_CONFIGURATION_Handle *cfg, + const struct GNUNET_PeerIdentity + *peer, int one_shot, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_PeerIterateCallback + peer_address_callback, + void *peer_address_callback_cls) { - size_t slen; - size_t len; - struct AddressLookupMessage *msg; - struct GNUNET_TRANSPORT_AddressLookupContext *alc; + struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx; + struct AddressIterateMessage msg; struct GNUNET_CLIENT_Connection *client; - char *addrbuf; + struct GNUNET_TIME_Absolute abs_timeout; - slen = strlen (nameTrans) + 1; - len = sizeof (struct AddressLookupMessage) + addressLen + slen; - if (len >= GNUNET_SERVER_MAX_MESSAGE_SIZE) + if (GNUNET_YES != one_shot) { - GNUNET_break (0); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Address monitoring not implemented\n"); return NULL; } client = GNUNET_CLIENT_connect ("transport", cfg); - if (client == NULL) - return NULL; - msg = GNUNET_malloc (len); - msg->header.size = htons (len); - msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP); - msg->numeric_only = htonl (numeric); - msg->timeout = GNUNET_TIME_relative_hton (timeout); - msg->addrlen = htonl (addressLen); - addrbuf = (char *) &msg[1]; - memcpy (addrbuf, address, addressLen); - memcpy (&addrbuf[addressLen], nameTrans, slen); - alc = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_AddressLookupContext)); - alc->cb = aluc; - alc->cb_cls = aluc_cls; - alc->timeout = GNUNET_TIME_relative_to_absolute (timeout); - alc->client = client; + if (client == NULL) + return NULL; + abs_timeout = GNUNET_TIME_relative_to_absolute (timeout); + msg.header.size = htons (sizeof (struct AddressIterateMessage)); + msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE); + msg.one_shot = htonl (one_shot); + msg.timeout = GNUNET_TIME_absolute_hton (abs_timeout); + if (peer == NULL) + memset (&msg.peer, 0, sizeof (struct GNUNET_PeerIdentity)); + else + msg.peer = *peer; + pal_ctx = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PeerIterateContext)); + pal_ctx->cb = peer_address_callback; + pal_ctx->cb_cls = peer_address_callback_cls; + pal_ctx->timeout = abs_timeout; + pal_ctx->client = client; GNUNET_assert (GNUNET_OK == - GNUNET_CLIENT_transmit_and_get_response (client, &msg->header, + GNUNET_CLIENT_transmit_and_get_response (client, &msg.header, timeout, GNUNET_YES, - &address_response_processor, - alc)); - GNUNET_free (msg); - return alc; + &peer_address_response_processor, + pal_ctx)); + return pal_ctx; } @@ -172,12 +222,13 @@ GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg, * @param alc handle for the request to cancel */ void -GNUNET_TRANSPORT_address_lookup_cancel (struct GNUNET_TRANSPORT_AddressLookupContext *alc) +GNUNET_TRANSPORT_peer_get_active_addresses_cancel (struct + GNUNET_TRANSPORT_PeerIterateContext + *alc) { GNUNET_CLIENT_disconnect (alc->client, GNUNET_NO); GNUNET_free (alc); } - -/* end of transport_api_address_lookup.c */ +/* end of transport_api_peer_address_lookup.c */