GNUnet  0.11.x
gnunet-daemon-hostlist_server.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008, 2009, 2010, 2014, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
28 #include "platform.h"
29 #include <microhttpd.h>
31 #include "gnunet_hello_lib.h"
33 #include "gnunet-daemon-hostlist.h"
35 #include "gnunet_mhd_compat.h"
36 
37 
42 #define GNUNET_ADV_TIMEOUT \
43  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
44 
45 
49 static struct MHD_Daemon *daemon_handle_v6;
50 
54 static struct MHD_Daemon *daemon_handle_v4;
55 
59 static const struct GNUNET_CONFIGURATION_Handle *cfg;
60 
65 
69 static struct GNUNET_CORE_Handle *core;
70 
75 
80 
85 
89 static struct MHD_Response *response;
90 
95 
99 static int advertising;
100 
104 static char *hostlist_uri;
105 
106 
110 struct HostSet
111 {
116 
120  char *data;
121 
125  unsigned int size;
126 };
127 
128 
132 static struct HostSet *builder;
133 
134 
141 static void
142 add_cors_headers (struct MHD_Response *response)
143 {
144  MHD_add_response_header (response, "Access-Control-Allow-Origin", "*");
145  MHD_add_response_header (response,
146  "Access-Control-Allow-Methods",
147  "GET, OPTIONS");
148  MHD_add_response_header (response, "Access-Control-Max-Age", "86400");
149 }
150 
151 
155 static void
157 {
158  if (NULL != response)
159  MHD_destroy_response (response);
161  "Creating hostlist response with %u bytes\n",
162  (unsigned int) builder->size);
163  response = MHD_create_response_from_buffer (builder->size,
164  builder->data,
165  MHD_RESPMEM_MUST_FREE);
167  if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
168  {
169  MHD_destroy_response (response);
170  response = NULL;
171  }
172  GNUNET_STATISTICS_set (stats,
173  gettext_noop ("bytes in hostlist"),
174  builder->size,
175  GNUNET_YES);
176  GNUNET_free (builder);
177  builder = NULL;
178 }
179 
180 
189 static int
190 check_has_addr (void *cls,
191  const struct GNUNET_HELLO_Address *address,
193 {
194  int *arg = cls;
195 
196  if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
197  {
199  gettext_noop ("expired addresses encountered"),
200  1,
201  GNUNET_YES);
202  return GNUNET_YES; /* ignore this address */
203  }
204  *arg = GNUNET_YES;
205  return GNUNET_SYSERR;
206 }
207 
208 
218 static void
219 host_processor (void *cls,
220  const struct GNUNET_PeerIdentity *peer,
221  const struct GNUNET_HELLO_Message *hello,
222  const char *err_msg)
223 {
224  size_t old;
225  size_t s;
226  int has_addr;
227 
228  if (NULL != err_msg)
229  {
230  GNUNET_assert (NULL == peer);
231  builder->pitr = NULL;
232  GNUNET_free (builder->data);
233  GNUNET_free (builder);
234  builder = NULL;
236  _ ("Error in communication with PEERINFO service: %s\n"),
237  err_msg);
238  return;
239  }
240  if (NULL == peer)
241  {
242  builder->pitr = NULL;
243  finish_response ();
244  return;
245  }
246  if (NULL == hello)
247  return;
248  has_addr = GNUNET_NO;
250  if (GNUNET_NO == has_addr)
251  {
253  "HELLO for peer `%4s' has no address, not suitable for hostlist!\n",
254  GNUNET_i2s (peer));
256  gettext_noop (
257  "HELLOs without addresses encountered (ignored)"),
258  1,
259  GNUNET_NO);
260  return;
261  }
262  old = builder->size;
263  s = GNUNET_HELLO_size (hello);
265  "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
266  (unsigned int) s,
267  "HELLO",
268  GNUNET_i2s (peer));
269  if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
270  (old + s >= MAX_BYTES_PER_HOSTLISTS))
271  {
272  /* too large, skip! */
274  gettext_noop (
275  "bytes not included in hostlist (size limit)"),
276  s,
277  GNUNET_NO);
278  return;
279  }
281  "Adding peer `%s' to hostlist (%u bytes)\n",
282  GNUNET_i2s (peer),
283  (unsigned int) s);
284  GNUNET_array_grow (builder->data, builder->size, old + s);
285  GNUNET_memcpy (&builder->data[old], hello, s);
286 }
287 
288 
298 static MHD_RESULT
300  const struct sockaddr *addr,
301  socklen_t addrlen)
302 {
303  if (NULL == response)
304  {
305  GNUNET_log (
307  "Received request for hostlist, but I am not yet ready; rejecting!\n");
308  return MHD_NO;
309  }
310  return MHD_YES; /* accept all */
311 }
312 
313 
349 static MHD_RESULT
351  struct MHD_Connection *connection,
352  const char *url,
353  const char *method,
354  const char *version,
355  const char *upload_data,
356  size_t *upload_data_size,
357  void **con_cls)
358 {
359  static int dummy;
360 
361  /* CORS pre-flight request */
362  if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
363  {
364  struct MHD_Response *options_response;
365  int rc;
366 
367  options_response =
368  MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
369  add_cors_headers (options_response);
370  rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response);
371  MHD_destroy_response (options_response);
372  return rc;
373  }
374  if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
375  {
377  _ ("Refusing `%s' request to hostlist server\n"),
378  method);
380  gettext_noop (
381  "hostlist requests refused (not HTTP GET)"),
382  1,
383  GNUNET_YES);
384  return MHD_NO;
385  }
386  if (NULL == *con_cls)
387  {
388  (*con_cls) = &dummy;
389  return MHD_YES;
390  }
391  if (0 != *upload_data_size)
392  {
394  _ ("Refusing `%s' request with %llu bytes of upload data\n"),
395  method,
396  (unsigned long long) *upload_data_size);
398  gettext_noop (
399  "hostlist requests refused (upload data)"),
400  1,
401  GNUNET_YES);
402  return MHD_NO; /* do not support upload data */
403  }
404  if (NULL == response)
405  {
406  GNUNET_log (
408  _ (
409  "Could not handle hostlist request since I do not have a response yet\n"));
411  gettext_noop (
412  "hostlist requests refused (not ready)"),
413  1,
414  GNUNET_YES);
415  return MHD_NO; /* internal error, no response yet */
416  }
418  _ ("Received request for our hostlist\n"));
420  gettext_noop ("hostlist requests processed"),
421  1,
422  GNUNET_YES);
423  return MHD_queue_response (connection, MHD_HTTP_OK, response);
424 }
425 
426 
436 static void
438 {
439  static uint64_t hostlist_adv_count;
440  size_t uri_size; /* Including \0 termination! */
441  struct GNUNET_MessageHeader *header;
442  struct GNUNET_MQ_Envelope *env;
443 
444  uri_size = strlen (hostlist_uri) + 1;
445  env = GNUNET_MQ_msg_extra (header,
446  uri_size,
448  GNUNET_memcpy (&header[1], hostlist_uri, uri_size);
452  GNUNET_MQ_send (mq, env);
454  "Sent advertisement message: Copied %u bytes into buffer!\n",
455  (unsigned int) uri_size);
456  hostlist_adv_count++;
458  " # Sent advertisement message: %llu\n",
459  (unsigned long long) hostlist_adv_count);
461  gettext_noop ("# hostlist advertisements send"),
462  1,
463  GNUNET_NO);
464 }
465 
466 
475 static void *
476 connect_handler (void *cls,
477  const struct GNUNET_PeerIdentity *peer,
478  struct GNUNET_MQ_Handle *mq)
479 {
480  size_t size;
481 
482  if (! advertising)
483  return NULL;
484  if (NULL == hostlist_uri)
485  return NULL;
486  size = strlen (hostlist_uri) + 1;
487  if (size + sizeof(struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE)
488  {
489  GNUNET_break (0);
490  return NULL;
491  }
492  size += sizeof(struct GNUNET_MessageHeader);
493  if (NULL == core)
494  {
495  GNUNET_break (0);
496  return NULL;
497  }
498  GNUNET_log (
500  "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n",
501  (unsigned int) size,
502  GNUNET_i2s (peer));
503  adv_transmit (mq);
504  return NULL;
505 }
506 
507 
517 static void
518 process_notify (void *cls,
519  const struct GNUNET_PeerIdentity *peer,
520  const struct GNUNET_HELLO_Message *hello,
521  const char *err_msg)
522 {
524  "Peerinfo is notifying us to rebuild our hostlist\n");
525  if (NULL != err_msg)
527  _ ("Error in communication with PEERINFO service: %s\n"),
528  err_msg);
529  if (NULL != builder)
530  {
531  /* restart re-build already in progress ... */
532  if (NULL != builder->pitr)
533  {
535  builder->pitr = NULL;
536  }
537  GNUNET_free (builder->data);
538  builder->size = 0;
539  builder->data = NULL;
540  }
541  else
542  {
543  builder = GNUNET_new (struct HostSet);
544  }
545  GNUNET_assert (NULL != peerinfo);
546  builder->pitr =
547  GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL);
548 }
549 
550 
555 static struct GNUNET_SCHEDULER_Task *
556 prepare_daemon (struct MHD_Daemon *daemon_handle);
557 
558 
565 static void
566 run_daemon (void *cls)
567 {
568  struct MHD_Daemon *daemon_handle = cls;
569 
570  if (daemon_handle == daemon_handle_v4)
571  hostlist_task_v4 = NULL;
572  else
573  hostlist_task_v6 = NULL;
574  GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
575  if (daemon_handle == daemon_handle_v4)
576  hostlist_task_v4 = prepare_daemon (daemon_handle);
577  else
578  hostlist_task_v6 = prepare_daemon (daemon_handle);
579 }
580 
581 
588 static struct GNUNET_SCHEDULER_Task *
589 prepare_daemon (struct MHD_Daemon *daemon_handle)
590 {
591  struct GNUNET_SCHEDULER_Task *ret;
592  fd_set rs;
593  fd_set ws;
594  fd_set es;
595  struct GNUNET_NETWORK_FDSet *wrs;
596  struct GNUNET_NETWORK_FDSet *wws;
597  int max;
598  MHD_UNSIGNED_LONG_LONG timeout;
599  int haveto;
600  struct GNUNET_TIME_Relative tv;
601 
602  FD_ZERO (&rs);
603  FD_ZERO (&ws);
604  FD_ZERO (&es);
607  max = -1;
608  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
609  haveto = MHD_get_timeout (daemon_handle, &timeout);
610  if (haveto == MHD_YES)
611  tv.rel_value_us = (uint64_t) timeout * 1000LL;
612  else
614  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
615  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
617  tv,
618  wrs,
619  wws,
620  &run_daemon,
621  daemon_handle);
624  return ret;
625 }
626 
627 
638 int
641  struct GNUNET_CORE_Handle *co,
643  int advertise)
644 {
645  unsigned long long port;
646  char *hostname;
647  char *ipv4;
648  char *ipv6;
649  size_t size;
650  struct in_addr i4;
651  struct in6_addr i6;
652  struct sockaddr_in v4;
653  struct sockaddr_in6 v6;
654  const struct sockaddr *sa4;
655  const struct sockaddr *sa6;
656 
657  advertising = advertise;
658  if (! advertising)
659  {
661  "Advertising not enabled on this hostlist server\n");
662  }
663  else
664  {
666  "Advertising enabled on this hostlist server\n");
667  }
668  cfg = c;
669  stats = st;
670  peerinfo = GNUNET_PEERINFO_connect (cfg);
671  if (NULL == peerinfo)
672  {
674  _ ("Could not access PEERINFO service. Exiting.\n"));
675  return GNUNET_SYSERR;
676  }
678  "HOSTLIST",
679  "HTTPPORT",
680  &port))
681  return GNUNET_SYSERR;
682  if ((0 == port) || (port > UINT16_MAX))
683  {
685  _ ("Invalid port number %llu. Exiting.\n"),
686  port);
687  return GNUNET_SYSERR;
688  }
689 
690  if (GNUNET_SYSERR ==
692  "HOSTLIST",
693  "EXTERNAL_DNS_NAME",
694  &hostname))
695  hostname = GNUNET_RESOLVER_local_fqdn_get ();
697  _ ("Hostlist service starts on %s:%llu\n"),
698  hostname,
699  port);
700  if (NULL != hostname)
701  {
702  size = strlen (hostname);
703  if (size + 15 > MAX_URL_LEN)
704  {
705  GNUNET_break (0);
706  }
707  else
708  {
710  "http://%s:%u/",
711  hostname,
712  (unsigned int) port);
714  _ ("Address to obtain hostlist: `%s'\n"),
715  hostlist_uri);
716  }
717  GNUNET_free (hostname);
718  }
719 
720  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
721  {
723  "HOSTLIST",
724  "BINDTOIP",
725  &ipv4))
726  {
727  GNUNET_log (
729  _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
730  }
731  }
732  else
733  ipv4 = NULL;
734  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
735  {
737  "HOSTLIST",
738  "BINDTOIP",
739  &ipv6))
740  {
741  GNUNET_log (
743  _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
744  }
745  }
746  else
747  ipv6 = NULL;
748  sa4 = NULL;
749  if (NULL != ipv4)
750  {
751  if (1 == inet_pton (AF_INET, ipv4, &i4))
752  {
753  memset (&v4, 0, sizeof(v4));
754  v4.sin_family = AF_INET;
755  v4.sin_addr = i4;
756  v4.sin_port = htons (port);
757 #if HAVE_SOCKADDR_IN_SIN_LEN
758  v4.sin_len = sizeof(v4);
759 #endif
760  sa4 = (const struct sockaddr *) &v4;
761  }
762  else
764  _ (
765  "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
766  ipv4);
767  GNUNET_free (ipv4);
768  }
769  sa6 = NULL;
770  if (NULL != ipv6)
771  {
772  if (1 == inet_pton (AF_INET6, ipv6, &i6))
773  {
774  memset (&v6, 0, sizeof(v6));
775  v6.sin6_family = AF_INET6;
776  v6.sin6_addr = i6;
777  v6.sin6_port = htons (port);
778 #if HAVE_SOCKADDR_IN_SIN_LEN
779  v6.sin6_len = sizeof(v6);
780 #endif
781  sa6 = (const struct sockaddr *) &v6;
782  }
783  else
785  _ (
786  "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
787  ipv6);
788  GNUNET_free (ipv6);
789  }
790 
791  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
792  (uint16_t) port,
794  NULL,
796  NULL,
797  MHD_OPTION_CONNECTION_LIMIT,
798  (unsigned int) 128,
799  MHD_OPTION_PER_IP_CONNECTION_LIMIT,
800  (unsigned int) 32,
801  MHD_OPTION_CONNECTION_TIMEOUT,
802  (unsigned int) 16,
803  MHD_OPTION_CONNECTION_MEMORY_LIMIT,
804  (size_t) (16 * 1024),
805  MHD_OPTION_SOCK_ADDR,
806  sa6,
807  MHD_OPTION_END);
808  daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
809  (uint16_t) port,
811  NULL,
813  NULL,
814  MHD_OPTION_CONNECTION_LIMIT,
815  (unsigned int) 128,
816  MHD_OPTION_PER_IP_CONNECTION_LIMIT,
817  (unsigned int) 32,
818  MHD_OPTION_CONNECTION_TIMEOUT,
819  (unsigned int) 16,
820  MHD_OPTION_CONNECTION_MEMORY_LIMIT,
821  (size_t) (16 * 1024),
822  MHD_OPTION_SOCK_ADDR,
823  sa4,
824  MHD_OPTION_END);
825 
826  if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4))
827  {
829  _ ("Could not start hostlist HTTP server on port %u\n"),
830  (unsigned short) port);
831  return GNUNET_SYSERR;
832  }
833 
834  core = co;
835  *server_ch = &connect_handler;
836  if (NULL != daemon_handle_v4)
837  hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
838  if (NULL != daemon_handle_v6)
839  hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
840  notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_notify, NULL);
841  return GNUNET_OK;
842 }
843 
844 
848 void
850 {
851  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
852  if (NULL != hostlist_task_v6)
853  {
854  GNUNET_SCHEDULER_cancel (hostlist_task_v6);
855  hostlist_task_v6 = NULL;
856  }
857  if (NULL != hostlist_task_v4)
858  {
859  GNUNET_SCHEDULER_cancel (hostlist_task_v4);
860  hostlist_task_v4 = NULL;
861  }
862  if (NULL != daemon_handle_v4)
863  {
864  MHD_stop_daemon (daemon_handle_v4);
865  daemon_handle_v4 = NULL;
866  }
867  if (NULL != daemon_handle_v6)
868  {
869  MHD_stop_daemon (daemon_handle_v6);
870  daemon_handle_v6 = NULL;
871  }
872  if (NULL != response)
873  {
874  MHD_destroy_response (response);
875  response = NULL;
876  }
877  if (NULL != notify)
878  {
880  notify = NULL;
881  }
882  if (NULL != builder)
883  {
884  if (NULL != builder->pitr)
885  {
887  builder->pitr = NULL;
888  }
889  GNUNET_free (builder->data);
890  GNUNET_free (builder);
891  builder = NULL;
892  }
893  if (NULL != peerinfo)
894  {
895  GNUNET_PEERINFO_disconnect (peerinfo);
896  peerinfo = NULL;
897  }
898  cfg = NULL;
899  stats = NULL;
900  core = NULL;
901 }
902 
903 
904 /* end of gnunet-daemon-hostlist_server.c */
static struct MHD_Daemon * daemon_handle
Handle to the HTTP server as provided by libmicrohttpd.
Definition: gnunet-bcd.c:47
static int check_has_addr(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Set cls to GNUNET_YES (we have an address!).
common internal definitions for hostlist daemon
static struct GNUNET_SCHEDULER_Task * prepare_daemon(struct MHD_Daemon *daemon_handle)
Function that queries MHD&#39;s select sets and starts the task waiting for them.
#define MAX_URL_LEN
How long can hostlist URLs be?
#define MAX_BYTES_PER_HOSTLISTS
How many bytes do we download at most from a hostlist server?
Run with high priority (important requests).
Handle to the peerinfo service.
Definition: peerinfo_api.c:84
A HELLO message is used to exchange information about transports with other peers.
static void adv_transmit(struct GNUNET_MQ_Handle *mq)
Handler called by CORE when CORE is ready to transmit message.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
uint64_t rel_value_us
The actual value.
Context for the core service connection.
Definition: core_api.c:77
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:130
Context for the info handler.
static struct GNUNET_STATISTICS_Handle * stats
For keeping statistics.
struct GNUNET_PEERINFO_IteratorContext * pitr
Iterator used to build data (NULL when done).
int GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_STATISTICS_Handle *st, struct GNUNET_CORE_Handle *co, GNUNET_CORE_ConnectEventHandler *server_ch, int advertise)
Start server offering our hostlist.
static int ipv4
Option -4: IPv4 requested.
Definition: gnunet-vpn.c:61
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_PEERINFO_notify_cancel(struct GNUNET_PEERINFO_NotifyContext *nc)
Stop notifying about changes.
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1022
static void * connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static char * hostlist_uri
Buffer for the hostlist address.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Handle for the service.
static void process_notify(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
PEERINFO calls this function to let us know about a possible peer that we might want to connect to...
Context for an iteration request.
Definition: peerinfo_api.c:37
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:1120
struct GNUNET_PEERINFO_NotifyContext * GNUNET_PEERINFO_notify(const struct GNUNET_CONFIGURATION_Handle *cfg, int include_friend_only, GNUNET_PEERINFO_Processor callback, void *callback_cls)
Call a method whenever our known information about peers changes.
void *(* GNUNET_CORE_ConnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
static struct GNUNET_SCHEDULER_Task * hostlist_task_v6
Our primary task for IPv6.
struct GNUNET_PEERINFO_IteratorContext * GNUNET_PEERINFO_iterate(struct GNUNET_PEERINFO_Handle *h, int include_friend_only, const struct GNUNET_PeerIdentity *peer, GNUNET_PEERINFO_Processor callback, void *callback_cls)
Call a method for each known matching host.
Definition: peerinfo_api.c:487
Context for host_processor().
static int advertising
Set if we are allowed to advertise our hostlist to others.
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250
void GNUNET_PEERINFO_iterate_cancel(struct GNUNET_PEERINFO_IteratorContext *ic)
Cancel an iteration over peer information.
Definition: peerinfo_api.c:520
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
struct GNUNET_HELLO_Message * GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, int return_modified, GNUNET_HELLO_AddressIterator it, void *it_cls)
Iterate over all of the addresses in the HELLO.
Definition: hello.c:254
static void finish_response()
Function that assembles our response.
static struct GNUNET_SCHEDULER_Task * hostlist_task_v4
Our primary task for IPv4.
int GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
char * GNUNET_RESOLVER_local_fqdn_get(void)
Get local fully qualified domain name.
unsigned int size
Number of bytes in data.
static void add_cors_headers(struct MHD_Response *response)
Add headers to a request indicating that we allow Cross-Origin Resource Sharing.
static struct GNUNET_PEERINFO_Handle * peerinfo
Handle for accessing peerinfo service.
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:1841
static GNUNET_CORE_ConnectEventHandler server_ch
Handle to hostlist server&#39;s connect handler.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
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 char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static MHD_RESULT access_handler_callback(void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls)
Main request handler.
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.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
static struct MHD_Daemon * daemon_handle_v6
Handle to the HTTP server as provided by libmicrohttpd for IPv6.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define MHD_RESULT
Data type to use for functions return an "MHD result".
static MHD_RESULT accept_policy_callback(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Hostlist access policy (very permissive, allows everything).
#define GNUNET_MAX_MALLOC_CHECKED
Maximum allocation with GNUNET_malloc macro.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
Handle to a message queue.
Definition: mq.c:85
The identity of the host (wraps the signing key of the peer).
static void host_processor(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
Callback that processes each of the known HELLOs for the hostlist response construction.
static char * hostname
Our hostname; we give this to all the peers we start.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
configuration data
Definition: configuration.c:84
void GNUNET_HOSTLIST_server_stop()
Stop server offering our hostlist.
An address for communicating with a peer.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT
Further X-VINE DHT messages continued from 880.
Entry in list of pending tasks.
Definition: scheduler.c:134
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:652
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
static struct MHD_Response * response
Our canonical response.
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
static void run_daemon(void *cls)
Call MHD to process pending requests and then go back and schedule the next run.
Flag to indicate that CORKing is acceptable.
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
char * data
Place where we accumulate all of the HELLO messages.
Flag to indicate that unreliable delivery is acceptable.
static struct GNUNET_CORE_Handle * core
Handle to the core service (NULL until we&#39;ve connected to it).
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
static struct MHD_Daemon * daemon_handle_v4
Handle to the HTTP server as provided by libmicrohttpd for IPv4.
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct HostSet * builder
NULL if we are not currenlty iterating over peer information.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
static int ipv6
Option -6: IPv6 requested.
Definition: gnunet-vpn.c:66
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972