X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Ftransport_api_address_lookup.c;h=9ae9b403103e99091c15063a53ace8687093fcc5;hb=f181f6eaf8cdb1fdb47dc98cf171ad1be842b441;hp=cd2e735843e9a6347277acf10fff0cd91607a0b2;hpb=afa1480d98bca6d9a6d388e464080c231b4cfc1f;p=oweals%2Fgnunet.git diff --git a/src/transport/transport_api_address_lookup.c b/src/transport/transport_api_address_lookup.c index cd2e73584..9ae9b4031 100644 --- a/src/transport/transport_api_address_lookup.c +++ b/src/transport/transport_api_address_lookup.c @@ -4,7 +4,7 @@ GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 2, or (at your + by the Free Software Foundation; either version 3, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but @@ -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" @@ -29,13 +41,13 @@ /** * Context for the address lookup. - */ -struct AddressLookupCtx + */ +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,123 +69,166 @@ struct AddressLookupCtx /** * Function called with responses from the service. * - * @param cls our 'struct AddressLookupCtx*' + * @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 AddressLookupCtx *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); - return; - } - GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); + { + pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL); + GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx); + return; + } 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); - return; - } - address = (const char *) &msg[1]; - if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0') - { - /* invalid reply */ - GNUNET_break (0); - alucb->cb (alucb->cb_cls, NULL); - GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO); - GNUNET_free (alucb); - return; - } + { + /* done! */ + 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; + } + + air_msg = (struct AddressIterateResponseMessage *) msg; + tlen = ntohl (air_msg->pluginlen); + alen = ntohl (air_msg->addrlen); + + if (size != sizeof (struct AddressIterateResponseMessage) + tlen + alen) + { + GNUNET_break (0); + 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 sched scheduler to use * @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 + * @param peer_address_callback function to call with the results + * @param peer_address_callback_cls closure for peer_address_callback */ -void -GNUNET_TRANSPORT_address_lookup (struct GNUNET_SCHEDULER_Handle *sched, - 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_TIME_Absolute abs_timeout; - struct AddressLookupCtx *aluCB; + struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx; + struct AddressIterateMessage msg; struct GNUNET_CLIENT_Connection *client; - char *addrbuf; - - slen = strlen (nameTrans) + 1; - len = sizeof (struct AddressLookupMessage) + addressLen + slen; - if (len >= GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - GNUNET_break (0); - aluc (aluc_cls, NULL); - return; - } - client = GNUNET_CLIENT_connect (sched, "transport", cfg); + struct GNUNET_TIME_Absolute abs_timeout; + + if (GNUNET_YES != one_shot) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Address monitoring not implemented\n"); + return NULL; + } + client = GNUNET_CLIENT_connect ("transport", cfg); if (client == NULL) - { - aluc (aluc_cls, NULL); - return; - } + return NULL; abs_timeout = GNUNET_TIME_relative_to_absolute (timeout); - 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_absolute_hton (abs_timeout); - msg->addrlen = htonl (addressLen); - addrbuf = (char *) &msg[1]; - memcpy (addrbuf, address, addressLen); - memcpy (&addrbuf[addressLen], nameTrans, slen); - aluCB = GNUNET_malloc (sizeof (struct AddressLookupCtx)); - aluCB->cb = aluc; - aluCB->cb_cls = aluc_cls; - aluCB->timeout = abs_timeout; - aluCB->client = client; - GNUNET_CLIENT_transmit_and_get_response (client, - &msg->header, - timeout, - GNUNET_YES, - &address_response_processor, - aluCB); - GNUNET_free (msg); + 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, + timeout, GNUNET_YES, + &peer_address_response_processor, + pal_ctx)); + return pal_ctx; } -/* end of transport_api_address_lookup.c */ + +/** + * Cancel request for address conversion. + * + * @param alc handle for the request to cancel + */ +void +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_peer_address_lookup.c */