GNUnet  0.11.x
Data Structures | Functions | Variables
plugin_transport_http_common.c File Reference

functionality shared between http(s)client plugins More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_plugin.h"
#include "plugin_transport_http_common.h"
#include "gnunet_resolver_service.h"
Include dependency graph for plugin_transport_http_common.c:

Go to the source code of this file.

Data Structures

struct  PrettyPrinterContext
 Closure for append_port(). More...
 

Functions

static void http_clean_splitted (struct SplittedHTTPAddress *spa)
 
struct SplittedHTTPAddresshttp_split_address (const char *addr)
 Split an HTTP address into protocol, hostname, port and path components. More...
 
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. More...
 
static void http_common_dns_reverse_lookup_cb (void *cls, const char *hostname)
 
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 void http_common_dns_ip_lookup_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 
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)
 
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. More...
 
const char * http_common_plugin_address_to_url (void *cls, const void *addr, size_t addrlen)
 FIXME. More...
 
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. More...
 
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. More...
 
struct HttpAddresshttp_common_address_from_socket (const char *protocol, const struct sockaddr *addr, socklen_t addrlen)
 Create a HTTP address from a socketaddr. More...
 
struct sockaddr * http_common_socket_from_address (const void *addr, size_t addrlen, int *res)
 Create a socketaddr from a HTTP address. More...
 
size_t http_common_address_get_size (const struct HttpAddress *addr)
 Get the length of an address. More...
 
size_t http_common_cmp_addresses (const void *addr1, size_t addrlen1, const void *addr2, size_t addrlen2)
 Compare addr1 to addr2. More...
 
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. More...
 

Variables

static struct PrettyPrinterContextdll_ppc_head
 Head of PPC list. More...
 
static struct PrettyPrinterContextdll_ppc_tail
 Tail of PPC list. More...
 

Detailed Description

functionality shared between http(s)client plugins

functionality shared by http client and server transport service plugin

Author
Matthias Wachs
Matthias Wachs
Christian Grothoff

Definition in file plugin_transport_http_common.c.

Function Documentation

◆ http_clean_splitted()

static void http_clean_splitted ( struct SplittedHTTPAddress spa)
static

Definition at line 33 of file plugin_transport_http_common.c.

34 {
35  if (NULL != spa)
36  {
37  GNUNET_free (spa->protocol);
38  GNUNET_free (spa->host);
39  GNUNET_free (spa->path);
40  GNUNET_free (spa);
41  }
42 }
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_free, SplittedHTTPAddress::host, SplittedHTTPAddress::path, and SplittedHTTPAddress::protocol.

Referenced by http_common_dns_ip_lookup_cb(), http_common_dns_reverse_lookup_cb(), http_common_plugin_address_pretty_printer(), and http_common_socket_from_address().

Here is the caller graph for this function:

◆ http_split_address()

struct SplittedHTTPAddress* http_split_address ( const char *  addr)

Split an HTTP address into protocol, hostname, port and path components.

Definition at line 46 of file plugin_transport_http_common.c.

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 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define HTTP_DEFAULT_PORT
#define HTTPS_DEFAULT_PORT
Representation of HTTP URL split into its components.

References GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_strdup, SplittedHTTPAddress::host, HTTP_DEFAULT_PORT, HTTPS_DEFAULT_PORT, SplittedHTTPAddress::path, SplittedHTTPAddress::port, and SplittedHTTPAddress::protocol.

Referenced by http_common_plugin_address_pretty_printer(), and http_common_socket_from_address().

Here is the caller graph for this function:

◆ http_common_plugin_dnsresult_to_address()

static const char* http_common_plugin_dnsresult_to_address ( const char *  plugin,
const struct SplittedHTTPAddress saddr,
uint32_t  options,
const char *  dnsresult 
)
static

Function called for a quick conversion of the binary address to a numeric address.

Note that the caller must not free the address and that the next call to this function is allowed to override the address again.

Parameters
pluginthe name of the plugin
saddrthe split http address
optionsaddress options
dnsresultdns name to include in address
Returns
string representing the same address or NULL on error

Definition at line 256 of file plugin_transport_http_common.c.

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 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static int res
struct Plugin * plugin
The process handle to the testbed service.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.

References GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_memcpy, options, SplittedHTTPAddress::path, plugin, SplittedHTTPAddress::port, SplittedHTTPAddress::protocol, res, and PrettyPrinterContext::saddr.

Referenced by http_common_dns_ip_lookup_cb(), and http_common_dns_reverse_lookup_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_dns_reverse_lookup_cb()

static void http_common_dns_reverse_lookup_cb ( void *  cls,
const char *  hostname 
)
static

Definition at line 280 of file plugin_transport_http_common.c.

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->success = GNUNET_YES;
291  }
292  else
293  {
294  ppc->asc (ppc->asc_cls, NULL,
295  (GNUNET_NO == ppc->success) ? GNUNET_SYSERR : GNUNET_OK);
296 
298  http_clean_splitted (ppc->saddr);
299  GNUNET_free (ppc->plugin);
300  GNUNET_free (ppc);
301  }
302 }
static char * hostname
Our hostname; we give this to all the peers we start.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct PrettyPrinterContext * dll_ppc_head
Head of PPC list.
static void http_clean_splitted(struct SplittedHTTPAddress *spa)
static struct PrettyPrinterContext * dll_ppc_tail
Tail of PPC list.
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.
Closure for append_port().
struct SplittedHTTPAddress * saddr
Split Address.
void * asc_cls
Clsoure for asc.
GNUNET_TRANSPORT_AddressStringCallback asc
Function to call with the result.
int success
Was conversion successful.
uint32_t options
Address options.

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, dll_ppc_head, dll_ppc_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, hostname, http_clean_splitted(), http_common_plugin_dnsresult_to_address(), PrettyPrinterContext::options, PrettyPrinterContext::plugin, PrettyPrinterContext::saddr, and PrettyPrinterContext::success.

Referenced by http_common_dns_reverse_lookup().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_dns_reverse_lookup()

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

Definition at line 306 of file plugin_transport_http_common.c.

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  }
337  dll_ppc_tail,
338  ppc);
339  return GNUNET_OK;
340 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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.
static void http_common_dns_reverse_lookup_cb(void *cls, const char *hostname)
struct GNUNET_RESOLVER_RequestHandle * resolver_handle
Resolver handle.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, dll_ppc_head, dll_ppc_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_RESOLVER_hostname_get(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, http_common_dns_reverse_lookup_cb(), options, PrettyPrinterContext::options, PrettyPrinterContext::plugin, PrettyPrinterContext::resolver_handle, PrettyPrinterContext::saddr, timeout, and type.

Referenced by http_common_plugin_address_pretty_printer().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_dns_ip_lookup_cb()

static void http_common_dns_ip_lookup_cb ( void *  cls,
const struct sockaddr *  addr,
socklen_t  addrlen 
)
static

Definition at line 344 of file plugin_transport_http_common.c.

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->success = 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->success) ? GNUNET_SYSERR : GNUNET_OK);
365 
367  GNUNET_free (ppc->plugin);
368  http_clean_splitted (ppc->saddr);
369  GNUNET_free (ppc);
370  }
371 }
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).

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, dll_ppc_head, dll_ppc_tail, GNUNET_a2s(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, http_clean_splitted(), http_common_plugin_dnsresult_to_address(), PrettyPrinterContext::options, PrettyPrinterContext::plugin, PrettyPrinterContext::saddr, and PrettyPrinterContext::success.

Referenced by http_common_dns_ip_lookup().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_dns_ip_lookup()

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 
)
static

Definition at line 375 of file plugin_transport_http_common.c.

382 {
383  struct PrettyPrinterContext *ppc;
384 
385  ppc = GNUNET_new (struct PrettyPrinterContext);
386  ppc->success = 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  }
404  dll_ppc_tail,
405  ppc);
406  return GNUNET_OK;
407 }
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
const char * name
static void http_common_dns_ip_lookup_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen)

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, dll_ppc_head, dll_ppc_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_RESOLVER_ip_get(), GNUNET_strdup, GNUNET_SYSERR, http_common_dns_ip_lookup_cb(), name, options, PrettyPrinterContext::options, PrettyPrinterContext::plugin, PrettyPrinterContext::resolver_handle, PrettyPrinterContext::saddr, PrettyPrinterContext::success, timeout, and type.

Referenced by http_common_plugin_address_pretty_printer().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_plugin_address_pretty_printer()

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.

Parameters
clsclosure
typename of the transport that generated the address
addrone of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlenlength of the addr
numericshould (IP) addresses be displayed in numeric form?
timeoutafter how long should we give up?
ascfunction to call on each string
asc_clsclosure for asc

Definition at line 425 of file plugin_transport_http_common.c.

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 */
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 (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 (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 (sock_addr);
535  return;
536  }
537  if ((GNUNET_NO == numeric) &&
538  (GNUNET_NO == have_ip))
539  {
540  /* No lookup required */
542  asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
543  asc (asc_cls, NULL, GNUNET_OK);
544  GNUNET_free (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 (sock_addr);
557  if (NULL != saddr)
558  http_clean_splitted (saddr);
559 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static char * address
GNS address for this phone.
static int numeric
Option -n.
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.
size_t http_common_address_get_size(const struct HttpAddress *addr)
Get the length of an address.
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)
struct SplittedHTTPAddress * http_split_address(const char *addr)
Split an HTTP address into protocol, hostname, port and path components.
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)
struct sockaddr * http_common_socket_from_address(const void *addr, size_t addrlen, int *res)
Create a socketaddr from a HTTP address.
HTTP addresses including a full URI.
void * addr
Address following.

References HttpAddress::addr, address, GNUNET_break, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, SplittedHTTPAddress::host, http_clean_splitted(), http_common_address_get_size(), http_common_dns_ip_lookup(), http_common_dns_reverse_lookup(), http_common_plugin_address_to_string(), http_common_socket_from_address(), http_split_address(), numeric, res, ret, timeout, and type.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_plugin_address_to_url()

const char* http_common_plugin_address_to_url ( void *  cls,
const void *  addr,
size_t  addrlen 
)

FIXME.

Definition at line 566 of file plugin_transport_http_common.c.

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 }

References HttpAddress::addr, address, GNUNET_break, GNUNET_memcpy, and http_common_address_get_size().

Referenced by client_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_plugin_address_to_string()

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.

Note that the caller must not free the address and that the next call to this function is allowed to override the address again.

Parameters
pluginthe name of the plugin
addrbinary address
addrlenlength of the address
Returns
string representing the same address

Definition at line 612 of file plugin_transport_http_common.c.

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  (char*)&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 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References HttpAddress::addr, address, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_memcpy, http_common_address_get_size(), plugin, and res.

Referenced by client_connect(), client_receive_mst_cb(), http_client_plugin_address_to_string(), http_client_plugin_get_session(), http_common_plugin_address_pretty_printer(), http_server_plugin_address_to_string(), libgnunet_plugin_transport_http_client_done(), server_access_cb(), server_add_address(), server_disconnect_cb(), server_lookup_connection(), server_receive_mst_cb(), and server_remove_address().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_plugin_string_to_address()

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.

Parameters
clsclosure ('struct Plugin*')
addrstring address
addrlenlength of the addr
buflocation to store the buffer If the function returns GNUNET_SYSERR, its contents are undefined.
addedlength of created address
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 658 of file plugin_transport_http_common.c.

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  }
691  optionstr = strchr (plugin, '.');
692  if (NULL == optionstr)
693  {
694  GNUNET_break (0);
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);
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;
720  return GNUNET_OK;
721 }
#define GNUNET_malloc(size)
Wrapper around malloc.
uint32_t urlen
Length of URL located after struct.
uint32_t options
Address options see enum HttpAddressOptions

References HttpAddress::addr, address, GNUNET_break, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, options, HttpAddress::options, plugin, and HttpAddress::urlen.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

◆ http_common_address_from_socket()

struct HttpAddress* http_common_address_from_socket ( const char *  protocol,
const struct sockaddr *  addr,
socklen_t  addrlen 
)

Create a HTTP address from a socketaddr.

Parameters
protocolprotocol
addrsockaddr * address
addrlenlength of the address
Returns
the HttpAddress

Definition at line 733 of file plugin_transport_http_common.c.

736 {
737  struct HttpAddress *address = NULL;
738  char *res;
739  size_t len;
740 
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 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
@ HTTP_OPTIONS_NONE
No bits set.

References HttpAddress::addr, address, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, HTTP_OPTIONS_NONE, len, and res.

Referenced by server_add_address(), server_lookup_connection(), and server_remove_address().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_socket_from_address()

struct sockaddr* http_common_socket_from_address ( const void *  addr,
size_t  addrlen,
int *  res 
)

Create a socketaddr from a HTTP address.

Parameters
addra sockaddr * address
addrlenlength of the addr
resthe result: GNUNET_SYSERR, invalid input, GNUNET_YES: could convert to ip, GNUNET_NO: valid input but could not convert to ip (hostname?)
Returns
the string

Definition at line 768 of file plugin_transport_http_common.c.

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 }
enum GNUNET_GenericReturnValue 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:1121

References HttpAddress::addr, GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_STRINGS_to_address_ip(), GNUNET_SYSERR, GNUNET_YES, SplittedHTTPAddress::host, http_clean_splitted(), http_split_address(), SplittedHTTPAddress::port, and HttpAddress::urlen.

Referenced by http_client_plugin_get_session(), and http_common_plugin_address_pretty_printer().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ http_common_address_get_size()

size_t http_common_address_get_size ( const struct HttpAddress addr)

Get the length of an address.

Parameters
addraddress
Returns
the size

Definition at line 851 of file plugin_transport_http_common.c.

852 {
853  return sizeof(struct HttpAddress) + ntohl (addr->urlen);
854 }

References HttpAddress::addr, and HttpAddress::urlen.

Referenced by http_common_plugin_address_pretty_printer(), http_common_plugin_address_to_string(), http_common_plugin_address_to_url(), server_add_address(), server_lookup_connection(), and server_remove_address().

Here is the caller graph for this function:

◆ http_common_cmp_addresses()

size_t http_common_cmp_addresses ( const void *  addr1,
size_t  addrlen1,
const void *  addr2,
size_t  addrlen2 
)

Compare addr1 to addr2.

Parameters
addr1address1
addrlen1address 1 length
addr2address2
addrlen2address 2 length
Returns
GNUNET_YES if equal, GNUNET_NO if not, GNUNET_SYSERR on error

Definition at line 867 of file plugin_transport_http_common.c.

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 }

References GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, and HttpAddress::urlen.

Referenced by http_server_plugin_address_suggested(), and server_remove_address().

Here is the caller graph for this function:

◆ http_common_get_network_for_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.

Parameters
envthe environment
addressthe address
Returns
the network type

Definition at line 867 of file plugin_transport_http_common.c.

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 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:36
@ GNUNET_NT_UNSPECIFIED
Category of last resort.
Definition: gnunet_nt_lib.h:40

Variable Documentation

◆ dll_ppc_head

struct PrettyPrinterContext* dll_ppc_head
static

◆ dll_ppc_tail

struct PrettyPrinterContext* dll_ppc_tail
static