GNUnet  0.10.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   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)
 
#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)
 
#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 47 of file plugin_transport_http_common.h.

◆ HTTP_SERVER_NOT_VALIDATED_TIMEOUT

#define HTTP_SERVER_NOT_VALIDATED_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)

Definition at line 50 of file plugin_transport_http_common.h.

Referenced by run_mhd_start_daemon().

◆ HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)

Definition at line 51 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 58 of file plugin_transport_http_common.h.

Referenced by http_split_address().

◆ HTTPS_DEFAULT_PORT

#define HTTPS_DEFAULT_PORT   443

Definition at line 59 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 64 of file plugin_transport_http_common.h.

64  {
69 
76 
81 };
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 416 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().

423 {
424  const struct HttpAddress *address = addr;
425  struct SplittedHTTPAddress *saddr;
426  struct sockaddr *sock_addr;
427  const char *ret;
428  char *addr_str;
429  int res;
430  int have_ip;
431 
432  saddr = NULL;
433  sock_addr = NULL;
434  if ((addrlen < sizeof(struct HttpAddress)) ||
435  (addrlen != http_common_address_get_size(address)))
436  {
437  GNUNET_break(0);
438  goto handle_error;
439  }
440 
441  addr_str = (char *)&address[1];
442  if (addr_str[ntohl(address->urlen) - 1] != '\0')
443  {
444  GNUNET_break(0);
445  goto handle_error;
446  }
447 
448  saddr = http_split_address(addr_str);
449  if (NULL == saddr)
450  {
451  GNUNET_break(0);
452  goto handle_error;
453  }
454 
455  sock_addr = http_common_socket_from_address(addr, addrlen, &res);
456  if (GNUNET_SYSERR == res)
457  {
458  /* Malformed address */
459  GNUNET_break(0);
460  goto handle_error;
461  }
462  else if (GNUNET_NO == res)
463  {
464  /* Could not convert to IP */
465  have_ip = GNUNET_NO;
466  }
467  else if (GNUNET_YES == res)
468  {
469  /* Converted to IP */
470  have_ip = GNUNET_YES;
471  }
472  else
473  {
474  /* Must not happen */
475  GNUNET_break(0);
476  goto handle_error;
477  }
478 
479  if ((GNUNET_YES == numeric) &&
480  (GNUNET_YES == have_ip))
481  {
482  /* No lookup required */
483  ret = http_common_plugin_address_to_string(type, address, addrlen);
484  asc(asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
485  asc(asc_cls, NULL, GNUNET_OK);
486  http_clean_splitted(saddr);
487  GNUNET_free_non_null(sock_addr);
488  return;
489  }
490  if ((GNUNET_YES == numeric) &&
491  (GNUNET_NO == have_ip))
492  {
493  /* Forward lookup */
494  if (GNUNET_SYSERR ==
495  http_common_dns_ip_lookup(saddr->host, type, saddr,
496  address->options, timeout,
497  asc, asc_cls))
498  {
499  GNUNET_break(0);
500  goto handle_error;
501  }
502  /* Wait for resolver callback */
503  GNUNET_free_non_null(sock_addr);
504  return;
505  }
506  if ((GNUNET_NO == numeric) &&
507  (GNUNET_YES == have_ip))
508  {
509  /* Reverse lookup */
510  if (GNUNET_SYSERR ==
512  (AF_INET == sock_addr->sa_family)
513  ? sizeof(struct sockaddr_in)
514  : sizeof(struct sockaddr_in6),
515  type,
516  saddr,
517  address->options, timeout,
518  asc, asc_cls))
519  {
520  GNUNET_break(0);
521  goto handle_error;
522  }
523  /* Wait for resolver callback */
524  GNUNET_free_non_null(sock_addr);
525  return;
526  }
527  if ((GNUNET_NO == numeric) &&
528  (GNUNET_NO == have_ip))
529  {
530  /* No lookup required */
531  ret = http_common_plugin_address_to_string(type, address, addrlen);
532  asc(asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
533  asc(asc_cls, NULL, GNUNET_OK);
534  GNUNET_free_non_null(sock_addr);
535  http_clean_splitted(saddr);
536  return;
537  }
538  /* Error (argument supplied not GNUNET_YES or GNUNET_NO) */
539  GNUNET_break(0);
540  goto handle_error;
541 
542 handle_error:
543  /* Report error */
544  asc(asc_cls, NULL, GNUNET_SYSERR);
545  asc(asc_cls, NULL, GNUNET_OK);
546  GNUNET_free_non_null(sock_addr);
547  if (NULL != saddr)
548  http_clean_splitted(saddr);
549 }
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.
#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.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#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 602 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().

605 {
606  static char rbuf[1024];
607  const struct HttpAddress *address = addr;
608  const char * addr_str;
609  char *res;
610 
611  GNUNET_assert(NULL != plugin);
612  if (NULL == addr)
613  return NULL;
614  if (0 == addrlen)
615  return NULL;
616  if (addrlen != http_common_address_get_size(address))
617  return NULL;
618  addr_str = (char *)&address[1];
619  if (addr_str[ntohl(address->urlen) - 1] != '\0')
620  return NULL;
621  GNUNET_asprintf(&res, "%s.%u.%s", plugin, ntohl(address->options),
622  &address[1]);
623  if (strlen(res) + 1 < 500)
624  {
625  GNUNET_memcpy(rbuf, res, strlen(res) + 1);
626  GNUNET_free(res);
627  return rbuf;
628  }
629  GNUNET_break(0);
630  GNUNET_free(res);
631  return NULL;
632 }
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...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
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
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 647 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().

652 {
653  struct HttpAddress *a;
654  char *address;
655  char *plugin;
656  char *optionstr;
657  size_t urlen;
658  uint32_t options;
659 
660  /* Format protocol.options.address:port */
661  address = NULL;
662  plugin = NULL;
663  optionstr = NULL;
664  if ((NULL == addr) || (addrlen == 0))
665  {
666  GNUNET_break(0);
667  return GNUNET_SYSERR;
668  }
669  if ('\0' != addr[addrlen - 1])
670  {
671  GNUNET_break(0);
672  return GNUNET_SYSERR;
673  }
674  if (strlen(addr) != addrlen - 1)
675  {
676  GNUNET_break(0);
677  return GNUNET_SYSERR;
678  }
679  plugin = GNUNET_strdup(addr);
680  optionstr = strchr(plugin, '.');
681  if (NULL == optionstr)
682  {
683  GNUNET_break(0);
684  GNUNET_free(plugin);
685  return GNUNET_SYSERR;
686  }
687  optionstr[0] = '\0';
688  optionstr++;
689  options = atol(optionstr); /* 0 on conversion error, that's ok */
690  address = strchr(optionstr, '.');
691  if (NULL == address)
692  {
693  GNUNET_break(0);
694  GNUNET_free(plugin);
695  return GNUNET_SYSERR;
696  }
697  address[0] = '\0';
698  address++;
699  urlen = strlen(address) + 1;
700 
701  a = GNUNET_malloc(sizeof(struct HttpAddress) + urlen);
702  a->options = htonl(options);
703  a->urlen = htonl(urlen);
704  GNUNET_memcpy(&a[1], address, urlen);
705 
706  (*buf) = a;
707  (*added) = sizeof(struct HttpAddress) + urlen;
708  GNUNET_free(plugin);
709  return GNUNET_OK;
710 }
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...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
void * addr
Address following.
#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 722 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().

725 {
726  struct HttpAddress *address = NULL;
727  char *res;
728  size_t len;
729 
730  GNUNET_asprintf(&res,
731  "%s://%s",
732  protocol,
734  addrlen));
735  len = strlen(res) + 1;
736  address = GNUNET_malloc(sizeof(struct HttpAddress) + len);
737  address->options = htonl(HTTP_OPTIONS_NONE);
738  address->urlen = htonl(len);
739  GNUNET_memcpy(&address[1], res, len);
740  GNUNET_free(res);
741  return address;
742 }
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 757 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().

