- improve handling of duplicate connection_create
[oweals/gnunet.git] / src / ats-tool / gnunet-ats.c
1 /*
2      This file is part of GNUnet.
3      (C) 2009--2013 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 ats-tool/gnunet-ats.c
23  * @brief ATS command line tool
24  * @author Matthias Wachs
25  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_ats_service.h"
29 #include "gnunet_transport_service.h"
30
31 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
32
33 #define BIG_M_STRING "unlimited"
34
35 /**
36  * Final status code.
37  */
38 static int ret;
39 static int results;
40 static int resolve_addresses_numeric;
41 static int receive_done;
42
43 /**
44  * For which peer should we change preference values?
45  */
46 static char *pid_str;
47
48 static char *type_str;
49 static unsigned int value;
50 static int pending;
51
52 /**
53  * Print verbose ATS information
54  */
55 static int verbose;
56
57 /**
58  * List only addresses currently used (active)
59  */
60 static int op_list_used;
61
62 /**
63  * List all addresses
64  */
65 static int op_list_all;
66
67 /**
68  * List all addresses
69  */
70 static int op_set_pref;
71
72 /**
73  * Print quotas configured
74  */
75 static int op_print_quotas;
76
77 /**
78  * Monitor addresses used
79  */
80 static int op_monitor;
81
82
83 static struct GNUNET_ATS_PerformanceHandle *ph;
84
85 static struct GNUNET_ATS_AddressListHandle *alh;
86
87 static struct GNUNET_CONFIGURATION_Handle *cfg;
88
89 static GNUNET_SCHEDULER_TaskIdentifier end_task;
90
91
92 struct PendingResolutions
93 {
94   struct PendingResolutions *next;
95   struct PendingResolutions *prev;
96
97   struct GNUNET_HELLO_Address *address;
98   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out;
99   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
100
101   struct GNUNET_ATS_Information *ats;
102   uint32_t ats_count;
103
104   struct GNUNET_TRANSPORT_AddressToStringContext * tats_ctx;
105 };
106
107
108 static struct PendingResolutions *head;
109
110 static struct PendingResolutions *tail;
111
112
113 static void
114 end (void *cls,
115      const struct GNUNET_SCHEDULER_TaskContext *tc)
116 {
117   struct PendingResolutions * pr;
118   struct PendingResolutions * next;
119   unsigned int pending;
120
121   if (NULL != alh)
122   {
123       GNUNET_ATS_performance_list_addresses_cancel (alh);
124       alh = NULL;
125   }
126
127   if (NULL != ph)
128   {
129     GNUNET_ATS_performance_done (ph);
130     ph = NULL;
131   }
132
133   pending = 0;
134   next = head;
135   while (NULL != (pr = next))
136   {
137       next = pr->next;
138       GNUNET_CONTAINER_DLL_remove (head, tail, pr);
139       GNUNET_TRANSPORT_address_to_string_cancel (pr->tats_ctx);
140       GNUNET_free (pr->address);
141       GNUNET_free (pr);
142       pending ++;
143   }
144   if (0 < pending)
145     fprintf (stderr, _("%u address resolutions had a timeout\n"), pending);
146   if (op_list_used || op_list_all)
147         fprintf (stderr, _("ATS returned results for %u addresses\n"), results);
148   ret = 0;
149 }
150
151
152 static void
153 transport_addr_to_str_cb (void *cls, const char *address)
154 {
155   struct PendingResolutions * pr = cls;
156   char *ats_str;
157   char *ats_tmp;
158   char *ats_prop_arr[GNUNET_ATS_PropertyCount] = GNUNET_ATS_PropertyStrings;
159   char *ats_prop_value;
160   unsigned int c;
161   uint32_t ats_type;
162   uint32_t ats_value;
163   uint32_t network;
164
165   if (NULL != address)
166   {
167     ats_str = GNUNET_strdup("");
168     network = GNUNET_ATS_NET_UNSPECIFIED;
169     for (c = 0; c < pr->ats_count; c++)
170     {
171         ats_tmp = ats_str;
172
173         ats_type = ntohl(pr->ats[c].type);
174         ats_value = ntohl(pr->ats[c].value);
175
176         if (ats_type > GNUNET_ATS_PropertyCount)
177         {
178             GNUNET_break (0);
179             continue;
180         }
181
182         switch (ats_type) {
183           case GNUNET_ATS_NETWORK_TYPE:
184             if (ats_value > GNUNET_ATS_NetworkTypeCount)
185             {
186                 GNUNET_break (0);
187                 continue;
188             }
189             network = ats_value;
190             GNUNET_asprintf (&ats_prop_value, "%s", GNUNET_ATS_print_network_type(ats_value));
191             break;
192           default:
193             GNUNET_asprintf (&ats_prop_value, "%u", ats_value);
194             break;
195         }
196         if ((verbose) && (ats_type < GNUNET_ATS_PropertyCount))
197         {
198           GNUNET_asprintf (&ats_str, "%s%s=%s, ", ats_tmp, ats_prop_arr[ats_type] , ats_prop_value);
199           GNUNET_free (ats_tmp);
200         }
201         GNUNET_free (ats_prop_value);
202                 }
203
204     fprintf (stderr, _("Peer `%s' plugin `%s', address `%s', `%s' bw out: %u Bytes/s, bw in %u Bytes/s, %s\n"),
205       GNUNET_i2s (&pr->address->peer), pr->address->transport_name, address,
206       GNUNET_ATS_print_network_type(network),
207       ntohl (pr->bandwidth_out.value__), ntohl (pr->bandwidth_in.value__),ats_str);
208     GNUNET_free (ats_str);
209   }
210   else
211   {
212     /* We're done */
213     GNUNET_CONTAINER_DLL_remove (head, tail, pr);
214     GNUNET_free (pr->address);
215     GNUNET_free (pr);
216     pending--;
217
218     if ((GNUNET_YES == receive_done) && (0 == pending))
219     {
220         /* All messages received and no resolutions pending*/
221         if (end_task != GNUNET_SCHEDULER_NO_TASK)
222           GNUNET_SCHEDULER_cancel (end_task);
223         end_task = GNUNET_SCHEDULER_add_now (end, NULL);
224     }
225   }
226 }
227
228
229 static void
230 ats_perf_cb (void *cls,
231              const struct GNUNET_HELLO_Address *address,
232              int active,
233              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
234              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
235              const struct GNUNET_ATS_Information *ats,
236              uint32_t ats_count)
237 {
238   struct PendingResolutions * pr;
239
240   if (NULL != address)
241   {
242     pr = GNUNET_malloc (sizeof (struct PendingResolutions) +
243                         ats_count * sizeof (struct GNUNET_ATS_Information));
244
245     pr->ats_count = ats_count;
246     pr->ats = (struct GNUNET_ATS_Information *) &pr[1];
247     if (ats_count > 0)
248       memcpy (pr->ats, ats, ats_count * sizeof (struct GNUNET_ATS_Information));
249     pr->address = GNUNET_HELLO_address_copy (address);
250     pr->bandwidth_in = bandwidth_in;
251     pr->bandwidth_out = bandwidth_out;
252     pr->tats_ctx = GNUNET_TRANSPORT_address_to_string(cfg, address,
253                       resolve_addresses_numeric,
254                                                           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
255                       transport_addr_to_str_cb, pr);
256     GNUNET_CONTAINER_DLL_insert (head, tail, pr);
257     results++;
258     pending++;
259   }
260   else
261   {
262     /* All messages received */
263     receive_done = GNUNET_YES;
264     alh = NULL;
265     if (0 == pending)
266     {
267       /* All messages received and no resolutions pending*/
268       if (end_task != GNUNET_SCHEDULER_NO_TASK)
269         GNUNET_SCHEDULER_cancel (end_task);
270       end_task = GNUNET_SCHEDULER_add_now (end, NULL);
271     }
272   }
273 }
274
275 static unsigned int
276 print_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg)
277 {
278   char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
279   char * entry_in = NULL;
280   char * entry_out = NULL;
281   char * quota_out_str;
282   char * quota_in_str;
283   unsigned long long int quota_out;
284   unsigned long long int quota_in;
285   int c;
286
287   for (c = 0; (c < GNUNET_ATS_NetworkTypeCount); c++)
288   {
289
290     GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
291     GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
292
293     /* quota out */
294     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, &quota_out_str))
295     {
296       if (0 == strcmp(quota_out_str, BIG_M_STRING) ||
297           (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &quota_out)))
298         quota_out = UINT32_MAX;
299
300       GNUNET_free (quota_out_str);
301       GNUNET_asprintf (&quota_out_str, "%llu", quota_out);
302     }
303     else
304     {
305         fprintf (stderr, "Outbound quota for network `%11s' not configured!\n",
306             network_str[c]);
307         GNUNET_asprintf (&quota_out_str, "-");
308     }
309     GNUNET_free (entry_out);
310
311     /* quota in */
312     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, &quota_in_str))
313     {
314       if (0 == strcmp(quota_in_str, BIG_M_STRING) ||
315           (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &quota_in)))
316           quota_in = UINT32_MAX;
317       GNUNET_free (quota_in_str);
318       GNUNET_asprintf (&quota_in_str, "%llu", quota_in);
319     }
320     else
321     {
322         fprintf (stderr, "Inbound quota for network `%11s' not configured!\n",
323             network_str[c]);
324         GNUNET_asprintf (&quota_in_str, "-");
325     }
326     GNUNET_free (entry_in);
327
328     fprintf (stderr, _("Quota for network `%11s' (in/out): %10s / %10s\n"), network_str[c], quota_in_str, quota_out_str );
329     GNUNET_free (quota_out_str);
330     GNUNET_free (quota_in_str);
331   }
332   return GNUNET_ATS_NetworkTypeCount;
333 }
334
335
336 static void
337 testservice_ats (void *cls,
338                  int result)
339 {
340   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
341   struct GNUNET_PeerIdentity pid;
342   unsigned int c;
343   unsigned int type;
344
345   if (GNUNET_YES != result)
346   {
347     FPRINTF (stderr, _("Service `%s' is not running\n"), "ats");
348     return;
349   }
350
351   results = 0;
352
353   if (NULL != pid_str)
354   {
355     if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (pid_str,
356                                                                     strlen (pid_str),
357                                                                     &pid.public_key))
358     {
359       FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
360       return;
361     }
362   }
363
364   c = op_list_all + op_list_used + op_monitor + op_set_pref;
365   if ((1 < c))
366   {
367       FPRINTF (stderr, _("Please select one operation : %s or %s or %s or %s or %s\n"),
368                "--used", "--all", "--monitor", "--preference", "--quotas");
369       return;
370   }
371   if ((0 == c))
372     op_list_used = GNUNET_YES; /* set default */
373     if (op_print_quotas)
374     {
375         ret = print_quotas (cfg);
376         return;
377     }
378     if (op_list_all)
379     {
380         ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
381         if (NULL == ph)
382         {
383           fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
384           return;
385         }
386
387         alh = GNUNET_ATS_performance_list_addresses (ph,
388                                                (NULL == pid_str) ? NULL : &pid,
389                                                GNUNET_YES, ats_perf_cb, NULL);
390         if (NULL == alh)
391         {
392           fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n"));
393           end_task = GNUNET_SCHEDULER_add_now (&end, NULL);
394           return;
395         }
396         end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
397     }
398     else if (op_list_used)
399     {
400         ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
401         if (NULL == ph)
402           fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
403
404         alh = GNUNET_ATS_performance_list_addresses (ph,
405                                                (NULL == pid_str) ? NULL : &pid,
406                                                GNUNET_NO, ats_perf_cb, NULL);
407         if (NULL == alh)
408         {
409           fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n"));
410           end_task = GNUNET_SCHEDULER_add_now (&end, NULL);
411           return;
412         }
413         end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
414     }
415     else if (op_monitor)
416     {
417         ph = GNUNET_ATS_performance_init (cfg, ats_perf_cb, NULL);
418         if (NULL == ph)
419           fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
420         end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
421
422     }
423     else if (op_set_pref)
424     {
425                 if (NULL == type_str)
426                 {
427                         fprintf (stderr, _("No preference type given!\n"));
428                         return;
429                 }
430                 if (NULL == pid_str)
431                 {
432                         fprintf (stderr, _("No peer given!\n"));
433                         return;
434                 }
435
436
437
438         for (c = 0; c<strlen(type_str); c++)
439         {
440           if (isupper (type_str[c]))
441             type_str[c] = tolower (type_str[c]);
442         }
443
444         if (0 == strcasecmp("latency", type_str))
445           type = GNUNET_ATS_PREFERENCE_LATENCY;
446         else if (0 == strcasecmp("bandwidth", type_str))
447           type = GNUNET_ATS_PREFERENCE_BANDWIDTH;
448         else
449         {
450           FPRINTF (stderr, "%s", _("Valid type required\n"));
451           return;
452         }
453
454             /* set */
455             ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
456             if (NULL == ph)
457               fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
458
459             GNUNET_ATS_performance_change_preference (ph, &pid, type, (double) value, GNUNET_ATS_PREFERENCE_END);
460
461             end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &end, NULL);
462     }
463   ret = 1;
464 }
465
466 /**
467  * Main function that will be run by the scheduler.
468  *
469  * @param cls closure
470  * @param args remaining command-line arguments
471  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
472  * @param my_cfg configuration
473  */
474 static void
475 run (void *cls, char *const *args, const char *cfgfile,
476      const struct GNUNET_CONFIGURATION_Handle *my_cfg)
477 {
478   cfg = (struct GNUNET_CONFIGURATION_Handle *) my_cfg;
479   GNUNET_CLIENT_service_test ("ats", cfg,
480                               TIMEOUT,
481                               &testservice_ats,
482                               (void *) cfg);
483 }
484
485
486 /**
487  * The main function.
488  *
489  * @param argc number of arguments from the command line
490  * @param argv command line arguments
491  * @return 0 ok, 1 on error
492  */
493 int
494 main (int argc, char *const *argv)
495 {
496   int res;
497   resolve_addresses_numeric = GNUNET_NO;
498   op_monitor = GNUNET_NO;
499   op_list_all = GNUNET_NO;
500   op_list_used = GNUNET_NO;
501   op_set_pref = GNUNET_NO;
502   pending = 0;
503   receive_done = GNUNET_NO;
504   type_str = NULL;
505
506   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
507       {'u', "used", NULL,
508        gettext_noop ("get list of active addresses currently used"),
509        0, &GNUNET_GETOPT_set_one, &op_list_used},
510        {'a', "all", NULL,
511         gettext_noop ("get list of all active addresses"),
512         0, &GNUNET_GETOPT_set_one, &op_list_all},
513       {'n', "numeric", NULL,
514        gettext_noop ("do not resolve IP addresses to hostnames"),
515        0, &GNUNET_GETOPT_set_one, &resolve_addresses_numeric},
516        {'m', "monitor", NULL,
517         gettext_noop ("monitor mode"),
518         0, &GNUNET_GETOPT_set_one, &op_monitor},
519        {'p', "preference", NULL,
520          gettext_noop ("set preference for the given peer"),
521          0, &GNUNET_GETOPT_set_one, &op_set_pref},
522        {'q', "quotas", NULL,
523          gettext_noop ("print all configured quotas"),
524          0, &GNUNET_GETOPT_set_one, &op_print_quotas},
525        {'i', "id", "TYPE",
526          gettext_noop ("peer id"),
527          1, &GNUNET_GETOPT_set_string, &pid_str},
528        {'t', "type", "TYPE",
529          gettext_noop ("preference type to set: latency | bandwidth"),
530          1, &GNUNET_GETOPT_set_string, &type_str},
531        {'k', "value", "VALUE",
532          gettext_noop ("preference value"),
533          1, &GNUNET_GETOPT_set_uint, &value},
534        {'V', "verbose", NULL,
535         gettext_noop ("verbose output (include ATS address properties)"),
536         0, &GNUNET_GETOPT_set_one, &verbose},
537     GNUNET_GETOPT_OPTION_END
538   };
539
540   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
541     return 2;
542
543   res = GNUNET_PROGRAM_run (argc, argv, "gnunet-ats",
544                               gettext_noop ("Print information about ATS state"), options, &run,
545                               NULL);
546   GNUNET_free_non_null (pid_str);
547   GNUNET_free_non_null (type_str);
548   GNUNET_free ((void *) argv);
549
550   if (GNUNET_OK == res)
551     return ret;
552   else
553     return 1;
554
555 }
556
557 /* end of gnunet-ats.c */