GNUnet  0.17.6
gnunet-daemon-hostlist_client.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001-2010, 2014, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your 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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
28 #include "gnunet_hello_lib.h"
32 #include "gnunet-daemon-hostlist.h"
33 /* Just included for the right curl.h */
34 #include "gnunet_curl_lib.h"
35 
36 
41 #define MIN_CONNECTIONS 4
42 
46 #define MAX_NUMBER_HOSTLISTS 30
47 
51 #define SAVING_INTERVAL \
52  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
53 
57 #define TESTING_INTERVAL \
58  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
59 
63 #define WAITING_INTERVAL \
64  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
65 
73 #define HOSTLIST_INITIAL 10000
74 
78 #define HOSTLIST_FAILED_DOWNLOAD 100
79 
83 #define HOSTLIST_SUCCESSFUL_DOWNLOAD 100
84 
88 #define HOSTLIST_SUCCESSFUL_HELLO 1
89 
90 
94 struct Hostlist
95 {
99  struct Hostlist *prev;
100 
104  struct Hostlist *next;
105 
109  const char *hostlist_uri;
110 
119  uint64_t quality;
120 
125 
130 
134  uint32_t hello_count;
135 
139  uint32_t times_used;
140 };
141 
142 
146 static const struct GNUNET_CONFIGURATION_Handle *cfg;
147 
152 
156 static char *proxy;
157 
161 static char *proxy_username;
162 
166 static char *proxy_password;
167 
171 static curl_proxytype proxy_type;
172 
176 static size_t download_pos;
177 
181 static char *current_url;
182 
186 static CURL *curl;
187 
191 static CURLM *multi;
192 
196 static uint32_t stat_bytes_downloaded;
197 
202 
207 
212 
217 
222 
227 
231 static struct GNUNET_TIME_Absolute end_time;
232 
236 static struct Hostlist *linked_list_head;
237 
241 static struct Hostlist *linked_list_tail;
242 
246 static struct Hostlist *current_hostlist;
247 
251 static unsigned int linked_list_size;
252 
256 static struct Hostlist *hostlist_to_test;
257 
262 
266 static int stat_bogus_url;
267 
272 
277 
282 
286 static unsigned int stat_use_bootstrap;
287 
291 static int stat_learning;
292 
296 static unsigned int stat_download_successful;
297 
301 static unsigned int stat_hellos_obtained;
302 
306 static unsigned int stat_connection_count;
307 
311 static struct GNUNET_PEERINFO_Handle *pi;
312 
313 
323 static size_t
324 callback_download (void *ptr, size_t size, size_t nmemb, void *ctx)
325 {
326  static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1];
327  const char *cbuf = ptr;
328  const struct GNUNET_MessageHeader *msg;
329  size_t total;
330  size_t cpy;
331  size_t left;
332  uint16_t msize;
333 
334  total = size * nmemb;
335  stat_bytes_downloaded += total;
336  if ((total == 0) || (stat_bogus_url))
337  {
338  return total; /* ok, no data or bogus data */
339  }
340 
342  gettext_noop (
343  "# bytes downloaded from hostlist servers"),
344  (int64_t) total,
345  GNUNET_NO);
346  left = total;
347  while ((left > 0) || (download_pos > 0))
348  {
349  cpy = GNUNET_MIN (left, GNUNET_MAX_MESSAGE_SIZE - 1 - download_pos);
350  GNUNET_memcpy (&download_buffer[download_pos], cbuf, cpy);
351  cbuf += cpy;
352  download_pos += cpy;
353  left -= cpy;
354  if (download_pos < sizeof(struct GNUNET_MessageHeader))
355  {
356  GNUNET_assert (0 == left);
357  break;
358  }
359  msg = (const struct GNUNET_MessageHeader *) download_buffer;
360  msize = ntohs (msg->size);
361  if (msize < sizeof(struct GNUNET_MessageHeader))
362  {
364  stats,
365  gettext_noop ("# invalid HELLOs downloaded from hostlist servers"),
366  1,
367  GNUNET_NO);
369  _ ("Invalid `%s' message received from hostlist at `%s'\n"),
370  "HELLO",
371  current_url);
373  stat_bogus_url = 1;
374  return total;
375  }
376  if (download_pos < msize)
377  {
378  GNUNET_assert (left == 0);
379  break;
380  }
381  if (GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *) msg) == msize)
382  {
384  "Received valid `%s' message from hostlist server.\n",
385  "HELLO");
387  stats,
388  gettext_noop ("# valid HELLOs downloaded from hostlist servers"),
389  1,
390  GNUNET_NO);
392  (void)
394  (const struct GNUNET_HELLO_Message *) msg,
395  NULL,
396  NULL);
397  }
398  else
399  {
401  stats,
402  gettext_noop ("# invalid HELLOs downloaded from hostlist servers"),
403  1,
404  GNUNET_NO);
406  _ ("Invalid `%s' message received from hostlist at `%s'\n"),
407  "HELLO",
408  current_url);
411  return total;
412  }
413  memmove (download_buffer, &download_buffer[msize], download_pos - msize);
414  download_pos -= msize;
415  }
416  return total;
417 }
418 
419 
425 static char *
427 {
428  char *servers;
429  char *ret;
430  size_t urls;
431  size_t pos;
432 
434  "HOSTLIST",
435  "SERVERS",
436  &servers))
437  {
439  "hostlist",
440  "SERVERS");
441  return NULL;
442  }
443 
444  urls = 0;
445  if (strlen (servers) > 0)
446  {
447  urls++;
448  pos = strlen (servers) - 1;
449  while (pos > 0)
450  {
451  if (servers[pos] == ' ')
452  urls++;
453  pos--;
454  }
455  }
456  if (urls == 0)
457  {
459  "hostlist",
460  "SERVERS");
461  GNUNET_free (servers);
462  return NULL;
463  }
464 
466  pos = strlen (servers) - 1;
467  while (pos > 0)
468  {
469  if (servers[pos] == ' ')
470  {
471  urls--;
472  servers[pos] = '\0';
473  }
474  if (urls == 0)
475  {
476  pos++;
477  break;
478  }
479  pos--;
480  }
481  ret = GNUNET_strdup (&servers[pos]);
482  GNUNET_free (servers);
483  return ret;
484 }
485 
486 
491 static char *
493 {
494  uint32_t index;
495  unsigned int counter;
496  struct Hostlist *pos;
497 
498  if (GNUNET_NO == stat_learning)
499  {
501  "Using preconfigured bootstrap server\n");
502  current_hostlist = NULL;
503  return get_bootstrap_server ();
504  }
505 
506  if ((GNUNET_YES == stat_testing_hostlist) && (NULL != hostlist_to_test))
507  {
509  "Testing new advertised hostlist if it is obtainable\n");
512  }
513 
515  {
517  "Using preconfigured bootstrap server\n");
518  current_hostlist = NULL;
519  return get_bootstrap_server ();
520  }
521  index =
523  counter = 0;
524  pos = linked_list_head;
525  while (counter < index)
526  {
527  pos = pos->next;
528  counter++;
529  }
531  "Using learned hostlist `%s'\n",
532  pos->hostlist_uri);
533  current_hostlist = pos;
534  return GNUNET_strdup (pos->hostlist_uri);
535 }
536 
537 
538 #define CURL_EASY_SETOPT(c, a, b) \
539  do \
540  { \
541  ret = curl_easy_setopt (c, a, b); \
542  if (CURLE_OK != ret) \
543  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \
544  _ ("%s failed at %s:%d: `%s'\n"), \
545  "curl_easy_setopt", \
546  __FILE__, \
547  __LINE__, \
548  curl_easy_strerror (ret)); \
549  } while (0)
550 
551 
557 static void
558 save_hostlist_file (int shutdown);
559 
560 
568 static uint64_t
569 checked_add (uint64_t val1, uint64_t val2)
570 {
571  static uint64_t temp;
572  static uint64_t maxv;
573 
574  maxv = 0;
575  maxv--;
576 
577  temp = val1 + val2;
578  if (temp < val1)
579  return maxv;
580  return temp;
581 }
582 
583 
591 static uint64_t
592 checked_sub (uint64_t val1, uint64_t val2)
593 {
594  if (val1 <= val2)
595  return 0;
596  return(val1 - val2);
597 }
598 
599 
606 static int
608 {
609  struct Hostlist *pos;
610 
611  pos = linked_list_head;
612  while (pos != NULL)
613  {
614  if (0 == strcmp (pos->hostlist_uri, uri))
615  return GNUNET_YES;
616  pos = pos->next;
617  }
618  return GNUNET_NO;
619 }
620 
621 
626 static struct Hostlist *
628 {
629  struct Hostlist *pos;
630  struct Hostlist *lowest;
631 
632  if (linked_list_size == 0)
633  return NULL;
634  lowest = linked_list_head;
635  pos = linked_list_head->next;
636  while (pos != NULL)
637  {
638  if (pos->quality < lowest->quality)
639  lowest = pos;
640  pos = pos->next;
641  }
642  return lowest;
643 }
644 
645 
651 static void
653 {
654  struct Hostlist *lowest_quality;
655 
657  {
658  /* No free entries available, replace existing entry */
659  lowest_quality = linked_list_get_lowest_quality ();
660  GNUNET_assert (lowest_quality != NULL);
661  GNUNET_log (
663  "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n",
664  lowest_quality->hostlist_uri,
665  (unsigned long long) lowest_quality->quality);
668  lowest_quality);
670  GNUNET_free (lowest_quality);
671  }
677  gettext_noop ("# advertised hostlist URIs"),
679  GNUNET_NO);
681 }
682 
683 
687 static void
689 {
690  char *stat;
691 
692  if (((stat_use_bootstrap == GNUNET_NO) && (NULL != current_hostlist)) ||
694  {
696  "Updating hostlist statics for URI `%s'\n",
704  {
708  GNUNET_asprintf (&stat,
709  gettext_noop ("# advertised URI `%s' downloaded"),
711 
713  GNUNET_free (stat);
714  }
715  else
718  }
719  current_hostlist = NULL;
720  /* Alternating the usage of preconfigured and learned hostlists */
721 
723  return;
724 
725  if (GNUNET_YES == stat_learning)
726  {
729  else
731  }
732  else
734 }
735 
736 
741 static void
743 {
744  CURLMcode mret;
745 
748  {
749  GNUNET_log (
751  _ (
752  "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"),
754  }
755 
757  {
759  }
760  if (NULL != hostlist_to_test)
761  {
763  hostlist_to_test = NULL;
764  }
765 
766  if (NULL != multi)
767  {
768  mret = curl_multi_remove_handle (multi, curl);
769  if (mret != CURLM_OK)
770  {
772  _ ("%s failed at %s:%d: `%s'\n"),
773  "curl_multi_remove_handle",
774  __FILE__,
775  __LINE__,
776  curl_multi_strerror (mret));
777  }
778  mret = curl_multi_cleanup (multi);
779  if (mret != CURLM_OK)
781  _ ("%s failed at %s:%d: `%s'\n"),
782  "curl_multi_cleanup",
783  __FILE__,
784  __LINE__,
785  curl_multi_strerror (mret));
786  multi = NULL;
787  }
788  if (NULL != curl)
789  {
790  curl_easy_cleanup (curl);
791  curl = NULL;
792  }
794  current_url = NULL;
797 }
798 
799 
806 static void
807 task_download (void *cls);
808 
809 
814 static void
816 {
817  CURLMcode mret;
818  fd_set rs;
819  fd_set ws;
820  fd_set es;
821  int max;
822  struct GNUNET_NETWORK_FDSet *grs;
823  struct GNUNET_NETWORK_FDSet *gws;
824  long timeout;
825  struct GNUNET_TIME_Relative rtime;
826 
827  max = -1;
828  FD_ZERO (&rs);
829  FD_ZERO (&ws);
830  FD_ZERO (&es);
831  mret = curl_multi_fdset (multi, &rs, &ws, &es, &max);
832  if (mret != CURLM_OK)
833  {
835  _ ("%s failed at %s:%d: `%s'\n"),
836  "curl_multi_fdset",
837  __FILE__,
838  __LINE__,
839  curl_multi_strerror (mret));
840  clean_up ();
841  return;
842  }
843  mret = curl_multi_timeout (multi, &timeout);
844  if (mret != CURLM_OK)
845  {
847  _ ("%s failed at %s:%d: `%s'\n"),
848  "curl_multi_timeout",
849  __FILE__,
850  __LINE__,
851  curl_multi_strerror (mret));
852  clean_up ();
853  return;
854  }
855  rtime = GNUNET_TIME_relative_min (
860  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
861  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
863  "Scheduling task for hostlist download using cURL\n");
865  rtime,
866  grs,
867  gws,
868  &task_download,
869  multi);
872 }
873 
874 
875 static void
876 task_download (void *cls)
877 {
878  int running;
879  struct CURLMsg *msg;
880  CURLMcode mret;
881 
882  ti_download = NULL;
883  if (0 == GNUNET_TIME_absolute_get_remaining (end_time).rel_value_us)
884  {
886  _ ("Timeout trying to download hostlist from `%s'\n"),
887  current_url);
888  update_hostlist ();
889  clean_up ();
890  return;
891  }
893  "Ready for processing hostlist client request\n");
894  do
895  {
896  running = 0;
898  {
900  _ (
901  "Download limit of %u bytes exceeded, stopping download\n"),
903  clean_up ();
904  return;
905  }
906  mret = curl_multi_perform (multi, &running);
907  if (running == 0)
908  {
909  do
910  {
911  msg = curl_multi_info_read (multi, &running);
912  GNUNET_break (msg != NULL);
913  if (msg == NULL)
914  break;
915  switch (msg->msg)
916  {
917  case CURLMSG_DONE:
918  if ((msg->data.result != CURLE_OK) &&
919  (msg->data.result != CURLE_GOT_NOTHING))
921  _ ("Download of hostlist from `%s' failed: `%s'\n"),
922  current_url,
923  curl_easy_strerror (msg->data.result));
924  else
925  {
927  _ ("Download of hostlist `%s' completed.\n"),
928  current_url);
930  update_hostlist ();
932  {
933  GNUNET_log (
935  _ ("Adding successfully tested hostlist `%s' datastore.\n"),
936  current_url);
937  insert_hostlist ();
938  hostlist_to_test = NULL;
940  }
941  }
942  clean_up ();
943  return;
944 
945  default:
946  break;
947  }
948  }
949  while ((running > 0));
950  }
951  }
952  while (mret == CURLM_CALL_MULTI_PERFORM);
953 
954  if (mret != CURLM_OK)
955  {
957  _ ("%s failed at %s:%d: `%s'\n"),
958  "curl_multi_perform",
959  __FILE__,
960  __LINE__,
961  curl_multi_strerror (mret));
962  clean_up ();
963  }
964  download_prepare ();
965 }
966 
967 
972 static void
974 {
975  CURLcode ret;
976  CURLMcode mret;
977 
978 
980  if (current_url == NULL)
981  return;
982  curl = curl_easy_init ();
983  multi = NULL;
984  if (curl == NULL)
985  {
986  GNUNET_break (0);
987  clean_up ();
988  return;
989  }
991  _ ("Bootstrapping using hostlist at `%s'.\n"),
992  current_url);
993 
998 
1000  gettext_noop ("# hostlist downloads initiated"),
1001  1,
1002  GNUNET_NO);
1003  if (NULL != proxy)
1004  {
1005  CURL_EASY_SETOPT (curl, CURLOPT_PROXY, proxy);
1006  CURL_EASY_SETOPT (curl, CURLOPT_PROXYTYPE, proxy_type);
1007  if (NULL != proxy_username)
1008  CURL_EASY_SETOPT (curl, CURLOPT_PROXYUSERNAME, proxy_username);
1009  if (NULL != proxy_password)
1010  CURL_EASY_SETOPT (curl, CURLOPT_PROXYPASSWORD, proxy_password);
1011  }
1012  download_pos = 0;
1013  stat_bogus_url = 0;
1014  CURL_EASY_SETOPT (curl, CURLOPT_WRITEFUNCTION, &callback_download);
1015  if (ret != CURLE_OK)
1016  {
1017  clean_up ();
1018  return;
1019  }
1020  CURL_EASY_SETOPT (curl, CURLOPT_WRITEDATA, NULL);
1021  if (ret != CURLE_OK)
1022  {
1023  clean_up ();
1024  return;
1025  }
1026  CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1);
1028  CURLOPT_REDIR_PROTOCOLS,
1029  CURLPROTO_HTTP | CURLPROTO_HTTPS);
1030  CURL_EASY_SETOPT (curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
1031  CURL_EASY_SETOPT (curl, CURLOPT_MAXREDIRS, 4);
1032  /* no need to abort if the above failed */
1033  CURL_EASY_SETOPT (curl, CURLOPT_URL, current_url);
1034  if (ret != CURLE_OK)
1035  {
1036  clean_up ();
1037  return;
1038  }
1039  CURL_EASY_SETOPT (curl, CURLOPT_FAILONERROR, 1);
1040 #if 0
1041  CURL_EASY_SETOPT (curl, CURLOPT_VERBOSE, 1);
1042 #endif
1043  CURL_EASY_SETOPT (curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE);
1044  if (0 == strncmp (current_url, "http", 4))
1045  CURL_EASY_SETOPT (curl, CURLOPT_USERAGENT, "GNUnet");
1046  CURL_EASY_SETOPT (curl, CURLOPT_CONNECTTIMEOUT, 60L);
1047  CURL_EASY_SETOPT (curl, CURLOPT_TIMEOUT, 60L);
1048  multi = curl_multi_init ();
1049  if (multi == NULL)
1050  {
1051  GNUNET_break (0);
1052  /* clean_up (); */
1053  return;
1054  }
1055  mret = curl_multi_add_handle (multi, curl);
1056  if (mret != CURLM_OK)
1057  {
1059  _ ("%s failed at %s:%d: `%s'\n"),
1060  "curl_multi_add_handle",
1061  __FILE__,
1062  __LINE__,
1063  curl_multi_strerror (mret));
1064  mret = curl_multi_cleanup (multi);
1065  if (mret != CURLM_OK)
1067  _ ("%s failed at %s:%d: `%s'\n"),
1068  "curl_multi_cleanup",
1069  __FILE__,
1070  __LINE__,
1071  curl_multi_strerror (mret));
1072  multi = NULL;
1073  clean_up ();
1074  return;
1075  }
1077  download_prepare ();
1078 }
1079 
1080 
1081 static void
1083 {
1085  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n");
1087  {
1088  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n");
1089  download_hostlist ();
1090  }
1091  else
1092  {
1094  "Download in progress, have to wait...\n");
1098  NULL);
1099  }
1100 }
1101 
1102 
1108 static void
1109 task_check (void *cls)
1110 {
1111  static int once;
1112  struct GNUNET_TIME_Relative delay;
1113 
1114  ti_check_download = NULL;
1115  if (stats == NULL)
1116  {
1117  curl_global_cleanup ();
1118  return; /* in shutdown */
1119  }
1121  (NULL == ti_download_dispatcher_task))
1124 
1126  if (0 == hostlist_delay.rel_value_us)
1128  else
1131  GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count))
1132  hostlist_delay =
1134  (1 + stat_connection_count));
1136  gettext_noop (
1137  "# milliseconds between hostlist downloads"),
1138  hostlist_delay.rel_value_us / 1000LL,
1139  GNUNET_YES);
1140  if (0 == once)
1141  {
1143  once = 1;
1144  }
1145  GNUNET_log (
1147  _ ("Have %u/%u connections. Will consider downloading hostlist in %s\n"),
1152 }
1153 
1154 
1160 static void
1162 {
1166  "Testing new hostlist advertisements is allowed again\n");
1167 }
1168 
1169 
1175 static void
1177 {
1178  ti_saving_task = NULL;
1180 
1182  "Hostlists will be saved to file again in %s\n",
1184  GNUNET_YES));
1185  ti_saving_task =
1187 }
1188 
1189 
1197 static void *
1198 handler_connect (void *cls,
1199  const struct GNUNET_PeerIdentity *peer,
1200  struct GNUNET_MQ_Handle *mq)
1201 {
1202  GNUNET_assert (stat_connection_count < UINT_MAX);
1205  gettext_noop ("# active connections"),
1206  1,
1207  GNUNET_NO);
1208  return NULL;
1209 }
1210 
1211 
1218 static void
1220  const struct GNUNET_PeerIdentity *peer,
1221  void *internal_cls)
1222 {
1226  gettext_noop ("# active connections"),
1227  -1,
1228  GNUNET_NO);
1229 }
1230 
1231 
1237 static void
1239 {
1240  size_t uri_size;
1241  struct Hostlist *hostlist;
1242 
1243  uri_size = strlen (uri) + 1;
1245  "Hostlist client received advertisement containing URI `%s'\n",
1246  uri);
1248  {
1249  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri);
1250  return;
1251  }
1252 
1254  {
1255  GNUNET_log (
1257  "Currently not accepting new advertisements: interval between to advertisements is not reached\n");
1258  return;
1259  }
1261  {
1262  GNUNET_log (
1264  "Currently not accepting new advertisements: we are already testing a hostlist\n");
1265  return;
1266  }
1267 
1268  hostlist = GNUNET_malloc (sizeof(struct Hostlist) + uri_size);
1269  hostlist->hostlist_uri = (const char *) &hostlist[1];
1270  GNUNET_memcpy (&hostlist[1], uri, uri_size);
1271  hostlist->time_creation = GNUNET_TIME_absolute_get ();
1272  hostlist->quality = HOSTLIST_INITIAL;
1273  hostlist_to_test = hostlist;
1274 
1280  NULL);
1281 
1283  "Testing new hostlist advertisements is locked for the next %s\n",
1285  GNUNET_YES));
1286 
1289 }
1290 
1291 
1300 static void
1301 primary_task (void *cls, int success)
1302 {
1303  if (NULL != ti_check_download)
1304  {
1306  ti_check_download = NULL;
1307  }
1308  sget = NULL;
1309  GNUNET_assert (NULL != stats);
1311  "Statistics request done, scheduling hostlist download\n");
1313 }
1314 
1315 
1324 static void
1326 {
1328  sget = NULL;
1330 }
1331 
1332 
1342 static int
1343 process_stat (void *cls,
1344  const char *subsystem,
1345  const char *name,
1346  uint64_t value,
1347  int is_persistent)
1348 {
1349  hostlist_delay.rel_value_us = value * 1000LL;
1351  "Initial time between hostlist downloads is %s\n",
1353  GNUNET_YES));
1354  return GNUNET_OK;
1355 }
1356 
1357 
1361 static void
1363 {
1364  char *filename;
1365  char *uri;
1366  char *emsg;
1367  struct Hostlist *hostlist;
1368  uint32_t times_used;
1369  uint32_t hellos_returned;
1370  uint64_t quality;
1371  uint64_t last_used;
1372  uint64_t created;
1373  uint32_t counter;
1374  struct GNUNET_BIO_ReadHandle *rh;
1375 
1376  uri = NULL;
1378  "HOSTLIST",
1379  "HOSTLISTFILE",
1380  &filename))
1381  {
1383  "hostlist",
1384  "HOSTLISTFILE");
1385  return;
1386  }
1387 
1389  _ ("Loading saved hostlist entries from file `%s' \n"),
1390  filename);
1392  {
1394  _ ("Hostlist file `%s' does not exist\n"),
1395  filename);
1397  return;
1398  }
1399 
1401  if (NULL == rh)
1402  {
1404  _ (
1405  "Could not open file `%s' for reading to load hostlists: %s\n"),
1406  filename,
1407  strerror (errno));
1409  return;
1410  }
1411 
1412  counter = 0;
1413  struct GNUNET_BIO_ReadSpec rs[] = {
1414  GNUNET_BIO_read_spec_int32 ("times used", (int32_t *) &times_used),
1415  GNUNET_BIO_read_spec_int64 ("quality", (int64_t *) &quality),
1416  GNUNET_BIO_read_spec_int64 ("last used", (int64_t *) &last_used),
1417  GNUNET_BIO_read_spec_int64 ("created", (int64_t *) &created),
1418  GNUNET_BIO_read_spec_int32 ("hellos returned",
1419  (int32_t *) &hellos_returned),
1421  };
1422  while ((GNUNET_OK == GNUNET_BIO_read_string (rh, "url", &uri, MAX_URL_LEN)) &&
1423  (NULL != uri) &&
1425  {
1426  hostlist = GNUNET_malloc (sizeof(struct Hostlist) + strlen (uri) + 1);
1427  hostlist->hello_count = hellos_returned;
1428  hostlist->hostlist_uri = (const char *) &hostlist[1];
1429  GNUNET_memcpy (&hostlist[1], uri, strlen (uri) + 1);
1430  hostlist->quality = quality;
1431  hostlist->time_creation.abs_value_us = created;
1432  hostlist->time_last_usage.abs_value_us = last_used;
1434  linked_list_size++;
1436  "Added hostlist entry with URI `%s' \n",
1437  hostlist->hostlist_uri);
1438  GNUNET_free (uri);
1439  uri = NULL;
1440  counter++;
1441  if (counter >= MAX_NUMBER_HOSTLISTS)
1442  break;
1443  }
1444 
1446  _ ("%u hostlist URIs loaded from file\n"),
1447  counter);
1449  gettext_noop ("# hostlist URIs read from file"),
1450  counter,
1451  GNUNET_YES);
1453  gettext_noop ("# advertised hostlist URIs"),
1455  GNUNET_NO);
1456 
1457  GNUNET_free (uri);
1458  emsg = NULL;
1459  (void) GNUNET_BIO_read_close (rh, &emsg);
1460  if (emsg != NULL)
1461  GNUNET_free (emsg);
1463 }
1464 
1465 
1471 static void
1472 save_hostlist_file (int shutdown)
1473 {
1474  char *filename;
1475  struct Hostlist *pos;
1476  struct GNUNET_BIO_WriteHandle *wh;
1477  int ok;
1478  uint32_t counter;
1479 
1481  "HOSTLIST",
1482  "HOSTLISTFILE",
1483  &filename))
1484  {
1486  "hostlist",
1487  "HOSTLISTFILE");
1488  return;
1489  }
1491  {
1493  return;
1494  }
1496  if (NULL == wh)
1497  {
1499  _ (
1500  "Could not open file `%s' for writing to save hostlists: %s\n"),
1501  filename,
1502  strerror (errno));
1504  return;
1505  }
1507  _ ("Writing %u hostlist URIs to `%s'\n"),
1509  filename);
1510  /* add code to write hostlists to file using bio */
1511  ok = GNUNET_YES;
1512  counter = 0;
1513  while (NULL != (pos = linked_list_head))
1514  {
1515  if (GNUNET_YES == shutdown)
1516  {
1518  linked_list_size--;
1519  }
1520  if (GNUNET_YES == ok)
1521  {
1522  struct GNUNET_BIO_WriteSpec ws[] = {
1523  GNUNET_BIO_write_spec_string ("hostlist uri", pos->hostlist_uri),
1524  GNUNET_BIO_write_spec_int32 ("times used",
1525  (int32_t *) &pos->times_used),
1526  GNUNET_BIO_write_spec_int64 ("quality", (int64_t *) &pos->quality),
1528  "last usage",
1529  (int64_t *) &pos->time_last_usage.abs_value_us),
1531  "creation time",
1532  (int64_t *) &pos->time_creation.abs_value_us),
1533  GNUNET_BIO_write_spec_int32 ("hellos count",
1534  (int32_t *) &pos->hello_count),
1536  };
1537  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)))
1538  {
1540  _ ("Error writing hostlist URIs to file `%s'\n"),
1541  filename);
1542  ok = GNUNET_NO;
1543  }
1544  }
1545 
1546  if (GNUNET_YES == shutdown)
1547  GNUNET_free (pos);
1548  counter++;
1549  if (counter >= MAX_NUMBER_HOSTLISTS)
1550  break;
1551  }
1553  gettext_noop ("# hostlist URIs written to file"),
1554  counter,
1555  GNUNET_YES);
1556 
1557  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1559  _ ("Error writing hostlist URIs to file `%s'\n"),
1560  filename);
1562 }
1563 
1564 
1576 int
1578  struct GNUNET_STATISTICS_Handle *st,
1582  int learn)
1583 {
1584  char *filename;
1585  char *proxytype_str;
1586  int result;
1587 
1588  GNUNET_assert (NULL != st);
1589  if (0 != curl_global_init (CURL_GLOBAL_WIN32))
1590  {
1591  GNUNET_break (0);
1592  return GNUNET_SYSERR;
1593  }
1594  cfg = c;
1595  stats = st;
1596 
1597  /* Read proxy configuration */
1599  if (GNUNET_OK ==
1600  GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", "PROXY", &proxy))
1601  {
1602  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy);
1603  /* proxy username */
1605  "HOSTLIST",
1606  "PROXY_USERNAME",
1607  &proxy_username))
1608  {
1610  "Found proxy username name: `%s'\n",
1611  proxy_username);
1612  }
1613 
1614  /* proxy password */
1616  "HOSTLIST",
1617  "PROXY_PASSWORD",
1618  &proxy_password))
1619  {
1621  "Found proxy password name: `%s'\n",
1622  proxy_password);
1623  }
1624 
1625  /* proxy type */
1627  "HOSTLIST",
1628  "PROXY_TYPE",
1629  &proxytype_str))
1630  {
1631  if (GNUNET_OK != GNUNET_STRINGS_utf8_toupper (proxytype_str,
1632  proxytype_str))
1634  "Unable to convert `%s' to UTF-8 uppercase\n",
1635  proxytype_str);
1636  proxy_type = CURLPROXY_HTTP;
1637  if (0 == strcmp (proxytype_str, "HTTP"))
1638  proxy_type = CURLPROXY_HTTP;
1639  else if (0 == strcmp (proxytype_str, "HTTP_1_0"))
1640  proxy_type = CURLPROXY_HTTP_1_0;
1641  else if (0 == strcmp (proxytype_str, "SOCKS4"))
1642  proxy_type = CURLPROXY_SOCKS4;
1643  else if (0 == strcmp (proxytype_str, "SOCKS5"))
1644  proxy_type = CURLPROXY_SOCKS5;
1645  else if (0 == strcmp (proxytype_str, "SOCKS4A"))
1646  proxy_type = CURLPROXY_SOCKS4A;
1647  else if (0 == strcmp (proxytype_str, "SOCKS5_HOSTNAME"))
1648  proxy_type = CURLPROXY_SOCKS5_HOSTNAME;
1649  else
1650  {
1651  GNUNET_log (
1653  _ (
1654  "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
1655  proxytype_str);
1656  GNUNET_free (proxytype_str);
1657  GNUNET_free (proxy);
1658  proxy = NULL;
1660  proxy_username = NULL;
1662  proxy_password = NULL;
1663 
1664  return GNUNET_SYSERR;
1665  }
1666  }
1667  GNUNET_free (proxytype_str);
1668  }
1669 
1670  stat_learning = learn;
1671  *ch = &handler_connect;
1672  *dh = &handler_disconnect;
1673  linked_list_head = NULL;
1674  linked_list_tail = NULL;
1678 
1679  if (GNUNET_YES == stat_learning)
1680  {
1681  *msgh = &handler_advertisement;
1683  _ ("Learning is enabled on this peer\n"));
1684  load_hostlist_file ();
1686  "Hostlists will be saved to file again in %s\n",
1688  GNUNET_YES));
1691  NULL);
1692  }
1693  else
1694  {
1696  _ ("Learning is not enabled on this peer\n"));
1697  *msgh = NULL;
1699  "HOSTLIST",
1700  "HOSTLISTFILE",
1701  &filename))
1702  {
1704  {
1705  result = remove (filename);
1706  if (0 == result)
1707  GNUNET_log (
1709  _ (
1710  "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
1711  filename);
1712  else
1714  "remove",
1715  filename);
1716  }
1717  }
1719  }
1721  "Loading stats value on hostlist download frequency\n");
1723  "hostlist",
1724  gettext_noop (
1725  "# milliseconds between hostlist downloads"),
1726  &primary_task,
1727  &process_stat,
1728  NULL);
1729  if (NULL == sget)
1730  {
1732  "Statistics request failed, scheduling hostlist download\n");
1734  }
1735  else
1736  {
1739  NULL);
1740  }
1741  return GNUNET_OK;
1742 }
1743 
1744 
1748 void
1750 {
1751  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n");
1752  if (NULL != sget)
1753  {
1755  sget = NULL;
1756  }
1757  stats = NULL;
1758  if (GNUNET_YES == stat_learning)
1760  if (NULL != ti_saving_task)
1761  {
1763  ti_saving_task = NULL;
1764  }
1765  if (NULL != ti_download_dispatcher_task)
1766  {
1769  }
1770  if (NULL != ti_testing_intervall_task)
1771  {
1774  }
1775  if (NULL != ti_download)
1776  {
1778  ti_download = NULL;
1779  update_hostlist ();
1780  clean_up ();
1781  }
1782  if (NULL != ti_check_download)
1783  {
1785  ti_check_download = NULL;
1786  curl_global_cleanup ();
1787  }
1788  GNUNET_free (proxy);
1789  proxy = NULL;
1791  proxy_username = NULL;
1793  proxy_password = NULL;
1794  if (NULL != pi)
1795  {
1797  pi = NULL;
1798  }
1799  cfg = NULL;
1800 }
1801 
1802 
1803 /* end of gnunet-daemon-hostlist_client.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define gettext_noop(String)
Definition: gettext.h:69
static int once
Global to mark if we've run the initialization.
Definition: gnsrecord.c:68
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
common internal definitions for hostlist daemon
#define MAX_URL_LEN
How long can hostlist URLs be?
#define MAX_BYTES_PER_HOSTLISTS
How many bytes do we download at most from a hostlist server?
static void task_download_dispatcher(void *cls)
static unsigned int stat_download_successful
Value saying if hostlist download was successful.
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
#define SAVING_INTERVAL
Time interval hostlists are saved to disk.
static char * proxy
Proxy hostname or ip we are using (can be NULL).
static uint64_t checked_add(uint64_t val1, uint64_t val2)
Add val2 to val1 with overflow check.
#define HOSTLIST_SUCCESSFUL_HELLO
Value added for each valid HELLO received during a hostlist download.
static void handler_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a given peer disconnects.
static int process_stat(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
We've received the previous delay value from statistics.
static void task_check(void *cls)
Task that checks if we should try to download a hostlist.
#define MAX_NUMBER_HOSTLISTS
Maximum number of hostlist that are saved.
static int stat_download_in_progress
Value controlling if a hostlist download is running at the moment.
static void task_hostlist_saving(void *cls)
Task that writes hostlist entries to a file on a regular base.
static int stat_learning
Set if we are allowed to learn new hostlists and use them.
static char * download_get_url()
Method deciding if a preconfigured or advertisied hostlist is used on a 50:50 ratio.
static struct GNUNET_TIME_Relative hostlist_delay
Amount of time we wait between hostlist downloads.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
#define HOSTLIST_FAILED_DOWNLOAD
Value subtracted each time a hostlist download fails.
static void handler_advertisement(const char *uri)
Method called whenever an advertisement message arrives.
static unsigned int stat_use_bootstrap
Value saying if a preconfigured bootstrap server is used.
int GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_STATISTICS_Handle *st, GNUNET_CORE_ConnectEventHandler *ch, GNUNET_CORE_DisconnectEventHandler *dh, GNUNET_HOSTLIST_UriHandler *msgh, int learn)
Start downloading hostlists from hostlist servers as necessary.
static void * handler_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
static int stat_testing_allowed
Value controlling if a hostlist testing is allowed at the moment.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void insert_hostlist()
Method to insert a hostlist into the datastore.
static size_t download_pos
Number of bytes valid in 'download_buffer'.
static CURL * curl
Current CURL handle.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static char * current_url
Current URL that we are using.
static char * proxy_password
Proxy password we are using (can be NULL).
static void stat_timeout_task(void *cls)
Continuation called by the statistics code once we go the stat.
static unsigned int linked_list_size
Size of the linked list used to store hostlists.
static struct GNUNET_STATISTICS_GetHandle * sget
Handle for our statistics GET operation.
#define CURL_EASY_SETOPT(c, a, b)
#define WAITING_INTERVAL
Time interval for download dispatcher before a download is re-scheduled.
static void load_hostlist_file()
Method to load persistent hostlist file during hostlist client startup.
static struct GNUNET_SCHEDULER_Task * ti_testing_intervall_task
ID of the task controlling the locking between two hostlist tests.
static unsigned int stat_connection_count
Number of active connections (according to core service).
static int linked_list_contains(const char *uri)
Method to check if a URI is in hostlist linked list.
static CURLM * multi
Current multi-CURL handle.
#define HOSTLIST_INITIAL
Defines concerning the hostlist quality metric.
static size_t callback_download(void *ptr, size_t size, size_t nmemb, void *ctx)
Process downloaded bits by calling callback on each HELLO.
#define TESTING_INTERVAL
Time interval between two hostlist tests.
#define MIN_CONNECTIONS
Number of connections that we must have to NOT download hostlists anymore.
static void update_hostlist()
Method updating hostlist statistics.
static int stat_bogus_url
Set to GNUNET_YES if the current URL had some problems.
static void task_download(void *cls)
Task that is run when we are ready to receive more data from the hostlist server.
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
static void download_hostlist()
Main function that will download a hostlist and process its data.
void GNUNET_HOSTLIST_client_stop()
Stop downloading hostlists from hostlist servers as necessary.
static unsigned int stat_hellos_obtained
Value saying how many valid HELLO messages were obtained during download.
static char * get_bootstrap_server()
Obtain a hostlist URL that we should use.
static struct Hostlist * linked_list_tail
Tail of the linked list used to store hostlists.
static struct GNUNET_SCHEDULER_Task * ti_download
ID of the task downloading the hostlist.
static struct Hostlist * current_hostlist
Current hostlist used for downloading.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
static struct Hostlist * linked_list_get_lowest_quality()
Method returning the hostlist element with the lowest quality in the datastore.
static struct GNUNET_SCHEDULER_Task * ti_saving_task
ID of the task saving the hostlsit in a regular interval.
static void save_hostlist_file(int shutdown)
Method to save hostlist to a file during hostlist client shutdown.
static uint32_t stat_bytes_downloaded
How many bytes did we download from the current hostlist URL?
static char * proxy_username
Proxy username we are using (can be NULL).
#define HOSTLIST_SUCCESSFUL_DOWNLOAD
Value added each time a hostlist download is successful.
static struct GNUNET_SCHEDULER_Task * ti_download_dispatcher_task
ID of the task called to initiate a download.
static void clean_up()
Clean up the state from the task that downloaded the hostlist and schedule the next task.
static uint64_t checked_sub(uint64_t val1, uint64_t val2)
Subtract val2 from val1 with underflow check.
static curl_proxytype proxy_type
Proxy type we are using (can be NULL).
static void task_testing_intervall_reset(void *cls)
This tasks sets hostlist testing to allowed after interval between to testings is reached.
static void primary_task(void *cls, int success)
Continuation called by the statistics code once we go the stat.
static void download_prepare()
Ask CURL for the select set and then schedule the receiving task with the scheduler.
void(* GNUNET_HOSTLIST_UriHandler)(const char *uri)
Function that handles an advertised URI.
static char * filename
static char * value
Value of the record to add/remove.
static int ok
Return value from 'main' (0 == success)
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static int result
Global testing status.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
static char * subsystem
Set to subsystem that we're going to get stats for (or NULL for all).
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
library to make it easy to download JSON replies over HTTP
Helper library for handling HELLOs.
Maintain the list of currently known hosts.
API to create, modify and access statistics.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
int GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string.
Definition: bio.c:327
int GNUNET_BIO_write_spec_commit(struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
Execute the write specifications in order.
Definition: bio.c:1540
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:119
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:609
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string(const char *what, const char *s)
Create the specification to write a 0-terminated string.
Definition: bio.c:1336
#define GNUNET_BIO_read_spec_end()
End of specifications marker.
int GNUNET_BIO_read_spec_commit(struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
Execute the read specifications in order.
Definition: bio.c:1243
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int32(const char *what, int32_t *i)
Create the specification to read an (u)int32_t.
Definition: bio.c:1136
#define GNUNET_BIO_write_spec_end()
End of specifications marker.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:167
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:560
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int32(const char *what, int32_t *i)
Create the specification to write an (u)int32_t.
Definition: bio.c:1427
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int64(const char *what, int64_t *i)
Create the specification to read an (u)int64_t.
Definition: bio.c:1180
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int64(const char *what, int64_t *i)
Create the specification to write an (u)int64_t.
Definition: bio.c:1472
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
void(* GNUNET_CORE_DisconnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
Method called whenever a peer disconnects.
void *(* GNUNET_CORE_ConnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:652
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MIN(a, b)
@ GNUNET_SCHEDULER_PRIORITY_DEFAULT
Run with the default priority (normal P2P operations).
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1193
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1209
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
Definition: network.c:1063
struct GNUNET_MQ_Envelope * GNUNET_PEERINFO_add_peer(struct GNUNET_PEERINFO_Handle *h, const struct GNUNET_HELLO_Message *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Add a host to the persistent list.
Definition: peerinfo_api.c:553
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:130
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1826
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_STATISTICS_GetHandle * GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
Get statistic from the peer.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to upper case.
Definition: strings.c:472
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:342
#define GNUNET_TIME_UNIT_HOURS
One hour.
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:404
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:315
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:483
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:570
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
const char * name
Handle for buffered reading.
Definition: bio.c:74
Structure specifying a reading operation on an IO handle.
GNUNET_BIO_ReadHandler rh
Function performing data deserialization.
Handle for buffered writing.
Definition: bio.c:518
Structure specifying a writing operation on an IO handle.
A HELLO message is used to exchange information about transports with other peers.
Handle to a message queue.
Definition: mq.c:86
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
collection of IO descriptors
Handle to the peerinfo service.
Definition: peerinfo_api.c:85
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:135
Linked list of things we still need to do.
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
A single hostlist obtained by hostlist advertisements.
struct GNUNET_TIME_Absolute time_last_usage
Last time the hostlist was obtained.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
struct Hostlist * prev
previous entry, used to manage entries in a double linked list
uint32_t hello_count
Number of HELLO messages obtained during last download.
struct GNUNET_TIME_Absolute time_creation
Time the hostlist advertisement was received and the entry was created.
uint32_t times_used
Number of times the hostlist was successfully obtained.
struct Hostlist * next
next entry, used to manage entries in a double linked list
const char * hostlist_uri
URI where hostlist can be obtained.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.