760 {
761  const struct HttpAddress *ha;
762  struct SplittedHTTPAddress * spa;
763  struct sockaddr_storage *s;
764  char * to_conv;
765  size_t urlen;
766 
767  (*res) = GNUNET_SYSERR;
768  ha = (const struct HttpAddress *)addr;
769  if (NULL == addr)
770  {
771  GNUNET_break(0);
772  return NULL;
773  }
774  if (0 == addrlen)
775  {
776  GNUNET_break(0);
777  return NULL;
778  }
779  if (addrlen < sizeof(struct HttpAddress))
780  {
781  GNUNET_break(0);
782  return NULL;
783  }
784  urlen = ntohl(ha->urlen);
785  if (sizeof(struct HttpAddress) + urlen != addrlen)
786  {
787  /* This is a legacy addresses */
788  return NULL;
789  }
790  if (addrlen < sizeof(struct HttpAddress) + urlen)
791  {
792  /* This is a legacy addresses */
793  return NULL;
794  }
795  if (((char *)addr)[addrlen - 1] != '\0')
796  {
797  GNUNET_break(0);
798  return NULL;
799  }
800  spa = http_split_address((const char *)&ha[1]);
801  if (NULL == spa)
802  {
803  (*res) = GNUNET_SYSERR;
804  return NULL;
805  }
806 
807  s = GNUNET_new(struct sockaddr_storage);
808  GNUNET_asprintf(&to_conv, "%s:%u", spa->host, spa->port);
809  if (GNUNET_SYSERR
810  == GNUNET_STRINGS_to_address_ip(to_conv, strlen(to_conv), s))
811  {
812  /* could be a hostname */
813  GNUNET_free(s);
814  (*res) = GNUNET_NO;
815  s = NULL;
816  }
817  else if ((AF_INET != s->ss_family) && (AF_INET6 != s->ss_family))
818  {
819  GNUNET_free(s);
820  (*res) = GNUNET_SYSERR;
821  s = NULL;
822  }
823  else
824  {
825  (*res) = GNUNET_YES;
826  }
827  http_clean_splitted(spa);
828  GNUNET_free(to_conv);
829  return (struct sockaddr *)s;
830 }
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:1327
#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 556 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().

559 {
560  static char rbuf[1024];
561  const struct HttpAddress *address = addr;
562  const char * addr_str;
563 
564  if (NULL == addr)
565  {
566  GNUNET_break(0);
567  return NULL;
568  }
569  if (0 == addrlen)
570  {
571  GNUNET_break(0);
572  return NULL;
573  }
574  if (addrlen != http_common_address_get_size(address))
575  {
576  GNUNET_break(0);
577  return NULL;
578  }
579  addr_str = (char *)&address[1];
580  if (addr_str[ntohl(address->urlen) - 1] != '\0')
581  return NULL;
582 
583  GNUNET_memcpy(rbuf,
584  &address[1],
585  ntohl(address->urlen));
586  return rbuf;
587 }
#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 840 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().

841 {
842  return sizeof(struct HttpAddress) + ntohl(addr->urlen);
843 }
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 856 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().

860 {
861  const char *a1 = addr1;
862  const char *a2 = addr2;
863  const struct HttpAddress *ha1;
864  const struct HttpAddress *ha2;
865 
866  ha1 = (const struct HttpAddress *)a1;
867  ha2 = (const struct HttpAddress *)a2;
868 
869  if (NULL == a1)
870  return GNUNET_SYSERR;
871  if (0 == addrlen1)
872  return GNUNET_SYSERR;
873  if (a1[addrlen1 - 1] != '\0')
874  return GNUNET_SYSERR;
875 
876  if (NULL == a2)
877  return GNUNET_SYSERR;
878  if (0 == addrlen2)
879  return GNUNET_SYSERR;
880  if (a2[addrlen2 - 1] != '\0')
881  return GNUNET_SYSERR;
882 
883  if (addrlen1 != addrlen2)
884  return GNUNET_NO;
885  if (ha1->urlen != ha2->urlen)
886  return GNUNET_NO;
887 
888  if (0 == strcmp((const char *)&ha1[1], (const char *)&ha2[1]))
889  return GNUNET_YES;
890  return GNUNET_NO;
891 }
#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 902 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().

904 {
905  struct sockaddr *sa;
906  enum GNUNET_NetworkType net_type;
907  size_t salen = 0;
908  int res;
909 
910  net_type = GNUNET_NT_UNSPECIFIED;
912  address->address_length,
913  &res);
914  if (GNUNET_SYSERR == res)
915  return net_type;
916  if (GNUNET_YES == res)
917  {
918  GNUNET_assert(NULL != sa);
919  if (AF_INET == sa->sa_family)
920  {
921  salen = sizeof(struct sockaddr_in);
922  }
923  else if (AF_INET6 == sa->sa_family)
924  {
925  salen = sizeof(struct sockaddr_in6);
926  }
927  net_type = env->get_address_type(env->cls,
928  sa,
929  salen);
930  GNUNET_free(sa);
931  }
932  return net_type;
933 }
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:39
Here is the call graph for this function:
Here is the caller graph for this function: