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:311

Definition at line 54 of file plugin_transport_http_common.h.

◆ HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

◆ HTTP_CLIENT_SESSION_TIMEOUT

#define HTTP_CLIENT_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT

Definition at line 58 of file plugin_transport_http_common.h.

◆ HTTP_SERVER_SESSION_TIMEOUT

#define HTTP_SERVER_SESSION_TIMEOUT   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT

Definition at line 59 of file plugin_transport_http_common.h.

◆ TIMEOUT_LOG

#define TIMEOUT_LOG   GNUNET_ERROR_TYPE_DEBUG

Definition at line 60 of file plugin_transport_http_common.h.

◆ HTTP_DEFAULT_PORT

#define HTTP_DEFAULT_PORT   80

Definition at line 64 of file plugin_transport_http_common.h.

◆ HTTPS_DEFAULT_PORT

#define HTTPS_DEFAULT_PORT   443

Definition at line 65 of file plugin_transport_http_common.h.

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 };
@ HTTP_OPTIONS_NONE
No bits set.
@ HTTP_OPTIONS_VERIFY_CERTIFICATE
Verify X509 server certificate, it should be valid.
@ HTTP_OPTIONS_TCP_STEALTH
Enable TCP Stealth-style port knocking.

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.

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 GNUNET_free(ptr)
Wrapper around free.
#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_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.

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 struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static int res
static char * address
GNS address for this phone.
static int numeric
Option -n.
@ 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
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 void http_clean_splitted(struct SplittedHTTPAddress *spa)
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.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

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

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 }
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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.

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

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 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#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 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.

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

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