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 SplittedHTTPAddress *	http_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 HttpAddress *	http_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:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 15)

Definition at line 54 of file plugin_transport_http_common.h.

HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 15)

Definition at line 56 of file plugin_transport_http_common.h.

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

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

{
  HTTP_OPTIONS_NONE = 0,
 
  HTTP_OPTIONS_VERIFY_CERTIFICATE = 1,
 
  HTTP_OPTIONS_TCP_STEALTH = 2
};

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.

{
  struct SplittedHTTPAddress *sp;
  char *src = GNUNET_strdup (addr);
  char *protocol_start = NULL;
  char *host_start = NULL;
  char *v6_end = NULL;
  char *port_start = NULL;
  char *path_start = NULL;
 
  protocol_start = src;
 
  sp = GNUNET_new (struct SplittedHTTPAddress);
  /* Address string consists of protocol://host[:port]path*/
 
  host_start = strstr (src, "://");
  if (NULL == host_start)
  {
    GNUNET_free (src);
    GNUNET_free (sp);
    return NULL;
  }
  host_start[0] = '\0';
  sp->protocol = GNUNET_strdup (protocol_start);
 
  host_start += strlen ("://");
  if (strlen (host_start) == 0)
  {
    GNUNET_free (src);
    GNUNET_free (sp->protocol);
    GNUNET_free (sp);
    return NULL;
  }
 
  /* Find path start */
  path_start = strchr (host_start, '/');
  if (NULL != path_start)
  {
    sp->path = GNUNET_strdup (path_start);
    path_start[0] = '\0';
  }
  else
    sp->path = GNUNET_strdup ("");
 
  if (strlen (host_start) < 1)
  {
    GNUNET_free (src);
    GNUNET_free (sp->protocol);
    GNUNET_free (sp->path);
    GNUNET_free (sp);
    return NULL;
  }
 
  if (NULL != (port_start = strrchr (host_start, ':')))
  {
    /* *We COULD have a port, but also an IPv6 address! */
    if (NULL != (v6_end = strchr (host_start, ']')))
    {
      if (v6_end < port_start)
      {
        /* IPv6 address + port */
        port_start[0] = '\0';
        port_start++;
        sp->port = atoi (port_start);
        if ((0 == sp->port) || (65535 < sp->port))
        {
          GNUNET_free (src);
          GNUNET_free (sp->protocol);
          GNUNET_free (sp->path);
          GNUNET_free (sp);
          return NULL;
        }
      }
      else
      {
        /* IPv6 address + no port */
        if (0 == strcmp (sp->protocol, "https"))
          sp->port = HTTPS_DEFAULT_PORT;
        else if (0 == strcmp (sp->protocol, "http"))
          sp->port = HTTP_DEFAULT_PORT;
      }
    }
    else
    {
      /* No IPv6 address */
      port_start[0] = '\0';
      port_start++;
      sp->port = atoi (port_start);
      if ((0 == sp->port) || (65535 < sp->port))
      {
        GNUNET_free (src);
        GNUNET_free (sp->protocol);
        GNUNET_free (sp->path);
        GNUNET_free (sp);
        return NULL;
      }
    }
  }
  else
  {
    /* No ':' as port separator, default port for protocol */
    if (0 == strcmp (sp->protocol, "https"))
      sp->port = HTTPS_DEFAULT_PORT;
    else if (0 == strcmp (sp->protocol, "http"))
      sp->port = HTTP_DEFAULT_PORT;
    else
    {
      GNUNET_break (0);
      GNUNET_free (src);
      GNUNET_free (sp->protocol);
      GNUNET_free (sp->path);
      GNUNET_free (sp);
      return NULL;
    }
  }
  if (strlen (host_start) > 0)
    sp->host = GNUNET_strdup (host_start);
  else
  {
    GNUNET_break (0);
    GNUNET_free (src);
    GNUNET_free (sp->protocol);
    GNUNET_free (sp->path);
    GNUNET_free (sp);
    return NULL;
  }
  GNUNET_free (src);
  return sp;
}

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

cls	closure
type	name of the transport that generated the address
addr	one of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlen	length of addr
numeric	should (IP) addresses be displayed in numeric form?
timeout	after how long should we give up?
asc	function to call on each string
asc_cls	closure for asc

Definition at line 411 of file plugin_transport_http_common.c.

{
  const struct HttpAddress *address = addr;
  struct SplittedHTTPAddress *saddr;
  struct sockaddr *sock_addr;
  const char *ret;
  char *addr_str;
  int res;
  int have_ip;
 
  saddr = NULL;
  sock_addr = NULL;
  if ((addrlen < sizeof(struct HttpAddress)) ||
      (addrlen != http_common_address_get_size (address)))
  {
    GNUNET_break (0);
    goto handle_error;
  }
 
  addr_str = (char *) &address[1];
  if (addr_str[ntohl (address->urlen) - 1] != '\0')
  {
    GNUNET_break (0);
    goto handle_error;
  }
 
  saddr = http_split_address (addr_str);
  if (NULL == saddr)
  {
    GNUNET_break (0);
    goto handle_error;
  }
 
  sock_addr = http_common_socket_from_address (addr, addrlen, &res);
  if (GNUNET_SYSERR == res)
  {
    /* Malformed address */
    GNUNET_break (0);
    goto handle_error;
  }
  else if (GNUNET_NO == res)
  {
    /* Could not convert to IP */
    have_ip = GNUNET_NO;
  }
  else if (GNUNET_YES == res)
  {
    /* Converted to IP */
    have_ip = GNUNET_YES;
  }
  else
  {
    /* Must not happen */
    GNUNET_break (0);
    goto handle_error;
  }
 
  if ((GNUNET_YES == numeric) &&
      (GNUNET_YES == have_ip))
  {
    /* No lookup required */
    ret = http_common_plugin_address_to_string (type, address, addrlen);
    asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
    asc (asc_cls, NULL, GNUNET_OK);
    http_clean_splitted (saddr);
    GNUNET_free (sock_addr);
    return;
  }
  if ((GNUNET_YES == numeric) &&
      (GNUNET_NO == have_ip))
  {
    /* Forward lookup */
    if (GNUNET_SYSERR ==
        http_common_dns_ip_lookup (saddr->host, type, saddr,
                                   address->options, timeout,
                                   asc, asc_cls))
    {
      GNUNET_break (0);
      goto handle_error;
    }
    /* Wait for resolver callback */
    GNUNET_free (sock_addr);
    return;
  }
  if ((GNUNET_NO == numeric) &&
      (GNUNET_YES == have_ip))
  {
    /* Reverse lookup */
    if (GNUNET_SYSERR ==
        http_common_dns_reverse_lookup (sock_addr,
                                        (AF_INET == sock_addr->sa_family)
                                        ? sizeof(struct sockaddr_in)
                                        : sizeof(struct sockaddr_in6),
                                        type,
                                        saddr,
                                        address->options, timeout,
                                        asc, asc_cls))
    {
      GNUNET_break (0);
      goto handle_error;
    }
    /* Wait for resolver callback */
    GNUNET_free (sock_addr);
    return;
  }
  if ((GNUNET_NO == numeric) &&
      (GNUNET_NO == have_ip))
  {
    /* No lookup required */
    ret = http_common_plugin_address_to_string (type, address, addrlen);
    asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
    asc (asc_cls, NULL, GNUNET_OK);
    GNUNET_free (sock_addr);
    http_clean_splitted (saddr);
    return;
  }
  /* Error (argument supplied not GNUNET_YES or GNUNET_NO) */
  GNUNET_break (0);
  goto handle_error;
 
handle_error:
  /* Report error */
  asc (asc_cls, NULL, GNUNET_SYSERR);
  asc (asc_cls, NULL, GNUNET_OK);
  GNUNET_free (sock_addr);
  if (NULL != saddr)
    http_clean_splitted (saddr);
}

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

plugin	name of the plugin
addr	binary address
addrlen	length of addr

Returns

string representing the same address

Definition at line 587 of file plugin_transport_http_common.c.

{
  static char rbuf[1024];
  const struct HttpAddress *address = addr;
  const char *addr_str;
  char *res;
 
  GNUNET_assert (NULL != plugin);
  if (NULL == addr)
    return NULL;
  if (0 == addrlen)
    return NULL;
  if (addrlen != http_common_address_get_size (address))
    return NULL;
  addr_str = (char *) &address[1];
  if (addr_str[ntohl (address->urlen) - 1] != '\0')
    return NULL;
  GNUNET_asprintf (&res, "%s.%u.%s", plugin, ntohl (address->options),
                   (char*) &address[1]);
  if (strlen (res) + 1 < 500)
  {
    GNUNET_memcpy (rbuf, res, strlen (res) + 1);
    GNUNET_free (res);
    return rbuf;
  }
  GNUNET_break (0);
  GNUNET_free (res);
  return NULL;
}

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

cls	closure (struct Plugin*)
addr	string address
addrlen	length of addr
buf	location to store the buffer If the function returns GNUNET_SYSERR, its contents are undefined.
added	length of created address

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 621 of file plugin_transport_http_common.c.

{
  struct HttpAddress *a;
  char *address;
  char *plugin;
  char *optionstr;
  size_t urlen;
  uint32_t options;
 
  /* Format protocol.options.address:port */
  address = NULL;
  plugin = NULL;
  optionstr = NULL;
  if ((NULL == addr) || (addrlen == 0))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != addr[addrlen - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (strlen (addr) != addrlen - 1)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  plugin = GNUNET_strdup (addr);
  optionstr = strchr (plugin, '.');
  if (NULL == optionstr)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  optionstr[0] = '\0';
  optionstr++;
  options = atol (optionstr);  /* 0 on conversion error, that's ok */
  address = strchr (optionstr, '.');
  if (NULL == address)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  address[0] = '\0';
  address++;
  urlen = strlen (address) + 1;
 
  a = GNUNET_malloc (sizeof(struct HttpAddress) + urlen);
  a->options = htonl (options);
  a->urlen = htonl (urlen);
  GNUNET_memcpy (&a[1], address, urlen);
 
  (*buf) = a;
  (*added) = sizeof(struct HttpAddress) + urlen;
  GNUNET_free (plugin);
  return GNUNET_OK;
}

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

protocol	protocol
addr	sockaddr * address
addrlen	length of the addr

Returns

A pointer to a struct HttpAddress derived from addr

Definition at line 688 of file plugin_transport_http_common.c.

{
  struct HttpAddress *address = NULL;
  char *res;
  size_t len;
 
  GNUNET_asprintf (&res,
                   "%s://%s",
                   protocol,
                   GNUNET_a2s (addr,
                               addrlen));
  len = strlen (res) + 1;
  address = GNUNET_malloc (sizeof(struct HttpAddress) + len);
  address->options = htonl (HTTP_OPTIONS_NONE);
  address->urlen = htonl (len);
  GNUNET_memcpy (&address[1], res, len);
  GNUNET_free (res);
  return address;
}

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

addr	a sockaddr * address
addrlen	length of the addr
res	the 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 723 of file plugin_transport_http_common.c.

{
  const struct HttpAddress *ha;
  struct SplittedHTTPAddress *spa;
  struct sockaddr_storage *s;
  char *to_conv;
  size_t urlen;
 
  (*res) = GNUNET_SYSERR;
  ha = (const struct HttpAddress *) addr;
  if (NULL == addr)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (0 == addrlen)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (addrlen < sizeof(struct HttpAddress))
  {
    GNUNET_break (0);
    return NULL;
  }
  urlen = ntohl (ha->urlen);
  if (sizeof(struct HttpAddress) + urlen != addrlen)
  {
    /* This is a legacy addresses */
    return NULL;
  }
  if (addrlen < sizeof(struct HttpAddress) + urlen)
  {
    /* This is a legacy addresses */
    return NULL;
  }
  if (((char *) addr)[addrlen - 1] != '\0')
  {
    GNUNET_break (0);
    return NULL;
  }
  spa = http_split_address ((const char *) &ha[1]);
  if (NULL == spa)
  {
    (*res) = GNUNET_SYSERR;
    return NULL;
  }
 
  s = GNUNET_new (struct sockaddr_storage);
  GNUNET_asprintf (&to_conv, "%s:%u", spa->host, spa->port);
  if (GNUNET_SYSERR
      == GNUNET_STRINGS_to_address_ip (to_conv, strlen (to_conv), s))
  {
    /* could be a hostname */
    GNUNET_free (s);
    (*res) = GNUNET_NO;
    s = NULL;
  }
  else if ((AF_INET != s->ss_family) && (AF_INET6 != s->ss_family))
  {
    GNUNET_free (s);
    (*res) = GNUNET_SYSERR;
    s = NULL;
  }
  else
  {
    (*res) = GNUNET_YES;
  }
  http_clean_splitted (spa);
  GNUNET_free (to_conv);
  return (struct sockaddr *) s;
}

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 552 of file plugin_transport_http_common.c.

{
  static char rbuf[1024];
  const struct HttpAddress *address = addr;
  const char *addr_str;
 
  if (NULL == addr)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (0 == addrlen)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (addrlen != http_common_address_get_size (address))
  {
    GNUNET_break (0);
    return NULL;
  }
  addr_str = (char *) &address[1];
  if (addr_str[ntohl (address->urlen) - 1] != '\0')
    return NULL;
 
  GNUNET_memcpy (rbuf,
                 &address[1],
                 ntohl (address->urlen));
  return rbuf;
}

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

addr

address

Returns

the size

Definition at line 806 of file plugin_transport_http_common.c.

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

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

addr1	address1
addrlen1	length of address1
addr2	address2
addrlen2	length of address2

Returns

GNUNET_YES if equal, GNUNET_NO else

Parameters

addr1	address1
addrlen1	address 1 length
addr2	address2
addrlen2	address 2 length

Returns

GNUNET_YES if equal, GNUNET_NO if not, GNUNET_SYSERR on error

Definition at line 822 of file plugin_transport_http_common.c.

{
  const char *a1 = addr1;
  const char *a2 = addr2;
  const struct HttpAddress *ha1;
  const struct HttpAddress *ha2;
 
  ha1 = (const struct HttpAddress *) a1;
  ha2 = (const struct HttpAddress *) a2;
 
  if (NULL == a1)
    return GNUNET_SYSERR;
  if (0 == addrlen1)
    return GNUNET_SYSERR;
  if (a1[addrlen1 - 1] != '\0')
    return GNUNET_SYSERR;
 
  if (NULL == a2)
    return GNUNET_SYSERR;
  if (0 == addrlen2)
    return GNUNET_SYSERR;
  if (a2[addrlen2 - 1] != '\0')
    return GNUNET_SYSERR;
 
  if (addrlen1 != addrlen2)
    return GNUNET_NO;
  if (ha1->urlen != ha2->urlen)
    return GNUNET_NO;
 
  if (0 == strcmp ((const char *) &ha1[1], (const char *) &ha2[1]))
    return GNUNET_YES;
  return GNUNET_NO;
}

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

env	the environment
address	the address

Returns

the network type

Definition at line 822 of file plugin_transport_http_common.c.

{
  struct sockaddr *sa;
  enum GNUNET_NetworkType net_type;
  size_t salen = 0;
  int res;
 
  net_type = GNUNET_NT_UNSPECIFIED;
  sa = http_common_socket_from_address (address->address,
                                        address->address_length,
                                        &res);
  if (GNUNET_SYSERR == res)
    return net_type;
  if (GNUNET_YES == res)
  {
    GNUNET_assert (NULL != sa);
    if (AF_INET == sa->sa_family)
    {
      salen = sizeof(struct sockaddr_in);
    }
    else if (AF_INET6 == sa->sa_family)
    {
      salen = sizeof(struct sockaddr_in6);
    }
    net_type = env->get_address_type (env->cls,
                                      sa,
                                      salen);
    GNUNET_free (sa);
  }
  return net_type;
}