GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions
plugin_transport_http_common.h File Reference
#include "platform.h"
#include "gnunet_common.h"
#include "gnunet_transport_plugin.h"
Include dependency graph for plugin_transport_http_common.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  HttpAddress
 HTTP addresses including a full URI. More...
 
struct  SplittedHTTPAddress
 Representation of HTTP URL split into its components. More...
 

Macros

#define TESTING   GNUNET_NO
 Timeout values for testing. More...
 
#define PROTOCOL   "http"
 
#define HTTP_SERVER_NOT_VALIDATED_TIMEOUT
 
#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT
 
#define HTTP_CLIENT_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
 
#define HTTP_SERVER_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
 
#define TIMEOUT_LOG   GNUNET_ERROR_TYPE_DEBUG
 
#define HTTP_DEFAULT_PORT   80
 
#define HTTPS_DEFAULT_PORT   443
 

Enumerations

enum  HttpAddressOptions { HTTP_OPTIONS_NONE = 0, HTTP_OPTIONS_VERIFY_CERTIFICATE = 1, HTTP_OPTIONS_TCP_STEALTH = 2 }
 Bits in the options field of HTTP addresses. More...
 

Functions

struct SplittedHTTPAddresshttp_split_address (const char *addr)
 Split an HTTP address into protocol, hostname, port and path components. More...
 
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_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...
 
const char * http_common_plugin_address_to_url (void *cls, const void *addr, size_t addrlen)
 FIXME. 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...
 

Macro Definition Documentation

◆ TESTING

#define TESTING   GNUNET_NO

Timeout values for testing.

Definition at line 33 of file plugin_transport_http_common.h.

◆ PROTOCOL

#define PROTOCOL   "http"

Definition at line 51 of file plugin_transport_http_common.h.

◆ HTTP_SERVER_NOT_VALIDATED_TIMEOUT

#define HTTP_SERVER_NOT_VALIDATED_TIMEOUT
Value:
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:442

Definition at line 54 of file plugin_transport_http_common.h.

Referenced by run_mhd_start_daemon().

◆ HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT
Value:
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:442

Definition at line 56 of file plugin_transport_http_common.h.

Referenced by client_connect_get(), and client_connect_put().

◆ HTTP_CLIENT_SESSION_TIMEOUT

#define HTTP_CLIENT_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT

◆ HTTP_SERVER_SESSION_TIMEOUT

#define HTTP_SERVER_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT

◆ TIMEOUT_LOG

#define TIMEOUT_LOG   GNUNET_ERROR_TYPE_DEBUG

◆ HTTP_DEFAULT_PORT

#define HTTP_DEFAULT_PORT   80

Definition at line 64 of file plugin_transport_http_common.h.

Referenced by http_split_address().

◆ HTTPS_DEFAULT_PORT

#define HTTPS_DEFAULT_PORT   443

Definition at line 65 of file plugin_transport_http_common.h.

Referenced by http_split_address().

Enumeration Type Documentation

◆ HttpAddressOptions

Bits in the options field of HTTP addresses.

Enumerator
HTTP_OPTIONS_NONE 

No bits set.

HTTP_OPTIONS_VERIFY_CERTIFICATE 

Verify X509 server certificate, it should be valid.

(if this bit is not set, it is probably just self- signed and not expected to be verified).

HTTP_OPTIONS_TCP_STEALTH 

Enable TCP Stealth-style port knocking.

Definition at line 70 of file plugin_transport_http_common.h.

71 {
76 
83 
88 };
Enable TCP Stealth-style port knocking.
Verify X509 server certificate, it should be valid.

Function Documentation

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

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().

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

References HttpAddress::addr, address, PrettyPrinterContext::asc, GNUNET_break, GNUNET_free_non_null, 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(), HttpAddress::options, res, ret, PrettyPrinterContext::saddr, and HttpAddress::urlen.

