GNUnet  0.11.x
plugin_transport_http_common.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2002-2013 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 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
31 
32 static void
34 {
35  if (NULL != spa)
36  {
41  }
42 }
43 
44 
45 struct SplittedHTTPAddress *
46 http_split_address (const char *addr)
47 {
48  struct SplittedHTTPAddress *sp;
49  char *src = GNUNET_strdup (addr);
50  char *protocol_start = NULL;
51  char *host_start = NULL;
52  char *v6_end = NULL;
53  char *port_start = NULL;
54  char *path_start = NULL;
55 
56  protocol_start = src;
57 
58  sp = GNUNET_new (struct SplittedHTTPAddress);
59  /* Address string consists of protocol://host[:port]path*/
60 
61  host_start = strstr (src, "://");
62  if (NULL == host_start)
63  {
64  GNUNET_free (src);
65  GNUNET_free (sp);
66  return NULL;
67  }
68  host_start[0] = '\0';
69  sp->protocol = GNUNET_strdup (protocol_start);
70 
71  host_start += strlen ("://");
72  if (strlen (host_start) == 0)
73  {
74  GNUNET_free (src);
75  GNUNET_free (sp->protocol);
76  GNUNET_free (sp);
77  return NULL;
78  }
79 
80  /* Find path start */
81  path_start = strchr (host_start, '/');
82  if (NULL != path_start)
83  {
84  sp->path = GNUNET_strdup (path_start);
85  path_start[0] = '\0';
86  }
87  else
88  sp->path = GNUNET_strdup ("");
89 
90  if (strlen (host_start) < 1)
91  {
92  GNUNET_free (src);
93  GNUNET_free (sp->protocol);
94  GNUNET_free (sp->path);
95  GNUNET_free (sp);
96  return NULL;
97  }
98 
99  if (NULL != (port_start = strrchr (host_start, ':')))
100  {
101  /* *We COULD have a port, but also an IPv6 address! */
102  if (NULL != (v6_end = strchr (host_start, ']')))
103  {
104  if (v6_end < port_start)
105  {
106  /* IPv6 address + port */
107  port_start[0] = '\0';
108  port_start++;
109  sp->port = atoi (port_start);
110  if ((0 == sp->port) || (65535 < sp->port))
111  {
112  GNUNET_free (src);
113  GNUNET_free (sp->protocol);
114  GNUNET_free (sp->path);
115  GNUNET_free (sp);
116  return NULL;
117  }
118  }
119  else
120  {
121  /* IPv6 address + no port */
122  if (0 == strcmp (sp->protocol, "https"))
123  sp->port = HTTPS_DEFAULT_PORT;
124  else if (0 == strcmp (sp->protocol, "http"))
125  sp->port = HTTP_DEFAULT_PORT;
126  }
127  }
128  else
129  {
130  /* No IPv6 address */
131  port_start[0] = '\0';
132  port_start++;
133  sp->port = atoi (port_start);
134  if ((0 == sp->port) || (65535 < sp->port))
135  {
136  GNUNET_free (src);
137  GNUNET_free (sp->protocol);
138  GNUNET_free (sp->path);
139  GNUNET_free (sp);
140  return NULL;
141  }
142  }
143  }
144  else
145  {
146  /* No ':' as port separator, default port for protocol */
147  if (0 == strcmp (sp->protocol, "https"))
148  sp->port = HTTPS_DEFAULT_PORT;
149  else if (0 == strcmp (sp->protocol, "http"))
150  sp->port = HTTP_DEFAULT_PORT;
151  else
152  {
153  GNUNET_break (0);
154  GNUNET_free (src);
155  GNUNET_free (sp->protocol);
156  GNUNET_free (sp->path);
157  GNUNET_free (sp);
158  return NULL;
159  }
160  }
161  if (strlen (host_start) > 0)
162  sp->host = GNUNET_strdup (host_start);
163  else
164  {
165  GNUNET_break (0);
166  GNUNET_free (src);
167  GNUNET_free (sp->protocol);
168  GNUNET_free (sp->path);
169  GNUNET_free (sp);
170  return NULL;
171  }
172  GNUNET_free (src);
173  return sp;
174 }
175 
176 
181 {
186 
191 
196 
201 
205  void *asc_cls;
206 
211 
216 
220  char *plugin;
221 
225  int sucess;
226 
230  uint32_t options;
231 };
232 
237 
242 
255 static const char *
257  const struct
259  uint32_t options,
260  const char *dnsresult)
261 {
262  static char rbuf[1024];
263  char *res;
264 
265  GNUNET_asprintf (&res, "%s.%u.%s://%s:%u%s", plugin, options, saddr->protocol,
266  dnsresult, saddr->port, saddr->path);
267  if (strlen (res) + 1 < 500)
268  {
269  GNUNET_memcpy (rbuf, res, strlen (res) + 1);
270  GNUNET_free (res);
271  return rbuf;
272  }
273  GNUNET_break (0);
274  GNUNET_free (res);
275  return NULL;
276 }
277 
278 
279 static void
281 {
282  struct PrettyPrinterContext *ppc = cls;
283 
284  if (NULL != hostname)
285  {
286  ppc->asc (ppc->asc_cls,
288  ppc->options,
289  hostname), GNUNET_OK);
290  ppc->sucess = GNUNET_YES;
291  }
292  else
293  {
294  ppc->asc (ppc->asc_cls, NULL,
295  (GNUNET_NO == ppc->sucess) ? GNUNET_SYSERR : GNUNET_OK);
296 
297  GNUNET_CONTAINER_DLL_remove (dll_ppc_head, dll_ppc_tail, ppc);
298  http_clean_splitted (ppc->saddr);
299  GNUNET_free (ppc->plugin);
300  GNUNET_free (ppc);
301  }
302 }
303 
304 
305 static int
306 http_common_dns_reverse_lookup (const struct sockaddr *sockaddr,
307  socklen_t sockaddr_len,
308  const char *type,
309  struct SplittedHTTPAddress *saddr,
310  uint32_t options,
313  void *asc_cls)
314 {
315  struct PrettyPrinterContext *ppc;
316 
317  ppc = GNUNET_new (struct PrettyPrinterContext);
318  ppc->saddr = saddr;
319  ppc->asc = asc;
320  ppc->asc_cls = asc_cls;
321  ppc->plugin = GNUNET_strdup (type);
322  ppc->options = options;
324  sockaddr_len,
325  GNUNET_YES,
326  timeout,
327  &
329  ppc);
330  if (NULL == ppc->resolver_handle)
331  {
332  GNUNET_free (ppc->plugin);
333  GNUNET_free (ppc);
334  return GNUNET_SYSERR;
335  }
336  GNUNET_CONTAINER_DLL_insert (dll_ppc_head,
337  dll_ppc_tail,
338  ppc);
339  return GNUNET_OK;
340 }
341 
342 
343 static void
345  const struct sockaddr *addr,
346  socklen_t addrlen)
347 {
348  struct PrettyPrinterContext *ppc = cls;
349 
350  if (NULL != addr)
351  {
352  ppc->asc (ppc->asc_cls,
354  ppc->options,
355  GNUNET_a2s (addr,
356  addrlen)),
357  GNUNET_OK);
358  ppc->sucess = GNUNET_YES;
359  ppc->asc (ppc->asc_cls, GNUNET_a2s (addr, addrlen), GNUNET_OK);
360  }
361  else
362  {
363  ppc->asc (ppc->asc_cls, NULL,
364  (GNUNET_NO == ppc->sucess) ? GNUNET_SYSERR : GNUNET_OK);
365 
366  GNUNET_CONTAINER_DLL_remove (dll_ppc_head, dll_ppc_tail, ppc);
367  GNUNET_free (ppc->plugin);
368  http_clean_splitted (ppc->saddr);
369  GNUNET_free (ppc);
370  }
371 }
372 
373 
374 static int
376  const char *type,
377  struct SplittedHTTPAddress *saddr,
378  uint32_t options,
381  void *asc_cls)
382 {
383  struct PrettyPrinterContext *ppc;
384 
385  ppc = GNUNET_new (struct PrettyPrinterContext);
386  ppc->sucess = GNUNET_NO;
387  ppc->saddr = saddr;
388  ppc->asc = asc;
389  ppc->asc_cls = asc_cls;
390  ppc->plugin = GNUNET_strdup (type);
391  ppc->options = options;
393  AF_UNSPEC,
394  timeout,
396  ppc);
397  if (NULL == ppc->resolver_handle)
398  {
399  GNUNET_free (ppc->plugin);
400  GNUNET_free (ppc);
401  return GNUNET_SYSERR;
402  }
403  GNUNET_CONTAINER_DLL_insert (dll_ppc_head,
404  dll_ppc_tail,
405  ppc);
406  return GNUNET_OK;
407 }
408 
409 
424 void
426  const void *addr,
427  size_t addrlen,
428  int numeric,
431  asc,
432  void *asc_cls)
433 {
434  const struct HttpAddress *address = addr;
435  struct SplittedHTTPAddress *saddr;
436  struct sockaddr *sock_addr;
437  const char *ret;
438  char *addr_str;
439  int res;
440  int have_ip;
441 
442  saddr = NULL;
443  sock_addr = NULL;
444  if ((addrlen < sizeof(struct HttpAddress)) ||
445  (addrlen != http_common_address_get_size (address)))
446  {
447  GNUNET_break (0);
448  goto handle_error;
449  }
450 
451  addr_str = (char *) &address[1];
452  if (addr_str[ntohl (address->urlen) - 1] != '\0')
453  {
454  GNUNET_break (0);
455  goto handle_error;
456  }
457 
458  saddr = http_split_address (addr_str);
459  if (NULL == saddr)
460  {
461  GNUNET_break (0);
462  goto handle_error;
463  }
464 
465  sock_addr = http_common_socket_from_address (addr, addrlen, &res);
466  if (GNUNET_SYSERR == res)
467  {
468  /* Malformed address */
469  GNUNET_break (0);
470  goto handle_error;
471  }
472  else if (GNUNET_NO == res)
473  {
474  /* Could not convert to IP */
475  have_ip = GNUNET_NO;
476  }
477  else if (GNUNET_YES == res)
478  {
479  /* Converted to IP */
480  have_ip = GNUNET_YES;
481  }
482  else
483  {
484  /* Must not happen */
485  GNUNET_break (0);
486  goto handle_error;
487  }
488 
489  if ((GNUNET_YES == numeric) &&
490  (GNUNET_YES == have_ip))
491  {
492  /* No lookup required */
493  ret = http_common_plugin_address_to_string (type, address, addrlen);
494  asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
495  asc (asc_cls, NULL, GNUNET_OK);
496  http_clean_splitted (saddr);
497  GNUNET_free_non_null (sock_addr);
498  return;
499  }
500  if ((GNUNET_YES == numeric) &&
501  (GNUNET_NO == have_ip))
502  {
503  /* Forward lookup */
504  if (GNUNET_SYSERR ==
505  http_common_dns_ip_lookup (saddr->host, type, saddr,
506  address->options, timeout,
507  asc, asc_cls))
508  {
509  GNUNET_break (0);
510  goto handle_error;
511  }
512  /* Wait for resolver callback */
513  GNUNET_free_non_null (sock_addr);
514  return;
515  }
516  if ((GNUNET_NO == numeric) &&
517  (GNUNET_YES == have_ip))
518  {
519  /* Reverse lookup */
520  if (GNUNET_SYSERR ==
522  (AF_INET == sock_addr->sa_family)
523  ? sizeof(struct sockaddr_in)
524  : sizeof(struct sockaddr_in6),
525  type,
526  saddr,
527  address->options, timeout,
528  asc, asc_cls))
529  {
530  GNUNET_break (0);
531  goto handle_error;
532  }
533  /* Wait for resolver callback */
534  GNUNET_free_non_null (sock_addr);
535  return;
536  }
537  if ((GNUNET_NO == numeric) &&
538  (GNUNET_NO == have_ip))
539  {
540  /* No lookup required */
541  ret = http_common_plugin_address_to_string (type, address, addrlen);
542  asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
543  asc (asc_cls, NULL, GNUNET_OK);
544  GNUNET_free_non_null (sock_addr);
545  http_clean_splitted (saddr);
546  return;
547  }
548  /* Error (argument supplied not GNUNET_YES or GNUNET_NO) */
549  GNUNET_break (0);
550  goto handle_error;
551 
552 handle_error:
553  /* Report error */
554  asc (asc_cls, NULL, GNUNET_SYSERR);
555  asc (asc_cls, NULL, GNUNET_OK);
556  GNUNET_free_non_null (sock_addr);
557  if (NULL != saddr)
558  http_clean_splitted (saddr);
559 }
560 
561 
565 const char *
567  const void *addr,
568  size_t addrlen)
569 {
570  static char rbuf[1024];
571  const struct HttpAddress *address = addr;
572  const char *addr_str;
573 
574  if (NULL == addr)
575  {
576  GNUNET_break (0);
577  return NULL;
578  }
579  if (0 == addrlen)
580  {
581  GNUNET_break (0);
582  return NULL;
583  }
584  if (addrlen != http_common_address_get_size (address))
585  {
586  GNUNET_break (0);
587  return NULL;
588  }
589  addr_str = (char *) &address[1];
590  if (addr_str[ntohl (address->urlen) - 1] != '\0')
591  return NULL;
592 
593  GNUNET_memcpy (rbuf,
594  &address[1],
595  ntohl (address->urlen));
596  return rbuf;
597 }
598 
599 
611 const char *
613  const void *addr,
614  size_t addrlen)
615 {
616  static char rbuf[1024];
617  const struct HttpAddress *address = addr;
618  const char *addr_str;
619  char *res;
620 
621  GNUNET_assert (NULL != plugin);
622  if (NULL == addr)
623  return NULL;
624  if (0 == addrlen)
625  return NULL;
626  if (addrlen != http_common_address_get_size (address))
627  return NULL;
628  addr_str = (char *) &address[1];
629  if (addr_str[ntohl (address->urlen) - 1] != '\0')
630  return NULL;
631  GNUNET_asprintf (&res, "%s.%u.%s", plugin, ntohl (address->options),
632  &address[1]);
633  if (strlen (res) + 1 < 500)
634  {
635  GNUNET_memcpy (rbuf, res, strlen (res) + 1);
636  GNUNET_free (res);
637  return rbuf;
638  }
639  GNUNET_break (0);
640  GNUNET_free (res);
641  return NULL;
642 }
643 
644 
657 int
659  const char *addr,
660  uint16_t addrlen,
661  void **buf,
662  size_t *added)
663 {
664  struct HttpAddress *a;
665  char *address;
666  char *plugin;
667  char *optionstr;
668  size_t urlen;
669  uint32_t options;
670 
671  /* Format protocol.options.address:port */
672  address = NULL;
673  plugin = NULL;
674  optionstr = NULL;
675  if ((NULL == addr) || (addrlen == 0))
676  {
677  GNUNET_break (0);
678  return GNUNET_SYSERR;
679  }
680  if ('\0' != addr[addrlen - 1])
681  {
682  GNUNET_break (0);
683  return GNUNET_SYSERR;
684  }
685  if (strlen (addr) != addrlen - 1)
686  {
687  GNUNET_break (0);
688  return GNUNET_SYSERR;
689  }
690  plugin = GNUNET_strdup (addr);
691  optionstr = strchr (plugin, '.');
692  if (NULL == optionstr)
693  {
694  GNUNET_break (0);
695  GNUNET_free (plugin);
696  return GNUNET_SYSERR;
697  }
698  optionstr[0] = '\0';
699  optionstr++;
700  options = atol (optionstr); /* 0 on conversion error, that's ok */
701  address = strchr (optionstr, '.');
702  if (NULL == address)
703  {
704  GNUNET_break (0);
705  GNUNET_free (plugin);
706  return GNUNET_SYSERR;
707  }
708  address[0] = '\0';
709  address++;
710  urlen = strlen (address) + 1;
711 
712  a = GNUNET_malloc (sizeof(struct HttpAddress) + urlen);
713  a->options = htonl (options);
714  a->urlen = htonl (urlen);
715  GNUNET_memcpy (&a[1], address, urlen);
716 
717  (*buf) = a;
718  (*added) = sizeof(struct HttpAddress) + urlen;
719  GNUNET_free (plugin);
720  return GNUNET_OK;
721 }
722 
723 
732 struct HttpAddress *
733 http_common_address_from_socket (const char *protocol,
734  const struct sockaddr *addr,
735  socklen_t addrlen)
736 {
737  struct HttpAddress *address = NULL;
738  char *res;
739  size_t len;
740 
741  GNUNET_asprintf (&res,
742  "%s://%s",
743  protocol,
744  GNUNET_a2s (addr,
745  addrlen));
746  len = strlen (res) + 1;
747  address = GNUNET_malloc (sizeof(struct HttpAddress) + len);
748  address->options = htonl (HTTP_OPTIONS_NONE);
749  address->urlen = htonl (len);
750  GNUNET_memcpy (&address[1], res, len);
751  GNUNET_free (res);
752  return address;
753 }
754 
755 
767 struct sockaddr *
769  size_t addrlen,
770  int *res)
771 {
772  const struct HttpAddress *ha;
773  struct SplittedHTTPAddress *spa;
774  struct sockaddr_storage *s;
775  char *to_conv;
776  size_t urlen;
777 
778  (*res) = GNUNET_SYSERR;
779  ha = (const struct HttpAddress *) addr;
780  if (NULL == addr)
781  {
782  GNUNET_break (0);
783  return NULL;
784  }
785  if (0 == addrlen)
786  {
787  GNUNET_break (0);
788  return NULL;
789  }
790  if (addrlen < sizeof(struct HttpAddress))
791  {
792  GNUNET_break (0);
793  return NULL;
794  }
795  urlen = ntohl (ha->urlen);
796  if (sizeof(struct HttpAddress) + urlen != addrlen)
797  {
798  /* This is a legacy addresses */
799  return NULL;
800  }
801  if (addrlen < sizeof(struct HttpAddress) + urlen)
802  {
803  /* This is a legacy addresses */
804  return NULL;
805  }
806  if (((char *) addr)[addrlen - 1] != '\0')
807  {
808  GNUNET_break (0);
809  return NULL;
810  }
811  spa = http_split_address ((const char *) &ha[1]);
812  if (NULL == spa)
813  {
814  (*res) = GNUNET_SYSERR;
815  return NULL;
816  }
817 
818  s = GNUNET_new (struct sockaddr_storage);
819  GNUNET_asprintf (&to_conv, "%s:%u", spa->host, spa->port);
820  if (GNUNET_SYSERR
821  == GNUNET_STRINGS_to_address_ip (to_conv, strlen (to_conv), s))
822  {
823  /* could be a hostname */
824  GNUNET_free (s);
825  (*res) = GNUNET_NO;
826  s = NULL;
827  }
828  else if ((AF_INET != s->ss_family) && (AF_INET6 != s->ss_family))
829  {
830  GNUNET_free (s);
831  (*res) = GNUNET_SYSERR;
832  s = NULL;
833  }
834  else
835  {
836  (*res) = GNUNET_YES;
837  }
838  http_clean_splitted (spa);
839  GNUNET_free (to_conv);
840  return (struct sockaddr *) s;
841 }
842 
843 
850 size_t
852 {
853  return sizeof(struct HttpAddress) + ntohl (addr->urlen);
854 }
855 
856 
866 size_t
867 http_common_cmp_addresses (const void *addr1,
868  size_t addrlen1,
869  const void *addr2,
870  size_t addrlen2)
871 {
872  const char *a1 = addr1;
873  const char *a2 = addr2;
874  const struct HttpAddress *ha1;
875  const struct HttpAddress *ha2;
876 
877  ha1 = (const struct HttpAddress *) a1;
878  ha2 = (const struct HttpAddress *) a2;
879 
880  if (NULL == a1)
881  return GNUNET_SYSERR;
882  if (0 == addrlen1)
883  return GNUNET_SYSERR;
884  if (a1[addrlen1 - 1] != '\0')
885  return GNUNET_SYSERR;
886 
887  if (NULL == a2)
888  return GNUNET_SYSERR;
889  if (0 == addrlen2)
890  return GNUNET_SYSERR;
891  if (a2[addrlen2 - 1] != '\0')
892  return GNUNET_SYSERR;
893 
894  if (addrlen1 != addrlen2)
895  return GNUNET_NO;
896  if (ha1->urlen != ha2->urlen)
897  return GNUNET_NO;
898 
899  if (0 == strcmp ((const char *) &ha1[1], (const char *) &ha2[1]))
900  return GNUNET_YES;
901  return GNUNET_NO;
902 }
903 
904 
915  const struct GNUNET_HELLO_Address *address)
916 {
917  struct sockaddr *sa;
918  enum GNUNET_NetworkType net_type;
919  size_t salen = 0;
920  int res;
921 
922  net_type = GNUNET_NT_UNSPECIFIED;
924  address->address_length,
925  &res);
926  if (GNUNET_SYSERR == res)
927  return net_type;
928  if (GNUNET_YES == res)
929  {
930  GNUNET_assert (NULL != sa);
931  if (AF_INET == sa->sa_family)
932  {
933  salen = sizeof(struct sockaddr_in);
934  }
935  else if (AF_INET6 == sa->sa_family)
936  {
937  salen = sizeof(struct sockaddr_in6);
938  }
939  net_type = env->get_address_type (env->cls,
940  sa,
941  salen);
942  GNUNET_free (sa);
943  }
944  return net_type;
945 }
946 
947 
948 /* end of plugin_transport_http_common.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
GNUNET_TRANSPORT_AddressStringCallback asc
Function to call with the result.
static void http_common_dns_reverse_lookup_cb(void *cls, const char *hostname)
uint32_t options
Address options see enum HttpAddressOptions
const void * address
Binary representation of the address (plugin-specific).
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct SplittedHTTPAddress * saddr
Splitted Address.
const char * http_common_plugin_address_to_url(void *cls, const void *addr, size_t addrlen)
FIXME.
int http_common_plugin_string_to_address(void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
Function called to convert a string address to a binary address.
GNUNET_TRANSPORT_AddressToType get_address_type
Function that will be called to figure if an address is an loopback, LAN, WAN etc.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RESOLVER_RequestHandle * resolver_handle
Resolver handle.
struct SplittedHTTPAddress * http_split_address(const char *addr)
Split an HTTP address into protocol, hostname, port and path components.
Closure for append_port().
#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
#define GNUNET_NO
Definition: gnunet_common.h:78
static int numeric
Option -n.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition: resolver_api.c:939
#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.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_get(const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
Perform a reverse DNS lookup.
void * asc_cls
Clsoure for asc.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int sucess
Was conversion successful.
#define HTTP_DEFAULT_PORT
size_t http_common_address_get_size(const struct HttpAddress *addr)
Get the length of an address.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
void * cls
Closure for the various callbacks.
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
Representation of HTTP URL split into its components.
void(* GNUNET_TRANSPORT_AddressStringCallback)(void *cls, const char *address, int res)
Function called by the pretty printer for the resolved address for each human-readable address obtain...
static int http_common_dns_reverse_lookup(const struct sockaddr *sockaddr, socklen_t sockaddr_len, const char *type, struct SplittedHTTPAddress *saddr, uint32_t options, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
static const char * http_common_plugin_dnsresult_to_address(const char *plugin, const struct SplittedHTTPAddress *saddr, uint32_t options, const char *dnsresult)
Function called for a quick conversion of the binary address to a numeric address.
struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
The transport service will pass a pointer to a struct of this type as the first and only argument to ...
struct PrettyPrinterContext * prev
DLL.
void * addr
Address following.
static char buf[2048]
void http_common_plugin_address_pretty_printer(void *cls, const char *type, const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
Convert the transports address to a nice, human-readable format.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
static struct PrettyPrinterContext * dll_ppc_tail
Tail of PPC list.
static int res
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static int http_common_dns_ip_lookup(const char *name, const char *type, struct SplittedHTTPAddress *saddr, uint32_t options, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
uint32_t urlen
Length of URL located after struct.
static void http_common_dns_ip_lookup_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Handle to a request given to the resolver.
Definition: resolver_api.c:102
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct PrettyPrinterContext * next
DLL.
const char * http_common_plugin_address_to_string(const char *plugin, const void *addr, size_t addrlen)
Function called for a quick conversion of the binary address to a numeric address.
enum GNUNET_NetworkType http_common_get_network_for_address(struct GNUNET_TRANSPORT_PluginEnvironment *env, const struct GNUNET_HELLO_Address *address)
Function obtain the network type for an address.
static char * hostname
Our hostname; we give this to all the peers we start.
size_t http_common_cmp_addresses(const void *addr1, size_t addrlen1, const void *addr2, size_t addrlen2)
Compare addr1 to addr2.
struct sockaddr * http_common_socket_from_address(const void *addr, size_t addrlen, int *res)
Create a socketaddr from a HTTP address.
uint32_t options
Address options.
const char * name
An address for communicating with a peer.
struct HttpAddress * http_common_address_from_socket(const char *protocol, const struct sockaddr *addr, socklen_t addrlen)
Create a HTTP address from a socketaddr.
Entry in list of pending tasks.
Definition: scheduler.c:134
static struct PrettyPrinterContext * dll_ppc_head
Head of PPC list.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
static char * address
GNS address for this phone.
HTTP addresses including a full URI.
int GNUNET_STRINGS_to_address_ip(const char *addr, uint16_t addrlen, struct sockaddr_storage *r_buf)
Tries to convert addr string to an IP (v4 or v6) address.
Definition: strings.c:1326
#define GNUNET_malloc(size)
Wrapper around malloc.
#define HTTPS_DEFAULT_PORT
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
static void http_clean_splitted(struct SplittedHTTPAddress *spa)
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Category of last resort.
Definition: gnunet_nt_lib.h:40