GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
gnunet-daemon-hostlist_client.c File Reference

hostlist support. More...

#include "platform.h"
#include "gnunet-daemon-hostlist_client.h"
#include "gnunet_hello_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet-daemon-hostlist.h"
#include "gnunet_curl_lib.h"
Include dependency graph for gnunet-daemon-hostlist_client.c:

Go to the source code of this file.

Data Structures

struct  Hostlist
 A single hostlist obtained by hostlist advertisements. More...
 

Macros

#define MIN_CONNECTIONS   4
 Number of connections that we must have to NOT download hostlists anymore. More...
 
#define MAX_NUMBER_HOSTLISTS   30
 Maximum number of hostlist that are saved. More...
 
#define SAVING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
 Time interval hostlists are saved to disk. More...
 
#define TESTING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3)
 Time interval between two hostlist tests. More...
 
#define WAITING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
 Time interval for download dispatcher before a download is re-scheduled. More...
 
#define HOSTLIST_INITIAL   10000
 Defines concerning the hostlist quality metric. More...
 
#define HOSTLIST_FAILED_DOWNLOAD   100
 Value subtracted each time a hostlist download fails. More...
 
#define HOSTLIST_SUCCESSFUL_DOWNLOAD   100
 Value added each time a hostlist download is successful. More...
 
#define HOSTLIST_SUCCESSFUL_HELLO   1
 Value added for each valid HELLO recived during a hostlist download. More...
 
#define CURL_EASY_SETOPT(c, a, b)
 

Functions

static size_t callback_download (void *ptr, size_t size, size_t nmemb, void *ctx)
 Process downloaded bits by calling callback on each HELLO. More...
 
static char * get_bootstrap_server ()
 Obtain a hostlist URL that we should use. More...
 
static char * download_get_url ()
 Method deciding if a preconfigured or advertisied hostlist is used on a 50:50 ratio. More...
 
static void save_hostlist_file (int shutdown)
 Method to save hostlist to a file during hostlist client shutdown. More...
 
static uint64_t checked_add (uint64_t val1, uint64_t val2)
 Add val2 to val1 with overflow check. More...
 
static uint64_t checked_sub (uint64_t val1, uint64_t val2)
 Subtract val2 from val1 with underflow check. More...
 
static int linked_list_contains (const char *uri)
 Method to check if a URI is in hostlist linked list. More...
 
static struct Hostlistlinked_list_get_lowest_quality ()
 Method returning the hostlist element with the lowest quality in the datastore. More...
 
static void insert_hostlist ()
 Method to insert a hostlist into the datastore. More...
 
static void update_hostlist ()
 Method updating hostlist statistics. More...
 
static void clean_up ()
 Clean up the state from the task that downloaded the hostlist and schedule the next task. More...
 
static void task_download (void *cls)
 Task that is run when we are ready to receive more data from the hostlist server. More...
 
static void download_prepare ()
 Ask CURL for the select set and then schedule the receiving task with the scheduler. More...
 
static void download_hostlist ()
 Main function that will download a hostlist and process its data. More...
 
static void task_download_dispatcher (void *cls)
 
static void task_check (void *cls)
 Task that checks if we should try to download a hostlist. More...
 
static void task_testing_intervall_reset (void *cls)
 This tasks sets hostlist testing to allowed after intervall between to testings is reached. More...
 
static void task_hostlist_saving (void *cls)
 Task that writes hostlist entries to a file on a regular base. More...
 
static void * handler_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 Method called whenever a given peer connects. More...
 
static void handler_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
 Method called whenever a given peer disconnects. More...
 
static void handler_advertisement (const char *uri)
 Method called whenever an advertisement message arrives. More...
 
static void primary_task (void *cls, int success)
 Continuation called by the statistics code once we go the stat. More...
 
static void stat_timeout_task (void *cls)
 Continuation called by the statistics code once we go the stat. More...
 
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. More...
 
static void load_hostlist_file ()
 Method to load persistent hostlist file during hostlist client startup. More...
 
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. More...
 
void GNUNET_HOSTLIST_client_stop ()
 Stop downloading hostlists from hostlist servers as necessary. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_STATISTICS_Handlestats
 Statistics handle. More...
 
static char * proxy
 Proxy hostname or ip we are using (can be NULL). More...
 
static char * proxy_username
 Proxy username we are using (can be NULL). More...
 
static char * proxy_password
 Proxy password we are using (can be NULL). More...
 
static curl_proxytype proxy_type
 Proxy type we are using (can be NULL). More...
 
static size_t download_pos
 Number of bytes valid in 'download_buffer'. More...
 
static char * current_url
 Current URL that we are using. More...
 
static CURL * curl
 Current CURL handle. More...
 
static CURLM * multi
 Current multi-CURL handle. More...
 
static uint32_t stat_bytes_downloaded
 How many bytes did we download from the current hostlist URL? More...
 
static struct GNUNET_TIME_Relative hostlist_delay
 Amount of time we wait between hostlist downloads. More...
 
static struct GNUNET_SCHEDULER_Taskti_check_download
 ID of the task, checking if hostlist download should take plate. More...
 
static struct GNUNET_SCHEDULER_Taskti_download
 ID of the task downloading the hostlist. More...
 
static struct GNUNET_SCHEDULER_Taskti_saving_task
 ID of the task saving the hostlsit in a regular intervall. More...
 
static struct GNUNET_SCHEDULER_Taskti_download_dispatcher_task
 ID of the task called to initiate a download. More...
 
static struct GNUNET_SCHEDULER_Taskti_testing_intervall_task
 ID of the task controlling the locking between two hostlist tests. More...
 
static struct GNUNET_TIME_Absolute end_time
 At what time MUST the current hostlist request be done? More...
 
static struct Hostlistlinked_list_head
 Head of the linked list used to store hostlists. More...
 
static struct Hostlistlinked_list_tail
 Tail of the linked list used to store hostlists. More...
 
static struct Hostlistcurrent_hostlist
 Current hostlist used for downloading. More...
 
static unsigned int linked_list_size
 Size of the linke list used to store hostlists. More...
 
static struct Hostlisthostlist_to_test
 Head of the linked list used to store hostlists. More...
 
static struct GNUNET_STATISTICS_GetHandlesget
 Handle for our statistics GET operation. More...
 
static int stat_bogus_url
 Set to GNUNET_YES if the current URL had some problems. More...
 
static int stat_testing_hostlist
 Value controlling if a hostlist is tested at the moment. More...
 
static int stat_testing_allowed
 Value controlling if a hostlist testing is allowed at the moment. More...
 
static int stat_download_in_progress
 Value controlling if a hostlist download is running at the moment. More...
 
static unsigned int stat_use_bootstrap
 Value saying if a preconfigured bootstrap server is used. More...
 
static int stat_learning
 Set if we are allowed to learn new hostlists and use them. More...
 
static unsigned int stat_download_successful
 Value saying if hostlist download was successful. More...
 
static unsigned int stat_hellos_obtained
 Value saying how many valid HELLO messages were obtained during download. More...
 
static unsigned int stat_connection_count
 Number of active connections (according to core service). More...
 
static struct GNUNET_PEERINFO_Handlepi
 Handle to peerinfo service. More...
 

Detailed Description

hostlist support.

Downloads HELLOs via HTTP.

Author
Christian Grothoff
Matthias Wachs

Definition in file gnunet-daemon-hostlist_client.c.

Macro Definition Documentation

◆ MIN_CONNECTIONS

#define MIN_CONNECTIONS   4

Number of connections that we must have to NOT download hostlists anymore.

Definition at line 41 of file gnunet-daemon-hostlist_client.c.

Referenced by task_check().

◆ MAX_NUMBER_HOSTLISTS

#define MAX_NUMBER_HOSTLISTS   30

Maximum number of hostlist that are saved.

Definition at line 46 of file gnunet-daemon-hostlist_client.c.

Referenced by insert_hostlist(), load_hostlist_file(), and save_hostlist_file().

◆ SAVING_INTERVAL

#define SAVING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)

Time interval hostlists are saved to disk.

Definition at line 51 of file gnunet-daemon-hostlist_client.c.

Referenced by GNUNET_HOSTLIST_client_start(), and task_hostlist_saving().

◆ TESTING_INTERVAL

#define TESTING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3)

Time interval between two hostlist tests.

Definition at line 57 of file gnunet-daemon-hostlist_client.c.

Referenced by handler_advertisement().

◆ WAITING_INTERVAL

#define WAITING_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)

Time interval for download dispatcher before a download is re-scheduled.

Definition at line 63 of file gnunet-daemon-hostlist_client.c.

Referenced by task_download_dispatcher().

◆ HOSTLIST_INITIAL

#define HOSTLIST_INITIAL   10000

Defines concerning the hostlist quality metric.

Initial quality of a new created hostlist

Definition at line 73 of file gnunet-daemon-hostlist_client.c.

Referenced by handler_advertisement().

◆ HOSTLIST_FAILED_DOWNLOAD

#define HOSTLIST_FAILED_DOWNLOAD   100

Value subtracted each time a hostlist download fails.

Definition at line 78 of file gnunet-daemon-hostlist_client.c.

Referenced by update_hostlist().

◆ HOSTLIST_SUCCESSFUL_DOWNLOAD

#define HOSTLIST_SUCCESSFUL_DOWNLOAD   100

Value added each time a hostlist download is successful.

Definition at line 83 of file gnunet-daemon-hostlist_client.c.

Referenced by update_hostlist().

◆ HOSTLIST_SUCCESSFUL_HELLO

