2 This file is part of GNUnet
3 (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file transport/plugin_transport_http_client.c
23 * @brief HTTP/S client transport plugin
24 * @author Matthias Wachs
28 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_https_client_init
29 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_https_client_done
31 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_client_init
32 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_client_done
35 #define VERBOSE_CURL GNUNET_YES
37 #define PUT_DISCONNECT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
39 #define ENABLE_PUT GNUNET_YES
40 #define ENABLE_GET GNUNET_YES
43 #include "gnunet_protocols.h"
44 #include "gnunet_common.h"
45 #include "gnunet_server_lib.h"
46 #include "gnunet_transport_plugin.h"
47 #include "plugin_transport_http_common.h"
48 #include <curl/curl.h>
52 * Encapsulation of all of the state of the plugin.
54 struct HTTP_Client_Plugin;
58 * Message to send using http
63 * next pointer for double linked list
65 struct HTTP_Message *next;
68 * previous pointer for double linked list
70 struct HTTP_Message *prev;
73 * buffer containing data to send
78 * amount of data already sent
88 * Continuation function to call once the transmission buffer
89 * has again space available. NULL if there is no
90 * continuation to call.
92 GNUNET_TRANSPORT_TransmitContinuation transmit_cont;
95 * Closure for transmit_cont.
97 void *transmit_cont_cls;
101 * Session handle for connections.
106 * To whom are we talking to (set to our identity
107 * if we are still waiting for the welcome message)
109 struct GNUNET_PeerIdentity target;
112 * Stored in a linked list.
114 struct Session *next;
117 * Stored in a linked list.
119 struct Session *prev;
122 * The URL to connect to
137 * ATS network type in NBO
139 uint32_t ats_address_network_type;
142 * Pointer to the global plugin struct.
144 struct HTTP_Client_Plugin *plugin;
147 * Was session given to transport service?
149 // int session_passed;
158 * Is the client PUT handle currently paused
163 * Is the client PUT handle disconnect in progress?
165 int put_tmp_disconnecting;
168 * Is the client PUT handle temporarily disconnected?
170 int put_tmp_disconnected;
173 * We received data to send while disconnecting, reconnect immediately
175 int put_reconnect_required;
178 * Client receive handle
183 * next pointer for double linked list
185 struct HTTP_Message *msg_head;
188 * previous pointer for double linked list
190 struct HTTP_Message *msg_tail;
193 * Message stream tokenizer for incoming data
195 struct GNUNET_SERVER_MessageStreamTokenizer *msg_tk;
198 * Session timeout task
200 GNUNET_SCHEDULER_TaskIdentifier put_disconnect_task;
203 * Session timeout task
205 GNUNET_SCHEDULER_TaskIdentifier timeout_task;
208 * Task to wake up client receive handle when receiving is allowed again
210 GNUNET_SCHEDULER_TaskIdentifier recv_wakeup_task;
213 * Absolute time when to receive data again
214 * Used for receive throttling
216 struct GNUNET_TIME_Absolute next_receive;
221 * Encapsulation of all of the state of the plugin.
223 struct HTTP_Client_Plugin
228 struct GNUNET_TRANSPORT_PluginEnvironment *env;
231 * Linked list head of open sessions.
233 struct Session *head;
236 * Linked list tail of open sessions.
238 struct Session *tail;
251 * Maximum number of sockets the plugin can use
252 * Each http inbound /outbound connections are two connections
254 unsigned int max_connections;
257 * Current number of sockets the plugin can use
258 * Each http inbound /outbound connections are two connections
260 unsigned int cur_connections;
263 * Last used unique HTTP connection tag
280 CURLM *curl_multi_handle;
285 GNUNET_SCHEDULER_TaskIdentifier client_perform_task;
290 * Encapsulation of all of the state of the plugin.
292 struct HTTP_Client_Plugin *p;
296 * Start session timeout for a session
297 * @param s the session
300 client_start_session_timeout (struct Session *s);
304 * Increment session timeout due to activity for a session
305 * @param s the session
308 client_reschedule_session_timeout (struct Session *s);
312 * Cancel timeout for a session
313 * @param s the session
316 client_stop_session_timeout (struct Session *s);
320 * Function setting up file descriptors and scheduling task to run
322 * @param plugin plugin as closure
323 * @param now schedule task in 1ms, regardless of what curl may say
324 * @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
327 client_schedule (struct HTTP_Client_Plugin *plugin, int now);
330 client_connect_put (struct Session *s);
333 * Does a session s exists?
335 * @param plugin the plugin
336 * @param s desired session
337 * @return GNUNET_YES or GNUNET_NO
340 client_exist_session (struct HTTP_Client_Plugin *plugin, struct Session *s)
342 struct Session * head;
344 GNUNET_assert (NULL != plugin);
345 GNUNET_assert (NULL != s);
347 for (head = plugin->head; head != NULL; head = head->next)
357 * Function to log curl debug messages with GNUNET_log
360 * @param type curl_infotype
367 client_log (CURL * curl, curl_infotype type, char *data, size_t size, void *cls)
370 if ((type == CURLINFO_TEXT) || (type == CURLINFO_HEADER_IN) || (type == CURLINFO_HEADER_OUT))
378 case CURLINFO_HEADER_IN:
381 case CURLINFO_HEADER_OUT:
382 ttype = "HEADER_OUT";
388 memcpy (text, data, size);
389 if (text[size - 1] == '\n')
394 text[size + 1] = '\0';
397 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-https_client",
398 "Connection %p %s: %s", cls, ttype, text);
400 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-http_client",
401 "Connection %p %s: %s", cls, ttype, text);
410 * Function that can be used by the transport service to transmit
411 * a message using the plugin. Note that in the case of a
412 * peer disconnecting, the continuation MUST be called
413 * prior to the disconnect notification itself. This function
414 * will be called with this peer's HELLO message to initiate
415 * a fresh connection to another peer.
418 * @param s which session must be used
419 * @param msgbuf the message to transmit
420 * @param msgbuf_size number of bytes in 'msgbuf'
421 * @param priority how important is the message (most plugins will
422 * ignore message priority and just FIFO)
423 * @param to how long to wait at most for the transmission (does not
424 * require plugins to discard the message after the timeout,
425 * just advisory for the desired delay; most plugins will ignore
427 * @param cont continuation to call once the message has
428 * been transmitted (or if the transport is ready
429 * for the next transmission call; or if the
430 * peer disconnected...); can be NULL
431 * @param cont_cls closure for cont
432 * @return number of bytes used (on the physical network, with overheads);
433 * -1 on hard errors (i.e. address invalid); 0 is a legal value
434 * and does NOT mean that the message was not transmitted (DV)
437 http_client_plugin_send (void *cls,
439 const char *msgbuf, size_t msgbuf_size,
440 unsigned int priority,
441 struct GNUNET_TIME_Relative to,
442 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
444 struct HTTP_Client_Plugin *plugin = cls;
445 struct HTTP_Message *msg;
448 GNUNET_assert (plugin != NULL);
449 GNUNET_assert (s != NULL);
451 /* lookup if session is really existing */
452 if (GNUNET_YES != client_exist_session (plugin, s))
455 return GNUNET_SYSERR;
458 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
459 "Session %p/connection %p: Sending message with %u to peer `%s' \n",
461 msgbuf_size, GNUNET_i2s (&s->target));
463 /* create new message and schedule */
464 msg = GNUNET_malloc (sizeof (struct HTTP_Message) + msgbuf_size);
466 msg->size = msgbuf_size;
468 msg->buf = (char *) &msg[1];
469 msg->transmit_cont = cont;
470 msg->transmit_cont_cls = cont_cls;
471 memcpy (msg->buf, msgbuf, msgbuf_size);
472 GNUNET_CONTAINER_DLL_insert_tail (s->msg_head, s->msg_tail, msg);
474 GNUNET_asprintf (&stat_txt, "# bytes currently in %s_client buffers", plugin->protocol);
475 GNUNET_STATISTICS_update (plugin->env->stats,
476 stat_txt, msgbuf_size, GNUNET_NO);
478 GNUNET_free (stat_txt);
480 if (GNUNET_YES == s->put_tmp_disconnecting)
482 /* PUT connection is currently getting disconnected */
483 s->put_reconnect_required = GNUNET_YES;
484 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
485 "Session %p/connection %jp: currently disconnecting, reconnecting immediately\n",
489 else if (GNUNET_YES == s->put_paused)
491 /* PUT connection was paused, unpause */
492 GNUNET_assert (s->put_disconnect_task != GNUNET_SCHEDULER_NO_TASK);
493 GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
494 s->put_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
495 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
496 "Session %p/connection %p: unpausing connection\n",
498 s->put_paused = GNUNET_NO;
499 curl_easy_pause (s->client_put, CURLPAUSE_CONT);
501 else if (GNUNET_YES == s->put_tmp_disconnected)
503 /* PUT connection was disconnected, reconnect */
504 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
505 "Session %p: Reconnecting PUT connection\n",
507 s->put_tmp_disconnected = GNUNET_NO;
508 GNUNET_break (s->client_put == NULL);
509 if (GNUNET_SYSERR == client_connect_put (s))
511 return GNUNET_SYSERR;
515 client_schedule (s->plugin, GNUNET_YES);
516 client_reschedule_session_timeout (s);
524 * @param s the session to delete
527 client_delete_session (struct Session *s)
529 struct HTTP_Client_Plugin *plugin = s->plugin;
530 struct HTTP_Message *pos;
531 struct HTTP_Message *next;
533 client_stop_session_timeout (s);
535 if (GNUNET_SCHEDULER_NO_TASK != s->put_disconnect_task)
537 GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
538 s->put_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
541 GNUNET_CONTAINER_DLL_remove (plugin->head, plugin->tail, s);
544 while (NULL != (pos = next))
547 GNUNET_CONTAINER_DLL_remove (s->msg_head, s->msg_tail, pos);
548 if (pos->transmit_cont != NULL)
549 pos->transmit_cont (pos->transmit_cont_cls, &s->target, GNUNET_SYSERR);
553 if (s->msg_tk != NULL)
555 GNUNET_SERVER_mst_destroy (s->msg_tk);
558 GNUNET_free (s->addr);
559 GNUNET_free (s->url);
566 * Disconnect a session
569 * @return GNUNET_OK on success, GNUNET_SYSERR on error
572 client_disconnect (struct Session *s)
574 struct HTTP_Client_Plugin *plugin = s->plugin;
575 struct HTTP_Message *msg;
576 struct HTTP_Message *t;
580 if (GNUNET_YES != client_exist_session (plugin, s))
583 return GNUNET_SYSERR;
586 if (s->client_put != NULL)
588 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
589 "Session %p/connection %p: disconnecting PUT connection to peer `%s'\n",
590 s, s->client_put, GNUNET_i2s (&s->target));
592 /* remove curl handle from multi handle */
593 mret = curl_multi_remove_handle (plugin->curl_multi_handle, s->client_put);
594 if (mret != CURLM_OK)
596 /* clean up easy handle, handle is now invalid and free'd */
600 curl_easy_cleanup (s->client_put);
601 s->client_put = NULL;
605 if (s->recv_wakeup_task != GNUNET_SCHEDULER_NO_TASK)
607 GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
608 s->recv_wakeup_task = GNUNET_SCHEDULER_NO_TASK;
611 if (s->client_get != NULL)
613 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
614 "Session %p/connection %p: disconnecting GET connection to peer `%s'\n",
615 s, s->client_get, GNUNET_i2s (&s->target));
617 /* remove curl handle from multi handle */
618 mret = curl_multi_remove_handle (plugin->curl_multi_handle, s->client_get);
619 if (mret != CURLM_OK)
621 /* clean up easy handle, handle is now invalid and free'd */
625 curl_easy_cleanup (s->client_get);
626 s->client_get = NULL;
633 if (NULL != msg->transmit_cont)
634 msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_SYSERR);
635 GNUNET_CONTAINER_DLL_remove (s->msg_head, s->msg_tail, msg);
640 GNUNET_assert (plugin->cur_connections >= 2);
641 plugin->cur_connections -= 2;
642 GNUNET_STATISTICS_set (plugin->env->stats,
643 "# HTTP client sessions",
644 plugin->cur_connections,
647 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
648 "Session %p: notifying transport about ending session\n",s);
650 plugin->env->session_end (plugin->env->cls, &s->target, s);
651 client_delete_session (s);
653 /* Re-schedule since handles have changed */
654 if (plugin->client_perform_task != GNUNET_SCHEDULER_NO_TASK)
656 GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
657 plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
659 client_schedule (plugin, GNUNET_YES);
666 * Function that can be used to force the plugin to disconnect
667 * from the given peer and cancel all previous transmissions
668 * (and their continuationc).
671 * @param target peer from which to disconnect
674 http_client_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
676 struct HTTP_Client_Plugin *plugin = cls;
677 struct Session *next = NULL;
678 struct Session *pos = NULL;
680 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
681 "Transport tells me to disconnect `%s'\n",
682 GNUNET_i2s (target));
685 while (NULL != (pos = next))
688 if (0 == memcmp (target, &pos->target, sizeof (struct GNUNET_PeerIdentity)))
690 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
691 "Disconnecting session %p to `%pos'\n",
692 pos, GNUNET_i2s (target));
693 GNUNET_assert (GNUNET_OK == client_disconnect (pos));
700 static struct Session *
701 client_lookup_session (struct HTTP_Client_Plugin *plugin,
702 const struct GNUNET_HELLO_Address *address)
706 for (pos = plugin->head; NULL != pos; pos = pos->next)
707 if ((0 == memcmp (&address->peer, &pos->target, sizeof (struct GNUNET_PeerIdentity))) &&
708 (address->address_length == pos->addrlen) &&
709 (0 == memcmp (address->address, pos->addr, pos->addrlen)))
715 client_put_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
717 struct Session *s = cls;
718 s->put_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
719 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
720 "Session %p/connection %p: will be disconnected due to no activity\n",
722 s->put_paused = GNUNET_NO;
723 s->put_tmp_disconnecting = GNUNET_YES;
724 curl_easy_pause (s->client_put, CURLPAUSE_CONT);
725 client_schedule (s->plugin, GNUNET_YES);
731 * Callback method used with libcurl
732 * Method is called when libcurl needs to read data during sending
734 * @param stream pointer where to write data
735 * @param size size of an individual element
736 * @param nmemb count of elements that can be written to the buffer
737 * @param cls source pointer, passed to the libcurl handle
738 * @return bytes written to stream, returning 0 will terminate connection!
741 client_send_cb (void *stream, size_t size, size_t nmemb, void *cls)
743 struct Session *s = cls;
744 struct HTTP_Client_Plugin *plugin = s->plugin;
745 struct HTTP_Message *msg = s->msg_head;
749 if (GNUNET_YES != client_exist_session (plugin, s))
754 if (GNUNET_YES == s->put_tmp_disconnecting)
757 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
758 "Session %p/connection %p: disconnect due to inactivity\n",
765 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
766 "Session %p/connection %p: nothing to send, suspending\n",
768 s->put_disconnect_task = GNUNET_SCHEDULER_add_delayed (PUT_DISCONNECT_TIMEOUT, &client_put_disconnect, s);
769 s->put_paused = GNUNET_YES;
770 return CURL_READFUNC_PAUSE;
773 GNUNET_assert (msg->pos < msg->size);
774 /* calculate how much fits in buffer */
775 len = GNUNET_MIN (msg->size - msg->pos,
777 memcpy (stream, &msg->buf[msg->pos], len);
779 if (msg->pos == msg->size)
781 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
782 "Session %p/connection %p: sent message with %u bytes sent, removing message from queue\n",
783 s, s->client_put, msg->size, msg->pos);
784 /* Calling transmit continuation */
785 GNUNET_CONTAINER_DLL_remove (s->msg_head, s->msg_tail, msg);
786 if (NULL != msg->transmit_cont)
787 msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_OK);
791 GNUNET_asprintf (&stat_txt, "# bytes currently in %s_client buffers", plugin->protocol);
792 GNUNET_STATISTICS_update (plugin->env->stats,
793 stat_txt, -len, GNUNET_NO);
794 GNUNET_free (stat_txt);
796 GNUNET_asprintf (&stat_txt, "# bytes transmitted via %s_client", plugin->protocol);
797 GNUNET_STATISTICS_update (plugin->env->stats,
798 stat_txt, len, GNUNET_NO);
799 GNUNET_free (stat_txt);
801 client_reschedule_session_timeout (s);
807 * Wake up a curl handle which was suspended
809 * @param cls the session
810 * @param tc task context
813 client_wake_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
815 struct Session *s = cls;
817 if (GNUNET_YES != client_exist_session(p, s))
822 s->recv_wakeup_task = GNUNET_SCHEDULER_NO_TASK;
823 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
825 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
826 "Session %p/connection %p: Waking up GET handle\n", s, s->client_get);
827 if (s->client_get != NULL)
828 curl_easy_pause (s->client_get, CURLPAUSE_CONT);
833 * Callback for message stream tokenizer
835 * @param cls the session
836 * @param client not used
837 * @param message the message received
838 * @return always GNUNET_OK
841 client_receive_mst_cb (void *cls, void *client,
842 const struct GNUNET_MessageHeader *message)
844 struct Session *s = cls;
845 struct HTTP_Client_Plugin *plugin;
846 struct GNUNET_TIME_Relative delay;
847 struct GNUNET_ATS_Information atsi[2];
849 if (GNUNET_YES != client_exist_session(p, s))
856 atsi[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
857 atsi[0].value = htonl (1);
858 atsi[1].type = htonl (GNUNET_ATS_NETWORK_TYPE);
859 atsi[1].value = s->ats_address_network_type;
860 GNUNET_break (s->ats_address_network_type != ntohl (GNUNET_ATS_NET_UNSPECIFIED));
862 delay = s->plugin->env->receive (plugin->env->cls, &s->target, message,
863 (const struct GNUNET_ATS_Information *) &atsi, 2,
864 s, s->addr, s->addrlen);
866 GNUNET_asprintf (&stat_txt, "# bytes received via %s_client", plugin->protocol);
867 GNUNET_STATISTICS_update (plugin->env->stats,
868 stat_txt, ntohs(message->size), GNUNET_NO);
869 GNUNET_free (stat_txt);
872 GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
874 if (GNUNET_TIME_absolute_get ().abs_value < s->next_receive.abs_value)
877 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
878 "Client: peer `%s' address `%s' next read delayed for %llu ms\n",
879 GNUNET_i2s (&s->target), GNUNET_a2s (s->addr, s->addrlen),
882 client_reschedule_session_timeout (s);
888 * Callback method used with libcurl when data for a PUT connection are
889 * received. We do not expect data here, so we just dismiss it
891 * @param stream pointer where to write data
892 * @param size size of an individual element
893 * @param nmemb count of elements that can be written to the buffer
894 * @param cls destination pointer, passed to the libcurl handle
895 * @return bytes read from stream
898 client_receive_put (void *stream, size_t size, size_t nmemb, void *cls)
905 * Callback method used with libcurl when data for a GET connection are
906 * received. Forward to MST
908 * @param stream pointer where to write data
909 * @param size size of an individual element
910 * @param nmemb count of elements that can be written to the buffer
911 * @param cls destination pointer, passed to the libcurl handle
912 * @return bytes read from stream
915 client_receive (void *stream, size_t size, size_t nmemb, void *cls)
917 struct Session *s = cls;
918 struct GNUNET_TIME_Absolute now;
919 size_t len = size * nmemb;
920 struct HTTP_Client_Plugin *plugin = s->plugin;
922 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
923 "Session %p / connection %p: Received %u bytes from peer `%s'\n",
925 len, GNUNET_i2s (&s->target));
926 now = GNUNET_TIME_absolute_get ();
927 if (now.abs_value < s->next_receive.abs_value)
929 struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
930 struct GNUNET_TIME_Relative delta =
931 GNUNET_TIME_absolute_get_difference (now, s->next_receive);
932 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
933 "Session %p / connection %p: No inbound bandwidth available! Next read was delayed for %llu ms\n",
934 s, s->client_get, delta.rel_value);
935 if (s->recv_wakeup_task != GNUNET_SCHEDULER_NO_TASK)
937 GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
938 s->recv_wakeup_task = GNUNET_SCHEDULER_NO_TASK;
940 s->recv_wakeup_task =
941 GNUNET_SCHEDULER_add_delayed (delta, &client_wake_up, s);
942 return CURL_WRITEFUNC_PAUSE;
944 if (NULL == s->msg_tk)
945 s->msg_tk = GNUNET_SERVER_mst_create (&client_receive_mst_cb, s);
946 GNUNET_SERVER_mst_receive (s->msg_tk, s, stream, len, GNUNET_NO, GNUNET_NO);
952 * Task performing curl operations
954 * @param cls plugin as closure
955 * @param tc gnunet scheduler task context
958 client_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
962 * Function setting up file descriptors and scheduling task to run
964 * @param plugin plugin as closure
965 * @param now schedule task in 1ms, regardless of what curl may say
966 * @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
969 client_schedule (struct HTTP_Client_Plugin *plugin, int now)
975 struct GNUNET_NETWORK_FDSet *grs;
976 struct GNUNET_NETWORK_FDSet *gws;
979 struct GNUNET_TIME_Relative timeout;
981 /* Cancel previous scheduled task */
982 if (plugin->client_perform_task != GNUNET_SCHEDULER_NO_TASK)
984 GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
985 plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
991 mret = curl_multi_fdset (plugin->curl_multi_handle, &rs, &ws, &es, &max);
992 if (mret != CURLM_OK)
994 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"),
995 "curl_multi_fdset", __FILE__, __LINE__,
996 curl_multi_strerror (mret));
997 return GNUNET_SYSERR;
999 mret = curl_multi_timeout (plugin->curl_multi_handle, &to);
1001 timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1);
1003 timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to);
1004 if (now == GNUNET_YES)
1005 timeout = GNUNET_TIME_UNIT_MILLISECONDS;
1007 if (mret != CURLM_OK)
1009 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"),
1010 "curl_multi_timeout", __FILE__, __LINE__,
1011 curl_multi_strerror (mret));
1012 return GNUNET_SYSERR;
1015 grs = GNUNET_NETWORK_fdset_create ();
1016 gws = GNUNET_NETWORK_fdset_create ();
1017 GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
1018 GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
1020 plugin->client_perform_task =
1021 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1023 &client_run, plugin);
1024 GNUNET_NETWORK_fdset_destroy (gws);
1025 GNUNET_NETWORK_fdset_destroy (grs);
1031 * Task performing curl operations
1033 * @param cls plugin as closure
1034 * @param tc gnunet scheduler task context
1037 client_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1039 struct HTTP_Client_Plugin *plugin = cls;
1041 long http_statuscode;
1044 GNUNET_assert (cls != NULL);
1046 plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
1047 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1053 mret = curl_multi_perform (plugin->curl_multi_handle, &running);
1058 while ((msg = curl_multi_info_read (plugin->curl_multi_handle, &msgs_left)))
1060 CURL *easy_h = msg->easy_handle;
1061 struct Session *s = NULL;
1062 char *d = (char *) s;
1067 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1068 "Client: connection to ended with reason %i: `%s', %i handles running\n",
1070 curl_easy_strerror (msg->data.result), running);
1074 GNUNET_assert (CURLE_OK ==
1075 curl_easy_getinfo (easy_h, CURLINFO_PRIVATE, &d));
1076 s = (struct Session *) d;
1078 if (GNUNET_YES != client_exist_session(plugin, s))
1084 GNUNET_assert (s != NULL);
1085 if (msg->msg == CURLMSG_DONE)
1087 curl_easy_getinfo (easy_h, CURLINFO_RESPONSE_CODE, &http_statuscode);
1088 if (easy_h == s->client_put)
1090 if ((0 != msg->data.result) || (http_statuscode != 200))
1092 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1093 "Session %p/connection %p: PUT connection to `%s' ended with status %i reason %i: `%s'\n",
1094 s, msg->easy_handle, GNUNET_i2s (&s->target),
1097 curl_easy_strerror (msg->data.result));
1100 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1101 "Session %p/connection %p: PUT connection to `%s' ended normal\n",
1102 s, msg->easy_handle, GNUNET_i2s (&s->target));
1103 if (s->client_get == NULL)
1105 /* Disconnect other transmission direction and tell transport */
1107 curl_multi_remove_handle (plugin->curl_multi_handle, easy_h);
1108 curl_easy_cleanup (easy_h);
1109 s->put_tmp_disconnecting = GNUNET_NO;
1110 s->put_tmp_disconnected = GNUNET_YES;
1111 s->client_put = NULL;
1114 * Handling a rare case:
1115 * plugin_send was called during temporary put disconnect,
1116 * reconnect required after connection was disconnected
1118 if (GNUNET_YES == s->put_reconnect_required)
1120 s->put_reconnect_required = GNUNET_NO;
1121 client_connect_put(s);
1124 if (easy_h == s->client_get)
1126 if ((0 != msg->data.result) || (http_statuscode != 200))
1128 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1129 "Session %p/connection %p: GET connection to `%s' ended with status %i reason %i: `%s'\n",
1130 s, msg->easy_handle, GNUNET_i2s (&s->target),
1133 curl_easy_strerror (msg->data.result));
1137 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1138 "Session %p/connection %p: GET connection to `%s' ended normal\n",
1139 s, msg->easy_handle, GNUNET_i2s (&s->target));
1140 /* Disconnect other transmission direction and tell transport */
1141 client_disconnect (s);
1146 while (mret == CURLM_CALL_MULTI_PERFORM);
1147 client_schedule (plugin, GNUNET_NO);
1151 client_connect_get (struct Session *s)
1154 /* create get connection */
1155 s->client_get = curl_easy_init ();
1157 curl_easy_setopt (s->client_get, CURLOPT_VERBOSE, 1L);
1158 curl_easy_setopt (s->client_get, CURLOPT_DEBUGFUNCTION, &client_log);
1159 curl_easy_setopt (s->client_get, CURLOPT_DEBUGDATA, s->client_get);
1162 curl_easy_setopt (s->client_get, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
1163 curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYPEER, 0);
1164 curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYHOST, 0);
1166 curl_easy_setopt (s->client_get, CURLOPT_URL, s->url);
1167 //curl_easy_setopt (s->client_get, CURLOPT_HEADERFUNCTION, &curl_get_header_cb);
1168 //curl_easy_setopt (s->client_get, CURLOPT_WRITEHEADER, ps);
1169 curl_easy_setopt (s->client_get, CURLOPT_READFUNCTION, client_send_cb);
1170 curl_easy_setopt (s->client_get, CURLOPT_READDATA, s);
1171 curl_easy_setopt (s->client_get, CURLOPT_WRITEFUNCTION, client_receive);
1172 curl_easy_setopt (s->client_get, CURLOPT_WRITEDATA, s);
1173 /* No timeout by default, timeout done with session timeout */
1174 curl_easy_setopt (s->client_get, CURLOPT_TIMEOUT, 0);
1175 curl_easy_setopt (s->client_get, CURLOPT_PRIVATE, s);
1176 curl_easy_setopt (s->client_get, CURLOPT_CONNECTTIMEOUT_MS,
1177 (long) HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value);
1178 curl_easy_setopt (s->client_get, CURLOPT_BUFFERSIZE,
1179 2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
1180 #if CURL_TCP_NODELAY
1181 curl_easy_setopt (ps->recv_endpoint, CURLOPT_TCP_NODELAY, 1);
1183 mret = curl_multi_add_handle (s->plugin->curl_multi_handle, s->client_get);
1184 if (mret != CURLM_OK)
1186 GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, s->plugin->name,
1187 "Session %p : Failed to add GET handle to multihandle: `%s'\n",
1188 s, curl_multi_strerror (mret));
1189 curl_easy_cleanup (s->client_get);
1190 s->client_get = NULL;
1192 return GNUNET_SYSERR;
1199 client_connect_put (struct Session *s)
1202 /* create put connection */
1203 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, s->plugin->name,
1204 "Session %p : Init PUT handle \n", s);
1205 s->client_put = curl_easy_init ();
1207 curl_easy_setopt (s->client_put, CURLOPT_VERBOSE, 1L);
1208 curl_easy_setopt (s->client_put, CURLOPT_DEBUGFUNCTION, &client_log);
1209 curl_easy_setopt (s->client_put, CURLOPT_DEBUGDATA, s->client_put);
1212 curl_easy_setopt (s->client_put, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
1213 curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYPEER, 0);
1214 curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYHOST, 0);
1216 curl_easy_setopt (s->client_put, CURLOPT_URL, s->url);
1217 curl_easy_setopt (s->client_put, CURLOPT_UPLOAD, 1L);
1218 //curl_easy_setopt (s->client_put, CURLOPT_HEADERFUNCTION, &client_curl_header);
1219 //curl_easy_setopt (s->client_put, CURLOPT_WRITEHEADER, ps);
1220 curl_easy_setopt (s->client_put, CURLOPT_READFUNCTION, client_send_cb);
1221 curl_easy_setopt (s->client_put, CURLOPT_READDATA, s);
1222 curl_easy_setopt (s->client_put, CURLOPT_WRITEFUNCTION, client_receive_put);
1223 curl_easy_setopt (s->client_put, CURLOPT_WRITEDATA, s);
1224 /* No timeout by default, timeout done with session timeout */
1225 curl_easy_setopt (s->client_put, CURLOPT_TIMEOUT, 0);
1226 curl_easy_setopt (s->client_put, CURLOPT_PRIVATE, s);
1227 curl_easy_setopt (s->client_put, CURLOPT_CONNECTTIMEOUT_MS,
1228 (long) HTTP_CLIENT_NOT_VALIDATED_TIMEOUT.rel_value);
1229 curl_easy_setopt (s->client_put, CURLOPT_BUFFERSIZE,
1230 2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
1231 #if CURL_TCP_NODELAY
1232 curl_easy_setopt (s->client_put, CURLOPT_TCP_NODELAY, 1);
1234 mret = curl_multi_add_handle (s->plugin->curl_multi_handle, s->client_put);
1235 if (mret != CURLM_OK)
1237 GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, s->plugin->name,
1238 "Session %p : Failed to add PUT handle to multihandle: `%s'\n",
1239 s, curl_multi_strerror (mret));
1240 curl_easy_cleanup (s->client_put);
1241 s->client_put = NULL;
1242 return GNUNET_SYSERR;
1248 client_connect (struct Session *s)
1251 struct HTTP_Client_Plugin *plugin = s->plugin;
1252 int res = GNUNET_OK;
1256 if (NULL == http_common_plugin_address_to_string (NULL, s->addr, s->addrlen))
1258 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1259 "Invalid address peer `%s'\n",
1260 GNUNET_i2s (&s->target));
1261 return GNUNET_SYSERR;
1264 GNUNET_asprintf (&s->url, "%s/%s;%u",
1265 http_common_plugin_address_to_string (plugin, s->addr, s->addrlen),
1266 GNUNET_h2s_full (&plugin->env->my_identity->hashPubKey),
1271 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1272 "Initiating outbound session peer `%s' using address `%s'\n",
1273 GNUNET_i2s (&s->target), s->url);
1275 if ((GNUNET_SYSERR == client_connect_get (s)) ||
1276 (GNUNET_SYSERR == client_connect_put (s)))
1279 return GNUNET_SYSERR;
1282 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1283 "Session %p: connected with connections GET %p and PUT %p\n",
1284 s, s->client_get, s->client_put);
1286 /* Perform connect */
1287 plugin->cur_connections += 2;
1288 GNUNET_STATISTICS_set (plugin->env->stats,
1289 "# HTTP client connections",
1290 plugin->cur_connections,
1293 /* Re-schedule since handles have changed */
1294 if (plugin->client_perform_task != GNUNET_SCHEDULER_NO_TASK)
1296 GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
1297 plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
1299 plugin->client_perform_task = GNUNET_SCHEDULER_add_now (client_run, plugin);
1305 * Creates a new outbound session the transport service will use to send data to the
1308 * @param cls the plugin
1309 * @param address the address
1310 * @return the session or NULL of max connections exceeded
1312 static struct Session *
1313 http_client_plugin_get_session (void *cls,
1314 const struct GNUNET_HELLO_Address *address)
1316 struct HTTP_Client_Plugin *plugin = cls;
1317 struct Session * s = NULL;
1318 struct sockaddr *sa;
1319 struct GNUNET_ATS_Information ats;
1323 GNUNET_assert (plugin != NULL);
1324 GNUNET_assert (address != NULL);
1325 GNUNET_assert (address->address != NULL);
1327 /* find existing session */
1328 s = client_lookup_session (plugin, address);
1332 if (plugin->max_connections <= plugin->cur_connections)
1334 GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, plugin->name,
1335 "Maximum number of connections (%u) reached: "
1336 "cannot connect to peer `%s'\n",
1337 plugin->max_connections,
1338 GNUNET_i2s (&address->peer));
1342 ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
1343 ats.value = htonl (GNUNET_ATS_NET_UNSPECIFIED);
1344 sa = http_common_socket_from_address (address->address, address->address_length, &res);
1346 if (GNUNET_SYSERR == res)
1350 else if (GNUNET_YES == res)
1352 GNUNET_assert (NULL != sa);
1353 if (AF_INET == sa->sa_family)
1355 salen = sizeof (struct sockaddr_in);
1357 else if (AF_INET == sa->sa_family)
1359 salen = sizeof (struct sockaddr_in6);
1361 ats = plugin->env->get_address_type (plugin->env->cls, sa, salen);
1364 else if (GNUNET_NO == res)
1366 ats.value = htonl (GNUNET_ATS_COST_WAN);
1369 if (GNUNET_ATS_NET_UNSPECIFIED == ntohl(ats.value))
1375 s = GNUNET_malloc (sizeof (struct Session));
1376 memcpy (&s->target, &address->peer, sizeof (struct GNUNET_PeerIdentity));
1378 s->addr = GNUNET_malloc (address->address_length);
1379 memcpy (s->addr, address->address, address->address_length);
1380 s->addrlen = address->address_length;
1381 s->ats_address_network_type = ats.value;
1382 s->put_paused = GNUNET_NO;
1383 s->put_tmp_disconnecting = GNUNET_NO;
1384 s->put_tmp_disconnected = GNUNET_NO;
1385 client_start_session_timeout (s);
1387 /* add new session */
1388 GNUNET_CONTAINER_DLL_insert (plugin->head, plugin->tail, s);
1390 /* initiate new connection */
1391 if (GNUNET_SYSERR == client_connect (s))
1393 GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
1394 "Cannot connect to peer `%s' address `%s''\n",
1395 http_common_plugin_address_to_string (NULL, s->addr, s->addrlen),
1396 GNUNET_i2s (&s->target));
1397 client_delete_session (s);
1405 * Setup http_client plugin
1407 * @param plugin the plugin handle
1408 * @return GNUNET_OK on success, GNUNET_SYSERR on error
1411 client_start (struct HTTP_Client_Plugin *plugin)
1413 curl_global_init (CURL_GLOBAL_ALL);
1414 plugin->curl_multi_handle = curl_multi_init ();
1416 if (NULL == plugin->curl_multi_handle)
1418 GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
1419 _("Could not initialize curl multi handle, failed to start %s plugin!\n"),
1421 return GNUNET_SYSERR;
1427 * Session was idle, so disconnect it
1430 client_session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1432 GNUNET_assert (NULL != cls);
1433 struct Session *s = cls;
1435 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1436 GNUNET_log (TIMEOUT_LOG,
1437 "Session %p was idle for %llu ms, disconnecting\n",
1438 s, (unsigned long long) CLIENT_SESSION_TIMEOUT.rel_value);
1440 /* call session destroy function */
1441 GNUNET_assert (GNUNET_OK == client_disconnect (s));
1446 * Start session timeout for session s
1448 * @param s the session
1451 client_start_session_timeout (struct Session *s)
1454 GNUNET_assert (NULL != s);
1455 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == s->timeout_task);
1456 s->timeout_task = GNUNET_SCHEDULER_add_delayed (CLIENT_SESSION_TIMEOUT,
1457 &client_session_timeout,
1459 GNUNET_log (TIMEOUT_LOG,
1460 "Timeout for session %p set to %llu ms\n",
1461 s, (unsigned long long) CLIENT_SESSION_TIMEOUT.rel_value);
1466 * Increment session timeout due to activity for session s
1468 * param s the session
1471 client_reschedule_session_timeout (struct Session *s)
1474 GNUNET_assert (NULL != s);
1475 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
1477 GNUNET_SCHEDULER_cancel (s->timeout_task);
1478 s->timeout_task = GNUNET_SCHEDULER_add_delayed (CLIENT_SESSION_TIMEOUT,
1479 &client_session_timeout,
1481 GNUNET_log (TIMEOUT_LOG,
1482 "Timeout rescheduled for session %p set to %llu ms\n",
1483 s, (unsigned long long) CLIENT_SESSION_TIMEOUT.rel_value);
1488 * Cancel timeout due to activity for session s
1490 * param s the session
1493 client_stop_session_timeout (struct Session *s)
1495 GNUNET_assert (NULL != s);
1497 if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
1499 GNUNET_SCHEDULER_cancel (s->timeout_task);
1500 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1501 GNUNET_log (TIMEOUT_LOG, "Timeout stopped for session %p\n", s);
1507 * Another peer has suggested an address for this
1508 * peer and transport plugin. Check that this could be a valid
1509 * address. If so, consider adding it to the list
1512 * @param cls closure
1513 * @param addr pointer to the address
1514 * @param addrlen length of addr
1515 * @return GNUNET_OK if this is a plausible address for this peer
1519 http_client_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
1521 /* struct Plugin *plugin = cls; */
1523 /* A HTTP/S client does not have any valid address so:*/
1529 * Exit point from the plugin.
1531 * @param cls api as closure
1535 LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
1537 struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
1538 struct HTTP_Client_Plugin *plugin = api->cls;
1539 struct Session *pos;
1540 struct Session *next;
1542 if (NULL == api->cls)
1549 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1550 _("Shutting down plugin `%s'\n"),
1554 next = plugin->head;
1555 while (NULL != (pos = next))
1558 client_disconnect (pos);
1560 if (GNUNET_SCHEDULER_NO_TASK != plugin->client_perform_task)
1562 GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
1563 plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
1567 if (NULL != plugin->curl_multi_handle)
1569 curl_multi_cleanup (plugin->curl_multi_handle);
1570 plugin->curl_multi_handle = NULL;
1572 curl_global_cleanup ();
1574 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1575 _("Shutdown for plugin `%s' complete\n"),
1578 GNUNET_free (plugin);
1587 * @param plugin the plugin handle
1588 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
1591 client_configure_plugin (struct HTTP_Client_Plugin *plugin)
1593 unsigned long long max_connections;
1595 /* Optional parameters */
1596 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
1598 "MAX_CONNECTIONS", &max_connections))
1599 max_connections = 128;
1600 plugin->max_connections = max_connections;
1602 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
1603 _("Maximum number of connections is %u\n"),
1604 plugin->max_connections);
1609 * Entry point for the plugin.
1612 LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
1614 struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
1615 struct GNUNET_TRANSPORT_PluginFunctions *api;
1616 struct HTTP_Client_Plugin *plugin;
1618 if (NULL == env->receive)
1620 /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
1621 initialze the plugin or the API */
1622 api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
1624 api->address_to_string = &http_common_plugin_address_to_string;
1625 api->string_to_address = &http_common_plugin_string_to_address;
1626 api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
1630 plugin = GNUNET_malloc (sizeof (struct HTTP_Client_Plugin));
1633 api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
1635 api->send = &http_client_plugin_send;
1636 api->disconnect = &http_client_plugin_disconnect;
1637 api->check_address = &http_client_plugin_address_suggested;
1638 api->get_session = &http_client_plugin_get_session;
1639 api->address_to_string = &http_common_plugin_address_to_string;
1640 api->string_to_address = &http_common_plugin_string_to_address;
1641 api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
1645 plugin->name = "transport-https_client";
1646 plugin->protocol = "https";
1648 plugin->name = "transport-http_client";
1649 plugin->protocol = "http";
1651 plugin->last_tag = 1;
1653 if (GNUNET_SYSERR == client_configure_plugin (plugin))
1655 LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
1660 if (GNUNET_SYSERR == client_start (plugin))
1662 LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
1668 /* end of plugin_transport_http_client.c */