GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions
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_Sessionclient_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_Sessionhttp_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"

◆ HTTP_STAT_STR_CONNECTIONS

#define HTTP_STAT_STR_CONNECTIONS   "# HTTP client connections"

◆ 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

◆ 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:
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442

Definition at line 46 of file plugin_transport_http_client.c.

Referenced by client_send_cb().

◆ 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__)

Enumeration Type Documentation

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

72 {
77 
82 
86  H_PAUSED,
87 
92 
97 
102 
107 };
Paused, nothing to send.
Temporarily disconnected.
Just created, not yet connected.
Temporary disconnect in progress due to inactivity.
Send request while temporary disconnect, reconnect.

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
clsthe struct HTTP_Client_Plugin *
ssession
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 850 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::address, client_delete_session(), HTTP_Client_Plugin::client_perform_task, client_schedule(), GNUNET_TRANSPORT_PluginEnvironment::cls, HTTP_Client_Plugin::env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, LOG, plugin, and GNUNET_TRANSPORT_PluginEnvironment::session_end.

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

852 {
853  struct HTTP_Client_Plugin *plugin = cls;
854 
856  "Session %p: notifying transport about ending session\n",
857  s);
858  plugin->env->session_end (plugin->env->cls,
859  s->address,
860  s);
862 
863  /* Re-schedule since handles have changed */
864  if (NULL != plugin->client_perform_task)
865  {
867  plugin->client_perform_task = NULL;
868  }
869  client_schedule (plugin, GNUNET_YES);
870 
871  return GNUNET_OK;
872 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
GNUNET_TRANSPORT_SessionEnd session_end
Function that must be called by the plugin when a non-NULL session handle stops being valid (is destr...
void * cls
Closure for the various callbacks.
static int client_schedule(struct HTTP_Client_Plugin *plugin, int now)
Function setting up file descriptors and scheduling task to run.
static char * plugin
Solver plugin name as string.
Encapsulation of all of the state of the plugin.
struct GNUNET_SCHEDULER_Task * client_perform_task
curl perform task
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
static void client_delete_session(struct GNUNET_ATS_Session *s)
Delete session s.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
pluginour plugin
sessionsession that changed state
statenew state of the session

Definition at line 413 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::address, GNUNET_TRANSPORT_SessionInfo::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_NO, GNUNET_TRANSPORT_SessionInfo::is_inbound, GNUNET_ATS_Session::msgs_in_queue, GNUNET_ATS_Session::next_receive, GNUNET_TRANSPORT_SessionInfo::num_bytes_pending, GNUNET_TRANSPORT_SessionInfo::num_msg_pending, GNUNET_TRANSPORT_SessionInfo::receive_delay, GNUNET_TRANSPORT_SessionInfo::session_timeout, HTTP_Client_Plugin::sic, HTTP_Client_Plugin::sic_cls, state, GNUNET_TRANSPORT_SessionInfo::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(), send_session_info_iter(), and template_plugin_update_session_timeout().

416 {
417  struct GNUNET_TRANSPORT_SessionInfo info;
418 
419  if (NULL == plugin->sic)
420  return;
421  memset (&info, 0, sizeof(info));
422  info.state = state;
423  info.is_inbound = GNUNET_NO;
424  info.num_msg_pending = session->msgs_in_queue;
425  info.num_bytes_pending = session->bytes_in_queue;
426  info.receive_delay = session->next_receive;
427  info.session_timeout = session->timeout;
428  info.address = session->address;
429  plugin->sic (plugin->sic_cls,
430  session,
431  &info);
432 }
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
struct GNUNET_TIME_Absolute next_receive
Absolute time when to receive data again Used for receive throttling.
Information about a plugin's session.
enum State state
current state of profiling
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
void * sic_cls
Closure for sic.
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
sthe session to delete

Definition at line 441 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, HTTP_Client_Plugin::cur_requests, HTTP_Client_Plugin::curl_multi_handle, RequestHandle::easyhandle, HTTP_Client_Plugin::env, 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, HTTP_Client_Plugin::sessions, HTTP_Message::size, GNUNET_TRANSPORT_PluginEnvironment::stats, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, HTTP_Message::transmit_cont, HTTP_Message::transmit_cont_cls, and GNUNET_ATS_Session::url.

Referenced by http_client_plugin_get_session(), and http_client_plugin_session_disconnect().

442 {
443  struct HTTP_Client_Plugin *plugin = s->plugin;
444  struct HTTP_Message *pos;
445  struct HTTP_Message *next;
446  CURLMcode mret;
447 
448  if (NULL != s->timeout_task)
449  {
451  s->timeout_task = NULL;
453  }
454  if (NULL != s->put_disconnect_task)
455  {
457  s->put_disconnect_task = NULL;
458  }
459  if (NULL != s->recv_wakeup_task)
460  {
462  s->recv_wakeup_task = NULL;
463  }
466  &s->address->peer,
467  s));
468  if (NULL != s->put.easyhandle)
469  {
471  "Session %p/request %p: disconnecting PUT request to peer `%s'\n",
472  s,
473  s->put.easyhandle,
474  GNUNET_i2s (&s->address->peer));
475 
476  /* remove curl handle from multi handle */
477  mret = curl_multi_remove_handle (plugin->curl_multi_handle,
478  s->put.easyhandle);
479  GNUNET_break (CURLM_OK == mret);
480  curl_easy_cleanup (s->put.easyhandle);
481  GNUNET_assert (plugin->cur_requests > 0);
482  plugin->cur_requests--;
483  s->put.easyhandle = NULL;
484  }
485  if (NULL != s->get.easyhandle)
486  {
488  "Session %p/request %p: disconnecting GET request to peer `%s'\n",
489  s, s->get.easyhandle,
490  GNUNET_i2s (&s->address->peer));
491  /* remove curl handle from multi handle */
492  mret = curl_multi_remove_handle (plugin->curl_multi_handle,
493  s->get.easyhandle);
494  GNUNET_break (CURLM_OK == mret);
495  curl_easy_cleanup (s->get.easyhandle);
496  GNUNET_assert (plugin->cur_requests > 0);
497  plugin->cur_requests--;
498  s->get.easyhandle = NULL;
499  }
500 
501  GNUNET_STATISTICS_set (plugin->env->stats,
503  plugin->cur_requests,
504  GNUNET_NO);
505  next = s->msg_head;
506  while (NULL != (pos = next))
507  {
508  next = pos->next;
510  s->msg_tail,
511  pos);
512  GNUNET_assert (0 < s->msgs_in_queue);
513  s->msgs_in_queue--;
514  GNUNET_assert (pos->size <= s->bytes_in_queue);
515  s->bytes_in_queue -= pos->size;
516  if (NULL != pos->transmit_cont)
517  pos->transmit_cont (pos->transmit_cont_cls,
518  &s->address->peer,
520  pos->size,
521  pos->pos + s->overhead);
522  s->overhead = 0;
523  GNUNET_free (pos);
524  }
525  GNUNET_assert (0 == s->msgs_in_queue);
526  GNUNET_assert (0 == s->bytes_in_queue);
527  notify_session_monitor (plugin,
528  s,
530  if (NULL != s->msg_tk)
531  {
533  s->msg_tk = NULL;
534  }
536  GNUNET_free (s->url);
537  GNUNET_free (s);
538 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Session is being torn down and about to disappear.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct GNUNET_SCHEDULER_Task * recv_wakeup_task
Task to wake up client receive handle when receiving is allowed again.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct HTTP_Message * msg_tail
previous pointer for double linked list
struct Plugin * plugin
Pointer to the global plugin struct.
size_t pos
amount of data already sent
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
Message to send using http.
struct GNUNET_SERVER_MessageStreamTokenizer * msg_tk
Message stream tokenizer for incoming data.
struct HTTP_Message * next
next pointer for double linked list
struct GNUNET_TIME_Absolute timeout
When does this session time out.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct RequestHandle get
Handle for the HTTP GET request.
struct HTTP_Message * msg_head
next pointer for double linked list
struct GNUNET_SCHEDULER_Task * put_disconnect_task
Session timeout task.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * transmit_cont_cls
Closure for transmit_cont.
GNUNET_TRANSPORT_TransmitContinuation transmit_cont
Continuation function to call once the transmission buffer has again space available.
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.
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:411
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static char * plugin
Solver plugin name as string.
size_t size
buffer length
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
char * url
The URL to connect to.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Encapsulation of all of the state of the plugin.
unsigned int cur_requests
Current number of sockets the plugin can use Each http connections are two requests.
#define HTTP_STAT_STR_CONNECTIONS
CURLM * curl_multi_handle
cURL Multihandle
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
size_t overhead
Outbound overhead due to HTTP connection Add to next message of this session when calling callback...
#define LOG(kind,...)
CURL * easyhandle
The curl easy handle.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_HELLO_address_free(addr)
Free an address.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
sthe session

Definition at line 547 of file plugin_transport_http_client.c.

References client_run(), 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().

548 {
549  GNUNET_assert (NULL != s->timeout_task);
552 }
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
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
clsplugin as closure
tcgnunet scheduler task context
clsplugin as closure

Definition at line 1299 of file plugin_transport_http_client.c.

References _, GNUNET_ATS_Session::address, address, client_connect_get(), client_connect_put(), HTTP_Client_Plugin::client_perform_task, client_schedule(), HTTP_Client_Plugin::cur_requests, HTTP_Client_Plugin::curl_multi_handle, RequestHandle::easyhandle, HTTP_Client_Plugin::emulate_xhr, HTTP_Client_Plugin::env, GNUNET_ATS_Session::get, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, 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, ret, RequestHandle::s, RequestHandle::state, GNUNET_TRANSPORT_PluginEnvironment::stats, and GNUNET_ATS_Session::url.

Referenced by client_connect(), client_reschedule_session_timeout(), and client_schedule().

1300 {
1301  struct HTTP_Client_Plugin *plugin = cls;
1302  int running;
1303  long http_statuscode;
1304  CURLMcode mret;
1305  CURLMsg *msg;
1306  int put_request; /* GNUNET_YES if easy handle is put, GNUNET_NO for get */
1307  int msgs_left;
1308 
1309  plugin->client_perform_task = NULL;
1310  /* While data are available or timeouts occured */
1311  do
1312  {
1313  running = 0;
1314  /* Perform operations for all handles */
1315  mret = curl_multi_perform (plugin->curl_multi_handle, &running);
1316 
1317  /* Get additional information for all handles */
1318  while (NULL != (msg = curl_multi_info_read (plugin->curl_multi_handle,
1319  &msgs_left)))
1320  {
1321  CURL *easy_h = msg->easy_handle;
1322  struct GNUNET_ATS_Session *s = NULL;
1323  char *d = NULL; /* curl requires 'd' to be a 'char *' */
1324 
1325  GNUNET_assert (NULL != easy_h);
1326 
1327  /* Obtain session from easy handle */
1328  GNUNET_assert (CURLE_OK == curl_easy_getinfo (easy_h, CURLINFO_PRIVATE,
1329  &d));
1330  s = (struct GNUNET_ATS_Session *) d;
1331  GNUNET_assert (NULL != s);
1332 
1333  if (msg->msg != CURLMSG_DONE)
1334  continue; /* This should not happen */
1335 
1336  /* Get HTTP response code */
1337  GNUNET_break (CURLE_OK == curl_easy_getinfo (easy_h,
1338  CURLINFO_RESPONSE_CODE,
1339  &http_statuscode));
1340 
1341  if (easy_h == s->put.easyhandle)
1342  put_request = GNUNET_YES;
1343  else
1344  put_request = GNUNET_NO;
1345 
1346  /* Log status of terminated request */
1347  if ((0 != msg->data.result) || (http_statuscode != 200))
1349  "Session %p/request %p: %s request to `%s' ended with status %i reason %i: `%s'\n",
1350  s, msg->easy_handle,
1351  (GNUNET_YES == put_request) ? "PUT" : "GET",
1352  GNUNET_i2s (&s->address->peer),
1353  http_statuscode,
1354  msg->data.result,
1355  curl_easy_strerror (msg->data.result));
1356  else
1358  "Session %p/request %p: %s request to `%s' ended normal\n",
1359  s, msg->easy_handle,
1360  (GNUNET_YES == put_request) ? "PUT" : "GET",
1361  GNUNET_i2s (&s->address->peer));
1362 
1363  /* Remove easy handle from multi handle */
1364  curl_multi_remove_handle (plugin->curl_multi_handle, easy_h);
1365 
1366  /* Clean up easy handle */
1367  curl_easy_cleanup (easy_h);
1368 
1369  /* Remove information */
1370  GNUNET_assert (plugin->cur_requests > 0);
1371  plugin->cur_requests--;
1373  "%s request to %s done, number of requests decreased to %u\n",
1374  (GNUNET_YES == put_request) ? "PUT" : "GET",
1375  s->url,
1376  plugin->cur_requests);
1377 
1378  if (GNUNET_YES == put_request)
1379  {
1380  /* Clean up a PUT request */
1381  s->put.easyhandle = NULL;
1382  s->put.s = NULL;
1383 
1384  switch (s->put.state)
1385  {
1386  case H_NOT_CONNECTED:
1387  case H_DISCONNECTED:
1388  case H_TMP_DISCONNECTED:
1389  /* This must not happen */
1390  GNUNET_break (0);
1391  break;
1392 
1394  /* Transport called send while disconnect in progess, reconnect */
1395  if (GNUNET_SYSERR == client_connect_put (s))
1396  {
1397  /* Reconnect failed, disconnect session */
1399  }
1400  break;
1401 
1402  case H_TMP_DISCONNECTING:
1403  /* PUT gets temporarily disconnected */
1405  break;
1406 
1407  case H_PAUSED:
1408  case H_CONNECTED:
1409  /* PUT gets permanently disconnected */
1410  s->put.state = H_DISCONNECTED;
1412  break;
1413 
1414  default:
1415  GNUNET_break (0);
1416  break;
1417  }
1418  }
1419  else if (GNUNET_NO == put_request)
1420  {
1421  /* Clean up a GET request */
1422  s->get.easyhandle = NULL;
1423  s->get.s = NULL;
1424 
1425  /* If we are emulating an XHR client we need to make another GET
1426  * request.
1427  */
1428  if (GNUNET_YES == plugin->emulate_xhr)
1429  {
1430  if (GNUNET_SYSERR == client_connect_get (s))
1432  }
1433  else
1434  {
1435  /* GET request was terminated, so disconnect session */
1437  }
1438  }
1439  else
1440  GNUNET_break (0); /* Must not happen */
1441 
1442  GNUNET_STATISTICS_set (plugin->env->stats,
1444  plugin->cur_requests,
1445  GNUNET_NO);
1446  }
1447  }
1448  while (mret == CURLM_CALL_MULTI_PERFORM);
1449  client_schedule (plugin, GNUNET_NO);
1450 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int http_client_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *s)
Disconnect a session.
static int client_connect_get(struct GNUNET_ATS_Session *s)
Connect GET request.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct RequestHandle get
Handle for the HTTP GET request.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Paused, nothing to send.
Temporarily disconnected.
static int client_schedule(struct HTTP_Client_Plugin *plugin, int now)
Function setting up file descriptors and scheduling task to run.
Session handle for connections.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static int client_connect_put(struct GNUNET_ATS_Session *s)
Connect a HTTP put request.
int state
The processing state.
static char * plugin
Solver plugin name as string.
char * url
The URL to connect to.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int emulate_xhr
Should we emulate an XHR client for testing?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Just created, not yet connected.
Encapsulation of all of the state of the plugin.
struct GNUNET_SCHEDULER_Task * client_perform_task
curl perform task
unsigned int cur_requests
Current number of sockets the plugin can use Each http connections are two requests.
#define HTTP_STAT_STR_CONNECTIONS
CURLM * curl_multi_handle
cURL Multihandle
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Temporary disconnect in progress due to inactivity.
struct GNUNET_ATS_Session * s
The related session.
CURL * easyhandle
The curl easy handle.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Send request while temporary disconnect, reconnect.
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
pluginthe plugin as closure
nowschedule task in 1ms, regardless of what curl may say
Returns
GNUNET_SYSERR for hard failure, GNUNET_OK for ok

Definition at line 573 of file plugin_transport_http_client.c.

References _, ch, client_connect_get(), client_connect_put(), HTTP_Client_Plugin::client_perform_task, client_run(), curl, HTTP_Client_Plugin::curl_multi_handle, data, RequestHandle::easyhandle, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_memcpy, 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, GNUNET_ATS_Session::overhead, RequestHandle::s, HTTP_Message::size, and type.

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

575 {
576  fd_set rs;
577  fd_set ws;
578  fd_set es;
579  int max;
580  struct GNUNET_NETWORK_FDSet *grs;
581  struct GNUNET_NETWORK_FDSet *gws;
582  long to;
583  CURLMcode mret;
585 
586  /* Cancel previous scheduled task */
587  if (plugin->client_perform_task != NULL)
588  {
590  plugin->client_perform_task = NULL;
591  }
592  max = -1;
593  FD_ZERO (&rs);
594  FD_ZERO (&ws);
595  FD_ZERO (&es);
596  mret = curl_multi_fdset (plugin->curl_multi_handle, &rs, &ws, &es, &max);
597  if (mret != CURLM_OK)
598  {
600  _ ("%s failed at %s:%d: `%s'\n"),
601  "curl_multi_fdset",
602  __FILE__,
603  __LINE__,
604  curl_multi_strerror (mret));
605  return GNUNET_SYSERR;
606  }
607  mret = curl_multi_timeout (plugin->curl_multi_handle, &to);
608  if (-1 == to)
610  else
612  if (now == GNUNET_YES)
614 
615  if (CURLM_OK != mret)
616  {
618  _ ("%s failed at %s:%d: `%s'\n"),
619  "curl_multi_timeout", __FILE__, __LINE__,
620  curl_multi_strerror (mret));
621  return GNUNET_SYSERR;
622  }
623 
626  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
627  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
628 
629  /* Schedule task to run when select is ready to read or write */
630  plugin->client_perform_task =
632  timeout, grs, gws,
633  &client_run, plugin);
636  return GNUNET_OK;
637 }
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void client_run(void *cls)
Task performing curl operations.
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
Definition: network.c:1120
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
collection of IO descriptors
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1810
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_SCHEDULER_Task * client_perform_task
curl perform task
CURLM * curl_multi_handle
cURL Multihandle
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Run with the default priority (normal P2P operations).
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
sthe session to connect
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1521 of file plugin_transport_http_client.c.

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(), client_run(), and client_schedule().

1522 {
1523  CURLMcode mret;
1524  struct HttpAddress *ha;
1525  uint32_t options;
1526 
1527  ha = (struct HttpAddress *) s->address->address;
1528  options = ntohl (ha->options);
1529  /* create get request */
1530  s->get.easyhandle = curl_easy_init ();
1531  s->get.s = s;
1532  if (0 != (options & HTTP_OPTIONS_TCP_STEALTH))
1533  {
1534 #ifdef TCP_STEALTH
1535  curl_easy_setopt (s->get.easyhandle,
1536  CURLOPT_OPENSOCKETFUNCTION,
1537  &open_tcp_stealth_socket_cb);
1538  curl_easy_setopt (s->get.easyhandle,
1539  CURLOPT_OPENSOCKETDATA,
1540  s);
1541 #else
1543  "Cannot connect, TCP STEALTH needed and not supported by kernel.\n");
1544  curl_easy_cleanup (s->get.easyhandle);
1545  s->get.easyhandle = NULL;
1546  s->get.s = NULL;
1547  return GNUNET_SYSERR;
1548 #endif
1549  }
1550 
1551 #if VERBOSE_CURL
1552  curl_easy_setopt (s->get.easyhandle,
1553  CURLOPT_VERBOSE,
1554  1L);
1555  curl_easy_setopt (s->get.easyhandle,
1556  CURLOPT_DEBUGFUNCTION,
1557  &client_log);
1558  curl_easy_setopt (s->get.easyhandle,
1559  CURLOPT_DEBUGDATA,
1560  &s->get);
1561 #endif
1562 #if BUILD_HTTPS
1563  curl_easy_setopt (s->get.easyhandle, CURLOPT_SSLVERSION,
1564  CURL_SSLVERSION_TLSv1);
1565  {
1567  (options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
1568  {
1569  curl_easy_setopt (s->get.easyhandle,
1570  CURLOPT_SSL_VERIFYPEER, 1L);
1571  curl_easy_setopt (s->get.easyhandle,
1572  CURLOPT_SSL_VERIFYHOST,
1573  2L);
1574  }
1575  else
1576  {
1577  curl_easy_setopt (s->get.easyhandle,
1578  CURLOPT_SSL_VERIFYPEER,
1579  0L);
1580  curl_easy_setopt (s->get.easyhandle,
1581  CURLOPT_SSL_VERIFYHOST,
1582  0L);
1583  }
1584  }
1585  curl_easy_setopt (s->get.easyhandle,
1586  CURLOPT_PROTOCOLS,
1587  CURLPROTO_HTTPS);
1588  curl_easy_setopt (s->get.easyhandle,
1589  CURLOPT_REDIR_PROTOCOLS,
1590  CURLPROTO_HTTPS);
1591 #else
1592  curl_easy_setopt (s->get.easyhandle,
1593  CURLOPT_PROTOCOLS,
1594  CURLPROTO_HTTP);
1595  curl_easy_setopt (s->get.easyhandle,
1596  CURLOPT_REDIR_PROTOCOLS,
1597  CURLPROTO_HTTP);
1598 #endif
1599 
1600  if (NULL != s->plugin->proxy_hostname)
1601  {
1602  curl_easy_setopt (s->get.easyhandle,
1603  CURLOPT_PROXY,
1604  s->plugin->proxy_hostname);
1605  curl_easy_setopt (s->get.easyhandle,
1606  CURLOPT_PROXYTYPE,
1607  s->plugin->proxytype);
1608  if (NULL != s->plugin->proxy_username)
1609  curl_easy_setopt (s->get.easyhandle,
1610  CURLOPT_PROXYUSERNAME,
1611  s->plugin->proxy_username);
1612  if (NULL != s->plugin->proxy_password)
1613  curl_easy_setopt (s->get.easyhandle,
1614  CURLOPT_PROXYPASSWORD,
1615  s->plugin->proxy_password);
1616  if (GNUNET_YES == s->plugin->proxy_use_httpproxytunnel)
1617  curl_easy_setopt (s->get.easyhandle,
1618  CURLOPT_HTTPPROXYTUNNEL,
1619  s->plugin->proxy_use_httpproxytunnel);
1620  }
1621 
1622  if (GNUNET_YES == s->plugin->emulate_xhr)
1623  {
1624  char *url;
1625 
1626  GNUNET_asprintf (&url,
1627  "%s,1",
1628  s->url);
1629  curl_easy_setopt (s->get.easyhandle,
1630  CURLOPT_URL,
1631  url);
1632  GNUNET_free (url);
1633  }
1634  else
1635  {
1636  curl_easy_setopt (s->get.easyhandle,
1637  CURLOPT_URL,
1638  s->url);
1639  }
1640  curl_easy_setopt (s->get.easyhandle,
1641  CURLOPT_READFUNCTION,
1642  &client_send_cb);
1643  curl_easy_setopt (s->get.easyhandle,
1644  CURLOPT_READDATA,
1645  s);
1646  curl_easy_setopt (s->get.easyhandle,
1647  CURLOPT_WRITEFUNCTION,
1648  &client_receive);
1649  curl_easy_setopt (s->get.easyhandle,
1650  CURLOPT_WRITEDATA,
1651  s);
1652  /* No timeout by default, timeout done with session timeout */
1653  curl_easy_setopt (s->get.easyhandle,
1654  CURLOPT_TIMEOUT,
1655  0L);
1656  curl_easy_setopt (s->get.easyhandle,
1657  CURLOPT_PRIVATE, s);
1658  curl_easy_setopt (s->get.easyhandle,
1659  CURLOPT_CONNECTTIMEOUT_MS,
1660  (long) (HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value_us
1661  / 1000LL));
1662  curl_easy_setopt (s->get.easyhandle, CURLOPT_BUFFERSIZE,
1664 #if CURL_TCP_NODELAY
1665  curl_easy_setopt (ps->recv_endpoint,
1666  CURLOPT_TCP_NODELAY,
1667  1L);
1668 #endif
1669  curl_easy_setopt (s->get.easyhandle,
1670  CURLOPT_FOLLOWLOCATION,
1671  0L);
1672 
1673  mret = curl_multi_add_handle (s->plugin->curl_multi_handle,
1674  s->get.easyhandle);
1675  if (CURLM_OK != mret)
1676  {
1678  "Session %p : Failed to add GET handle to multihandle: `%s'\n",
1679  s,
1680  curl_multi_strerror (mret));
1681  curl_easy_cleanup (s->get.easyhandle);
1682  s->get.easyhandle = NULL;
1683  s->get.s = NULL;
1684  GNUNET_break (0);
1685  return GNUNET_SYSERR;
1686  }
1687  s->plugin->cur_requests++;
1689  "GET request `%s' established, number of requests increased to %u\n",
1690  s->url,
1691  s->plugin->cur_requests);
1692  return GNUNET_OK;
1693 }
uint32_t options
Address options see enum HttpAddressOptions
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct Plugin * plugin
Pointer to the global plugin struct.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct RequestHandle get
Handle for the HTTP GET request.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
char * url
The URL to connect to.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT
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.
Enable TCP Stealth-style port knocking.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
#define GNUNET_log(kind,...)
Verify X509 server certificate, it should be valid.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
struct GNUNET_ATS_Session * s
The related session.
CURL * easyhandle
The curl easy handle.
HTTP addresses including a full URI.
#define GNUNET_free(ptr)
Wrapper around free.
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...
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
sthe session to connect
Returns
GNUNET_SYSERR for hard failure, GNUNET_OK for success
Parameters
sthe session to connect
Returns
GNUNET_SYSERR for hard failure, GNUNET_OK for ok

Definition at line 1703 of file plugin_transport_http_client.c.

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(), client_schedule(), and http_client_plugin_send().

