use enum GNUNET_ATS_Network_Type instead of uint32_t where appropriate
[oweals/gnunet.git] / 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_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 #include "platform.h"
32 #include "gnunet_util_lib.h"
33 #include "gnunet_arm_service.h"
34 #include "gnunet_hello_lib.h"
35 #include "gnunet_protocols.h"
36 #include "gnunet_transport_service.h"
37 #include "transport.h"
38
39 /**
40  * Context for the address lookup.
41  */
42 struct GNUNET_TRANSPORT_PeerIterateContext
43 {
44   /**
45    * Function to call with the binary address.
46    */
47   GNUNET_TRANSPORT_PeerIterateCallback cb;
48
49   /**
50    * Closure for cb.
51    */
52   void *cb_cls;
53
54   /**
55    * Connection to the service.
56    */
57   struct GNUNET_CLIENT_Connection *client;
58
59   /**
60    * Configuration we use.
61    */
62   const struct GNUNET_CONFIGURATION_Handle *cfg;
63
64   /**
65    * When should this operation time out?
66    */
67   struct GNUNET_TIME_Absolute timeout;
68
69   /**
70    * Backoff for reconnect.
71    */
72   struct GNUNET_TIME_Relative backoff;
73
74   /**
75    * Task ID for reconnect.
76    */
77   GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
78
79   /**
80    * Identity of the peer to monitor.
81    */
82   struct GNUNET_PeerIdentity peer;
83
84   /**
85    * Was this a one-shot request?
86    */
87   int one_shot;
88 };
89
90
91 /**
92  * Function called with responses from the service.
93  *
94  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
95  * @param msg NULL on timeout or error, otherwise presumably a
96  *        message with the human-readable address
97  */
98 static void
99 peer_address_response_processor (void *cls,
100                                  const struct GNUNET_MessageHeader *msg);
101
102
103 /**
104  * Send our subscription request to the service.
105  *
106  * @param pal_ctx our context
107  */
108 static void
109 send_request (struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx)
110 {
111   struct AddressIterateMessage msg;
112
113   msg.header.size = htons (sizeof (struct AddressIterateMessage));
114   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE);
115   msg.one_shot = htonl (pal_ctx->one_shot);
116   msg.timeout = GNUNET_TIME_absolute_hton (pal_ctx->timeout);
117   msg.peer = pal_ctx->peer;
118   GNUNET_assert (GNUNET_OK ==
119                  GNUNET_CLIENT_transmit_and_get_response (pal_ctx->client,
120                                                           &msg.header,
121                                                           GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout),
122                                                           GNUNET_YES,
123                                                           &peer_address_response_processor,
124                                                           pal_ctx));
125 }
126
127 /**
128  * Task run to re-establish the connection.
129  *
130  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
131  * @param tc scheduler context, unused
132  */
133 static void
134 do_connect (void *cls,
135             const struct GNUNET_SCHEDULER_TaskContext *tc)
136 {
137   struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx = cls;
138
139   pal_ctx->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
140   pal_ctx->client = GNUNET_CLIENT_connect ("transport", pal_ctx->cfg);
141   GNUNET_assert (NULL != pal_ctx->client);
142   send_request (pal_ctx);
143 }
144
145
146 /**
147  * Cut the existing connection and reconnect.
148  *
149  * @param pal_ctx our context
150  */
151 static void
152 reconnect (struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx)
153 {
154   GNUNET_assert (GNUNET_NO == pal_ctx->one_shot);
155   GNUNET_CLIENT_disconnect (pal_ctx->client);
156   pal_ctx->client = NULL;
157   pal_ctx->backoff = GNUNET_TIME_STD_BACKOFF (pal_ctx->backoff);
158   pal_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (pal_ctx->backoff,
159                                                           &do_connect,
160                                                           pal_ctx);
161 }
162
163
164 /**
165  * Function called with responses from the service.
166  *
167  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
168  * @param msg NULL on timeout or error, otherwise presumably a
169  *        message with the human-readable address
170  */
171 static void
172 peer_address_response_processor (void *cls,
173                                  const struct GNUNET_MessageHeader *msg)
174 {
175   struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx = cls;
176   struct AddressIterateResponseMessage *air_msg;
177   struct GNUNET_HELLO_Address *address;
178   const char *addr;
179   const char *transport_name;
180   uint16_t size;
181   size_t alen;
182   size_t tlen;
183
184   if (msg == NULL)
185   {
186     if (pal_ctx->one_shot)
187     {
188       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
189       GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
190     }
191     else
192     {
193       reconnect (pal_ctx);
194     }
195     return;
196   }
197   size = ntohs (msg->size);
198   GNUNET_break (ntohs (msg->type) ==
199                 GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE);
200   if (size == sizeof (struct GNUNET_MessageHeader))
201   {
202     /* done! */
203     if (pal_ctx->one_shot)
204     {
205       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
206       GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
207     }
208     else
209     {
210       reconnect (pal_ctx);
211     }
212     return;
213   }
214
215   if ((size < sizeof (struct AddressIterateResponseMessage)) ||
216       (ntohs (msg->type) !=
217        GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE))
218   {
219     GNUNET_break (0);
220     if (pal_ctx->one_shot)
221     {
222       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
223       GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
224     }
225     else
226     {
227       reconnect (pal_ctx);
228     }
229     return;
230   }
231
232   air_msg = (struct AddressIterateResponseMessage *) msg;
233   tlen = ntohl (air_msg->pluginlen);
234   alen = ntohl (air_msg->addrlen);
235
236   if (size != sizeof (struct AddressIterateResponseMessage) + tlen + alen)
237   {
238     GNUNET_break (0);
239     if (pal_ctx->one_shot)
240     {
241       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
242       GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
243     }
244     else
245     {
246       reconnect (pal_ctx);
247     }
248     return;
249   }
250
251   if (alen == 0 && tlen == 0)
252   {
253     pal_ctx->cb (pal_ctx->cb_cls, &air_msg->peer, NULL);
254   }
255   else
256   {
257     addr = (const char *) &air_msg[1];
258     transport_name = &addr[alen];
259
260     if (transport_name[tlen - 1] != '\0')
261     {
262       GNUNET_break (0);
263       if (pal_ctx->one_shot)    
264       {
265         pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
266         GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
267       }
268       else
269       {
270         reconnect (pal_ctx);
271       }
272       return;
273     }
274
275     /* notify client */
276     address =
277         GNUNET_HELLO_address_allocate (&air_msg->peer, transport_name, addr,
278                                        alen);
279     pal_ctx->cb (pal_ctx->cb_cls, &air_msg->peer, address);
280     GNUNET_HELLO_address_free (address);
281   }
282
283   /* expect more replies */
284   GNUNET_CLIENT_receive (pal_ctx->client, &peer_address_response_processor,
285                          pal_ctx,
286                          GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout));
287 }
288
289
290 /**
291  * Return all the known addresses for a specific peer or all peers.
292  * Returns continuously all address if one_shot is set to GNUNET_NO
293  *
294  * CHANGE: Returns the address(es) that we are currently using for this
295  * peer.  Upon completion, the 'AddressLookUpCallback' is called one more
296  * time with 'NULL' for the address and the peer.  After this, the operation must no
297  * longer be explicitly canceled.
298  *
299  * @param cfg configuration to use
300  * @param peer peer identity to look up the addresses of, CHANGE: allow NULL for all (connected) peers
301  * @param one_shot GNUNET_YES to return the current state and then end (with NULL+NULL),
302  *                 GNUNET_NO to monitor the set of addresses used (continuously, must be explicitly canceled)
303  * @param timeout how long is the lookup allowed to take at most (irrelevant if one_shot is set to GNUNET_NO)
304  * @param peer_address_callback function to call with the results
305  * @param peer_address_callback_cls closure for peer_address_callback
306  */
307 struct GNUNET_TRANSPORT_PeerIterateContext *
308 GNUNET_TRANSPORT_peer_get_active_addresses (const struct
309                                             GNUNET_CONFIGURATION_Handle *cfg,
310                                             const struct GNUNET_PeerIdentity
311                                             *peer, int one_shot,
312                                             struct GNUNET_TIME_Relative timeout,
313                                             GNUNET_TRANSPORT_PeerIterateCallback
314                                             peer_address_callback,
315                                             void *peer_address_callback_cls)
316 {
317   struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx;
318   struct GNUNET_CLIENT_Connection *client;
319
320   client = GNUNET_CLIENT_connect ("transport", cfg);
321   if (client == NULL)
322     return NULL;
323   if (GNUNET_YES != one_shot)
324     timeout = GNUNET_TIME_UNIT_FOREVER_REL;
325   pal_ctx = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PeerIterateContext));
326   pal_ctx->cb = peer_address_callback;
327   pal_ctx->cb_cls = peer_address_callback_cls;
328   pal_ctx->cfg = cfg;
329   pal_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
330   if (NULL != peer)
331     pal_ctx->peer = *peer;
332   pal_ctx->one_shot = one_shot;
333   pal_ctx->client = client;
334   send_request (pal_ctx);
335
336   return pal_ctx;
337 }
338
339
340 /**
341  * Cancel request for address conversion.
342  *
343  * @param alc handle for the request to cancel
344  */
345 void
346 GNUNET_TRANSPORT_peer_get_active_addresses_cancel (struct
347                                                    GNUNET_TRANSPORT_PeerIterateContext
348                                                    *alc)
349 {
350   if (NULL != alc->client)
351   {
352     GNUNET_CLIENT_disconnect (alc->client);
353     alc->client = NULL;
354   }
355   if (GNUNET_SCHEDULER_NO_TASK != alc->reconnect_task)
356   {
357     GNUNET_SCHEDULER_cancel (alc->reconnect_task);
358     alc->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
359   }
360   GNUNET_free (alc);
361 }
362
363
364 /* end of transport_api_peer_address_lookup.c */