Referenced by libgnunet_plugin_transport_http_client_init(), and libgnunet_plugin_transport_http_server_init().

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 }
uint32_t options
Address options see enum HttpAddressOptions
struct SplittedHTTPAddress * http_split_address(const char *addr)
Split an HTTP address into protocol, hostname, port and path components.
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.
#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_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
size_t http_common_address_get_size(const struct HttpAddress *addr)
Get the length of an address.
Representation of HTTP URL split into its 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)
void * addr
Address following.
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.
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.
struct sockaddr * http_common_socket_from_address(const void *addr, size_t addrlen, int *res)
Create a socketaddr from a HTTP address.
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.
static void http_clean_splitted(struct SplittedHTTPAddress *spa)
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
pluginname of the plugin
addrbinary address
addrlenlength of addr
Returns
string representing the same 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.

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

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_server_done(), server_access_cb(), server_add_address(), server_disconnect_cb(), server_lookup_connection(), server_receive_mst_cb(), and server_remove_address().

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 }
uint32_t options
Address options see enum HttpAddressOptions
#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_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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 * addr
Address following.
static int res
static char * plugin
Solver plugin name as string.
uint32_t urlen
Length of URL located after struct.
static char * address
GNS address for this phone.
HTTP addresses including a full URI.
#define GNUNET_free(ptr)
Wrapper around free.
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 address
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
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.

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

Referenced by libgnunet_plugin_transport_http_client_init(), and libgnunet_plugin_transport_http_server_init().

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 }
uint32_t options
Address options see enum HttpAddressOptions
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * addr
Address following.
static char * plugin
Solver plugin name as string.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t urlen
Length of URL located after struct.
static char * address
GNS address for this phone.
HTTP addresses including a full URI.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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 addr
Returns
the string
Parameters
protocolprotocol
addrsockaddr * address
addrlenlength of the address
Returns
the HttpAddress

Definition at line 733 of file plugin_transport_http_common.c.

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

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

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 }
uint32_t options
Address options see enum HttpAddressOptions
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
void * addr
Address following.
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 int res
uint32_t urlen
Length of URL located after struct.
static char * address
GNS address for this phone.
HTTP addresses including a full URI.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

References 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(), http_common_get_network_for_address(), and http_common_plugin_address_pretty_printer().

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 }
struct SplittedHTTPAddress * http_split_address(const char *addr)
Split an HTTP address into protocol, hostname, port and path components.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Representation of HTTP URL split into its components.
void * addr
Address following.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t urlen
Length of URL located after struct.
#define GNUNET_YES
Definition: gnunet_common.h:77
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_free(ptr)
Wrapper around free.
static void http_clean_splitted(struct SplittedHTTPAddress *spa)
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.

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

Referenced by client_connect().

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 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
size_t http_common_address_get_size(const struct HttpAddress *addr)
Get the length of an address.
void * addr
Address following.
uint32_t urlen
Length of URL located after struct.
static char * address
GNS address for this phone.
HTTP addresses including a full URI.
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.

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().

852 {
853  return sizeof(struct HttpAddress) + ntohl (addr->urlen);
854 }
uint32_t urlen
Length of URL located after struct.
HTTP addresses including a full URI.
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
addrlen1length of address1
addr2address2
addrlen2length of address2
Returns
GNUNET_YES if equal, GNUNET_NO else
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.

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

Referenced by http_server_plugin_address_suggested(), and server_remove_address().

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 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t urlen
Length of URL located after struct.
#define GNUNET_YES
Definition: gnunet_common.h:77
HTTP addresses including a full URI.
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 913 of file plugin_transport_http_common.c.

References GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_TRANSPORT_PluginEnvironment::cls, GNUNET_TRANSPORT_PluginEnvironment::get_address_type, GNUNET_assert, GNUNET_free, GNUNET_NT_UNSPECIFIED, GNUNET_SYSERR, GNUNET_YES, http_common_socket_from_address(), and res.

Referenced by http_client_plugin_get_network_for_address(), and http_server_plugin_get_network_for_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 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
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.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
void * cls
Closure for the various callbacks.
static int res
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct sockaddr * http_common_socket_from_address(const void *addr, size_t addrlen, int *res)
Create a socketaddr from a HTTP address.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
Category of last resort.
Definition: gnunet_nt_lib.h:40
Here is the call graph for this function:
Here is the caller graph for this function: