plugin_transport_http_client.c File Reference

HTTP/S client transport plugin. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_plugin.h"
#include "plugin_transport_http_common.h"
#include "gnunet_curl_lib.h"

Include dependency graph for plugin_transport_http_client.c:

Go to the source code of this file.

Data Structures
struct	HTTP_Message
	Message to send using http. More...
struct	RequestHandle
	The request handle. More...
struct	GNUNET_ATS_Session
	Session handle for connections. More...
struct	HTTP_Client_Plugin
	Encapsulation of all of the state of the plugin. More...
struct	GNUNET_ATS_SessionClientCtx
	Closure for session_lookup_client_by_address(). More...

Macros
#define	PLUGIN_NAME   "http_client"
#define	HTTP_STAT_STR_CONNECTIONS   "# HTTP client connections"
#define	LIBGNUNET_PLUGIN_TRANSPORT_INIT    libgnunet_plugin_transport_http_client_init
#define	LIBGNUNET_PLUGIN_TRANSPORT_DONE    libgnunet_plugin_transport_http_client_done
#define	VERBOSE_CURL   GNUNET_NO
#define	PUT_DISCONNECT_TIMEOUT
#define	ENABLE_PUT   GNUNET_YES
#define	ENABLE_GET   GNUNET_YES
#define	LOG(kind, ...)   GNUNET_log_from (kind, PLUGIN_NAME, __VA_ARGS__)

Enumerations
enum	HTTP_PUT_REQUEST_STATE {   H_NOT_CONNECTED , H_CONNECTED , H_PAUSED , H_TMP_DISCONNECTING ,   H_TMP_RECONNECT_REQUIRED , H_TMP_DISCONNECTED , H_DISCONNECTED }
	State of a HTTP PUT request. More...

Functions
static int	http_client_plugin_session_disconnect (void *cls, struct GNUNET_ATS_Session *s)
	Disconnect a session. More...
static void	notify_session_monitor (struct HTTP_Client_Plugin *plugin, struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state)
	If a session monitor is attached, notify it about the new session state. More...
static void	client_delete_session (struct GNUNET_ATS_Session *s)
	Delete session s. More...
static void	client_reschedule_session_timeout (struct GNUNET_ATS_Session *s)
	Increment session timeout due to activity for session s. More...
static void	client_run (void *cls)
	Task performing curl operations. More...
static int	client_schedule (struct HTTP_Client_Plugin *plugin, int now)
	Function setting up file descriptors and scheduling task to run. More...
static int	client_connect_get (struct GNUNET_ATS_Session *s)
	Connect GET request. More...
static int	client_connect_put (struct GNUNET_ATS_Session *s)
	Connect a HTTP put request. More...
static ssize_t	http_client_plugin_send (void *cls, struct GNUNET_ATS_Session *s, const char *msgbuf, size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative to, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
	Function that can be used by the transport service to transmit a message using the plugin. More...
static unsigned int	http_client_query_keepalive_factor (void *cls)
	Function that is called to get the keepalive factor. More...
static int	destroy_session_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Callback to destroys all sessions on exit. More...
static void	http_client_plugin_peer_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
	Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuationc). More...
static int	session_lookup_client_by_address (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Locate the seession object for a given address. More...
static struct GNUNET_ATS_Session *	client_lookup_session (struct HTTP_Client_Plugin *plugin, const struct GNUNET_HELLO_Address *address)
	Check if a sessions exists for an specific address. More...
static void	client_put_disconnect (void *cls)
	When we have nothing to transmit, we pause the HTTP PUT after a while (so that gnurl stops asking). More...
static size_t	client_send_cb (void *stream, size_t size, size_t nmemb, void *cls)
	Callback method used with libcurl Method is called when libcurl needs to read data during sending. More...
static void	client_wake_up (void *cls)
	Wake up a curl handle which was suspended. More...
static int	client_receive_mst_cb (void *cls, const struct GNUNET_MessageHeader *message)
	Callback for message stream tokenizer. More...
static size_t	client_receive_put (void *stream, size_t size, size_t nmemb, void *cls)
	Callback method used with libcurl when data for a PUT request are received. More...
static size_t	client_receive (void *stream, size_t size, size_t nmemb, void *cls)
	Callback method used with libcurl when data for a GET request are received. More...
static int	client_connect (struct GNUNET_ATS_Session *s)
	Connect both PUT and GET request for a session. More...
static enum GNUNET_NetworkType	http_client_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
	Function obtain the network type for a session. More...
static enum GNUNET_NetworkType	http_client_plugin_get_network_for_address (void *cls, const struct GNUNET_HELLO_Address *address)
	Function obtain the network type for an address. More...
static void	client_session_timeout (void *cls)
	Session was idle, so disconnect it. More...
static struct GNUNET_ATS_Session *	http_client_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
	Creates a new outbound session the transport service will use to send data to the peer. More...
static int	client_start (struct HTTP_Client_Plugin *plugin)
	Setup http_client plugin. More...
static int	http_client_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
	Another peer has suggested an address for this peer and transport plugin. More...
void *	libgnunet_plugin_transport_http_client_done (void *cls)
	Exit point from the plugin. More...
static int	client_configure_plugin (struct HTTP_Client_Plugin *plugin)
	Configure plugin. More...
static const char *	http_client_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
	Function to convert an address to a human-readable string. More...
static void	http_client_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
	Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated. More...
static void	http_client_plugin_update_inbound_delay (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *s, struct GNUNET_TIME_Relative delay)
	Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value. More...
static int	send_session_info_iter (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Return information about the given session to the monitor callback. More...
static void	http_client_plugin_setup_monitor (void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
	Begin monitoring sessions of a plugin. More...
void *	libgnunet_plugin_transport_http_client_init (void *cls)
	Entry point for the plugin. More...

Detailed Description

HTTP/S client transport plugin.

Author

Matthias Wachs

Christian Grothoff

Definition in file plugin_transport_http_client.c.

Macro Definition Documentation

PLUGIN_NAME

#define PLUGIN_NAME   "http_client"

Definition at line 36 of file plugin_transport_http_client.c.

HTTP_STAT_STR_CONNECTIONS

#define HTTP_STAT_STR_CONNECTIONS   "# HTTP client connections"

Definition at line 37 of file plugin_transport_http_client.c.

LIBGNUNET_PLUGIN_TRANSPORT_INIT

#define LIBGNUNET_PLUGIN_TRANSPORT_INIT    libgnunet_plugin_transport_http_client_init

Definition at line 38 of file plugin_transport_http_client.c.

LIBGNUNET_PLUGIN_TRANSPORT_DONE

#define LIBGNUNET_PLUGIN_TRANSPORT_DONE    libgnunet_plugin_transport_http_client_done

Definition at line 40 of file plugin_transport_http_client.c.

VERBOSE_CURL

#define VERBOSE_CURL   GNUNET_NO

Definition at line 44 of file plugin_transport_http_client.c.

PUT_DISCONNECT_TIMEOUT

#define PUT_DISCONNECT_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 1)

Definition at line 46 of file plugin_transport_http_client.c.

ENABLE_PUT

#define ENABLE_PUT   GNUNET_YES

Definition at line 49 of file plugin_transport_http_client.c.

ENABLE_GET

#define ENABLE_GET   GNUNET_YES

Definition at line 50 of file plugin_transport_http_client.c.

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, PLUGIN_NAME, __VA_ARGS__)

Definition at line 61 of file plugin_transport_http_client.c.

Enumeration Type Documentation

HTTP_PUT_REQUEST_STATE

enum HTTP_PUT_REQUEST_STATE

State of a HTTP PUT request.

Enumerator
H_NOT_CONNECTED	Just created, not yet connected.
H_CONNECTED	Connected.
H_PAUSED	Paused, nothing to send.
H_TMP_DISCONNECTING	Temporary disconnect in progress due to inactivity.
H_TMP_RECONNECT_REQUIRED	Send request while temporary disconnect, reconnect.
H_TMP_DISCONNECTED	Temporarily disconnected.
H_DISCONNECTED	Disconnected.

Definition at line 71 of file plugin_transport_http_client.c.

{
  H_NOT_CONNECTED,
 
  H_CONNECTED,
 
  H_PAUSED,
 
  H_TMP_DISCONNECTING,
 
  H_TMP_RECONNECT_REQUIRED,
 
  H_TMP_DISCONNECTED,
 
  H_DISCONNECTED
};

Function Documentation

http_client_plugin_session_disconnect()

static int http_client_plugin_session_disconnect ( void *  cls, struct GNUNET_ATS_Session *  s  )

static

Disconnect a session.

Parameters

cls	the struct HTTP_Client_Plugin *
s	session

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 849 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p: notifying transport about ending session\n",
       s);
  plugin->env->session_end (plugin->env->cls,
                            s->address,
                            s);
  client_delete_session (s);
 
  /* Re-schedule since handles have changed */
  if (NULL != plugin->client_perform_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
    plugin->client_perform_task = NULL;
  }
  client_schedule (plugin, GNUNET_YES);
 
  return GNUNET_OK;
}

References GNUNET_ATS_Session::address, client_delete_session(), client_schedule(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, LOG, and plugin.

Referenced by client_run(), client_session_timeout(), destroy_session_cb(), http_client_plugin_send(), and libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_session_monitor()

static void notify_session_monitor ( struct HTTP_Client_Plugin *  plugin, struct GNUNET_ATS_Session *  session, enum GNUNET_TRANSPORT_SessionState  state  )

static

If a session monitor is attached, notify it about the new session state.

Parameters

plugin	our plugin
session	session that changed state
state	new state of the session

Definition at line 413 of file plugin_transport_http_client.c.

{
  struct GNUNET_TRANSPORT_SessionInfo info;
 
  if (NULL == plugin->sic)
    return;
  memset (&info, 0, sizeof(info));
  info.state = state;
  info.is_inbound = GNUNET_NO;
  info.num_msg_pending = session->msgs_in_queue;
  info.num_bytes_pending = session->bytes_in_queue;
  info.receive_delay = session->next_receive;
  info.session_timeout = session->timeout;
  info.address = session->address;
  plugin->sic (plugin->sic_cls,
               session,
               &info);
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_NO, info, GNUNET_ATS_Session::msgs_in_queue, GNUNET_ATS_Session::next_receive, plugin, state, and GNUNET_ATS_Session::timeout.

Referenced by client_delete_session(), client_send_cb(), client_session_timeout(), http_client_plugin_get_session(), http_client_plugin_send(), and send_session_info_iter().

Here is the caller graph for this function:

client_delete_session()

static void client_delete_session ( struct GNUNET_ATS_Session *  s )

static

Delete session s.

Parameters

s	the session to delete

Definition at line 441 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = s->plugin;
  struct HTTP_Message *pos;
  struct HTTP_Message *next;
  CURLMcode mret;
 
  if (NULL != s->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (s->timeout_task);
    s->timeout_task = NULL;
    s->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  }
  if (NULL != s->put_disconnect_task)
  {
    GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
    s->put_disconnect_task = NULL;
  }
  if (NULL != s->recv_wakeup_task)
  {
    GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
    s->recv_wakeup_task = NULL;
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
                                                       &s->address->peer,
                                                       s));
  if (NULL != s->put.easyhandle)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: disconnecting PUT request to peer `%s'\n",
         s,
         s->put.easyhandle,
         GNUNET_i2s (&s->address->peer));
 
    /* remove curl handle from multi handle */
    mret = curl_multi_remove_handle (plugin->curl_multi_handle,
                                     s->put.easyhandle);
    GNUNET_break (CURLM_OK == mret);
    curl_easy_cleanup (s->put.easyhandle);
    GNUNET_assert (plugin->cur_requests > 0);
    plugin->cur_requests--;
    s->put.easyhandle = NULL;
  }
  if (NULL != s->get.easyhandle)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: disconnecting GET request to peer `%s'\n",
         s, s->get.easyhandle,
         GNUNET_i2s (&s->address->peer));
    /* remove curl handle from multi handle */
    mret = curl_multi_remove_handle (plugin->curl_multi_handle,
                                     s->get.easyhandle);
    GNUNET_break (CURLM_OK == mret);
    curl_easy_cleanup (s->get.easyhandle);
    GNUNET_assert (plugin->cur_requests > 0);
    plugin->cur_requests--;
    s->get.easyhandle = NULL;
  }
 
  GNUNET_STATISTICS_set (plugin->env->stats,
                         HTTP_STAT_STR_CONNECTIONS,
                         plugin->cur_requests,
                         GNUNET_NO);
  next = s->msg_head;
  while (NULL != (pos = next))
  {
    next = pos->next;
    GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                 s->msg_tail,
                                 pos);
    GNUNET_assert (0 < s->msgs_in_queue);
    s->msgs_in_queue--;
    GNUNET_assert (pos->size <= s->bytes_in_queue);
    s->bytes_in_queue -= pos->size;
    if (NULL != pos->transmit_cont)
      pos->transmit_cont (pos->transmit_cont_cls,
                          &s->address->peer,
                          GNUNET_SYSERR,
                          pos->size,
                          pos->pos + s->overhead);
    s->overhead = 0;
    GNUNET_free (pos);
  }
  GNUNET_assert (0 == s->msgs_in_queue);
  GNUNET_assert (0 == s->bytes_in_queue);
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_DONE);
  if (NULL != s->msg_tk)
  {
    GNUNET_MST_destroy (s->msg_tk);
    s->msg_tk = NULL;
  }
  GNUNET_HELLO_address_free (s->address);
  GNUNET_free (s->url);
  GNUNET_free (s);
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_i2s(), GNUNET_MST_destroy(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_SS_DONE, HTTP_STAT_STR_CONNECTIONS, LOG, GNUNET_ATS_Session::msg_head, GNUNET_ATS_Session::msg_tail, GNUNET_ATS_Session::msg_tk, GNUNET_ATS_Session::msgs_in_queue, HTTP_Message::next, notify_session_monitor(), GNUNET_ATS_Session::overhead, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, HTTP_Message::pos, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, GNUNET_ATS_Session::recv_wakeup_task, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and GNUNET_ATS_Session::url.

Referenced by http_client_plugin_get_session(), and http_client_plugin_session_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

client_reschedule_session_timeout()

static void client_reschedule_session_timeout ( struct GNUNET_ATS_Session *  s )

static

Increment session timeout due to activity for session s.

Parameters

s	the session

Definition at line 547 of file plugin_transport_http_client.c.

{
  GNUNET_assert (NULL != s->timeout_task);
  s->timeout = GNUNET_TIME_relative_to_absolute (
    GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by client_receive_mst_cb(), and http_client_plugin_update_session_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

client_run()

static void client_run ( void *  cls )

static

Task performing curl operations.

Parameters

cls	plugin as closure

Definition at line 1292 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
  int running;
  long http_statuscode;
  CURLMcode mret;
  CURLMsg *msg;
  int put_request; /* GNUNET_YES if easy handle is put, GNUNET_NO for get */
  int msgs_left;
 
  plugin->client_perform_task = NULL;
  /* While data are available or timeouts occurred */
  do
  {
    running = 0;
    /* Perform operations for all handles */
    mret = curl_multi_perform (plugin->curl_multi_handle, &running);
 
    /* Get additional information for all handles */
    while (NULL != (msg = curl_multi_info_read (plugin->curl_multi_handle,
                                                &msgs_left)))
    {
      CURL *easy_h = msg->easy_handle;
      struct GNUNET_ATS_Session *s = NULL;
      char *d = NULL;     /* curl requires 'd' to be a 'char *' */
 
      GNUNET_assert (NULL != easy_h);
 
      /* Obtain session from easy handle */
      GNUNET_assert (CURLE_OK == curl_easy_getinfo (easy_h, CURLINFO_PRIVATE,
                                                    &d));
      s = (struct GNUNET_ATS_Session *) d;
      GNUNET_assert (NULL != s);
 
      if (msg->msg != CURLMSG_DONE)
        continue;     /* This should not happen */
 
      /* Get HTTP response code */
      GNUNET_break (CURLE_OK == curl_easy_getinfo (easy_h,
                                                   CURLINFO_RESPONSE_CODE,
                                                   &http_statuscode));
 
      if (easy_h == s->put.easyhandle)
        put_request = GNUNET_YES;
      else
        put_request = GNUNET_NO;
 
      /* Log status of terminated request */
      if ((0 != msg->data.result) || (http_statuscode != 200))
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Session %p/request %p: %s request to `%s' ended with status %li reason %i: `%s'\n",
             s, msg->easy_handle,
             (GNUNET_YES == put_request) ? "PUT" : "GET",
             GNUNET_i2s (&s->address->peer),
             http_statuscode,
             msg->data.result,
             curl_easy_strerror (msg->data.result));
      else
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Session %p/request %p: %s request to `%s' ended normal\n",
             s, msg->easy_handle,
             (GNUNET_YES == put_request) ? "PUT" : "GET",
             GNUNET_i2s (&s->address->peer));
 
      /* Remove easy handle from multi handle */
      curl_multi_remove_handle (plugin->curl_multi_handle, easy_h);
 
      /* Clean up easy handle */
      curl_easy_cleanup (easy_h);
 
      /* Remove information */
      GNUNET_assert (plugin->cur_requests > 0);
      plugin->cur_requests--;
      LOG (GNUNET_ERROR_TYPE_INFO,
           "%s request to %s done, number of requests decreased to %u\n",
           (GNUNET_YES == put_request) ? "PUT" : "GET",
           s->url,
           plugin->cur_requests);
 
      if (GNUNET_YES == put_request)
      {
        /* Clean up a PUT request */
        s->put.easyhandle = NULL;
        s->put.s = NULL;
 
        switch (s->put.state)
        {
        case H_NOT_CONNECTED:
        case H_DISCONNECTED:
        case H_TMP_DISCONNECTED:
          /* This must not happen */
          GNUNET_break (0);
          break;
 
        case H_TMP_RECONNECT_REQUIRED:
          /* Transport called send while disconnect in progress, reconnect */
          if (GNUNET_SYSERR == client_connect_put (s))
          {
            /* Reconnect failed, disconnect session */
            http_client_plugin_session_disconnect (plugin, s);
          }
          break;
 
        case H_TMP_DISCONNECTING:
          /* PUT gets temporarily disconnected */
          s->put.state = H_TMP_DISCONNECTED;
          break;
 
        case H_PAUSED:
        case H_CONNECTED:
          /* PUT gets permanently disconnected */
          s->put.state = H_DISCONNECTED;
          http_client_plugin_session_disconnect (plugin, s);
          break;
 
        default:
          GNUNET_break (0);
          break;
        }
      }
      else if (GNUNET_NO == put_request)
      {
        /* Clean up a GET request */
        s->get.easyhandle = NULL;
        s->get.s = NULL;
 
        /* If we are emulating an XHR client we need to make another GET
         * request.
         */
        if (GNUNET_YES == plugin->emulate_xhr)
        {
          if (GNUNET_SYSERR == client_connect_get (s))
            http_client_plugin_session_disconnect (plugin, s);
        }
        else
        {
          /* GET request was terminated, so disconnect session */
          http_client_plugin_session_disconnect (plugin, s);
        }
      }
      else
        GNUNET_break (0);    /* Must not happen */
 
      GNUNET_STATISTICS_set (plugin->env->stats,
                             HTTP_STAT_STR_CONNECTIONS,
                             plugin->cur_requests,
                             GNUNET_NO);
    }
  }
  while (mret == CURLM_CALL_MULTI_PERFORM);
  client_schedule (plugin, GNUNET_NO);
}

References GNUNET_ATS_Session::address, client_connect_get(), client_connect_put(), client_schedule(), RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_YES, H_CONNECTED, H_DISCONNECTED, H_NOT_CONNECTED, H_PAUSED, H_TMP_DISCONNECTED, H_TMP_DISCONNECTING, H_TMP_RECONNECT_REQUIRED, http_client_plugin_session_disconnect(), HTTP_STAT_STR_CONNECTIONS, LOG, msg, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::put, RequestHandle::s, RequestHandle::state, and GNUNET_ATS_Session::url.

Referenced by client_connect(), and client_schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

client_schedule()

static int client_schedule ( struct HTTP_Client_Plugin *  plugin, int  now  )

static

Function setting up file descriptors and scheduling task to run.

Parameters

plugin	the plugin as closure
now	schedule task in 1ms, regardless of what curl may say

Returns

GNUNET_SYSERR for hard failure, GNUNET_OK for ok

Definition at line 572 of file plugin_transport_http_client.c.

{
  fd_set rs;
  fd_set ws;
  fd_set es;
  int max;
  struct GNUNET_NETWORK_FDSet *grs;
  struct GNUNET_NETWORK_FDSet *gws;
  long to;
  CURLMcode mret;
  struct GNUNET_TIME_Relative timeout;
 
  /* Cancel previous scheduled task */
  if (plugin->client_perform_task != NULL)
  {
    GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
    plugin->client_perform_task = NULL;
  }
  max = -1;
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
  mret = curl_multi_fdset (plugin->curl_multi_handle, &rs, &ws, &es, &max);
  if (mret != CURLM_OK)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("%s failed at %s:%d: `%s'\n"),
         "curl_multi_fdset",
         __FILE__,
         __LINE__,
         curl_multi_strerror (mret));
    return GNUNET_SYSERR;
  }
  mret = curl_multi_timeout (plugin->curl_multi_handle, &to);
  if (-1 == to)
    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1);
  else
    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to);
  if (now == GNUNET_YES)
    timeout = GNUNET_TIME_UNIT_MILLISECONDS;
 
  if (CURLM_OK != mret)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("%s failed at %s:%d: `%s'\n"),
         "curl_multi_timeout", __FILE__, __LINE__,
         curl_multi_strerror (mret));
    return GNUNET_SYSERR;
  }
 
  grs = GNUNET_NETWORK_fdset_create ();
  gws = GNUNET_NETWORK_fdset_create ();
  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
 
  /* Schedule task to run when select is ready to read or write */
  plugin->client_perform_task =
    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                 timeout, grs, gws,
                                 &client_run, plugin);
  GNUNET_NETWORK_fdset_destroy (gws);
  GNUNET_NETWORK_fdset_destroy (grs);
  return GNUNET_OK;
}