1704 {
1705  CURLMcode mret;
1706  struct HttpAddress *ha;
1707  uint32_t options;
1708 
1709  ha = (struct HttpAddress *) s->address->address;
1710  options = ntohl (ha->options);
1711  /* create put request */
1713  "Session %p: Init PUT handle\n",
1714  s);
1715  s->put.easyhandle = curl_easy_init ();
1716  s->put.s = s;
1717 #if VERBOSE_CURL
1718  curl_easy_setopt (s->put.easyhandle,
1719  CURLOPT_VERBOSE,
1720  1L);
1721  curl_easy_setopt (s->put.easyhandle,
1722  CURLOPT_DEBUGFUNCTION,
1723  &client_log);
1724  curl_easy_setopt (s->put.easyhandle,
1725  CURLOPT_DEBUGDATA,
1726  &s->put);
1727 #endif
1728  if (0 != (options & HTTP_OPTIONS_TCP_STEALTH))
1729  {
1730 #ifdef TCP_STEALTH
1731  curl_easy_setopt (s->put.easyhandle,
1732  CURLOPT_OPENSOCKETFUNCTION,
1733  &open_tcp_stealth_socket_cb);
1734  curl_easy_setopt (s->put.easyhandle,
1735  CURLOPT_OPENSOCKETDATA,
1736  s);
1737 #else
1739  "Cannot connect, TCP STEALTH needed and not supported by kernel.\n");
1740  curl_easy_cleanup (s->put.easyhandle);
1741  s->put.easyhandle = NULL;
1742  s->put.s = NULL;
1743  s->put.state = H_DISCONNECTED;
1744  return GNUNET_SYSERR;
1745 #endif
1746  }
1747 #if BUILD_HTTPS
1748  curl_easy_setopt (s->put.easyhandle,
1749  CURLOPT_SSLVERSION,
1750  CURL_SSLVERSION_TLSv1);
1751  {
1752  struct HttpAddress *ha;
1753  ha = (struct HttpAddress *) s->address->address;
1754 
1756  (ntohl (ha->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
1757  {
1758  curl_easy_setopt (s->put.easyhandle,
1759  CURLOPT_SSL_VERIFYPEER,
1760  1L);
1761  curl_easy_setopt (s->put.easyhandle,
1762  CURLOPT_SSL_VERIFYHOST,
1763  2L);
1764  }
1765  else
1766  {
1767  curl_easy_setopt (s->put.easyhandle,
1768  CURLOPT_SSL_VERIFYPEER,
1769  0L);
1770  curl_easy_setopt (s->put.easyhandle,
1771  CURLOPT_SSL_VERIFYHOST,
1772  0L);
1773  }
1774  }
1775  curl_easy_setopt (s->put.easyhandle,
1776  CURLOPT_PROTOCOLS,
1777  CURLPROTO_HTTPS);
1778  curl_easy_setopt (s->put.easyhandle,
1779  CURLOPT_REDIR_PROTOCOLS,
1780  CURLPROTO_HTTPS);
1781 #else
1782  curl_easy_setopt (s->put.easyhandle,
1783  CURLOPT_PROTOCOLS,
1784  CURLPROTO_HTTP);
1785  curl_easy_setopt (s->put.easyhandle,
1786  CURLOPT_REDIR_PROTOCOLS,
1787  CURLPROTO_HTTP);
1788 #endif
1789  if (NULL != s->plugin->proxy_hostname)
1790  {
1791  curl_easy_setopt (s->put.easyhandle,
1792  CURLOPT_PROXY,
1793  s->plugin->proxy_hostname);
1794  curl_easy_setopt (s->put.easyhandle,
1795  CURLOPT_PROXYTYPE,
1796  s->plugin->proxytype);
1797  if (NULL != s->plugin->proxy_username)
1798  curl_easy_setopt (s->put.easyhandle,
1799  CURLOPT_PROXYUSERNAME,
1800  s->plugin->proxy_username);
1801  if (NULL != s->plugin->proxy_password)
1802  curl_easy_setopt (s->put.easyhandle,
1803  CURLOPT_PROXYPASSWORD,
1804  s->plugin->proxy_password);
1805  if (GNUNET_YES == s->plugin->proxy_use_httpproxytunnel)
1806  curl_easy_setopt (s->put.easyhandle,
1807  CURLOPT_HTTPPROXYTUNNEL,
1808  s->plugin->proxy_use_httpproxytunnel);
1809  }
1810 
1811  curl_easy_setopt (s->put.easyhandle,
1812  CURLOPT_URL,
1813  s->url);
1814  curl_easy_setopt (s->put.easyhandle,
1815  CURLOPT_UPLOAD,
1816  1L);
1817  curl_easy_setopt (s->put.easyhandle,
1818  CURLOPT_READFUNCTION,
1819  &client_send_cb);
1820  curl_easy_setopt (s->put.easyhandle,
1821  CURLOPT_READDATA,
1822  s);
1823  curl_easy_setopt (s->put.easyhandle,
1824  CURLOPT_WRITEFUNCTION,
1826  curl_easy_setopt (s->put.easyhandle,
1827  CURLOPT_WRITEDATA,
1828  s);
1829  /* No timeout by default, timeout done with session timeout */
1830  curl_easy_setopt (s->put.easyhandle,
1831  CURLOPT_TIMEOUT,
1832  0L);
1833  curl_easy_setopt (s->put.easyhandle,
1834  CURLOPT_PRIVATE,
1835  s);
1836  curl_easy_setopt (s->put.easyhandle,
1837  CURLOPT_CONNECTTIMEOUT_MS,
1838  (long) (HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value_us
1839  / 1000LL));
1840  curl_easy_setopt (s->put.easyhandle, CURLOPT_BUFFERSIZE,
1842 #if CURL_TCP_NODELAY
1843  curl_easy_setopt (s->put.easyhandle, CURLOPT_TCP_NODELAY, 1);
1844 #endif
1845  mret = curl_multi_add_handle (s->plugin->curl_multi_handle,
1846  s->put.easyhandle);
1847  if (CURLM_OK != mret)
1848  {
1850  "Session %p : Failed to add PUT handle to multihandle: `%s'\n",
1851  s, curl_multi_strerror (mret));
1852  curl_easy_cleanup (s->put.easyhandle);
1853  s->put.easyhandle = NULL;
1854  s->put.s = NULL;
1855  s->put.state = H_DISCONNECTED;
1856  return GNUNET_SYSERR;
1857  }
1858  s->put.state = H_CONNECTED;
1859  s->plugin->cur_requests++;
1860 
1862  "PUT request `%s' established, number of requests increased to %u\n",
1863  s->url, s->plugin->cur_requests);
1864 
1865  return GNUNET_OK;
1866 }
uint32_t options
Address options see enum HttpAddressOptions
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct Plugin * plugin
Pointer to the global plugin struct.
struct RequestHandle put
Handle for the HTTP PUT request.
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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
int state
The processing state.
char * url
The URL to connect to.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define HTTP_CLIENT_NOT_VALIDATED_TIMEOUT
Enable TCP Stealth-style port knocking.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
#define GNUNET_log(kind,...)
Verify X509 server certificate, it should be valid.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
struct GNUNET_ATS_Session * s
The related session.
CURL * easyhandle
The curl easy handle.
HTTP addresses including a full URI.
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...
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
clsclosure
swhich session must be used
msgbufthe message to transmit
msgbuf_sizenumber of bytes in msgbuf
priorityhow important is the message (most plugins will ignore message priority and just FIFO)
tohow 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)
contcontinuation 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_clsclosure 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 758 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::address, HTTP_Message::buf, GNUNET_ATS_Session::bytes_in_queue, client_connect_put(), client_schedule(), RequestHandle::easyhandle, HTTP_Client_Plugin::env, 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, HTTP_Client_Plugin::protocol, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, HTTP_Message::size, RequestHandle::state, GNUNET_TRANSPORT_PluginEnvironment::stats, HTTP_Message::transmit_cont, and HTTP_Message::transmit_cont_cls.

Referenced by libgnunet_plugin_transport_http_client_init().

766 {
767  struct HTTP_Client_Plugin *plugin = cls;
768  struct HTTP_Message *msg;
769  char *stat_txt;
770 
772  "Session %p/request %p: Sending message with %u to peer `%s' \n",
773  s,
774  s->put.easyhandle,
775  msgbuf_size,
776  GNUNET_i2s (&s->address->peer));
777 
778  /* create new message and schedule */
779  msg = GNUNET_malloc (sizeof(struct HTTP_Message) + msgbuf_size);
780  msg->size = msgbuf_size;
781  msg->buf = (char *) &msg[1];
782  msg->transmit_cont = cont;
783  msg->transmit_cont_cls = cont_cls;
784  GNUNET_memcpy (msg->buf,
785  msgbuf,
786  msgbuf_size);
788  s->msg_tail,
789  msg);
790  s->msgs_in_queue++;
791  s->bytes_in_queue += msg->size;
792 
793  GNUNET_asprintf (&stat_txt,
794  "# bytes currently in %s_client buffers",
795  plugin->protocol);
797  stat_txt, msgbuf_size, GNUNET_NO);
798  GNUNET_free (stat_txt);
799  notify_session_monitor (plugin,
800  s,
802  if (H_TMP_DISCONNECTING == s->put.state)
803  {
804  /* PUT request is currently getting disconnected */
807  "Session %p/request %p: currently disconnecting, reconnecting immediately\n",
808  s,
809  s->put.easyhandle);
810  return msgbuf_size;
811  }
812  if (H_PAUSED == s->put.state)
813  {
814  /* PUT request was paused, unpause */
815  GNUNET_assert (s->put_disconnect_task != NULL);
817  s->put_disconnect_task = NULL;
819  "Session %p/request %p: unpausing request\n",
820  s, s->put.easyhandle);
821  s->put.state = H_CONNECTED;
822  if (NULL != s->put.easyhandle)
823  curl_easy_pause (s->put.easyhandle, CURLPAUSE_CONT);
824  }
825  else if (H_TMP_DISCONNECTED == s->put.state)
826  {
827  /* PUT request was disconnected, reconnect */
828  LOG (GNUNET_ERROR_TYPE_DEBUG, "Session %p: Reconnecting PUT request\n", s);
829  GNUNET_break (NULL == s->put.easyhandle);
831  {
832  /* Could not reconnect */
834  return GNUNET_SYSERR;
835  }
836  }
838  return msgbuf_size;
839 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int http_client_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *s)
Disconnect a session.
char * buf
buffer containing data to send
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct HTTP_Message * msg_tail
previous pointer for double linked list
struct Plugin * plugin
Pointer to the global plugin struct.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
Message to send using http.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct HTTP_Message * msg_head
next pointer for double linked list
struct GNUNET_SCHEDULER_Task * put_disconnect_task
Session timeout task.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * transmit_cont_cls
Closure for transmit_cont.
GNUNET_TRANSPORT_TransmitContinuation transmit_cont
Continuation function to call once the transmission buffer has again space available.
Paused, nothing to send.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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.
Temporarily disconnected.
static int client_schedule(struct HTTP_Client_Plugin *plugin, int now)
Function setting up file descriptors and scheduling task to run.
static int client_connect_put(struct GNUNET_ATS_Session *s)
Connect a HTTP put request.
int state
The processing state.
static char * plugin
Solver plugin name as string.
size_t size
buffer length
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Encapsulation of all of the state of the plugin.
This is just an update about the session, the state did not change.
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Temporary disconnect in progress due to inactivity.
CURL * easyhandle
The curl easy handle.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Send request while temporary disconnect, reconnect.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsclosure with the struct Plugin
Returns
keepalive factor

Definition at line 884 of file plugin_transport_http_client.c.

Referenced by libgnunet_plugin_transport_http_client_init().

885 {
886  return 3;
887 }
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
clsthe struct HTTP_Client_Plugin *
peeridentity of the peer
valuethe struct GNUNET_ATS_Session *
Returns
GNUNET_OK (continue iterating)

Definition at line 899 of file plugin_transport_http_client.c.

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

902 {
903  struct HTTP_Client_Plugin *plugin = cls;
904  struct GNUNET_ATS_Session *session = value;
905 
906  http_client_plugin_session_disconnect (plugin, session);
907  return GNUNET_OK;
908 }
static int http_client_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *s)
Disconnect a session.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * value
Value of the record to add/remove.
Session handle for connections.
static char * plugin
Solver plugin name as string.
Encapsulation of all of the state of the plugin.
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
clsclosure
targetpeer from which to disconnect

Definition at line 920 of file plugin_transport_http_client.c.

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

Referenced by libgnunet_plugin_transport_http_client_init().

922 {
923  struct HTTP_Client_Plugin *plugin = cls;
924 
926  "Transport tells me to disconnect `%s'\n",
927  GNUNET_i2s (target));
929  target,
931  plugin);
932 }
static int destroy_session_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Callback to destroys all sessions on exit.
static char * plugin
Solver plugin name as string.
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
Encapsulation of all of the state of the plugin.
#define LOG(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
clsthe struct GNUNET_ATS_SessionClientCtx *
keypeer identity
valuethe struct GNUNET_ATS_Session to check
Returns
GNUNET_NO if found, GNUNET_OK if not

Definition at line 961 of file plugin_transport_http_client.c.

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

964 {
965  struct GNUNET_ATS_SessionClientCtx *sc_ctx = cls;
966  struct GNUNET_ATS_Session *s = value;
967 
968  if (0 == GNUNET_HELLO_address_cmp (sc_ctx->address,
969  s->address))
970  {
971  sc_ctx->ret = s;
972  return GNUNET_NO;
973  }
974  return GNUNET_YES;
975 }
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
const struct GNUNET_HELLO_Address * address
Address we are looking for.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
static char * value
Value of the record to add/remove.
Session handle for connections.
Closure for session_lookup_client_by_address().
struct GNUNET_ATS_Session * ret
Session that was found.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
pluginthe plugin
addressthe address
Returns
the session or NULL

Definition at line 986 of file plugin_transport_http_client.c.

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

Referenced by http_client_plugin_get_session().

988 {
989  struct GNUNET_ATS_SessionClientCtx sc_ctx;
990 
991  sc_ctx.address = address;
992  sc_ctx.ret = NULL;
995  &sc_ctx);
996  return sc_ctx.ret;
997 }
const struct GNUNET_HELLO_Address * address
Address we are looking for.
static int session_lookup_client_by_address(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Locate the seession object for a given address.
Closure for session_lookup_client_by_address().
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
static char * address
GNS address for this phone.
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
clsthe struct GNUNET_ATS_Session * with the put

Definition at line 1008 of file plugin_transport_http_client.c.

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

1009 {
1010  struct GNUNET_ATS_Session *s = cls;
1011 
1012  s->put_disconnect_task = NULL;
1014  "Session %p/request %p: will be disconnected due to no activity\n",
1015  s, s->put.easyhandle);
1017  if (NULL != s->put.easyhandle)
1018  curl_easy_pause (s->put.easyhandle,
1019  CURLPAUSE_CONT);
1021 }
struct Plugin * plugin
Pointer to the global plugin struct.
struct RequestHandle put
Handle for the HTTP PUT request.
struct GNUNET_SCHEDULER_Task * put_disconnect_task
Session timeout task.
static int client_schedule(struct HTTP_Client_Plugin *plugin, int now)
Function setting up file descriptors and scheduling task to run.
Session handle for connections.
int state
The processing state.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Temporary disconnect in progress due to inactivity.
CURL * easyhandle
The curl easy handle.
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
streampointer where to write data
sizesize of an individual element
nmembcount of elements that can be written to the buffer
clsour struct GNUNET_ATS_Session
Returns
bytes written to stream, returning 0 will terminate request!

Definition at line 1035 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::address, HTTP_Message::buf, GNUNET_ATS_Session::bytes_in_queue, client_put_disconnect(), RequestHandle::easyhandle, HTTP_Client_Plugin::emulate_xhr, HTTP_Client_Plugin::env, 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, HTTP_Message::pos, HTTP_Client_Plugin::protocol, GNUNET_ATS_Session::put, GNUNET_ATS_Session::put_disconnect_task, PUT_DISCONNECT_TIMEOUT, HTTP_Message::size, RequestHandle::state, GNUNET_TRANSPORT_PluginEnvironment::stats, HTTP_Message::transmit_cont, and HTTP_Message::transmit_cont_cls.

Referenced by client_connect_get(), and client_connect_put().

1039 {
1040  struct GNUNET_ATS_Session *s = cls;
1041  struct HTTP_Client_Plugin *plugin = s->plugin;
1042  struct HTTP_Message *msg = s->msg_head;
1043  size_t len;
1044  char *stat_txt;
1045 
1046  if (H_TMP_DISCONNECTING == s->put.state)
1047  {
1049  "Session %p/request %p: disconnect due to inactivity\n",
1050  s, s->put.easyhandle);
1051  return 0;
1052  }
1053 
1054  if (NULL == msg)
1055  {
1056  if (GNUNET_YES == plugin->emulate_xhr)
1057  {
1059  "Session %p/request %p: PUT request finished\n",
1060  s,
1061  s->put.easyhandle);
1063  return 0;
1064  }
1065 
1066  /* We have nothing to send, so pause PUT request */
1068  "Session %p/request %p: nothing to send, suspending\n",
1069  s,
1070  s->put.easyhandle);
1074  s);
1075  s->put.state = H_PAUSED;
1076  return CURL_READFUNC_PAUSE;
1077  }
1078  /* data to send */
1079  GNUNET_assert (msg->pos < msg->size);
1080  /* calculate how much fits in buffer */
1081  len = GNUNET_MIN (msg->size - msg->pos,
1082  size * nmemb);
1083  GNUNET_memcpy (stream,
1084  &msg->buf[msg->pos],
1085  len);
1086  msg->pos += len;
1087  if (msg->pos == msg->size)
1088  {
1090  "Session %p/request %p: sent message with %u bytes sent, removing message from queue\n",
1091  s,
1092  s->put.easyhandle,
1093  msg->size,
1094  msg->pos);
1095  /* Calling transmit continuation */
1097  s->msg_tail,
1098  msg);
1099  GNUNET_assert (0 < s->msgs_in_queue);
1100  s->msgs_in_queue--;
1101  GNUNET_assert (msg->size <= s->bytes_in_queue);
1102  s->bytes_in_queue -= msg->size;
1103  if (NULL != msg->transmit_cont)
1104  msg->transmit_cont (msg->transmit_cont_cls,
1105  &s->address->peer,
1106  GNUNET_OK,
1107  msg->size,
1108  msg->size + s->overhead);
1109  s->overhead = 0;
1110  GNUNET_free (msg);
1111  }
1112  notify_session_monitor (plugin,
1113  s,
1115  GNUNET_asprintf (&stat_txt,
1116  "# bytes currently in %s_client buffers",
1117  plugin->protocol);
1119  stat_txt,
1120  -len,
1121  GNUNET_NO);
1122  GNUNET_free (stat_txt);
1123  GNUNET_asprintf (&stat_txt,
1124  "# bytes transmitted via %s_client",
1125  plugin->protocol);
1127  stat_txt,
1128  len,
1129  GNUNET_NO);
1130  GNUNET_free (stat_txt);
1131  return len;
1132 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
char * buf
buffer containing data to send
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct HTTP_Message * msg_tail
previous pointer for double linked list
struct Plugin * plugin
Pointer to the global plugin struct.
#define PUT_DISCONNECT_TIMEOUT
size_t pos
amount of data already sent
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
Message to send using http.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct HTTP_Message * msg_head
next pointer for double linked list
struct GNUNET_SCHEDULER_Task * put_disconnect_task
Session timeout task.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
void * transmit_cont_cls
Closure for transmit_cont.
GNUNET_TRANSPORT_TransmitContinuation transmit_cont
Continuation function to call once the transmission buffer has again space available.
Paused, nothing to send.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
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.
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)...
Session handle for connections.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
int state
The processing state.
static char * plugin
Solver plugin name as string.
size_t size
buffer length
static unsigned int size
Size of the "table".
Definition: peer.c:67
int emulate_xhr
Should we emulate an XHR client for testing?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Encapsulation of all of the state of the plugin.
This is just an update about the session, the state did not change.
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
size_t overhead
Outbound overhead due to HTTP connection Add to next message of this session when calling callback...
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Temporary disconnect in progress due to inactivity.
CURL * easyhandle
The curl easy handle.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_wake_up()

static void client_wake_up ( void *  cls)
static

Wake up a curl handle which was suspended.

Parameters
clsthe session

Definition at line 1141 of file plugin_transport_http_client.c.

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

1142 {
1143  struct GNUNET_ATS_Session *s = cls;
1144 
1145  s->recv_wakeup_task = NULL;
1147  "Session %p/request %p: Waking up GET handle\n",
1148  s, s->get.easyhandle);
1149  if (H_PAUSED == s->put.state)
1150  {
1151  /* PUT request was paused, unpause */
1152  GNUNET_assert (s->put_disconnect_task != NULL);
1154  s->put_disconnect_task = NULL;
1155  s->put.state = H_CONNECTED;
1156  if (NULL != s->put.easyhandle)
1157  curl_easy_pause (s->put.easyhandle, CURLPAUSE_CONT);
1158  }
1159  if (NULL != s->get.easyhandle)
1160  curl_easy_pause (s->get.easyhandle, CURLPAUSE_CONT);
1161 }
struct GNUNET_SCHEDULER_Task * recv_wakeup_task
Task to wake up client receive handle when receiving is allowed again.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
struct RequestHandle get
Handle for the HTTP GET request.
struct GNUNET_SCHEDULER_Task * put_disconnect_task
Session timeout task.
Paused, nothing to send.
Session handle for connections.
int state
The processing state.
#define LOG(kind,...)
CURL * easyhandle
The curl easy handle.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsthe session
messagethe message received
Returns
always GNUNET_OK

Definition at line 1172 of file plugin_transport_http_client.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, client_reschedule_session_timeout(), GNUNET_TRANSPORT_PluginEnvironment::cls, Plugin::env, HTTP_Client_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, HTTP_Client_Plugin::protocol, GNUNET_MessageHeader::size, and GNUNET_TRANSPORT_PluginEnvironment::stats.

Referenced by client_receive().

1174 {
1175  struct GNUNET_ATS_Session *s = cls;
1176  struct HTTP_Client_Plugin *plugin;
1177  struct GNUNET_TIME_Relative delay;
1178  char *stat_txt;
1179 
1180  plugin = s->plugin;
1181  delay = s->plugin->env->receive (plugin->env->cls,
1182  s->address,
1183  s,
1184  message);
1185  GNUNET_asprintf (&stat_txt,
1186  "# bytes received via %s_client",
1187  plugin->protocol);
1189  stat_txt,
1190  ntohs (message->size),
1191  GNUNET_NO);
1192  GNUNET_free (stat_txt);
1193 
1195  if (GNUNET_TIME_absolute_get ().abs_value_us < s->next_receive.abs_value_us)
1196  {
1198  "Client: peer `%s' address `%s' next read delayed for %s\n",
1199  GNUNET_i2s (&s->address->peer),
1201  s->address->address,
1202  s->address->address_length),
1204  GNUNET_YES));
1205  }
1207  return GNUNET_OK;
1208 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
char * protocol
Plugin protocol http, https.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
uint64_t abs_value_us
The actual value.
struct GNUNET_TIME_Absolute next_receive
Absolute time when to receive data again Used for receive throttling.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
void * cls
Closure for the various callbacks.
Session handle for connections.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
static char * plugin
Solver plugin name as string.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static void client_reschedule_session_timeout(struct GNUNET_ATS_Session *s)
Increment session timeout due to activity for session s.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Encapsulation of all of the state of the plugin.
const char * http_common_plugin_address_to_string(const char *plugin, const void *addr, size_t addrlen)
Function called for a quick conversion of the binary address to a numeric address.
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
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
streampointer where to write data
sizesize of an individual element
nmembcount of elements that can be written to the buffer
clsdestination pointer, passed to the libcurl handle
Returns
bytes read from stream

Definition at line 1222 of file plugin_transport_http_client.c.

Referenced by client_connect_put().

1226 {
1227  return size * nmemb;
1228 }
static unsigned int size
Size of the "table".
Definition: peer.c:67
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
streampointer where to write data
sizesize of an individual element
nmembcount of elements that can be written to the buffer
clsdestination pointer, passed to the libcurl handle
Returns
bytes read from stream

Definition at line 1242 of file plugin_transport_http_client.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_ATS_Session::address, client_receive_mst_cb(), client_wake_up(), 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, and GNUNET_ATS_Session::recv_wakeup_task.

Referenced by client_connect_get().

1246 {
1247  struct GNUNET_ATS_Session *s = cls;
1248  struct GNUNET_TIME_Absolute now;
1249  size_t len = size * nmemb;
1250 
1252  "Session %p / request %p: Received %u bytes from peer `%s'\n",
1253  s,
1254  s->get.easyhandle,
1255  len,
1256  GNUNET_i2s (&s->address->peer));
1257  now = GNUNET_TIME_absolute_get ();
1258  if (now.abs_value_us < s->next_receive.abs_value_us)
1259  {
1263 
1265  "Session %p / request %p: No inbound bandwidth available! Next read was delayed for %s\n",
1266  s,
1267  s->get.easyhandle,
1269  GNUNET_YES));
1270  if (s->recv_wakeup_task != NULL)
1271  {
1273  s->recv_wakeup_task = NULL;
1274  }
1275  s->recv_wakeup_task
1277  &client_wake_up,
1278  s);
1279  return CURL_WRITEFUNC_PAUSE;
1280  }
1281  if (NULL == s->msg_tk)
1283  s);
1285  stream,
1286  len,
1287  GNUNET_NO,
1288  GNUNET_NO);
1289  return len;
1290 }
static int client_receive_mst_cb(void *cls, const struct GNUNET_MessageHeader *message)
Callback for message stream tokenizer.
struct GNUNET_SCHEDULER_Task * recv_wakeup_task
Task to wake up client receive handle when receiving is allowed again.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
struct GNUNET_SERVER_MessageStreamTokenizer * msg_tk
Message stream tokenizer for incoming data.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
static void client_wake_up(void *cls)
Wake up a curl handle which was suspended.
struct RequestHandle get
Handle for the HTTP GET request.
uint64_t abs_value_us
The actual value.
struct GNUNET_TIME_Absolute next_receive
Absolute time when to receive data again Used for receive throttling.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
Session handle for connections.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:85
int GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:114
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:354
#define LOG(kind,...)
CURL * easyhandle
The curl easy handle.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Time for relative time used by GNUnet, in microseconds.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
sthe session to connect
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1876 of file plugin_transport_http_client.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, client_connect_get(), client_connect_put(), HTTP_Client_Plugin::client_perform_task, client_run(), HTTP_Client_Plugin::cur_requests, RequestHandle::easyhandle, HTTP_Client_Plugin::emulate_xhr, HTTP_Client_Plugin::env, 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, HTTP_Client_Plugin::last_tag, LOG, GNUNET_TRANSPORT_PluginEnvironment::my_identity, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, HTTP_Client_Plugin::protocol, GNUNET_ATS_Session::put, res, RequestHandle::state, GNUNET_TRANSPORT_PluginEnvironment::stats, and GNUNET_ATS_Session::url.

Referenced by http_client_plugin_get_session().

1877 {
1878  struct HTTP_Client_Plugin *plugin = s->plugin;
1879  int res = GNUNET_OK;
1880 
1881  /* create url */
1882  if (NULL ==
1884  s->address->address,
1885  s->address->address_length))
1886  {
1888  "Invalid address peer `%s'\n",
1889  GNUNET_i2s (&s->address->peer));
1890  return GNUNET_SYSERR;
1891  }
1892 
1893  GNUNET_asprintf (&s->url,
1894  "%s/%s;%u",
1896  s->address->address,
1897  s->address->address_length),
1898  GNUNET_i2s_full (plugin->env->my_identity),
1899  plugin->last_tag);
1900 
1901  plugin->last_tag++;
1903  "Initiating outbound session peer `%s' using address `%s'\n",
1904  GNUNET_i2s (&s->address->peer), s->url);
1905 
1906  if (GNUNET_SYSERR == client_connect_get (s))
1907  return GNUNET_SYSERR;
1908  /* If we are emulating an XHR client then delay sending a PUT request until
1909  * there is something to send.
1910  */
1911  if (GNUNET_YES == plugin->emulate_xhr)
1912  {
1914  }
1915  else if (GNUNET_SYSERR == client_connect_put (s))
1916  return GNUNET_SYSERR;
1917 
1919  "Session %p: connected with GET %p and PUT %p\n",
1920  s, s->get.easyhandle,
1921  s->put.easyhandle);
1922  /* Perform connect */
1923  GNUNET_STATISTICS_set (plugin->env->stats,
1925  plugin->cur_requests,
1926  GNUNET_NO);
1927  /* Re-schedule since handles have changed */
1928  if (NULL != plugin->client_perform_task)
1929  {
1931  plugin->client_perform_task = NULL;
1932  }
1933 
1934  /* Schedule task to run immediately */
1936  plugin);
1937  return res;
1938 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
uint32_t last_tag
Last used unique HTTP connection tag.
struct Plugin * plugin
Pointer to the global plugin struct.
const char * http_common_plugin_address_to_url(void *cls, const void *addr, size_t addrlen)
FIXME.
static int client_connect_get(struct GNUNET_ATS_Session *s)
Connect GET request.
struct RequestHandle put
Handle for the HTTP PUT request.
const struct GNUNET_PeerIdentity * my_identity
Identity of this peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void client_run(void *cls)
Task performing curl operations.
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct RequestHandle get
Handle for the HTTP GET request.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Temporarily disconnected.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static int client_connect_put(struct GNUNET_ATS_Session *s)
Connect a HTTP put request.
int state
The processing state.
static int res
static char * plugin
Solver plugin name as string.
char * url
The URL to connect to.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int emulate_xhr
Should we emulate an XHR client for testing?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Encapsulation of all of the state of the plugin.
const char * http_common_plugin_address_to_string(const char *plugin, const void *addr, size_t addrlen)
Function called for a quick conversion of the binary address to a numeric address.
struct GNUNET_SCHEDULER_Task * client_perform_task
curl perform task
unsigned int cur_requests
Current number of sockets the plugin can use Each http connections are two requests.
#define HTTP_STAT_STR_CONNECTIONS
struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
CURL * easyhandle
The curl easy handle.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsclosure (struct Plugin*)
sessionthe session
Returns
the network type

Definition at line 1949 of file plugin_transport_http_client.c.

References GNUNET_ATS_Session::scope.

Referenced by libgnunet_plugin_transport_http_client_init().

1951 {
1952  return session->scope;
1953 }
enum GNUNET_NetworkType scope
ATS network type.
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
clsclosure (struct Plugin *)
addressthe address
Returns
the network type

Definition at line 1964 of file plugin_transport_http_client.c.

References HTTP_Client_Plugin::env, http_common_get_network_for_address(), and plugin.

Referenced by libgnunet_plugin_transport_http_client_init().

1967 {
1968  struct HTTP_Client_Plugin *plugin = cls;
1969 
1970  return http_common_get_network_for_address (plugin->env,
1971  address);
1972 }
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
static char * plugin
Solver plugin name as string.
Encapsulation of all of the state of the plugin.
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.
Here is the call graph for this function:
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
clsthe struct GNUNET_ATS_Session of the idle session

Definition at line 1981 of file plugin_transport_http_client.c.

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

1982 {
1983  struct GNUNET_ATS_Session *s = cls;
1984  struct GNUNET_TIME_Relative left;
1985 
1986  s->timeout_task = NULL;
1988  if (0 != left.rel_value_us)
1989  {
1990  /* not actually our turn yet, but let's at least update
1991  the monitor, it may think we're about to die ... */
1993  s,
1997  s);
1998  return;
1999  }
2000  LOG (TIMEOUT_LOG,
2001  "Session %p was idle for %s, disconnecting\n",
2002  s,
2004  GNUNET_YES));
2007  s));
2008 }
#define HTTP_CLIENT_SESSION_TIMEOUT
static int http_client_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *s)
Disconnect a session.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct Plugin * plugin
Pointer to the global plugin struct.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void client_session_timeout(void *cls)
Session was idle, so disconnect it.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
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.
Session handle for connections.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
This is just an update about the session, the state did not change.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
#define TIMEOUT_LOG
Time for relative time used by GNUnet, in microseconds.
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
clsthe plugin
addressthe address
Returns
the session or NULL of max connections exceeded

Definition at line 2020 of file plugin_transport_http_client.c.

References 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_TRANSPORT_PluginEnvironment::cls, HTTP_Client_Plugin::cur_requests, HTTP_Client_Plugin::env, GNUNET_TRANSPORT_PluginEnvironment::get_address_type, 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, HTTP_Client_Plugin::max_requests, notify_session_monitor(), GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, HTTP_Client_Plugin::protocol, GNUNET_ATS_Session::put, res, GNUNET_ATS_Session::scope, HTTP_Client_Plugin::sessions, RequestHandle::state, GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by libgnunet_plugin_transport_http_client_init().

2022 {
2023  struct HTTP_Client_Plugin *plugin = cls;
2024  struct GNUNET_ATS_Session *s;
2025  struct sockaddr *sa;
2026  enum GNUNET_NetworkType net_type;
2027  size_t salen = 0;
2028  int res;
2029 
2030  GNUNET_assert (NULL != address->address);
2031 
2032  /* find existing session */
2033  s = client_lookup_session (plugin, address);
2034  if (NULL != s)
2035  return s;
2036 
2037  /* create a new session */
2038  if (plugin->max_requests <= plugin->cur_requests)
2039  {
2041  "Maximum number of requests (%u) reached: "
2042  "cannot connect to peer `%s'\n",
2043  plugin->max_requests,
2044  GNUNET_i2s (&address->peer));
2045  return NULL;
2046  }
2047 
2048  /* Determine network location */
2049  net_type = GNUNET_NT_UNSPECIFIED;
2051  address->address_length,
2052  &res);
2053  if (GNUNET_SYSERR == res)
2054  return NULL;
2055  if (GNUNET_YES == res)
2056  {
2057  GNUNET_assert (NULL != sa);
2058  if (AF_INET == sa->sa_family)
2059  {
2060  salen = sizeof(struct sockaddr_in);
2061  }
2062  else if (AF_INET6 == sa->sa_family)
2063  {
2064  salen = sizeof(struct sockaddr_in6);
2065  }
2066  net_type = plugin->env->get_address_type (plugin->env->cls, sa, salen);
2067  GNUNET_free (sa);
2068  }
2069  else if (GNUNET_NO == res)
2070  {
2071  /* Cannot convert to sockaddr -> is external hostname */
2072  net_type = GNUNET_NT_WAN;
2073  }
2074  if (GNUNET_NT_UNSPECIFIED == net_type)
2075  {
2076  GNUNET_break (0);
2077  return NULL;
2078  }
2079 
2080  s = GNUNET_new (struct GNUNET_ATS_Session);
2081  s->plugin = plugin;
2082  s->address = GNUNET_HELLO_address_copy (address);
2083  s->scope = net_type;
2084 
2085  s->put.state = H_NOT_CONNECTED;
2089  s);
2091  "Created new session %p for `%s' address `%s''\n",
2092  s,
2094  s->address->address,
2095  s->address->address_length),
2096  GNUNET_i2s (&s->address->peer));
2097 
2098  /* add new session */
2100  &s->address->peer,
2101  s,
2103  /* initiate new connection */
2104  if (GNUNET_SYSERR == client_connect (s))
2105  {
2107  "Cannot connect to peer `%s' address `%s''\n",
2109  s->address->address,
2110  s->address->address_length),
2111  GNUNET_i2s (&s->address->peer));
2113  return NULL;
2114  }
2115  notify_session_monitor (plugin,
2116  s,
2118  notify_session_monitor (plugin,
2119  s,
2120  GNUNET_TRANSPORT_SS_UP); /* or handshake? */
2121  return s;
2122 }
size_t address_length
Number of bytes in address.
#define HTTP_CLIENT_SESSION_TIMEOUT
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct Plugin * plugin
Pointer to the global plugin struct.
GNUNET_TRANSPORT_AddressToType get_address_type
Function that will be called to figure if an address is an loopback, LAN, WAN etc.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct RequestHandle put
Handle for the HTTP PUT request.
static void client_session_timeout(void *cls)
Session was idle, so disconnect it.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
Wide area network (i.e.
Definition: gnunet_nt_lib.h:55
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
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.
void * cls
Closure for the various callbacks.
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.
Session handle for connections.
int state
The processing state.
static int res
static char * plugin
Solver plugin name as string.
static int client_connect(struct GNUNET_ATS_Session *s)
Connect both PUT and GET request for a session.
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
enum GNUNET_NetworkType scope
ATS network type.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Just created, not yet connected.
Encapsulation of all of the state of the plugin.
Allow multiple values with the same key.
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.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct sockaddr * http_common_socket_from_address(const void *addr, size_t addrlen, int *res)
Create a socketaddr from a HTTP address.
unsigned int cur_requests
Current number of sockets the plugin can use Each http connections are two requests.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
The session was created (first call for each session object).
unsigned int max_requests
Maximum number of sockets the plugin can use Each http connections are two requests.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
Category of last resort.
Definition: gnunet_nt_lib.h:40
static void client_delete_session(struct GNUNET_ATS_Session *s)
Delete session s.
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
pluginthe plugin handle
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2132 of file plugin_transport_http_client.c.

References _, HTTP_Client_Plugin::curl_multi_handle, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG, and HTTP_Client_Plugin::name.

Referenced by libgnunet_plugin_transport_http_client_init().

2133 {
2134  curl_global_init (CURL_GLOBAL_ALL);
2135  plugin->curl_multi_handle = curl_multi_init ();
2136 
2137  if (NULL == plugin->curl_multi_handle)
2138  {
2140  _ (
2141  "Could not initialize curl multi handle, failed to start %s plugin!\n"),
2142  plugin->name);
2143  return GNUNET_SYSERR;
2144  }
2145  return GNUNET_OK;
2146 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
CURLM * curl_multi_handle
cURL Multihandle
#define LOG(kind,...)
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
clsclosure with the struct Plugin
addrpointer to the address
addrlenlength 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 2162 of file plugin_transport_http_client.c.

References GNUNET_NO.

Referenced by libgnunet_plugin_transport_http_client_init().

2165 {
2166  /* A HTTP/S client does not have any valid address so:*/
2167  return GNUNET_NO;
2168 }
#define GNUNET_NO
Definition: gnunet_common.h:78
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
clsapi as closure
Returns
NULL

Definition at line 2178 of file plugin_transport_http_client.c.

References _, HTTP_Client_Plugin::client_perform_task, GNUNET_TRANSPORT_PluginFunctions::cls, HTTP_Client_Plugin::curl_multi_handle, destroy_session_cb(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, GNUNET_SCHEDULER_cancel(), LOG, HTTP_Client_Plugin::name, plugin, HTTP_Client_Plugin::proxy_hostname, HTTP_Client_Plugin::proxy_password, HTTP_Client_Plugin::proxy_username, and HTTP_Client_Plugin::sessions.

2179 {
2180  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
2181  struct HTTP_Client_Plugin *plugin = api->cls;
2182 
2183  if (NULL == api->cls)
2184  {
2185  /* Stub shutdown */
2186  GNUNET_free (api);
2187  return NULL;
2188  }
2190  _ ("Shutting down plugin `%s'\n"),
2191  plugin->name);
2194  plugin);
2195  if (NULL != plugin->client_perform_task)
2196  {
2198  plugin->client_perform_task = NULL;
2199  }
2200  if (NULL != plugin->curl_multi_handle)
2201  {
2202  curl_multi_cleanup (plugin->curl_multi_handle);
2203  plugin->curl_multi_handle = NULL;
2204  }
2205  curl_global_cleanup ();
2207  _ ("Shutdown for plugin `%s' complete\n"),
2208  plugin->name);
2213  GNUNET_free (plugin);
2214  GNUNET_free (api);
2215  return NULL;
2216 }
char * proxy_username
Username for the proxy server.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
void * cls
Closure for all of the callbacks.
static int destroy_session_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Callback to destroys all sessions on exit.
static char * plugin
Solver plugin name as string.
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
Encapsulation of all of the state of the plugin.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_SCHEDULER_Task * client_perform_task
curl perform task
CURLM * curl_multi_handle
cURL Multihandle
char * proxy_hostname
Proxy configuration: hostname or ip of the proxy server.
#define LOG(kind,...)
char * proxy_password
Password for the proxy server.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
pluginthe plugin handle
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2226 of file plugin_transport_http_client.c.

References _, GNUNET_TRANSPORT_PluginEnvironment::cfg, HTTP_Client_Plugin::emulate_xhr, HTTP_Client_Plugin::env, 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_free_non_null, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_utf8_toupper(), GNUNET_SYSERR, LOG, HTTP_Client_Plugin::max_requests, HTTP_Client_Plugin::name, HTTP_Client_Plugin::proxy_hostname, HTTP_Client_Plugin::proxy_password, proxy_type, HTTP_Client_Plugin::proxy_use_httpproxytunnel, HTTP_Client_Plugin::proxy_username, and HTTP_Client_Plugin::proxytype.

Referenced by libgnunet_plugin_transport_http_client_init().

2227 {
2228  unsigned long long max_requests;
2229  char *proxy_type;
2230 
2231  /* Optional parameters */
2232  if (GNUNET_OK !=
2234  plugin->name,
2235  "MAX_CONNECTIONS",
2236  &max_requests))
2237  max_requests = 128;
2238  plugin->max_requests = max_requests;
2239 
2241  _ ("Maximum number of requests is %u\n"),
2242  plugin->max_requests);
2243 
2244  /* Read proxy configuration */
2245  if (GNUNET_OK ==
2247  plugin->name,
2248  "PROXY",
2249  &plugin->proxy_hostname))
2250  {
2252  "Found proxy host: `%s'\n",
2253  plugin->proxy_hostname);
2254  /* proxy username */
2255  if (GNUNET_OK ==
2257  plugin->name,
2258  "PROXY_USERNAME",
2259  &plugin->proxy_username))
2260  {
2262  "Found proxy username name: `%s'\n",
2263  plugin->proxy_username);
2264  }
2265 
2266  /* proxy password */
2267  if (GNUNET_OK ==
2269  plugin->name,
2270  "PROXY_PASSWORD",
2271  &plugin->proxy_password))
2272  {
2274  "Found proxy password name: `%s'\n",
2275  plugin->proxy_password);
2276  }
2277 
2278  /* proxy type */
2279  if (GNUNET_OK ==
2281  plugin->name,
2282  "PROXY_TYPE",
2283  &proxy_type))
2284  {
2285  GNUNET_STRINGS_utf8_toupper (proxy_type, proxy_type);
2286 
2287  if (0 == strcmp (proxy_type, "HTTP"))
2288  plugin->proxytype = CURLPROXY_HTTP;
2289  else if (0 == strcmp (proxy_type, "SOCKS4"))
2290  plugin->proxytype = CURLPROXY_SOCKS4;
2291  else if (0 == strcmp (proxy_type, "SOCKS5"))
2292  plugin->proxytype = CURLPROXY_SOCKS5;
2293  else if (0 == strcmp (proxy_type, "SOCKS4A"))
2294  plugin->proxytype = CURLPROXY_SOCKS4A;
2295  else if (0 == strcmp (proxy_type, "SOCKS5_HOSTNAME "))
2296  plugin->proxytype = CURLPROXY_SOCKS5_HOSTNAME;
2297  else
2298  {
2300  _ (
2301  "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
2302  proxy_type);
2303 
2304  GNUNET_free (proxy_type);
2305  GNUNET_free (plugin->proxy_hostname);
2306  plugin->proxy_hostname = NULL;
2308  plugin->proxy_username = NULL;
2310  plugin->proxy_password = NULL;
2311 
2312  return GNUNET_SYSERR;
2313  }
2314 
2316  "Found proxy type: `%s'\n",
2317  proxy_type);
2318  }
2319 
2320  /* proxy http tunneling */
2323  plugin->name,
2324  "PROXY_HTTP_TUNNELING");
2327 
2328  GNUNET_free_non_null (proxy_type);
2329  }
2330 
2331  /* Should we emulate an XHR client for testing? */
2332  plugin->emulate_xhr
2334  plugin->name,
2335  "EMULATE_XHR");
2336  return GNUNET_OK;
2337 }
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
curl_proxytype proxytype
Type of proxy server:
char * proxy_username
Username for the proxy server.
static curl_proxytype proxy_type
Proxy type we are using (can be NULL).
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int proxy_use_httpproxytunnel
Use proxy tunneling: Tunnel all operations through a given HTTP instead of have the proxy evaluate th...
void GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to upper case.
Definition: strings.c:578
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int emulate_xhr
Should we emulate an XHR client for testing?
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
unsigned int max_requests
Maximum number of sockets the plugin can use Each http connections are two requests.
char * proxy_hostname
Proxy configuration: hostname or ip of the proxy server.
#define LOG(kind,...)
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
char * proxy_password
Password for the proxy server.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure
addraddress to convert
addrlenaddress length
Returns
res string if conversion was successful, NULL otherwise

Definition at line 2349 of file plugin_transport_http_client.c.

References http_common_plugin_address_to_string(), and PLUGIN_NAME.

Referenced by libgnunet_plugin_transport_http_client_init().

2352 {
2354  addr,
2355  addrlen);
2356 }
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.
#define PLUGIN_NAME
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
clsclosure
peerwhich peer was the session for
sessionwhich session is being updated

Definition at line 2369 of file plugin_transport_http_client.c.

References client_reschedule_session_timeout().

Referenced by libgnunet_plugin_transport_http_client_init().

2373 {
2375 }
static void client_reschedule_session_timeout(struct GNUNET_ATS_Session *s)
Increment session timeout due to activity for session s.
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
clsclosure
peerwhich peer was the session for
swhich session is being updated
delaynew delay to use for receiving

Definition at line 2389 of file plugin_transport_http_client.c.

References client_wake_up(), 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().

2393 {
2396  "New inbound delay %s\n",
2398  GNUNET_NO));
2399  if (s->recv_wakeup_task != NULL)
2400  {
2402  s->recv_wakeup_task
2404  &client_wake_up,
2405  s);
2406  }
2407 }
struct GNUNET_SCHEDULER_Task * recv_wakeup_task
Task to wake up client receive handle when receiving is allowed again.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_NO
Definition: gnunet_common.h:78
static void client_wake_up(void *cls)
Wake up a curl handle which was suspended.
struct GNUNET_TIME_Absolute next_receive
Absolute time when to receive data again Used for receive throttling.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
#define LOG(kind,...)
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsthe struct Plugin with the monitor callback (sic)
peerpeer we send information about
valueour struct GNUNET_ATS_Session to send information about
Returns
GNUNET_OK (continue to iterate)

Definition at line 2420 of file plugin_transport_http_client.c.

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

Referenced by http_client_plugin_setup_monitor(), template_plugin_setup_monitor(), and template_plugin_update_session_timeout().

2423 {
2424  struct HTTP_Client_Plugin *plugin = cls;
2425  struct GNUNET_ATS_Session *session = value;
2426 
2427  notify_session_monitor (plugin,
2428  session,
2430  notify_session_monitor (plugin,
2431  session,
2432  GNUNET_TRANSPORT_SS_UP); /* FIXME: or handshake? */
2433  return GNUNET_OK;
2434 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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.
static char * value
Value of the record to add/remove.
Session handle for connections.
static char * plugin
Solver plugin name as string.
Encapsulation of all of the state of the plugin.
The session was created (first call for each session object).
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
clsclosure of the plugin
siccallback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_clsclosure for sic

Definition at line 2450 of file plugin_transport_http_client.c.

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

Referenced by libgnunet_plugin_transport_http_client_init().

2453 {
2454  struct HTTP_Client_Plugin *plugin = cls;
2455 
2456  plugin->sic = sic;
2457  plugin->sic_cls = sic_cls;
2458  if (NULL != sic)
2459  {
2462  plugin);
2463  /* signal end of first iteration */
2464  sic (sic_cls, NULL, NULL);
2465  }
2466 }
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.
static char * plugin
Solver plugin name as string.
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
void * sic_cls
Closure for sic.
Encapsulation of all of the state of the plugin.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
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 2473 of file plugin_transport_http_client.c.

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, HTTP_Client_Plugin::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(), HTTP_Client_Plugin::last_tag, LIBGNUNET_PLUGIN_TRANSPORT_DONE, HTTP_Client_Plugin::name, plugin, HTTP_Client_Plugin::protocol, GNUNET_TRANSPORT_PluginFunctions::query_keepalive_factor, GNUNET_TRANSPORT_PluginEnvironment::receive, GNUNET_TRANSPORT_PluginFunctions::send, HTTP_Client_Plugin::sessions, GNUNET_TRANSPORT_PluginFunctions::setup_monitor, GNUNET_TRANSPORT_PluginFunctions::string_to_address, GNUNET_TRANSPORT_PluginFunctions::update_inbound_delay, and GNUNET_TRANSPORT_PluginFunctions::update_session_timeout.

2474 {
2477  struct HTTP_Client_Plugin *plugin;
2478 
2479  if (NULL == env->receive)
2480  {
2481  /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
2482  initialze the plugin or the API */
2484  api->cls = NULL;
2488  return api;
2489  }
2490 
2491  plugin = GNUNET_new (struct HTTP_Client_Plugin);
2492  plugin->env = env;
2494  GNUNET_YES);
2496  api->cls = plugin;
2497  api->send = &http_client_plugin_send;
2511 #if BUILD_HTTPS
2512  plugin->name = "transport-https_client";
2513  plugin->protocol = "https";
2514 #else
2515  plugin->name = "transport-http_client";
2516  plugin->protocol = "http";
2517 #endif
2518  plugin->last_tag = 1;
2519 
2520  if (GNUNET_SYSERR == client_configure_plugin (plugin))
2521  {
2523  return NULL;
2524  }
2525 
2526  /* Start client */
2527  if (GNUNET_SYSERR == client_start (plugin))
2528  {
2530  return NULL;
2531  }
2532  return api;
2533 }
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.
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.
static unsigned int http_client_query_keepalive_factor(void *cls)
Function that is called to get the keepalive factor.
GNUNET_TRANSPORT_CreateSession get_session
Function that will be called tell the plugin to create a session object.
static int http_client_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *s)
Disconnect a session.
GNUNET_TRANSPORT_AddressToString address_to_string
Function that will be called to convert a binary address to a string (numeric conversion only)...
static int client_configure_plugin(struct HTTP_Client_Plugin *plugin)
Configure plugin.
uint32_t last_tag
Last used unique HTTP connection tag.
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.
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
GNUNET_TRANSPORT_DisconnectPeerFunction disconnect_peer
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
GNUNET_TRANSPORT_DisconnectSessionFunction disconnect_session
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
GNUNET_TRANSPORT_SessionMonitorSetup setup_monitor
Function to monitor the sessions managed by the plugin.
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...
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...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TRANSPORT_PluginEnvironment * env
Our environment.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
GNUNET_TRANSPORT_PluginReceiveCallback receive
Function that should be called by the transport plugin whenever a message is received.
GNUNET_TRANSPORT_UpdateSessionTimeout update_session_timeout
Function that will be called whenever the transport service wants to notify the plugin that a session...
void * cls
Closure for the various callbacks.
void * cls
Closure for all of the callbacks.
GNUNET_TRANSPORT_StringToAddress string_to_address
Function that will be called to convert a string address to binary (numeric conversion only)...
The transport service will pass a pointer to a struct of this type as the first and only argument to ...
GNUNET_TRANSPORT_GetNetworkType get_network
Function to obtain the network type for a session.
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.
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...
GNUNET_TRANSPORT_UpdateInboundDelay update_inbound_delay
Function that will be called whenever the transport service wants to notify the plugin that the inbou...
static char * plugin
Solver plugin name as string.
static enum GNUNET_NetworkType http_client_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session)
Function obtain the network type for a session.
struct GNUNET_CONTAINER_MultiPeerMap * sessions
Open sessions.
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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 previo...
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE
Encapsulation of all of the state of the plugin.
GNUNET_TRANSPORT_QueryKeepaliveFactorFunction query_keepalive_factor
Function that is used to query keepalive factor.
static void http_client_plugin_setup_monitor(void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
Begin monitoring sessions of a plugin.
static int client_start(struct HTTP_Client_Plugin *plugin)
Setup http_client plugin.
GNUNET_TRANSPORT_AddressPrettyPrinter address_pretty_printer
Function to pretty-print addresses.
#define GNUNET_YES
Definition: gnunet_common.h:77
GNUNET_TRANSPORT_CheckAddress check_address
Function that will be called to check if a binary address for this plugin is well-formed and correspo...
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 inbou...
GNUNET_TRANSPORT_GetNetworkTypeForAddress get_network_for_address
Function to obtain the network type for an address.
Here is the call graph for this function: