From 0a217a8df1657b4334b55b0e4a6c7837a8dbcfd9 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Fri, 29 May 2009 00:46:26 +0000 Subject: ng --- src/transport/Makefile.am | 84 + src/transport/NOTES | 46 + src/transport/gnunet-service-transport.c | 2852 +++++++++++++++++++++++++++ src/transport/gnunet-transport.c | 42 + src/transport/plugin_transport.h | 468 +++++ src/transport/plugin_transport_http.c | 2085 ++++++++++++++++++++ src/transport/plugin_transport_smtp.c | 906 +++++++++ src/transport/plugin_transport_tcp.c | 1782 +++++++++++++++++ src/transport/plugin_transport_template.c | 335 ++++ src/transport/plugin_transport_udp.c | 592 ++++++ src/transport/test_transport_api.c | 305 +++ src/transport/test_transport_api_data.conf | 24 + src/transport/test_transport_api_peer1.conf | 25 + src/transport/test_transport_api_peer2.conf | 25 + src/transport/transport.h | 238 +++ src/transport/transport_api.c | 1863 +++++++++++++++++ 16 files changed, 11672 insertions(+) create mode 100644 src/transport/Makefile.am create mode 100644 src/transport/NOTES create mode 100644 src/transport/gnunet-service-transport.c create mode 100644 src/transport/gnunet-transport.c create mode 100644 src/transport/plugin_transport.h create mode 100644 src/transport/plugin_transport_http.c create mode 100644 src/transport/plugin_transport_smtp.c create mode 100644 src/transport/plugin_transport_tcp.c create mode 100644 src/transport/plugin_transport_template.c create mode 100644 src/transport/plugin_transport_udp.c create mode 100644 src/transport/test_transport_api.c create mode 100644 src/transport/test_transport_api_data.conf create mode 100644 src/transport/test_transport_api_peer1.conf create mode 100644 src/transport/test_transport_api_peer2.conf create mode 100644 src/transport/transport.h create mode 100644 src/transport/transport_api.c (limited to 'src/transport') diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am new file mode 100644 index 000000000..236dec7c4 --- /dev/null +++ b/src/transport/Makefile.am @@ -0,0 +1,84 @@ +INCLUDES = -I$(top_srcdir)/src/include + +plugindir = $(libdir)/gnunet + +if MINGW + WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols +endif + +if USE_COVERAGE + AM_CFLAGS = -fprofile-arcs -ftest-coverage +endif + + +lib_LTLIBRARIES = \ + libgnunettransport.la + +libgnunettransport_la_SOURCES = \ + transport_api.c transport.h +libgnunettransport_la_LIBADD = \ + $(top_builddir)/src/arm/libgnunetarm.la \ + $(top_builddir)/src/hello/libgnunethello.la \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(GN_LIBINTL) +libgnunettransport_la_LDFLAGS = \ + $(GN_LIB_LDFLAGS) $(WINFLAGS) \ + -version-info 0:0:0 + + +bin_PROGRAMS = \ + gnunet-transport \ + gnunet-service-transport + +gnunet_transport_SOURCES = \ + gnunet-transport.c +gnunet_transport_LDADD = \ + $(top_builddir)/src/transport/libgnunettransport.la \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(GN_LIBINTL) + +gnunet_service_transport_SOURCES = \ + gnunet-service-transport.c +gnunet_service_transport_LDADD = \ + $(top_builddir)/src/peerinfo/libgnunetpeerinfo.la \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(GN_LIBINTL) + + + +plugin_LTLIBRARIES = \ + libgnunet_plugin_transport_tcp.la \ + libgnunet_plugin_transport_template.la +# TODO: add udp, http, nat, etc. + +libgnunet_plugin_transport_tcp_la_SOURCES = \ + plugin_transport_tcp.c +libgnunet_plugin_transport_tcp_la_LIBADD = \ + $(top_builddir)/src/resolver/libgnunetresolver.la \ + $(top_builddir)/src/util/libgnunetutil.la +libgnunet_plugin_transport_tcp_la_LDFLAGS = \ + $(GN_PLUGIN_LDFLAGS) + +libgnunet_plugin_transport_template_la_SOURCES = \ + plugin_transport_template.c +libgnunet_plugin_transport_template_la_LDFLAGS = \ + $(GN_PLUGIN_LDFLAGS) + + +check_PROGRAMS = \ + test_transport_api +# TODO: add tests for tcp, udp, http, nat, etc. + +TESTS = $(check_PROGRAMS) + +test_transport_api_SOURCES = \ + test_transport_api.c +test_transport_api_LDADD = \ + $(top_builddir)/src/transport/libgnunettransport.la \ + $(top_builddir)/src/util/libgnunetutil.la + + +EXTRA_DIST = \ + test_transport_api_data.conf \ + test_transport_api_peer1.conf \ + test_transport_api_peer2.conf diff --git a/src/transport/NOTES b/src/transport/NOTES new file mode 100644 index 000000000..41404e1f9 --- /dev/null +++ b/src/transport/NOTES @@ -0,0 +1,46 @@ +KEY DESIGN CHOICES: + - who decides which connections to keep/create? + => higher level session/key management! + - who enforces things like F2F topology, etc? + => higher level session/key management! + - who tracks all known HELLOs & validates? + => We validate, PEERINFO tracks! + - who advertises our HELLO? + => us! (need background job; previously: advertising) + - who advertises other peers HELLOs? + => higher level (core?) + - who does bootstrapping? + => bootstrap service (external!) + - who enforces inbound bandwidth limits? + => transport-service and plugins! (previously: core); + either by limiting reads (TCP) or discarding packets + (transport-service) + - who enforces outbound bandwidth limits? + => transport_api! + - who decides outbound bandwidth limits? + => other peer, via core (need authenticated limits!) + - who decides inbound bandwidth limits? + => core / apps above core (need trust info) + - cost function for transports is latency estimate in ms + => plugin provides latency data, transport-service + selects plugin(s) for transmission + - who is responsible for fragmentation? + => plugins! (may use common shared library) + - should we require UDP to be reliable? + => NO. There are other places that may (rarely) + use messages that we can not fix + - how do we access the 50% of service that we need for TCP/UDP + from service.c without code replication or getting 50% + that we do not want (i.e. shutdown, pid-file-writing, etc.) + => use GNUNET_SERVICE_start/stop functions! + - At what level do we manage timeouts? + => At the plugin (TCP connections), + transport-service (neighbours) and + core (sessions) level! + => All plugins have to disconnect before service-level + disconnect occurs + => We can have a plugin-connection die, but the session + survives! + => We can have a session die (no further authenticated + communication) even if the plugin thinks it is still + up! diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c new file mode 100644 index 000000000..08745c378 --- /dev/null +++ b/src/transport/gnunet-service-transport.c @@ -0,0 +1,2852 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/gnunet-service-transport.c + * @brief low-level P2P messaging + * @author Christian Grothoff + * + * TODO: + * - if we do not receive an ACK in response to our + * HELLO, retransmit HELLO! + */ +#include "platform.h" +#include "gnunet_client_lib.h" +#include "gnunet_getopt_lib.h" +#include "gnunet_hello_lib.h" +#include "gnunet_os_lib.h" +#include "gnunet_peerinfo_service.h" +#include "gnunet_plugin_lib.h" +#include "gnunet_protocols.h" +#include "gnunet_service_lib.h" +#include "gnunet_signatures.h" +#include "plugin_transport.h" +#include "transport.h" + +/** + * How many messages can we have pending for a given client process + * before we start to drop incoming messages? We typically should + * have only one client and so this would be the primary buffer for + * messages, so the number should be chosen rather generously. + * + * The expectation here is that most of the time the queue is large + * enough so that a drop is virtually never required. + */ +#define MAX_PENDING 128 + +/** + * How often should we try to reconnect to a peer using a particular + * transport plugin before giving up? Note that the plugin may be + * added back to the list after PLUGIN_RETRY_FREQUENCY expires. + */ +#define MAX_CONNECT_RETRY 3 + +/** + * How often must a peer violate bandwidth quotas before we start + * to simply drop its messages? + */ +#define QUOTA_VIOLATION_DROP_THRESHOLD 100 + +/** + * How long until a HELLO verification attempt should time out? + */ +#define HELLO_VERIFICATION_TIMEOUT GNUNET_TIME_UNIT_MINUTES + +/** + * How often do we re-add (cheaper) plugins to our list of plugins + * to try for a given connected peer? + */ +#define PLUGIN_RETRY_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15) + +/** + * After how long do we expire an address in a HELLO + * that we just validated? This value is also used + * for our own addresses when we create a HELLO. + */ +#define HELLO_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 12) + +/** + * After how long do we consider a connection to a peer dead + * if we don't receive messages from the peer? + */ +#define IDLE_CONNECTION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) + + +/** + * Entry in linked list of network addresses. + */ +struct AddressList +{ + /** + * This is a linked list. + */ + struct AddressList *next; + + /** + * The address, actually a pointer to the end + * of this struct. Do not free! + */ + void *addr; + + /** + * How long until we auto-expire this address (unless it is + * re-confirmed by the transport)? + */ + struct GNUNET_TIME_Absolute expires; + + /** + * Length of addr. + */ + size_t addrlen; + +}; + + +/** + * Entry in linked list of all of our plugins. + */ +struct TransportPlugin +{ + + /** + * This is a linked list. + */ + struct TransportPlugin *next; + + /** + * API of the transport as returned by the plugin's + * initialization function. + */ + struct GNUNET_TRANSPORT_PluginFunctions *api; + + /** + * Short name for the plugin (i.e. "tcp"). + */ + char *short_name; + + /** + * Name of the library (i.e. "gnunet_plugin_transport_tcp"). + */ + char *lib_name; + + /** + * List of our known addresses for this transport. + */ + struct AddressList *addresses; + + /** + * Environment this transport service is using + * for this plugin. + */ + struct GNUNET_TRANSPORT_PluginEnvironment env; + + /** + * ID of task that is used to clean up expired addresses. + */ + GNUNET_SCHEDULER_TaskIdentifier address_update_task; + + + /** + * Set to GNUNET_YES if we need to scrap the existing + * list of "addresses" and start fresh when we receive + * the next address update from a transport. Set to + * GNUNET_NO if we should just add the new address + * to the list and wait for the commit call. + */ + int rebuild; +}; + +struct NeighbourList; + +/** + * For each neighbour we keep a list of messages + * that we still want to transmit to the neighbour. + */ +struct MessageQueue +{ + + /** + * This is a linked list. + */ + struct MessageQueue *next; + + /** + * The message we want to transmit. + */ + struct GNUNET_MessageHeader *message; + + /** + * Client responsible for queueing the message; + * used to check that a client has not two messages + * pending for the same target. Can be NULL. + */ + struct TransportClient *client; + + /** + * Neighbour this entry belongs to. + */ + struct NeighbourList *neighbour; + + /** + * Plugin that we used for the transmission. + * NULL until we scheduled a transmission. + */ + struct TransportPlugin *plugin; + + /** + * Internal message of the transport system that should not be + * included in the usual SEND-SEND_OK transmission confirmation + * traffic management scheme. Typically, "internal_msg" will + * be set whenever "client" is NULL (but it is not strictly + * required). + */ + int internal_msg; + +}; + + +/** + * For a given Neighbour, which plugins are available + * to talk to this peer and what are their costs? + */ +struct ReadyList +{ + + /** + * This is a linked list. + */ + struct ReadyList *next; + + /** + * Which of our transport plugins does this entry + * represent? + */ + struct TransportPlugin *plugin; + + /** + * Neighbour this entry belongs to. + */ + struct NeighbourList *neighbour; + + /** + * Opaque handle (specific to the plugin) for the + * connection to our target; can be NULL. + */ + void *plugin_handle; + + /** + * What was the last latency observed for this plugin + * and peer? Invalid if connected is GNUNET_NO. + */ + struct GNUNET_TIME_Relative latency; + + /** + * If we did not successfully transmit a message to the + * given peer via this connection during the specified + * time, we should consider the connection to be dead. + * This is used in the case that a TCP transport simply + * stalls writing to the stream but does not formerly + * get a signal that the other peer died. + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * Is this plugin currently connected? The first time + * we transmit or send data to a peer via a particular + * plugin, we set this to GNUNET_YES. If we later get + * an error (disconnect notification or transmission + * failure), we set it back to GNUNET_NO. Each time the + * value is set to GNUNET_YES, we increment the + * "connect_attempts" counter. If that one reaches a + * particular threshold, we consider the plugin to not + * be working properly at this time for the given peer + * and remove it from the eligible list. + */ + int connected; + + /** + * How often have we tried to connect using this plugin? + */ + unsigned int connect_attempts; + + /** + * Is this plugin ready to transmit to the specific + * target? GNUNET_NO if not. Initially, all plugins + * are marked ready. If a transmission is in progress, + * "transmit_ready" is set to GNUNET_NO. + */ + int transmit_ready; + +}; + + +/** + * Entry in linked list of all of our current neighbours. + */ +struct NeighbourList +{ + + /** + * This is a linked list. + */ + struct NeighbourList *next; + + /** + * Which of our transports is connected to this peer + * and what is their status? + */ + struct ReadyList *plugins; + + /** + * List of messages we would like to send to this peer; + * must contain at most one message per client. + */ + struct MessageQueue *messages; + + /** + * Identity of this neighbour. + */ + struct GNUNET_PeerIdentity id; + + /** + * ID of task scheduled to run when this peer is about to + * time out (will free resources associated with the peer). + */ + GNUNET_SCHEDULER_TaskIdentifier timeout_task; + + /** + * How long until we should consider this peer dead + * (if we don't receive another message in the + * meantime)? + */ + struct GNUNET_TIME_Absolute peer_timeout; + + /** + * At what time did we reset last_received last? + */ + struct GNUNET_TIME_Absolute last_quota_update; + + /** + * At what time should we try to again add plugins to + * our ready list? + */ + struct GNUNET_TIME_Absolute retry_plugins_time; + + /** + * How many bytes have we received since the "last_quota_update" + * timestamp? + */ + uint64_t last_received; + + /** + * Global quota for outbound traffic for the neighbour in bytes/ms. + */ + uint32_t quota_in; + + /** + * What is the latest version of our HELLO that we have + * sent to this neighbour? + */ + unsigned int hello_version_sent; + + /** + * How often has the other peer (recently) violated the + * inbound traffic limit? Incremented by 10 per violation, + * decremented by 1 per non-violation (for each + * time interval). + */ + unsigned int quota_violation_count; + + /** + * Have we seen an ACK from this neighbour in the past? + * (used to make up a fake ACK for clients connecting after + * the neighbour connected to us). + */ + int saw_ack; + +}; + + +/** + * Linked list of messages to be transmitted to + * the client. Each entry is followed by the + * actual message. + */ +struct ClientMessageQueueEntry +{ + /** + * This is a linked list. + */ + struct ClientMessageQueueEntry *next; +}; + + +/** + * Client connected to the transport service. + */ +struct TransportClient +{ + + /** + * This is a linked list. + */ + struct TransportClient *next; + + /** + * Handle to the client. + */ + struct GNUNET_SERVER_Client *client; + + /** + * Linked list of messages yet to be transmitted to + * the client. + */ + struct ClientMessageQueueEntry *message_queue_head; + + /** + * Tail of linked list of messages yet to be transmitted to the + * client. + */ + struct ClientMessageQueueEntry *message_queue_tail; + + /** + * Is a call to "transmit_send_continuation" pending? If so, we + * must not free this struct (even if the corresponding client + * disconnects) and instead only remove it from the linked list and + * set the "client" field to NULL. + */ + int tcs_pending; + + /** + * Length of the list of messages pending for this client. + */ + unsigned int message_count; + +}; + + +/** + * Message used to ask a peer to validate receipt (to check an address + * from a HELLO). Followed by the address used. Note that the + * recipients response does not affirm that he has this address, + * only that he got the challenge message. + */ +struct ValidationChallengeMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PING + */ + struct GNUNET_MessageHeader header; + + /** + * What are we signing and why? + */ + struct GNUNET_CRYPTO_RsaSignaturePurpose purpose; + + /** + * Random challenge number (in network byte order). + */ + uint32_t challenge GNUNET_PACKED; + + /** + * Who is the intended recipient? + */ + struct GNUNET_PeerIdentity target; +}; + + +/** + * Message used to validate a HELLO. If this was + * the right recipient, the response is a signature + * of the original validation request. The + * challenge is included in the confirmation to make + * matching of replies to requests possible. + */ +struct ValidationChallengeResponse +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PONG + */ + struct GNUNET_MessageHeader header; + + /** + * Random challenge number (in network byte order). + */ + uint32_t challenge GNUNET_PACKED; + + /** + * Who signed this message? + */ + struct GNUNET_PeerIdentity sender; + + /** + * Signature. + */ + struct GNUNET_CRYPTO_RsaSignature signature; + +}; + + +/** + * For each HELLO, we may have to validate multiple addresses; + * each address gets its own request entry. + */ +struct ValidationAddress +{ + /** + * This is a linked list. + */ + struct ValidationAddress *next; + + /** + * Our challenge message. Points to after this + * struct, so this field should not be freed. + */ + struct ValidationChallengeMessage *msg; + + /** + * Name of the transport. + */ + char *transport_name; + + /** + * When should this validated address expire? + */ + struct GNUNET_TIME_Absolute expiration; + + /** + * Length of the address we are validating. + */ + size_t addr_len; + + /** + * Set to GNUNET_YES if the challenge was met, + * GNUNET_SYSERR if we know it failed, GNUNET_NO + * if we are waiting on a response. + */ + int ok; +}; + + +/** + * Entry in linked list of all HELLOs awaiting validation. + */ +struct ValidationList +{ + + /** + * This is a linked list. + */ + struct ValidationList *next; + + /** + * Linked list with one entry per address from the HELLO + * that needs to be validated. + */ + struct ValidationAddress *addresses; + + /** + * The public key of the peer. + */ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey; + + /** + * When does this record time-out? (assuming the + * challenge goes unanswered) + */ + struct GNUNET_TIME_Absolute timeout; + +}; + + +/** + * HELLOs awaiting validation. + */ +static struct ValidationList *pending_validations; + +/** + * Our HELLO message. + */ +static struct GNUNET_HELLO_Message *our_hello; + +/** + * "version" of "our_hello". Used to see if a given + * neighbour has already been sent the latest version + * of our HELLO message. + */ +static unsigned int our_hello_version; + +/** + * Our public key. + */ +static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key; + +/** + * Our identity. + */ +static struct GNUNET_PeerIdentity my_identity; + +/** + * Our private key. + */ +static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key; + +/** + * Our scheduler. + */ +struct GNUNET_SCHEDULER_Handle *sched; + +/** + * Our configuration. + */ +struct GNUNET_CONFIGURATION_Handle *cfg; + +/** + * Linked list of all clients to this service. + */ +static struct TransportClient *clients; + +/** + * All loaded plugins. + */ +static struct TransportPlugin *plugins; + +/** + * Our server. + */ +static struct GNUNET_SERVER_Handle *server; + +/** + * All known neighbours and their HELLOs. + */ +static struct NeighbourList *neighbours; + +/** + * Default bandwidth quota for receiving for new peers in bytes/ms. + */ +static uint32_t default_quota_in; + +/** + * Default bandwidth quota for sending for new peers in bytes/ms. + */ +static uint32_t default_quota_out; + +/** + * Number of neighbours we'd like to have. + */ +static uint32_t max_connect_per_transport; + + +/** + * Find an entry in the neighbour list for a particular peer. + * + * @return NULL if not found. + */ +static struct NeighbourList * +find_neighbour (const struct GNUNET_PeerIdentity *key) +{ + struct NeighbourList *head = neighbours; + while ((head != NULL) && + (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity)))) + head = head->next; + return head; +} + + +/** + * Find an entry in the transport list for a particular transport. + * + * @return NULL if not found. + */ +static struct TransportPlugin * +find_transport (const char *short_name) +{ + struct TransportPlugin *head = plugins; + while ((head != NULL) && (0 != strcmp (short_name, head->short_name))) + head = head->next; + return head; +} + + +/** + * Update the quota values for the given neighbour now. + */ +static void +update_quota (struct NeighbourList *n) +{ + struct GNUNET_TIME_Relative delta; + uint64_t allowed; + uint64_t remaining; + + delta = GNUNET_TIME_absolute_get_duration (n->last_quota_update); + if (delta.value < MIN_QUOTA_REFRESH_TIME) + return; /* not enough time passed for doing quota update */ + allowed = delta.value * n->quota_in; + if (n->last_received < allowed) + { + remaining = allowed - n->last_received; + if (n->quota_in > 0) + remaining /= n->quota_in; + else + remaining = 0; + if (remaining > MAX_BANDWIDTH_CARRY) + remaining = MAX_BANDWIDTH_CARRY; + n->last_received = 0; + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->last_quota_update.value -= remaining; + if (n->quota_violation_count > 0) + n->quota_violation_count--; + } + else + { + n->last_received -= allowed; + n->last_quota_update = GNUNET_TIME_absolute_get (); + if (n->last_received > allowed) + { + /* more than twice the allowed rate! */ + n->quota_violation_count += 10; + } + } +} + + +/** + * Function called to notify a client about the socket + * being ready to queue more data. "buf" will be + * NULL and "size" zero if the socket was closed for + * writing in the meantime. + * + * @param cls closure + * @param size number of bytes available in buf + * @param buf where the callee should write the message + * @return number of bytes written to buf + */ +static size_t +transmit_to_client_callback (void *cls, size_t size, void *buf) +{ + struct TransportClient *client = cls; + struct ClientMessageQueueEntry *q; + uint16_t msize; + size_t tsize; + const struct GNUNET_MessageHeader *msg; + struct GNUNET_NETWORK_TransmitHandle *th; + char *cbuf; + + if (buf == NULL) + { + /* fatal error with client, free message queue! */ + while (NULL != (q = client->message_queue_head)) + { + client->message_queue_head = q->next; + GNUNET_free (q); + } + client->message_queue_tail = NULL; + client->message_count = 0; + return 0; + } + cbuf = buf; + tsize = 0; + while (NULL != (q = client->message_queue_head)) + { + msg = (const struct GNUNET_MessageHeader *) &q[1]; + msize = ntohs (msg->size); + if (msize + tsize > size) + break; + client->message_queue_head = q->next; + if (q->next == NULL) + client->message_queue_tail = NULL; + memcpy (&cbuf[tsize], msg, msize); + tsize += msize; + GNUNET_free (q); + client->message_count--; + } + GNUNET_assert (tsize > 0); + if (NULL != q) + { + th = GNUNET_SERVER_notify_transmit_ready (client->client, + msize, + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_client_callback, + client); + GNUNET_assert (th != NULL); + } + return tsize; +} + + +/** + * Send the specified message to the specified client. Since multiple + * messages may be pending for the same client at a time, this code + * makes sure that no message is lost. + * + * @param client client to transmit the message to + * @param msg the message to send + * @param may_drop can this message be dropped if the + * message queue for this client is getting far too large? + */ +static void +transmit_to_client (struct TransportClient *client, + const struct GNUNET_MessageHeader *msg, int may_drop) +{ + struct ClientMessageQueueEntry *q; + uint16_t msize; + struct GNUNET_NETWORK_TransmitHandle *th; + + if ((client->message_count >= MAX_PENDING) && (GNUNET_YES == may_drop)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ + ("Dropping message, have %u messages pending (%u is the soft limit)\n"), + client->message_count, MAX_PENDING); + /* TODO: call to statistics... */ + return; + } + client->message_count++; + msize = ntohs (msg->size); + q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize); + memcpy (&q[1], msg, msize); + /* append to message queue */ + if (client->message_queue_tail == NULL) + { + client->message_queue_tail = q; + } + else + { + client->message_queue_tail->next = q; + client->message_queue_tail = q; + } + if (client->message_queue_head == NULL) + { + client->message_queue_head = q; + th = GNUNET_SERVER_notify_transmit_ready (client->client, + msize, + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_client_callback, + client); + GNUNET_assert (th != NULL); + } +} + + +/** + * Find alternative plugins for communication. + * + * @param neighbour for which neighbour should we try to find + * more plugins? + */ +static void +try_alternative_plugins (struct NeighbourList *neighbour) +{ + struct ReadyList *rl; + + if ((neighbour->plugins != NULL) && + (neighbour->retry_plugins_time.value > + GNUNET_TIME_absolute_get ().value)) + return; /* don't try right now */ + neighbour->retry_plugins_time + = GNUNET_TIME_relative_to_absolute (PLUGIN_RETRY_FREQUENCY); + + rl = neighbour->plugins; + while (rl != NULL) + { + if (rl->connect_attempts > 0) + rl->connect_attempts--; /* amnesty */ + rl = rl->next; + } + +} + + +/** + * Check the ready list for the given neighbour and + * if a plugin is ready for transmission (and if we + * have a message), do so! + * + * @param neighbour target peer for which to check the plugins + */ +static void try_transmission_to_peer (struct NeighbourList *neighbour); + + +/** + * Function called by the GNUNET_TRANSPORT_TransmitFunction + * upon "completion" of a send request. This tells the API + * that it is now legal to send another message to the given + * peer. + * + * @param cls closure, identifies the entry on the + * message queue that was transmitted and the + * client responsible for queueing the message + * @param rl identifies plugin used for the transmission for + * this neighbour; needs to be re-enabled for + * future transmissions + * @param target the peer receiving the message + * @param result GNUNET_OK on success, if the transmission + * failed, we should not tell the client to transmit + * more messages + */ +static void +transmit_send_continuation (void *cls, + struct ReadyList *rl, + const struct GNUNET_PeerIdentity *target, + int result) +{ + struct MessageQueue *mq = cls; + struct SendOkMessage send_ok_msg; + struct NeighbourList *n; + + GNUNET_assert (mq != NULL); + n = mq->neighbour; + GNUNET_assert (0 == + memcmp (&n->id, target, + sizeof (struct GNUNET_PeerIdentity))); + if (rl == NULL) + { + rl = n->plugins; + while ((rl != NULL) && (rl->plugin != mq->plugin)) + rl = rl->next; + GNUNET_assert (rl != NULL); + } + if (result == GNUNET_OK) + rl->timeout = GNUNET_TIME_relative_to_absolute (IDLE_CONNECTION_TIMEOUT); + else + rl->connected = GNUNET_NO; + if (!mq->internal_msg) + rl->transmit_ready = GNUNET_YES; + if (mq->client != NULL) + { + send_ok_msg.header.size = htons (sizeof (send_ok_msg)); + send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK); + send_ok_msg.success = htonl (result); + send_ok_msg.peer = n->id; + transmit_to_client (mq->client, &send_ok_msg.header, GNUNET_NO); + } + GNUNET_free (mq->message); + GNUNET_free (mq); + /* one plugin just became ready again, try transmitting + another message (if available) */ + try_transmission_to_peer (n); +} + + + + +/** + * We could not use an existing (or validated) connection to + * talk to a peer. Try addresses that have not yet been + * validated. + * + * @param n neighbour we want to communicate with + * @return plugin ready to talk, or NULL if none is available + */ +static struct ReadyList * +try_unvalidated_addresses (struct NeighbourList *n) +{ + struct ValidationList *vl; + struct ValidationAddress *va; + struct GNUNET_PeerIdentity id; + struct GNUNET_TIME_Absolute now; + unsigned int total; + unsigned int cnt; + struct ReadyList *rl; + struct TransportPlugin *plugin; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Trying to connect to `%4s' using unvalidated addresses\n", + GNUNET_i2s (&n->id)); +#endif + /* NOTE: this function needs to not only identify the + plugin but also setup "plugin_handle", binding it to the + right address using the plugin's "send_to" API */ + now = GNUNET_TIME_absolute_get (); + vl = pending_validations; + while (vl != NULL) + { + GNUNET_CRYPTO_hash (&vl->publicKey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &id.hashPubKey); + if (0 == memcmp (&id, &n->id, sizeof (struct GNUNET_PeerIdentity))) + break; + vl = vl->next; + } + if (vl == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No unvalidated address found for peer `%4s'\n", + GNUNET_i2s (&n->id)); +#endif + return NULL; + } + total = 0; + cnt = 0; + va = vl->addresses; + while (va != NULL) + { + cnt++; + if (va->expiration.value > now.value) + total++; + va = va->next; + } + if (total == 0) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "All %u unvalidated addresses for peer have expired\n", + cnt); +#endif + return NULL; + } + total = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total); + for (va = vl->addresses; va != NULL; va = va->next) + { + if (va->expiration.value <= now.value) + continue; + if (total > 0) + { + total--; + continue; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Trying unvalidated address of `%s' transport\n", + va->transport_name); +#endif + plugin = find_transport (va->transport_name); + if (plugin == NULL) + { + GNUNET_break (0); + break; + } + rl = GNUNET_malloc (sizeof (struct ReadyList)); + rl->next = n->plugins; + n->plugins = rl; + rl->plugin = plugin; + rl->plugin_handle = plugin->api->send_to (plugin->api->cls, + &n->id, + NULL, + NULL, + GNUNET_TIME_UNIT_ZERO, + &va->msg[1], va->addr_len); + rl->transmit_ready = GNUNET_YES; + return rl; + } + return NULL; +} + + +/** + * Check the ready list for the given neighbour and + * if a plugin is ready for transmission (and if we + * have a message), do so! + */ +static void +try_transmission_to_peer (struct NeighbourList *neighbour) +{ + struct ReadyList *pos; + struct GNUNET_TIME_Relative min_latency; + struct ReadyList *rl; + struct MessageQueue *mq; + struct GNUNET_TIME_Absolute now; + + if (neighbour->messages == NULL) + return; /* nothing to do */ + try_alternative_plugins (neighbour); + min_latency = GNUNET_TIME_UNIT_FOREVER_REL; + rl = NULL; + mq = neighbour->messages; + now = GNUNET_TIME_absolute_get (); + pos = neighbour->plugins; + while (pos != NULL) + { + /* set plugins that are inactive for a long time back to disconnected */ + if ((pos->timeout.value < now.value) && (pos->connected == GNUNET_YES)) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Marking long-time inactive connection to `%4s' as down.\n", + GNUNET_i2s (&neighbour->id)); +#endif + pos->connected = GNUNET_NO; + } + if (((GNUNET_YES == pos->transmit_ready) || + (mq->internal_msg)) && + (pos->connect_attempts < MAX_CONNECT_RETRY) && + ((rl == NULL) || (min_latency.value > pos->latency.value))) + { + rl = pos; + min_latency = pos->latency; + } + pos = pos->next; + } + if (rl == NULL) + rl = try_unvalidated_addresses (neighbour); + if (rl == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No plugin ready to transmit message\n"); +#endif + return; /* nobody ready */ + } + if (GNUNET_NO == rl->connected) + { + rl->connect_attempts++; + rl->connected = GNUNET_YES; + } + neighbour->messages = mq->next; + mq->plugin = rl->plugin; + if (!mq->internal_msg) + rl->transmit_ready = GNUNET_NO; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Giving message of type `%u' for `%4s' to plugin `%s'\n", + ntohs (mq->message->type), + GNUNET_i2s (&neighbour->id), rl->plugin->short_name); +#endif + rl->plugin_handle + = rl->plugin->api->send (rl->plugin->api->cls, + rl->plugin_handle, + rl, + &neighbour->id, + mq->message, + IDLE_CONNECTION_TIMEOUT, + &transmit_send_continuation, mq); +} + + +/** + * Send the specified message to the specified peer. + * + * @param client source of the transmission request (can be NULL) + * @param msg message to send + * @param is_internal is this an internal message + * @param neighbour handle to the neighbour for transmission + */ +static void +transmit_to_peer (struct TransportClient *client, + const struct GNUNET_MessageHeader *msg, + int is_internal, struct NeighbourList *neighbour) +{ + struct MessageQueue *mq; + struct MessageQueue *mqe; + struct GNUNET_MessageHeader *m; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + _("Sending message of type %u to peer `%4s'\n"), + ntohs (msg->type), GNUNET_i2s (&neighbour->id)); +#endif + if (client != NULL) + { + /* check for duplicate submission */ + mq = neighbour->messages; + while (NULL != mq) + { + if (mq->client == client) + { + /* client transmitted to same peer twice + before getting SendOk! */ + GNUNET_break (0); + return; + } + mq = mq->next; + } + } + mq = GNUNET_malloc (sizeof (struct MessageQueue)); + mq->client = client; + m = GNUNET_malloc (ntohs (msg->size)); + memcpy (m, msg, ntohs (msg->size)); + mq->message = m; + mq->neighbour = neighbour; + mq->internal_msg = is_internal; + + /* find tail */ + mqe = neighbour->messages; + if (mqe != NULL) + while (mqe->next != NULL) + mqe = mqe->next; + if (mqe == NULL) + { + /* new head */ + neighbour->messages = mq; + try_transmission_to_peer (neighbour); + } + else + { + /* append */ + mqe->next = mq; + } +} + + +struct GeneratorContext +{ + struct TransportPlugin *plug_pos; + struct AddressList *addr_pos; + struct GNUNET_TIME_Absolute expiration; +}; + + +static size_t +address_generator (void *cls, size_t max, void *buf) +{ + struct GeneratorContext *gc = cls; + size_t ret; + + while ((gc->addr_pos == NULL) && (gc->plug_pos != NULL)) + { + gc->plug_pos = gc->plug_pos->next; + gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL; + } + if (NULL == gc->plug_pos) + return 0; + ret = GNUNET_HELLO_add_address (gc->plug_pos->short_name, + gc->expiration, + gc->addr_pos->addr, + gc->addr_pos->addrlen, buf, max); + gc->addr_pos = gc->addr_pos->next; + return ret; +} + + +/** + * Construct our HELLO message from all of the addresses of + * all of the transports. + */ +static void +refresh_hello () +{ + struct GNUNET_HELLO_Message *hello; + struct TransportClient *cpos; + struct NeighbourList *npos; + struct GeneratorContext gc; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Refreshing my HELLO\n"); +#endif + gc.plug_pos = plugins; + gc.addr_pos = plugins != NULL ? plugins->addresses : NULL; + gc.expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION); + hello = GNUNET_HELLO_create (&my_public_key, &address_generator, &gc); + cpos = clients; + while (cpos != NULL) + { + transmit_to_client (cpos, + (const struct GNUNET_MessageHeader *) hello, + GNUNET_NO); + cpos = cpos->next; + } + + GNUNET_free_non_null (our_hello); + our_hello = hello; + our_hello_version++; + npos = neighbours; + while (npos != NULL) + { + transmit_to_peer (NULL, + (const struct GNUNET_MessageHeader *) our_hello, + GNUNET_YES, npos); + npos = npos->next; + } +} + + +/** + * Task used to clean up expired addresses for a plugin. + * + * @param cls closure + * @param tc context + */ +static void +expire_address_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc); + + +/** + * Update the list of addresses for this plugin, + * expiring those that are past their expiration date. + * + * @param plugin addresses of which plugin should be recomputed? + * @param fresh set to GNUNET_YES if a new address was added + * and we need to regenerate the HELLO even if nobody + * expired + */ +static void +update_addresses (struct TransportPlugin *plugin, int fresh) +{ + struct GNUNET_TIME_Relative min_remaining; + struct GNUNET_TIME_Relative remaining; + struct GNUNET_TIME_Absolute now; + struct AddressList *pos; + struct AddressList *prev; + struct AddressList *next; + int expired; + + if (plugin->address_update_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + GNUNET_SCHEDULER_cancel (plugin->env.sched, plugin->address_update_task); + plugin->address_update_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + now = GNUNET_TIME_absolute_get (); + min_remaining = GNUNET_TIME_UNIT_FOREVER_REL; + expired = GNUNET_NO; + prev = NULL; + pos = plugin->addresses; + while (pos != NULL) + { + next = pos->next; + if (pos->expires.value < now.value) + { + expired = GNUNET_YES; + if (prev == NULL) + plugin->addresses = pos->next; + else + prev->next = pos->next; + GNUNET_free (pos); + } + else + { + remaining = GNUNET_TIME_absolute_get_remaining (pos->expires); + if (remaining.value < min_remaining.value) + min_remaining = remaining; + prev = pos; + } + pos = next; + } + + if (expired || fresh) + refresh_hello (); + if (min_remaining.value < GNUNET_TIME_UNIT_FOREVER_REL.value) + plugin->address_update_task + = GNUNET_SCHEDULER_add_delayed (plugin->env.sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + min_remaining, + &expire_address_task, plugin); + +} + + +/** + * Task used to clean up expired addresses for a plugin. + * + * @param cls closure + * @param tc context + */ +static void +expire_address_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct TransportPlugin *plugin = cls; + plugin->address_update_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + update_addresses (plugin, GNUNET_NO); +} + + +/** + * Function that must be called by each plugin to notify the + * transport service about the addresses under which the transport + * provided by the plugin can be reached. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + * @param expires when should this address automatically expire? + */ +static void +plugin_env_notify_address (void *cls, + const char *name, + const void *addr, + size_t addrlen, + struct GNUNET_TIME_Relative expires) +{ + struct TransportPlugin *p = cls; + struct AddressList *al; + struct GNUNET_TIME_Absolute abex; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Plugin `%s' informs us about a new address\n", name); +#endif + abex = GNUNET_TIME_relative_to_absolute (expires); + GNUNET_assert (p == find_transport (name)); + + al = p->addresses; + while (al != NULL) + { + if ((addrlen == al->addrlen) && (0 == memcmp (addr, &al[1], addrlen))) + { + if (al->expires.value < abex.value) + al->expires = abex; + return; + } + al = al->next; + } + al = GNUNET_malloc (sizeof (struct AddressList) + addrlen); + al->addr = &al[1]; + al->next = p->addresses; + p->addresses = al; + al->expires = abex; + al->addrlen = addrlen; + memcpy (&al[1], addr, addrlen); + update_addresses (p, GNUNET_YES); +} + + +struct LookupHelloContext +{ + GNUNET_TRANSPORT_AddressCallback iterator; + + void *iterator_cls; +}; + + +static int +lookup_address_callback (void *cls, + const char *tname, + struct GNUNET_TIME_Absolute expiration, + const void *addr, size_t addrlen) +{ + struct LookupHelloContext *lhc = cls; + lhc->iterator (lhc->iterator_cls, tname, addr, addrlen); + return GNUNET_OK; +} + + +static void +lookup_hello_callback (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *h, uint32_t trust) +{ + struct LookupHelloContext *lhc = cls; + + if (peer == NULL) + { + lhc->iterator (lhc->iterator_cls, NULL, NULL, 0); + GNUNET_free (lhc); + return; + } + if (h == NULL) + return; + GNUNET_HELLO_iterate_addresses (h, + GNUNET_NO, &lookup_address_callback, lhc); +} + + +/** + * Function that allows a transport to query the known + * network addresses for a given peer. + * + * @param cls closure + * @param timeout after how long should we time out? + * @param target which peer are we looking for? + * @param iter function to call for each known address + * @param iter_cls closure for iter + */ +static void +plugin_env_lookup_address (void *cls, + struct GNUNET_TIME_Relative timeout, + const struct GNUNET_PeerIdentity *target, + GNUNET_TRANSPORT_AddressCallback iter, + void *iter_cls) +{ + struct LookupHelloContext *lhc; + + lhc = GNUNET_malloc (sizeof (struct LookupHelloContext)); + lhc->iterator = iter; + lhc->iterator_cls = iter_cls; + GNUNET_PEERINFO_for_all (cfg, + sched, + target, 0, timeout, &lookup_hello_callback, &lhc); +} + + +/** + * Notify all of our clients about a peer connecting. + */ +static void +notify_clients_connect (const struct GNUNET_PeerIdentity *peer, + struct GNUNET_TIME_Relative latency) +{ + struct ConnectInfoMessage cim; + struct TransportClient *cpos; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Informing clients about peer `%4s' connecting to us\n", + GNUNET_i2s (peer)); +#endif + cim.header.size = htons (sizeof (struct ConnectInfoMessage)); + cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); + cim.quota_out = htonl (default_quota_out); + cim.latency = GNUNET_TIME_relative_hton (latency); + memcpy (&cim.id, peer, sizeof (struct GNUNET_PeerIdentity)); + cpos = clients; + while (cpos != NULL) + { + transmit_to_client (cpos, &cim.header, GNUNET_NO); + cpos = cpos->next; + } +} + + +/** + * Notify all of our clients about a peer disconnecting. + */ +static void +notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer) +{ + struct DisconnectInfoMessage dim; + struct TransportClient *cpos; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Informing clients about peer `%4s' disconnecting\n", + GNUNET_i2s (peer)); +#endif + dim.header.size = htons (sizeof (struct DisconnectInfoMessage)); + dim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT); + dim.reserved = htonl (0); + memcpy (&dim.peer, peer, sizeof (struct GNUNET_PeerIdentity)); + cpos = clients; + while (cpos != NULL) + { + transmit_to_client (cpos, &dim.header, GNUNET_NO); + cpos = cpos->next; + } +} + + +/** + * Copy any validated addresses to buf. + * + * @return 0 once all addresses have been + * returned + */ +static size_t +list_validated_addresses (void *cls, size_t max, void *buf) +{ + struct ValidationAddress **va = cls; + size_t ret; + + while ((NULL != *va) && ((*va)->ok != GNUNET_YES)) + *va = (*va)->next; + if (NULL == *va) + return 0; + ret = GNUNET_HELLO_add_address ((*va)->transport_name, + (*va)->expiration, + &(*va)->msg[1], (*va)->addr_len, buf, max); + *va = (*va)->next; + return ret; +} + + +/** + * HELLO validation cleanup task. + */ +static void +cleanup_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct ValidationAddress *va; + struct ValidationList *pos; + struct ValidationList *prev; + struct GNUNET_TIME_Absolute now; + struct GNUNET_HELLO_Message *hello; + struct GNUNET_PeerIdentity pid; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "HELLO validation cleanup background task running...\n"); +#endif + now = GNUNET_TIME_absolute_get (); + prev = NULL; + pos = pending_validations; + while (pos != NULL) + { + if (pos->timeout.value < now.value) + { + if (prev == NULL) + pending_validations = pos->next; + else + prev->next = pos->next; + va = pos->addresses; + hello = GNUNET_HELLO_create (&pos->publicKey, + &list_validated_addresses, &va); + GNUNET_CRYPTO_hash (&pos->publicKey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &pid.hashPubKey); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating persistent `%s' message for peer `%4s' based on confirmed addresses.\n", + "HELLO", GNUNET_i2s (&pid)); +#endif + GNUNET_PEERINFO_add_peer (cfg, sched, &pid, hello); + GNUNET_free (hello); + while (NULL != (va = pos->addresses)) + { + pos->addresses = va->next; + GNUNET_free (va->transport_name); + GNUNET_free (va); + } + GNUNET_free (pos); + if (prev == NULL) + pos = pending_validations; + else + pos = prev->next; + continue; + } + prev = pos; + pos = pos->next; + } + + /* finally, reschedule cleanup if needed; list is + ordered by timeout, so we need the last element... */ + pos = pending_validations; + while ((pos != NULL) && (pos->next != NULL)) + pos = pos->next; + if (NULL != pos) + GNUNET_SCHEDULER_add_delayed (sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_absolute_get_remaining (pos-> + timeout), + &cleanup_validation, NULL); +} + + +struct CheckHelloValidatedContext +{ + /** + * Plugin for which we are validating. + */ + struct TransportPlugin *plugin; + + /** + * Hello that we are validating. + */ + struct GNUNET_HELLO_Message *hello; + + /** + * Validation list being build. + */ + struct ValidationList *e; +}; + + +/** + * Append the given address to the list of entries + * that need to be validated. + */ +static int +run_validation (void *cls, + const char *tname, + struct GNUNET_TIME_Absolute expiration, + const void *addr, size_t addrlen) +{ + struct ValidationList *e = cls; + struct TransportPlugin *tp; + struct ValidationAddress *va; + struct ValidationChallengeMessage *vcm; + + tp = find_transport (tname); + if (tp == NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO | + GNUNET_ERROR_TYPE_BULK, + _ + ("Transport `%s' not loaded, will not try to validate peer address using this transport.\n"), + tname); + return GNUNET_OK; + } + va = GNUNET_malloc (sizeof (struct ValidationAddress) + + sizeof (struct ValidationChallengeMessage) + addrlen); + va->next = e->addresses; + e->addresses = va; + vcm = (struct ValidationChallengeMessage *) &va[1]; + va->msg = vcm; + va->transport_name = GNUNET_strdup (tname); + va->addr_len = addrlen; + vcm->header.size = + htons (sizeof (struct ValidationChallengeMessage) + addrlen); + vcm->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PING); + vcm->purpose.size = + htonl (sizeof (struct ValidationChallengeMessage) + addrlen - + sizeof (struct GNUNET_MessageHeader)); + vcm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO); + vcm->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + (unsigned int) -1); + /* Note: vcm->target is set in check_hello_validated */ + memcpy (&vcm[1], addr, addrlen); + return GNUNET_OK; +} + + +/** + * Check if addresses in validated hello "h" overlap with + * those in "chvc->hello" and update "chvc->hello" accordingly, + * removing those addresses that have already been validated. + */ +static void +check_hello_validated (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *h, uint32_t trust) +{ + struct CheckHelloValidatedContext *chvc = cls; + struct ValidationAddress *va; + struct TransportPlugin *tp; + int first_call; + + first_call = GNUNET_NO; + if (chvc->e == NULL) + { + first_call = GNUNET_YES; + chvc->e = GNUNET_malloc (sizeof (struct ValidationList)); + GNUNET_HELLO_get_key (h != NULL ? h : chvc->hello, &chvc->e->publicKey); + chvc->e->timeout = + GNUNET_TIME_relative_to_absolute (HELLO_VERIFICATION_TIMEOUT); + chvc->e->next = pending_validations; + pending_validations = chvc->e; + } + if (h != NULL) + { + GNUNET_HELLO_iterate_new_addresses (chvc->hello, + h, + GNUNET_TIME_absolute_get (), + &run_validation, chvc->e); + } + else if (GNUNET_YES == first_call) + { + /* no existing HELLO, all addresses are new */ + GNUNET_HELLO_iterate_addresses (chvc->hello, + GNUNET_NO, &run_validation, chvc->e); + } + if (h != NULL) + return; /* wait for next call */ + /* finally, transmit validation attempts */ + va = chvc->e->addresses; + while (va != NULL) + { + GNUNET_CRYPTO_hash (&chvc->e->publicKey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &va->msg->target.hashPubKey); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Establishing `%s' connection to validate `%s' of `%4s' (sending our `%s')\n", + va->transport_name, + "HELLO", GNUNET_i2s (&va->msg->target), "HELLO"); +#endif + tp = find_transport (va->transport_name); + GNUNET_assert (tp != NULL); + if (NULL == + tp->api->send_to (tp->api->cls, + &va->msg->target, + (const struct GNUNET_MessageHeader *) our_hello, + &va->msg->header, + HELLO_VERIFICATION_TIMEOUT, + &va->msg[1], va->addr_len)) + va->ok = GNUNET_SYSERR; + va = va->next; + } + if (chvc->e->next == NULL) + GNUNET_SCHEDULER_add_delayed (sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_absolute_get_remaining (chvc-> + e-> + timeout), + &cleanup_validation, NULL); + GNUNET_free (chvc); +} + + +/** + * Process HELLO-message. + * + * @param plugin transport involved, may be NULL + * @param message the actual message + * @return GNUNET_OK if the HELLO was well-formed, GNUNET_SYSERR otherwise + */ +static int +process_hello (struct TransportPlugin *plugin, + const struct GNUNET_MessageHeader *message) +{ + struct ValidationList *e; + uint16_t hsize; + struct GNUNET_PeerIdentity target; + const struct GNUNET_HELLO_Message *hello; + struct CheckHelloValidatedContext *chvc; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey; + + hsize = ntohs (message->size); + if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_HELLO) || + (hsize < sizeof (struct GNUNET_MessageHeader))) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + /* first, check if load is too high */ + if (GNUNET_OS_load_cpu_get (cfg) > 100) + { + /* TODO: call to stats? */ + return GNUNET_OK; + } + hello = (const struct GNUNET_HELLO_Message *) message; + if (GNUNET_OK != GNUNET_HELLO_get_key (hello, &publicKey)) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + GNUNET_CRYPTO_hash (&publicKey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &target.hashPubKey); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Processing `%s' message for `%4s'\n", + "HELLO", GNUNET_i2s (&target)); +#endif + /* check if a HELLO for this peer is already on the validation list */ + e = pending_validations; + while (e != NULL) + { + if (0 == memcmp (&e->publicKey, + &publicKey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))) + { + /* TODO: call to stats? */ + return GNUNET_OK; + } + e = e->next; + } + chvc = GNUNET_malloc (sizeof (struct CheckHelloValidatedContext) + hsize); + chvc->plugin = plugin; + chvc->hello = (struct GNUNET_HELLO_Message *) &chvc[1]; + memcpy (chvc->hello, hello, hsize); + /* finally, check if HELLO was previously validated + (continuation will then schedule actual validation) */ + GNUNET_PEERINFO_for_all (cfg, + sched, + &target, + 0, + HELLO_VERIFICATION_TIMEOUT, + &check_hello_validated, chvc); + return GNUNET_OK; +} + + +/** + * Handle PING-message. If the plugin that gave us the message is + * able to queue the PONG immediately, we only queue one PONG. + * Otherwise we send at most TWO PONG messages, one via an unconfirmed + * transport and one via a confirmed transport. Both addresses are + * selected randomly among those available. + * + * @param plugin plugin that gave us the message + * @param sender claimed sender of the PING + * @param plugin_context context that might be used to send response + * @param message the actual message + */ +static void +process_ping (struct TransportPlugin *plugin, + const struct GNUNET_PeerIdentity *sender, + void *plugin_context, + const struct GNUNET_MessageHeader *message) +{ + const struct ValidationChallengeMessage *vcm; + struct ValidationChallengeResponse vcr; + uint16_t msize; + struct NeighbourList *n; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Processing PING\n"); +#endif + msize = ntohs (message->size); + if (msize < sizeof (struct ValidationChallengeMessage)) + { + GNUNET_break_op (0); + return; + } + vcm = (const struct ValidationChallengeMessage *) message; + if (0 != memcmp (&vcm->target, + &my_identity, sizeof (struct GNUNET_PeerIdentity))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Received `%s' message not destined for me!\n"), "PING"); + /* TODO: call statistics */ + return; + } + if ((ntohl (vcm->purpose.size) != + msize - sizeof (struct GNUNET_MessageHeader)) + || (ntohl (vcm->purpose.purpose) != + GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO)) + { + GNUNET_break_op (0); + return; + } + msize -= sizeof (struct ValidationChallengeMessage); + if (GNUNET_OK != + plugin->api->address_suggested (plugin->api->cls, &vcm[1], msize)) + { + GNUNET_break_op (0); + return; + } + vcr.header.size = htons (sizeof (struct ValidationChallengeResponse)); + vcr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG); + vcr.challenge = vcm->challenge; + vcr.sender = my_identity; + GNUNET_assert (GNUNET_OK == + GNUNET_CRYPTO_rsa_sign (my_private_key, + &vcm->purpose, &vcr.signature)); +#if EXTRA_CHECKS + GNUNET_assert (GNUNET_OK == + GNUNET_CRYPTO_rsa_verify + (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO, &vcm->purpose, + &vcr.signature, &my_public_key)); +#endif +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Trying to transmit PONG using inbound connection\n"); +#endif + n = find_neighbour (sender); + transmit_to_peer (NULL, &vcr.header, GNUNET_YES, n); +} + + +/** + * Handle PONG-message. + * + * @param message the actual message + */ +static void +process_pong (struct TransportPlugin *plugin, + const struct GNUNET_MessageHeader *message) +{ + const struct ValidationChallengeResponse *vcr; + struct ValidationList *pos; + struct GNUNET_PeerIdentity peer; + struct ValidationAddress *va; + int all_done; + int matched; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Processing PONG\n"); +#endif + vcr = (const struct ValidationChallengeResponse *) message; + pos = pending_validations; + while (pos != NULL) + { + GNUNET_CRYPTO_hash (&pos->publicKey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &peer.hashPubKey); + if (0 == + memcmp (&peer, &vcr->sender, sizeof (struct GNUNET_PeerIdentity))) + break; + pos = pos->next; + } + if (pos == NULL) + { + /* TODO: call statistics (unmatched PONG) */ + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ + ("Received `%s' message but have no record of a matching `%s' message. Ignoring.\n"), + "PONG", "PING"); + return; + } + all_done = GNUNET_YES; + matched = GNUNET_NO; + va = pos->addresses; + while (va != NULL) + { + if (va->msg->challenge == vcr->challenge) + { + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify + (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO, &va->msg->purpose, + &vcr->signature, &pos->publicKey)) + { + /* this could rarely happen if we used the same + challenge number for the peer for two different + transports / addresses, but the likelihood is + very small... */ + GNUNET_break_op (0); + } + else + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Confirmed validity of peer address.\n"); +#endif + va->ok = GNUNET_YES; + va->expiration = + GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION); + matched = GNUNET_YES; + } + } + if (va->ok != GNUNET_YES) + all_done = GNUNET_NO; + va = va->next; + } + if (GNUNET_NO == matched) + { + /* TODO: call statistics (unmatched PONG) */ + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ + ("Received `%s' message but have no record of a matching `%s' message. Ignoring.\n"), + "PONG", "PING"); + } + if (GNUNET_YES == all_done) + { + pos->timeout.value = 0; + GNUNET_SCHEDULER_add_delayed (sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_UNIT_ZERO, + &cleanup_validation, NULL); + } +} + + +/** + * The peer specified by the given neighbour has timed-out. Update + * our state and do the necessary notifications. Also notifies + * our clients that the neighbour is now officially gone. + * + * @param n the neighbour list entry for the peer + */ +static void +disconnect_neighbour (struct NeighbourList *n) +{ + struct ReadyList *rpos; + struct NeighbourList *npos; + struct NeighbourList *nprev; + struct MessageQueue *mq; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Disconnecting from neighbour\n"); +#endif + /* remove n from neighbours list */ + nprev = NULL; + npos = neighbours; + while ((npos != NULL) && (npos != n)) + { + nprev = npos; + npos = npos->next; + } + GNUNET_assert (npos != NULL); + if (nprev == NULL) + neighbours = n->next; + else + nprev->next = n->next; + + /* notify all clients about disconnect */ + notify_clients_disconnect (&n->id); + + /* clean up all plugins, cancel connections & pending transmissions */ + while (NULL != (rpos = n->plugins)) + { + n->plugins = rpos->next; + GNUNET_assert (rpos->neighbour == n); + rpos->plugin->api->cancel (rpos->plugin->api->cls, + rpos->plugin_handle, rpos, &n->id); + GNUNET_free (rpos); + } + + /* free all messages on the queue */ + while (NULL != (mq = n->messages)) + { + n->messages = mq->next; + GNUNET_assert (mq->neighbour == n); + GNUNET_free (mq); + } + + /* finally, free n itself */ + GNUNET_free (n); +} + + +/** + * Add an entry for each of our transport plugins + * (that are able to send) to the list of plugins + * for this neighbour. + * + * @param neighbour to initialize + */ +static void +add_plugins (struct NeighbourList *neighbour) +{ + struct TransportPlugin *tp; + struct ReadyList *rl; + + neighbour->retry_plugins_time + = GNUNET_TIME_relative_to_absolute (PLUGIN_RETRY_FREQUENCY); + tp = plugins; + while (tp != NULL) + { + if (tp->api->send != NULL) + { + rl = GNUNET_malloc (sizeof (struct ReadyList)); + rl->next = neighbour->plugins; + neighbour->plugins = rl; + rl->plugin = tp; + rl->neighbour = neighbour; + rl->transmit_ready = GNUNET_YES; + } + tp = tp->next; + } +} + + +static void +neighbour_timeout_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct NeighbourList *n = cls; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Neighbour has timed out!\n"); +#endif + n->timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + disconnect_neighbour (n); +} + + + +/** + * Create a fresh entry in our neighbour list for the given peer. + * Will try to transmit our current HELLO to the new neighbour. Also + * notifies our clients about the new "connection". + * + * @param peer the peer for which we create the entry + * @return the new neighbour list entry + */ +static struct NeighbourList * +setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) +{ + struct NeighbourList *n; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Setting up new neighbour `%4s', sending our HELLO to introduce ourselves\n", + GNUNET_i2s (peer)); +#endif + GNUNET_assert (our_hello != NULL); + n = GNUNET_malloc (sizeof (struct NeighbourList)); + n->next = neighbours; + neighbours = n; + n->id = *peer; + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->peer_timeout = + GNUNET_TIME_relative_to_absolute (IDLE_CONNECTION_TIMEOUT); + n->quota_in = default_quota_in; + add_plugins (n); + n->hello_version_sent = our_hello_version; + n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + IDLE_CONNECTION_TIMEOUT, + &neighbour_timeout_task, n); + transmit_to_peer (NULL, + (const struct GNUNET_MessageHeader *) our_hello, + GNUNET_YES, n); + notify_clients_connect (peer, GNUNET_TIME_UNIT_FOREVER_REL); + return n; +} + + +/** + * Function called by the plugin for each received message. + * Update data volumes, possibly notify plugins about + * reducing the rate at which they read from the socket + * and generally forward to our receive callback. + * + * @param plugin_context value to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing) + * @param service_context value passed to the transport-service + * to identify the neighbour; will be NULL on the first + * call for a given peer + * @param latency estimated latency for communicating with the + * given peer + * @param peer (claimed) identity of the other peer + * @param message the message, NULL if peer was disconnected + * @return the new service_context that the plugin should use + * for future receive calls for messages from this + * particular peer + */ +static struct ReadyList * +plugin_env_receive (void *cls, + void *plugin_context, + struct ReadyList *service_context, + struct GNUNET_TIME_Relative latency, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) +{ + const struct GNUNET_MessageHeader ack = { + htons (sizeof (struct GNUNET_MessageHeader)), + htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ACK) + }; + struct TransportPlugin *plugin = cls; + struct TransportClient *cpos; + struct InboundMessage *im; + uint16_t msize; + struct NeighbourList *n; + + if (service_context != NULL) + { + n = service_context->neighbour; + GNUNET_assert (n != NULL); + } + else + { + n = find_neighbour (peer); + if (n == NULL) + { + if (message == NULL) + return NULL; /* disconnect of peer already marked down */ + n = setup_new_neighbour (peer); + } + service_context = n->plugins; + while ((service_context != NULL) && (plugin != service_context->plugin)) + service_context = service_context->next; + GNUNET_assert ((plugin->api->send == NULL) || + (service_context != NULL)); + } + if (message == NULL) + { + if ((service_context != NULL) && + (service_context->plugin_handle == plugin_context)) + { + service_context->connected = GNUNET_NO; + service_context->plugin_handle = NULL; + } + /* TODO: call stats */ + return NULL; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Processing message of type `%u' received by plugin...\n", + ntohs (message->type)); +#endif + if (service_context != NULL) + { + if (service_context->connected == GNUNET_NO) + { + service_context->connected = GNUNET_YES; + service_context->transmit_ready = GNUNET_YES; + service_context->connect_attempts++; + } + service_context->timeout + = GNUNET_TIME_relative_to_absolute (IDLE_CONNECTION_TIMEOUT); + service_context->plugin_handle = plugin_context; + service_context->latency = latency; + } + /* update traffic received amount ... */ + msize = ntohs (message->size); + n->last_received += msize; + GNUNET_SCHEDULER_cancel (sched, n->timeout_task); + n->peer_timeout = + GNUNET_TIME_relative_to_absolute (IDLE_CONNECTION_TIMEOUT); + n->timeout_task = + GNUNET_SCHEDULER_add_delayed (sched, GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_IDLE, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + IDLE_CONNECTION_TIMEOUT, + &neighbour_timeout_task, n); + update_quota (n); + if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD) + { + /* dropping message due to frequent inbound volume violations! */ + GNUNET_log (GNUNET_ERROR_TYPE_WARNING | + GNUNET_ERROR_TYPE_BULK, + _ + ("Dropping incoming message due to repeated bandwidth quota violations.\n")); + /* TODO: call stats */ + return service_context; + } + switch (ntohs (message->type)) + { + case GNUNET_MESSAGE_TYPE_HELLO: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message from other peer.\n", "HELLO"); +#endif + process_hello (plugin, message); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message to connecting peer.\n", "ACK"); +#endif + transmit_to_peer (NULL, &ack, GNUNET_YES, n); + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_PING: + process_ping (plugin, peer, plugin_context, message); + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG: + process_pong (plugin, message); + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_ACK: + n->saw_ack = GNUNET_YES; + /* intentional fall-through! */ + default: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received message of type %u from other peer, sending to all clients.\n", + ntohs (message->type)); +#endif + /* transmit message to all clients */ + im = GNUNET_malloc (sizeof (struct InboundMessage) + msize); + im->header.size = htons (sizeof (struct InboundMessage) + msize); + im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); + im->latency = GNUNET_TIME_relative_hton (latency); + im->peer = *peer; + memcpy (&im[1], message, msize); + + cpos = clients; + while (cpos != NULL) + { + transmit_to_client (cpos, &im->header, GNUNET_YES); + cpos = cpos->next; + } + GNUNET_free (im); + } + return service_context; +} + + +/** + * Handle START-message. This is the first message sent to us + * by any client which causes us to add it to our list. + * + * @param cls closure (always NULL) + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_start (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + struct TransportClient *c; + struct ConnectInfoMessage cim; + struct NeighbourList *n; + struct InboundMessage *im; + struct GNUNET_MessageHeader *ack; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' request from client\n", "START"); +#endif + c = clients; + while (c != NULL) + { + if (c->client == client) + { + /* client already on our list! */ + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + c = c->next; + } + c = GNUNET_malloc (sizeof (struct TransportClient)); + c->next = clients; + clients = c; + c->client = client; + if (our_hello != NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending our own HELLO to new client\n"); +#endif + transmit_to_client (c, + (const struct GNUNET_MessageHeader *) our_hello, + GNUNET_NO); + /* tell new client about all existing connections */ + cim.header.size = htons (sizeof (struct ConnectInfoMessage)); + cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); + cim.quota_out = htonl (default_quota_out); + cim.latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO); /* FIXME? */ + im = GNUNET_malloc (sizeof (struct InboundMessage) + + sizeof (struct GNUNET_MessageHeader)); + im->header.size = htons (sizeof (struct InboundMessage) + + sizeof (struct GNUNET_MessageHeader)); + im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); + im->latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO); /* FIXME? */ + ack = (struct GNUNET_MessageHeader *) &im[1]; + ack->size = htons (sizeof (struct GNUNET_MessageHeader)); + ack->type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ACK); + for (n = neighbours; n != NULL; n = n->next) + { + cim.id = n->id; + transmit_to_client (c, &cim.header, GNUNET_NO); + if (n->saw_ack) + { + im->peer = n->id; + transmit_to_client (c, &im->header, GNUNET_NO); + } + } + GNUNET_free (im); + } + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} + + +/** + * Handle HELLO-message. + * + * @param cls closure (always NULL) + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_hello (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + int ret; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' request from client\n", "HELLO"); +#endif + ret = process_hello (NULL, message); + GNUNET_SERVER_receive_done (client, ret); +} + + +/** + * Handle SEND-message. + * + * @param cls closure (always NULL) + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_send (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + struct TransportClient *tc; + struct NeighbourList *n; + const struct OutboundMessage *obm; + const struct GNUNET_MessageHeader *obmm; + uint16_t size; + uint16_t msize; + + size = ntohs (message->size); + if (size < + sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader)) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + obm = (const struct OutboundMessage *) message; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' request from client with target `%4s'\n", + "SEND", GNUNET_i2s (&obm->peer)); +#endif + obmm = (const struct GNUNET_MessageHeader *) &obm[1]; + msize = ntohs (obmm->size); + if (size != msize + sizeof (struct OutboundMessage)) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + n = find_neighbour (&obm->peer); + if (n == NULL) + n = setup_new_neighbour (&obm->peer); + tc = clients; + while ((tc != NULL) && (tc->client != client)) + tc = tc->next; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Client asked to transmit %u-byte message of type %u to `%4s'\n", + ntohs (obmm->size), + ntohs (obmm->type), GNUNET_i2s (&obm->peer)); +#endif + transmit_to_peer (tc, obmm, GNUNET_NO, n); + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} + + +/** + * Handle SET_QUOTA-message. + * + * @param cls closure (always NULL) + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_set_quota (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + const struct QuotaSetMessage *qsm = + (const struct QuotaSetMessage *) message; + struct NeighbourList *n; + struct TransportPlugin *p; + struct ReadyList *rl; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' request from client for peer `%4s'\n", + "SET_QUOTA", GNUNET_i2s (&qsm->peer)); +#endif + n = find_neighbour (&qsm->peer); + if (n == NULL) + { + GNUNET_SERVER_receive_done (client, GNUNET_OK); + return; + } + update_quota (n); + if (n->quota_in < ntohl (qsm->quota_in)) + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->quota_in = ntohl (qsm->quota_in); + rl = n->plugins; + while (rl != NULL) + { + p = rl->plugin; + p->api->set_receive_quota (p->api->cls, + &qsm->peer, ntohl (qsm->quota_in)); + rl = rl->next; + } + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} + + +/** + * Handle TRY_CONNECT-message. + * + * @param cls closure (always NULL) + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_try_connect (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + const struct TryConnectMessage *tcm; + + tcm = (const struct TryConnectMessage *) message; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' request from client asking to connect to `%4s'\n", + "TRY_CONNECT", GNUNET_i2s (&tcm->peer)); +#endif + if (NULL == find_neighbour (&tcm->peer)) + setup_new_neighbour (&tcm->peer); + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} + + +/** + * List of handlers for the messages understood by this + * service. + */ +static struct GNUNET_SERVER_MessageHandler handlers[] = { + {&handle_start, NULL, + GNUNET_MESSAGE_TYPE_TRANSPORT_START, 0}, + {&handle_hello, NULL, + GNUNET_MESSAGE_TYPE_HELLO, 0}, + {&handle_send, NULL, + GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0}, + {&handle_set_quota, NULL, + GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)}, + {&handle_try_connect, NULL, + GNUNET_MESSAGE_TYPE_TRANSPORT_TRY_CONNECT, + sizeof (struct TryConnectMessage)}, + {NULL, NULL, 0, 0} +}; + + +/** + * Setup the environment for this plugin. + */ +static void +create_environment (struct TransportPlugin *plug) +{ + plug->env.cfg = cfg; + plug->env.sched = sched; + plug->env.my_public_key = &my_public_key; + plug->env.cls = plug; + plug->env.receive = &plugin_env_receive; + plug->env.lookup = &plugin_env_lookup_address; + plug->env.notify_address = &plugin_env_notify_address; + plug->env.default_quota_in = default_quota_in; + plug->env.max_connections = max_connect_per_transport; +} + + +/** + * Start the specified transport (load the plugin). + */ +static void +start_transport (struct GNUNET_SERVER_Handle *server, const char *name) +{ + struct TransportPlugin *plug; + char *libname; + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Loading `%s' transport plugin\n"), name); + GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", name); + plug = GNUNET_malloc (sizeof (struct TransportPlugin)); + create_environment (plug); + plug->short_name = GNUNET_strdup (name); + plug->lib_name = libname; + plug->next = plugins; + plugins = plug; + plug->api = GNUNET_PLUGIN_load (libname, &plug->env); + if (plug->api == NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to load transport plugin for `%s'\n"), name); + GNUNET_free (plug->short_name); + plugins = plug->next; + GNUNET_free (libname); + GNUNET_free (plug); + } +} + + +/** + * Called whenever a client is disconnected. Frees our + * resources associated with that client. + * + * @param cls closure + * @param client identification of the client + */ +static void +client_disconnect_notification (void *cls, + struct GNUNET_SERVER_Client *client) +{ + struct TransportClient *pos; + struct TransportClient *prev; + struct ClientMessageQueueEntry *mqe; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Client disconnected, cleaning up.\n"); +#endif + prev = NULL; + pos = clients; + while ((pos != NULL) && (pos->client != client)) + { + prev = pos; + pos = pos->next; + } + if (pos == NULL) + return; + while (NULL != (mqe = pos->message_queue_head)) + { + pos->message_queue_head = mqe->next; + GNUNET_free (mqe); + } + pos->message_queue_head = NULL; + if (prev == NULL) + clients = pos->next; + else + prev->next = pos->next; + if (GNUNET_YES == pos->tcs_pending) + { + pos->client = NULL; + return; + } + GNUNET_free (pos); +} + + +/** + * Initiate transport service. + * + * @param cls closure + * @param s scheduler to use + * @param serv the initialized server + * @param c configuration to use + */ +static void +run (void *cls, + struct GNUNET_SCHEDULER_Handle *s, + struct GNUNET_SERVER_Handle *serv, struct GNUNET_CONFIGURATION_Handle *c) +{ + char *plugs; + char *pos; + int no_transports; + unsigned long long qin; + unsigned long long qout; + unsigned long long tneigh; + char *keyfile; + + sched = s; + cfg = c; + /* parse configuration */ + if ((GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (c, + "TRANSPORT", + "DEFAULT_QUOTA_IN", + &qin)) || + (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (c, + "TRANSPORT", + "DEFAULT_QUOTA_OUT", + &qout)) || + (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (c, + "TRANSPORT", + "NEIGHBOUR_LIMIT", + &tneigh)) || + (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_filename (c, + "GNUNETD", + "HOSTKEY", &keyfile))) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ + ("Transport service is lacking key configuration settings. Exiting.\n")); + GNUNET_SCHEDULER_shutdown (s); + return; + } + max_connect_per_transport = (uint32_t) tneigh; + default_quota_in = (uint32_t) qin; + default_quota_out = (uint32_t) qout; + my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile); + GNUNET_free (keyfile); + if (my_private_key == NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ + ("Transport service could not access hostkey. Exiting.\n")); + GNUNET_SCHEDULER_shutdown (s); + return; + } + GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key); + GNUNET_CRYPTO_hash (&my_public_key, + sizeof (my_public_key), &my_identity.hashPubKey); + /* setup notification */ + server = serv; + GNUNET_SERVER_disconnect_notify (server, + &client_disconnect_notification, NULL); + /* load plugins... */ + no_transports = 1; + if (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_string (c, + "TRANSPORT", "PLUGINS", &plugs)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Starting transport plugins `%s'\n"), plugs); + pos = strtok (plugs, " "); + while (pos != NULL) + { + start_transport (server, pos); + no_transports = 0; + pos = strtok (NULL, " "); + } + GNUNET_free (plugs); + } + if (no_transports) + refresh_hello (); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n")); + /* process client requests */ + GNUNET_SERVER_add_handlers (server, handlers); +} + + +/** + * Function called when the service shuts + * down. Unloads our plugins. + * + * @param cls closure + * @param cfg configuration to use + */ +static void +unload_plugins (void *cls, struct GNUNET_CONFIGURATION_Handle *cfg) +{ + struct TransportPlugin *plug; + struct AddressList *al; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transport service is unloading plugins...\n"); +#endif + while (NULL != (plug = plugins)) + { + plugins = plug->next; + GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api)); + GNUNET_free (plug->lib_name); + GNUNET_free (plug->short_name); + while (NULL != (al = plug->addresses)) + { + plug->addresses = al->next; + GNUNET_free (al); + } + GNUNET_free (plug); + } + if (my_private_key != NULL) + GNUNET_CRYPTO_rsa_key_free (my_private_key); +} + + +/** + * The main function for the transport service. + * + * @param argc number of arguments from the command line + * @param argv command line arguments + * @return 0 ok, 1 on error + */ +int +main (int argc, char *const *argv) +{ + return (GNUNET_OK == + GNUNET_SERVICE_run (argc, + argv, + "transport", + &run, NULL, &unload_plugins, NULL)) ? 0 : 1; +} + +/* end of gnunet-service-transport.c */ diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c new file mode 100644 index 000000000..52475e3eb --- /dev/null +++ b/src/transport/gnunet-transport.c @@ -0,0 +1,42 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file server/gnunet-transport.c + * @brief Tool to help configure the transports. + * @author Christian Grothoff + * + * This utility can be used to test if a transport mechanism for + * GNUnet is properly configured. + */ + +#include "platform.h" +#include "gnunet_program_lib.h" +#include "gnunet_protocols.h" +#include "gnunet_transport_service.h" + +int +main (int argc, char *const *argv) +{ + return 0; +} + + +/* end of gnunet-transport.c */ diff --git a/src/transport/plugin_transport.h b/src/transport/plugin_transport.h new file mode 100644 index 000000000..57df9affe --- /dev/null +++ b/src/transport/plugin_transport.h @@ -0,0 +1,468 @@ +/* + This file is part of GNUnet + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/plugin_transport.h + * @brief API for the transport services. This header + * specifies the struct that is given to the plugin's entry + * method and the other struct that must be returned. + * Note that the destructors of transport plugins will + * be given the value returned by the constructor + * and is expected to return a NULL pointer. + * + * TODO: + * - consider moving DATA message (latency measurement) + * to service; avoids encapsulation overheads and + * would enable latency measurements for non-bidi + * transports. + * - + * + * @author Christian Grothoff + */ +#ifndef PLUGIN_TRANSPORT_H +#define PLUGIN_TRANSPORT_H + +#include "gnunet_configuration_lib.h" +#include "gnunet_scheduler_lib.h" +#include "gnunet_transport_service.h" + +/** + * Opaque internal context for a particular peer of the transport + * service. Plugins will be given a pointer to this type and, if + * cheaply possible, should pass this pointer back to the transport + * service whenever additional messages from the same peer are + * received. + */ +struct ReadyList; + +/** + * Function called by the transport for each received message. + * This function should also be called with "NULL" for the + * message to signal that the other peer disconnected. + * + * @param cls closure + * @param plugin_context value to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing) + * @param service_context value passed to the transport-service + * to identify the neighbour; will be NULL on the first + * call for a given peer + * @param latency estimated latency for communicating with the + * given peer; should be set to GNUNET_TIME_UNIT_FOREVER_REL + * until the transport has seen messages transmitted in + * BOTH directions (and hence been able to do an actual + * round-trip observation); a non-FOREVER latency is also used + * by the transport to know that communication in both directions + * using this one plugin actually works + * @param peer (claimed) identity of the other peer + * @param message the message, NULL if peer was disconnected + * @return the new service_context that the plugin should use + * for future receive calls for messages from this + * particular peer + */ +typedef struct ReadyList * + (*GNUNET_TRANSPORT_PluginReceiveCallback) (void *cls, + void *plugin_context, + struct ReadyList * + service_context, + struct GNUNET_TIME_Relative + latency, + const struct GNUNET_PeerIdentity + * peer, + const struct GNUNET_MessageHeader + * message); + + +/** + * Function that will be called for each address the transport + * is aware that it might be reachable under. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + * @param expires when should this address automatically expire? + */ +typedef void (*GNUNET_TRANSPORT_AddressNotification) (void *cls, + const char *name, + const void *addr, + size_t addrlen, + struct + GNUNET_TIME_Relative + expires); + + +/** + * Function that will be called for each address obtained from the HELLO. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + */ +typedef void (*GNUNET_TRANSPORT_AddressCallback) (void *cls, + const char *name, + const void *addr, + size_t addrlen); + + +/** + * Function that allows a transport to query the known + * network addresses for a given peer. + * + * @param cls closure + * @param timeout after how long should we time out? + * @param target which peer are we looking for? + * @param iter function to call for each known address + * @param iter_cls closure for iter + */ +typedef void (*GNUNET_TRANSPORT_LookupAddress) (void *cls, + struct GNUNET_TIME_Relative + timeout, + const struct + GNUNET_PeerIdentity * target, + GNUNET_TRANSPORT_AddressCallback + iter, void *iter_cls); + + +/** + * The transport service will pass a pointer to a struct + * of this type as the first and only argument to the + * entry point of each transport plugin. + */ +struct GNUNET_TRANSPORT_PluginEnvironment +{ + /** + * Configuration to use. + */ + struct GNUNET_CONFIGURATION_Handle *cfg; + + /** + * Scheduler to use. + */ + struct GNUNET_SCHEDULER_Handle *sched; + + /** + * Our public key. + */ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *my_public_key; + + /** + * Closure for the various callbacks. + */ + void *cls; + + /** + * Function that should be called by the transport plugin + * whenever a message is received. + */ + GNUNET_TRANSPORT_PluginReceiveCallback receive; + + /** + * Address lookup function. + */ + GNUNET_TRANSPORT_LookupAddress lookup; + + /** + * Function that must be called by each plugin to notify the + * transport service about the addresses under which the transport + * provided by the plugin can be reached. + */ + GNUNET_TRANSPORT_AddressNotification notify_address; + + /** + * What is the default quota (in terms of incoming bytes per + * ms) for new connections? + */ + uint32_t default_quota_in; + + /** + * What is the maximum number of connections that this transport + * should allow? Transports that do not have sessions (such as + * UDP) can ignore this value. + */ + uint32_t max_connections; + +}; + + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin using a fresh connection (even if + * we already have a connection to this peer, this function is + * required to establish a new one). + * + * @param cls closure + * @param target who should receive this message + * @param msg1 first message to transmit + * @param msg2 second message to transmit (can be NULL) + * @param timeout how long should we try to transmit these? + * @param addrlen length of the address + * @param addr the address + * @return session instance if the transmission has been scheduled + * NULL if the address format is invalid + */ +typedef void * + (*GNUNET_TRANSPORT_TransmitToAddressFunction) (void *cls, + const struct + GNUNET_PeerIdentity * target, + const struct + GNUNET_MessageHeader * msg1, + const struct + GNUNET_MessageHeader * msg2, + struct GNUNET_TIME_Relative + timeout, const void *addr, + size_t addrlen); + +/** + * Function called by the GNUNET_TRANSPORT_TransmitFunction + * upon "completion". + * + * @param cls closure + * @param service_context value passed to the transport-service + * to identify the neighbour + * @param target who was the recipient of the message? + * @param result GNUNET_OK on success + * GNUNET_SYSERR if the target disconnected; + * disconnect will ALSO be signalled using + * the ReceiveCallback. + */ +typedef void + (*GNUNET_TRANSPORT_TransmitContinuation) (void *cls, + struct ReadyList * + service_context, + const struct GNUNET_PeerIdentity * + target, int result); + +/** + * 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. + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL + * @param service_context value passed to the transport-service + * to identify the neighbour; NULL is used to indicate + * an urgent message. If the urgent message can not be + * scheduled for immediate transmission, the plugin is to + * call the continuation with failure immediately + * @param target who should receive this message + * @param msg the message to transmit + * @param timeout how long to wait at most for the transmission + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...); can be NULL + * @param cont_cls closure for cont + * @return plugin_context that should be used next time for + * sending messages to the specified peer + */ +typedef void * + (*GNUNET_TRANSPORT_TransmitFunction) (void *cls, + void *plugin_context, + struct ReadyList * service_context, + const struct GNUNET_PeerIdentity * + target, + const struct GNUNET_MessageHeader * + msg, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_TransmitContinuation + cont, void *cont_cls); + + +/** + * Function that can be called to force a disconnect from the + * specified neighbour. This should also cancel all previously + * scheduled transmissions. Obviously the transmission may have been + * partially completed already, which is OK. The plugin is supposed + * to close the connection (if applicable) and no longer call the + * transmit continuation(s). + * + * Finally, plugin MUST NOT call the services's receive function to + * notify the service that the connection to the specified target was + * closed after a getting this call. + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL (if + * NULL was returned from the transmit function) + * @param service_context must correspond to the service context + * of the corresponding Transmit call; the plugin should + * not cancel a send call made with a different service + * context pointer! Never NULL. + * @param target peer for which the last transmission is + * to be cancelled + */ +typedef void + (*GNUNET_TRANSPORT_CancelFunction) (void *cls, + void *plugin_context, + struct ReadyList * service_context, + const struct GNUNET_PeerIdentity * + target); + + +/** + * Function called by the pretty printer for the resolved address for + * each human-readable address obtained. + * + * @param cls closure + * @param hostname one of the names for the host, NULL + * on the last call to the callback + */ +typedef void (*GNUNET_TRANSPORT_AddressStringCallback) (void *cls, + const char *address); + + +/** + * Convert the transports address to a nice, human-readable + * format. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + * @param numeric should (IP) addresses be displayed in numeric form? + * @param timeout after how long should we give up? + * @param asc function to call on each string + * @param asc_cls closure for asc + */ +typedef void + (*GNUNET_TRANSPORT_AddressPrettyPrinter) (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); + + +/** + * Set a quota for receiving data from the given peer; this is a + * per-transport limit. The transport should limit its read/select + * calls to stay below the quota (in terms of incoming data). + * + * @param cls closure + * @param peer the peer for whom the quota is given + * @param quota_in quota for receiving/sending data in bytes per ms + */ +typedef void + (*GNUNET_TRANSPORT_SetQuota) (void *cls, + const struct GNUNET_PeerIdentity * target, + uint32_t quota_in); + + +/** + * 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. + * + * @param addr pointer to the address + * @param addrlen length of addr + * @return GNUNET_OK if this is a plausible address for this peer + * and transport + */ +typedef int + (*GNUNET_TRANSPORT_SuggestAddress) (void *cls, + const void *addr, size_t addrlen); + +/** + * Each plugin is required to return a pointer to a struct of this + * type as the return value from its entry point. + */ +struct GNUNET_TRANSPORT_PluginFunctions +{ + + /** + * Closure for all of the callbacks. + */ + void *cls; + + /** + * Function used to send a single message to a particular + * peer using the specified address. Used to validate + * HELLOs. + */ + GNUNET_TRANSPORT_TransmitToAddressFunction send_to; + + /** + * Function that the transport service will use to transmit data to + * another peer. May be null for plugins that only support + * receiving data. After this call, the plugin call the specified + * continuation with success or error before notifying us about the + * target having disconnected. + */ + GNUNET_TRANSPORT_TransmitFunction send; + + /** + * Function that can be used to force the plugin to disconnect + * from the given peer and cancel all previous transmissions + * (and their continuationc). + */ + GNUNET_TRANSPORT_CancelFunction cancel; + + /** + * Function to pretty-print addresses. NOTE: this function is not + * yet used by transport-service, but will be used in the future + * once the transport-API has been completed. + */ + GNUNET_TRANSPORT_AddressPrettyPrinter address_pretty_printer; + + /** + * Function that the transport service can use to try to enforce a + * quota for the number of bytes received via this transport. + * Transports that can not refuse incoming data (such as UDP) + * are free to ignore these calls. + */ + GNUNET_TRANSPORT_SetQuota set_receive_quota; + + /** + * Function that will be called if another peer suggested that + * we should use a particular address (since he is reaching + * us at that address) for this transport. + */ + GNUNET_TRANSPORT_SuggestAddress address_suggested; + + /** + * Relative cost of this transport compared to others. This + * is supposed to be a static cost estimate which determines + * which plugins should not even be attempted if other, + * cheaper transports are already working. The idea is that + * the costs have roughly this relationship: + * 
+   * TCP < UDP < HTTP == HTTPS < SMTP
+   *
+ */ + unsigned int cost_estimate; +}; + + +#endif diff --git a/src/transport/plugin_transport_http.c b/src/transport/plugin_transport_http.c new file mode 100644 index 000000000..eb69f4386 --- /dev/null +++ b/src/transport/plugin_transport_http.c @@ -0,0 +1,2085 @@ +/* + This file is part of GNUnet + (C) 2003, 2004, 2005, 2006, 2007, 2008 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transports/http.c + * @brief Implementation of the HTTP transport service + * @author Christian Grothoff + */ + +#include "platform.h" +#include "gnunet_util.h" +#include "gnunet_protocols.h" +#include "gnunet_transport.h" +#include "gnunet_stats_service.h" +#include "gnunet_upnp_service.h" +#include +#include +#include +#include "ip.h" + +#define DEBUG_HTTP GNUNET_NO + +/** + * Disable GET (for debugging only!). Must be GNUNET_YES + * in production use! + */ +#define DO_GET GNUNET_YES + +/** + * After how much time of the core not being associated with a http + * connection anymore do we close it? + * + * Needs to be larger than SECONDS_INACTIVE_DROP in + * core's connection.s + */ +#define HTTP_TIMEOUT (600 * GNUNET_CRON_SECONDS) + +/** + * How often do we re-issue GET requests? + */ +#define HTTP_GET_REFRESH (5 * GNUNET_CRON_SECONDS) + +/** + * Default maximum size of the HTTP read and write buffer. + */ +#define HTTP_BUF_SIZE (64 * 1024) + +/** + * Text of the response sent back after the last bytes of a PUT + * request have been received (just to formally obey the HTTP + * protocol). + */ +#define HTTP_PUT_RESPONSE "Thank you!" + +#define MY_TRANSPORT_NAME "HTTP" +#include "common.c" + +/** + * Client-side data per PUT request. + */ +struct HTTPPutData +{ + /** + * This is a linked list. + */ + struct HTTPPutData *next; + + /** + * Handle to our CURL request. + */ + CURL *curl_put; + + /** + * Last time we made progress with the PUT. + */ + GNUNET_CronTime last_activity; + + /** + * The message we are sending. + */ + char *msg; + + /** + * Size of msg. + */ + unsigned int size; + + /** + * Current position in msg. + */ + unsigned int pos; + + /** + * Are we done sending? Set to 1 after we + * completed sending and started to receive + * a response ("Thank you!") or once the + * timeout has been reached. + */ + int done; + +}; + +/** + * Server-side data per PUT request. + */ +struct MHDPutData +{ + /** + * This is a linked list. + */ + struct MHDPutData *next; + + /** + * MHD connection handle for this request. + */ + struct MHD_Connection *session; + + /** + * Last time we received data on this PUT + * connection. + */ + GNUNET_CronTime last_activity; + + /** + * Read buffer for the header (from PUT) + */ + char rbuff1[sizeof (GNUNET_MessageHeader)]; + + /** + * The read buffer (used only receiving PUT data). + */ + char *rbuff2; + + /** + * Number of valid bytes in rbuff1 + */ + unsigned int rpos1; + + /** + * Number of valid bytes in rbuff2 + */ + unsigned int rpos2; + + + /** + * Size of the rbuff2 buffer. + */ + unsigned int rsize2; + + /** + * Should we sent a response for this PUT yet? + */ + int ready; + + /** + * Have we sent a response for this PUT yet? + */ + int done; + +}; + +/** + * Server-side data for a GET request. + */ +struct MHDGetData +{ + + /** + * This is a linked list. + */ + struct MHDGetData *next; + + /** + * MHD connection handle for this request. + */ + struct MHD_Connection *session; + + /** + * GET session response handle + */ + struct MHD_Response *get; + + /** + * My HTTP session. + */ + struct HTTPSession *httpsession; + + /** + * The write buffer (for sending GET response) + */ + char *wbuff; + + /** + * What was the last time we were able to + * transmit data using the current get handle? + */ + GNUNET_CronTime last_get_activity; + + /** + * Current write position in wbuff + */ + unsigned int woff; + + /** + * Number of valid bytes in wbuff (starting at woff) + */ + unsigned int wpos; + + /** + * Size of the write buffer. + */ + unsigned int wsize; + +}; + +/** + * Transport Session handle. + */ +typedef struct HTTPSession +{ + + /** + * GNUNET_TSession for this session. + */ + GNUNET_TSession *tsession; + + /** + * To whom are we talking to. + */ + GNUNET_PeerIdentity sender; + + /** + * number of users of this session + */ + unsigned int users; + + /** + * Has this session been destroyed? + */ + int destroyed; + + /** + * Are we client or server? Determines which of the + * structs in the union below is being used for this + * connection! + */ + int is_client; + + /** + * Is MHD still using this session handle? + */ + int is_mhd_active; + + /** + * Data maintained for the http client-server connection + * (depends on if we are client or server). + */ + union + { + + struct + { + /** + * Active PUT requests (linked list). + */ + struct MHDPutData *puts; + +#if DO_GET + /** + * Active GET requests (linked list; most + * recent received GET is the head of the list). + */ + struct MHDGetData *gets; +#endif + + } server; + + struct + { + + /** + * Address of the other peer. + */ + HostAddress address; + +#if DO_GET + /** + * Last time the GET was active. + */ + GNUNET_CronTime last_get_activity; + + /** + * What was the last time we were able to + * transmit data using the current get handle? + */ + GNUNET_CronTime last_get_initiated; + + /** + * GET operation + */ + CURL *get; + + /** + * Read buffer for the header (from GET). + */ + char rbuff1[sizeof (GNUNET_MessageHeader)]; + + /** + * The read buffer (used only receiving GET data). + */ + char *rbuff2; + + /** + * Number of valid bytes in rbuff1 + */ + unsigned int rpos1; + + /** + * Number of valid bytes in rbuff2 + */ + unsigned int rpos2; + + /** + * Current size of the read buffer rbuff2. + */ + unsigned int rsize2; +#endif + + /** + * URL of the get and put operations. + */ + char *url; + + /** + * Linked list of PUT operations. + */ + struct HTTPPutData *puts; + + } client; + + } cs; + +} HTTPSession; + +/* *********** globals ************* */ + +static int stat_bytesReceived; + +static int stat_bytesSent; + +static int stat_bytesDropped; + +static int stat_get_issued; + +static int stat_get_received; + +static int stat_put_issued; + +static int stat_put_received; + +static int stat_select_calls; + +static int stat_send_calls; + +static int stat_connect_calls; + +static int stat_curl_send_callbacks; + +static int stat_curl_receive_callbacks; + +static int stat_mhd_access_callbacks; + +static int stat_mhd_read_callbacks; + +static int stat_mhd_close_callbacks; + +static int stat_connect_calls; + +/** + * How many requests do we have currently pending + * (with libcurl)? + */ +static unsigned int http_requests_pending; + +static int signal_pipe[2]; + +static char *proxy; + +/** + * Daemon for listening for new connections. + */ +static struct MHD_Daemon *mhd_daemon; + +/** + * Curl multi for managing client operations. + */ +static CURLM *curl_multi; + +/** + * Set to GNUNET_YES while the transport is running. + */ +static int http_running; + +/** + * Thread running libcurl activities. + */ +static struct GNUNET_ThreadHandle *curl_thread; + +/** + * Array of currently active HTTP sessions. + */ +static GNUNET_TSession **tsessions; + +/** + * Number of valid entries in tsessions. + */ +static unsigned int tsessionCount; + +/** + * Sie of the tsessions array. + */ +static unsigned int tsessionArrayLength; + +/** + * Lock for concurrent access to all structures used + * by http, including CURL. + */ +static struct GNUNET_Mutex *lock; + + +/** + * Signal select thread that its selector + * set may have changed. + */ +static void +signal_select () +{ + static char c; + WRITE (signal_pipe[1], &c, sizeof (c)); +} + +/** + * Check if we are allowed to connect to the given IP. + */ +static int +acceptPolicyCallback (void *cls, + const struct sockaddr *addr, socklen_t addr_len) +{ + if (GNUNET_NO != is_rejected_tester (addr, addr_len)) + return MHD_NO; + return MHD_YES; +} + +/** + * Disconnect from a remote node. May only be called + * on sessions that were acquired by the caller first. + * For the core, aquiration means to call associate or + * connect. The number of disconnects must match the + * number of calls to connect+associate. + * + * Sessions are actually discarded in cleanup_connections. + * + * + * @param tsession the session that is closed + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +httpDisconnect (GNUNET_TSession * tsession) +{ + HTTPSession *httpsession = tsession->internal; + if (httpsession == NULL) + { + GNUNET_free (tsession); + return GNUNET_OK; + } + GNUNET_mutex_lock (lock); + httpsession->users--; + GNUNET_mutex_unlock (lock); + return GNUNET_OK; +} + +static void +destroy_tsession (GNUNET_TSession * tsession) +{ + HTTPSession *httpsession = tsession->internal; + struct HTTPPutData *pos; + struct HTTPPutData *next; +#if DO_GET + struct MHDGetData *gpos; + struct MHDGetData *gnext; +#endif + struct MHD_Response *r; + int i; + + GNUNET_mutex_lock (lock); + for (i = 0; i < tsessionCount; i++) + { + if (tsessions[i] == tsession) + { + tsessions[i] = tsessions[--tsessionCount]; + break; + } + } + if (httpsession->is_client) + { +#if DO_GET + curl_multi_remove_handle (curl_multi, httpsession->cs.client.get); + http_requests_pending--; + signal_select (); + curl_easy_cleanup (httpsession->cs.client.get); + GNUNET_array_grow (httpsession->cs.client.rbuff2, + httpsession->cs.client.rsize2, 0); +#endif + GNUNET_free_non_null (httpsession->cs.client.url); + pos = httpsession->cs.client.puts; + while (pos != NULL) + { + next = pos->next; + curl_multi_remove_handle (curl_multi, pos->curl_put); + http_requests_pending--; + signal_select (); + curl_easy_cleanup (pos->curl_put); + GNUNET_free (pos->msg); + GNUNET_free (pos); + pos = next; + } + GNUNET_free (httpsession); + GNUNET_free (tsession); + } + else + { + httpsession->destroyed = GNUNET_YES; + GNUNET_GE_BREAK (NULL, httpsession->cs.server.puts == NULL); +#if DO_GET + gpos = httpsession->cs.server.gets; + while (gpos != NULL) + { + GNUNET_array_grow (gpos->wbuff, gpos->wsize, 0); + r = gpos->get; + gpos->get = NULL; + gnext = gpos->next; + MHD_destroy_response (r); + gpos = gnext; + } + httpsession->cs.server.gets = NULL; +#endif + GNUNET_free (httpsession->tsession); + GNUNET_free (httpsession); + } + GNUNET_mutex_unlock (lock); +} + +/** + * MHD is done handling a request. Cleanup + * the respective transport state. + */ +static void +requestCompletedCallback (void *unused, + struct MHD_Connection *session, + void **httpSessionCache) +{ + HTTPSession *httpsession = *httpSessionCache; + struct MHDPutData *pprev; + struct MHDPutData *ppos; +#if DO_GET + struct MHDGetData *gprev; + struct MHDGetData *gpos; +#endif + + if (stats != NULL) + stats->change (stat_mhd_close_callbacks, 1); + if (httpsession == NULL) + return; /* oops */ + GNUNET_GE_ASSERT (NULL, !httpsession->is_client); + pprev = NULL; + ppos = httpsession->cs.server.puts; + while (ppos != NULL) + { + if (ppos->session == session) + { + ppos->last_activity = 0; + signal_select (); + return; + } + pprev = ppos; + ppos = ppos->next; + } +#if DO_GET + gprev = NULL; + gpos = httpsession->cs.server.gets; + while (gpos != NULL) + { + if (gpos->session == session) + { + gpos->last_get_activity = 0; + signal_select (); + return; + } + gprev = gpos; + gpos = gpos->next; + } +#endif + httpsession->is_mhd_active--; +} + +/** + * A (core) Session is to be associated with a transport session. The + * transport service may want to know in order to call back on the + * core if the connection is being closed. Associate can also be + * called to test if it would be possible to associate the session + * later, in this case the argument session is NULL. This can be used + * to test if the connection must be closed by the core or if the core + * can assume that it is going to be self-managed (if associate + * returns GNUNET_OK and session was NULL, the transport layer is responsible + * for eventually freeing resources associated with the tesession). If + * session is not NULL, the core takes responsbility for eventually + * calling disconnect. + * + * @param tsession the session handle passed along + * from the call to receive that was made by the transport + * layer + * @return GNUNET_OK if the session could be associated, + * GNUNET_SYSERR if not. + */ +static int +httpAssociate (GNUNET_TSession * tsession) +{ + HTTPSession *httpSession; + + if (tsession == NULL) + { + GNUNET_GE_BREAK (NULL, 0); + return GNUNET_SYSERR; + } + httpSession = tsession->internal; + GNUNET_mutex_lock (lock); + if (httpSession->destroyed == GNUNET_YES) + { + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + httpSession->users++; + GNUNET_mutex_unlock (lock); + return GNUNET_OK; +} + +/** + * Add a new session to the array watched by the select thread. Grows + * the array if needed. If the caller wants to do anything useful + * with the return value, it must have the lock before + * calling. It is ok to call this function without holding lock if + * the return value is ignored. + */ +static unsigned int +addTSession (GNUNET_TSession * tsession) +{ + unsigned int i; + + GNUNET_mutex_lock (lock); + if (tsessionCount == tsessionArrayLength) + GNUNET_array_grow (tsessions, tsessionArrayLength, + tsessionArrayLength * 2); + i = tsessionCount; + tsessions[tsessionCount++] = tsession; + GNUNET_mutex_unlock (lock); + return i; +} + +#if DO_GET +/** + * Callback for processing GET requests if our side is the + * MHD HTTP server. + * + * @param cls the HTTP session + * @param pos read-offset in the stream + * @param buf where to write the data + * @param max how much data to write (at most) + * @return number of bytes written, 0 is allowed! + */ +static int +contentReaderCallback (void *cls, uint64_t pos, char *buf, int max) +{ + struct MHDGetData *mgd = cls; + + if (stats != NULL) + stats->change (stat_mhd_read_callbacks, 1); + GNUNET_mutex_lock (lock); + if (mgd->wpos < max) + max = mgd->wpos; + memcpy (buf, &mgd->wbuff[mgd->woff], max); + mgd->wpos -= max; + mgd->woff += max; + if (max > 0) + mgd->last_get_activity = GNUNET_get_time (); + if (mgd->wpos == 0) + mgd->woff = 0; + GNUNET_mutex_unlock (lock); +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP returns %u bytes in MHD's GET handler.\n", max); +#endif + if (stats != NULL) + stats->change (stat_bytesSent, max); + if ((max == 0) && (mgd->httpsession->cs.server.gets != mgd)) + return -1; /* end of response (another GET replaces this one) */ + return max; +} +#endif + +#if DO_GET +/** + * Notification that libmicrohttpd no longer needs the + * response object. + */ +static void +contentReaderFreeCallback (void *cls) +{ + struct MHDGetData *mgd = cls; + + GNUNET_GE_ASSERT (NULL, mgd->get == NULL); + GNUNET_array_grow (mgd->wbuff, mgd->wsize, 0); + GNUNET_free (mgd); +} +#endif + +/** + * Process GET or PUT request received via MHD. For + * GET, queue response that will send back our pending + * messages. For PUT, process incoming data and send + * to GNUnet core. In either case, check if a session + * already exists and create a new one if not. + */ +static int +accessHandlerCallback (void *cls, + struct MHD_Connection *session, + const char *url, + const char *method, + const char *version, + const char *upload_data, + size_t * upload_data_size, void **httpSessionCache) +{ + GNUNET_TSession *tsession; + struct MHDPutData *put; + struct MHDGetData *get; + HTTPSession *httpSession; + struct MHD_Response *response; + GNUNET_HashCode client; + int i; + unsigned int have; + GNUNET_MessageHeader *hdr; + GNUNET_TransportPacket *mp; + unsigned int cpy; + unsigned int poff; + + if (stats != NULL) + stats->change (stat_mhd_access_callbacks, 1); +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD receives `%s' request.\n", method); +#endif + /* convert URL to sender peer id */ + if ((strlen (url) < 2) + || (GNUNET_OK != GNUNET_enc_to_hash (&url[1], &client))) + { + /* invalid request */ + /* GNUNET_GE_BREAK_OP (NULL, 0); -- this happens a lot, most likely + somebody scanning for MyDoom.X-opened backdoors */ + return MHD_NO; + } + + /* check if we already have a session for this */ + httpSession = *httpSessionCache; + if (httpSession == NULL) + { + /* new http connection */ + if (stats != NULL) + { + if (0 == strcasecmp (MHD_HTTP_METHOD_PUT, method)) + stats->change (stat_put_received, 1); + else + stats->change (stat_get_received, 1); + } + GNUNET_mutex_lock (lock); + for (i = 0; i < tsessionCount; i++) + { + tsession = tsessions[i]; + httpSession = tsession->internal; + if ((0 == + memcmp (&httpSession->sender, &client, + sizeof (GNUNET_HashCode))) + && (httpSession->is_client == GNUNET_NO)) + break; + tsession = NULL; + httpSession = NULL; + } + GNUNET_mutex_unlock (lock); + } + /* create new session if necessary */ + if (httpSession == NULL) + { +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD creates new session for request from `%s'.\n", + &url[1]); +#endif + httpSession = GNUNET_malloc (sizeof (HTTPSession)); + memset (httpSession, 0, sizeof (HTTPSession)); + httpSession->sender.hashPubKey = client; + httpSession->users = 0; /* MHD */ + tsession = GNUNET_malloc (sizeof (GNUNET_TSession)); + memset (tsession, 0, sizeof (GNUNET_TSession)); + tsession->ttype = GNUNET_TRANSPORT_PROTOCOL_NUMBER_HTTP; + tsession->internal = httpSession; + tsession->peer.hashPubKey = client; + httpSession->tsession = tsession; + addTSession (tsession); + } + if (*httpSessionCache == NULL) + { + httpSession->is_mhd_active++; + *httpSessionCache = httpSession; + } + GNUNET_mutex_lock (lock); +#if DO_GET + if (0 == strcasecmp (MHD_HTTP_METHOD_GET, method)) + { +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD receives GET request from `%s'.\n", &url[1]); +#endif + + /* handle get; create response object if we do not + have one already */ + get = GNUNET_malloc (sizeof (struct MHDGetData)); + memset (get, 0, sizeof (struct MHDGetData)); + get->next = httpSession->cs.server.gets; + httpSession->cs.server.gets = get; + get->session = session; + get->httpsession = httpSession; + get->last_get_activity = GNUNET_get_time (); + get->get = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN, + 64 * 1024, + contentReaderCallback, + get, + contentReaderFreeCallback); + MHD_queue_response (session, MHD_HTTP_OK, get->get); + GNUNET_mutex_unlock (lock); + return MHD_YES; + } +#endif + if (0 == strcasecmp (MHD_HTTP_METHOD_PUT, method)) + { +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD receives PUT request from `%s' with %u bytes.\n", + &url[1], *upload_data_size); +#endif + put = httpSession->cs.server.puts; + while ((put != NULL) && (put->session != session)) + put = put->next; + if (put == NULL) + { + put = GNUNET_malloc (sizeof (struct MHDPutData)); + memset (put, 0, sizeof (struct MHDPutData)); + put->next = httpSession->cs.server.puts; + httpSession->cs.server.puts = put; + put->session = session; + } + put->last_activity = GNUNET_get_time (); + + /* handle put (upload_data!) */ + poff = 0; + have = *upload_data_size; + if (stats != NULL) + stats->change (stat_bytesReceived, have); + *upload_data_size = 0; /* we will always process everything */ + if ((have == 0) && (put->done == GNUNET_NO) + && (put->ready == GNUNET_YES)) + { + put->done = GNUNET_YES; + /* end of upload, send response! */ +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD queues dummy response to completed PUT request.\n"); +#endif + response = + MHD_create_response_from_data (strlen (HTTP_PUT_RESPONSE), + HTTP_PUT_RESPONSE, MHD_NO, MHD_NO); + MHD_queue_response (session, MHD_HTTP_OK, response); + MHD_destroy_response (response); + GNUNET_mutex_unlock (lock); + return MHD_YES; + } + while (have > 0) + { + put->ready = GNUNET_NO; + if (put->rpos1 < sizeof (GNUNET_MessageHeader)) + { + cpy = sizeof (GNUNET_MessageHeader) - put->rpos1; + if (cpy > have) + cpy = have; + memcpy (&put->rbuff1[put->rpos1], &upload_data[poff], cpy); + put->rpos1 += cpy; + have -= cpy; + poff += cpy; + put->rpos2 = 0; + } + if (put->rpos1 < sizeof (GNUNET_MessageHeader)) + break; + hdr = (GNUNET_MessageHeader *) put->rbuff1; + GNUNET_array_grow (put->rbuff2, + put->rsize2, + ntohs (hdr->size) - + sizeof (GNUNET_MessageHeader)); + if (put->rpos2 < ntohs (hdr->size) - sizeof (GNUNET_MessageHeader)) + { + cpy = + ntohs (hdr->size) - sizeof (GNUNET_MessageHeader) - + put->rpos2; + if (cpy > have) + cpy = have; + memcpy (&put->rbuff2[put->rpos2], &upload_data[poff], cpy); + have -= cpy; + poff += cpy; + put->rpos2 += cpy; + } + if (put->rpos2 < ntohs (hdr->size) - sizeof (GNUNET_MessageHeader)) + break; + mp = GNUNET_malloc (sizeof (GNUNET_TransportPacket)); + mp->msg = put->rbuff2; + mp->sender = httpSession->sender; + mp->tsession = httpSession->tsession; + mp->size = ntohs (hdr->size) - sizeof (GNUNET_MessageHeader); +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD passes %u bytes to core (received via PUT request).\n", + mp->size); +#endif + coreAPI->receive (mp); + put->rbuff2 = NULL; + put->rpos2 = 0; + put->rsize2 = 0; + put->rpos1 = 0; + put->ready = GNUNET_YES; + } + GNUNET_mutex_unlock (lock); + return MHD_YES; + } + GNUNET_mutex_unlock (lock); + GNUNET_GE_BREAK_OP (NULL, 0); /* invalid request */ + return MHD_NO; +} + +#if DO_GET +/** + * Process downloaded bits (from GET via CURL). + */ +static size_t +receiveContentCallback (void *ptr, size_t size, size_t nmemb, void *ctx) +{ + HTTPSession *httpSession = ctx; + const char *inbuf = ptr; + size_t have = size * nmemb; + size_t poff = 0; + size_t cpy; + GNUNET_MessageHeader *hdr; + GNUNET_TransportPacket *mp; + + if (stats != NULL) + stats->change (stat_curl_receive_callbacks, 1); + httpSession->cs.client.last_get_activity = GNUNET_get_time (); +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/CURL receives %u bytes as response to GET.\n", + size * nmemb); +#endif + while (have > 0) + { + if (httpSession->cs.client.rpos1 < sizeof (GNUNET_MessageHeader)) + { + cpy = sizeof (GNUNET_MessageHeader) - httpSession->cs.client.rpos1; + if (cpy > have) + cpy = have; + memcpy (&httpSession->cs.client. + rbuff1[httpSession->cs.client.rpos1], &inbuf[poff], cpy); + httpSession->cs.client.rpos1 += cpy; + have -= cpy; + poff += cpy; + httpSession->cs.client.rpos2 = 0; + } + if (httpSession->cs.client.rpos1 < sizeof (GNUNET_MessageHeader)) + break; + hdr = (GNUNET_MessageHeader *) httpSession->cs.client.rbuff1; + GNUNET_array_grow (httpSession->cs.client.rbuff2, + httpSession->cs.client.rsize2, + ntohs (hdr->size) - sizeof (GNUNET_MessageHeader)); + if (httpSession->cs.client.rpos2 < + ntohs (hdr->size) - sizeof (GNUNET_MessageHeader)) + { + cpy = + ntohs (hdr->size) - sizeof (GNUNET_MessageHeader) - + httpSession->cs.client.rpos2; + if (cpy > have) + cpy = have; + memcpy (&httpSession->cs.client. + rbuff2[httpSession->cs.client.rpos2], &inbuf[poff], cpy); + have -= cpy; + poff += cpy; + httpSession->cs.client.rpos2 += cpy; + } + if (httpSession->cs.client.rpos2 < + ntohs (hdr->size) - sizeof (GNUNET_MessageHeader)) + break; + mp = GNUNET_malloc (sizeof (GNUNET_TransportPacket)); + mp->msg = httpSession->cs.client.rbuff2; + mp->sender = httpSession->sender; + mp->tsession = httpSession->tsession; + mp->size = ntohs (hdr->size) - sizeof (GNUNET_MessageHeader); + coreAPI->receive (mp); + httpSession->cs.client.rbuff2 = NULL; + httpSession->cs.client.rpos2 = 0; + httpSession->cs.client.rsize2 = 0; + httpSession->cs.client.rpos1 = 0; + } + if (stats != NULL) + stats->change (stat_bytesReceived, size * nmemb); + return size * nmemb; +} +#endif + +/** + * Provide bits for upload: we're using CURL for a PUT request + * and now need to provide data from the message we are transmitting. + */ +static size_t +sendContentCallback (void *ptr, size_t size, size_t nmemb, void *ctx) +{ + struct HTTPPutData *put = ctx; + size_t max = size * nmemb; + + if (stats != NULL) + stats->change (stat_curl_send_callbacks, 1); + put->last_activity = GNUNET_get_time (); + if (max > put->size - put->pos) + max = put->size - put->pos; + memcpy (ptr, &put->msg[put->pos], max); + put->pos += max; +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/CURL sends %u bytes in PUT request.\n", max); +#endif + if (stats != NULL) + stats->change (stat_bytesSent, max); + return max; +} + +#define CURL_EASY_SETOPT(c, a, b) do { ret = curl_easy_setopt(c, a, b); if (ret != CURLE_OK) GNUNET_GE_LOG(coreAPI->ectx, GNUNET_GE_WARNING | GNUNET_GE_USER | GNUNET_GE_BULK, _("%s failed at %s:%d: `%s'\n"), "curl_easy_setopt", __FILE__, __LINE__, curl_easy_strerror(ret)); } while (0); +#define IP_BUF_LEN 128 + +static void +create_session_url (HTTPSession * httpSession) +{ + char buf[IP_BUF_LEN]; + char *url; + GNUNET_EncName enc; + unsigned short available; + const char *obr; + const char *cbr; + const HostAddress *haddr = + (const HostAddress *) &httpSession->cs.client.address; + + url = httpSession->cs.client.url; + if (url == NULL) + { + GNUNET_hash_to_enc (&coreAPI->my_identity->hashPubKey, &enc); + available = ntohs (haddr->availability) & available_protocols; + if (available == (VERSION_AVAILABLE_IPV4 | VERSION_AVAILABLE_IPV6)) + { + if (GNUNET_random_u32 (GNUNET_RANDOM_QUALITY_WEAK, 2) == 0) + available = VERSION_AVAILABLE_IPV4; + else + available = VERSION_AVAILABLE_IPV6; + } + if ((available & VERSION_AVAILABLE_IPV4) > 0) + { + if (NULL == inet_ntop (AF_INET, &haddr->ipv4, buf, IP_BUF_LEN)) + { + /* log? */ + return; + } + obr = ""; + cbr = ""; + } + else if ((available & VERSION_AVAILABLE_IPV6) > 0) + { + if (NULL == inet_ntop (AF_INET6, &haddr->ipv6, buf, IP_BUF_LEN)) + { + /* log? */ + return; + } + obr = "["; + cbr = "]"; + } + else + return; /* error */ + url = GNUNET_malloc (64 + sizeof (GNUNET_EncName) + strlen (buf)); + GNUNET_snprintf (url, + 64 + sizeof (GNUNET_EncName), + "http://%s%s%s:%u/%s", obr, buf, cbr, + ntohs (haddr->port), &enc); + httpSession->cs.client.url = url; + } +} + +#if DO_GET +/** + * Try to do a GET on the other peer of the given + * http session. + * + * @return GNUNET_OK on success, GNUNET_SYSERR on error + */ +static int +create_curl_get (HTTPSession * httpSession) +{ + CURL *curl_get; + CURLcode ret; + CURLMcode mret; + GNUNET_CronTime now; + + if (httpSession->cs.client.url == NULL) + return GNUNET_SYSERR; + curl_get = httpSession->cs.client.get; + if (curl_get != NULL) + { + GNUNET_mutex_lock (lock); + curl_multi_remove_handle (curl_multi, curl_get); + http_requests_pending--; + signal_select (); + curl_easy_cleanup (curl_get); + GNUNET_mutex_unlock (lock); + httpSession->cs.client.get = NULL; + } + curl_get = curl_easy_init (); + if (curl_get == NULL) + return GNUNET_SYSERR; + /* create GET */ + CURL_EASY_SETOPT (curl_get, CURLOPT_FAILONERROR, 1); + CURL_EASY_SETOPT (curl_get, CURLOPT_URL, httpSession->cs.client.url); + if (strlen (proxy) > 0) + CURL_EASY_SETOPT (curl_get, CURLOPT_PROXY, proxy); + CURL_EASY_SETOPT (curl_get, CURLOPT_BUFFERSIZE, 32 * 1024); + if (0 == strncmp (httpSession->cs.client.url, "http", 4)) + CURL_EASY_SETOPT (curl_get, CURLOPT_USERAGENT, "GNUnet-http"); +#if 0 + CURL_EASY_SETOPT (curl_get, CURLOPT_VERBOSE, 1); +#endif + CURL_EASY_SETOPT (curl_get, CURLOPT_CONNECTTIMEOUT, 150L); + /* NOTE: use of CONNECTTIMEOUT without also + setting NOSIGNAL results in really weird + crashes on my system! */ + CURL_EASY_SETOPT (curl_get, CURLOPT_NOSIGNAL, 1); + CURL_EASY_SETOPT (curl_get, CURLOPT_TIMEOUT, 150L); + CURL_EASY_SETOPT (curl_get, CURLOPT_WRITEFUNCTION, &receiveContentCallback); + CURL_EASY_SETOPT (curl_get, CURLOPT_WRITEDATA, httpSession); + CURL_EASY_SETOPT (curl_get, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); + if (ret != CURLE_OK) + { + curl_easy_cleanup (curl_get); + return GNUNET_SYSERR; + } + GNUNET_mutex_lock (lock); + mret = curl_multi_add_handle (curl_multi, curl_get); + http_requests_pending++; + GNUNET_mutex_unlock (lock); + if (stats != NULL) + stats->change (stat_get_issued, 1); + if (mret != CURLM_OK) + { + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, _("%s failed at %s:%d: `%s'\n"), + "curl_multi_add_handle", __FILE__, __LINE__, + curl_multi_strerror (mret)); + curl_easy_cleanup (curl_get); + return GNUNET_SYSERR; + } + signal_select (); + now = GNUNET_get_time (); + httpSession->cs.client.last_get_activity = now; + httpSession->cs.client.get = curl_get; + httpSession->cs.client.last_get_initiated = now; +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/CURL initiated GET request.\n"); +#endif + return GNUNET_OK; +} +#endif + +/** + * Establish a connection to a remote node. + * + * @param hello the hello-Message for the target node + * @param tsessionPtr the session handle that is set + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +httpConnect (const GNUNET_MessageHello * hello, + GNUNET_TSession ** tsessionPtr, int may_reuse) +{ + const HostAddress *haddr = (const HostAddress *) &hello[1]; + GNUNET_TSession *tsession; + HTTPSession *httpSession; + int i; + + if (stats != NULL) + stats->change (stat_connect_calls, 1); + /* check if we have a session pending for this peer */ + tsession = NULL; + if (may_reuse) + { + GNUNET_mutex_lock (lock); + for (i = 0; i < tsessionCount; i++) + { + if (0 == memcmp (&hello->senderIdentity, + &tsessions[i]->peer, sizeof (GNUNET_PeerIdentity))) + { + tsession = tsessions[i]; + break; + } + } + if ((tsession != NULL) && (GNUNET_OK == httpAssociate (tsession))) + { + *tsessionPtr = tsession; + GNUNET_mutex_unlock (lock); + return GNUNET_OK; + } + GNUNET_mutex_unlock (lock); + } + /* no session pending, initiate a new one! */ + httpSession = GNUNET_malloc (sizeof (HTTPSession)); + memset (httpSession, 0, sizeof (HTTPSession)); + httpSession->sender = hello->senderIdentity; + httpSession->users = 1; /* us only, core has not seen this tsession! */ + httpSession->is_client = GNUNET_YES; + httpSession->cs.client.address = *haddr; + tsession = GNUNET_malloc (sizeof (GNUNET_TSession)); + memset (tsession, 0, sizeof (GNUNET_TSession)); + httpSession->tsession = tsession; + tsession->ttype = GNUNET_TRANSPORT_PROTOCOL_NUMBER_HTTP; + tsession->internal = httpSession; + tsession->peer = hello->senderIdentity; + create_session_url (httpSession); +#if DO_GET + if (GNUNET_OK != create_curl_get (httpSession)) + { + GNUNET_free (tsession); + GNUNET_free (httpSession); + return GNUNET_SYSERR; + } +#endif + /* PUTs will be created as needed */ + addTSession (tsession); + *tsessionPtr = tsession; +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/CURL initiated connection to `%s'.\n", + httpSession->cs.client.url); +#endif + return GNUNET_OK; +} + +/** + * We received the "Thank you!" response to a PUT. + * Discard the data (not useful) and mark the PUT + * operation as completed. + */ +static size_t +discardContentCallback (void *data, size_t size, size_t nmemb, void *put_cls) +{ + struct HTTPPutData *put = put_cls; + /* this condition should pretty much always be + true; just checking here in case the PUT + response comes early somehow */ + if (put->pos == put->size) + put->done = GNUNET_YES; + return size * nmemb; +} + +/** + * Create a new PUT request for the given PUT data. + */ +static int +create_curl_put (HTTPSession * httpSession, struct HTTPPutData *put) +{ + CURL *curl_put; + CURLcode ret; + CURLMcode mret; + long size; + + /* we should have initiated a GET earlier, + so URL must not be NULL here */ + if (httpSession->cs.client.url == NULL) + return GNUNET_SYSERR; + curl_put = curl_easy_init (); + if (curl_put == NULL) + return GNUNET_SYSERR; + CURL_EASY_SETOPT (curl_put, CURLOPT_FAILONERROR, 1); + CURL_EASY_SETOPT (curl_put, CURLOPT_URL, httpSession->cs.client.url); + if (strlen (proxy) > 0) + CURL_EASY_SETOPT (curl_put, CURLOPT_PROXY, proxy); + CURL_EASY_SETOPT (curl_put, CURLOPT_BUFFERSIZE, put->size); + if (0 == strncmp (httpSession->cs.client.url, "http", 4)) + CURL_EASY_SETOPT (curl_put, CURLOPT_USERAGENT, "GNUnet-http"); + CURL_EASY_SETOPT (curl_put, CURLOPT_UPLOAD, 1); +#if 0 + CURL_EASY_SETOPT (curl_put, CURLOPT_VERBOSE, 1); +#endif + CURL_EASY_SETOPT (curl_put, CURLOPT_CONNECTTIMEOUT, 150L); + /* NOTE: use of CONNECTTIMEOUT without also + setting NOSIGNAL results in really weird + crashes on my system! */ + CURL_EASY_SETOPT (curl_put, CURLOPT_NOSIGNAL, 1); + CURL_EASY_SETOPT (curl_put, CURLOPT_TIMEOUT, 150L); + size = put->size; + CURL_EASY_SETOPT (curl_put, CURLOPT_INFILESIZE, size); + CURL_EASY_SETOPT (curl_put, CURLOPT_READFUNCTION, &sendContentCallback); + CURL_EASY_SETOPT (curl_put, CURLOPT_READDATA, put); + CURL_EASY_SETOPT (curl_put, CURLOPT_WRITEFUNCTION, &discardContentCallback); + CURL_EASY_SETOPT (curl_put, CURLOPT_WRITEDATA, put); + CURL_EASY_SETOPT (curl_put, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); + if (ret != CURLE_OK) + { + curl_easy_cleanup (curl_put); + return GNUNET_SYSERR; + } + GNUNET_mutex_lock (lock); + mret = curl_multi_add_handle (curl_multi, curl_put); + http_requests_pending++; + GNUNET_mutex_unlock (lock); + if (stats != NULL) + stats->change (stat_put_issued, 1); + if (mret != CURLM_OK) + { + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, _("%s failed at %s:%d: `%s'\n"), + "curl_multi_add_handle", __FILE__, __LINE__, + curl_multi_strerror (mret)); + return GNUNET_SYSERR; + } + signal_select (); + put->curl_put = curl_put; +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/CURL initiated PUT request to `%s'.\n", + httpSession->cs.client.url); +#endif + return GNUNET_OK; +} + + +/** + * Test if the transport would even try to send + * a message of the given size and importance + * for the given session.
+ * This function is used to check if the core should + * even bother to construct (and encrypt) this kind + * of message. + * + * @return GNUNET_YES if the transport would try (i.e. queue + * the message or call the OS to send), + * GNUNET_NO if the transport would just drop the message, + * GNUNET_SYSERR if the size/session is invalid + */ +static int +httpTestWouldTry (GNUNET_TSession * tsession, const unsigned int size, + int important) +{ + HTTPSession *httpSession = tsession->internal; + struct MHDGetData *get; + int ret; + + if (size >= GNUNET_MAX_BUFFER_SIZE - sizeof (GNUNET_MessageHeader)) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + if (size == 0) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + if (httpSession->is_client) + { + /* client */ + if ((important != GNUNET_YES) && (httpSession->cs.client.puts != NULL)) + return GNUNET_NO; + return GNUNET_YES; + } + else + { + /* server */ + GNUNET_mutex_lock (lock); + get = httpSession->cs.server.gets; + if (get == NULL) + ret = GNUNET_NO; + else + { + if (get->wsize == 0) + ret = GNUNET_YES; + else if ((get->wpos + size > get->wsize) + && (important != GNUNET_YES)) + ret = GNUNET_NO; + else + ret = GNUNET_YES; + } + GNUNET_mutex_unlock (lock); + return ret; + } +} + + +/** + * Send a message to the specified remote node. + * + * @param tsession the GNUNET_MessageHello identifying the remote node + * @param msg the message + * @param size the size of the message + * @return GNUNET_SYSERR on error, GNUNET_OK on success, GNUNET_NO if queue is full + */ +static int +httpSend (GNUNET_TSession * tsession, + const void *msg, unsigned int size, int important) +{ + HTTPSession *httpSession = tsession->internal; + struct HTTPPutData *putData; + GNUNET_MessageHeader *hdr; +#if DO_GET + struct MHDGetData *getData; + char *tmp; +#endif + + if (stats != NULL) + stats->change (stat_send_calls, 1); + if (httpSession->is_client) + { + /* we need to do a PUT (we are the client) */ + if (size >= GNUNET_MAX_BUFFER_SIZE) + return GNUNET_SYSERR; + if (size == 0) + { + GNUNET_GE_BREAK (NULL, 0); + return GNUNET_SYSERR; + } + if (important != GNUNET_YES) + { + GNUNET_mutex_lock (lock); + if (httpSession->cs.client.puts != NULL) + { + /* do not queue more than one unimportant PUT at a time */ + signal_select (); /* do clean up now! */ + GNUNET_mutex_unlock (lock); + if (stats != NULL) + stats->change (stat_bytesDropped, size); + + return GNUNET_NO; + } + GNUNET_mutex_unlock (lock); + } + putData = GNUNET_malloc (sizeof (struct HTTPPutData)); + memset (putData, 0, sizeof (struct HTTPPutData)); + putData->msg = GNUNET_malloc (size + sizeof (GNUNET_MessageHeader)); + hdr = (GNUNET_MessageHeader *) putData->msg; + hdr->size = htons (size + sizeof (GNUNET_MessageHeader)); + hdr->type = htons (0); + memcpy (&putData->msg[sizeof (GNUNET_MessageHeader)], msg, size); + putData->size = size + sizeof (GNUNET_MessageHeader); + putData->last_activity = GNUNET_get_time (); + if (GNUNET_OK != create_curl_put (httpSession, putData)) + { + GNUNET_free (putData->msg); + GNUNET_free (putData); + return GNUNET_SYSERR; + } + GNUNET_mutex_lock (lock); + putData->next = httpSession->cs.client.puts; + httpSession->cs.client.puts = putData; + GNUNET_mutex_unlock (lock); + return GNUNET_OK; + } + + /* httpSession->isClient == false, respond to a GET (we + hopefully have one or will have one soon) */ +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP/MHD queues %u bytes to be sent as response to GET as soon as possible.\n", + size); +#endif +#if DO_GET + GNUNET_mutex_lock (lock); + getData = httpSession->cs.server.gets; + if (getData == NULL) + { + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + if (getData->wsize == 0) + GNUNET_array_grow (getData->wbuff, getData->wsize, HTTP_BUF_SIZE); + size += sizeof (GNUNET_MessageHeader); + if (getData->wpos + size > getData->wsize) + { + /* need to grow or discard */ + if (!important) + { + GNUNET_mutex_unlock (lock); + return GNUNET_NO; + } + tmp = GNUNET_malloc (getData->wpos + size); + memcpy (tmp, &getData->wbuff[getData->woff], getData->wpos); + hdr = (GNUNET_MessageHeader *) & tmp[getData->wpos]; + hdr->type = htons (0); + hdr->size = htons (size); + memcpy (&hdr[1], msg, size - sizeof (GNUNET_MessageHeader)); + GNUNET_free (getData->wbuff); + getData->wbuff = tmp; + getData->wsize = getData->wpos + size; + getData->woff = 0; + getData->wpos = getData->wpos + size; + } + else + { + /* fits without growing */ + if (getData->wpos + getData->woff + size > getData->wsize) + { + /* need to compact first */ + memmove (getData->wbuff, + &getData->wbuff[getData->woff], getData->wpos); + getData->woff = 0; + } + /* append */ + hdr = + (GNUNET_MessageHeader *) & getData->wbuff[getData->woff + + getData->wpos]; + hdr->size = htons (size); + hdr->type = htons (0); + memcpy (&hdr[1], msg, size - sizeof (GNUNET_MessageHeader)); + getData->wpos += size; + } + signal_select (); + GNUNET_mutex_unlock (lock); +#endif + return GNUNET_OK; +} + +/** + * Function called to cleanup dead connections + * (completed PUTs, GETs that have timed out, + * etc.). Also re-vives GETs that have timed out + * if we are still interested in the connection. + */ +static void +cleanup_connections () +{ + int i; + HTTPSession *s; + struct HTTPPutData *prev; + struct HTTPPutData *pos; + struct MHDPutData *mpos; + struct MHDPutData *mprev; +#if DO_GET + struct MHD_Response *r; + struct MHDGetData *gpos; + struct MHDGetData *gnext; +#endif + GNUNET_CronTime now; + + GNUNET_mutex_lock (lock); + now = GNUNET_get_time (); + for (i = 0; i < tsessionCount; i++) + { + s = tsessions[i]->internal; + if (s->is_client) + { + if ((s->cs.client.puts == NULL) && (s->users == 0) +#if DO_GET + && (s->cs.client.last_get_activity + HTTP_TIMEOUT < now) +#endif + ) + { +#if DO_GET +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | + GNUNET_GE_USER, + "HTTP transport destroys old (%llu ms) unused client session\n", + now - s->cs.client.last_get_activity); +#endif +#endif + destroy_tsession (tsessions[i]); + i--; + continue; + } + + prev = NULL; + pos = s->cs.client.puts; + while (pos != NULL) + { + if (pos->last_activity + HTTP_TIMEOUT < now) + pos->done = GNUNET_YES; + if (pos->done) + { + if (prev == NULL) + s->cs.client.puts = pos->next; + else + prev->next = pos->next; + GNUNET_free (pos->msg); + curl_multi_remove_handle (curl_multi, pos->curl_put); + http_requests_pending--; + signal_select (); + curl_easy_cleanup (pos->curl_put); + GNUNET_free (pos); + if (prev == NULL) + pos = s->cs.client.puts; + else + pos = prev->next; + continue; + } + prev = pos; + pos = pos->next; + } +#if DO_GET + if ((s->cs.client.last_get_activity + HTTP_TIMEOUT < now) && + ((s->users > 0) || (s->cs.client.puts != NULL)) && + ((s->cs.client.last_get_initiated + HTTP_GET_REFRESH > now) || + (s->cs.client.get == NULL)) && + ((s->cs.client.get == NULL) || + (s->cs.client.last_get_activity + HTTP_GET_REFRESH / 2 < now))) + create_curl_get (s); +#endif + } + else + { + mpos = s->cs.server.puts; + mprev = NULL; + while (mpos != NULL) + { + if (mpos->last_activity == 0) + { + if (mprev == NULL) + s->cs.server.puts = mpos->next; + else + mprev->next = mpos->next; + GNUNET_array_grow (mpos->rbuff2, mpos->rsize2, 0); + GNUNET_free (mpos); + if (mprev == NULL) + mpos = s->cs.server.puts; + else + mpos = mprev->next; + continue; + } + mprev = mpos; + mpos = mpos->next; + } + + /* ! s->is_client */ +#if DO_GET + gpos = s->cs.server.gets; + while (gpos != NULL) + { + gnext = gpos->next; + gpos->next = NULL; + if ((gpos->last_get_activity + HTTP_TIMEOUT < now) || + (gpos != s->cs.server.gets)) + { + if (gpos == s->cs.server.gets) + s->cs.server.gets = NULL; + r = gpos->get; + gpos->get = NULL; + MHD_destroy_response (r); + } + gpos = gnext; + } +#endif + if ( +#if DO_GET + (s->cs.server.gets == NULL) && +#endif + (s->is_mhd_active == 0) && (s->users == 0)) + { +#if DO_GET +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | + GNUNET_GE_USER, + "HTTP transport destroys unused server session\n"); +#endif +#endif + destroy_tsession (tsessions[i]); + i--; + continue; + } + } + } + GNUNET_mutex_unlock (lock); +} + +/** + * Thread that runs the CURL and MHD requests. + */ +static void * +curl_runner (void *unused) +{ + CURLMcode mret; + fd_set rs; + fd_set ws; + fd_set es; + int max; + struct timeval tv; + int running; + unsigned long long timeout; + long ms; + int have_tv; + char buf[128]; /* for reading from pipe */ + int ret; + +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP transport select thread started\n"); +#endif + while (GNUNET_YES == http_running) + { + max = 0; + FD_ZERO (&rs); + FD_ZERO (&ws); + FD_ZERO (&es); + GNUNET_mutex_lock (lock); + mret = curl_multi_fdset (curl_multi, &rs, &ws, &es, &max); + GNUNET_mutex_unlock (lock); + if (mret != CURLM_OK) + { + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, _("%s failed at %s:%d: `%s'\n"), + "curl_multi_fdset", __FILE__, __LINE__, + curl_multi_strerror (mret)); + break; + } + if (mhd_daemon != NULL) + MHD_get_fdset (mhd_daemon, &rs, &ws, &es, &max); + timeout = 0; + have_tv = MHD_NO; + if (mhd_daemon != NULL) + have_tv = MHD_get_timeout (mhd_daemon, &timeout); + GNUNET_mutex_lock (lock); + if ((CURLM_OK == curl_multi_timeout (curl_multi, &ms)) && + (ms != -1) && ((ms < timeout) || (have_tv == MHD_NO))) + { + timeout = ms; + have_tv = MHD_YES; + } + GNUNET_mutex_unlock (lock); + FD_SET (signal_pipe[0], &rs); + if (max < signal_pipe[0]) + max = signal_pipe[0]; + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout % 1000) * 1000; + if (stats != NULL) + stats->change (stat_select_calls, 1); + ret = + SELECT (max + 1, &rs, &ws, &es, (have_tv == MHD_YES) ? &tv : NULL); + if (ret == -1) + { + GNUNET_GE_LOG_STRERROR (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | + GNUNET_GE_DEVELOPER, "select"); + } + if (GNUNET_YES != http_running) + break; + running = 0; + do + { + GNUNET_mutex_lock (lock); + mret = curl_multi_perform (curl_multi, &running); + GNUNET_mutex_unlock (lock); + } + while ((mret == CURLM_CALL_MULTI_PERFORM) + && (http_running == GNUNET_YES)); + if (FD_ISSET (signal_pipe[0], &rs)) + read (signal_pipe[0], buf, sizeof (buf)); + if ((mret != CURLM_OK) && (mret != CURLM_CALL_MULTI_PERFORM)) + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, _("%s failed at %s:%d: `%s'\n"), + "curl_multi_perform", __FILE__, __LINE__, + curl_multi_strerror (mret)); + if (mhd_daemon != NULL) + MHD_run (mhd_daemon); + cleanup_connections (); + } +#if DEBUG_HTTP + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "HTTP transport select thread exits.\n"); +#endif + return NULL; +} + + +/** + * Start the server process to receive inbound traffic. + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +startTransportServer () +{ + unsigned short port; + + if ((curl_multi != NULL) || (http_running == GNUNET_YES)) + return GNUNET_SYSERR; + curl_multi = curl_multi_init (); + if (curl_multi == NULL) + return GNUNET_SYSERR; + port = get_port (); + if ((mhd_daemon == NULL) && (port != 0)) + { + if (GNUNET_YES != + GNUNET_GC_get_configuration_value_yesno (cfg, "GNUNETD", + "DISABLE-IPV6", + GNUNET_YES)) + { + mhd_daemon = MHD_start_daemon (MHD_USE_IPv6, + port, + &acceptPolicyCallback, + NULL, &accessHandlerCallback, NULL, + MHD_OPTION_CONNECTION_TIMEOUT, + (unsigned int) HTTP_TIMEOUT, + MHD_OPTION_CONNECTION_MEMORY_LIMIT, + (unsigned int) 1024 * 128, + MHD_OPTION_CONNECTION_LIMIT, + (unsigned int) 128, + MHD_OPTION_PER_IP_CONNECTION_LIMIT, + (unsigned int) 8, + MHD_OPTION_NOTIFY_COMPLETED, + &requestCompletedCallback, NULL, + MHD_OPTION_END); + } + if (mhd_daemon == NULL) + { + /* try without IPv6 */ + mhd_daemon = MHD_start_daemon (MHD_NO_FLAG, + port, + &acceptPolicyCallback, + NULL, &accessHandlerCallback, NULL, + MHD_OPTION_CONNECTION_TIMEOUT, + (unsigned int) HTTP_TIMEOUT, + MHD_OPTION_CONNECTION_MEMORY_LIMIT, + (unsigned int) 1024 * 128, + MHD_OPTION_CONNECTION_LIMIT, + (unsigned int) 128, + MHD_OPTION_PER_IP_CONNECTION_LIMIT, + (unsigned int) 8, + MHD_OPTION_NOTIFY_COMPLETED, + &requestCompletedCallback, NULL, + MHD_OPTION_END); + } + else + { + available_protocols |= VERSION_AVAILABLE_IPV6; + } + if (mhd_daemon != NULL) + available_protocols |= VERSION_AVAILABLE_IPV4; + } + if (port == 0) + { + /* NAT */ + available_protocols |= VERSION_AVAILABLE_IPV4; + if (GNUNET_YES != + GNUNET_GC_get_configuration_value_yesno (cfg, "GNUNETD", + "DISABLE-IPV6", + GNUNET_YES)) + available_protocols |= VERSION_AVAILABLE_IPV6; + } + if (0 != PIPE (signal_pipe)) + { + MHD_stop_daemon (mhd_daemon); + curl_multi_cleanup (curl_multi); + curl_multi = NULL; + mhd_daemon = NULL; + return GNUNET_SYSERR; + } + GNUNET_pipe_make_nonblocking (coreAPI->ectx, signal_pipe[0]); + GNUNET_pipe_make_nonblocking (coreAPI->ectx, signal_pipe[1]); + http_running = GNUNET_YES; + curl_thread = GNUNET_thread_create (&curl_runner, NULL, 32 * 1024); + if (curl_thread == NULL) + GNUNET_GE_DIE_STRERROR (coreAPI->ectx, + GNUNET_GE_FATAL | GNUNET_GE_ADMIN | + GNUNET_GE_IMMEDIATE, "pthread_create"); + return GNUNET_OK; +} + +/** + * Shutdown the server process (stop receiving inbound + * traffic). May be restarted later! + */ +static int +stopTransportServer () +{ + void *unused; + int i; + HTTPSession *s; + + if ((http_running == GNUNET_NO) || (curl_multi == NULL)) + return GNUNET_SYSERR; + http_running = GNUNET_NO; + signal_select (); + GNUNET_thread_stop_sleep (curl_thread); + GNUNET_thread_join (curl_thread, &unused); + CLOSE (signal_pipe[0]); + CLOSE (signal_pipe[1]); + if (mhd_daemon != NULL) + { + MHD_stop_daemon (mhd_daemon); + mhd_daemon = NULL; + } + cleanup_connections (); + for (i = 0; i < tsessionCount; i++) + { + s = tsessions[i]->internal; + if (s->users == 0) + { + destroy_tsession (tsessions[i]); + i--; + } + } + curl_multi_cleanup (curl_multi); + curl_multi = NULL; + return GNUNET_OK; +} + +/* ******************** public API ******************** */ + +/** + * The exported method. Makes the core api available + * via a global and returns the udp transport API. + */ +GNUNET_TransportAPI * +inittransport_http (GNUNET_CoreAPIForTransport * core) +{ + GNUNET_GE_ASSERT (coreAPI->ectx, sizeof (HostAddress) == 24); + coreAPI = core; + cfg = coreAPI->cfg; + lock = GNUNET_mutex_create (GNUNET_YES); + if (0 != GNUNET_GC_attach_change_listener (coreAPI->cfg, + &reload_configuration, NULL)) + { + GNUNET_mutex_destroy (lock); + lock = NULL; + return NULL; + } + if (0 != curl_global_init (CURL_GLOBAL_WIN32)) + { + GNUNET_GE_BREAK (NULL, 0); + GNUNET_GC_detach_change_listener (coreAPI->cfg, &reload_configuration, + NULL); + GNUNET_mutex_destroy (lock); + lock = NULL; + return NULL; + } + tsessionCount = 0; + tsessionArrayLength = 0; + GNUNET_array_grow (tsessions, tsessionArrayLength, 32); + if (GNUNET_GC_get_configuration_value_yesno (coreAPI->cfg, + "HTTP", "UPNP", + GNUNET_YES) == GNUNET_YES) + { + upnp = coreAPI->service_request ("upnp"); + + if (upnp == NULL) + { + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_USER | + GNUNET_GE_IMMEDIATE, + _ + ("The UPnP service could not be loaded. To disable UPnP, set the " + "configuration option \"UPNP\" in section \"%s\" to \"NO\"\n"), + "HTTP"); + } + } + stats = coreAPI->service_request ("stats"); + if (stats != NULL) + { + stat_bytesReceived + = stats->create (gettext_noop ("# bytes received via HTTP")); + stat_bytesSent = stats->create (gettext_noop ("# bytes sent via HTTP")); + stat_bytesDropped + = stats->create (gettext_noop ("# bytes dropped by HTTP (outgoing)")); + stat_get_issued = stats->create (gettext_noop ("# HTTP GET issued")); + stat_get_received + = stats->create (gettext_noop ("# HTTP GET received")); + stat_put_issued = stats->create (gettext_noop ("# HTTP PUT issued")); + stat_put_received + = stats->create (gettext_noop ("# HTTP PUT received")); + stat_select_calls + = stats->create (gettext_noop ("# HTTP select calls")); + + stat_send_calls = stats->create (gettext_noop ("# HTTP send calls")); + + stat_curl_send_callbacks + = stats->create (gettext_noop ("# HTTP curl send callbacks")); + stat_curl_receive_callbacks + = stats->create (gettext_noop ("# HTTP curl receive callbacks")); + stat_mhd_access_callbacks + = stats->create (gettext_noop ("# HTTP mhd access callbacks")); + stat_mhd_read_callbacks + = stats->create (gettext_noop ("# HTTP mhd read callbacks")); + stat_mhd_close_callbacks + = stats->create (gettext_noop ("# HTTP mhd close callbacks")); + stat_connect_calls + = stats->create (gettext_noop ("# HTTP connect calls")); + } + GNUNET_GC_get_configuration_value_string (coreAPI->cfg, + "GNUNETD", "HTTP-PROXY", "", + &proxy); + + myAPI.protocol_number = GNUNET_TRANSPORT_PROTOCOL_NUMBER_HTTP; + myAPI.mtu = 0; + myAPI.cost = 20000; /* about equal to udp */ + myAPI.hello_verify = &verify_hello; + myAPI.hello_create = &create_hello; + myAPI.connect = &httpConnect; + myAPI.associate = &httpAssociate; + myAPI.send = &httpSend; + myAPI.disconnect = &httpDisconnect; + myAPI.server_start = &startTransportServer; + myAPI.server_stop = &stopTransportServer; + myAPI.hello_to_address = &hello_to_address; + myAPI.send_now_test = &httpTestWouldTry; + + return &myAPI; +} + +void +donetransport_http () +{ + curl_global_cleanup (); + GNUNET_free_non_null (proxy); + proxy = NULL; + GNUNET_array_grow (tsessions, tsessionArrayLength, 0); + do_shutdown (); +} + +/* end of http.c */ diff --git a/src/transport/plugin_transport_smtp.c b/src/transport/plugin_transport_smtp.c new file mode 100644 index 000000000..f7cc530e4 --- /dev/null +++ b/src/transport/plugin_transport_smtp.c @@ -0,0 +1,906 @@ +/* + This file is part of GNUnet + (C) 2003, 2004, 2005, 2006, 2007 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transports/smtp.c + * @brief Implementation of the SMTP transport service + * @author Christian Grothoff + * @author Renaldo Ferreira + */ + +#include "platform.h" +#include "gnunet_util.h" +#include "gnunet_directories.h" +#include "gnunet_protocols.h" +#include "gnunet_transport.h" +#include "gnunet_stats_service.h" +#include +#include + + +/** + * The default maximum size of each outbound SMTP message. + */ +#define SMTP_MESSAGE_SIZE 65528 + +#define DEBUG_SMTP GNUNET_NO + +#define FILTER_STRING_SIZE 64 + +/* how long can a line in base64 encoded + mime text be? (in characters, excluding "\n") */ +#define MAX_CHAR_PER_LINE 76 + +#define EBUF_LEN 128 + +/** + * Host-Address in a SMTP network. + */ +typedef struct +{ + + /** + * Filter line that every sender must include in the E-mails such + * that the receiver can effectively filter out the GNUnet traffic + * from the E-mail. + */ + char filter[FILTER_STRING_SIZE]; + + /** + * Claimed E-mail address of the sender. + * Format is "foo@bar.com" with null termination, padded to be + * of a multiple of 8 bytes long. + */ + char senderAddress[0]; + +} EmailAddress; + +/** + * Encapsulation of a GNUnet message in the SMTP mail body (before + * base64 encoding). + */ +typedef struct +{ + GNUNET_MessageHeader header; + + /** + * What is the identity of the sender (GNUNET_hash of public key) + */ + GNUNET_PeerIdentity sender; + +} SMTPMessage; + +/* *********** globals ************* */ + +/** + * apis (our advertised API and the core api ) + */ +static GNUNET_CoreAPIForTransport *coreAPI; + +static struct GNUNET_GE_Context *ectx; + +/** + * Thread that listens for inbound messages + */ +static struct GNUNET_ThreadHandle *dispatchThread; + +/** + * Flag to indicate that server has been shut down. + */ +static int smtp_shutdown = GNUNET_YES; + +/** + * Set to the SMTP server hostname (and port) for outgoing messages. + */ +static char *smtp_server_name; + +static char *pipename; + +/** + * Lock for uses of libesmtp (not thread-safe). + */ +static struct GNUNET_Mutex *lock; + +/** + * Old handler for SIGPIPE (kept to be able to restore). + */ +static struct sigaction old_handler; + +static char *email; + +static GNUNET_TransportAPI smtpAPI; + +static GNUNET_Stats_ServiceAPI *stats; + +static int stat_bytesReceived; + +static int stat_bytesSent; + +static int stat_bytesDropped; + +/** + * How many e-mails are we allowed to send per hour? + */ +static unsigned long long rate_limit; + +static GNUNET_CronTime last_transmission; + +/** ******************** Base64 encoding ***********/ + +#define FILLCHAR '=' +static char *cvt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" "0123456789+/"; + +/** + * Encode into Base64. + * + * @param data the data to encode + * @param len the length of the input + * @param output where to write the output (*output should be NULL, + * is allocated) + * @return the size of the output + */ +static unsigned int +base64_encode (const char *data, unsigned int len, char **output) +{ + unsigned int i; + char c; + unsigned int ret; + char *opt; + +/* (*output)[ret++] = '\r'; \*/ +#define CHECKLINE \ + if ( (ret % MAX_CHAR_PER_LINE) == 0) { \ + (*output)[ret++] = '\n'; \ + } + ret = 0; + opt = GNUNET_malloc (2 + (((len * 4 / 3) + 8) * (MAX_CHAR_PER_LINE + 2)) / + MAX_CHAR_PER_LINE); + /* message must start with \r\n for libesmtp */ + *output = opt; + opt[0] = '\r'; + opt[1] = '\n'; + ret += 2; + for (i = 0; i < len; ++i) + { + c = (data[i] >> 2) & 0x3f; + opt[ret++] = cvt[(int) c]; + CHECKLINE; + c = (data[i] << 4) & 0x3f; + if (++i < len) + c |= (data[i] >> 4) & 0x0f; + opt[ret++] = cvt[(int) c]; + CHECKLINE; + if (i < len) + { + c = (data[i] << 2) & 0x3f; + if (++i < len) + c |= (data[i] >> 6) & 0x03; + opt[ret++] = cvt[(int) c]; + CHECKLINE; + } + else + { + ++i; + opt[ret++] = FILLCHAR; + CHECKLINE; + } + if (i < len) + { + c = data[i] & 0x3f; + opt[ret++] = cvt[(int) c]; + CHECKLINE; + } + else + { + opt[ret++] = FILLCHAR; + CHECKLINE; + } + } + opt[ret++] = FILLCHAR; + return ret; +} + +#define cvtfind(a)( (((a) >= 'A')&&((a) <= 'Z'))? (a)-'A'\ + :(((a)>='a')&&((a)<='z')) ? (a)-'a'+26\ + :(((a)>='0')&&((a)<='9')) ? (a)-'0'+52\ + :((a) == '+') ? 62\ + :((a) == '/') ? 63 : -1) +/** + * Decode from Base64. + * + * @param data the data to encode + * @param len the length of the input + * @param output where to write the output (*output should be NULL, + * is allocated) + * @return the size of the output + */ +static unsigned int +base64_decode (const char *data, unsigned int len, char **output) +{ + unsigned int i; + char c; + char c1; + unsigned int ret = 0; + +#define CHECK_CRLF while (data[i] == '\r' || data[i] == '\n') {\ + GNUNET_GE_LOG(ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, "ignoring CR/LF\n"); \ + i++; \ + if (i >= len) goto END; \ + } + + *output = GNUNET_malloc ((len * 3 / 4) + 8); +#if DEBUG_SMTP + GNUNET_GE_LOG (ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "base64_decode decoding len=%d\n", len); +#endif + for (i = 0; i < len; ++i) + { + CHECK_CRLF; + if (data[i] == FILLCHAR) + break; + c = (char) cvtfind (data[i]); + ++i; + CHECK_CRLF; + c1 = (char) cvtfind (data[i]); + c = (c << 2) | ((c1 >> 4) & 0x3); + (*output)[ret++] = c; + if (++i < len) + { + CHECK_CRLF; + c = data[i]; + if (FILLCHAR == c) + break; + c = (char) cvtfind (c); + c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf); + (*output)[ret++] = c1; + } + if (++i < len) + { + CHECK_CRLF; + c1 = data[i]; + if (FILLCHAR == c1) + break; + + c1 = (char) cvtfind (c1); + c = ((c << 6) & 0xc0) | c1; + (*output)[ret++] = c; + } + } +END: + return ret; +} + +/* ********************* the real stuff ******************* */ + +#define strAUTOncmp(a,b) strncmp(a,b,strlen(b)) + +/** + * Listen to the pipe, decode messages and send to core. + */ +static void * +listenAndDistribute (void *unused) +{ + char *line; + unsigned int linesize; + SMTPMessage *mp; + FILE *fdes; + char *retl; + char *out; + unsigned int size; + GNUNET_TransportPacket *coreMP; + int fd; + unsigned int pos; + + linesize = ((GNUNET_MAX_BUFFER_SIZE * 4 / 3) + 8) * (MAX_CHAR_PER_LINE + 2) / MAX_CHAR_PER_LINE; /* maximum size of a line supported */ + line = GNUNET_malloc (linesize + 2); /* 2 bytes for off-by-one errors, just to be safe... */ + +#define READLINE(l,limit) \ + do { retl = fgets(l, (limit), fdes); \ + if ( (retl == NULL) || (smtp_shutdown == GNUNET_YES)) {\ + goto END; \ + }\ + if (coreAPI->load_monitor != NULL) \ + GNUNET_network_monitor_notify_transmission(coreAPI->load_monitor, GNUNET_ND_DOWNLOAD, strlen(retl)); \ + } while (0) + + + while (smtp_shutdown == GNUNET_NO) + { + fd = OPEN (pipename, O_RDONLY | O_ASYNC); + if (fd == -1) + { + if (smtp_shutdown == GNUNET_NO) + GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS); + continue; + } + fdes = fdopen (fd, "r"); + while (smtp_shutdown == GNUNET_NO) + { + /* skip until end of header */ + do + { + READLINE (line, linesize); + } + while ((line[0] != '\r') && (line[0] != '\n')); /* expect newline */ + READLINE (line, linesize); /* read base64 encoded message; decode, process */ + pos = 0; + while (1) + { + pos = strlen (line) - 1; /* ignore new line */ + READLINE (&line[pos], linesize - pos); /* read base64 encoded message; decode, process */ + if ((line[pos] == '\r') || (line[pos] == '\n')) + break; /* empty line => end of message! */ + } + size = base64_decode (line, pos, &out); + if (size < sizeof (SMTPMessage)) + { + GNUNET_GE_BREAK (ectx, 0); + GNUNET_free (out); + goto END; + } + + mp = (SMTPMessage *) & out[size - sizeof (SMTPMessage)]; + if (ntohs (mp->header.size) != size) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_BULK | + GNUNET_GE_USER, + _ + ("Received malformed message via %s. Ignored.\n"), + "SMTP"); +#if DEBUG_SMTP + GNUNET_GE_LOG (ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | + GNUNET_GE_USER, + "Size returned by base64=%d, in the msg=%d.\n", + size, ntohl (mp->size)); +#endif + GNUNET_free (out); + goto END; + } + if (stats != NULL) + stats->change (stat_bytesReceived, size); + coreMP = GNUNET_malloc (sizeof (GNUNET_TransportPacket)); + coreMP->msg = out; + coreMP->size = size - sizeof (SMTPMessage); + coreMP->tsession = NULL; + coreMP->sender = mp->sender; +#if DEBUG_SMTP + GNUNET_GE_LOG (ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "SMTP message passed to the core.\n"); +#endif + + coreAPI->receive (coreMP); + } + END: +#if DEBUG_SMTP + GNUNET_GE_LOG (ectx, + GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER, + "SMTP message processed.\n"); +#endif + if (fdes != NULL) + fclose (fdes); + } + GNUNET_free (line); + return NULL; +} + +/* *************** API implementation *************** */ + +/** + * Verify that a hello-Message is correct (a node is reachable at that + * address). Since the reply will be asynchronous, a method must be + * called on success. + * + * @param hello the hello message to verify + * (the signature/crc have been verified before) + * @return GNUNET_OK on success, GNUNET_SYSERR on error + */ +static int +api_verify_hello (const GNUNET_MessageHello * hello) +{ + const EmailAddress *maddr; + + maddr = (const EmailAddress *) &hello[1]; + if ((ntohs (hello->header.size) != + sizeof (GNUNET_MessageHello) + ntohs (hello->senderAddressSize)) || + (maddr->senderAddress[ntohs (hello->senderAddressSize) - 1 - + FILTER_STRING_SIZE] != '\0')) + { + GNUNET_GE_BREAK (ectx, 0); + return GNUNET_SYSERR; /* obviously invalid */ + } + if (NULL == strstr (maddr->filter, ": ")) + return GNUNET_SYSERR; + return GNUNET_OK; +} + +/** + * Create a hello-Message for the current node. The hello is created + * without signature and without a timestamp. The GNUnet core will + * GNUNET_RSA_sign the message and add an expiration time. + * + * @return hello on success, NULL on error + */ +static GNUNET_MessageHello * +api_create_hello () +{ + GNUNET_MessageHello *msg; + char *filter; + EmailAddress *haddr; + int i; + + GNUNET_GC_get_configuration_value_string (coreAPI->cfg, + "SMTP", "FILTER", + "X-mailer: GNUnet", &filter); + if (NULL == strstr (filter, ": ")) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER, + _("SMTP filter string to invalid, lacks ': '\n")); + GNUNET_free (filter); + return NULL; + } + + if (strlen (filter) > FILTER_STRING_SIZE) + { + filter[FILTER_STRING_SIZE] = '\0'; + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER, + _("SMTP filter string to long, capped to `%s'\n"), + filter); + } + i = (strlen (email) + 8) & (~7); /* make multiple of 8 */ + msg = + GNUNET_malloc (sizeof (GNUNET_MessageHello) + sizeof (EmailAddress) + i); + memset (msg, 0, sizeof (GNUNET_MessageHello) + sizeof (EmailAddress) + i); + haddr = (EmailAddress *) & msg[1]; + memset (&haddr->filter[0], 0, FILTER_STRING_SIZE); + strcpy (&haddr->filter[0], filter); + memcpy (&haddr->senderAddress[0], email, strlen (email) + 1); + msg->senderAddressSize = htons (strlen (email) + 1 + sizeof (EmailAddress)); + msg->protocol = htons (GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP); + msg->MTU = htonl (smtpAPI.mtu); + msg->header.size = htons (GNUNET_sizeof_hello (msg)); + if (api_verify_hello (msg) == GNUNET_SYSERR) + GNUNET_GE_ASSERT (ectx, 0); + GNUNET_free (filter); + return msg; +} + +struct GetMessageClosure +{ + unsigned int esize; + unsigned int pos; + char *ebody; +}; + +static const char * +get_message (void **buf, int *len, void *cls) +{ + struct GetMessageClosure *gmc = cls; + + *buf = NULL; + if (len == NULL) + { + gmc->pos = 0; + return NULL; + } + if (gmc->pos == gmc->esize) + return NULL; /* done */ + *len = gmc->esize; + gmc->pos = gmc->esize; + return gmc->ebody; +} + +/** + * Send a message to the specified remote node. + * + * @param tsession the GNUNET_MessageHello identifying the remote node + * @param message what to send + * @param size the size of the message + * @return GNUNET_SYSERR on error, GNUNET_OK on success + */ +static int +api_send (GNUNET_TSession * tsession, + const void *msg, const unsigned int size, int important) +{ + const GNUNET_MessageHello *hello; + const EmailAddress *haddr; + char *m; + char *filter; + char *fvalue; + SMTPMessage *mp; + struct GetMessageClosure gm_cls; + smtp_session_t session; + smtp_message_t message; + smtp_recipient_t recipient; +#define EBUF_LEN 128 + char ebuf[EBUF_LEN]; + GNUNET_CronTime now; + + if (smtp_shutdown == GNUNET_YES) + return GNUNET_SYSERR; + if ((size == 0) || (size > smtpAPI.mtu)) + { + GNUNET_GE_BREAK (ectx, 0); + return GNUNET_SYSERR; + } + now = GNUNET_get_time (); + if ((important != GNUNET_YES) && + ((now - last_transmission) * rate_limit) < GNUNET_CRON_HOURS) + return GNUNET_NO; /* rate too high */ + last_transmission = now; + + hello = (const GNUNET_MessageHello *) tsession->internal; + if (hello == NULL) + return GNUNET_SYSERR; + GNUNET_mutex_lock (lock); + session = smtp_create_session (); + if (session == NULL) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_IMMEDIATE, + _("SMTP: `%s' failed: %s.\n"), + "smtp_create_session", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + if (0 == smtp_set_server (session, smtp_server_name)) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_IMMEDIATE, + _("SMTP: `%s' failed: %s.\n"), + "smtp_set_server", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + haddr = (const EmailAddress *) &hello[1]; + message = smtp_add_message (session); + if (message == NULL) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_add_message", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + smtp_set_header (message, "To", NULL, haddr->senderAddress); + smtp_set_header (message, "From", NULL, email); + + filter = GNUNET_strdup (haddr->filter); + fvalue = strstr (filter, ": "); + GNUNET_GE_ASSERT (NULL, NULL != fvalue); + fvalue[0] = '\0'; + fvalue += 2; + if (0 == smtp_set_header (message, filter, fvalue)) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_set_header", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + GNUNET_free (filter); + return GNUNET_SYSERR; + } + GNUNET_free (filter); + m = GNUNET_malloc (size + sizeof (SMTPMessage)); + memcpy (m, msg, size); + mp = (SMTPMessage *) & m[size]; + mp->header.size = htons (size + sizeof (SMTPMessage)); + mp->header.type = htons (0); + mp->sender = *coreAPI->my_identity; + gm_cls.ebody = NULL; + gm_cls.pos = 0; + gm_cls.esize = + base64_encode (m, size + sizeof (SMTPMessage), &gm_cls.ebody); + GNUNET_free (m); + if (0 == smtp_size_set_estimate (message, gm_cls.esize)) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_size_set_estimate", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + } + if (0 == smtp_set_messagecb (message, &get_message, &gm_cls)) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_set_messagecb", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + GNUNET_free (gm_cls.ebody); + return GNUNET_SYSERR; + } + recipient = smtp_add_recipient (message, haddr->senderAddress); + if (recipient == NULL) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_add_recipient", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + return GNUNET_SYSERR; + } + if (0 == smtp_start_session (session)) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER | + GNUNET_GE_BULK, + _("SMTP: `%s' failed: %s.\n"), + "smtp_start_session", + smtp_strerror (smtp_errno (), ebuf, EBUF_LEN)); + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + GNUNET_free (gm_cls.ebody); + return GNUNET_SYSERR; + } + if (stats != NULL) + stats->change (stat_bytesSent, size); + if (coreAPI->load_monitor != NULL) + GNUNET_network_monitor_notify_transmission (coreAPI->load_monitor, + GNUNET_ND_UPLOAD, + gm_cls.esize); + smtp_message_reset_status (message); /* this is needed to plug a 28-byte/message memory leak in libesmtp */ + smtp_destroy_session (session); + GNUNET_mutex_unlock (lock); + GNUNET_free (gm_cls.ebody); + return GNUNET_OK; +} + +/** + * Establish a connection to a remote node. + * @param helo the hello-Message for the target node + * @param tsessionPtr the session handle that is to be set + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +api_connect (const GNUNET_MessageHello * hello, + GNUNET_TSession ** tsessionPtr, int may_reuse) +{ + GNUNET_TSession *tsession; + + tsession = GNUNET_malloc (sizeof (GNUNET_TSession)); + tsession->internal = GNUNET_malloc (GNUNET_sizeof_hello (hello)); + tsession->peer = hello->senderIdentity; + memcpy (tsession->internal, hello, GNUNET_sizeof_hello (hello)); + tsession->ttype = smtpAPI.protocol_number; + (*tsessionPtr) = tsession; + return GNUNET_OK; +} + +/** + * Disconnect from a remote node. + * + * @param tsession the session that is closed + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +api_disconnect (GNUNET_TSession * tsession) +{ + if (tsession != NULL) + { + if (tsession->internal != NULL) + GNUNET_free (tsession->internal); + GNUNET_free (tsession); + } + return GNUNET_OK; +} + +/** + * Start the server process to receive inbound traffic. + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +api_start_transport_server () +{ + smtp_shutdown = GNUNET_NO; + /* initialize SMTP network */ + dispatchThread = + GNUNET_thread_create (&listenAndDistribute, NULL, 1024 * 4); + if (dispatchThread == NULL) + { + GNUNET_GE_DIE_STRERROR (ectx, + GNUNET_GE_ADMIN | GNUNET_GE_BULK | + GNUNET_GE_FATAL, "pthread_create"); + return GNUNET_SYSERR; + } + return GNUNET_OK; +} + +/** + * Shutdown the server process (stop receiving inbound traffic). Maybe + * restarted later! + */ +static int +api_stop_transport_server () +{ + void *unused; + + smtp_shutdown = GNUNET_YES; + GNUNET_thread_stop_sleep (dispatchThread); + GNUNET_thread_join (dispatchThread, &unused); + return GNUNET_OK; +} + +/** + * Convert SMTP hello to an IP address (always fails). + */ +static int +api_hello_to_address (const GNUNET_MessageHello * hello, + void **sa, unsigned int *sa_len) +{ + return GNUNET_SYSERR; +} + +/** + * Always fails. + */ +static int +api_associate (GNUNET_TSession * tsession) +{ + return GNUNET_SYSERR; /* SMTP connections can never be associated */ +} + +/** + * Always succeeds (for now; we should look at adding + * frequency limits to SMTP in the future!). + */ +static int +api_test_would_try (GNUNET_TSession * tsession, const unsigned int size, + int important) +{ + return GNUNET_OK; /* we always try... */ +} + +/** + * The exported method. Makes the core api available via a global and + * returns the smtp transport API. + */ +GNUNET_TransportAPI * +inittransport_smtp (GNUNET_CoreAPIForTransport * core) +{ + + + unsigned long long mtu; + struct sigaction sa; + + coreAPI = core; + ectx = core->ectx; + if (!GNUNET_GC_have_configuration_value (coreAPI->cfg, "SMTP", "EMAIL")) + { + GNUNET_GE_LOG (ectx, + GNUNET_GE_ERROR | GNUNET_GE_BULK | GNUNET_GE_USER, + _ + ("No email-address specified, can not start SMTP transport.\n")); + return NULL; + } + GNUNET_GC_get_configuration_value_number (coreAPI->cfg, + "SMTP", + "MTU", + 1200, + SMTP_MESSAGE_SIZE, + SMTP_MESSAGE_SIZE, &mtu); + GNUNET_GC_get_configuration_value_number (coreAPI->cfg, + "SMTP", + "RATELIMIT", + 0, 0, 1024 * 1024, &rate_limit); + stats = coreAPI->service_request ("stats"); + if (stats != NULL) + { + stat_bytesReceived + = stats->create (gettext_noop ("# bytes received via SMTP")); + stat_bytesSent = stats->create (gettext_noop ("# bytes sent via SMTP")); + stat_bytesDropped + = stats->create (gettext_noop ("# bytes dropped by SMTP (outgoing)")); + } + GNUNET_GC_get_configuration_value_filename (coreAPI->cfg, + "SMTP", + "PIPE", + GNUNET_DEFAULT_DAEMON_VAR_DIRECTORY + "/smtp-pipe", &pipename); + UNLINK (pipename); + if (0 != mkfifo (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH)) + { + GNUNET_GE_LOG_STRERROR (ectx, + GNUNET_GE_ADMIN | GNUNET_GE_BULK | + GNUNET_GE_FATAL, "mkfifo"); + GNUNET_free (pipename); + coreAPI->service_release (stats); + stats = NULL; + return NULL; + } + /* we need to allow the mailer program to send us messages; + easiest done by giving it write permissions (see Mantis #1142) */ + if (0 != chmod (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH)) + GNUNET_GE_LOG_STRERROR (ectx, + GNUNET_GE_ADMIN | GNUNET_GE_BULK | + GNUNET_GE_WARNING, "chmod"); + GNUNET_GC_get_configuration_value_string (coreAPI->cfg, + "SMTP", "EMAIL", NULL, &email); + lock = GNUNET_mutex_create (GNUNET_NO); + GNUNET_GC_get_configuration_value_string (coreAPI->cfg, + "SMTP", + "SERVER", + "localhost:25", + &smtp_server_name); + sa.sa_handler = SIG_IGN; + sigemptyset (&sa.sa_mask); + sa.sa_flags = 0; + sigaction (SIGPIPE, &sa, &old_handler); + + smtpAPI.protocol_number = GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP; + smtpAPI.mtu = mtu - sizeof (SMTPMessage); + smtpAPI.cost = 50; + smtpAPI.hello_verify = &api_verify_hello; + smtpAPI.hello_create = &api_create_hello; + smtpAPI.connect = &api_connect; + smtpAPI.send = &api_send; + smtpAPI.associate = &api_associate; + smtpAPI.disconnect = &api_disconnect; + smtpAPI.server_start = &api_start_transport_server; + smtpAPI.server_stop = &api_stop_transport_server; + smtpAPI.hello_to_address = &api_hello_to_address; + smtpAPI.send_now_test = &api_test_would_try; + return &smtpAPI; +} + +void +donetransport_smtp () +{ + sigaction (SIGPIPE, &old_handler, NULL); + GNUNET_free (smtp_server_name); + if (stats != NULL) + { + coreAPI->service_release (stats); + stats = NULL; + } + GNUNET_mutex_destroy (lock); + lock = NULL; + UNLINK (pipename); + GNUNET_free (pipename); + pipename = NULL; + GNUNET_free (email); + email = NULL; +} + +/* end of smtp.c */ diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c new file mode 100644 index 000000000..c87056e71 --- /dev/null +++ b/src/transport/plugin_transport_tcp.c @@ -0,0 +1,1782 @@ +/* + This file is part of GNUnet + (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/plugin_transport_tcp.c + * @brief Implementation of the TCP transport service + * @author Christian Grothoff + */ + +#include "platform.h" +#include "gnunet_hello_lib.h" +#include "gnunet_network_lib.h" +#include "gnunet_os_lib.h" +#include "gnunet_peerinfo_service.h" +#include "gnunet_protocols.h" +#include "gnunet_resolver_service.h" +#include "gnunet_server_lib.h" +#include "gnunet_service_lib.h" +#include "gnunet_statistics_service.h" +#include "gnunet_transport_service.h" +#include "plugin_transport.h" +#include "transport.h" + +#define DEBUG_TCP GNUNET_NO + +/** + * After how long do we expire an address that we + * learned from another peer if it is not reconfirmed + * by anyone? + */ +#define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6) + +/** + * How long until we give up on transmitting the welcome message? + */ +#define WELCOME_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) + +/** + * How long until we give up on transmitting the welcome message? + */ +#define HOSTNAME_RESOLVE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) + +/** + * For how many messages back to we keep transmission times? + */ +#define ACK_LOG_SIZE 32 + +/** + * Initial handshake message for a session. This header + * is followed by the address that the other peer used to + * connect to us (so that we may learn it) or the address + * that the other peer got from the accept call. + */ +struct WelcomeMessage +{ + struct GNUNET_MessageHeader header; + + /** + * Identity of the node connecting (TCP client) + */ + struct GNUNET_PeerIdentity clientIdentity; + +}; + + +/** + * Encapsulation for normal TCP traffic. + */ +struct DataMessage +{ + struct GNUNET_MessageHeader header; + + /** + * For alignment. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * Number of the last message that was received from the other peer. + */ + uint64_t ack_in GNUNET_PACKED; + + /** + * Number of this outgoing message. + */ + uint64_t ack_out GNUNET_PACKED; + + /** + * How long was sending this ack delayed by the other peer + * (estimate). The receiver of this message can use the delay + * between sending his message number 'ack' and receiving this ack + * minus the delay as an estimate of the round-trip time. + */ + struct GNUNET_TIME_RelativeNBO delay; + +}; + + +/** + * Encapsulation of all of the state of the plugin. + */ +struct Plugin; + + +/** + * Information kept for each message that is yet to + * be transmitted. + */ +struct PendingMessage +{ + + /** + * This is a linked list. + */ + struct PendingMessage *next; + + /** + * The pending message, pointer to the end + * of this struct, do not free! + */ + struct GNUNET_MessageHeader *msg; + + + /** + * Continuation function to call once the message + * has been sent. Can be NULL if there is no + * continuation to call. + */ + GNUNET_TRANSPORT_TransmitContinuation transmit_cont; + + /** + * Closure for transmit_cont. + */ + void *transmit_cont_cls; + + /** + * Timeout value for the pending message. + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * GNUNET_YES if this is a welcome message; + * otherwise this should be a DATA message. + */ + int is_welcome; + +}; + + +/** + * Session handle for TCP connections. + */ +struct Session +{ + + /** + * Stored in a linked list. + */ + struct Session *next; + + /** + * Pointer to the global plugin struct. + */ + struct Plugin *plugin; + + /** + * The client (used to identify this connection) + */ + struct GNUNET_SERVER_Client *client; + + /** + * gnunet-service-transport context for this connection. + */ + struct ReadyList *service_context; + + /** + * Messages currently pending for transmission + * to this peer, if any. + */ + struct PendingMessage *pending_messages; + + /** + * Handle for pending transmission request. + */ + struct GNUNET_NETWORK_TransmitHandle *transmit_handle; + + /** + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) + */ + struct GNUNET_PeerIdentity target; + + /** + * At what time did we reset last_received last? + */ + struct GNUNET_TIME_Absolute last_quota_update; + + /** + * Address of the other peer if WE initiated the connection + * (and hence can be sure what it is), otherwise NULL. + */ + void *connect_addr; + + /** + * How many bytes have we received since the "last_quota_update" + * timestamp? + */ + uint64_t last_received; + + /** + * Our current latency estimate (in ms). + */ + double latency_estimate; + + /** + * Time when we generated the last ACK_LOG_SIZE acks. + * (the "last" refers to the "out_msg_counter" here) + */ + struct GNUNET_TIME_Absolute gen_time[ACK_LOG_SIZE]; + + /** + * Our current sequence number. + */ + uint64_t out_msg_counter; + + /** + * Highest received incoming sequence number. + */ + uint64_t max_in_msg_counter; + + /** + * Number of bytes per ms that this peer is allowed + * to send to us. + */ + uint32_t quota_in; + + /** + * Length of connect_addr, can be 0. + */ + size_t connect_alen; + + /** + * Are we still expecting the welcome message? (GNUNET_YES/GNUNET_NO) + */ + int expecting_welcome; + + /** + * Are we still trying to connect? + */ + int still_connecting; + +}; + + +/** + * Encapsulation of all of the state of the plugin. + */ +struct Plugin +{ + /** + * Our environment. + */ + struct GNUNET_TRANSPORT_PluginEnvironment *env; + + /** + * The listen socket. + */ + struct GNUNET_NETWORK_SocketHandle *lsock; + + /** + * List of open TCP sessions. + */ + struct Session *sessions; + + /** + * Handle for the statistics service. + */ + struct GNUNET_STATISTICS_Handle *statistics; + + /** + * Handle to the network service. + */ + struct GNUNET_SERVICE_Context *service; + + /** + * Handle to the server for this service. + */ + struct GNUNET_SERVER_Handle *server; + + /** + * Copy of the handler array where the closures are + * set to this struct's instance. + */ + struct GNUNET_SERVER_MessageHandler *handlers; + + /** + * ID of task used to update our addresses when one expires. + */ + GNUNET_SCHEDULER_TaskIdentifier address_update_task; + + /** + * Port that we are actually listening on. + */ + uint16_t open_port; + + /** + * Port that the user said we would have visible to the + * rest of the world. + */ + uint16_t adv_port; + +}; + + +/** + * Find the session handle for the given peer. + */ +static struct Session * +find_session_by_target (struct Plugin *plugin, + const struct GNUNET_PeerIdentity *target) +{ + struct Session *ret; + + ret = plugin->sessions; + while ((ret != NULL) && + (0 != memcmp (target, + &ret->target, sizeof (struct GNUNET_PeerIdentity)))) + ret = ret->next; + return ret; +} + + +/** + * Find the session handle for the given peer. + */ +static struct Session * +find_session_by_client (struct Plugin *plugin, + const struct GNUNET_SERVER_Client *client) +{ + struct Session *ret; + + ret = plugin->sessions; + while ((ret != NULL) && (client != ret->client)) + ret = ret->next; + return ret; +} + + +/** + * Create a welcome message. + */ +static struct PendingMessage * +create_welcome (size_t addrlen, const void *addr, struct Plugin *plugin) +{ + struct PendingMessage *pm; + struct WelcomeMessage *welcome; + + pm = GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct WelcomeMessage) + addrlen); + pm->msg = (struct GNUNET_MessageHeader *) &pm[1]; + welcome = (struct WelcomeMessage *) &pm[1]; + welcome->header.size = htons (sizeof (struct WelcomeMessage) + addrlen); + welcome->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME); + GNUNET_CRYPTO_hash (plugin->env->my_public_key, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &welcome->clientIdentity.hashPubKey); + memcpy (&welcome[1], addr, addrlen); + pm->timeout = GNUNET_TIME_relative_to_absolute (WELCOME_TIMEOUT); + pm->is_welcome = GNUNET_YES; + return pm; +} + + +/** + * Create a new session using the specified address + * for the welcome message. + * + * @param plugin us + * @param target peer to connect to + * @param client client to use + * @param addrlen IPv4 or IPv6 + * @param addr either struct sockaddr_in or struct sockaddr_in6 + * @return NULL connection failed / invalid address + */ +static struct Session * +create_session (struct Plugin *plugin, + const struct GNUNET_PeerIdentity *target, + struct GNUNET_SERVER_Client *client, + const void *addr, size_t addrlen) +{ + struct Session *ret; + + ret = GNUNET_malloc (sizeof (struct Session)); + ret->plugin = plugin; + ret->next = plugin->sessions; + plugin->sessions = ret; + ret->client = client; + ret->target = *target; + ret->last_quota_update = GNUNET_TIME_absolute_get (); + ret->quota_in = plugin->env->default_quota_in; + ret->expecting_welcome = GNUNET_YES; + ret->pending_messages = create_welcome (addrlen, addr, plugin); + return ret; +} + + +/** + * Create a new session connecting to the specified + * target at the specified address. + * + * @param plugin us + * @param target peer to connect to + * @param addrlen IPv4 or IPv6 + * @param addr either struct sockaddr_in or struct sockaddr_in6 + * @return NULL connection failed / invalid address + */ +static struct Session * +connect_and_create_session (struct Plugin *plugin, + const struct GNUNET_PeerIdentity *target, + const void *addr, size_t addrlen) +{ + struct GNUNET_SERVER_Client *client; + struct GNUNET_NETWORK_SocketHandle *conn; + struct Session *session; + int af; + char buf[INET6_ADDRSTRLEN]; + uint16_t port; + + session = plugin->sessions; + while (session != NULL) + { + if ((0 == memcmp (target, + &session->target, + sizeof (struct GNUNET_PeerIdentity))) && + (session->connect_alen == addrlen) && + (0 == memcmp (session->connect_addr, addr, addrlen))) + return session; /* already exists! */ + session = session->next; + } + + if (addrlen == sizeof (struct sockaddr_in)) + { + af = AF_INET; + inet_ntop (af, + &((struct sockaddr_in *) addr)->sin_addr, buf, sizeof (buf)); + port = ntohs (((struct sockaddr_in *) addr)->sin_port); + } + else if (addrlen == sizeof (struct sockaddr_in6)) + { + af = AF_INET6; + inet_ntop (af, + &((struct sockaddr_in6 *) addr)->sin6_addr, + buf, sizeof (buf)); + port = ntohs (((struct sockaddr_in6 *) addr)->sin6_port); + } + else + { + GNUNET_break_op (0); + return NULL; /* invalid address */ + } + conn = GNUNET_NETWORK_socket_create_from_sockaddr (plugin->env->sched, + af, + addr, + addrlen, + GNUNET_SERVER_MAX_MESSAGE_SIZE); + if (conn == NULL) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Failed to create connection to peer at `%s:%u'.\n", + buf, port); +#endif + return NULL; + } + client = GNUNET_SERVER_connect_socket (plugin->server, conn); + GNUNET_assert (client != NULL); + session = create_session (plugin, target, client, addr, addrlen); + session->connect_alen = addrlen; + session->connect_addr = GNUNET_malloc (addrlen); + memcpy (session->connect_addr, addr, addrlen); +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Creating new session %p with `%s:%u' based on `%s' request.\n", + session, buf, port, "send_to"); +#endif + return session; +} + + +/** + * If we have pending messages, ask the server to + * transmit them (schedule the respective tasks, etc.) + * + * @param session for which session should we do this + */ +static void process_pending_messages (struct Session *session); + + +/** + * Function called to notify a client about the socket + * begin ready to queue more data. "buf" will be + * NULL and "size" zero if the socket was closed for + * writing in the meantime. + * + * @param cls closure + * @param size number of bytes available in buf + * @param buf where the callee should write the message + * @return number of bytes written to buf + */ +static size_t +do_transmit (void *cls, size_t size, void *buf) +{ + struct Session *session = cls; + struct PendingMessage *pm; + char *cbuf; + uint16_t msize; + size_t ret; + struct DataMessage *dm; + + session->transmit_handle = NULL; + if (buf == NULL) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Timeout trying to transmit\n"); +#endif + /* timeout */ + while (NULL != (pm = session->pending_messages)) + { + session->pending_messages = pm->next; + if (pm->transmit_cont != NULL) + pm->transmit_cont (pm->transmit_cont_cls, + session->service_context, + &session->target, GNUNET_SYSERR); + GNUNET_free (pm); + } + return 0; + } + ret = 0; + cbuf = buf; + while (NULL != (pm = session->pending_messages)) + { + if (pm->is_welcome) + { + if (size < (msize = htons (pm->msg->size))) + break; + memcpy (cbuf, pm->msg, msize); + cbuf += msize; + ret += msize; + size -= msize; + } + else + { + if (size < + sizeof (struct DataMessage) + (msize = htons (pm->msg->size))) + break; + dm = (struct DataMessage *) cbuf; + dm->header.size = htons (sizeof (struct DataMessage) + msize); + dm->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_DATA); + dm->ack_out = GNUNET_htonll (++session->out_msg_counter); + dm->ack_in = GNUNET_htonll (session->max_in_msg_counter); + cbuf += sizeof (struct DataMessage); + ret += sizeof (struct DataMessage); + size -= sizeof (struct DataMessage); + memcpy (cbuf, pm->msg, msize); + cbuf += msize; + ret += msize; + size -= msize; + } + session->pending_messages = pm->next; + if (pm->transmit_cont != NULL) + pm->transmit_cont (pm->transmit_cont_cls, + session->service_context, + &session->target, GNUNET_OK); + GNUNET_free (pm); + session->gen_time[session->out_msg_counter % ACK_LOG_SIZE] + = GNUNET_TIME_absolute_get (); + } + process_pending_messages (session); +#if DEBUG_TCP || 1 + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Transmitting %u bytes\n", ret); +#endif + return ret; +} + + +/** + * If we have pending messages, ask the server to + * transmit them (schedule the respective tasks, etc.) + * + * @param session for which session should we do this + */ +static void +process_pending_messages (struct Session *session) +{ + GNUNET_assert (session->client != NULL); + if (session->pending_messages == NULL) + return; + if (session->transmit_handle != NULL) + return; + session->transmit_handle + = GNUNET_SERVER_notify_transmit_ready (session->client, + htons (session->pending_messages-> + msg->size) + + (session->pending_messages-> + is_welcome ? 0 : sizeof (struct + DataMessage)), + GNUNET_TIME_absolute_get_remaining + (session->pending_messages[0]. + timeout), &do_transmit, session); +} + + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin using a fresh connection (even if + * we already have a connection to this peer, this function is + * required to establish a new one). + * + * @param cls closure + * @param target who should receive this message + * @param msg1 first message to transmit + * @param msg2 second message to transmit (can be NULL) + * @param timeout how long should we try to transmit these? + * @param addrlen length of the address + * @param addr the address + * @return session if the transmission has been scheduled + * NULL if the address format is invalid + */ +static void * +tcp_plugin_send_to (void *cls, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg1, + const struct GNUNET_MessageHeader *msg2, + struct GNUNET_TIME_Relative timeout, + const void *addr, size_t addrlen) +{ + struct Plugin *plugin = cls; + struct Session *session; + struct PendingMessage *pl; + struct PendingMessage *pm; + + session = connect_and_create_session (plugin, target, addr, addrlen); + if (session == NULL) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Failed to create fresh session.\n"); +#endif + return NULL; + } + pl = NULL; + if (msg2 != NULL) + { + pm = GNUNET_malloc (sizeof (struct PendingMessage) + + ntohs (msg2->size)); + pm->msg = (struct GNUNET_MessageHeader *) &pm[1]; + memcpy (pm->msg, msg2, ntohs (msg2->size)); + pm->timeout = GNUNET_TIME_relative_to_absolute (timeout); + pm->is_welcome = GNUNET_NO; + pl = pm; + } + if (msg1 != NULL) + { + pm = GNUNET_malloc (sizeof (struct PendingMessage) + + ntohs (msg1->size)); + pm->msg = (struct GNUNET_MessageHeader *) &pm[1]; + memcpy (pm->msg, msg1, ntohs (msg1->size)); + pm->timeout = GNUNET_TIME_relative_to_absolute (timeout); + pm->is_welcome = GNUNET_NO; + pm->next = pl; + pl = pm; + } + /* append */ + if (session->pending_messages != NULL) + { + pm = session->pending_messages; + while (pm->next != NULL) + pm = pm->next; + pm->next = pl; + } + else + { + session->pending_messages = pl; + } + process_pending_messages (session); + return session; +} + + +/** + * Functions with this signature are called whenever we need + * to close a session due to a disconnect or failure to + * establish a connection. + * + * @param session session to close down + */ +static void +disconnect_session (struct Session *session) +{ + struct Session *prev; + struct Session *pos; + struct PendingMessage *pm; + +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Disconnecting from other peer (session %p).\n", session); +#endif + /* remove from session list */ + prev = NULL; + pos = session->plugin->sessions; + while (pos != session) + { + prev = pos; + pos = pos->next; + } + if (prev == NULL) + session->plugin->sessions = session->next; + else + prev->next = session->next; + /* clean up state */ + if (session->client != NULL) + { +#if DEBUG_TCP + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting from client address %p\n", session->client); +#endif + GNUNET_SERVER_client_drop (session->client); + session->client = NULL; + } + if (session->transmit_handle != NULL) + { + GNUNET_NETWORK_notify_transmit_ready_cancel (session->transmit_handle); + session->transmit_handle = NULL; + } + while (NULL != (pm = session->pending_messages)) + { + session->pending_messages = pm->next; + if (NULL != pm->transmit_cont) + pm->transmit_cont (pm->transmit_cont_cls, + session->service_context, + &session->target, GNUNET_SYSERR); + GNUNET_free (pm); + } + /* notify transport service about disconnect */ + session->plugin->env->receive (session->plugin->env->cls, + session, + session->service_context, + GNUNET_TIME_UNIT_ZERO, + &session->target, NULL); + GNUNET_free_non_null (session->connect_addr); + GNUNET_free (session); +} + + +/** + * Iterator callback to go over all addresses. If we get + * a TCP address, increment the counter + * + * @param cls closure, points to the counter + * @param tname name of the transport + * @param expiration expiration time + * @param addr the address + * @param addrlen length of the address + * @return GNUNET_OK to keep the address, + * GNUNET_NO to delete it from the HELLO + * GNUNET_SYSERR to stop iterating (but keep current address) + */ +static int +count_tcp_addresses (void *cls, + const char *tname, + struct GNUNET_TIME_Absolute expiration, + const void *addr, size_t addrlen) +{ + unsigned int *counter = cls; + + if (0 != strcmp (tname, "tcp")) + return GNUNET_OK; /* not one of ours */ + (*counter)++; + return GNUNET_OK; /* failed to connect */ +} + + +struct ConnectContext +{ + struct Plugin *plugin; + + struct GNUNET_NETWORK_SocketHandle *sa; + + struct PendingMessage *welcome; + + unsigned int pos; +}; + + +/** + * Iterator callback to go over all addresses. If we get + * the "pos" TCP address, try to connect to it. + * + * @param cls closure + * @param tname name of the transport + * @param expiration expiration time + * @param addrlen length of the address + * @param addr the address + * @return GNUNET_OK to keep the address, + * GNUNET_NO to delete it from the HELLO + * GNUNET_SYSERR to stop iterating (but keep current address) + */ +static int +try_connect_to_address (void *cls, + const char *tname, + struct GNUNET_TIME_Absolute expiration, + const void *addr, size_t addrlen) +{ + struct ConnectContext *cc = cls; + int af; + + if (0 != strcmp (tname, "tcp")) + return GNUNET_OK; /* not one of ours */ + if (sizeof (struct sockaddr_in) == addrlen) + af = AF_INET; + else if (sizeof (struct sockaddr_in6) == addrlen) + af = AF_INET6; + else + { + /* not a valid address */ + GNUNET_break (0); + return GNUNET_NO; + } + if (0 == cc->pos--) + { + cc->welcome = create_welcome (addrlen, addr, cc->plugin); + cc->sa = + GNUNET_NETWORK_socket_create_from_sockaddr (cc->plugin->env->sched, + af, addr, addrlen, + GNUNET_SERVER_MAX_MESSAGE_SIZE); +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Connected to other peer.\n"); +#endif + return GNUNET_SYSERR; + } + return GNUNET_OK; /* failed to connect */ +} + + +/** + * Type of an iterator over the hosts. Note that each + * host will be called with each available protocol. + * + * @param cls closure + * @param peer id of the peer, NULL for last call + * @param hello hello message for the peer (can be NULL) + * @param trust amount of trust we have in the peer + */ +static void +session_try_connect (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *hello, uint32_t trust) +{ + struct Session *session = cls; + unsigned int count; + struct ConnectContext cctx; + struct PendingMessage *pm; + + if (peer == NULL) + { + /* last call, destroy session if we are still not + connected */ + if (session->still_connecting == GNUNET_NO) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Connected to other peer, now processing messages.\n"); +#endif + process_pending_messages (session); + } + else + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Failed to connect to other peer, now closing session.\n"); +#endif + disconnect_session (session); + } + return; + } + if ((hello == NULL) || (session->client != NULL)) + { + GNUNET_break (0); /* should this ever happen!? */ + return; + } + count = 0; + GNUNET_HELLO_iterate_addresses (hello, + GNUNET_NO, &count_tcp_addresses, &count); + if (count == 0) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Asked to connect, but have no addresses to try.\n"); +#endif + return; + } + cctx.plugin = session->plugin; + cctx.sa = NULL; + cctx.welcome = NULL; + cctx.pos = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, count); + GNUNET_HELLO_iterate_addresses (hello, + GNUNET_NO, &try_connect_to_address, &cctx); + if (cctx.sa == NULL) + { +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Asked to connect, but all addresses failed.\n"); +#endif + GNUNET_free_non_null (cctx.welcome); + return; + } + session->client = GNUNET_SERVER_connect_socket (session->plugin->server, + cctx.sa); +#if DEBUG_TCP + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Connected getting client address %p\n", session->client); +#endif + if (session->client == NULL) + { + GNUNET_break (0); /* how could this happen? */ + GNUNET_free_non_null (cctx.welcome); + return; + } + pm = cctx.welcome; + /* prepend (!) */ + pm->next = session->pending_messages; + session->pending_messages = pm; + session->still_connecting = GNUNET_NO; +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Connected to other peer, now sending `%s' message.\n", + "WELCOME"); +#endif +} + + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin. + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL + * @param service_context value passed to the transport-service + * to identify the neighbour + * @param target who should receive this message + * @param msg the message to transmit + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...) + * @param cont_cls closure for cont + * @return plugin_context that should be used next time for + * sending messages to the specified peer + */ +static void * +tcp_plugin_send (void *cls, + void *plugin_context, + struct ReadyList *service_context, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) +{ + struct Plugin *plugin = cls; + struct Session *session = plugin_context; + struct PendingMessage *pm; + struct PendingMessage *pme; + + if (session == NULL) + session = find_session_by_target (plugin, target); + pm = GNUNET_malloc (sizeof (struct PendingMessage) + ntohs (msg->size)); + pm->msg = (struct GNUNET_MessageHeader *) &pm[1]; + memcpy (pm->msg, msg, ntohs (msg->size)); + pm->timeout = GNUNET_TIME_relative_to_absolute (timeout); + pm->transmit_cont = cont; + pm->transmit_cont_cls = cont_cls; + if (session == NULL) + { + session = GNUNET_malloc (sizeof (struct Session)); +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Asked to transmit, creating fresh session %p.\n", + session); +#endif + session->next = plugin->sessions; + plugin->sessions = session; + session->plugin = plugin; + session->target = *target; + session->last_quota_update = GNUNET_TIME_absolute_get (); + session->quota_in = plugin->env->default_quota_in; + session->expecting_welcome = GNUNET_YES; + session->still_connecting = GNUNET_YES; + session->pending_messages = pm; + GNUNET_PEERINFO_for_all (plugin->env->cfg, + plugin->env->sched, + target, + 0, timeout, &session_try_connect, session); + return session; + } + GNUNET_assert (session != NULL); + GNUNET_assert (session->still_connecting == GNUNET_NO); + /* append pm to pending_messages list */ + pme = session->pending_messages; + if (pme == NULL) + { + session->pending_messages = pm; + } + else + { + while (NULL != pme->next) + pme = pme->next; + pme->next = pm; + } +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Asked to transmit, added message to list.\n"); +#endif + process_pending_messages (session); + return session; +} + + + +/** + * Function that can be called to force a disconnect from the + * specified neighbour. This should also cancel all previously + * scheduled transmissions. Obviously the transmission may have been + * partially completed already, which is OK. The plugin is supposed + * to close the connection (if applicable) and no longer call the + * transmit continuation(s). + * + * Finally, plugin MUST NOT call the services's receive function to + * notify the service that the connection to the specified target was + * closed after a getting this call. + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL (if + * NULL was returned from the transmit function) + * @param service_context must correspond to the service context + * of the corresponding Transmit call; the plugin should + * not cancel a send call made with a different service + * context pointer! Never NULL. + * @param target peer for which the last transmission is + * to be cancelled + */ +static void +tcp_plugin_cancel (void *cls, + void *plugin_context, + struct ReadyList *service_context, + const struct GNUNET_PeerIdentity *target) +{ + struct Plugin *plugin = cls; + struct PendingMessage *pm; + struct Session *session; + struct Session *next; + + session = plugin->sessions; + while (session != NULL) + { + next = session->next; + if (0 == memcmp (target, + &session->target, sizeof (struct GNUNET_PeerIdentity))) + { + pm = session->pending_messages; + while (pm != NULL) + { + pm->transmit_cont = NULL; + pm->transmit_cont_cls = NULL; + pm = pm->next; + } + session->service_context = NULL; + GNUNET_SERVER_client_disconnect (session->client); + /* rest of the clean-up of the session will be done as part of + disconnect_notify which should be triggered any time now */ + } + session = next; + } +} + + +struct PrettyPrinterContext +{ + GNUNET_TRANSPORT_AddressStringCallback asc; + void *asc_cls; + uint16_t port; +}; + + +/** + * Append our port and forward the result. + */ +static void +append_port (void *cls, const char *hostname) +{ + struct PrettyPrinterContext *ppc = cls; + char *ret; + + if (hostname == NULL) + { + ppc->asc (ppc->asc_cls, NULL); + GNUNET_free (ppc); + return; + } + GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port); + ppc->asc (ppc->asc_cls, ret); + GNUNET_free (ret); +} + + +/** + * Convert the transports address to a nice, human-readable + * format. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + * @param numeric should (IP) addresses be displayed in numeric form? + * @param timeout after how long should we give up? + * @param asc function to call on each string + * @param asc_cls closure for asc + */ +static void +tcp_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) +{ + struct Plugin *plugin = cls; + const struct sockaddr_in *v4; + const struct sockaddr_in6 *v6; + struct PrettyPrinterContext *ppc; + + if ((addrlen != sizeof (struct sockaddr_in)) && + (addrlen != sizeof (struct sockaddr_in6))) + { + /* invalid address */ + GNUNET_break_op (0); + asc (asc_cls, NULL); + return; + } + ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext)); + ppc->asc = asc; + ppc->asc_cls = asc_cls; + if (addrlen == sizeof (struct sockaddr_in)) + { + v4 = (const struct sockaddr_in *) addr; + ppc->port = ntohs (v4->sin_port); + } + else + { + v6 = (const struct sockaddr_in6 *) addr; + ppc->port = ntohs (v6->sin6_port); + + } + GNUNET_RESOLVER_hostname_get (plugin->env->sched, + plugin->env->cfg, + addr, + addrlen, + !numeric, timeout, &append_port, ppc); +} + + +/** + * Update the last-received and bandwidth quota values + * for this session. + * + * @param session session to update + * @param force set to GNUNET_YES if we should update even + * though the minimum refresh time has not yet expired + */ +static void +update_quota (struct Session *session, int force) +{ + struct GNUNET_TIME_Absolute now; + unsigned long long delta; + unsigned long long total_allowed; + unsigned long long total_remaining; + + now = GNUNET_TIME_absolute_get (); + delta = now.value - session->last_quota_update.value; + if ((delta < MIN_QUOTA_REFRESH_TIME) && (!force)) + return; /* too early, not enough data */ + + total_allowed = session->quota_in * delta; + if (total_allowed > session->last_received) + { + /* got less than acceptable */ + total_remaining = total_allowed - session->last_received; + session->last_received = 0; + delta = total_remaining / session->quota_in; /* bonus seconds */ + if (delta > MAX_BANDWIDTH_CARRY) + delta = MAX_BANDWIDTH_CARRY; /* limit amount of carry-over */ + } + else + { + /* got more than acceptable */ + total_remaining = 0; + session->last_received -= total_allowed; + delta = 0; + } + session->last_quota_update.value = now.value - delta; +} + + +/** + * Set a quota for receiving data from the given peer; this is a + * per-transport limit. The transport should limit its read/select + * calls to stay below the quota (in terms of incoming data). + * + * @param cls closure + * @param peer the peer for whom the quota is given + * @param quota_in quota for receiving/sending data in bytes per ms + */ +static void +tcp_plugin_set_receive_quota (void *cls, + const struct GNUNET_PeerIdentity *target, + uint32_t quota_in) +{ + struct Plugin *plugin = cls; + struct Session *session; + + session = find_session_by_target (plugin, target); + if (session->quota_in != quota_in) + { + update_quota (session, GNUNET_YES); + if (session->quota_in > quota_in) + session->last_quota_update = GNUNET_TIME_absolute_get (); + session->quota_in = quota_in; + } +} + + +/** + * Check if the given port is plausible (must be either + * our listen port or our advertised port). If it is + * neither, we return one of these two ports at random. + * + * @return either in_port or a more plausible port + */ +static uint16_t +check_port (struct Plugin *plugin, uint16_t in_port) +{ + if ((in_port == plugin->adv_port) || (in_port == plugin->open_port)) + return in_port; + return (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + 2) == 0) + ? plugin->open_port : plugin->adv_port; +} + + +/** + * 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. + * + * @param cls closure + * @param addr pointer to the address + * @param addrlen length of addr + * @return GNUNET_OK if this is a plausible address for this peer + * and transport + */ +static int +tcp_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) +{ + struct Plugin *plugin = cls; + char buf[sizeof (struct sockaddr_in6)]; + struct sockaddr_in *v4; + struct sockaddr_in6 *v6; + char dst[INET6_ADDRSTRLEN]; + uint16_t port; + + if ((addrlen != sizeof (struct sockaddr_in)) && + (addrlen != sizeof (struct sockaddr_in6))) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + memcpy (buf, addr, sizeof (struct sockaddr_in6)); + if (addrlen == sizeof (struct sockaddr_in)) + { + v4 = (struct sockaddr_in *) buf; + v4->sin_port = htons (check_port (plugin, ntohs (v4->sin_port))); + inet_ntop (AF_INET, &v4->sin_addr, dst, sizeof (dst)); + port = ntohs (v4->sin_port); + } + else + { + v6 = (struct sockaddr_in6 *) buf; + v6->sin6_port = htons (check_port (plugin, ntohs (v6->sin6_port))); + inet_ntop (AF_INET6, &v6->sin6_addr, dst, sizeof (dst)); + port = ntohs (v6->sin6_port); + } +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Informing transport service about my address `%s:%u'.\n", + dst, port); +#endif + plugin->env->notify_address (plugin->env->cls, + "tcp", + buf, addrlen, LEARNED_ADDRESS_EXPIRATION); + return GNUNET_OK; +} + + +/** + * We've received a welcome from this peer via TCP. + * Possibly create a fresh client record and send back + * our welcome. + * + * @param cls closure + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_tcp_welcome (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + struct Plugin *plugin = cls; + struct Session *session_c; + const struct WelcomeMessage *wm; + uint16_t msize; + uint32_t addrlen; + size_t alen; + void *vaddr; + const struct sockaddr *addr; + +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Received `%s' message from %p.\n", "WELCOME", client); +#endif + msize = ntohs (message->size); + if (msize < sizeof (struct WelcomeMessage)) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + wm = (const struct WelcomeMessage *) message; + session_c = find_session_by_client (plugin, client); + if (session_c == NULL) + { + vaddr = NULL; + GNUNET_SERVER_client_get_address (client, &vaddr, &alen); + GNUNET_SERVER_client_keep (client); + session_c = create_session (plugin, + &wm->clientIdentity, client, vaddr, alen); +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Creating new session %p for incoming `%s' message.\n", + session_c, "WELCOME"); +#endif + GNUNET_free_non_null (vaddr); + process_pending_messages (session_c); + } + session_c->expecting_welcome = GNUNET_NO; + if (0 < (addrlen = msize - sizeof (struct WelcomeMessage))) + { + addr = (const struct sockaddr *) &wm[1]; + tcp_plugin_address_suggested (plugin, addr, addrlen); + } + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} + + +/** + * Calculate how long we should delay reading from the TCP socket to + * ensure that we stay within our bandwidth limits (push back). + * + * @param session for which client should this be calculated + */ +static struct GNUNET_TIME_Relative +calculate_throttle_delay (struct Session *session) +{ + struct GNUNET_TIME_Relative ret; + struct GNUNET_TIME_Absolute now; + uint64_t del; + uint64_t avail; + uint64_t excess; + + now = GNUNET_TIME_absolute_get (); + del = now.value - session->last_quota_update.value; + if (del > MAX_BANDWIDTH_CARRY) + { + update_quota (session, GNUNET_YES); + del = now.value - session->last_quota_update.value; + GNUNET_assert (del <= MAX_BANDWIDTH_CARRY); + } + if (session->quota_in == 0) + session->quota_in = 1; /* avoid divison by zero */ + avail = del * session->quota_in; + if (avail > session->last_received) + return GNUNET_TIME_UNIT_ZERO; /* can receive right now */ + excess = session->last_received - avail; + ret.value = excess / session->quota_in; + return ret; +} + + +/** + * Task to signal the server that we can continue + * receiving from the TCP client now. + */ +static void +delayed_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct Session *session = cls; + GNUNET_SERVER_receive_done (session->client, GNUNET_OK); +} + + +/** + * We've received data for this peer via TCP. Unbox, + * compute latency and forward. + * + * @param cls closure + * @param server the server handling the message + * @param client identification of the client + * @param message the actual message + */ +static void +handle_tcp_data (void *cls, + struct GNUNET_SERVER_Handle *server, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ + struct Plugin *plugin = cls; + struct Session *session; + const struct DataMessage *dm; + uint16_t msize; + const struct GNUNET_MessageHeader *msg; + struct GNUNET_TIME_Relative latency; + struct GNUNET_TIME_Absolute ttime; + struct GNUNET_TIME_Absolute now; + struct GNUNET_TIME_Relative delay; + uint64_t ack_in; + +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Receiving data from other peer.\n"); +#endif + msize = ntohs (message->size); + if ((msize < + sizeof (struct DataMessage) + sizeof (struct GNUNET_MessageHeader))) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + session = find_session_by_client (plugin, client); + if ((NULL == session) || (GNUNET_YES == session->expecting_welcome)) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + dm = (const struct DataMessage *) message; + session->max_in_msg_counter = GNUNET_MAX (session->max_in_msg_counter, + GNUNET_ntohll (dm->ack_out)); + msg = (const struct GNUNET_MessageHeader *) &dm[1]; + if (msize != sizeof (struct DataMessage) + ntohs (msg->size)) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + /* estimate latency */ + ack_in = GNUNET_ntohll (dm->ack_in); + if ((ack_in <= session->out_msg_counter) && + (session->out_msg_counter - ack_in < ACK_LOG_SIZE)) + { + delay = GNUNET_TIME_relative_ntoh (dm->delay); + ttime = session->gen_time[ack_in % ACK_LOG_SIZE]; + now = GNUNET_TIME_absolute_get (); + if (delay.value > now.value - ttime.value) + delay.value = 0; /* not plausible */ + /* update (round-trip) latency using ageing; we + use 7:1 so that we can reasonably quickly react + to changes, but not so fast that latency is largely + jitter... */ + session->latency_estimate + = ((7 * session->latency_estimate) + + (now.value - ttime.value - delay.value)) / 8; + } + latency.value = (uint64_t) session->latency_estimate; + /* deliver on */ +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Forwarding data of type %u to transport service.\n", + ntohs (msg->type)); +#endif + session->service_context + = plugin->env->receive (plugin->env->cls, + session, + session->service_context, + latency, &session->target, msg); + /* update bandwidth used */ + session->last_received += msize; + update_quota (session, GNUNET_NO); + + delay = calculate_throttle_delay (session); + if (delay.value == 0) + GNUNET_SERVER_receive_done (client, GNUNET_OK); + else + GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_HIGH, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + delay, &delayed_done, session); +} + + +/** + * Handlers for the various TCP messages. + */ +static struct GNUNET_SERVER_MessageHandler my_handlers[] = { + {&handle_tcp_welcome, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME, 0}, + {&handle_tcp_data, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_DATA, 0}, + {NULL, NULL, 0, 0} +}; + + +static void +create_tcp_handlers (struct Plugin *plugin) +{ + unsigned int i; + plugin->handlers = GNUNET_malloc (sizeof (my_handlers)); + memcpy (plugin->handlers, my_handlers, sizeof (my_handlers)); + for (i = 0; + i < + sizeof (my_handlers) / sizeof (struct GNUNET_SERVER_MessageHandler); + i++) + plugin->handlers[i].callback_cls = plugin; + GNUNET_SERVER_add_handlers (plugin->server, plugin->handlers); +} + + +/** + * Functions with this signature are called whenever a peer + * is disconnected on the network level. + * + * @param cls closure + * @param client identification of the client + */ +static void +disconnect_notify (void *cls, struct GNUNET_SERVER_Client *client) +{ + struct Plugin *plugin = cls; + struct Session *session; + +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", + "Notified about network-level disconnect of client %p.\n", + client); +#endif + session = find_session_by_client (plugin, client); + if (session == NULL) + return; /* unknown, nothing to do */ +#if DEBUG_TCP + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "tcp", "Will now destroy session %p.\n", session); +#endif + disconnect_session (session); +} + + +/** + * Add the IP of our network interface to the list of + * our external IP addresses. + */ +static int +process_interfaces (void *cls, + const char *name, + int isDefault, + const struct sockaddr *addr, socklen_t addrlen) +{ + struct Plugin *plugin = cls; + char dst[INET6_ADDRSTRLEN]; + int af; + struct sockaddr_in *v4; + struct sockaddr_in6 *v6; + + af = addr->sa_family; + if (af == AF_INET) + { + v4 = (struct sockaddr_in *) addr; + inet_ntop (AF_INET, &v4->sin_addr, dst, sizeof (dst)); + v4->sin_port = htons (plugin->adv_port); + } + else + { + GNUNET_assert (af == AF_INET6); + v6 = (struct sockaddr_in6 *) addr; + inet_ntop (AF_INET6, &v6->sin6_addr, dst, sizeof (dst)); + v6->sin6_port = htons (plugin->adv_port); + } + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | + GNUNET_ERROR_TYPE_BULK, + "tcp", _("Found address `%s' (%s)\n"), dst, name); + plugin->env->notify_address (plugin->env->cls, + "tcp", + addr, addrlen, GNUNET_TIME_UNIT_FOREVER_REL); + return GNUNET_OK; +} + + +/** + * Function called by the resolver for each address obtained from DNS + * for our own hostname. Add the addresses to the list of our + * external IP addresses. + * + * @param cls closure + * @param addr one of the addresses of the host, NULL for the last address + * @param addrlen length of the address + */ +static void +process_hostname_ips (void *cls, + const struct sockaddr *addr, socklen_t addrlen) +{ + struct Plugin *plugin = cls; + + if (addr == NULL) + return; + plugin->env->notify_address (plugin->env->cls, + "tcp", + addr, addrlen, GNUNET_TIME_UNIT_FOREVER_REL); +} + + +/** + * Entry point for the plugin. + */ +void * +libgnunet_plugin_transport_tcp_init (void *cls) +{ + struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; + struct GNUNET_TRANSPORT_PluginFunctions *api; + struct Plugin *plugin; + struct GNUNET_SERVICE_Context *service; + unsigned long long aport; + unsigned long long bport; + + service = GNUNET_SERVICE_start ("tcp", env->sched, env->cfg); + if (service == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, + "tcp", + _ + ("Failed to start service for `%s' transport plugin.\n"), + "tcp"); + return NULL; + } + aport = 0; + if ((GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (env->cfg, + "tcp", + "PORT", + &bport)) || + (bport > 65535) || + ((GNUNET_OK == + GNUNET_CONFIGURATION_get_value_number (env->cfg, + "tcp", + "ADVERTISED-PORT", + &aport)) && (aport > 65535))) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "tcp", + _ + ("Require valid port number for service `%s' in configuration!\n"), + "tcp"); + GNUNET_SERVICE_stop (service); + return NULL; + } + if (aport == 0) + aport = bport; + plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin->open_port = bport; + plugin->adv_port = aport; + plugin->env = env; + plugin->lsock = NULL; + plugin->statistics = NULL; + api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); + api->cls = plugin; + api->send_to = &tcp_plugin_send_to; + api->send = &tcp_plugin_send; + api->cancel = &tcp_plugin_cancel; + api->address_pretty_printer = &tcp_plugin_address_pretty_printer; + api->set_receive_quota = &tcp_plugin_set_receive_quota; + api->address_suggested = &tcp_plugin_address_suggested; + api->cost_estimate = 42; /* TODO: ATS */ + plugin->service = service; + plugin->server = GNUNET_SERVICE_get_server (service); + create_tcp_handlers (plugin); + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, + "tcp", _("TCP transport listening on port %u\n"), bport); + if (aport != bport) + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, + "tcp", + _ + ("TCP transport advertises itself as being on port %u\n"), + aport); + GNUNET_SERVER_disconnect_notify (plugin->server, &disconnect_notify, + plugin); + GNUNET_OS_network_interfaces_list (&process_interfaces, plugin); + GNUNET_RESOLVER_hostname_resolve (env->sched, + env->cfg, + AF_UNSPEC, + HOSTNAME_RESOLVE_TIMEOUT, + &process_hostname_ips, plugin); + return api; +} + + +/** + * Exit point from the plugin. + */ +void * +libgnunet_plugin_transport_tcp_done (void *cls) +{ + struct GNUNET_TRANSPORT_PluginFunctions *api = cls; + struct Plugin *plugin = api->cls; + + GNUNET_SERVICE_stop (plugin->service); + GNUNET_free (plugin->handlers); + GNUNET_free (plugin); + GNUNET_free (api); + return NULL; +} + +/* end of plugin_transport_tcp.c */ diff --git a/src/transport/plugin_transport_template.c b/src/transport/plugin_transport_template.c new file mode 100644 index 000000000..1c8b06c61 --- /dev/null +++ b/src/transport/plugin_transport_template.c @@ -0,0 +1,335 @@ +/* + This file is part of GNUnet + (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/plugin_transport_template.c + * @brief template for a new transport service + * @author Christian Grothoff + */ + +#include "platform.h" +#include "gnunet_protocols.h" +#include "gnunet_network_lib.h" +#include "gnunet_server_lib.h" +#include "gnunet_service_lib.h" +#include "gnunet_statistics_service.h" +#include "gnunet_transport_service.h" +#include "plugin_transport.h" + +#define DEBUG_TEMPLATE GNUNET_NO + +/** + * After how long do we expire an address that we + * learned from another peer if it is not reconfirmed + * by anyone? + */ +#define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6) + + +/** + * Encapsulation of all of the state of the plugin. + */ +struct Plugin; + + +/** + * Session handle for connections. + */ +struct Session +{ + + /** + * Stored in a linked list. + */ + struct Session *next; + + /** + * Pointer to the global plugin struct. + */ + struct Plugin *plugin; + + /** + * The client (used to identify this connection) + */ + /* void *client; */ + + /** + * Continuation function to call once the transmission buffer + * has again space available. NULL if there is no + * continuation to call. + */ + GNUNET_TRANSPORT_TransmitContinuation transmit_cont; + + /** + * Closure for transmit_cont. + */ + void *transmit_cont_cls; + + /** + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) + */ + struct GNUNET_PeerIdentity sender; + + /** + * At what time did we reset last_received last? + */ + struct GNUNET_TIME_Absolute last_quota_update; + + /** + * How many bytes have we received since the "last_quota_update" + * timestamp? + */ + uint64_t last_received; + + /** + * Number of bytes per ms that this peer is allowed + * to send to us. + */ + uint32_t quota; + +}; + +/** + * Encapsulation of all of the state of the plugin. + */ +struct Plugin +{ + /** + * Our environment. + */ + struct GNUNET_TRANSPORT_PluginEnvironment *env; + + /** + * List of open sessions. + */ + struct Session *sessions; + + /** + * Handle for the statistics service. + */ + struct GNUNET_STATISTICS_Handle *statistics; + +}; + + + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin using a fresh connection (even if + * we already have a connection to this peer, this function is + * required to establish a new one). + * + * @param cls closure + * @param target who should receive this message + * @param msg1 first message to transmit + * @param msg2 second message to transmit (can be NULL) + * @param timeout how long until we give up? + * @param addr the address + * @param addrlen length of the address + * @return non-null session if the transmission has been scheduled + * NULL if the address format is invalid + */ +static void * +template_plugin_send_to (void *cls, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg1, + const struct GNUNET_MessageHeader *msg2, + struct GNUNET_TIME_Relative timeout, + const void *addr, size_t addrlen) +{ + // FIXME + return NULL; +} + + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin. + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL + * @param service_context value passed to the transport-service + * to identify the neighbour + * @param target who should receive this message + * @param msg the message to transmit + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...) + * @param cont_cls closure for cont + * @return plugin_context that should be used next time for + * sending messages to the specified peer + */ +static void * +template_plugin_send (void *cls, + void *plugin_context, + struct ReadyList *service_context, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_TransmitContinuation cont, + void *cont_cls) +{ + // struct Plugin *plugin = cls; + return NULL; +} + + + +/** + * + * @param cls closure + * @param plugin_context value we were asked to pass to this plugin + * to respond to the given peer (use is optional, + * but may speed up processing), can be NULL (if + * NULL was returned from the transmit function) + * @param service_context must correspond to the service context + * of the corresponding Transmit call; the plugin should + * not cancel a send call made with a different service + * context pointer! Never NULL. + * @param target peer for which the last transmission is + * to be cancelled + */ +static void +template_plugin_cancel (void *cls, + void *plugin_context, + struct ReadyList *service_context, + const struct GNUNET_PeerIdentity *target) +{ + // struct Plugin *plugin = cls; + // FIXME +} + + +/** + * Convert the transports address to a nice, human-readable + * format. + * + * @param cls closure + * @param name name of the transport that generated the address + * @param addr one of the addresses of the host, NULL for the last address + * the specific address format depends on the transport + * @param addrlen length of the address + * @param numeric should (IP) addresses be displayed in numeric form? + * @param timeout after how long should we give up? + * @param asc function to call on each string + * @param asc_cls closure for asc + */ +static void +template_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) +{ + asc (asc_cls, NULL); +} + +/** + * Set a quota for receiving data from the given peer; this is a + * per-transport limit. The transport should limit its read/select + * calls to stay below the quota (in terms of incoming data). + * + * @param cls closure + * @param peer the peer for whom the quota is given + * @param quota_in quota for receiving/sending data in bytes per ms + */ +static void +template_plugin_set_receive_quota (void *cls, + const struct GNUNET_PeerIdentity *target, + uint32_t quota_in) +{ + // struct Plugin *plugin = cls; + // FIXME! +} + + +/** + * 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. + * + * @param cls closure + * @param addr pointer to the address + * @param addrlen length of addr + * @return GNUNET_OK if this is a plausible address for this peer + * and transport + */ +static int +template_plugin_address_suggested (void *cls, + const void *addr, size_t addrlen) +{ + // struct Plugin *plugin = cls; + + /* check if the address is plausible; if so, + add it to our list! */ + // FIXME! + return GNUNET_OK; +} + + +/** + * Entry point for the plugin. + */ +void * +gnunet_plugin_transport_template_init (void *cls) +{ + struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; + struct GNUNET_TRANSPORT_PluginFunctions *api; + struct Plugin *plugin; + + plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin->env = env; + plugin->statistics = NULL; + api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); + api->cls = plugin; + api->send_to = &template_plugin_send_to; + api->send = &template_plugin_send; + api->cancel = &template_plugin_cancel; + api->address_pretty_printer = &template_plugin_address_pretty_printer; + api->set_receive_quota = &template_plugin_set_receive_quota; + api->address_suggested = &template_plugin_address_suggested; + api->cost_estimate = 42; // FIXME + return api; +} + + +/** + * Exit point from the plugin. + */ +void * +gnunet_plugin_transport_template_done (void *cls) +{ + struct GNUNET_TRANSPORT_PluginFunctions *api = cls; + struct Plugin *plugin = api->cls; + + GNUNET_free (plugin); + GNUNET_free (api); + return NULL; +} + +/* end of plugin_transport_template.c */ diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c new file mode 100644 index 000000000..ccaf9fbd1 --- /dev/null +++ b/src/transport/plugin_transport_udp.c @@ -0,0 +1,592 @@ +/* + This file is part of GNUnet + (C) 2001, 2002, 2003, 2004, 2005, 2008 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transports/udp.c + * @brief Implementation of the UDP transport service + * @author Christian Grothoff + */ + +#include "platform.h" +#include "gnunet_util.h" +#include "gnunet_protocols.h" +#include "gnunet_transport.h" +#include "gnunet_stats_service.h" +#include "gnunet_upnp_service.h" +#include "ip.h" + +#define DEBUG_UDP GNUNET_YES + +/** + * The default maximum size of each outbound UDP message, + * optimal value for Ethernet (10 or 100 MBit). + */ +#define MESSAGE_SIZE 1472 + +/** + * Message-Packet header. + */ +typedef struct +{ + /** + * size of the message, in bytes, including this header. + */ + GNUNET_MessageHeader header; + + /** + * What is the identity of the sender (GNUNET_hash of public key) + */ + GNUNET_PeerIdentity sender; + +} UDPMessage; + +#define MY_TRANSPORT_NAME "UDP" +#include "common.c" + +/* *********** globals ************* */ + +static int stat_bytesReceived; + +static int stat_bytesSent; + +static int stat_bytesDropped; + +static int stat_udpConnected; + +/** + * thread that listens for inbound messages + */ +static struct GNUNET_SelectHandle *selector; + +/** + * the socket that we transmit all data with + */ +static struct GNUNET_SocketHandle *udp_sock; + +static struct GNUNET_LoadMonitor *load_monitor; + + +/** + * The socket of session has data waiting, process! + * + * This function may only be called if the tcplock is + * already held by the caller. + */ +static int +select_message_handler (void *mh_cls, + struct GNUNET_SelectHandle *sh, + struct GNUNET_SocketHandle *sock, + void *sock_ctx, const GNUNET_MessageHeader * msg) +{ + unsigned int len; + GNUNET_TransportPacket *mp; + const UDPMessage *um; + + len = ntohs (msg->size); + if (len <= sizeof (UDPMessage)) + { + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_WARNING | GNUNET_GE_USER | GNUNET_GE_BULK, + _("Received malformed message via %s. Ignored.\n"), + "UDP"); + return GNUNET_SYSERR; + } + um = (const UDPMessage *) msg; + mp = GNUNET_malloc (sizeof (GNUNET_TransportPacket)); + mp->msg = GNUNET_malloc (len - sizeof (UDPMessage)); + memcpy (mp->msg, &um[1], len - sizeof (UDPMessage)); + mp->sender = um->sender; + mp->size = len - sizeof (UDPMessage); + mp->tsession = NULL; + coreAPI->receive (mp); + if (stats != NULL) + stats->change (stat_bytesReceived, len); + return GNUNET_OK; +} + +static void * +select_accept_handler (void *ah_cls, + struct GNUNET_SelectHandle *sh, + struct GNUNET_SocketHandle *sock, + const void *addr, unsigned int addr_len) +{ + static int nonnullpointer; + + if (GNUNET_NO != is_rejected_tester (addr, addr_len)) + return NULL; + return &nonnullpointer; +} + +/** + * Select has been forced to close a connection. + * Free the associated context. + */ +static void +select_close_handler (void *ch_cls, + struct GNUNET_SelectHandle *sh, + struct GNUNET_SocketHandle *sock, void *sock_ctx) +{ + /* do nothing */ +} + +/** + * Establish a connection to a remote node. + * + * @param hello the hello-Message for the target node + * @param tsessionPtr the session handle that is to be set + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +udp_connect (const GNUNET_MessageHello * hello, + GNUNET_TSession ** tsessionPtr, int may_reuse) +{ + GNUNET_TSession *tsession; + + tsession = GNUNET_malloc (sizeof (GNUNET_TSession)); + memset (tsession, 0, sizeof (GNUNET_TSession)); + tsession->internal = GNUNET_malloc (GNUNET_sizeof_hello (hello)); + memcpy (tsession->internal, hello, GNUNET_sizeof_hello (hello)); + tsession->ttype = myAPI.protocol_number; + tsession->peer = hello->senderIdentity; + *tsessionPtr = tsession; + if (stats != NULL) + stats->change (stat_udpConnected, 1); + return GNUNET_OK; +} + +/** + * A (core) Session is to be associated with a transport session. The + * transport service may want to know in order to call back on the + * core if the connection is being closed. + * + * @param tsession the session handle passed along + * from the call to receive that was made by the transport + * layer + * @return GNUNET_OK if the session could be associated, + * GNUNET_SYSERR if not. + */ +int +udp_associate (GNUNET_TSession * tsession) +{ + return GNUNET_SYSERR; /* UDP connections can never be associated */ +} + +/** + * Disconnect from a remote node. + * + * @param tsession the session that is closed + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +udp_disconnect (GNUNET_TSession * tsession) +{ + if (tsession != NULL) + { + if (tsession->internal != NULL) + GNUNET_free (tsession->internal); + GNUNET_free (tsession); + if (stats != NULL) + stats->change (stat_udpConnected, -1); + } + return GNUNET_OK; +} + +/** + * Shutdown the server process (stop receiving inbound traffic). Maybe + * restarted later! + */ +static int +udp_transport_server_stop () +{ + GNUNET_GE_ASSERT (coreAPI->ectx, udp_sock != NULL); + if (selector != NULL) + { + GNUNET_select_destroy (selector); + selector = NULL; + } + GNUNET_socket_destroy (udp_sock); + udp_sock = NULL; + return GNUNET_OK; +} + +/** + * Test if the transport would even try to send + * a message of the given size and importance + * for the given session.
+ * This function is used to check if the core should + * even bother to construct (and encrypt) this kind + * of message. + * + * @return GNUNET_YES if the transport would try (i.e. queue + * the message or call the OS to send), + * GNUNET_NO if the transport would just drop the message, + * GNUNET_SYSERR if the size/session is invalid + */ +static int +udp_test_would_try (GNUNET_TSession * tsession, unsigned int size, + int important) +{ + const GNUNET_MessageHello *hello; + + if (udp_sock == NULL) + return GNUNET_SYSERR; + if (size == 0) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + if (size > myAPI.mtu) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + hello = (const GNUNET_MessageHello *) tsession->internal; + if (hello == NULL) + return GNUNET_SYSERR; + return GNUNET_YES; +} + +/** + * Create a UDP socket. If possible, use IPv6, otherwise + * try IPv4. Update available_protocols accordingly. + */ +static int +udp_create_socket () +{ + int s; + + available_protocols = VERSION_AVAILABLE_NONE; + s = -1; + if (GNUNET_YES != + GNUNET_GC_get_configuration_value_yesno (cfg, "GNUNETD", "DISABLE-IPV6", + GNUNET_YES)) + { +#ifndef MINGW + s = SOCKET (PF_INET6, SOCK_DGRAM, 17); +#else + s = win_ols_socket (PF_INET6, SOCK_DGRAM, 17); +#endif + } + if (s < 0) + { +#ifndef MINGW + s = SOCKET (PF_INET, SOCK_DGRAM, 17); +#else + s = win_ols_socket (PF_INET, SOCK_DGRAM, 17); +#endif + if (s < 0) + { + GNUNET_GE_LOG_STRERROR (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | + GNUNET_GE_BULK, "socket"); + return GNUNET_SYSERR; + } + available_protocols = VERSION_AVAILABLE_IPV4; + } + else + { + available_protocols = VERSION_AVAILABLE_IPV6 | VERSION_AVAILABLE_IPV4; + } + return s; +} + +/** + * Send a message to the specified remote node. + * + * @param tsession the GNUNET_MessageHello identifying the remote node + * @param message what to send + * @param size the size of the message + * @return GNUNET_SYSERR on error, GNUNET_OK on success + */ +static int +udp_send (GNUNET_TSession * tsession, + const void *message, const unsigned int size, int important) +{ + const GNUNET_MessageHello *hello; + const HostAddress *haddr; + UDPMessage *mp; + struct sockaddr_in serverAddrv4; + struct sockaddr_in6 serverAddrv6; + struct sockaddr *serverAddr; + socklen_t addrlen; + unsigned short available; + int ok; + int ssize; + size_t sent; + + GNUNET_GE_ASSERT (NULL, tsession != NULL); + if (udp_sock == NULL) + return GNUNET_SYSERR; + if (size == 0) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + if (size > myAPI.mtu) + { + GNUNET_GE_BREAK (coreAPI->ectx, 0); + return GNUNET_SYSERR; + } + hello = (const GNUNET_MessageHello *) tsession->internal; + if (hello == NULL) + return GNUNET_SYSERR; + + haddr = (const HostAddress *) &hello[1]; + available = ntohs (haddr->availability) & available_protocols; + if (available == VERSION_AVAILABLE_NONE) + return GNUNET_SYSERR; + if (available == (VERSION_AVAILABLE_IPV4 | VERSION_AVAILABLE_IPV6)) + { + if (GNUNET_random_u32 (GNUNET_RANDOM_QUALITY_WEAK, 2) == 0) + available = VERSION_AVAILABLE_IPV4; + else + available = VERSION_AVAILABLE_IPV6; + } + ssize = size + sizeof (UDPMessage); + mp = GNUNET_malloc (ssize); + mp->header.size = htons (ssize); + mp->header.type = 0; + mp->sender = *(coreAPI->my_identity); + memcpy (&mp[1], message, size); + ok = GNUNET_SYSERR; + + if ((available & VERSION_AVAILABLE_IPV4) > 0) + { + memset (&serverAddrv4, 0, sizeof (serverAddrv4)); + serverAddrv4.sin_family = AF_INET; + serverAddrv4.sin_port = haddr->port; + memcpy (&serverAddrv4.sin_addr, &haddr->ipv4, sizeof (struct in_addr)); + addrlen = sizeof (serverAddrv4); + serverAddr = (struct sockaddr *) &serverAddrv4; + } + else + { + memset (&serverAddrv6, 0, sizeof (serverAddrv6)); + serverAddrv6.sin6_family = AF_INET; + serverAddrv6.sin6_port = haddr->port; + memcpy (&serverAddrv6.sin6_addr, &haddr->ipv6, + sizeof (struct in6_addr)); + addrlen = sizeof (serverAddrv6); + serverAddr = (struct sockaddr *) &serverAddrv6; + } +#ifndef MINGW + if (GNUNET_YES == GNUNET_socket_send_to (udp_sock, + GNUNET_NC_NONBLOCKING, + mp, + ssize, &sent, + (const char *) serverAddr, + addrlen)) +#else + sent = + win_ols_sendto (udp_sock, mp, ssize, (const char *) serverAddr, addrlen); + if (sent != SOCKET_ERROR) +#endif + { + ok = GNUNET_OK; + if (stats != NULL) + stats->change (stat_bytesSent, sent); + } + else + { + if (stats != NULL) + stats->change (stat_bytesDropped, ssize); + } + GNUNET_free (mp); + return ok; +} + +/** + * Start the server process to receive inbound traffic. + * + * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed + */ +static int +udp_transport_server_start () +{ + struct sockaddr_in serverAddrv4; + struct sockaddr_in6 serverAddrv6; + struct sockaddr *serverAddr; + socklen_t addrlen; + int sock; + const int on = 1; + unsigned short port; + + GNUNET_GE_ASSERT (coreAPI->ectx, selector == NULL); + /* initialize UDP network */ + port = get_port (); + if (port != 0) + { + sock = udp_create_socket (); + if (sock < 0) + return GNUNET_SYSERR; + if (SETSOCKOPT (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0) + { + GNUNET_GE_DIE_STRERROR (coreAPI->ectx, + GNUNET_GE_FATAL | GNUNET_GE_ADMIN | + GNUNET_GE_IMMEDIATE, "setsockopt"); + return GNUNET_SYSERR; + } + if (available_protocols == VERSION_AVAILABLE_IPV4) + { + memset (&serverAddrv4, 0, sizeof (serverAddrv4)); + serverAddrv4.sin_family = AF_INET; + serverAddrv4.sin_addr.s_addr = INADDR_ANY; + serverAddrv4.sin_port = htons (port); + addrlen = sizeof (serverAddrv4); + serverAddr = (struct sockaddr *) &serverAddrv4; + } + else + { + memset (&serverAddrv6, 0, sizeof (serverAddrv6)); + serverAddrv6.sin6_family = AF_INET6; + serverAddrv6.sin6_addr = in6addr_any; + serverAddrv6.sin6_port = htons (port); + addrlen = sizeof (serverAddrv6); + serverAddr = (struct sockaddr *) &serverAddrv6; + } + if (BIND (sock, serverAddr, addrlen) < 0) + { + GNUNET_GE_LOG_STRERROR (coreAPI->ectx, + GNUNET_GE_FATAL | GNUNET_GE_ADMIN | + GNUNET_GE_IMMEDIATE, "bind"); + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_FATAL | GNUNET_GE_ADMIN | + GNUNET_GE_IMMEDIATE, + _("Failed to bind to %s port %d.\n"), + MY_TRANSPORT_NAME, port); + if (0 != CLOSE (sock)) + GNUNET_GE_LOG_STRERROR (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_USER | + GNUNET_GE_ADMIN | GNUNET_GE_BULK, + "close"); + return GNUNET_SYSERR; + } + selector = GNUNET_select_create ("udp", GNUNET_YES, coreAPI->ectx, load_monitor, sock, addrlen, 0, /* timeout */ + &select_message_handler, + NULL, + &select_accept_handler, + NULL, + &select_close_handler, + NULL, 64 * 1024, + 16 /* max sockets */ ); + if (selector == NULL) + return GNUNET_SYSERR; + } + sock = udp_create_socket (); + if (sock == -1) + { + GNUNET_GE_LOG_STRERROR (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_ADMIN | + GNUNET_GE_BULK, "socket"); + GNUNET_select_destroy (selector); + selector = NULL; + return GNUNET_SYSERR; + } + udp_sock = GNUNET_socket_create (coreAPI->ectx, load_monitor, sock); + GNUNET_GE_ASSERT (coreAPI->ectx, udp_sock != NULL); + return GNUNET_OK; +} + +/** + * The exported method. Makes the core api available via a global and + * returns the udp transport API. + */ +GNUNET_TransportAPI * +inittransport_udp (GNUNET_CoreAPIForTransport * core) +{ + unsigned long long mtu; + + cfg = core->cfg; + load_monitor = core->load_monitor; + GNUNET_GE_ASSERT (coreAPI->ectx, sizeof (UDPMessage) == 68); + GNUNET_GE_ASSERT (coreAPI->ectx, sizeof (HostAddress) == 24); + coreAPI = core; + if (-1 == GNUNET_GC_get_configuration_value_number (cfg, + "UDP", + "MTU", + sizeof (UDPMessage) + + + GNUNET_P2P_MESSAGE_OVERHEAD + + + sizeof + (GNUNET_MessageHeader) + + 32, 65500, + MESSAGE_SIZE, &mtu)) + { + return NULL; + } + if (mtu < 1200) + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_USER | GNUNET_GE_IMMEDIATE, + _("MTU %llu for `%s' is probably too low!\n"), mtu, "UDP"); + lock = GNUNET_mutex_create (GNUNET_NO); + if (0 != + GNUNET_GC_attach_change_listener (cfg, &reload_configuration, NULL)) + { + GNUNET_mutex_destroy (lock); + lock = NULL; + return NULL; + } + if (GNUNET_GC_get_configuration_value_yesno (cfg, "UDP", "UPNP", GNUNET_YES) + == GNUNET_YES) + { + upnp = coreAPI->service_request ("upnp"); + if (upnp == NULL) + GNUNET_GE_LOG (coreAPI->ectx, + GNUNET_GE_ERROR | GNUNET_GE_USER | GNUNET_GE_IMMEDIATE, + "The UPnP service could not be loaded. To disable UPnP, set the " + "configuration option \"UPNP\" in section \"%s\" to \"NO\"\n", + "UDP"); + } + stats = coreAPI->service_request ("stats"); + if (stats != NULL) + { + stat_bytesReceived + = stats->create (gettext_noop ("# bytes received via UDP")); + stat_bytesSent = stats->create (gettext_noop ("# bytes sent via UDP")); + stat_bytesDropped + = stats->create (gettext_noop ("# bytes dropped by UDP (outgoing)")); + stat_udpConnected + = stats->create (gettext_noop ("# UDP connections (right now)")); + } + myAPI.protocol_number = GNUNET_TRANSPORT_PROTOCOL_NUMBER_UDP; + myAPI.mtu = mtu - sizeof (UDPMessage); + myAPI.cost = 20000; + myAPI.hello_verify = &verify_hello; + myAPI.hello_create = &create_hello; + myAPI.connect = &udp_connect; + myAPI.send = &udp_send; + myAPI.associate = &udp_associate; + myAPI.disconnect = &udp_disconnect; + myAPI.server_start = &udp_transport_server_start; + myAPI.server_stop = &udp_transport_server_stop; + myAPI.hello_to_address = &hello_to_address; + myAPI.send_now_test = &udp_test_would_try; + + return &myAPI; +} + +void +donetransport_udp () +{ + do_shutdown (); +} + +/* end of udp.c */ diff --git a/src/transport/test_transport_api.c b/src/transport/test_transport_api.c new file mode 100644 index 000000000..02c28b09c --- /dev/null +++ b/src/transport/test_transport_api.c @@ -0,0 +1,305 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ +/** + * @file transport/test_transport_api.c + * @brief testcase for transport_api.c + */ +#include "platform.h" +#include "gnunet_common.h" +#include "gnunet_hello_lib.h" +#include "gnunet_getopt_lib.h" +#include "gnunet_os_lib.h" +#include "gnunet_program_lib.h" +#include "gnunet_scheduler_lib.h" +#include "gnunet_transport_service.h" +#include "transport.h" + +#define VERBOSE GNUNET_NO + +#define START_ARM GNUNET_YES + +/** + * How long until we give up on transmitting the message? + */ +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) + +#define MTYPE 12345 + +struct PeerContext +{ + struct GNUNET_CONFIGURATION_Handle *cfg; + struct GNUNET_TRANSPORT_Handle *th; + struct GNUNET_PeerIdentity id; +#if START_ARM + pid_t arm_pid; +#endif +}; + +static struct PeerContext p1; + +static struct PeerContext p2; + +static struct GNUNET_SCHEDULER_Handle *sched; + +static int ok; + +#if VERBOSE +#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0) +#else +#define OKPP do { ok++; } while (0) +#endif + + +static void +end () +{ + /* do work here */ + GNUNET_assert (ok == 8); + GNUNET_TRANSPORT_disconnect (p1.th); + GNUNET_TRANSPORT_disconnect (p2.th); + ok = 0; +} + + +/** + * Function called by the transport for each received message. + * + * @param cls closure + * @param latency estimated latency for communicating with the + * given peer + * @param peer (claimed) identity of the other peer + * @param message the message + */ +static void +notify_receive (void *cls, + struct GNUNET_TIME_Relative latency, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) +{ + GNUNET_assert (ok == 7); + OKPP; + GNUNET_assert (MTYPE == ntohs (message->type)); + GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == + ntohs (message->size)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from peer (%p)!\n", + cls); + end (); +} + + +/** + * Function called to notify transport users that another + * peer connected to us. + * + * @param cls closure + * @param transport the transport service handle + * @param peer the peer that disconnected + * @param latency current latency of the connection + */ +static void +notify_connect (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_TIME_Relative latency) +{ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected to us (%p)!\n", cls); + GNUNET_assert ((ok >= 1) && (ok <= 6)); + OKPP; +} + + +/** + * Function called to notify transport users that another + * peer disconnected from us. + * + * @param cls closure + * @param transport the transport service handle + * @param peer the peer that disconnected + */ +static void +notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) +{ + GNUNET_assert (0); +} + + +static void +setup_peer (struct PeerContext *p, const char *cfgname) +{ + p->cfg = GNUNET_CONFIGURATION_create (); +#if START_ARM + p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm", + "gnunet-service-arm", +#if VERBOSE + "-L", "DEBUG", +#endif + "-c", cfgname, NULL); + sleep (1); /* allow ARM to start */ +#endif + GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); + p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, + p, + ¬ify_receive, + ¬ify_connect, ¬ify_disconnect); + GNUNET_assert (p->th != NULL); +} + + +static size_t +notify_ready (void *cls, size_t size, void *buf) +{ + struct GNUNET_MessageHeader *hdr; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting message to peer (%p) - %u!\n", cls, size); + GNUNET_assert (size >= 256); + GNUNET_assert ((ok >= 5) && (ok <= 6)); + OKPP; + hdr = buf; + hdr->size = htons (sizeof (struct GNUNET_MessageHeader)); + hdr->type = htons (MTYPE); + return sizeof (struct GNUNET_MessageHeader); +} + + +static void +exchange_hello_last (void *cls, + struct GNUNET_TIME_Relative latency, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) +{ + struct PeerContext *me = cls; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Exchanging HELLO with peer (%p)!\n", cls); + GNUNET_assert (ok >= 3); + OKPP; + GNUNET_assert (message != NULL); + GNUNET_assert (GNUNET_OK == + GNUNET_HELLO_get_key ((const struct GNUNET_HELLO_Message *) + message, &pk)); + GNUNET_CRYPTO_hash (&pk, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &me->id.hashPubKey); + GNUNET_TRANSPORT_offer_hello (p1.th, message); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Finished exchanging HELLOs, now waiting for transmission!\n"); + /* both HELLOs exchanged, get ready to test transmission! */ + GNUNET_TRANSPORT_notify_transmit_ready (p1.th, + &p2.id, + 256, TIMEOUT, ¬ify_ready, &p1); +} + + +static void +exchange_hello (void *cls, + struct GNUNET_TIME_Relative latency, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) +{ + struct PeerContext *me = cls; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Exchanging HELLO with peer (%p)!\n", cls); + GNUNET_assert (ok >= 2); + OKPP; + GNUNET_assert (message != NULL); + GNUNET_assert (GNUNET_OK == + GNUNET_HELLO_get_key ((const struct GNUNET_HELLO_Message *) + message, &pk)); + GNUNET_CRYPTO_hash (&pk, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &me->id.hashPubKey); + GNUNET_TRANSPORT_get_hello (p2.th, GNUNET_TIME_UNIT_MINUTES, + &exchange_hello_last, &p2); +} + + +static void +run (void *cls, + struct GNUNET_SCHEDULER_Handle *s, + char *const *args, + const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg) +{ + GNUNET_assert (ok == 1); + OKPP; + sched = s; + setup_peer (&p1, "test_transport_api_peer1.conf"); + setup_peer (&p2, "test_transport_api_peer2.conf"); + GNUNET_TRANSPORT_get_hello (p1.th, + GNUNET_TIME_UNIT_MINUTES, &exchange_hello, &p1); +} + + +static void +stop_arm (struct PeerContext *p) +{ +#if START_ARM + if (0 != PLIBC_KILL (p->arm_pid, SIGTERM)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + waitpid (p->arm_pid, NULL, 0); +#endif + GNUNET_CONFIGURATION_destroy (p->cfg); +} + + +static int +check () +{ + char *const argv[] = { "test-transport-api", + "-c", + "test_transport_api_data.conf", +#if VERBOSE + "-L", "DEBUG", +#endif + NULL + }; + struct GNUNET_GETOPT_CommandLineOption options[] = { + GNUNET_GETOPT_OPTION_END + }; + + ok = 1; + GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, + argv, "test-transport-api", "nohelp", + options, &run, &ok); + stop_arm (&p1); + stop_arm (&p2); + return ok; +} + +int +main (int argc, char *argv[]) +{ + int ret; + + GNUNET_log_setup ("test-transport-api", +#if VERBOSE + "DEBUG", +#else + "WARNING", +#endif + NULL); + ret = check (); + + return ret; +} + +/* end of test_transport_api.c */ diff --git a/src/transport/test_transport_api_data.conf b/src/transport/test_transport_api_data.conf new file mode 100644 index 000000000..0fa611350 --- /dev/null +++ b/src/transport/test_transport_api_data.conf @@ -0,0 +1,24 @@ +[PATHS] +SERVICEHOME = /tmp/test-gnunetd-transport-master/ + +[resolver] +PORT = 2364 + +[transport] +PORT = 2365 +PLUGINS = tcp + +[arm] +PORT = 2366 + +[statistics] +PORT = 2367 + +[tcp] +PORT = 2368 + +[peerinfo] +PORT = 2369 + +[testing] +WEAKRANDOM = YES diff --git a/src/transport/test_transport_api_peer1.conf b/src/transport/test_transport_api_peer1.conf new file mode 100644 index 000000000..dcc0ab4cf --- /dev/null +++ b/src/transport/test_transport_api_peer1.conf @@ -0,0 +1,25 @@ +[PATHS] +SERVICEHOME = /tmp/test-gnunetd-transport-peer-1/ +DEFAULTCONFIG = test_transport_api_peer1.conf + +[resolver] +PORT = 12364 + +[transport] +PORT = 12365 +PLUGINS = tcp + +[arm] +PORT = 12366 + +[statistics] +PORT = 12367 + +[tcp] +PORT = 12368 + +[peerinfo] +PORT = 12369 + +[testing] +WEAKRANDOM = YES diff --git a/src/transport/test_transport_api_peer2.conf b/src/transport/test_transport_api_peer2.conf new file mode 100644 index 000000000..8567c6ac8 --- /dev/null +++ b/src/transport/test_transport_api_peer2.conf @@ -0,0 +1,25 @@ +[PATHS] +SERVICEHOME = /tmp/test-gnunetd-transport-peer-2/ +DEFAULTCONFIG = test_transport_api_peer2.conf + +[resolver] +PORT = 22364 + +[transport] +PORT = 22365 +PLUGINS = tcp + +[arm] +PORT = 22366 + +[statistics] +PORT = 22367 + +[tcp] +PORT = 22368 + +[peerinfo] +PORT = 22369 + +[testing] +WEAKRANDOM = YES diff --git a/src/transport/transport.h b/src/transport/transport.h new file mode 100644 index 000000000..8e1291005 --- /dev/null +++ b/src/transport/transport.h @@ -0,0 +1,238 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/transport.h + * @brief common internal definitions for transport service + * @author Christian Grothoff + */ +#include "gnunet_crypto_lib.h" +#include "gnunet_time_lib.h" +#include "gnunet_transport_service.h" + +#define DEBUG_TRANSPORT GNUNET_NO + +/** + * For how long do we allow unused bandwidth + * from the past to carry over into the future? (in ms) + */ +#define MAX_BANDWIDTH_CARRY 5000 + +/** + * How often do we (at most) do a full quota + * recalculation? (in ms) + */ +#define MIN_QUOTA_REFRESH_TIME 2000 + +/** + * Message from the transport service to the library + * informing about neighbors. + */ +struct ConnectInfoMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT + */ + struct GNUNET_MessageHeader header; + + /** + * Current quota for outbound traffic in bytes/ms. + * (should be equal to system default) + */ + uint32_t quota_out GNUNET_PACKED; + + /** + * Latency estimate. + */ + struct GNUNET_TIME_RelativeNBO latency; + + /** + * Identity of the new neighbour. + */ + struct GNUNET_PeerIdentity id; + +}; + + +/** + * Message from the transport service to the library + * informing about disconnects. + */ +struct DisconnectInfoMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT + */ + struct GNUNET_MessageHeader header; + + /** + * Reserved, always zero. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * Who got disconnected? + */ + struct GNUNET_PeerIdentity peer; + +}; + + +/** + * Message used to set a particular bandwidth quota. Send + * TO the service to set an incoming quota, send FROM the + * service to update an outgoing quota. + */ +struct QuotaSetMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_NEIGHBOUR_INFO + */ + struct GNUNET_MessageHeader header; + + /** + * Quota in bytes per ms, 0 to drop everything; + * in network byte order. + */ + uint32_t quota_in GNUNET_PACKED; + + /** + * About which peer are we talking here? + */ + struct GNUNET_PeerIdentity peer; + +}; + + +/** + * Message used to ask the transport service to connect + * to a particular peer. + */ +struct TryConnectMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_TRY_CONNECT. + */ + struct GNUNET_MessageHeader header; + + /** + * Always zero. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * About which peer are we talking here? + */ + struct GNUNET_PeerIdentity peer; + +}; + +/** + * Message used to notify the transport API about a message + * received from the network. The actual message follows. + */ +struct InboundMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV + */ + struct GNUNET_MessageHeader header; + + /** + * Always zero. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * Latency estimate. + */ + struct GNUNET_TIME_RelativeNBO latency; + + /** + * Which peer sent the message? + */ + struct GNUNET_PeerIdentity peer; + +}; + + +/** + * Message used to notify the transport API that it can + * send another message to the transport service. + */ +struct SendOkMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK + */ + struct GNUNET_MessageHeader header; + + /** + * GNUNET_OK if the transmission succeeded, + * GNUNET_SYSERR if it failed (i.e. network disconnect); + * in either case, it is now OK for this client to + * send us another message for the given peer. + */ + uint32_t success GNUNET_PACKED; + + /** + * Which peer can send more now? + */ + struct GNUNET_PeerIdentity peer; + +}; + + +/** + * Message used to notify the transport service about a message + * to be transmitted to another peer. The actual message follows. + */ +struct OutboundMessage +{ + + /** + * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND + */ + struct GNUNET_MessageHeader header; + + /** + * Always zero. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * Which peer should receive the message? + */ + struct GNUNET_PeerIdentity peer; + +}; + + + + + + +/* end of transport.h */ diff --git a/src/transport/transport_api.c b/src/transport/transport_api.c new file mode 100644 index 000000000..d6d4e2a96 --- /dev/null +++ b/src/transport/transport_api.c @@ -0,0 +1,1863 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 2, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file transport/transport_api.c + * @brief library to access the low-level P2P IO service + * @author Christian Grothoff + * + * TODO: + * - set_quota with low bandwidth should cause peer + * disconnects (currently never does that) (MINOR) + */ +#include "platform.h" +#include "gnunet_client_lib.h" +#include "gnunet_arm_service.h" +#include "gnunet_hello_lib.h" +#include "gnunet_protocols.h" +#include "gnunet_server_lib.h" +#include "gnunet_time_lib.h" +#include "gnunet_transport_service.h" +#include "transport.h" + +/** + * After how long do we give up on transmitting a HELLO + * to the service? + */ +#define OFFER_HELLO_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) + +/** + * How long should ARM wait when starting up the + * transport service before reporting back? + */ +#define START_SERVICE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) + +/** + * How long should ARM wait when stopping the + * transport service before reporting back? + */ +#define STOP_SERVICE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) + +/** + * Entry in linked list of all of our current neighbours. + */ +struct NeighbourList +{ + + /** + * This is a linked list. + */ + struct NeighbourList *next; + + /** + * Active transmit handle, can be NULL. Used to move + * from ready to wait list on disconnect and to block + * two transmissions to the same peer from being scheduled + * at the same time. + */ + struct GNUNET_TRANSPORT_TransmitHandle *transmit_handle; + + + /** + * Identity of this neighbour. + */ + struct GNUNET_PeerIdentity id; + + /** + * At what time did we reset last_sent last? + */ + struct GNUNET_TIME_Absolute last_quota_update; + + /** + * How many bytes have we sent since the "last_quota_update" + * timestamp? + */ + uint64_t last_sent; + + /** + * Global quota for outbound traffic to the neighbour in bytes/ms. + */ + uint32_t quota_out; + + /** + * Set to GNUNET_YES if we are currently allowed to + * transmit a message to the transport service for this + * peer, GNUNET_NO otherwise. + */ + int transmit_ok; + + /** + * Set to GNUNET_YES if we have received an ACK for the + * given peer. Peers that receive our HELLO always respond + * with an ACK to let us know that we are successfully + * communicating. Note that a PING can not be used for this + * since PINGs are only send if a HELLO address requires + * confirmation (and also, PINGs are not passed to the + * transport API itself). + */ + int received_ack; + +}; + + +/** + * Linked list of requests from clients for our HELLO + * that were deferred. + */ +struct HelloWaitList +{ + + /** + * This is a linked list. + */ + struct HelloWaitList *next; + + /** + * Reference back to our transport handle. + */ + struct GNUNET_TRANSPORT_Handle *handle; + + /** + * Callback to call once we got our HELLO. + */ + GNUNET_TRANSPORT_ReceiveCallback rec; + + /** + * Closure for rec. + */ + void *rec_cls; + + /** + * When to time out (call rec with NULL). + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * Timeout task (used to trigger timeout, + * cancel if we get the HELLO in time). + */ + GNUNET_SCHEDULER_TaskIdentifier task; + + +}; + + +/** + * Opaque handle for a transmission-ready request. + */ +struct GNUNET_TRANSPORT_TransmitHandle +{ + + /** + * We keep the transmit handles that are waiting for + * a transport-level connection in a doubly linked list. + */ + struct GNUNET_TRANSPORT_TransmitHandle *next; + + /** + * We keep the transmit handles that are waiting for + * a transport-level connection in a doubly linked list. + */ + struct GNUNET_TRANSPORT_TransmitHandle *prev; + + /** + * Handle of the main transport data structure. + */ + struct GNUNET_TRANSPORT_Handle *handle; + + /** + * Neighbour for this handle, can be NULL if the service + * is not yet connected to the target. + */ + struct NeighbourList *neighbour; + + /** + * Which peer is this transmission going to be for? All + * zeros if it is control-traffic to the service. + */ + struct GNUNET_PeerIdentity target; + + /** + * Function to call when notify_size bytes are available + * for transmission. + */ + GNUNET_NETWORK_TransmitReadyNotify notify; + + /** + * Closure for notify. + */ + void *notify_cls; + + /** + * transmit_ready task Id. The task is used to introduce + * the artificial delay that may be required to maintain + * the bandwidth limits. + */ + GNUNET_SCHEDULER_TaskIdentifier notify_delay_task; + + /** + * Timeout for this request. + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * How many bytes is our notify callback waiting for? + */ + size_t notify_size; + +}; + + +/** + * Handle for the transport service (includes all of the + * state for the transport service). + */ +struct GNUNET_TRANSPORT_Handle +{ + + /** + * Closure for the callbacks. + */ + void *cls; + + /** + * Function to call for received data. + */ + GNUNET_TRANSPORT_ReceiveCallback rec; + + /** + * function to call on connect events + */ + GNUNET_TRANSPORT_NotifyConnect nc_cb; + + /** + * function to call on disconnect events + */ + GNUNET_TRANSPORT_NotifyDisconnect nd_cb; + + /** + * The current HELLO message for this peer. Updated + * whenever transports change their addresses. + */ + struct GNUNET_HELLO_Message *my_hello; + + /** + * My client connection to the transport service. + */ + struct GNUNET_CLIENT_Connection *client; + + /** + * Handle to our registration with the client for notification. + */ + struct GNUNET_NETWORK_TransmitHandle *network_handle; + + /** + * Linked list of transmit handles that are waiting for the + * transport to connect to the respective peer. When we + * receive notification that the transport connected to a + * peer, we go over this list and check if someone has already + * requested a transmission to the new peer; if so, we trigger + * the next step. + */ + struct GNUNET_TRANSPORT_TransmitHandle *connect_wait_head; + + /** + * Linked list of transmit handles that are waiting for the + * transport to be ready for transmission to the respective + * peer. When we + * receive notification that the transport disconnected from + * a peer, we go over this list and move the entry back to + * the connect_wait list. + */ + struct GNUNET_TRANSPORT_TransmitHandle *connect_ready_head; + + /** + * Linked list of pending requests for our HELLO. + */ + struct HelloWaitList *hwl_head; + + /** + * My scheduler. + */ + struct GNUNET_SCHEDULER_Handle *sched; + + /** + * My configuration. + */ + struct GNUNET_CONFIGURATION_Handle *cfg; + + /** + * Linked list of the current neighbours of this peer. + */ + struct NeighbourList *neighbours; + + /** + * ID of the task trying to reconnect to the + * service. + */ + GNUNET_SCHEDULER_TaskIdentifier reconnect_task; + + /** + * Delay until we try to reconnect. + */ + struct GNUNET_TIME_Relative reconnect_delay; + + /** + * Do we currently have a transmission pending? + * (schedule transmission was called but has not + * yet succeeded)? + */ + int transmission_scheduled; +}; + + +static struct NeighbourList * +find_neighbour (struct GNUNET_TRANSPORT_Handle *h, + const struct GNUNET_PeerIdentity *peer) +{ + struct NeighbourList *pos; + + pos = h->neighbours; + while ((pos != NULL) && + (0 != memcmp (peer, &pos->id, sizeof (struct GNUNET_PeerIdentity)))) + pos = pos->next; + return pos; +} + + +/** + * Schedule the task to send one message from the + * connect_ready list to the service. + */ +static void schedule_transmission (struct GNUNET_TRANSPORT_Handle *h); + + +/** + * Transmit message to client... + */ +static size_t +transport_notify_ready (void *cls, size_t size, void *buf) +{ + struct GNUNET_TRANSPORT_Handle *h = cls; + struct GNUNET_TRANSPORT_TransmitHandle *th; + struct NeighbourList *n; + size_t ret; + char *cbuf; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Ready to transmit %u bytes to transport service\n", size); +#endif + h->network_handle = NULL; + h->transmission_scheduled = GNUNET_NO; + if (buf == NULL) + { + th = h->connect_ready_head; + if (th->next != NULL) + th->next->prev = NULL; + h->connect_ready_head = th->next; + if (NULL != (n = th->neighbour)) + { + GNUNET_assert (n->transmit_handle == th); + n->transmit_handle = NULL; + } + GNUNET_assert (0 == th->notify (th->notify_cls, 0, NULL)); + GNUNET_free (th); + return 0; + } + cbuf = buf; + ret = 0; + h->network_handle = NULL; + h->transmission_scheduled = GNUNET_NO; + do + { + th = h->connect_ready_head; + GNUNET_assert (th->notify_size <= size); + if (th->next != NULL) + th->next->prev = NULL; + h->connect_ready_head = th->next; + if (NULL != (n = th->neighbour)) + { + GNUNET_assert (n->transmit_handle == th); + n->transmit_handle = NULL; + } + ret += th->notify (th->notify_cls, size, &cbuf[ret]); + GNUNET_free (th); + if (n != NULL) + n->last_sent += ret; + size -= ret; + } + while ((h->connect_ready_head != NULL) && + (h->connect_ready_head->notify_size <= size)); + if (h->connect_ready_head != NULL) + schedule_transmission (h); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting %u bytes to transport service\n", ret); +#endif + return ret; +} + + +/** + * Schedule the task to send one message from the + * connect_ready list to the service. + */ +static void +schedule_transmission (struct GNUNET_TRANSPORT_Handle *h) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th; + + GNUNET_assert (NULL == h->network_handle); + if (h->client == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Not yet connected to transport service, need to wait.\n"); +#endif + return; + } + th = h->connect_ready_head; + if (th == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Schedule transmission called, but no request is pending.\n"); +#endif + return; + } + h->transmission_scheduled = GNUNET_YES; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Asking client API for transmission of %u bytes\n", + th->notify_size); +#endif + h->network_handle = GNUNET_CLIENT_notify_transmit_ready (h->client, + th->notify_size, + GNUNET_TIME_absolute_get_remaining + (th->timeout), + &transport_notify_ready, + h); + GNUNET_assert (NULL != h->network_handle); +} + + +/** + * Insert the given transmit handle in the given sorted + * doubly linked list based on timeout. + * + * @param head pointer to the head of the linked list + * @param th element to insert into the list + */ +static void +insert_transmit_handle (struct GNUNET_TRANSPORT_TransmitHandle **head, + struct GNUNET_TRANSPORT_TransmitHandle *th) +{ + struct GNUNET_TRANSPORT_TransmitHandle *pos; + struct GNUNET_TRANSPORT_TransmitHandle *prev; + + pos = *head; + prev = NULL; + while ((pos != NULL) && (pos->timeout.value < th->timeout.value)) + { + prev = pos; + pos = pos->next; + } + if (prev == NULL) + { + th->next = *head; + if (th->next != NULL) + th->next->prev = th; + *head = th; + } + else + { + th->next = pos; + th->prev = prev; + prev->next = th; + if (pos != NULL) + pos->prev = th; + } +} + + +/** + * Queue control request for transmission to the transport + * service. + * + * @param size number of bytes to be transmitted + * @param at_head request must be added to the head of the queue + * (otherwise request will be appended) + * @param timeout how long this transmission can wait (at most) + * @param notify function to call to get the content + * @param notify_cls closure for notify + */ +static void +schedule_control_transmit (struct GNUNET_TRANSPORT_Handle *h, + size_t size, + int at_head, + struct GNUNET_TIME_Relative timeout, + GNUNET_NETWORK_TransmitReadyNotify notify, + void *notify_cls) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Queueing %u bytes control transmission request.\n", size); +#endif + th = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TransmitHandle)); + th->handle = h; + th->notify = notify; + th->notify_cls = notify_cls; + th->timeout = GNUNET_TIME_relative_to_absolute (timeout); + th->notify_size = size; + if (at_head) + { + th->next = h->connect_ready_head; + h->connect_ready_head = th; + if (th->next != NULL) + th->next->prev = th; + } + else + { + insert_transmit_handle (&h->connect_ready_head, th); + } + if (GNUNET_NO == h->transmission_scheduled) + schedule_transmission (h); +} + + +/** + * Update the quota values for the given neighbour now. + */ +static void +update_quota (struct NeighbourList *n) +{ + struct GNUNET_TIME_Relative delta; + uint64_t allowed; + uint64_t remaining; + + delta = GNUNET_TIME_absolute_get_duration (n->last_quota_update); + allowed = delta.value * n->quota_out; + if (n->last_sent < allowed) + { + remaining = allowed - n->last_sent; + if (n->quota_out > 0) + remaining /= n->quota_out; + else + remaining = 0; + if (remaining > MAX_BANDWIDTH_CARRY) + remaining = MAX_BANDWIDTH_CARRY; + n->last_sent = 0; + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->last_quota_update.value -= remaining; + } + else + { + n->last_sent -= allowed; + n->last_quota_update = GNUNET_TIME_absolute_get (); + } +} + + +struct SetQuotaContext +{ + struct GNUNET_TRANSPORT_Handle *handle; + + struct GNUNET_PeerIdentity target; + + GNUNET_SCHEDULER_Task cont; + + void *cont_cls; + + struct GNUNET_TIME_Absolute timeout; + + uint32_t quota_in; +}; + + +static size_t +send_set_quota (void *cls, size_t size, void *buf) +{ + struct SetQuotaContext *sqc = cls; + struct QuotaSetMessage *msg; + + if (buf == NULL) + { + GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, + GNUNET_NO, + sqc->cont, + sqc->cont_cls, + GNUNET_SCHEDULER_REASON_TIMEOUT); + GNUNET_free (sqc); + return 0; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting `%s' request with respect to `%4s'.\n", + "SET_QUOTA", GNUNET_i2s (&sqc->target)); +#endif + GNUNET_assert (size >= sizeof (struct QuotaSetMessage)); + msg = buf; + msg->header.size = htons (sizeof (struct QuotaSetMessage)); + msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA); + msg->quota_in = htonl (sqc->quota_in); + memcpy (&msg->peer, &sqc->target, sizeof (struct GNUNET_PeerIdentity)); + if (sqc->cont != NULL) + GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, + GNUNET_NO, + sqc->cont, + sqc->cont_cls, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + GNUNET_free (sqc); + return sizeof (struct QuotaSetMessage); +} + + +/** + * Set the share of incoming bandwidth for the given + * peer to the specified amount. + * + * @param handle connection to transport service + * @param target who's bandwidth quota is being changed + * @param quota_in incoming bandwidth quota in bytes per ms; 0 can + * be used to force all traffic to be discarded + * @param quota_out outgoing bandwidth quota in bytes per ms; 0 can + * be used to force all traffic to be discarded + * @param timeout how long to wait until signaling failure if + * we can not communicate the quota change + * @param cont continuation to call when done, will be called + * either with reason "TIMEOUT" or with reason "PREREQ_DONE" + * @param cont_cls closure for continuation + */ +void +GNUNET_TRANSPORT_set_quota (struct GNUNET_TRANSPORT_Handle *handle, + const struct GNUNET_PeerIdentity *target, + uint32_t quota_in, + uint32_t quota_out, + struct GNUNET_TIME_Relative timeout, + GNUNET_SCHEDULER_Task cont, void *cont_cls) +{ + struct NeighbourList *n; + struct SetQuotaContext *sqc; + + n = find_neighbour (handle, target); + if (n != NULL) + { + update_quota (n); + if (n->quota_out < quota_out) + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->quota_out = quota_out; + } + sqc = GNUNET_malloc (sizeof (struct SetQuotaContext)); + sqc->handle = handle; + sqc->target = *target; + sqc->cont = cont; + sqc->cont_cls = cont_cls; + sqc->timeout = GNUNET_TIME_relative_to_absolute (timeout); + sqc->quota_in = quota_in; + schedule_control_transmit (handle, + sizeof (struct QuotaSetMessage), + GNUNET_NO, timeout, &send_set_quota, sqc); +} + + +/** + * A "get_hello" request has timed out. Signal the client + * and clean up. + */ +static void +hello_wait_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct HelloWaitList *hwl = cls; + struct HelloWaitList *pos; + struct HelloWaitList *prev; + + prev = NULL; + pos = hwl->handle->hwl_head; + while (pos != hwl) + { + GNUNET_assert (pos != NULL); + prev = pos; + pos = pos->next; + } + if (prev == NULL) + hwl->handle->hwl_head = hwl->next; + else + prev->next = hwl->next; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Timeout trying to obtain `%s' from transport service.\n"), + "HELLO"); + /* signal timeout */ + if (hwl->rec != NULL) + hwl->rec (hwl->rec_cls, GNUNET_TIME_UNIT_ZERO, NULL, NULL); + GNUNET_free (hwl); +} + + +/** + * Obtain the HELLO message for this peer. + * + * @param handle connection to transport service + * @param timeout how long to wait for the HELLO + * @param rec function to call with the HELLO, sender will be our peer + * identity; message and sender will be NULL on timeout + * (handshake with transport service pending/failed). + * cost estimate will be 0. + * @param rec_cls closure for rec + */ +void +GNUNET_TRANSPORT_get_hello (struct GNUNET_TRANSPORT_Handle *handle, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_ReceiveCallback rec, + void *rec_cls) +{ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk; + struct GNUNET_PeerIdentity me; + struct HelloWaitList *hwl; + + if (handle->my_hello == NULL) + { + hwl = GNUNET_malloc (sizeof (struct HelloWaitList)); + hwl->next = handle->hwl_head; + handle->hwl_head = hwl; + hwl->handle = handle; + hwl->rec = rec; + hwl->rec_cls = rec_cls; + hwl->timeout = GNUNET_TIME_relative_to_absolute (timeout); + hwl->task = GNUNET_SCHEDULER_add_delayed (handle->sched, + GNUNET_YES, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + timeout, + &hello_wait_timeout, hwl); + return; + } + GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_key (handle->my_hello, &pk)); + GNUNET_CRYPTO_hash (&pk, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &me.hashPubKey); + + rec (rec_cls, + GNUNET_TIME_UNIT_ZERO, + &me, (const struct GNUNET_MessageHeader *) handle->my_hello); +} + + +static size_t +send_hello (void *cls, size_t size, void *buf) +{ + struct GNUNET_MessageHeader *hello = cls; + uint16_t msize; + + if (buf == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Timeout while trying to transmit `%s' request.\n", + "HELLO"); +#endif + GNUNET_free (hello); + return 0; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting `%s' request.\n", "HELLO"); +#endif + msize = ntohs (hello->size); + GNUNET_assert (size >= msize); + memcpy (buf, hello, msize); + GNUNET_free (hello); + return msize; +} + + +/** + * Offer the transport service the HELLO of another peer. Note that + * the transport service may just ignore this message if the HELLO is + * malformed or useless due to our local configuration. + * + * @param handle connection to transport service + * @param hello the hello message + */ +void +GNUNET_TRANSPORT_offer_hello (struct GNUNET_TRANSPORT_Handle *handle, + const struct GNUNET_MessageHeader *hello) +{ + struct GNUNET_MessageHeader *hc; + uint16_t size; + + if (handle->client == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Not connected to transport service, dropping offered HELLO\n"); +#endif + return; + } + GNUNET_break (ntohs (hello->type) == GNUNET_MESSAGE_TYPE_HELLO); + size = ntohs (hello->size); + GNUNET_break (size >= sizeof (struct GNUNET_MessageHeader)); + hc = GNUNET_malloc (size); + memcpy (hc, hello, size); + schedule_control_transmit (handle, + size, + GNUNET_NO, OFFER_HELLO_TIMEOUT, &send_hello, hc); +} + + +/** + * Function we use for handling incoming messages. + */ +static void demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg); + + +static size_t +send_start (void *cls, size_t size, void *buf) +{ + struct GNUNET_MessageHeader *s = buf; + + if (buf == NULL) + return 0; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting `%s' request.\n", "START"); +#endif + GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader)); + s->size = htons (sizeof (struct GNUNET_MessageHeader)); + s->type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_START); + return sizeof (struct GNUNET_MessageHeader); +} + + +/** + * Try again to connect to transport service. + */ +static void +reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_TRANSPORT_Handle *h = cls; + struct GNUNET_TRANSPORT_TransmitHandle *pos; + struct NeighbourList *n; + + while (NULL != (n = h->neighbours)) + { + h->neighbours = n->next; + pos = n->transmit_handle; + if (pos != NULL) + { + pos->neighbour = NULL; + pos->next = h->connect_wait_head; + h->connect_wait_head = pos; + if (pos->next != NULL) + pos->next->prev = pos; + pos->prev = NULL; + } + GNUNET_free (n); + } + h->connect_ready_head = NULL; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n"); +#endif + GNUNET_assert (h->client == NULL); + h->reconnect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + h->client = GNUNET_CLIENT_connect (h->sched, "transport", h->cfg); + GNUNET_assert (h->client != NULL); + /* make sure we don't send "START" twice, + remove existing entry from queue (if present) */ + pos = h->connect_ready_head; + while (pos != NULL) + { + if (pos->notify == &send_start) + { + if (pos->prev == NULL) + h->connect_ready_head = pos->next; + else + pos->prev->next = pos->next; + if (pos->next != NULL) + pos->next->prev = pos->prev; + GNUNET_assert (pos->neighbour == NULL); + GNUNET_free (pos); + break; + } + pos = pos->next; + } + schedule_control_transmit (h, + sizeof (struct GNUNET_MessageHeader), + GNUNET_YES, + GNUNET_TIME_UNIT_FOREVER_REL, &send_start, NULL); + GNUNET_CLIENT_receive (h->client, + &demultiplexer, h, GNUNET_TIME_UNIT_FOREVER_REL); +} + + +/** + * Function that will schedule the job that will try + * to connect us again to the client. + */ +static void +schedule_reconnect (struct GNUNET_TRANSPORT_Handle *h) +{ +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Scheduling task to reconnect to transport service in %llu ms.\n", + h->reconnect_delay.value); +#endif + GNUNET_assert (h->client == NULL); + GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK); + h->reconnect_task + = GNUNET_SCHEDULER_add_delayed (h->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + h->reconnect_delay, &reconnect, h); + h->reconnect_delay = GNUNET_TIME_UNIT_SECONDS; +} + + +/** + * Remove the given transmit handle from the wait list. Does NOT free + * it. + */ +static void +remove_from_wait_list (struct GNUNET_TRANSPORT_TransmitHandle *th) +{ + if (th->prev == NULL) + th->handle->connect_wait_head = th->next; + else + th->prev->next = th->next; + if (th->next != NULL) + th->next->prev = th->prev; +} + + +/** + * We are connected to the respective peer, check the + * bandwidth limits and schedule the transmission. + */ +static void schedule_request (struct GNUNET_TRANSPORT_TransmitHandle *th); + + +/** + * Function called by the scheduler when the timeout + * for bandwidth availablility for the target + * neighbour is reached. + */ +static void +transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th = cls; + + th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + schedule_request (th); +} + + +/** + * Called when our transmit request timed out before any transport + * reported success connecting to the desired peer or before the + * transport was ready to receive. Signal error and free + * TransmitHandle. + */ +static void +transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th = cls; + + if (th->neighbour != NULL) + th->neighbour->transmit_handle = NULL; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmission request timed out.\n"); +#endif + th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + remove_from_wait_list (th); + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); +} + + +/** + * We are connected to the respective peer, check the + * bandwidth limits and schedule the transmission. + */ +static void +schedule_request (struct GNUNET_TRANSPORT_TransmitHandle *th) +{ + struct GNUNET_TRANSPORT_Handle *h; + struct GNUNET_TIME_Relative duration; + struct NeighbourList *n; + uint64_t available; + + h = th->handle; + n = th->neighbour; + if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + { + GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task); + th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + } + /* check outgoing quota */ + duration = GNUNET_TIME_absolute_get_duration (n->last_quota_update); + if (duration.value > MIN_QUOTA_REFRESH_TIME) + { + update_quota (n); + duration = GNUNET_TIME_absolute_get_duration (n->last_quota_update); + } + available = duration.value * n->quota_out; + if (available < n->last_sent + th->notify_size) + { + /* calculate how much bandwidth we'd still need to + accumulate and based on that how long we'll have + to wait... */ + available = n->last_sent + th->notify_size - available; + duration = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, + available / n->quota_out); + if (th->timeout.value < + GNUNET_TIME_relative_to_absolute (duration).value) + { + /* signal timeout! */ +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Would need %llu ms before bandwidth is available for delivery, that is too long. Signaling timeout.\n", + duration.value); +#endif + remove_from_wait_list (th); + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + return; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Need more bandwidth, delaying delivery by %llu ms\n", + duration.value); +#endif + th->notify_delay_task + = GNUNET_SCHEDULER_add_delayed (h->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + duration, &transmit_ready, th); + return; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth available for transmission to `%4s'\n", + GNUNET_i2s (&n->id)); +#endif + if (GNUNET_NO == n->transmit_ok) + { + /* we may be ready, but transport service is not; + wait for SendOkMessage or timeout */ +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Need to wait for transport service `%s' message\n", + "SEND_OK"); +#endif + th->notify_delay_task + = GNUNET_SCHEDULER_add_delayed (h->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_absolute_get_remaining + (th->timeout), &transmit_timeout, th); + return; + } + n->transmit_ok = GNUNET_NO; + remove_from_wait_list (th); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Moving message to ready list\n"); +#endif + insert_transmit_handle (&h->connect_ready_head, th); + if (GNUNET_NO == h->transmission_scheduled) + schedule_transmission (h); +} + + +/** + * Add neighbour to our list + */ +static void +add_neighbour (struct GNUNET_TRANSPORT_Handle *h, + uint32_t quota_out, + struct GNUNET_TIME_Relative latency, + const struct GNUNET_PeerIdentity *pid) +{ + struct NeighbourList *n; + struct GNUNET_TRANSPORT_TransmitHandle *prev; + struct GNUNET_TRANSPORT_TransmitHandle *pos; + struct GNUNET_TRANSPORT_TransmitHandle *next; + + /* check for duplicates */ + if (NULL != find_neighbour (h, pid)) + { + GNUNET_break (0); + return; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating entry for new neighbour `%4s'.\n", GNUNET_i2s (pid)); +#endif + n = GNUNET_malloc (sizeof (struct NeighbourList)); + n->id = *pid; + n->last_quota_update = GNUNET_TIME_absolute_get (); + n->quota_out = quota_out; + n->next = h->neighbours; + n->transmit_ok = GNUNET_YES; + h->neighbours = n; + if (h->nc_cb != NULL) + h->nc_cb (h->cls, &n->id, latency); + prev = NULL; + pos = h->connect_wait_head; + while (pos != NULL) + { + next = pos->next; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found entry in connect_wait_head for `%4s'.\n", + GNUNET_i2s (&pos->target)); +#endif + if (0 == memcmp (pid, + &pos->target, sizeof (struct GNUNET_PeerIdentity))) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found pending request for new connection, will trigger now.\n"); +#endif + pos->neighbour = n; + if (pos->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + { + GNUNET_SCHEDULER_cancel (h->sched, pos->notify_delay_task); + pos->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + } + GNUNET_assert (NULL == n->transmit_handle); + n->transmit_handle = pos; + if (GNUNET_YES == n->received_ack) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "`%s' already received, scheduling request\n", + "ACK"); +#endif + schedule_request (pos); + } + else + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Still need to wait to receive `%s' message\n", + "ACK"); +#endif + pos->notify_delay_task + = GNUNET_SCHEDULER_add_delayed (h->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_absolute_get_remaining + (pos->timeout), + &transmit_timeout, pos); + } + if (prev == NULL) + h->connect_wait_head = next; + else + prev->next = next; + break; + } + prev = pos; + pos = next; + } +} + + +/** + * Connect to the transport service. Note that the connection may + * complete (or fail) asynchronously. + * + + * @param sched scheduler to use + * @param cfg configuration to use + * @param cls closure for the callbacks + * @param rec receive function to call + * @param nc function to call on connect events + * @param dc function to call on disconnect events + */ +struct GNUNET_TRANSPORT_Handle * +GNUNET_TRANSPORT_connect (struct GNUNET_SCHEDULER_Handle *sched, + struct GNUNET_CONFIGURATION_Handle *cfg, + void *cls, + GNUNET_TRANSPORT_ReceiveCallback rec, + GNUNET_TRANSPORT_NotifyConnect nc, + GNUNET_TRANSPORT_NotifyDisconnect nd) +{ + struct GNUNET_TRANSPORT_Handle *ret; + + GNUNET_ARM_start_service ("peerinfo", + cfg, sched, START_SERVICE_TIMEOUT, NULL, NULL); + GNUNET_ARM_start_service ("transport", + cfg, sched, START_SERVICE_TIMEOUT, NULL, NULL); + ret = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_Handle)); + ret->sched = sched; + ret->cfg = cfg; + ret->cls = cls; + ret->rec = rec; + ret->nc_cb = nc; + ret->nd_cb = nd; + ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO; + schedule_reconnect (ret); + return ret; +} + + +/** + * These stop activities must be run in a fresh + * scheduler that is NOT in shutdown mode. + */ +static void +stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct GNUNET_TRANSPORT_Handle *handle = cls; + GNUNET_ARM_stop_service ("transport", + handle->cfg, + tc->sched, STOP_SERVICE_TIMEOUT, NULL, NULL); + GNUNET_ARM_stop_service ("peerinfo", + handle->cfg, + tc->sched, STOP_SERVICE_TIMEOUT, NULL, NULL); +} + + +/** + * Disconnect from the transport service. + */ +void +GNUNET_TRANSPORT_disconnect (struct GNUNET_TRANSPORT_Handle *handle) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th; + struct NeighbourList *n; + struct HelloWaitList *hwl; + struct GNUNET_CLIENT_Connection *client; + +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n"); +#endif + while (NULL != (th = handle->connect_ready_head)) + { + handle->connect_ready_head = th->next; + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + } + + while (NULL != (th = handle->connect_wait_head)) + { + handle->connect_wait_head = th->next; + if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + { + GNUNET_SCHEDULER_cancel (handle->sched, th->notify_delay_task); + th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + } + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + } + while (NULL != (n = handle->neighbours)) + { + handle->neighbours = n->next; + GNUNET_free (n); + } + while (NULL != (hwl = handle->hwl_head)) + { + handle->hwl_head = hwl->next; + GNUNET_SCHEDULER_cancel (handle->sched, hwl->task); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ + ("Disconnect while trying to obtain HELLO from transport service.\n")); + if (hwl->rec != NULL) + hwl->rec (hwl->rec_cls, GNUNET_TIME_UNIT_ZERO, NULL, NULL); + GNUNET_free (hwl); + } + if (handle->reconnect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + { + GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task); + handle->reconnect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + } + GNUNET_free_non_null (handle->my_hello); + handle->my_hello = NULL; + GNUNET_SCHEDULER_run (&stop_task, handle); + if (NULL != (client = handle->client)) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting from transport service for good.\n"); +#endif + handle->client = NULL; + GNUNET_CLIENT_disconnect (client); + } + if (client == NULL) + GNUNET_free (handle); +} + + +/** + * We're ready to transmit the request that the transport service + * should connect to a new peer. In addition to sending the + * request, schedule the next phase for the transmission processing + * that caused the connect request in the first place. + */ +static size_t +request_connect (void *cls, size_t size, void *buf) +{ + struct GNUNET_TRANSPORT_TransmitHandle *th = cls; + struct TryConnectMessage *tcm; + struct GNUNET_TRANSPORT_Handle *h; + + h = th->handle; + if (buf == NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to transmit connect request to service.\n"); +#endif + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + return 0; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting `%s' message for `%4s'.\n", + "TRY_CONNECT", GNUNET_i2s (&th->target)); +#endif + GNUNET_assert (size >= sizeof (struct TryConnectMessage)); + tcm = buf; + tcm->header.size = htons (sizeof (struct TryConnectMessage)); + tcm->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TRY_CONNECT); + tcm->reserved = htonl (0); + memcpy (&tcm->peer, &th->target, sizeof (struct GNUNET_PeerIdentity)); + th->notify_delay_task + = GNUNET_SCHEDULER_add_delayed (h->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + GNUNET_TIME_absolute_get_remaining (th-> + timeout), + &transmit_timeout, th); + insert_transmit_handle (&h->connect_wait_head, th); + return sizeof (struct TryConnectMessage); +} + + +/** + * Schedule a request to connect to the given + * neighbour (and if successful, add the specified + * handle to the wait list). + */ +static void +try_connect (struct GNUNET_TRANSPORT_TransmitHandle *th) +{ + schedule_control_transmit (th->handle, + sizeof (struct TryConnectMessage), + GNUNET_NO, + GNUNET_TIME_absolute_get_remaining (th->timeout), + &request_connect, th); +} + + +/** + * Cancel a pending notify transmit task + * and also remove the given transmit handle + * from whatever list is on. + */ +static void +remove_from_any_list (struct GNUNET_TRANSPORT_TransmitHandle *th) +{ + struct GNUNET_TRANSPORT_Handle *h; + + h = th->handle; + if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) + { + GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task); + th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + } + if (th->prev == NULL) + { + if (th == h->connect_wait_head) + h->connect_wait_head = th->next; + else + h->connect_ready_head = th->next; + } + else + th->prev->next = th->next; + if (th->next != NULL) + th->next->prev = th->prev; +} + + +/** + * Remove neighbour from our list + */ +static void +remove_neighbour (struct GNUNET_TRANSPORT_Handle *h, + const struct GNUNET_PeerIdentity *peer) +{ + struct NeighbourList *prev; + struct NeighbourList *pos; + struct GNUNET_TRANSPORT_TransmitHandle *th; + + prev = NULL; + pos = h->neighbours; + while ((pos != NULL) && + (0 != memcmp (peer, &pos->id, sizeof (struct GNUNET_PeerIdentity)))) + { + prev = pos; + pos = pos->next; + } + if (pos == NULL) + { + GNUNET_break (0); + return; + } + if (prev == NULL) + h->neighbours = pos->next; + else + prev->next = pos->next; + if (NULL != (th = pos->transmit_handle)) + { + pos->transmit_handle = NULL; + th->neighbour = NULL; + remove_from_any_list (th); + try_connect (th); + } + if (h->nc_cb != NULL) + h->nd_cb (h->cls, peer); + GNUNET_free (pos); +} + + +/** + * Type of a function to call when we receive a message + * from the service. + * + * @param cls closure + * @param msg message received, NULL on timeout or fatal error + */ +static void +demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg) +{ + struct GNUNET_TRANSPORT_Handle *h = cls; + const struct DisconnectInfoMessage *dim; + const struct ConnectInfoMessage *cim; + const struct InboundMessage *im; + const struct GNUNET_MessageHeader *imm; + const struct SendOkMessage *okm; + struct HelloWaitList *hwl; + struct NeighbourList *n; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey; + struct GNUNET_PeerIdentity me; + uint16_t size; + + if ((msg == NULL) || (h->client == NULL)) + { + if (h->client != NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Error receiving from transport service, disconnecting temporarily.\n"); +#endif + if (h->network_handle != NULL) + { + GNUNET_NETWORK_notify_transmit_ready_cancel (h->network_handle); + h->network_handle = NULL; + h->transmission_scheduled = GNUNET_NO; + } + GNUNET_CLIENT_disconnect (h->client); + h->client = NULL; + schedule_reconnect (h); + } + else + { + /* shutdown initiated from 'GNUNET_TRANSPORT_disconnect', + finish clean up work! */ + GNUNET_free (h); + } + return; + } + GNUNET_CLIENT_receive (h->client, + &demultiplexer, h, GNUNET_TIME_UNIT_FOREVER_REL); + size = ntohs (msg->size); + switch (ntohs (msg->type)) + { + case GNUNET_MESSAGE_TYPE_HELLO: + if (GNUNET_OK != + GNUNET_HELLO_get_key ((const struct GNUNET_HELLO_Message *) msg, + &pkey)) + { + GNUNET_break (0); + break; + } + GNUNET_CRYPTO_hash (&pkey, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &me.hashPubKey); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving (my own) `%s' message, I am `%4s'.\n", + "HELLO", GNUNET_i2s (&me)); +#endif + GNUNET_free_non_null (h->my_hello); + h->my_hello = NULL; + if (size < sizeof (struct GNUNET_MessageHeader)) + { + GNUNET_break (0); + break; + } + h->my_hello = GNUNET_malloc (size); + memcpy (h->my_hello, msg, size); + while (NULL != (hwl = h->hwl_head)) + { + h->hwl_head = hwl->next; + GNUNET_SCHEDULER_cancel (h->sched, hwl->task); + GNUNET_TRANSPORT_get_hello (h, + GNUNET_TIME_UNIT_ZERO, + hwl->rec, hwl->rec_cls); + GNUNET_free (hwl); + } + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT: + if (size != sizeof (struct ConnectInfoMessage)) + { + GNUNET_break (0); + break; + } + cim = (const struct ConnectInfoMessage *) msg; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message for `%4s'.\n", + "CONNECT", GNUNET_i2s (&cim->id)); +#endif + add_neighbour (h, + ntohl (cim->quota_out), + GNUNET_TIME_relative_ntoh (cim->latency), &cim->id); + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT: + if (size != sizeof (struct DisconnectInfoMessage)) + { + GNUNET_break (0); + break; + } + dim = (const struct DisconnectInfoMessage *) msg; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message for `%4s'.\n", + "DISCONNECT", GNUNET_i2s (&dim->peer)); +#endif + remove_neighbour (h, &dim->peer); + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message.\n", "SEND_OK"); +#endif + if (size != sizeof (struct SendOkMessage)) + { + GNUNET_break (0); + break; + } + okm = (const struct SendOkMessage *) msg; + n = find_neighbour (h, &okm->peer); + GNUNET_assert (n != NULL); + n->transmit_ok = GNUNET_YES; + if (n->transmit_handle != NULL) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Processing pending message\n"); +#endif + GNUNET_SCHEDULER_cancel (h->sched, + n->transmit_handle->notify_delay_task); + n->transmit_handle->notify_delay_task = + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK; + GNUNET_assert (GNUNET_YES == n->received_ack); + schedule_request (n->transmit_handle); + } + break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_RECV: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message.\n", "RECV"); +#endif + if (size < + sizeof (struct InboundMessage) + + sizeof (struct GNUNET_MessageHeader)) + { + GNUNET_break (0); + break; + } + im = (const struct InboundMessage *) msg; + imm = (const struct GNUNET_MessageHeader *) &im[1]; + if (ntohs (imm->size) + sizeof (struct InboundMessage) != size) + { + GNUNET_break (0); + break; + } + switch (ntohs (imm->type)) + { + case GNUNET_MESSAGE_TYPE_TRANSPORT_ACK: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receiving `%s' message from `%4s'.\n", + "ACK", GNUNET_i2s (&im->peer)); +#endif + n = find_neighbour (h, &im->peer); + if (n == NULL) + { + GNUNET_break (0); + break; + } + if (n->received_ack == GNUNET_NO) + { + n->received_ack = GNUNET_YES; + if (NULL != n->transmit_handle) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peer connected, scheduling delayed message for deliverery now.\n"); +#endif + schedule_request (n->transmit_handle); + } + } + break; + default: +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received message of type %u from `%4s'.\n", + ntohs (imm->type), GNUNET_i2s (&im->peer)); +#endif + if (h->rec != NULL) + h->rec (h->cls, + GNUNET_TIME_relative_ntoh (im->latency), &im->peer, imm); + break; + } + break; + default: + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ + ("Received unexpected message of type %u from `%4s' in %s:%u\n"), + ntohs (msg->type), GNUNET_i2s (&im->peer), __FILE__, + __LINE__); + GNUNET_break (0); + break; + } +} + + +struct ClientTransmitWrapper +{ + GNUNET_NETWORK_TransmitReadyNotify notify; + void *notify_cls; + struct GNUNET_TRANSPORT_TransmitHandle *th; +}; + + +/** + * Transmit message of a client destined for another + * peer to the service. + */ +static size_t +client_notify_wrapper (void *cls, size_t size, void *buf) +{ + struct ClientTransmitWrapper *ctw = cls; + struct OutboundMessage *obm; + struct GNUNET_MessageHeader *hdr; + size_t ret; + + if (size == 0) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmission request could not be satisfied.\n"); +#endif + ret = ctw->notify (ctw->notify_cls, 0, NULL); + GNUNET_assert (ret == 0); + GNUNET_free (ctw); + return 0; + } + GNUNET_assert (size >= sizeof (struct OutboundMessage)); + obm = buf; + ret = ctw->notify (ctw->notify_cls, + size - sizeof (struct OutboundMessage), + (void *) &obm[1]); + if (ret == 0) + { + /* Need to reset flag, no SEND means no SEND_OK! */ + ctw->th->neighbour->transmit_ok = GNUNET_YES; + GNUNET_free (ctw); + return 0; + } + GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader)); + hdr = (struct GNUNET_MessageHeader *) &obm[1]; + GNUNET_assert (ntohs (hdr->size) == ret); + GNUNET_assert (ret + sizeof (struct OutboundMessage) < + GNUNET_SERVER_MAX_MESSAGE_SIZE); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting `%s' message with data for `%4s'\n", + "SEND", GNUNET_i2s (&ctw->th->target)); +#endif + ret += sizeof (struct OutboundMessage); + obm->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND); + obm->header.size = htons (ret); + obm->reserved = htonl (0); + obm->peer = ctw->th->target; + GNUNET_free (ctw); + return ret; +} + + + +/** + * Check if we could queue a message of the given size for + * transmission. The transport service will take both its + * internal buffers and bandwidth limits imposed by the + * other peer into consideration when answering this query. + * + * @param handle connection to transport service + * @param target who should receive the message + * @param size how big is the message we want to transmit? + * @param timeout after how long should we give up (and call + * notify with buf NULL and size 0)? + * @param notify function to call when we are ready to + * send such a message + * @param notify_cls closure for notify + * @return NULL if someone else is already waiting to be notified + * non-NULL if the notify callback was queued (can be used to cancel + * using GNUNET_TRANSPORT_notify_transmit_ready_cancel) + */ +struct GNUNET_TRANSPORT_TransmitHandle * +GNUNET_TRANSPORT_notify_transmit_ready (struct GNUNET_TRANSPORT_Handle + *handle, + const struct GNUNET_PeerIdentity + *target, size_t size, + struct GNUNET_TIME_Relative timeout, + GNUNET_NETWORK_TransmitReadyNotify + notify, void *notify_cls) +{ + struct GNUNET_TRANSPORT_TransmitHandle *pos; + struct GNUNET_TRANSPORT_TransmitHandle *th; + struct NeighbourList *n; + struct ClientTransmitWrapper *ctw; + + if (size + sizeof (struct OutboundMessage) >= + GNUNET_SERVER_MAX_MESSAGE_SIZE) + return NULL; +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Asking transport service for transmission of %u bytes to peer `%4s'.\n", + size, GNUNET_i2s (target)); +#endif + n = find_neighbour (handle, target); + ctw = GNUNET_malloc (sizeof (struct ClientTransmitWrapper)); + th = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TransmitHandle)); + ctw->notify = notify; + ctw->notify_cls = notify_cls; + ctw->th = th; + th->handle = handle; + th->target = *target; + th->notify = &client_notify_wrapper; + th->notify_cls = ctw; + th->notify_size = size + sizeof (struct OutboundMessage); + th->timeout = GNUNET_TIME_relative_to_absolute (timeout); + th->neighbour = n; + if (NULL == n) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmission request could not be satisfied (not yet connected), adding it to pending request list.\n"); +#endif + pos = handle->connect_wait_head; + while (pos != NULL) + { + GNUNET_assert (0 != memcmp (target, + &pos->target, + sizeof (struct GNUNET_PeerIdentity))); + pos = pos->next; + } +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Will now try to connect to `%4s'.\n", GNUNET_i2s (target)); +#endif + try_connect (th); + } + else + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Transmission request queued for transmission to transport service.\n"); +#endif + GNUNET_assert (NULL == n->transmit_handle); + n->transmit_handle = th; + if (GNUNET_YES == n->received_ack) + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peer `%4s' is connected, scheduling for delivery now.\n", + GNUNET_i2s (target)); +#endif + schedule_request (th); + } + else + { +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Connection to `%4s' is not yet confirmed connected, scheduling timeout (%llums) only.\n", + GNUNET_i2s (target), timeout.value); +#endif + th->notify_delay_task + = GNUNET_SCHEDULER_add_delayed (handle->sched, + GNUNET_NO, + GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_PREREQUISITE_TASK, + timeout, &transmit_timeout, th); + } + } + return th; +} + + +/** + * Cancel the specified transmission-ready + * notification. + */ +void +GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct + GNUNET_TRANSPORT_TransmitHandle + *th) +{ + struct GNUNET_TRANSPORT_Handle *h; + + GNUNET_assert (th->notify == &client_notify_wrapper); + remove_from_any_list (th); + h = th->handle; + if ((h->connect_ready_head == NULL) && (h->network_handle != NULL)) + { + GNUNET_NETWORK_notify_transmit_ready_cancel (h->network_handle); + h->network_handle = NULL; + h->transmission_scheduled = GNUNET_NO; + } + GNUNET_free (th->notify_cls); + GNUNET_free (th); +} + + +/* end of transport_api.c */ -- cgit v1.2.3