#define HOSTLIST_SUCCESSFUL_HELLO   1

Value added for each valid HELLO recived during a hostlist download.

Definition at line 88 of file gnunet-daemon-hostlist_client.c.

Referenced by update_hostlist().

◆ CURL_EASY_SETOPT

#define CURL_EASY_SETOPT (   c,
  a,
 
)
Value:
do \
{ \
ret = curl_easy_setopt(c, a, b); \
if (CURLE_OK != ret) \
_("%s failed at %s:%d: `%s'\n"), \
"curl_easy_setopt", \
__FILE__, \
__LINE__, \
curl_easy_strerror(ret)); \
} while (0)
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:181

Definition at line 537 of file gnunet-daemon-hostlist_client.c.

Referenced by download_hostlist().

Function Documentation

◆ callback_download()

static size_t callback_download ( void *  ptr,
size_t  size,
size_t  nmemb,
void *  ctx 
)
static

Process downloaded bits by calling callback on each HELLO.

Parameters
ptrbuffer with downloaded data
sizesize of a record
nmembnumber of records downloaded
ctxunused
Returns
number of bytes that were processed (always size*nmemb)

Definition at line 323 of file gnunet-daemon-hostlist_client.c.

References _, current_url, download_pos, gettext_noop, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_size(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_PEERINFO_add_peer(), GNUNET_STATISTICS_update(), GNUNET_YES, msg, GNUNET_MessageHeader::size, stat_bogus_url, stat_bytes_downloaded, and stat_hellos_obtained.

Referenced by download_hostlist().

324 {
325  static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1];
326  const char *cbuf = ptr;
327  const struct GNUNET_MessageHeader *msg;
328  size_t total;
329  size_t cpy;
330  size_t left;
331  uint16_t msize;
332 
333  total = size * nmemb;
334  stat_bytes_downloaded += total;
335  if ((total == 0) || (stat_bogus_url))
336  {
337  return total; /* ok, no data or bogus data */
338  }
339 
341  gettext_noop(
342  "# bytes downloaded from hostlist servers"),
343  (int64_t)total,
344  GNUNET_NO);
345  left = total;
346  while ((left > 0) || (download_pos > 0))
347  {
349  GNUNET_memcpy(&download_buffer[download_pos], cbuf, cpy);
350  cbuf += cpy;
351  download_pos += cpy;
352  left -= cpy;
353  if (download_pos < sizeof(struct GNUNET_MessageHeader))
354  {
355  GNUNET_assert(0 == left);
356  break;
357  }
358  msg = (const struct GNUNET_MessageHeader *)download_buffer;
359  msize = ntohs(msg->size);
360  if (msize < sizeof(struct GNUNET_MessageHeader))
361  {
363  stats,
364  gettext_noop("# invalid HELLOs downloaded from hostlist servers"),
365  1,
366  GNUNET_NO);
368  _("Invalid `%s' message received from hostlist at `%s'\n"),
369  "HELLO",
370  current_url);
372  stat_bogus_url = 1;
373  return total;
374  }
375  if (download_pos < msize)
376  {
377  GNUNET_assert(left == 0);
378  break;
379  }
380  if (GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)msg) == msize)
381  {
383  "Received valid `%s' message from hostlist server.\n",
384  "HELLO");
386  stats,
387  gettext_noop("# valid HELLOs downloaded from hostlist servers"),
388  1,
389  GNUNET_NO);
391  (void)
393  (const struct GNUNET_HELLO_Message *)msg,
394  NULL,
395  NULL);
396  }
397  else
398  {
400  stats,
401  gettext_noop("# invalid HELLOs downloaded from hostlist servers"),
402  1,
403  GNUNET_NO);
405  _("Invalid `%s' message received from hostlist at `%s'\n"),
406  "HELLO",
407  current_url);
410  return total;
411  }
412  memmove(download_buffer, &download_buffer[msize], download_pos - msize);
413  download_pos -= msize;
414  }
415  return total;
416 }
A HELLO message is used to exchange information about transports with other peers.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
static size_t download_pos
Number of bytes valid in &#39;download_buffer&#39;.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static char * current_url
Current URL that we are using.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
static int stat_bogus_url
Set to GNUNET_YES if the current URL had some problems.
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:552
static unsigned int size
Size of the "table".
Definition: peer.c:66
static unsigned int stat_hellos_obtained
Value saying how many valid HELLO messages were obtained during download.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
#define GNUNET_log(kind,...)
static uint32_t stat_bytes_downloaded
How many bytes did we download from the current hostlist URL?
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:643
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_bootstrap_server()

static char* get_bootstrap_server ( )
static

Obtain a hostlist URL that we should use.

Returns
NULL if there is no URL available

Definition at line 425 of file gnunet-daemon-hostlist_client.c.

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_strdup, and ret.

Referenced by download_get_url().

426 {
427  char *servers;
428  char *ret;
429  size_t urls;
430  size_t pos;
431 
433  "HOSTLIST",
434  "SERVERS",
435  &servers))
436  {
438  "hostlist",
439  "SERVERS");
440  return NULL;
441  }
442 
443  urls = 0;
444  if (strlen(servers) > 0)
445  {
446  urls++;
447  pos = strlen(servers) - 1;
448  while (pos > 0)
449  {
450  if (servers[pos] == ' ')
451  urls++;
452  pos--;
453  }
454  }
455  if (urls == 0)
456  {
458  "hostlist",
459  "SERVERS");
460  GNUNET_free(servers);
461  return NULL;
462  }
463 
465  pos = strlen(servers) - 1;
466  while (pos > 0)
467  {
468  if (servers[pos] == ' ')
469  {
470  urls--;
471  servers[pos] = '\0';
472  }
473  if (urls == 0)
474  {
475  pos++;
476  break;
477  }
478  pos--;
479  }
480  ret = GNUNET_strdup(&servers[pos]);
481  GNUNET_free(servers);
482  return ret;
483 }
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
int 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.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ download_get_url()

static char* download_get_url ( )
static

Method deciding if a preconfigured or advertisied hostlist is used on a 50:50 ratio.

Returns
uri to use, NULL if there is no URL available

Definition at line 491 of file gnunet-daemon-hostlist_client.c.

References get_bootstrap_server(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_strdup, GNUNET_YES, hostlist_to_test, Hostlist::hostlist_uri, linked_list_head, linked_list_size, Hostlist::next, stat_learning, stat_testing_hostlist, and stat_use_bootstrap.

Referenced by download_hostlist().

492 {
493  uint32_t index;
494  unsigned int counter;
495  struct Hostlist *pos;
496 
497  if (GNUNET_NO == stat_learning)
498  {
500  "Using preconfigured bootstrap server\n");
501  current_hostlist = NULL;
502  return get_bootstrap_server();
503  }
504 
505  if ((GNUNET_YES == stat_testing_hostlist) && (NULL != hostlist_to_test))
506  {
508  "Testing new advertised hostlist if it is obtainable\n");
511  }
512 
514  {
516  "Using preconfigured bootstrap server\n");
517  current_hostlist = NULL;
518  return get_bootstrap_server();
519  }
520  index =
522  counter = 0;
523  pos = linked_list_head;
524  while (counter < index)
525  {
526  pos = pos->next;
527  counter++;
528  }
530  "Using learned hostlist `%s'\n",
531  pos->hostlist_uri);
532  current_hostlist = pos;
533  return GNUNET_strdup(pos->hostlist_uri);
534 }
static int stat_learning
Set if we are allowed to learn new hostlists and use them.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct Hostlist * next
next entry, used to manage entries in a double linked list
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
const char * hostlist_uri
URI where hostlist can be obtained.
static unsigned int stat_use_bootstrap
Value saying if a preconfigured bootstrap server is used.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
static struct Hostlist * current_hostlist
Current hostlist used for downloading.
static char * get_bootstrap_server()
Obtain a hostlist URL that we should use.
static unsigned int linked_list_size
Size of the linke list used to store hostlists.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
A single hostlist obtained by hostlist advertisements.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ save_hostlist_file()

static void save_hostlist_file ( int  shutdown)
static

Method to save hostlist to a file during hostlist client shutdown.

Method to save persistent hostlist file during hostlist client shutdown.

Parameters
shutdownset if called because of shutdown, entries in linked list will be destroyed

Definition at line 1473 of file gnunet-daemon-hostlist_client.c.

References _, GNUNET_TIME_Absolute::abs_value_us, filename, gettext_noop, GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_open(), GNUNET_BIO_write_string(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_YES, Hostlist::hello_count, Hostlist::hostlist_uri, linked_list_size, MAX_NUMBER_HOSTLISTS, ok, Hostlist::quality, Hostlist::time_creation, Hostlist::time_last_usage, Hostlist::times_used, and wh.

Referenced by GNUNET_HOSTLIST_client_stop(), and task_hostlist_saving().

1474 {
1475  char *filename;
1476  struct Hostlist *pos;
1477  struct GNUNET_BIO_WriteHandle *wh;
1478  int ok;
1479  uint32_t counter;
1480 
1482  "HOSTLIST",
1483  "HOSTLISTFILE",
1484  &filename))
1485  {
1487  "hostlist",
1488  "HOSTLISTFILE");
1489  return;
1490  }
1492  {
1493  GNUNET_free(filename);
1494  return;
1495  }
1496  wh = GNUNET_BIO_write_open(filename);
1497  if (NULL == wh)
1498  {
1500  _(
1501  "Could not open file `%s' for writing to save hostlists: %s\n"),
1502  filename,
1503  strerror(errno));
1504  GNUNET_free(filename);
1505  return;
1506  }
1508  _("Writing %u hostlist URIs to `%s'\n"),
1510  filename);
1511  /* add code to write hostlists to file using bio */
1512  ok = GNUNET_YES;
1513  counter = 0;
1514  while (NULL != (pos = linked_list_head))
1515  {
1516  if (GNUNET_YES == shutdown)
1517  {
1519  linked_list_size--;
1520  }
1521  if (GNUNET_YES == ok)
1522  {
1523  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, pos->hostlist_uri)) ||
1524  (GNUNET_OK != GNUNET_BIO_write_int32(wh, pos->times_used)) ||
1525  (GNUNET_OK != GNUNET_BIO_write_int64(wh, pos->quality)) ||
1526  (GNUNET_OK !=
1528  (GNUNET_OK !=
1531  {
1533  _("Error writing hostlist URIs to file `%s'\n"),
1534  filename);
1535  ok = GNUNET_NO;
1536  }
1537  }
1538 
1539  if (GNUNET_YES == shutdown)
1540  GNUNET_free(pos);
1541  counter++;
1542  if (counter >= MAX_NUMBER_HOSTLISTS)
1543  break;
1544  }
1546  gettext_noop("# hostlist URIs written to file"),
1547  counter,
1548  GNUNET_YES);
1549 
1550  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
1552  _("Error writing hostlist URIs to file `%s'\n"),
1553  filename);
1554  GNUNET_free(filename);
1555 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_TIME_Absolute time_last_usage
Last time the hostlist was obtained.
struct GNUNET_TIME_Absolute time_creation
Time the hostlist advertisement was recieved and the entry was created.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:521
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, int64_t i)
Write an (u)int64_t.
Definition: bio.c:597
static int ok
Return value from &#39;main&#39; (0 == success)
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:681
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint64_t abs_value_us
The actual value.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
uint32_t hello_count
Number of HELLO messages obtained during last download.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * filename
const char * hostlist_uri
URI where hostlist can be obtained.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
Handle for buffered writing.
Definition: bio.c:378
static struct Hostlist * linked_list_tail
Tail of the linked list used to store hostlists.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static unsigned int linked_list_size
Size of the linke list used to store hostlists.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:436
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open(const char *fn)
Open a file for writing.
Definition: bio.c:408
uint32_t times_used
Number of times the hostlist was successfully obtained.
#define GNUNET_log(kind,...)
int 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.
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:580
#define MAX_NUMBER_HOSTLISTS
Maximum number of hostlist that are saved.
#define GNUNET_YES
Definition: gnunet_common.h:77
A single hostlist obtained by hostlist advertisements.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ checked_add()

static uint64_t checked_add ( uint64_t  val1,
uint64_t  val2 
)
static

Add val2 to val1 with overflow check.

Parameters
val1value 1
val2value 2
Returns
result

Definition at line 568 of file gnunet-daemon-hostlist_client.c.

Referenced by update_hostlist().

569 {
570  static uint64_t temp;
571  static uint64_t maxv;
572 
573  maxv = 0;
574  maxv--;
575 
576  temp = val1 + val2;
577  if (temp < val1)
578  return maxv;
579  return temp;
580 }
Here is the caller graph for this function:

◆ checked_sub()

static uint64_t checked_sub ( uint64_t  val1,
uint64_t  val2 
)
static

Subtract val2 from val1 with underflow check.

Parameters
val1value 1
val2value 2
Returns
result

Definition at line 591 of file gnunet-daemon-hostlist_client.c.

Referenced by update_hostlist().

592 {
593  if (val1 <= val2)
594  return 0;
595  return(val1 - val2);
596 }
Here is the caller graph for this function:

◆ linked_list_contains()

static int linked_list_contains ( const char *  uri)
static

Method to check if a URI is in hostlist linked list.

Parameters
uriuri to check
Returns
GNUNET_YES if existing in linked list, GNUNET_NO if not

Definition at line 606 of file gnunet-daemon-hostlist_client.c.

References GNUNET_NO, GNUNET_YES, Hostlist::hostlist_uri, linked_list_head, and Hostlist::next.

Referenced by handler_advertisement().

607 {
608  struct Hostlist *pos;
609 
610  pos = linked_list_head;
611  while (pos != NULL)
612  {
613  if (0 == strcmp(pos->hostlist_uri, uri))
614  return GNUNET_YES;
615  pos = pos->next;
616  }
617  return GNUNET_NO;
618 }
#define GNUNET_NO
Definition: gnunet_common.h:78
struct Hostlist * next
next entry, used to manage entries in a double linked list
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
const char * hostlist_uri
URI where hostlist can be obtained.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
#define GNUNET_YES
Definition: gnunet_common.h:77
A single hostlist obtained by hostlist advertisements.
Here is the caller graph for this function:

◆ linked_list_get_lowest_quality()

static struct Hostlist* linked_list_get_lowest_quality ( )
static

Method returning the hostlist element with the lowest quality in the datastore.

Returns
hostlist with lowest quality

Definition at line 626 of file gnunet-daemon-hostlist_client.c.

References linked_list_head, linked_list_size, Hostlist::next, and Hostlist::quality.

Referenced by insert_hostlist().

627 {
628  struct Hostlist *pos;
629  struct Hostlist *lowest;
630 
631  if (linked_list_size == 0)
632  return NULL;
633  lowest = linked_list_head;
634  pos = linked_list_head->next;
635  while (pos != NULL)
636  {
637  if (pos->quality < lowest->quality)
638  lowest = pos;
639  pos = pos->next;
640  }
641  return lowest;
642 }
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
struct Hostlist * next
next entry, used to manage entries in a double linked list
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
static unsigned int linked_list_size
Size of the linke list used to store hostlists.
A single hostlist obtained by hostlist advertisements.
Here is the caller graph for this function:

◆ insert_hostlist()

static void insert_hostlist ( )
static

Method to insert a hostlist into the datastore.

If datastore contains maximum number of elements, the elements with lowest quality is dismissed

Definition at line 651 of file gnunet-daemon-hostlist_client.c.

References gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), Hostlist::hostlist_uri, linked_list_get_lowest_quality(), linked_list_size, MAX_NUMBER_HOSTLISTS, Hostlist::quality, and stat_testing_hostlist.

Referenced by task_download().

652 {
653  struct Hostlist *lowest_quality;
654 
656  {
657  /* No free entries available, replace existing entry */
658  lowest_quality = linked_list_get_lowest_quality();
659  GNUNET_assert(lowest_quality != NULL);
660  GNUNET_log(
662  "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n",
663  lowest_quality->hostlist_uri,
664  (unsigned long long)lowest_quality->quality);
667  lowest_quality);
669  GNUNET_free(lowest_quality);
670  }
676  gettext_noop("# advertised hostlist URIs"),
678  GNUNET_NO);
680 }
#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.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * hostlist_uri
URI where hostlist can be obtained.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
static struct Hostlist * linked_list_tail
Tail of the linked list used to store hostlists.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static unsigned int linked_list_size
Size of the linke list used to store hostlists.
#define GNUNET_log(kind,...)
static struct Hostlist * linked_list_get_lowest_quality()
Method returning the hostlist element with the lowest quality in the datastore.
#define MAX_NUMBER_HOSTLISTS
Maximum number of hostlist that are saved.
A single hostlist obtained by hostlist advertisements.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_hostlist()

static void update_hostlist ( )
static

Method updating hostlist statistics.

Definition at line 687 of file gnunet-daemon-hostlist_client.c.

References checked_add(), checked_sub(), gettext_noop, GNUNET_asprintf(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_YES, Hostlist::hello_count, HOSTLIST_FAILED_DOWNLOAD, HOSTLIST_SUCCESSFUL_DOWNLOAD, HOSTLIST_SUCCESSFUL_HELLO, Hostlist::hostlist_uri, Hostlist::quality, stat_download_successful, stat_hellos_obtained, stat_learning, stat_testing_hostlist, stat_use_bootstrap, Hostlist::time_last_usage, and Hostlist::times_used.

Referenced by GNUNET_HOSTLIST_client_stop(), and task_download().

688 {
689  char *stat;
690 
691  if (((stat_use_bootstrap == GNUNET_NO) && (NULL != current_hostlist)) ||
693  {
695  "Updating hostlist statics for URI `%s'\n",
703  {
707  GNUNET_asprintf(&stat,
708  gettext_noop("# advertised URI `%s' downloaded"),
710 
712  GNUNET_free(stat);
713  }
714  else
717  }
718  current_hostlist = NULL;
719  /* Alternating the usage of preconfigured and learned hostlists */
720 
722  return;
723 
724  if (GNUNET_YES == stat_learning)
725  {
728  else
730  }
731  else
733 }
struct GNUNET_TIME_Absolute time_last_usage
Last time the hostlist was obtained.
static uint64_t checked_add(uint64_t val1, uint64_t val2)
Add val2 to val1 with overflow check.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
static int stat_learning
Set if we are allowed to learn new hostlists and use them.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define HOSTLIST_SUCCESSFUL_HELLO
Value added for each valid HELLO recived during a hostlist download.
uint32_t hello_count
Number of HELLO messages obtained during last download.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static unsigned int stat_download_successful
Value saying if hostlist download was successful.
const char * hostlist_uri
URI where hostlist can be obtained.
static unsigned int stat_use_bootstrap
Value saying if a preconfigured bootstrap server is used.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct Hostlist * current_hostlist
Current hostlist used for downloading.
#define HOSTLIST_SUCCESSFUL_DOWNLOAD
Value added each time a hostlist download is successful.
static unsigned int stat_hellos_obtained
Value saying how many valid HELLO messages were obtained during download.
uint32_t times_used
Number of times the hostlist was successfully obtained.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
#define HOSTLIST_FAILED_DOWNLOAD
Value subtracted each time a hostlist download fails.
static uint64_t checked_sub(uint64_t val1, uint64_t val2)
Subtract val2 from val1 with underflow check.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ clean_up()

static void clean_up ( )
static

Clean up the state from the task that downloaded the hostlist and schedule the next task.

Definition at line 741 of file gnunet-daemon-hostlist_client.c.

References _, curl, current_url, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_NO, GNUNET_YES, Hostlist::hostlist_uri, multi, stat_bytes_downloaded, stat_download_in_progress, stat_download_successful, stat_testing_hostlist, and task_download().

Referenced by download_hostlist(), download_prepare(), GNUNET_HOSTLIST_client_stop(), and task_download().

742 {
743  CURLMcode mret;
744 
747  {
748  GNUNET_log(
750  _(
751  "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"),
753  }
754 
756  {
758  }
759  if (NULL != hostlist_to_test)
760  {
762  hostlist_to_test = NULL;
763  }
764 
765  if (NULL != multi)
766  {
767  mret = curl_multi_remove_handle(multi, curl);
768  if (mret != CURLM_OK)
769  {
771  _("%s failed at %s:%d: `%s'\n"),
772  "curl_multi_remove_handle",
773  __FILE__,
774  __LINE__,
775  curl_multi_strerror(mret));
776  }
777  mret = curl_multi_cleanup(multi);
778  if (mret != CURLM_OK)
780  _("%s failed at %s:%d: `%s'\n"),
781  "curl_multi_cleanup",
782  __FILE__,
783  __LINE__,
784  curl_multi_strerror(mret));
785  multi = NULL;
786  }
787  if (NULL != curl)
788  {
789  curl_easy_cleanup(curl);
790  curl = NULL;
791  }
793  current_url = NULL;
796 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static char * current_url
Current URL that we are using.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static CURLM * multi
Current multi-CURL handle.
static unsigned int stat_download_successful
Value saying if hostlist download was successful.
const char * hostlist_uri
URI where hostlist can be obtained.
static CURL * curl
Current CURL handle.
#define GNUNET_log(kind,...)
static uint32_t stat_bytes_downloaded
How many bytes did we download from the current hostlist URL?
#define GNUNET_YES
Definition: gnunet_common.h:77
static int stat_download_in_progress
Value controlling if a hostlist download is running at the moment.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ task_download()

static void task_download ( void *  cls)
static

Task that is run when we are ready to receive more data from the hostlist server.

Parameters
clsclosure, unused
tctask context, unused
clsclosure, unused

Definition at line 882 of file gnunet-daemon-hostlist_client.c.

References _, clean_up(), current_url, download_prepare(), end_time, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, insert_hostlist(), MAX_BYTES_PER_HOSTLISTS, msg, multi, stat_bytes_downloaded, stat_download_successful, stat_testing_hostlist, and update_hostlist().

Referenced by clean_up(), and download_prepare().

883 {
884  int running;
885  struct CURLMsg *msg;
886  CURLMcode mret;
887 
888  ti_download = NULL;
889  if (0 == GNUNET_TIME_absolute_get_remaining(end_time).rel_value_us)
890  {
892  _("Timeout trying to download hostlist from `%s'\n"),
893  current_url);
894  update_hostlist();
895  clean_up();
896  return;
897  }
899  "Ready for processing hostlist client request\n");
900  do
901  {
902  running = 0;
904  {
906  _(
907  "Download limit of %u bytes exceeded, stopping download\n"),
909  clean_up();
910  return;
911  }
912  mret = curl_multi_perform(multi, &running);
913  if (running == 0)
914  {
915  do
916  {
917  msg = curl_multi_info_read(multi, &running);
918  GNUNET_break(msg != NULL);
919  if (msg == NULL)
920  break;
921  switch (msg->msg)
922  {
923  case CURLMSG_DONE:
924  if ((msg->data.result != CURLE_OK) &&
925  (msg->data.result != CURLE_GOT_NOTHING))
927  _("Download of hostlist from `%s' failed: `%s'\n"),
928  current_url,
929  curl_easy_strerror(msg->data.result));
930  else
931  {
933  _("Download of hostlist `%s' completed.\n"),
934  current_url);
936  update_hostlist();
938  {
939  GNUNET_log(
941  _("Adding successfully tested hostlist `%s' datastore.\n"),
942  current_url);
943  insert_hostlist();
944  hostlist_to_test = NULL;
946  }
947  }
948  clean_up();
949  return;
950 
951  default:
952  break;
953  }
954  }
955  while ((running > 0));
956  }
957  }
958  while (mret == CURLM_CALL_MULTI_PERFORM);
959 
960  if (mret != CURLM_OK)
961  {
963  _("%s failed at %s:%d: `%s'\n"),
964  "curl_multi_perform",
965  __FILE__,
966  __LINE__,
967  curl_multi_strerror(mret));
968  clean_up();
969  }
971 }
#define MAX_BYTES_PER_HOSTLISTS
How many bytes do we download at most from a hostlist server?
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
static struct GNUNET_SCHEDULER_Task * ti_download
ID of the task downloading the hostlist.
#define GNUNET_NO
Definition: gnunet_common.h:78
static void update_hostlist()
Method updating hostlist statistics.
static char * current_url
Current URL that we are using.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void insert_hostlist()
Method to insert a hostlist into the datastore.
static CURLM * multi
Current multi-CURL handle.
static unsigned int stat_download_successful
Value saying if hostlist download was successful.
static void download_prepare()
Ask CURL for the select set and then schedule the receiving task with the scheduler.
static void clean_up()
Clean up the state from the task that downloaded the hostlist and schedule the next task...
#define GNUNET_log(kind,...)
static uint32_t stat_bytes_downloaded
How many bytes did we download from the current hostlist URL?
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:331
#define GNUNET_YES
Definition: gnunet_common.h:77
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ download_prepare()

static void download_prepare ( )
static

Ask CURL for the select set and then schedule the receiving task with the scheduler.

Definition at line 815 of file gnunet-daemon-hostlist_client.c.

References _, clean_up(), end_time, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, multi, task_download(), and timeout.

Referenced by download_hostlist(), and task_download().

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 }
static void task_download(void *cls)
Task that is run when we are ready to receive more data from the hostlist server. ...
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
static struct GNUNET_SCHEDULER_Task * ti_download
ID of the task downloading the hostlist.
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:1108
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1254
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1238
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
static CURLM * multi
Current multi-CURL handle.
collection of IO descriptors
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:1784
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:440
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
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:272
static void clean_up()
Clean up the state from the task that downloaded the hostlist and schedule the next task...
#define GNUNET_log(kind,...)
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:331
Run with the default priority (normal P2P operations).
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ download_hostlist()

static void download_hostlist ( )
static

Main function that will download a hostlist and process its data.

Definition at line 979 of file gnunet-daemon-hostlist_client.c.

References _, callback_download(), clean_up(), curl, CURL_EASY_SETOPT, current_url, download_get_url(), download_pos, download_prepare(), end_time, gettext_noop, GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, multi, proxy, proxy_password, proxy_type, proxy_username, ret, stat_bogus_url, stat_bytes_downloaded, stat_download_in_progress, stat_download_successful, and stat_hellos_obtained.

Referenced by task_download_dispatcher().