References _, client_run(), GNUNET_ERROR_TYPE_ERROR, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_OK, GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, LOG, max, plugin, and timeout.

Referenced by client_put_disconnect(), client_run(), http_client_plugin_send(), and http_client_plugin_session_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_get()

static int client_connect_get ( struct GNUNET_ATS_Session *  s )

static

Connect GET request.

Connect GET request for a session.

Parameters

s	the session to connect

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1514 of file plugin_transport_http_client.c.

{
  CURLMcode mret;
  struct HttpAddress *ha;
  uint32_t options;
 
  ha = (struct HttpAddress *) s->address->address;
  options = ntohl (ha->options);
  /* create get request */
  s->get.easyhandle = curl_easy_init ();
  s->get.s = s;
  if (0 != (options & HTTP_OPTIONS_TCP_STEALTH))
  {
#ifdef TCP_STEALTH
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_OPENSOCKETFUNCTION,
                      &open_tcp_stealth_socket_cb);
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_OPENSOCKETDATA,
                      s);
#else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cannot connect, TCP STEALTH needed and not supported by kernel.\n");
    curl_easy_cleanup (s->get.easyhandle);
    s->get.easyhandle = NULL;
    s->get.s = NULL;
    return GNUNET_SYSERR;
#endif
  }
 
#if VERBOSE_CURL
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_VERBOSE,
                    1L);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_DEBUGFUNCTION,
                    &client_log);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_DEBUGDATA,
                    &s->get);
#endif
#if BUILD_HTTPS
  curl_easy_setopt (s->get.easyhandle, CURLOPT_SSLVERSION,
                    CURL_SSLVERSION_TLSv1);
  {
    if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
        (options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
    {
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_SSL_VERIFYPEER, 1L);
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_SSL_VERIFYHOST,
                        2L);
    }
    else
    {
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_SSL_VERIFYPEER,
                        0L);
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_SSL_VERIFYHOST,
                        0L);
    }
  }
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_PROTOCOLS,
                    CURLPROTO_HTTPS);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_REDIR_PROTOCOLS,
                    CURLPROTO_HTTPS);
#else
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_PROTOCOLS,
                    CURLPROTO_HTTP);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_REDIR_PROTOCOLS,
                    CURLPROTO_HTTP);
#endif
 
  if (NULL != s->plugin->proxy_hostname)
  {
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_PROXY,
                      s->plugin->proxy_hostname);
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_PROXYTYPE,
                      s->plugin->proxytype);
    if (NULL != s->plugin->proxy_username)
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_PROXYUSERNAME,
                        s->plugin->proxy_username);
    if (NULL != s->plugin->proxy_password)
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_PROXYPASSWORD,
                        s->plugin->proxy_password);
    if (GNUNET_YES == s->plugin->proxy_use_httpproxytunnel)
      curl_easy_setopt (s->get.easyhandle,
                        CURLOPT_HTTPPROXYTUNNEL,
                        s->plugin->proxy_use_httpproxytunnel);
  }
 
  if (GNUNET_YES == s->plugin->emulate_xhr)
  {
    char *url;
 
    GNUNET_asprintf (&url,
                     "%s,1",
                     s->url);
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_URL,
                      url);
    GNUNET_free (url);
  }
  else
  {
    curl_easy_setopt (s->get.easyhandle,
                      CURLOPT_URL,
                      s->url);
  }
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_READFUNCTION,
                    &client_send_cb);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_READDATA,
                    s);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_WRITEFUNCTION,
                    &client_receive);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_WRITEDATA,
                    s);
  /* No timeout by default, timeout done with session timeout */
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_TIMEOUT,
                    0L);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_PRIVATE, s);
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_CONNECTTIMEOUT_MS,
                    (long) (HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value_us
                            / 1000LL));
  curl_easy_setopt (s->get.easyhandle, CURLOPT_BUFFERSIZE,
                    2 * GNUNET_MAX_MESSAGE_SIZE);
#if CURL_TCP_NODELAY
  curl_easy_setopt (ps->recv_endpoint,
                    CURLOPT_TCP_NODELAY,
                    1L);
