plugin_transport_http_common.c File Reference

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

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_plugin.h"
#include "plugin_transport_http_common.h"
#include "gnunet_resolver_service.h"

Include dependency graph for plugin_transport_http_common.c:

Go to the source code of this file.

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

Functions
static void	http_clean_splitted (struct SplittedHTTPAddress *spa)
struct SplittedHTTPAddress *	http_split_address (const char *addr)
	Split an HTTP address into protocol, hostname, port and path components. More...
static const char *	http_common_plugin_dnsresult_to_address (const char *plugin, const struct SplittedHTTPAddress *saddr, uint32_t options, const char *dnsresult)
	Function called for a quick conversion of the binary address to a numeric address. More...
static void	http_common_dns_reverse_lookup_cb (void *cls, const char *hostname)
static int	http_common_dns_reverse_lookup (const struct sockaddr *sockaddr, socklen_t sockaddr_len, const char *type, struct SplittedHTTPAddress *saddr, uint32_t options, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
static void	http_common_dns_ip_lookup_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen)
static int	http_common_dns_ip_lookup (const char *name, const char *type, struct SplittedHTTPAddress *saddr, uint32_t options, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
void	http_common_plugin_address_pretty_printer (void *cls, const char *type, const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
	Convert the transports address to a nice, human-readable format. More...
const char *	http_common_plugin_address_to_url (void *cls, const void *addr, size_t addrlen)
	FIXME. More...
const char *	http_common_plugin_address_to_string (const char *plugin, const void *addr, size_t addrlen)
	Function called for a quick conversion of the binary address to a numeric address. More...
int	http_common_plugin_string_to_address (void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
	Function called to convert a string address to a binary address. More...
struct 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...
size_t	http_common_address_get_size (const struct HttpAddress *addr)
	Get the length of an address. More...
size_t	http_common_cmp_addresses (const void *addr1, size_t addrlen1, const void *addr2, size_t addrlen2)
	Compare addr1 to addr2. More...
enum GNUNET_NetworkType	http_common_get_network_for_address (struct GNUNET_TRANSPORT_PluginEnvironment *env, const struct GNUNET_HELLO_Address *address)
	Function obtain the network type for an address. More...

Variables
static struct PrettyPrinterContext *	dll_ppc_head
	Head of PPC list. More...
static struct PrettyPrinterContext *	dll_ppc_tail
	Tail of PPC list. More...

Detailed Description

functionality shared between http(s)client plugins

functionality shared by http client and server transport service plugin

Author

Matthias Wachs

Matthias Wachs

Christian Grothoff

Definition in file plugin_transport_http_common.c.

Function Documentation

http_clean_splitted()

static void http_clean_splitted ( struct SplittedHTTPAddress *  spa )

static

Definition at line 33 of file plugin_transport_http_common.c.

{
  if (NULL != spa)
  {
    GNUNET_free (spa->protocol);
    GNUNET_free (spa->host);
    GNUNET_free (spa->path);
    GNUNET_free (spa);
  }
}

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

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

Here is the caller graph for this function:

http_split_address()

struct SplittedHTTPAddress* http_split_address

(

const char *

addr

)

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

Definition at line 46 of file plugin_transport_http_common.c.

{
  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_dnsresult_to_address()

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

static

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

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

Parameters

plugin	the name of the plugin
saddr	the split http address
options	address options
dnsresult	dns name to include in address

Returns

string representing the same address or NULL on error

Definition at line 256 of file plugin_transport_http_common.c.

{
  static char rbuf[1024];
  char *res;
 
  GNUNET_asprintf (&res, "%s.%u.%s://%s:%u%s", plugin, options, saddr->protocol,
                   dnsresult, saddr->port, saddr->path);
  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 GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_memcpy, options, SplittedHTTPAddress::path, plugin, SplittedHTTPAddress::port, SplittedHTTPAddress::protocol, res, and PrettyPrinterContext::saddr.

Referenced by http_common_dns_ip_lookup_cb(), and http_common_dns_reverse_lookup_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

http_common_dns_reverse_lookup_cb()

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

static

Definition at line 280 of file plugin_transport_http_common.c.

{
  struct PrettyPrinterContext *ppc = cls;
 
  if (NULL != hostname)
  {
    ppc->asc (ppc->asc_cls,
              http_common_plugin_dnsresult_to_address (ppc->plugin, ppc->saddr,
                                                       ppc->options,
                                                       hostname), GNUNET_OK);
    ppc->success = GNUNET_YES;
  }
  else
  {
    ppc->asc (ppc->asc_cls, NULL,
              (GNUNET_NO == ppc->success) ? GNUNET_SYSERR : GNUNET_OK);
 
    GNUNET_CONTAINER_DLL_remove (dll_ppc_head, dll_ppc_tail, ppc);
    http_clean_splitted (ppc->saddr);
    GNUNET_free (ppc->plugin);
    GNUNET_free (ppc);
  }
}

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

Referenced by http_common_dns_reverse_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

http_common_dns_reverse_lookup()

static int http_common_dns_reverse_lookup ( const struct sockaddr *  sockaddr, socklen_t  sockaddr_len, const char *  type, struct SplittedHTTPAddress *  saddr, uint32_t  options, struct GNUNET_TIME_Relative  timeout, GNUNET_TRANSPORT_AddressStringCallback  asc, void *  asc_cls  )

static

Definition at line 306 of file plugin_transport_http_common.c.

{
  struct PrettyPrinterContext *ppc;
 
  ppc = GNUNET_new (struct PrettyPrinterContext);
  ppc->saddr = saddr;
  ppc->asc = asc;
  ppc->asc_cls = asc_cls;
  ppc->plugin = GNUNET_strdup (type);
  ppc->options = options;
  ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sockaddr,
                                                       sockaddr_len,
                                                       GNUNET_YES,
                                                       timeout,
                                                       &
                                                       http_common_dns_reverse_lookup_cb,
                                                       ppc);
  if (NULL == ppc->resolver_handle)
  {
    GNUNET_free (ppc->plugin);
    GNUNET_free (ppc);
    return GNUNET_SYSERR;
  }
  GNUNET_CONTAINER_DLL_insert (dll_ppc_head,
                               dll_ppc_tail,
                               ppc);
  return GNUNET_OK;
}

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

Referenced by http_common_plugin_address_pretty_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

http_common_dns_ip_lookup_cb()

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

static

Definition at line 344 of file plugin_transport_http_common.c.

{
  struct PrettyPrinterContext *ppc = cls;
 
  if (NULL != addr)
  {
    ppc->asc (ppc->asc_cls,
              http_common_plugin_dnsresult_to_address (ppc->plugin, ppc->saddr,
                                                       ppc->options,
                                                       GNUNET_a2s (addr,
                                                                   addrlen)),
              GNUNET_OK);
    ppc->success = GNUNET_YES;
    ppc->asc (ppc->asc_cls, GNUNET_a2s (addr, addrlen), GNUNET_OK);
  }
  else
  {
    ppc->asc (ppc->asc_cls, NULL,
              (GNUNET_NO == ppc->success) ? GNUNET_SYSERR : GNUNET_OK);
 
    GNUNET_CONTAINER_DLL_remove (dll_ppc_head, dll_ppc_tail, ppc);
    GNUNET_free (ppc->plugin);
    http_clean_splitted (ppc->saddr);
    GNUNET_free (ppc);
  }
}

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

Referenced by http_common_dns_ip_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

http_common_dns_ip_lookup()

static int http_common_dns_ip_lookup ( const char *  name, const char *  type, struct SplittedHTTPAddress *  saddr, uint32_t  options, struct GNUNET_TIME_Relative  timeout, GNUNET_TRANSPORT_AddressStringCallback  asc, void *  asc_cls  )

static

Definition at line 375 of file plugin_transport_http_common.c.

{
  struct PrettyPrinterContext *ppc;
 
  ppc = GNUNET_new (struct PrettyPrinterContext);
  ppc->success = GNUNET_NO;
  ppc->saddr = saddr;
  ppc->asc = asc;
  ppc->asc_cls = asc_cls;
  ppc->plugin = GNUNET_strdup (type);
  ppc->options = options;
  ppc->resolver_handle = GNUNET_RESOLVER_ip_get (name,
                                                 AF_UNSPEC,
                                                 timeout,
                                                 &http_common_dns_ip_lookup_cb,
                                                 ppc);
  if (NULL == ppc->resolver_handle)
  {
    GNUNET_free (ppc->plugin);
    GNUNET_free (ppc);
    return GNUNET_SYSERR;
  }
  GNUNET_CONTAINER_DLL_insert (dll_ppc_head,
                               dll_ppc_tail,
                               ppc);
  return GNUNET_OK;
}

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

Referenced by http_common_plugin_address_pretty_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

http_common_plugin_address_pretty_printer()

void http_common_plugin_address_pretty_printer	(	void *	cls,
		const char *	type,
		const void *	addr,
		size_t	addrlen,
		int	numeric,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_TRANSPORT_AddressStringCallback	asc,
		void *	asc_cls
	)

Convert the transports address to a nice, human-readable format.

Parameters

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_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_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_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	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;
}

Variable Documentation

dll_ppc_head

struct PrettyPrinterContext* dll_ppc_head

static

Head of PPC list.

Definition at line 236 of file plugin_transport_http_common.c.

Referenced by http_common_dns_ip_lookup(), http_common_dns_ip_lookup_cb(), http_common_dns_reverse_lookup(), and http_common_dns_reverse_lookup_cb().

dll_ppc_tail

struct PrettyPrinterContext* dll_ppc_tail

static

Tail of PPC list.

Definition at line 241 of file plugin_transport_http_common.c.

Referenced by http_common_dns_ip_lookup(), http_common_dns_ip_lookup_cb(), http_common_dns_reverse_lookup(), and http_common_dns_reverse_lookup_cb().