980 {
981  CURLcode ret;
982  CURLMcode mret;
983 
984 
986  if (current_url == NULL)
987  return;
988  curl = curl_easy_init();
989  multi = NULL;
990  if (curl == NULL)
991  {
992  GNUNET_break(0);
993  clean_up();
994  return;
995  }
997  _("Bootstrapping using hostlist at `%s'.\n"),
998  current_url);
999 
1004 
1006  gettext_noop("# hostlist downloads initiated"),
1007  1,
1008  GNUNET_NO);
1009  if (NULL != proxy)
1010  {
1011  CURL_EASY_SETOPT(curl, CURLOPT_PROXY, proxy);
1012  CURL_EASY_SETOPT(curl, CURLOPT_PROXYTYPE, proxy_type);
1013  if (NULL != proxy_username)
1014  CURL_EASY_SETOPT(curl, CURLOPT_PROXYUSERNAME, proxy_username);
1015  if (NULL != proxy_password)
1016  CURL_EASY_SETOPT(curl, CURLOPT_PROXYPASSWORD, proxy_password);
1017  }
1018  download_pos = 0;
1019  stat_bogus_url = 0;
1020  CURL_EASY_SETOPT(curl, CURLOPT_WRITEFUNCTION, &callback_download);
1021  if (ret != CURLE_OK)
1022  {
1023  clean_up();
1024  return;
1025  }
1026  CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, NULL);
1027  if (ret != CURLE_OK)
1028  {
1029  clean_up();
1030  return;
1031  }
1032  CURL_EASY_SETOPT(curl, CURLOPT_FOLLOWLOCATION, 1);
1034  CURLOPT_REDIR_PROTOCOLS,
1035  CURLPROTO_HTTP | CURLPROTO_HTTPS);
1036  CURL_EASY_SETOPT(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
1037  CURL_EASY_SETOPT(curl, CURLOPT_MAXREDIRS, 4);
1038  /* no need to abort if the above failed */
1039  CURL_EASY_SETOPT(curl, CURLOPT_URL, current_url);
1040  if (ret != CURLE_OK)
1041  {
1042  clean_up();
1043  return;
1044  }
1045  CURL_EASY_SETOPT(curl, CURLOPT_FAILONERROR, 1);
1046 #if 0
1047  CURL_EASY_SETOPT(curl, CURLOPT_VERBOSE, 1);
1048 #endif
1049  CURL_EASY_SETOPT(curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE);
1050  if (0 == strncmp(current_url, "http", 4))
1051  CURL_EASY_SETOPT(curl, CURLOPT_USERAGENT, "GNUnet");
1052  CURL_EASY_SETOPT(curl, CURLOPT_CONNECTTIMEOUT, 60L);
1053  CURL_EASY_SETOPT(curl, CURLOPT_TIMEOUT, 60L);
1054  multi = curl_multi_init();
1055  if (multi == NULL)
1056  {
1057  GNUNET_break(0);
1058  /* clean_up (); */
1059  return;
1060  }
1061  mret = curl_multi_add_handle(multi, curl);
1062  if (mret != CURLM_OK)
1063  {
1065  _("%s failed at %s:%d: `%s'\n"),
1066  "curl_multi_add_handle",
1067  __FILE__,
1068  __LINE__,
1069  curl_multi_strerror(mret));
1070  mret = curl_multi_cleanup(multi);
1071  if (mret != CURLM_OK)
1073  _("%s failed at %s:%d: `%s'\n"),
1074  "curl_multi_cleanup",
1075  __FILE__,
1076  __LINE__,
1077  curl_multi_strerror(mret));
1078  multi = NULL;
1079  clean_up();
1080  return;
1081  }
1083  download_prepare();
1084 }
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
#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:246
static curl_proxytype proxy_type
Proxy type we are using (can be NULL).
#define GNUNET_NO
Definition: gnunet_common.h:78
static size_t download_pos
Number of bytes valid in &#39;download_buffer&#39;.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static char * proxy_username
Proxy username we are using (can be NULL).
static int ret
Final status code.
Definition: gnunet-arm.c:89
static char * current_url
Current URL that we are using.
static char * proxy
Proxy hostname or ip we are using (can be NULL).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define CURL_EASY_SETOPT(c, a, b)
static char * proxy_password
Proxy password we are using (can be NULL).
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static CURLM * multi
Current multi-CURL handle.
static unsigned int stat_download_successful
Value saying if hostlist download was successful.
static int stat_bogus_url
Set to GNUNET_YES if the current URL had some problems.
static size_t callback_download(void *ptr, size_t size, size_t nmemb, void *ctx)
Process downloaded bits by calling callback on each HELLO.
static CURL * curl
Current CURL handle.
static unsigned int stat_hellos_obtained
Value saying how many valid HELLO messages were obtained during download.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static void download_prepare()
Ask CURL for the select set and then schedule the receiving task with the scheduler.
static void clean_up()
Clean up the state from the task that downloaded the hostlist and schedule the next task...
#define GNUNET_log(kind,...)
static uint32_t stat_bytes_downloaded
How many bytes did we download from the current hostlist URL?
static char * download_get_url()
Method deciding if a preconfigured or advertisied hostlist is used on a 50:50 ratio.
#define GNUNET_YES
Definition: gnunet_common.h:77
static int stat_download_in_progress
Value controlling if a hostlist download is running at the moment.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ task_download_dispatcher()

static void task_download_dispatcher ( void *  cls)
static

Definition at line 1088 of file gnunet-daemon-hostlist_client.c.

References download_hostlist(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), stat_download_in_progress, and WAITING_INTERVAL.

Referenced by handler_advertisement(), and task_check().

1089 {
1091  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n");
1093  {
1094  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n");
1096  }
1097  else
1098  {
1100  "Download in progess, have to wait...\n");
1104  NULL);
1105  }
1106 }
#define WAITING_INTERVAL
Time interval for download dispatcher before a download is re-scheduled.
static struct GNUNET_SCHEDULER_Task * ti_download_dispatcher_task
ID of the task called to initiate a download.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:1237
static void task_download_dispatcher(void *cls)
static void download_hostlist()
Main function that will download a hostlist and process its data.
#define GNUNET_log(kind,...)
static int stat_download_in_progress
Value controlling if a hostlist download is running at the moment.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ task_check()

static void task_check ( void *  cls)
static

Task that checks if we should try to download a hostlist.

If so, we initiate the download, otherwise we schedule this task again for a later time.

Definition at line 1115 of file gnunet-daemon-hostlist_client.c.

References _, gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_HOURS, GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, hostlist_delay, MIN_CONNECTIONS, once, GNUNET_TIME_Relative::rel_value_us, stat_connection_count, and task_download_dispatcher().

Referenced by GNUNET_HOSTLIST_client_start(), primary_task(), and stat_timeout_task().

1116 {
1117  static int once;
1118  struct GNUNET_TIME_Relative delay;
1119 
1120  ti_check_download = NULL;
1121  if (stats == NULL)
1122  {
1123  curl_global_cleanup();
1124  return; /* in shutdown */
1125  }
1127  (NULL == ti_download_dispatcher_task))
1130 
1132  if (0 == hostlist_delay.rel_value_us)
1134  else
1137  GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count))
1138  hostlist_delay =
1140  (1 + stat_connection_count));
1142  gettext_noop(
1143  "# milliseconds between hostlist downloads"),
1144  hostlist_delay.rel_value_us / 1000LL,
1145  GNUNET_YES);
1146  if (0 == once)
1147  {
1149  once = 1;
1150  }
1151  GNUNET_log(
1153  _("Have %u/%u connections. Will consider downloading hostlist in %s\n"),
1157  ti_check_download = GNUNET_SCHEDULER_add_delayed(delay, &task_check, NULL);
1158 }
#define GNUNET_TIME_UNIT_HOURS
One hour.
uint64_t rel_value_us
The actual value.
static unsigned int stat_connection_count
Number of active connections (according to core service).
static struct GNUNET_SCHEDULER_Task * ti_download_dispatcher_task
ID of the task called to initiate a download.
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:1237
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:1264
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:686
static int once
Global to mark if we&#39;ve run the initialization.
Definition: gnsrecord.c:67
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:440
static void task_download_dispatcher(void *cls)
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static void task_check(void *cls)
Task that checks if we should try to download a hostlist.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
#define MIN_CONNECTIONS
Number of connections that we must have to NOT download hostlists anymore.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
static struct GNUNET_TIME_Relative hostlist_delay
Amount of time we wait between hostlist downloads.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ task_testing_intervall_reset()

static void task_testing_intervall_reset ( void *  cls)
static

This tasks sets hostlist testing to allowed after intervall between to testings is reached.

Parameters
clsclosure

Definition at line 1167 of file gnunet-daemon-hostlist_client.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, and stat_testing_allowed.

Referenced by handler_advertisement().

1168 {
1172  "Testing new hostlist advertisements is allowed again\n");
1173 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int stat_testing_allowed
Value controlling if a hostlist testing is allowed at the moment.
static struct GNUNET_SCHEDULER_Task * ti_testing_intervall_task
ID of the task controlling the locking between two hostlist tests.
#define GNUNET_log(kind,...)
Here is the caller graph for this function:

◆ task_hostlist_saving()

static void task_hostlist_saving ( void *  cls)
static

Task that writes hostlist entries to a file on a regular base.

Parameters
clsclosure

Definition at line 1182 of file gnunet-daemon-hostlist_client.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, save_hostlist_file(), and SAVING_INTERVAL.

Referenced by GNUNET_HOSTLIST_client_start().

1183 {
1184  ti_saving_task = NULL;
1186 
1188  "Hostlists will be saved to file again in %s\n",
1190  GNUNET_YES));
1191  ti_saving_task =
1193 }
static struct GNUNET_SCHEDULER_Task * ti_saving_task
ID of the task saving the hostlsit in a regular intervall.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:1237
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:686
static void save_hostlist_file(int shutdown)
Method to save hostlist to a file during hostlist client shutdown.
#define GNUNET_log(kind,...)
#define SAVING_INTERVAL
Time interval hostlists are saved to disk.
static void task_hostlist_saving(void *cls)
Task that writes hostlist entries to a file on a regular base.
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handler_connect()

static void* handler_connect ( void *  cls,
const struct GNUNET_PeerIdentity peer,
struct GNUNET_MQ_Handle mq 
)
static

Method called whenever a given peer connects.

Parameters
clsclosure
peerpeer identity this notification is about
mqmessage queue for transmissions to peer

Definition at line 1204 of file gnunet-daemon-hostlist_client.c.

References gettext_noop, GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), and stat_connection_count.

Referenced by GNUNET_HOSTLIST_client_start().

1207 {
1211  gettext_noop("# active connections"),
1212  1,
1213  GNUNET_NO);
1214  return NULL;
1215 }
static unsigned int stat_connection_count
Number of active connections (according to core service).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handler_disconnect()

static void handler_disconnect ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  internal_cls 
)
static

Method called whenever a given peer disconnects.

Parameters
clsclosure
peerpeer identity this notification is about

Definition at line 1225 of file gnunet-daemon-hostlist_client.c.

References gettext_noop, GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), and stat_connection_count.

Referenced by GNUNET_HOSTLIST_client_start().

1228 {
1232  gettext_noop("# active connections"),
1233  -1,
1234  GNUNET_NO);
1235 }
static unsigned int stat_connection_count
Number of active connections (according to core service).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handler_advertisement()

static void handler_advertisement ( const char *  uri)
static

Method called whenever an advertisement message arrives.

Parameters
urithe advertised URI

Definition at line 1244 of file gnunet-daemon-hostlist_client.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, HOSTLIST_INITIAL, Hostlist::hostlist_uri, linked_list_contains(), Hostlist::quality, stat_testing_allowed, stat_testing_hostlist, task_download_dispatcher(), task_testing_intervall_reset(), TESTING_INTERVAL, and Hostlist::time_creation.

Referenced by GNUNET_HOSTLIST_client_start().

1245 {
1246  size_t uri_size;
1247  struct Hostlist *hostlist;
1248 
1249  uri_size = strlen(uri) + 1;
1251  "Hostlist client recieved advertisement containing URI `%s'\n",
1252  uri);
1254  {
1255  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri);
1256  return;
1257  }
1258 
1260  {
1261  GNUNET_log(
1263  "Currently not accepting new advertisements: interval between to advertisements is not reached\n");
1264  return;
1265  }
1267  {
1268  GNUNET_log(
1270  "Currently not accepting new advertisements: we are already testing a hostlist\n");
1271  return;
1272  }
1273 
1274  hostlist = GNUNET_malloc(sizeof(struct Hostlist) + uri_size);
1275  hostlist->hostlist_uri = (const char *)&hostlist[1];
1276  GNUNET_memcpy(&hostlist[1], uri, uri_size);
1278  hostlist->quality = HOSTLIST_INITIAL;
1279  hostlist_to_test = hostlist;
1280 
1286  NULL);
1287 
1289  "Testing new hostlist advertisements is locked for the next %s\n",
1291  GNUNET_YES));
1292 
1295 }
#define TESTING_INTERVAL
Time interval between two hostlist tests.
struct GNUNET_TIME_Absolute time_creation
Time the hostlist advertisement was recieved and the entry was created.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
#define HOSTLIST_INITIAL
Defines concerning the hostlist quality metric.
static struct GNUNET_SCHEDULER_Task * ti_download_dispatcher_task
ID of the task called to initiate a download.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
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:1237
static int stat_testing_allowed
Value controlling if a hostlist testing is allowed at the moment.
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:1264
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:686
static int linked_list_contains(const char *uri)
Method to check if a URI is in hostlist linked list.
const char * hostlist_uri
URI where hostlist can be obtained.
static void task_download_dispatcher(void *cls)
static struct GNUNET_SCHEDULER_Task * ti_testing_intervall_task
ID of the task controlling the locking between two hostlist tests.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static void task_testing_intervall_reset(void *cls)
This tasks sets hostlist testing to allowed after intervall between to testings is reached...
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
A single hostlist obtained by hostlist advertisements.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
#define GNUNET_malloc(size)
Wrapper around malloc.
static struct Hostlist * hostlist_to_test
Head of the linked list used to store hostlists.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ primary_task()

static void primary_task ( void *  cls,
int  success 
)
static

Continuation called by the statistics code once we go the stat.

Initiates hostlist download scheduling.

Parameters
clsclosure
successGNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

Definition at line 1307 of file gnunet-daemon-hostlist_client.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), and task_check().

Referenced by GNUNET_HOSTLIST_client_start().

1308 {
1309  if (NULL != ti_check_download)
1310  {
1312  ti_check_download = NULL;
1313  }
1314  sget = NULL;
1315  GNUNET_assert(NULL != stats);
1317  "Statistics request done, scheduling hostlist download\n");
1319 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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:1264
static void task_check(void *cls)
Task that checks if we should try to download a hostlist.
static struct GNUNET_STATISTICS_GetHandle * sget
Handle for our statistics GET operation.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_timeout_task()

static void stat_timeout_task ( void *  cls)
static

Continuation called by the statistics code once we go the stat.

Initiates hostlist download scheduling.

Parameters
clsclosure
successGNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

Definition at line 1331 of file gnunet-daemon-hostlist_client.c.

References GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_get_cancel(), and task_check().

Referenced by GNUNET_HOSTLIST_client_start().

1332 {
1334  sget = NULL;
1336 }
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
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:1264
static void task_check(void *cls)
Task that checks if we should try to download a hostlist.
static struct GNUNET_STATISTICS_GetHandle * sget
Handle for our statistics GET operation.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_stat()

static int process_stat ( void *  cls,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)
static

We've received the previous delay value from statistics.

Remember it.

Parameters
clsNULL, unused
subsystemshould be "hostlist", unused
namewill be "milliseconds between hostlist downloads", unused
valueprevious delay value, in milliseconds (!)
is_persistentunused, will be GNUNET_YES

Definition at line 1349 of file gnunet-daemon-hostlist_client.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, hostlist_delay, and GNUNET_TIME_Relative::rel_value_us.

Referenced by GNUNET_HOSTLIST_client_start().

1354 {
1355  hostlist_delay.rel_value_us = value * 1000LL;
1357  "Initial time between hostlist downloads is %s\n",
1359  GNUNET_YES));
1360  return GNUNET_OK;
1361 }
uint64_t rel_value_us
The actual value.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * value
Value of the record to add/remove.
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:686
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_TIME_Relative hostlist_delay
Amount of time we wait between hostlist downloads.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_hostlist_file()

static void load_hostlist_file ( )
static

Method to load persistent hostlist file during hostlist client startup.

Definition at line 1368 of file gnunet-daemon-hostlist_client.c.

References _, GNUNET_TIME_Absolute::abs_value_us, filename, gettext_noop, GNUNET_BIO_read_close(), GNUNET_BIO_read_int32, GNUNET_BIO_read_int64, GNUNET_BIO_read_open(), GNUNET_BIO_read_string(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_DLL_insert, GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_log_config_missing(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_YES, Hostlist::hello_count, Hostlist::hostlist_uri, linked_list_size, MAX_NUMBER_HOSTLISTS, MAX_URL_LEN, Hostlist::quality, Hostlist::time_creation, Hostlist::time_last_usage, Hostlist::times_used, and uri.

Referenced by GNUNET_HOSTLIST_client_start().

1369 {
1370  char *filename;
1371  char *uri;
1372  char *emsg;
1373  struct Hostlist *hostlist;
1374  uint32_t times_used;
1375  uint32_t hellos_returned;
1376  uint64_t quality;
1377  uint64_t last_used;
1378  uint64_t created;
1379  uint32_t counter;
1380  struct GNUNET_BIO_ReadHandle *rh;
1381 
1382  uri = NULL;
1384  "HOSTLIST",
1385  "HOSTLISTFILE",
1386  &filename))
1387  {
1389  "hostlist",
1390  "HOSTLISTFILE");
1391  return;
1392  }
1393 
1395  _("Loading saved hostlist entries from file `%s' \n"),
1396  filename);
1397  if (GNUNET_NO == GNUNET_DISK_file_test(filename))
1398  {
1400  _("Hostlist file `%s' does not exist\n"),
1401  filename);
1402  GNUNET_free(filename);
1403  return;
1404  }
1405 
1406  rh = GNUNET_BIO_read_open(filename);
1407  if (NULL == rh)
1408  {
1410  _(
1411  "Could not open file `%s' for reading to load hostlists: %s\n"),
1412  filename,
1413  strerror(errno));
1414  GNUNET_free(filename);
1415  return;
1416  }
1417 
1418  counter = 0;
1419  while ((GNUNET_OK == GNUNET_BIO_read_string(rh, "url", &uri, MAX_URL_LEN)) &&
1420  (NULL != uri) &&
1421  (GNUNET_OK == GNUNET_BIO_read_int32(rh, &times_used)) &&
1422  (GNUNET_OK == GNUNET_BIO_read_int64(rh, &quality)) &&
1423  (GNUNET_OK == GNUNET_BIO_read_int64(rh, &last_used)) &&
1424  (GNUNET_OK == GNUNET_BIO_read_int64(rh, &created)) &&
1425  (GNUNET_OK == GNUNET_BIO_read_int32(rh, &hellos_returned)))
1426  {
1427  hostlist = GNUNET_malloc(sizeof(struct Hostlist) + strlen(uri) + 1);
1428  hostlist->hello_count = hellos_returned;
1429  hostlist->hostlist_uri = (const char *)&hostlist[1];
1430  GNUNET_memcpy(&hostlist[1], uri, strlen(uri) + 1);
1431  hostlist->quality = quality;
1432  hostlist->time_creation.abs_value_us = created;
1433  hostlist->time_last_usage.abs_value_us = last_used;
1435  linked_list_size++;
1437  "Added hostlist entry eith URI `%s' \n",
1438  hostlist->hostlist_uri);
1439  GNUNET_free(uri);
1440  uri = NULL;
1441  counter++;
1442  if (counter >= MAX_NUMBER_HOSTLISTS)
1443  break;
1444  }
1445 
1447  _("%u hostlist URIs loaded from file\n"),
1448  counter);
1450  gettext_noop("# hostlist URIs read from file"),
1451  counter,
1452  GNUNET_YES);
1454  gettext_noop("# advertised hostlist URIs"),
1456  GNUNET_NO);
1457 
1458  GNUNET_free_non_null(uri);
1459  emsg = NULL;
1460  (void)GNUNET_BIO_read_close(rh, &emsg);
1461  if (emsg != NULL)
1462  GNUNET_free(emsg);
1463  GNUNET_free(filename);
1464 }
int 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:541
struct GNUNET_TIME_Absolute time_last_usage
Last time the hostlist was obtained.
#define MAX_URL_LEN
How long can hostlist URLs be?
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_TIME_Absolute time_creation
Time the hostlist advertisement was recieved and the entry was created.
uint64_t quality
Value describing the quality of the hostlist, the bigger the better but (should) never < 0 used for d...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
uint64_t abs_value_us
The actual value.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open file.
Definition: bio.c:118
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open(const char *fn)
Open a file for reading.
Definition: bio.c:93
uint32_t hello_count
Number of HELLO messages obtained during last download.
#define GNUNET_BIO_read_int64(h, i)
Read an (u)int64_t.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * filename
const char * hostlist_uri
URI where hostlist can be obtained.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
static struct Hostlist * linked_list_tail
Tail of the linked list used to store hostlists.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
int GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string from a file.
Definition: bio.c:232
static unsigned int linked_list_size
Size of the linke list used to store hostlists.
#define GNUNET_BIO_read_int32(h, i)
Read an (u)int32_t.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
uint32_t times_used
Number of times the hostlist was successfully obtained.
#define GNUNET_log(kind,...)
int 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.
#define MAX_NUMBER_HOSTLISTS
Maximum number of hostlist that are saved.
#define GNUNET_YES
Definition: gnunet_common.h:77
A single hostlist obtained by hostlist advertisements.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:53
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_HOSTLIST_client_start()

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.

Parameters
cconfiguration to use
ststatistics handle to use
[out]chset to handler for CORE connect events
[out]dhset to handler for CORE disconnect events
[out]msghset to handler for CORE advertisement messages
learnshould we learn hostlist URLs from CORE
Returns
GNUNET_OK on success

Definition at line 1570 of file gnunet-daemon-hostlist_client.c.

References _, filename, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_PEERINFO_connect(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_get(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_STRINGS_utf8_toupper(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, handler_advertisement(), handler_connect(), handler_disconnect(), load_hostlist_file(), primary_task(), process_stat(), proxy, proxy_password, proxy_type, proxy_username, result, SAVING_INTERVAL, st, stat_learning, stat_testing_allowed, stat_testing_hostlist, stat_timeout_task(), stat_use_bootstrap, task_check(), and task_hostlist_saving().

Referenced by run().

1576 {
1577  char *filename;
1578  char *proxytype_str;
1579  int result;
1580 
1581  GNUNET_assert(NULL != st);
1582  if (0 != curl_global_init(CURL_GLOBAL_WIN32))
1583  {
1584  GNUNET_break(0);
1585  return GNUNET_SYSERR;
1586  }
1587  cfg = c;
1588  stats = st;
1589 
1590  /* Read proxy configuration */
1592  if (GNUNET_OK ==
1593  GNUNET_CONFIGURATION_get_value_string(cfg, "HOSTLIST", "PROXY", &proxy))
1594  {
1595  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy);
1596  /* proxy username */
1598  "HOSTLIST",
1599  "PROXY_USERNAME",
1600  &proxy_username))
1601  {
1603  "Found proxy username name: `%s'\n",
1604  proxy_username);
1605  }
1606 
1607  /* proxy password */
1609  "HOSTLIST",
1610  "PROXY_PASSWORD",
1611  &proxy_password))
1612  {
1614  "Found proxy password name: `%s'\n",
1615  proxy_password);
1616  }
1617 
1618  /* proxy type */
1620  "HOSTLIST",
1621  "PROXY_TYPE",
1622  &proxytype_str))
1623  {
1624  GNUNET_STRINGS_utf8_toupper(proxytype_str, proxytype_str);
1625  proxy_type = CURLPROXY_HTTP;
1626  if (0 == strcmp(proxytype_str, "HTTP"))
1627  proxy_type = CURLPROXY_HTTP;
1628  else if (0 == strcmp(proxytype_str, "HTTP_1_0"))
1629  proxy_type = CURLPROXY_HTTP_1_0;
1630  else if (0 == strcmp(proxytype_str, "SOCKS4"))
1631  proxy_type = CURLPROXY_SOCKS4;
1632  else if (0 == strcmp(proxytype_str, "SOCKS5"))
1633  proxy_type = CURLPROXY_SOCKS5;
1634  else if (0 == strcmp(proxytype_str, "SOCKS4A"))
1635  proxy_type = CURLPROXY_SOCKS4A;
1636  else if (0 == strcmp(proxytype_str, "SOCKS5_HOSTNAME"))
1637  proxy_type = CURLPROXY_SOCKS5_HOSTNAME;
1638  else
1639  {
1640  GNUNET_log(
1642  _(
1643  "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
1644  proxytype_str);
1645  GNUNET_free(proxytype_str);
1646  GNUNET_free(proxy);
1647  proxy = NULL;
1649  proxy_username = NULL;
1651  proxy_password = NULL;
1652 
1653  return GNUNET_SYSERR;
1654  }
1655  }
1656  GNUNET_free_non_null(proxytype_str);
1657  }
1658 
1659  stat_learning = learn;
1660  *ch = &handler_connect;
1661  *dh = &handler_disconnect;
1662  linked_list_head = NULL;
1663  linked_list_tail = NULL;
1667 
1668  if (GNUNET_YES == stat_learning)
1669  {
1670  *msgh = &handler_advertisement;
1672  _("Learning is enabled on this peer\n"));
1675  "Hostlists will be saved to file again in %s\n",
1677  GNUNET_YES));
1680  NULL);
1681  }
1682  else
1683  {
1685  _("Learning is not enabled on this peer\n"));
1686  *msgh = NULL;
1688  "HOSTLIST",
1689  "HOSTLISTFILE",
1690  &filename))
1691  {
1692  if (GNUNET_YES == GNUNET_DISK_file_test(filename))
1693  {
1694  result = remove(filename);
1695  if (0 == result)
1696  GNUNET_log(
1698  _(
1699  "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
1700  filename);
1701  else
1703  "remove",
1704  filename);
1705  }
1706  }
1707  GNUNET_free(filename);
1708  }
1710  "Loading stats value on hostlist download frequency\n");
1712  "hostlist",
1713  gettext_noop(
1714  "# milliseconds between hostlist downloads"),
1715  &primary_task,
1716  &process_stat,
1717  NULL);
1718  if (NULL == sget)
1719  {
1721  "Statistics request failed, scheduling hostlist download\n");
1723  }
1724  else
1725  {
1728  NULL);
1729  }
1730  return GNUNET_OK;
1731 }
int 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:541
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:128
static int stat_learning
Set if we are allowed to learn new hostlists and use them.
#define GNUNET_TIME_UNIT_MINUTES
One minute.
static struct GNUNET_SCHEDULER_Task * ti_saving_task
ID of the task saving the hostlsit in a regular intervall.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void load_hostlist_file()
Method to load persistent hostlist file during hostlist client startup.
static void handler_advertisement(const char *uri)
Method called whenever an advertisement message arrives.
static curl_proxytype proxy_type
Proxy type we are using (can be NULL).
static int process_stat(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
We&#39;ve received the previous delay value from statistics.
static void * handler_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
#define GNUNET_NO
Definition: gnunet_common.h:78
static void primary_task(void *cls, int success)
Continuation called by the statistics code once we go the stat.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static char * proxy_username
Proxy username we are using (can be NULL).
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static char * proxy
Proxy hostname or ip we are using (can be NULL).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static char * proxy_password
Proxy password we are using (can be NULL).
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void stat_timeout_task(void *cls)
Continuation called by the statistics code once we go the stat.
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:1237
void GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to upper case.
Definition: strings.c:577
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static int stat_testing_allowed
Value controlling if a hostlist testing is allowed at the moment.
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:1264
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:686
static char * filename
static int result
Global testing status.
static unsigned int stat_use_bootstrap
Value saying if a preconfigured bootstrap server is used.
static struct Hostlist * linked_list_head
Head of the linked list used to store hostlists.
static struct Hostlist * linked_list_tail
Tail of the linked list used to store hostlists.
static void handler_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a given peer disconnects.
static void task_check(void *cls)
Task that checks if we should try to download a hostlist.
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_STATISTICS_GetHandle * sget
Handle for our statistics GET operation.
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.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
#define GNUNET_log(kind,...)
#define SAVING_INTERVAL
Time interval hostlists are saved to disk.
int 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.
static void task_hostlist_saving(void *cls)
Task that writes hostlist entries to a file on a regular base.
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
static int stat_testing_hostlist
Value controlling if a hostlist is tested at the moment.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_HOSTLIST_client_stop()

void GNUNET_HOSTLIST_client_stop ( void  )

Stop downloading hostlists from hostlist servers as necessary.

Definition at line 1738 of file gnunet-daemon-hostlist_client.c.

References clean_up(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free_non_null, GNUNET_log, GNUNET_PEERINFO_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_get_cancel(), GNUNET_YES, proxy, proxy_password, proxy_username, save_hostlist_file(), stat_learning, and update_hostlist().

Referenced by cleaning_task().

1739 {
1740  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n");
1741  if (NULL != sget)
1742  {
1744  sget = NULL;
1745  }
1746  stats = NULL;
1747  if (GNUNET_YES == stat_learning)
1749  if (NULL != ti_saving_task)
1750  {
1752  ti_saving_task = NULL;
1753  }
1754  if (NULL != ti_download_dispatcher_task)
1755  {
1758  }
1759  if (NULL != ti_testing_intervall_task)
1760  {
1763  }
1764  if (NULL != ti_download)
1765  {
1767  ti_download = NULL;
1768  update_hostlist();
1769  clean_up();
1770  }
1771  if (NULL != ti_check_download)
1772  {
1774  ti_check_download = NULL;
1775  curl_global_cleanup();
1776  }
1778  proxy = NULL;
1780  proxy_username = NULL;
1782  proxy_password = NULL;
1783  if (NULL != pi)
1784  {
1786  pi = NULL;
1787  }
1788  cfg = NULL;
1789 }
static int stat_learning
Set if we are allowed to learn new hostlists and use them.
static struct GNUNET_SCHEDULER_Task * ti_download_dispatcher_task
ID of the task called to initiate a download.
static struct GNUNET_SCHEDULER_Task * ti_saving_task
ID of the task saving the hostlsit in a regular intervall.
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
static struct GNUNET_SCHEDULER_Task * ti_download
ID of the task downloading the hostlist.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static void update_hostlist()
Method updating hostlist statistics.
static char * proxy_username
Proxy username we are using (can be NULL).
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static char * proxy
Proxy hostname or ip we are using (can be NULL).
static char * proxy_password
Proxy password we are using (can be NULL).
static struct GNUNET_SCHEDULER_Task * ti_testing_intervall_task
ID of the task controlling the locking between two hostlist tests.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void save_hostlist_file(int shutdown)
Method to save hostlist to a file during hostlist client shutdown.
static void clean_up()
Clean up the state from the task that downloaded the hostlist and schedule the next task...
static struct GNUNET_STATISTICS_GetHandle * sget
Handle for our statistics GET operation.
static struct GNUNET_SCHEDULER_Task * ti_check_download
ID of the task, checking if hostlist download should take plate.
#define GNUNET_log(kind,...)
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:154
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_STATISTICS_Handle * stats
Statistics handle.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

Definition at line 145 of file gnunet-daemon-hostlist_client.c.

◆ stats

struct GNUNET_STATISTICS_Handle* stats
static

Statistics handle.

Definition at line 150 of file gnunet-daemon-hostlist_client.c.

◆ proxy

char* proxy
static

Proxy hostname or ip we are using (can be NULL).

Definition at line 155 of file gnunet-daemon-hostlist_client.c.

Referenced by download_hostlist(), GNUNET_HOSTLIST_client_start(), and GNUNET_HOSTLIST_client_stop().

◆ proxy_username

char* proxy_username
static

Proxy username we are using (can be NULL).

Definition at line 160 of file gnunet-daemon-hostlist_client.c.

Referenced by download_hostlist(), GNUNET_HOSTLIST_client_start(), and GNUNET_HOSTLIST_client_stop().

◆ proxy_password

char* proxy_password
static

Proxy password we are using (can be NULL).

Definition at line 165 of file gnunet-daemon-hostlist_client.c.

Referenced by download_hostlist(), GNUNET_HOSTLIST_client_start(), and GNUNET_HOSTLIST_client_stop().

◆ proxy_type

curl_proxytype proxy_type
static

Proxy type we are using (can be NULL).

Definition at line 170 of file gnunet-daemon-hostlist_client.c.

Referenced by client_configure_plugin(), download_hostlist(), and GNUNET_HOSTLIST_client_start().

◆ download_pos

size_t download_pos
static

Number of bytes valid in 'download_buffer'.

Definition at line 175 of file gnunet-daemon-hostlist_client.c.

Referenced by callback_download(), and download_hostlist().

◆ current_url

char* current_url
static

Current URL that we are using.

Definition at line 180 of file gnunet-daemon-hostlist_client.c.

Referenced by callback_download(), clean_up(), download_hostlist(), and task_download().

◆ curl

CURL* curl
static

Current CURL handle.

Definition at line 185 of file gnunet-daemon-hostlist_client.c.

Referenced by clean_up(), client_schedule(), and download_hostlist().

◆ multi

CURLM* multi
static

Current multi-CURL handle.

Definition at line 190 of file gnunet-daemon-hostlist_client.c.

Referenced by clean_up(), download_hostlist(), download_prepare(), GNUNET_CURL_init(), and task_download().

◆ stat_bytes_downloaded

uint32_t stat_bytes_downloaded
static

How many bytes did we download from the current hostlist URL?

Definition at line 195 of file gnunet-daemon-hostlist_client.c.

Referenced by callback_download(), clean_up(), download_hostlist(), and task_download().

◆ hostlist_delay

struct GNUNET_TIME_Relative hostlist_delay
static

Amount of time we wait between hostlist downloads.

Definition at line 200 of file gnunet-daemon-hostlist_client.c.

Referenced by process_stat(), and task_check().

◆ ti_check_download

struct GNUNET_SCHEDULER_Task* ti_check_download
static

ID of the task, checking if hostlist download should take plate.

Definition at line 205 of file gnunet-daemon-hostlist_client.c.

◆ ti_download

struct GNUNET_SCHEDULER_Task* ti_download
static

ID of the task downloading the hostlist.

Definition at line 210 of file gnunet-daemon-hostlist_client.c.

◆ ti_saving_task

struct GNUNET_SCHEDULER_Task* ti_saving_task
static

ID of the task saving the hostlsit in a regular intervall.

Definition at line 215 of file gnunet-daemon-hostlist_client.c.

◆ ti_download_dispatcher_task

struct GNUNET_SCHEDULER_Task* ti_download_dispatcher_task
static

ID of the task called to initiate a download.

Definition at line 220 of file gnunet-daemon-hostlist_client.c.

◆ ti_testing_intervall_task

struct GNUNET_SCHEDULER_Task* ti_testing_intervall_task
static

ID of the task controlling the locking between two hostlist tests.

Definition at line 225 of file gnunet-daemon-hostlist_client.c.

◆ end_time

struct GNUNET_TIME_Absolute end_time
static

At what time MUST the current hostlist request be done?

Definition at line 230 of file gnunet-daemon-hostlist_client.c.

Referenced by download_hostlist(), download_prepare(), and task_download().

◆ linked_list_head

struct Hostlist* linked_list_head
static

Head of the linked list used to store hostlists.

Definition at line 235 of file gnunet-daemon-hostlist_client.c.

Referenced by download_get_url(), linked_list_contains(), and linked_list_get_lowest_quality().

◆ linked_list_tail

struct Hostlist* linked_list_tail
static

Tail of the linked list used to store hostlists.

Definition at line 240 of file gnunet-daemon-hostlist_client.c.

◆ current_hostlist

struct Hostlist* current_hostlist
static

Current hostlist used for downloading.

Definition at line 245 of file gnunet-daemon-hostlist_client.c.

◆ linked_list_size

unsigned int linked_list_size
static

Size of the linke list used to store hostlists.

Definition at line 250 of file gnunet-daemon-hostlist_client.c.

Referenced by download_get_url(), insert_hostlist(), linked_list_get_lowest_quality(), load_hostlist_file(), and save_hostlist_file().

◆ hostlist_to_test

struct Hostlist* hostlist_to_test
static

Head of the linked list used to store hostlists.

Definition at line 255 of file gnunet-daemon-hostlist_client.c.

Referenced by download_get_url().

◆ sget

struct GNUNET_STATISTICS_GetHandle* sget
static

Handle for our statistics GET operation.

Definition at line 260 of file gnunet-daemon-hostlist_client.c.

◆ stat_bogus_url

int stat_bogus_url
static

Set to GNUNET_YES if the current URL had some problems.

Definition at line 265 of file gnunet-daemon-hostlist_client.c.

Referenced by callback_download(), and download_hostlist().

◆ stat_testing_hostlist

int stat_testing_hostlist
static

Value controlling if a hostlist is tested at the moment.

Definition at line 270 of file gnunet-daemon-hostlist_client.c.

Referenced by clean_up(), download_get_url(), GNUNET_HOSTLIST_client_start(), handler_advertisement(), insert_hostlist(), task_download(), and update_hostlist().

◆ stat_testing_allowed

int stat_testing_allowed
static

Value controlling if a hostlist testing is allowed at the moment.

Definition at line 275 of file gnunet-daemon-hostlist_client.c.

Referenced by GNUNET_HOSTLIST_client_start(), handler_advertisement(), and task_testing_intervall_reset().

◆ stat_download_in_progress

int stat_download_in_progress
static

Value controlling if a hostlist download is running at the moment.

Definition at line 280 of file gnunet-daemon-hostlist_client.c.

Referenced by clean_up(), download_hostlist(), and task_download_dispatcher().

◆ stat_use_bootstrap

unsigned int stat_use_bootstrap
static

Value saying if a preconfigured bootstrap server is used.

Definition at line 285 of file gnunet-daemon-hostlist_client.c.

Referenced by download_get_url(), GNUNET_HOSTLIST_client_start(), and update_hostlist().

◆ stat_learning

int stat_learning
static

Set if we are allowed to learn new hostlists and use them.

Definition at line 290 of file gnunet-daemon-hostlist_client.c.

Referenced by download_get_url(), GNUNET_HOSTLIST_client_start(), GNUNET_HOSTLIST_client_stop(), and update_hostlist().

◆ stat_download_successful

unsigned int stat_download_successful
static

Value saying if hostlist download was successful.

Definition at line 295 of file gnunet-daemon-hostlist_client.c.

Referenced by clean_up(), download_hostlist(), task_download(), and update_hostlist().

◆ stat_hellos_obtained

unsigned int stat_hellos_obtained
static

Value saying how many valid HELLO messages were obtained during download.

Definition at line 300 of file gnunet-daemon-hostlist_client.c.

Referenced by callback_download(), download_hostlist(), and update_hostlist().

◆ stat_connection_count

unsigned int stat_connection_count
static

Number of active connections (according to core service).

Definition at line 305 of file gnunet-daemon-hostlist_client.c.

Referenced by handler_connect(), handler_disconnect(), and task_check().

◆ pi

struct GNUNET_PEERINFO_Handle* pi
static