#endif
  curl_easy_setopt (s->get.easyhandle,
                    CURLOPT_FOLLOWLOCATION,
                    0L);
 
  mret = curl_multi_add_handle (s->plugin->curl_multi_handle,
                                s->get.easyhandle);
  if (CURLM_OK != mret)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %p : Failed to add GET handle to multihandle: `%s'\n",
         s,
         curl_multi_strerror (mret));
    curl_easy_cleanup (s->get.easyhandle);
    s->get.easyhandle = NULL;
    s->get.s = NULL;
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  s->plugin->cur_requests++;
  LOG (GNUNET_ERROR_TYPE_INFO,
       "GET request `%s' established, number of requests increased to %u\n",
       s->url,
       s->plugin->cur_requests);
  return GNUNET_OK;
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, client_receive(), client_send_cb(), RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_asprintf(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, HTTP_CLIENT_NOT_VALIDATED_TIMEOUT, HTTP_OPTIONS_TCP_STEALTH, HTTP_OPTIONS_VERIFY_CERTIFICATE, LOG, options, HttpAddress::options, GNUNET_ATS_Session::plugin, RequestHandle::s, and GNUNET_ATS_Session::url.

Referenced by client_connect(), and client_run().

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_put()

static int client_connect_put ( struct GNUNET_ATS_Session *  s )

static

Connect a HTTP put request.

Parameters

s	the session to connect

Returns

GNUNET_SYSERR for hard failure, GNUNET_OK for success

Definition at line 1690 of file plugin_transport_http_client.c.

{
  CURLMcode mret;
  struct HttpAddress *ha;
  uint32_t options;
 
  ha = (struct HttpAddress *) s->address->address;
  options = ntohl (ha->options);
  /* create put request */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p: Init PUT handle\n",
       s);
  s->put.easyhandle = curl_easy_init ();
  s->put.s = s;
#if VERBOSE_CURL
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_VERBOSE,
                    1L);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_DEBUGFUNCTION,
                    &client_log);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_DEBUGDATA,
                    &s->put);
#endif
  if (0 != (options & HTTP_OPTIONS_TCP_STEALTH))
  {
#ifdef TCP_STEALTH
    curl_easy_setopt (s->put.easyhandle,
                      CURLOPT_OPENSOCKETFUNCTION,
                      &open_tcp_stealth_socket_cb);
    curl_easy_setopt (s->put.easyhandle,
                      CURLOPT_OPENSOCKETDATA,
                      s);
#else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cannot connect, TCP STEALTH needed and not supported by kernel.\n");
    curl_easy_cleanup (s->put.easyhandle);
    s->put.easyhandle = NULL;
    s->put.s = NULL;
    s->put.state = H_DISCONNECTED;
    return GNUNET_SYSERR;
#endif
  }
#if BUILD_HTTPS
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_SSLVERSION,
                    CURL_SSLVERSION_TLSv1);
  {
    struct HttpAddress *ha;
    ha = (struct HttpAddress *) s->address->address;
 
    if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
        (ntohl (ha->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
    {
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_SSL_VERIFYPEER,
                        1L);
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_SSL_VERIFYHOST,
                        2L);
    }
    else
    {
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_SSL_VERIFYPEER,
                        0L);
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_SSL_VERIFYHOST,
                        0L);
    }
  }
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_PROTOCOLS,
                    CURLPROTO_HTTPS);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_REDIR_PROTOCOLS,
                    CURLPROTO_HTTPS);
#else
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_PROTOCOLS,
                    CURLPROTO_HTTP);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_REDIR_PROTOCOLS,
                    CURLPROTO_HTTP);
#endif
  if (NULL != s->plugin->proxy_hostname)
  {
    curl_easy_setopt (s->put.easyhandle,
                      CURLOPT_PROXY,
                      s->plugin->proxy_hostname);
    curl_easy_setopt (s->put.easyhandle,
                      CURLOPT_PROXYTYPE,
                      s->plugin->proxytype);
    if (NULL != s->plugin->proxy_username)
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_PROXYUSERNAME,
                        s->plugin->proxy_username);
    if (NULL != s->plugin->proxy_password)
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_PROXYPASSWORD,
                        s->plugin->proxy_password);
    if (GNUNET_YES == s->plugin->proxy_use_httpproxytunnel)
      curl_easy_setopt (s->put.easyhandle,
                        CURLOPT_HTTPPROXYTUNNEL,
                        s->plugin->proxy_use_httpproxytunnel);
  }
 
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_URL,
                    s->url);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_UPLOAD,
                    1L);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_READFUNCTION,
                    &client_send_cb);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_READDATA,
                    s);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_WRITEFUNCTION,
                    &client_receive_put);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_WRITEDATA,
                    s);
  /* No timeout by default, timeout done with session timeout */
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_TIMEOUT,
                    0L);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_PRIVATE,
                    s);
  curl_easy_setopt (s->put.easyhandle,
                    CURLOPT_CONNECTTIMEOUT_MS,
                    (long) (HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value_us
                            / 1000LL));
  curl_easy_setopt (s->put.easyhandle, CURLOPT_BUFFERSIZE,
                    2 * GNUNET_MAX_MESSAGE_SIZE);
#if CURL_TCP_NODELAY
  curl_easy_setopt (s->put.easyhandle, CURLOPT_TCP_NODELAY, 1);
#endif
  mret = curl_multi_add_handle (s->plugin->curl_multi_handle,
                                s->put.easyhandle);
  if (CURLM_OK != mret)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %p : Failed to add PUT handle to multihandle: `%s'\n",
         s, curl_multi_strerror (mret));
    curl_easy_cleanup (s->put.easyhandle);
    s->put.easyhandle = NULL;
    s->put.s = NULL;
    s->put.state = H_DISCONNECTED;
    return GNUNET_SYSERR;
  }
  s->put.state = H_CONNECTED;
  s->plugin->cur_requests++;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "PUT request `%s' established, number of requests increased to %u\n",
       s->url, s->plugin->cur_requests);
 
  return GNUNET_OK;
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, client_receive_put(), client_send_cb(), RequestHandle::easyhandle, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, H_CONNECTED, H_DISCONNECTED, HTTP_CLIENT_NOT_VALIDATED_TIMEOUT, HTTP_OPTIONS_TCP_STEALTH, HTTP_OPTIONS_VERIFY_CERTIFICATE, LOG, options, HttpAddress::options, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, RequestHandle::s, RequestHandle::state, and GNUNET_ATS_Session::url.

Referenced by client_connect(), client_run(), and http_client_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

http_client_plugin_send()

static ssize_t http_client_plugin_send ( void *  cls, struct GNUNET_ATS_Session *  s, const char *  msgbuf, size_t  msgbuf_size, unsigned int  priority, struct GNUNET_TIME_Relative  to, GNUNET_TRANSPORT_TransmitContinuation  cont, void *  cont_cls  )

static

Function that can be used by the transport service to transmit a message using the plugin.

Note that in the case of a peer disconnecting, the continuation MUST be called prior to the disconnect notification itself. This function will be called with this peer's HELLO message to initiate a fresh connection to another peer.

Parameters

cls	closure
s	which session must be used
msgbuf	the message to transmit
msgbuf_size	number of bytes in msgbuf
priority	how important is the message (most plugins will ignore message priority and just FIFO)
to	how long to wait at most for the transmission (does not require plugins to discard the message after the timeout, just advisory for the desired delay; most plugins will ignore this as well)
cont	continuation to call once the message has been transmitted (or if the transport is ready for the next transmission call; or if the peer disconnected...); can be NULL
cont_cls	closure for cont

Returns

number of bytes used (on the physical network, with overheads); -1 on hard errors (i.e. address invalid); 0 is a legal value and does NOT mean that the message was not transmitted (DV)

Definition at line 757 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
  struct HTTP_Message *msg;
  char *stat_txt;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p/request %p: Sending message with %lu to peer `%s' \n",
       s,
       s->put.easyhandle,
       (unsigned long) msgbuf_size,
       GNUNET_i2s (&s->address->peer));
 
  /* create new message and schedule */
  msg = GNUNET_malloc (sizeof(struct HTTP_Message) + msgbuf_size);
  msg->size = msgbuf_size;
  msg->buf = (char *) &msg[1];
  msg->transmit_cont = cont;
  msg->transmit_cont_cls = cont_cls;
  GNUNET_memcpy (msg->buf,
                 msgbuf,
                 msgbuf_size);
  GNUNET_CONTAINER_DLL_insert_tail (s->msg_head,
                                    s->msg_tail,
                                    msg);
  s->msgs_in_queue++;
  s->bytes_in_queue += msg->size;
 
  GNUNET_asprintf (&stat_txt,
                   "# bytes currently in %s_client buffers",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt, msgbuf_size, GNUNET_NO);
  GNUNET_free (stat_txt);
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_UPDATE);
  if (H_TMP_DISCONNECTING == s->put.state)
  {
    /* PUT request is currently getting disconnected */
    s->put.state = H_TMP_RECONNECT_REQUIRED;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: currently disconnecting, reconnecting immediately\n",
         s,
         s->put.easyhandle);
    return msgbuf_size;
  }
  if (H_PAUSED == s->put.state)
  {
    /* PUT request was paused, unpause */
    GNUNET_assert (s->put_disconnect_task != NULL);
    GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
    s->put_disconnect_task = NULL;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: unpausing request\n",
         s, s->put.easyhandle);
    s->put.state = H_CONNECTED;
    if (NULL != s->put.easyhandle)
      curl_easy_pause (s->put.easyhandle, CURLPAUSE_CONT);
  }
  else if (H_TMP_DISCONNECTED == s->put.state)
  {
    /* PUT request was disconnected, reconnect */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Session %p: Reconnecting PUT request\n", s);
    GNUNET_break (NULL == s->put.easyhandle);
    if (GNUNET_SYSERR == client_connect_put (s))
    {
      /* Could not reconnect */
      http_client_plugin_session_disconnect (plugin, s);
      return GNUNET_SYSERR;
    }
  }
  client_schedule (s->plugin, GNUNET_YES);
  return msgbuf_size;
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, client_connect_put(), client_schedule(), RequestHandle::easyhandle, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, H_CONNECTED, H_PAUSED, H_TMP_DISCONNECTED, H_TMP_DISCONNECTING, H_TMP_RECONNECT_REQUIRED, http_client_plugin_session_disconnect(), LOG, msg, GNUNET_ATS_Session::msg_head, GNUNET_ATS_Session::msg_tail, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, GNUNET_MessageHeader::size, and RequestHandle::state.

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

static unsigned int http_client_query_keepalive_factor ( void *  cls )

static

Function that is called to get the keepalive factor.

GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to calculate the interval between keepalive packets.

Parameters

cls	closure with the struct Plugin

Returns

keepalive factor

Definition at line 883 of file plugin_transport_http_client.c.

{
  return 3;
}

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

destroy_session_cb()

static int destroy_session_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Callback to destroys all sessions on exit.

Parameters

cls	the struct HTTP_Client_Plugin *
peer	identity of the peer
value	the struct GNUNET_ATS_Session *

Returns

GNUNET_OK (continue iterating)

Definition at line 898 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;
 
  http_client_plugin_session_disconnect (plugin, session);
  return GNUNET_OK;
}

References GNUNET_OK, http_client_plugin_session_disconnect(), plugin, and value.

Referenced by http_client_plugin_peer_disconnect(), and libgnunet_plugin_transport_http_client_done().

Here is the call graph for this function:

Here is the caller graph for this function:

http_client_plugin_peer_disconnect()

static void http_client_plugin_peer_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  target  )

static

Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuationc).

Parameters

cls	closure
target	peer from which to disconnect

Definition at line 919 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transport tells me to disconnect `%s'\n",
       GNUNET_i2s (target));
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions,
                                              target,
                                              &destroy_session_cb,
                                              plugin);
}

References destroy_session_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, and plugin.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

session_lookup_client_by_address()

static int session_lookup_client_by_address ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Locate the seession object for a given address.

Parameters

cls	the struct GNUNET_ATS_SessionClientCtx *
key	peer identity
value	the struct GNUNET_ATS_Session to check

Returns

GNUNET_NO if found, GNUNET_OK if not

Definition at line 960 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_SessionClientCtx *sc_ctx = cls;
  struct GNUNET_ATS_Session *s = value;
 
  if (0 == GNUNET_HELLO_address_cmp (sc_ctx->address,
                                     s->address))
  {
    sc_ctx->ret = s;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References GNUNET_ATS_Session::address, GNUNET_ATS_SessionClientCtx::address, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, GNUNET_ATS_SessionClientCtx::ret, and value.

Referenced by client_lookup_session().

Here is the call graph for this function:

Here is the caller graph for this function:

client_lookup_session()

static struct GNUNET_ATS_Session* client_lookup_session ( struct HTTP_Client_Plugin *  plugin, const struct GNUNET_HELLO_Address *  address  )

static

Check if a sessions exists for an specific address.

Parameters

plugin	the plugin
address	the address

Returns

the session or NULL

Definition at line 985 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_SessionClientCtx sc_ctx;
 
  sc_ctx.address = address;
  sc_ctx.ret = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                         &session_lookup_client_by_address,
                                         &sc_ctx);
  return sc_ctx.ret;
}

References address, GNUNET_ATS_SessionClientCtx::address, GNUNET_CONTAINER_multipeermap_iterate(), plugin, GNUNET_ATS_SessionClientCtx::ret, and session_lookup_client_by_address().

Referenced by http_client_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

client_put_disconnect()

static void client_put_disconnect ( void *  cls )

static

When we have nothing to transmit, we pause the HTTP PUT after a while (so that gnurl stops asking).

This task is the delayed task that actually disconnects the PUT.

Parameters

cls	the struct GNUNET_ATS_Session * with the put

Definition at line 1007 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
 
  s->put_disconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p/request %p: will be disconnected due to no activity\n",
       s, s->put.easyhandle);
  s->put.state = H_TMP_DISCONNECTING;
  if (NULL != s->put.easyhandle)
    curl_easy_pause (s->put.easyhandle,
                     CURLPAUSE_CONT);
  client_schedule (s->plugin, GNUNET_YES);
}

References client_schedule(), RequestHandle::easyhandle, GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, H_TMP_DISCONNECTING, LOG, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, and RequestHandle::state.

Referenced by client_send_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

client_send_cb()

static size_t client_send_cb ( void *  stream, size_t  size, size_t  nmemb, void *  cls  )

static

Callback method used with libcurl Method is called when libcurl needs to read data during sending.

Parameters

stream	pointer where to write data
size	size of an individual element
nmemb	count of elements that can be written to the buffer
cls	our struct GNUNET_ATS_Session

Returns

bytes written to stream, returning 0 will terminate request!

Definition at line 1034 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
  struct HTTP_Client_Plugin *plugin = s->plugin;
  struct HTTP_Message *msg = s->msg_head;
  size_t len;
  char *stat_txt;
 
  if (H_TMP_DISCONNECTING == s->put.state)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: disconnect due to inactivity\n",
         s, s->put.easyhandle);
    return 0;
  }
 
  if (NULL == msg)
  {
    if (GNUNET_YES == plugin->emulate_xhr)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Session %p/request %p: PUT request finished\n",
           s,
           s->put.easyhandle);
      s->put.state = H_TMP_DISCONNECTING;
      return 0;
    }
 
    /* We have nothing to send, so pause PUT request */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: nothing to send, suspending\n",
         s,
         s->put.easyhandle);
    s->put_disconnect_task
      = GNUNET_SCHEDULER_add_delayed (PUT_DISCONNECT_TIMEOUT,
                                      &client_put_disconnect,
                                      s);
    s->put.state = H_PAUSED;
    return CURL_READFUNC_PAUSE;
  }
  /* data to send */
  GNUNET_assert (msg->pos < msg->size);
  /* calculate how much fits in buffer */
  len = GNUNET_MIN (msg->size - msg->pos,
                    size * nmemb);
  GNUNET_memcpy (stream,
                 &msg->buf[msg->pos],
                 len);
  msg->pos += len;
  if (msg->pos == msg->size)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p/request %p: sent message with %lu bytes sent, removing message from queue\n",
         s,
         s->put.easyhandle,
         (unsigned long) msg->size);
    /* Calling transmit continuation  */
    GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                 s->msg_tail,
                                 msg);
    GNUNET_assert (0 < s->msgs_in_queue);
    s->msgs_in_queue--;
    GNUNET_assert (msg->size <= s->bytes_in_queue);
    s->bytes_in_queue -= msg->size;
    if (NULL != msg->transmit_cont)
      msg->transmit_cont (msg->transmit_cont_cls,
                          &s->address->peer,
                          GNUNET_OK,
                          msg->size,
                          msg->size + s->overhead);
    s->overhead = 0;
    GNUNET_free (msg);
  }
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_UPDATE);
  GNUNET_asprintf (&stat_txt,
                   "# bytes currently in %s_client buffers",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt,
                            -len,
                            GNUNET_NO);
  GNUNET_free (stat_txt);
  GNUNET_asprintf (&stat_txt,
                   "# bytes transmitted via %s_client",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt,
                            len,
                            GNUNET_NO);
  GNUNET_free (stat_txt);
  return len;
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, client_put_disconnect(), RequestHandle::easyhandle, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, H_PAUSED, H_TMP_DISCONNECTING, len, LOG, msg, GNUNET_ATS_Session::msg_head, GNUNET_ATS_Session::msg_tail, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), GNUNET_ATS_Session::overhead, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, PUT_DISCONNECT_TIMEOUT, GNUNET_MessageHeader::size, size, and RequestHandle::state.

Referenced by client_connect_get(), and client_connect_put().

Here is the call graph for this function:

Here is the caller graph for this function:

client_wake_up()

static void client_wake_up ( void *  cls )

static

Wake up a curl handle which was suspended.

Parameters

cls	the session

Definition at line 1139 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
 
  s->recv_wakeup_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p/request %p: Waking up GET handle\n",
       s, s->get.easyhandle);
  if (H_PAUSED == s->put.state)
  {
    /* PUT request was paused, unpause */
    GNUNET_assert (s->put_disconnect_task != NULL);
    GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
    s->put_disconnect_task = NULL;
    s->put.state = H_CONNECTED;
    if (NULL != s->put.easyhandle)
      curl_easy_pause (s->put.easyhandle, CURLPAUSE_CONT);
  }
  if (NULL != s->get.easyhandle)
    curl_easy_pause (s->get.easyhandle, CURLPAUSE_CONT);
}

References RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_cancel(), H_CONNECTED, H_PAUSED, LOG, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, GNUNET_ATS_Session::recv_wakeup_task, and RequestHandle::state.

Referenced by client_receive(), and http_client_plugin_update_inbound_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

client_receive_mst_cb()

static int client_receive_mst_cb ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Callback for message stream tokenizer.

Parameters

cls	the session
message	the message received

Returns

always GNUNET_OK

Definition at line 1170 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
  struct HTTP_Client_Plugin *plugin;
  struct GNUNET_TIME_Relative delay;
  char *stat_txt;
 
  plugin = s->plugin;
  delay = s->plugin->env->receive (plugin->env->cls,
                                   s->address,
                                   s,
                                   message);
  GNUNET_asprintf (&stat_txt,
                   "# bytes received via %s_client",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt,
                            ntohs (message->size),
                            GNUNET_NO);
  GNUNET_free (stat_txt);
 
  s->next_receive = GNUNET_TIME_relative_to_absolute (delay);
  if (GNUNET_TIME_absolute_get ().abs_value_us < s->next_receive.abs_value_us)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Client: peer `%s' address `%s' next read delayed for %s\n",
         GNUNET_i2s (&s->address->peer),
         http_common_plugin_address_to_string (s->plugin->protocol,
                                               s->address->address,
                                               s->address->address_length),
         GNUNET_STRINGS_relative_time_to_string (delay,
                                                 GNUNET_YES));
  }
  client_reschedule_session_timeout (s);
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, client_reschedule_session_timeout(), delay, Plugin::env, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, http_common_plugin_address_to_string(), LOG, GNUNET_ATS_Session::next_receive, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, Plugin::protocol, and GNUNET_MessageHeader::size.

Referenced by client_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

client_receive_put()

static size_t client_receive_put ( void *  stream, size_t  size, size_t  nmemb, void *  cls  )

static

Callback method used with libcurl when data for a PUT request are received.

We do not expect data here, so we just discard it.

Parameters

stream	pointer where to write data
size	size of an individual element
nmemb	count of elements that can be written to the buffer
cls	destination pointer, passed to the libcurl handle

Returns

bytes read from stream

Definition at line 1220 of file plugin_transport_http_client.c.

{
  return size * nmemb;
}

References size.

Referenced by client_connect_put().

Here is the caller graph for this function:

client_receive()

static size_t client_receive ( void *  stream, size_t  size, size_t  nmemb, void *  cls  )

static

Callback method used with libcurl when data for a GET request are received.

Forward to MST

Parameters

stream	pointer where to write data
size	size of an individual element
nmemb	count of elements that can be written to the buffer
cls	destination pointer, passed to the libcurl handle

Returns

bytes read from stream

Definition at line 1240 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
  struct GNUNET_TIME_Absolute now;
  size_t len = size * nmemb;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p / request %p: Received %lu bytes from peer `%s'\n",
       s,
       s->get.easyhandle,
       (unsigned long) len,
       GNUNET_i2s (&s->address->peer));
  now = GNUNET_TIME_absolute_get ();
  if (now.abs_value_us < s->next_receive.abs_value_us)
  {
    struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
    struct GNUNET_TIME_Relative delta
      = GNUNET_TIME_absolute_get_difference (now, s->next_receive);
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p / request %p: No inbound bandwidth available! Next read was delayed for %s\n",
         s,
         s->get.easyhandle,
         GNUNET_STRINGS_relative_time_to_string (delta,
                                                 GNUNET_YES));
    if (s->recv_wakeup_task != NULL)
    {
      GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
      s->recv_wakeup_task = NULL;
    }
    s->recv_wakeup_task
      = GNUNET_SCHEDULER_add_delayed (delta,
                                      &client_wake_up,
                                      s);
    return CURL_WRITEFUNC_PAUSE;
  }
  if (NULL == s->msg_tk)
    s->msg_tk = GNUNET_MST_create (&client_receive_mst_cb,
                                   s);
  GNUNET_MST_from_buffer (s->msg_tk,
                          stream,
                          len,
                          GNUNET_NO,
                          GNUNET_NO);
  return len;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_ATS_Session::address, client_receive_mst_cb(), client_wake_up(), delta, RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MST_create(), GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_YES, len, LOG, GNUNET_ATS_Session::msg_tk, GNUNET_ATS_Session::next_receive, GNUNET_HELLO_Address::peer, GNUNET_ATS_Session::recv_wakeup_task, and size.

Referenced by client_connect_get().

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect()

static int client_connect ( struct GNUNET_ATS_Session *  s )

static

Connect both PUT and GET request for a session.

Parameters

s	the session to connect

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1863 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = s->plugin;
  int res = GNUNET_OK;
 
  /* create url */
  if (NULL ==
      http_common_plugin_address_to_string (plugin->protocol,
                                            s->address->address,
                                            s->address->address_length))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Invalid address peer `%s'\n",
         GNUNET_i2s (&s->address->peer));
    return GNUNET_SYSERR;
  }
 
  GNUNET_asprintf (&s->url,
                   "%s/%s;%u",
                   http_common_plugin_address_to_url (NULL,
                                                      s->address->address,
                                                      s->address->address_length),
                   GNUNET_i2s_full (plugin->env->my_identity),
                   plugin->last_tag);
 
  plugin->last_tag++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Initiating outbound session peer `%s' using address `%s'\n",
       GNUNET_i2s (&s->address->peer), s->url);
 
  if (GNUNET_SYSERR == client_connect_get (s))
    return GNUNET_SYSERR;
  /* If we are emulating an XHR client then delay sending a PUT request until
   * there is something to send.
   */
  if (GNUNET_YES == plugin->emulate_xhr)
  {
    s->put.state = H_TMP_DISCONNECTED;
  }
  else if (GNUNET_SYSERR == client_connect_put (s))
    return GNUNET_SYSERR;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p: connected with GET %p and PUT %p\n",
       s, s->get.easyhandle,
       s->put.easyhandle);
  /* Perform connect */
  GNUNET_STATISTICS_set (plugin->env->stats,
                         HTTP_STAT_STR_CONNECTIONS,
                         plugin->cur_requests,
                         GNUNET_NO);
  /* Re-schedule since handles have changed */
  if (NULL != plugin->client_perform_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
    plugin->client_perform_task = NULL;
  }
 
  /* Schedule task to run immediately */
  plugin->client_perform_task = GNUNET_SCHEDULER_add_now (client_run,
                                                          plugin);
  return res;
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, client_connect_get(), client_connect_put(), client_run(), RequestHandle::easyhandle, GNUNET_ATS_Session::get, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_YES, H_TMP_DISCONNECTED, http_common_plugin_address_to_string(), http_common_plugin_address_to_url(), HTTP_STAT_STR_CONNECTIONS, LOG, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, res, RequestHandle::state, and GNUNET_ATS_Session::url.

Referenced by http_client_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

http_client_plugin_get_network()

static enum GNUNET_NetworkType http_client_plugin_get_network ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Function obtain the network type for a session.

Parameters

cls	closure (struct Plugin*)
session	the session

Returns

the network type

Definition at line 1863 of file plugin_transport_http_client.c.

{
  return session->scope;
}

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

http_client_plugin_get_network_for_address()

static enum GNUNET_NetworkType http_client_plugin_get_network_for_address ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Function obtain the network type for an address.

Parameters

cls	closure (struct Plugin *)
address	the address

Returns

the network type

Definition at line 1863 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
 
  return http_common_get_network_for_address (plugin->env,
                                              address);
}

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

client_session_timeout()

static void client_session_timeout ( void *  cls )

static

Session was idle, so disconnect it.

Parameters

cls	the struct GNUNET_ATS_Session of the idle session

Definition at line 1968 of file plugin_transport_http_client.c.

