src/transport/transport_api_address_lookup.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file transport/transport_api_peer_address_lookup.c
  23  * @brief given a peer id, get all known addresses from transport service
  24  *
  25  * This api provides the ability to query the transport service about
  26  * the status of connections to a specific peer.  Calls back with a
  27  * pretty printed string of the address, as formatted by the appropriate
  28  * transport plugin, and whether or not the address given is currently
  29  * in the 'connected' state (according to the transport service).
  30  */
  31
  32 #include "platform.h"
  33 #include "gnunet_client_lib.h"
  34 #include "gnunet_arm_service.h"
  35 #include "gnunet_hello_lib.h"
  36 #include "gnunet_protocols.h"
  37 #include "gnunet_server_lib.h"
  38 #include "gnunet_time_lib.h"
  39 #include "gnunet_transport_service.h"
  40 #include "transport.h"
  41
  42 /**
  43  * Context for the address lookup.
  44  */
  45 struct GNUNET_TRANSPORT_PeerIterateContext
  46 {
  47   /**
  48    * Function to call with the binary address.
  49    */
  50   GNUNET_TRANSPORT_PeerIterateCallback cb;
  51
  52   /**
  53    * Closure for cb.
  54    */
  55   void *cb_cls;
  56
  57   /**
  58    * Connection to the service.
  59    */
  60   struct GNUNET_CLIENT_Connection *client;
  61
  62   /**
  63    * When should this operation time out?
  64    */
  65   struct GNUNET_TIME_Absolute timeout;
  66 };
  67
  68
  69 /**
  70  * Function called with responses from the service.
  71  *
  72  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
  73  * @param msg NULL on timeout or error, otherwise presumably a
  74  *        message with the human-readable address
  75  */
  76 static void
  77 peer_address_response_processor (void *cls,
  78                                  const struct GNUNET_MessageHeader *msg)
  79 {
  80   struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx = cls;
  81   struct AddressIterateResponseMessage *air_msg;
  82   struct GNUNET_HELLO_Address *address;
  83   const char *addr;
  84   const char *transport_name;
  85   uint16_t size;
  86   size_t alen;
  87   size_t tlen;
  88
  89   if (msg == NULL)
  90   {
  91     pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
  92     GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
  93     return;
  94   }
  95   size = ntohs (msg->size);
  96   GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE);
  97   if (size == sizeof (struct GNUNET_MessageHeader))
  98   {
  99     /* done! */
 100     pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
 101     GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
 102     return;
 103   }
 104
 105   if ( (size < sizeof (struct GNUNET_MessageHeader) + sizeof (struct AddressIterateResponseMessage)) ||
 106        (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE) )
 107   {
 108     GNUNET_break (0);
 109     pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
 110     GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
 111     return;
 112   }
 113
 114   air_msg = (struct AddressIterateResponseMessage *) msg;
 115   tlen = ntohl(air_msg->pluginlen);
 116   alen = ntohl(air_msg->addrlen);
 117
 118   if (size != sizeof (struct AddressIterateResponseMessage) + tlen + alen)
 119   {
 120     GNUNET_break (0);
 121     pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
 122     GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
 123     return;
 124   }
 125
 126   addr = (const char *) &air_msg[1];
 127   transport_name = &addr[alen];
 128
 129   if (transport_name[tlen-1] != '\0')
 130   {
 131     GNUNET_break_op (0);
 132     pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
 133     GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
 134     return;
 135   }
 136
 137   /* expect more replies */
 138   GNUNET_CLIENT_receive (pal_ctx->client,
 139                          &peer_address_response_processor, pal_ctx,
 140                          GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout));
 141
 142   /* notify client */
 143   address = GNUNET_HELLO_address_allocate (&air_msg->peer,
 144                                            transport_name, addr, alen);
 145   pal_ctx->cb (pal_ctx->cb_cls, &air_msg->peer, address);
 146   GNUNET_HELLO_address_free (address);
 147 }
 148
 149
 150 /**
 151  * Return all the known addresses for a specific peer or all peers.
 152  * Returns continously all address if one_shot is set to GNUNET_NO
 153  *
 154  * CHANGE: Returns the address(es) that we are currently using for this
 155  * peer.  Upon completion, the 'AddressLookUpCallback' is called one more
 156  * time with 'NULL' for the address and the peer.  After this, the operation must no
 157  * longer be explicitly cancelled.
 158  *
 159  * @param cfg configuration to use
 160  * @param peer peer identity to look up the addresses of, CHANGE: allow NULL for all (connected) peers
 161  * @param one_shot GNUNET_YES to return the current state and then end (with NULL+NULL),
 162  *                 GNUNET_NO to monitor the set of addresses used (continuously, must be explicitly cancelled)
 163  * @param timeout how long is the lookup allowed to take at most
 164  * @param peer_address_callback function to call with the results
 165  * @param peer_address_callback_cls closure for peer_address_callback
 166  */
 167 struct GNUNET_TRANSPORT_PeerIterateContext *
 168 GNUNET_TRANSPORT_peer_get_active_addresses (const struct GNUNET_CONFIGURATION_Handle *cfg,
 169                                             const struct GNUNET_PeerIdentity *peer,
 170                                             int one_shot,
 171                                             struct GNUNET_TIME_Relative timeout,
 172                                             GNUNET_TRANSPORT_PeerIterateCallback peer_address_callback,
 173                                             void *peer_address_callback_cls)
 174 {
 175   struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx;
 176   struct AddressIterateMessage msg;
 177   struct GNUNET_CLIENT_Connection *client;
 178   struct GNUNET_TIME_Absolute abs_timeout;
 179
 180   if (GNUNET_YES != one_shot)
 181   {
 182     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 183                 "Address monitoring not implemented\n");
 184     return NULL;
 185   }
 186   client = GNUNET_CLIENT_connect ("transport", cfg);
 187   if (client == NULL)
 188     return NULL;
 189   abs_timeout = GNUNET_TIME_relative_to_absolute (timeout);
 190   msg.header.size = htons (sizeof (struct AddressIterateMessage));
 191   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE);
 192   msg.one_shot = htonl (one_shot);
 193   msg.timeout = GNUNET_TIME_absolute_hton (abs_timeout);
 194   if (peer == NULL)
 195    memset (&msg.peer, 0 , sizeof (struct GNUNET_PeerIdentity));
 196   else
 197     msg.peer = *peer;
 198   pal_ctx = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PeerIterateContext));
 199   pal_ctx->cb = peer_address_callback;
 200   pal_ctx->cb_cls = peer_address_callback_cls;
 201   pal_ctx->timeout = abs_timeout;
 202   pal_ctx->client = client;
 203   GNUNET_assert (GNUNET_OK ==
 204                  GNUNET_CLIENT_transmit_and_get_response (client, &msg.header,
 205                                                           timeout, GNUNET_YES,
 206                                                           &peer_address_response_processor,
 207                                                           pal_ctx));
 208   return pal_ctx;
 209 }
 210
 211
 212 /**
 213  * Cancel request for address conversion.
 214  *
 215  * @param alc handle for the request to cancel
 216  */
 217 void
 218 GNUNET_TRANSPORT_peer_get_active_addresses_cancel (struct
 219                                              GNUNET_TRANSPORT_PeerIterateContext
 220                                              *alc)
 221 {
 222   GNUNET_CLIENT_disconnect (alc->client, GNUNET_NO);
 223   GNUNET_free (alc);
 224 }
 225
 226
 227 /* end of transport_api_peer_address_lookup.c */