{
  struct GNUNET_ATS_Session *s = cls;
  struct GNUNET_TIME_Relative left;
 
  s->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining (s->timeout);
  if (0 != left.rel_value_us)
  {
    /* not actually our turn yet, but let's at least update
       the monitor, it may think we're about to die ... */
    notify_session_monitor (s->plugin,
                            s,
                            GNUNET_TRANSPORT_SS_UPDATE);
    s->timeout_task = GNUNET_SCHEDULER_add_delayed (left,
                                                    &client_session_timeout,
                                                    s);
    return;
  }
  LOG (TIMEOUT_LOG,
       "Session %p was idle for %s, disconnecting\n",
       s,
       GNUNET_STRINGS_relative_time_to_string (HTTP_CLIENT_SESSION_TIMEOUT,
                                               GNUNET_YES));
  GNUNET_assert (GNUNET_OK ==
                 http_client_plugin_session_disconnect (s->plugin,
                                                        s));
}

References GNUNET_assert, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, http_client_plugin_session_disconnect(), HTTP_CLIENT_SESSION_TIMEOUT, LOG, notify_session_monitor(), GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_Session::timeout, TIMEOUT_LOG, and GNUNET_ATS_Session::timeout_task.

Referenced by http_client_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

http_client_plugin_get_session()

static struct GNUNET_ATS_Session* http_client_plugin_get_session ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Creates a new outbound session the transport service will use to send data to the peer.

Parameters

cls	the plugin
address	the address

Returns

the session or NULL of max connections exceeded

Definition at line 2007 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
  struct GNUNET_ATS_Session *s;
  struct sockaddr *sa;
  enum GNUNET_NetworkType net_type;
  size_t salen = 0;
  int res;
 
  GNUNET_assert (NULL != address->address);
 
  /* find existing session */
  s = client_lookup_session (plugin, address);
  if (NULL != s)
    return s;
 
  /* create a new session */
  if (plugin->max_requests <= plugin->cur_requests)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Maximum number of requests (%u) reached: "
         "cannot connect to peer `%s'\n",
         plugin->max_requests,
         GNUNET_i2s (&address->peer));
    return NULL;
  }
 
  /* Determine network location */
  net_type = GNUNET_NT_UNSPECIFIED;
  sa = http_common_socket_from_address (address->address,
                                        address->address_length,
                                        &res);
  if (GNUNET_SYSERR == res)
    return NULL;
  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 = plugin->env->get_address_type (plugin->env->cls, sa, salen);
    GNUNET_free (sa);
  }
  else if (GNUNET_NO == res)
  {
    /* Cannot convert to sockaddr -> is external hostname */
    net_type = GNUNET_NT_WAN;
  }
  if (GNUNET_NT_UNSPECIFIED == net_type)
  {
    GNUNET_break (0);
    return NULL;
  }
 
  s = GNUNET_new (struct GNUNET_ATS_Session);
  s->plugin = plugin;
  s->address = GNUNET_HELLO_address_copy (address);
  s->scope = net_type;
 
  s->put.state = H_NOT_CONNECTED;
  s->timeout = GNUNET_TIME_relative_to_absolute (HTTP_CLIENT_SESSION_TIMEOUT);
  s->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_CLIENT_SESSION_TIMEOUT,
                                                  &client_session_timeout,
                                                  s);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Created new session %p for `%s' address `%s''\n",
       s,
       http_common_plugin_address_to_string (plugin->protocol,
                                             s->address->address,
                                             s->address->address_length),
       GNUNET_i2s (&s->address->peer));
 
  /* add new session */
  (void) GNUNET_CONTAINER_multipeermap_put (plugin->sessions,
                                            &s->address->peer,
                                            s,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  /* initiate new connection */
  if (GNUNET_SYSERR == client_connect (s))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Cannot connect to peer `%s' address `%s''\n",
         http_common_plugin_address_to_string (plugin->protocol,
                                               s->address->address,
                                               s->address->address_length),
         GNUNET_i2s (&s->address->peer));
    client_delete_session (s);
    return NULL;
  }
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_INIT);
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_UP); /* or handshake? */
  return s;
}

References address, GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, client_connect(), client_delete_session(), client_lookup_session(), client_session_timeout(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_NT_UNSPECIFIED, GNUNET_NT_WAN, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, GNUNET_YES, H_NOT_CONNECTED, HTTP_CLIENT_SESSION_TIMEOUT, http_common_plugin_address_to_string(), http_common_socket_from_address(), LOG, notify_session_monitor(), GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::put, res, GNUNET_ATS_Session::scope, RequestHandle::state, GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

client_start()

static int client_start ( struct HTTP_Client_Plugin *  plugin )

static

Setup http_client plugin.

Parameters

plugin

the plugin handle

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2119 of file plugin_transport_http_client.c.

{
  curl_global_init (CURL_GLOBAL_ALL);
  plugin->curl_multi_handle = curl_multi_init ();
 
  if (NULL == plugin->curl_multi_handle)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ (
           "Could not initialize curl multi handle, failed to start %s plugin!\n"),
         plugin->name);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References _, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG, and plugin.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

http_client_plugin_address_suggested()

static int http_client_plugin_address_suggested ( void *  cls, const void *  addr, size_t  addrlen  )

static

Another peer has suggested an address for this peer and transport plugin.

Check that this could be a valid address. If so, consider adding it to the list of addresses.

Parameters

cls	closure with the struct Plugin
addr	pointer to the address
addrlen	length of addr

Returns

GNUNET_OK if this is a plausible address for this peer and transport; always returns GNUNET_NO (this is the client!)

Definition at line 2149 of file plugin_transport_http_client.c.

{
  /* A HTTP/S client does not have any valid address so:*/
  return GNUNET_NO;
}

References GNUNET_NO.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

libgnunet_plugin_transport_http_client_done()

void* libgnunet_plugin_transport_http_client_done

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	api as closure

Returns

NULL

Definition at line 2165 of file plugin_transport_http_client.c.

{
  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
  struct HTTP_Client_Plugin *plugin = api->cls;
 
  if (NULL == api->cls)
  {
    /* Stub shutdown */
    GNUNET_free (api);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _ ("Shutting down plugin `%s'\n"),
       plugin->name);
  GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                         &destroy_session_cb,
                                         plugin);
  if (NULL != plugin->client_perform_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
    plugin->client_perform_task = NULL;
  }
  if (NULL != plugin->curl_multi_handle)
  {
    curl_multi_cleanup (plugin->curl_multi_handle);
    plugin->curl_multi_handle = NULL;
  }
  curl_global_cleanup ();
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _ ("Shutdown for plugin `%s' complete\n"),
       plugin->name);
  GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
  GNUNET_free (plugin->proxy_hostname);
  GNUNET_free (plugin->proxy_username);
  GNUNET_free (plugin->proxy_password);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References _, GNUNET_TRANSPORT_PluginFunctions::cls, destroy_session_cb(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), LOG, and plugin.

Here is the call graph for this function:

client_configure_plugin()

static int client_configure_plugin ( struct HTTP_Client_Plugin *  plugin )

static

Configure plugin.

Parameters

plugin

the plugin handle

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2213 of file plugin_transport_http_client.c.

{
  unsigned long long max_requests;
  char *proxy_type;
 
  /* Optional parameters */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
                                             plugin->name,
                                             "MAX_CONNECTIONS",
                                             &max_requests))
    max_requests = 128;
  plugin->max_requests = max_requests;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _ ("Maximum number of requests is %u\n"),
       plugin->max_requests);
 
  /* Read proxy configuration */
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                             plugin->name,
                                             "PROXY",
                                             &plugin->proxy_hostname))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Found proxy host: `%s'\n",
         plugin->proxy_hostname);
    /* proxy username */
    if (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                               plugin->name,
                                               "PROXY_USERNAME",
                                               &plugin->proxy_username))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Found proxy username name: `%s'\n",
           plugin->proxy_username);
    }
 
    /* proxy password */
    if (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                               plugin->name,
                                               "PROXY_PASSWORD",
                                               &plugin->proxy_password))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Found proxy password name: `%s'\n",
           plugin->proxy_password);
    }
 
    /* proxy type */
    if (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                               plugin->name,
                                               "PROXY_TYPE",
                                               &proxy_type))
    {
      GNUNET_STRINGS_utf8_toupper (proxy_type, proxy_type);
 
      if (0 == strcmp (proxy_type, "HTTP"))
        plugin->proxytype = CURLPROXY_HTTP;
      else if (0 == strcmp (proxy_type, "SOCKS4"))
        plugin->proxytype = CURLPROXY_SOCKS4;
      else if (0 == strcmp (proxy_type, "SOCKS5"))
        plugin->proxytype = CURLPROXY_SOCKS5;
      else if (0 == strcmp (proxy_type, "SOCKS4A"))
        plugin->proxytype = CURLPROXY_SOCKS4A;
      else if (0 == strcmp (proxy_type, "SOCKS5_HOSTNAME "))
        plugin->proxytype = CURLPROXY_SOCKS5_HOSTNAME;
      else
      {
        LOG (GNUNET_ERROR_TYPE_ERROR,
             _ (
               "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
             proxy_type);
 
        GNUNET_free (proxy_type);
        GNUNET_free (plugin->proxy_hostname);
        plugin->proxy_hostname = NULL;
        GNUNET_free (plugin->proxy_username);
        plugin->proxy_username = NULL;
        GNUNET_free (plugin->proxy_password);
        plugin->proxy_password = NULL;
 
        return GNUNET_SYSERR;
      }
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Found proxy type: `%s'\n",
           proxy_type);
    }
 
    /* proxy http tunneling */
    plugin->proxy_use_httpproxytunnel
      = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                              plugin->name,
                                              "PROXY_HTTP_TUNNELING");
    if (GNUNET_SYSERR == plugin->proxy_use_httpproxytunnel)
      plugin->proxy_use_httpproxytunnel = GNUNET_NO;
 
    GNUNET_free (proxy_type);
  }
 
  /* Should we emulate an XHR client for testing? */
  plugin->emulate_xhr
    = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                            plugin->name,
                                            "EMULATE_XHR");
  return GNUNET_OK;
}

References _, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_utf8_toupper(), GNUNET_SYSERR, LOG, HTTP_Client_Plugin::max_requests, plugin, and proxy_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_client_plugin_address_to_string()

static const char* http_client_plugin_address_to_string ( void *  cls, const void *  addr, size_t  addrlen  )

static

Function to convert an address to a human-readable string.

Parameters

cls	closure
addr	address to convert
addrlen	address length

Returns

res string if conversion was successful, NULL otherwise

Definition at line 2336 of file plugin_transport_http_client.c.

{
  return http_common_plugin_address_to_string (PLUGIN_NAME,
                                               addr,
                                               addrlen);
}

References http_common_plugin_address_to_string(), and PLUGIN_NAME.

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

static void http_client_plugin_update_session_timeout ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session  )

static

Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated

Definition at line 2356 of file plugin_transport_http_client.c.

{
  client_reschedule_session_timeout (session);
}

References client_reschedule_session_timeout().

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

static void http_client_plugin_update_inbound_delay ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  s, struct GNUNET_TIME_Relative  delay  )

static

Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value.

Parameters

cls	closure
peer	which peer was the session for
s	which session is being updated
delay	new delay to use for receiving

Definition at line 2376 of file plugin_transport_http_client.c.

{
  s->next_receive = GNUNET_TIME_relative_to_absolute (delay);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New inbound delay %s\n",
       GNUNET_STRINGS_relative_time_to_string (delay,
                                               GNUNET_NO));
  if (s->recv_wakeup_task != NULL)
  {
    GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
    s->recv_wakeup_task
      = GNUNET_SCHEDULER_add_delayed (delay,
                                      &client_wake_up,
                                      s);
  }
}

References client_wake_up(), delay, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), LOG, GNUNET_ATS_Session::next_receive, and GNUNET_ATS_Session::recv_wakeup_task.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

send_session_info_iter()

static int send_session_info_iter ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Return information about the given session to the monitor callback.

Parameters

cls	the struct Plugin with the monitor callback (sic)
peer	peer we send information about
value	our struct GNUNET_ATS_Session to send information about

Returns

GNUNET_OK (continue to iterate)

Definition at line 2407 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;
 
  notify_session_monitor (plugin,
                          session,
                          GNUNET_TRANSPORT_SS_INIT);
  notify_session_monitor (plugin,
                          session,
                          GNUNET_TRANSPORT_SS_UP); /* FIXME: or handshake? */
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, notify_session_monitor(), plugin, and value.

Referenced by http_client_plugin_setup_monitor(), and template_plugin_setup_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

http_client_plugin_setup_monitor()

static void http_client_plugin_setup_monitor ( void *  cls, GNUNET_TRANSPORT_SessionInfoCallback  sic, void *  sic_cls  )

static

Begin monitoring sessions of a plugin.

There can only be one active monitor per plugin (i.e. if there are multiple monitors, the transport service needs to multiplex the generated events over all of them).

Parameters

cls	closure of the plugin
sic	callback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_cls	closure for sic

Definition at line 2437 of file plugin_transport_http_client.c.

{
  struct HTTP_Client_Plugin *plugin = cls;
 
  plugin->sic = sic;
  plugin->sic_cls = sic_cls;
  if (NULL != sic)
  {
    GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                           &send_session_info_iter,
                                           plugin);
    /* signal end of first iteration */
    sic (sic_cls, NULL, NULL);
  }
}

References GNUNET_CONTAINER_multipeermap_iterate(), plugin, send_session_info_iter(), HTTP_Client_Plugin::sic, and HTTP_Client_Plugin::sic_cls.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_transport_http_client_init()

void* libgnunet_plugin_transport_http_client_init

(

void *

cls

)

Entry point for the plugin.

Definition at line 2460 of file plugin_transport_http_client.c.

{
  struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
  struct GNUNET_TRANSPORT_PluginFunctions *api;
  struct HTTP_Client_Plugin *plugin;
 
  if (NULL == env->receive)
  {
    /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
       initialize the plugin or the API */
    api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
    api->cls = NULL;
    api->address_to_string = &http_client_plugin_address_to_string;
    api->string_to_address = &http_common_plugin_string_to_address;
    api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
    return api;
  }
 
  plugin = GNUNET_new (struct HTTP_Client_Plugin);
  plugin->env = env;
  plugin->sessions = GNUNET_CONTAINER_multipeermap_create (128,
                                                           GNUNET_YES);
  api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
  api->cls = plugin;
  api->send = &http_client_plugin_send;
  api->disconnect_session = &http_client_plugin_session_disconnect;
  api->query_keepalive_factor = &http_client_query_keepalive_factor;
  api->disconnect_peer = &http_client_plugin_peer_disconnect;
  api->check_address = &http_client_plugin_address_suggested;
  api->get_session = &http_client_plugin_get_session;
  api->address_to_string = &http_client_plugin_address_to_string;
  api->string_to_address = &http_common_plugin_string_to_address;
  api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
  api->get_network = &http_client_plugin_get_network;
  api->get_network_for_address = &http_client_plugin_get_network_for_address;
  api->update_session_timeout = &http_client_plugin_update_session_timeout;
  api->update_inbound_delay = &http_client_plugin_update_inbound_delay;
  api->setup_monitor = &http_client_plugin_setup_monitor;
#if BUILD_HTTPS
  plugin->name = "transport-https_client";
  plugin->protocol = "https";
#else
  plugin->name = "transport-http_client";
  plugin->protocol = "http";
#endif
  plugin->last_tag = 1;
 
  if (GNUNET_SYSERR == client_configure_plugin (plugin))
  {
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
  }
 
  /* Start client */
  if (GNUNET_SYSERR == client_start (plugin))
  {
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
  }
  return api;
}

References GNUNET_TRANSPORT_PluginFunctions::address_pretty_printer, GNUNET_TRANSPORT_PluginFunctions::address_to_string, GNUNET_TRANSPORT_PluginFunctions::check_address, client_configure_plugin(), client_start(), GNUNET_TRANSPORT_PluginEnvironment::cls, GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::disconnect_peer, GNUNET_TRANSPORT_PluginFunctions::disconnect_session, env, GNUNET_TRANSPORT_PluginFunctions::get_network, GNUNET_TRANSPORT_PluginFunctions::get_network_for_address, GNUNET_TRANSPORT_PluginFunctions::get_session, GNUNET_CONTAINER_multipeermap_create(), GNUNET_new, GNUNET_SYSERR, GNUNET_YES, http_client_plugin_address_suggested(), http_client_plugin_address_to_string(), http_client_plugin_get_network(), http_client_plugin_get_network_for_address(), http_client_plugin_get_session(), http_client_plugin_peer_disconnect(), http_client_plugin_send(), http_client_plugin_session_disconnect(), http_client_plugin_setup_monitor(), http_client_plugin_update_inbound_delay(), http_client_plugin_update_session_timeout(), http_client_query_keepalive_factor(), http_common_plugin_address_pretty_printer(), http_common_plugin_string_to_address(), LIBGNUNET_PLUGIN_TRANSPORT_DONE, plugin, GNUNET_TRANSPORT_PluginFunctions::query_keepalive_factor, GNUNET_TRANSPORT_PluginFunctions::send, GNUNET_TRANSPORT_PluginFunctions::setup_monitor, GNUNET_TRANSPORT_PluginFunctions::string_to_address, GNUNET_TRANSPORT_PluginFunctions::update_inbound_delay, and GNUNET_TRANSPORT_PluginFunctions::update_session_timeout.

Here is the call graph for this function: