X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fplugin_transport_tcp.c;h=a63013caad6e644451869318074b6eeeb0130197;hb=5a7cef0202631204485cbcb1e36671e4321a936f;hp=5fdffd927f28ec14bad1f05611e6b0da0a3802d4;hpb=8cd6b76a214ff9b4b36f76d9374074ab4520b9f4;p=oweals%2Fgnunet.git diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c index 5fdffd927..a63013caa 100644 --- a/src/transport/plugin_transport_tcp.c +++ b/src/transport/plugin_transport_tcp.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet - Copyright (C) 2002--2015 Christian Grothoff (and other contributing authors) + Copyright (C) 2002--2015 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -14,8 +14,8 @@ 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. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /** * @file transport/plugin_transport_tcp.c @@ -26,7 +26,7 @@ #include "gnunet_hello_lib.h" #include "gnunet_constants.h" #include "gnunet_util_lib.h" -#include "gnunet_nat_lib.h" +#include "gnunet_nat_service.h" #include "gnunet_protocols.h" #include "gnunet_resolver_service.h" #include "gnunet_signatures.h" @@ -45,9 +45,537 @@ */ #define NAT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10) -GNUNET_NETWORK_STRUCT_BEGIN +/** + * Opaque handle that can be used to cancel + * a transmit-ready notification. + */ +struct GNUNET_CONNECTION_TransmitHandle; + +/** + * @brief handle for a server + */ +struct GNUNET_SERVER_Handle; + +/** + * @brief opaque handle for a client of the server + */ +struct GNUNET_SERVER_Client; + +/** + * @brief opaque handle server returns for aborting transmission to a client. + */ +struct GNUNET_SERVER_TransmitHandle; + +/** + * @brief handle for a network connection + */ +struct GNUNET_CONNECTION_Handle; + +/** + * @brief handle for a network service + */ +struct LEGACY_SERVICE_Context; + + +/** + * Stops a service that was started with #GNUNET_SERVICE_start(). + * + * @param srv service to stop + */ +void +LEGACY_SERVICE_stop (struct LEGACY_SERVICE_Context *srv); + + + +/** + * Function called to notify a client about the connection begin ready + * to queue more data. @a buf will be NULL and @a size zero if the + * connection was closed for writing in the meantime. + * + * @param cls closure + * @param size number of bytes available in @a buf + * @param buf where the callee should write the message + * @return number of bytes written to @a buf + */ +typedef size_t +(*GNUNET_CONNECTION_TransmitReadyNotify) (void *cls, + size_t size, + void *buf); + +/** + * Credentials for UNIX domain sockets. + */ +struct GNUNET_CONNECTION_Credentials +{ + /** + * UID of the other end of the connection. + */ + uid_t uid; + + /** + * GID of the other end of the connection. + */ + gid_t gid; +}; + + +/** + * Functions with this signature are called whenever a client + * is disconnected on the network level. + * + * @param cls closure + * @param client identification of the client; NULL + * for the last call when the server is destroyed + */ +typedef void +(*GNUNET_SERVER_DisconnectCallback) (void *cls, + struct GNUNET_SERVER_Client *client); + + +/** + * Functions with this signature are called whenever a client + * is connected on the network level. + * + * @param cls closure + * @param client identification of the client + */ +typedef void +(*GNUNET_SERVER_ConnectCallback) (void *cls, + struct GNUNET_SERVER_Client *client); + + + + +/** + * Function to call for access control checks. + * + * @param cls closure + * @param ucred credentials, if available, otherwise NULL + * @param addr address + * @param addrlen length of address + * @return GNUNET_YES to allow, GNUNET_NO to deny, GNUNET_SYSERR + * for unknown address family (will be denied). + */ +typedef int +(*GNUNET_CONNECTION_AccessCheck) (void *cls, + const struct + GNUNET_CONNECTION_Credentials * + ucred, + const struct sockaddr * addr, + socklen_t addrlen); + +/** + * Callback function for data received from the network. Note that + * both "available" and "err" would be 0 if the read simply timed out. + * + * @param cls closure + * @param buf pointer to received data + * @param available number of bytes availabe in "buf", + * possibly 0 (on errors) + * @param addr address of the sender + * @param addrlen size of addr + * @param errCode value of errno (on errors receiving) + */ +typedef void +(*GNUNET_CONNECTION_Receiver) (void *cls, const void *buf, + size_t available, + const struct sockaddr * addr, + socklen_t addrlen, int errCode); + + + +/** + * Close the connection and free associated resources. There must + * not be any pending requests for reading or writing to the + * connection at this time. + * + * @param connection connection to destroy + */ +void +GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection); +/** + * Signature of a function to create a custom tokenizer. + * + * @param cls closure from #GNUNET_SERVER_set_callbacks + * @param client handle to client the tokenzier will be used for + * @return handle to custom tokenizer ('mst') + */ +typedef void* +(*GNUNET_SERVER_MstCreateCallback) (void *cls, + struct GNUNET_SERVER_Client *client); + + +/** + * Signature of a function to destroy a custom tokenizer. + * + * @param cls closure from #GNUNET_SERVER_set_callbacks + * @param mst custom tokenizer handle + */ +typedef void +(*GNUNET_SERVER_MstDestroyCallback) (void *cls, + void *mst); + +/** + * Signature of a function to receive data for a custom tokenizer. + * + * @param cls closure from #GNUNET_SERVER_set_callbacks + * @param mst custom tokenizer handle + * @param client_identity ID of client for which this is a buffer, + * can be NULL (will be passed back to 'cb') + * @param buf input data to add + * @param size number of bytes in @a buf + * @param purge should any excess bytes in the buffer be discarded + * (i.e. for packet-based services like UDP) + * @param one_shot only call callback once, keep rest of message in buffer + * @return #GNUNET_OK if we are done processing (need more data) + * #GNUNET_NO if one_shot was set and we have another message ready + * #GNUNET_SYSERR if the data stream is corrupt + */ +typedef int +(*GNUNET_SERVER_MstReceiveCallback) (void *cls, void *mst, + struct GNUNET_SERVER_Client *client, + const char *buf, + size_t size, + int purge, + int one_shot); +/** + * Functions with this signature are called whenever a message is + * received. + * + * @param cls closure + * @param client identification of the client + * @param message the actual message + */ +typedef void +(*GNUNET_SERVER_MessageCallback) (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message); + +/** + * Message handler. Each struct specifies how to handle on particular + * type of message received. + */ +struct GNUNET_SERVER_MessageHandler +{ + /** + * Function to call for messages of "type". + */ + GNUNET_SERVER_MessageCallback callback; + + /** + * Closure argument for @e callback. + */ + void *callback_cls; + + /** + * Type of the message this handler covers. + */ + uint16_t type; + + /** + * Expected size of messages of this type. Use 0 for + * variable-size. If non-zero, messages of the given + * type will be discarded (and the connection closed) + * if they do not have the right size. + */ + uint16_t expected_size; + +}; + + +/** + * Options for the service (bitmask). + */ +enum LEGACY_SERVICE_Options +{ + /** + * Use defaults. Terminates all client connections and the listen + * sockets immediately upon receiving the shutdown signal. + */ + LEGACY_SERVICE_OPTION_NONE = 0, + + /** + * Do not trigger server shutdown on signal at all; instead, allow + * for the user to terminate the server explicitly when needed + * by calling #LEGACY_SERVICE_shutdown(). + */ + LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN = 1, + + /** + * Trigger a SOFT server shutdown on signals, allowing active + * non-monitor clients to complete their transactions. + */ + LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN = 2 +}; + + + +/** + * Ask the server to disconnect from the given client. This is the + * same as passing #GNUNET_SYSERR to #GNUNET_SERVER_receive_done, + * except that it allows dropping of a client even when not handling a + * message from that client. + * + * @param client the client to disconnect from + */ +void +GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client); + +/** + * Return user context associated with the given client. + * Note: you should probably use the macro (call without the underscore). + * + * @param client client to query + * @param size number of bytes in user context struct (for verification only) + * @return pointer to user context + */ +void * +GNUNET_SERVER_client_get_user_context_ (struct GNUNET_SERVER_Client *client, + size_t size); + + +/** + * Functions with this signature are called whenever a + * complete message is received by the tokenizer. + * + * Do not call #GNUNET_SERVER_mst_destroy from within + * the scope of this callback. + * + * @param cls closure + * @param client identification of the client + * @param message the actual message + * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing + */ +typedef int +(*GNUNET_SERVER_MessageTokenizerCallback) (void *cls, + void *client, + const struct GNUNET_MessageHeader *message); + + +/** + * Create a message stream tokenizer. + * + * @param cb function to call on completed messages + * @param cb_cls closure for @a cb + * @return handle to tokenizer + */ +struct GNUNET_SERVER_MessageStreamTokenizer * +GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb, + void *cb_cls); + +/** + * Add incoming data to the receive buffer and call the + * callback for all complete messages. + * + * @param mst tokenizer to use + * @param client_identity ID of client for which this is a buffer, + * can be NULL (will be passed back to 'cb') + * @param buf input data to add + * @param size number of bytes in @a buf + * @param purge should any excess bytes in the buffer be discarded + * (i.e. for packet-based services like UDP) + * @param one_shot only call callback once, keep rest of message in buffer + * @return #GNUNET_OK if we are done processing (need more data) + * #GNUNET_NO if one_shot was set and we have another message ready + * #GNUNET_SYSERR if the data stream is corrupt + */ +int +GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst, + void *client_identity, + const char *buf, size_t size, + int purge, int one_shot); + + + +/** + * Destroys a tokenizer. + * + * @param mst tokenizer to destroy + */ +void +GNUNET_SERVER_mst_destroy (struct GNUNET_SERVER_MessageStreamTokenizer *mst); + + +/** + * Set user context to be associated with the given client. + * Note: you should probably use the macro (call without the underscore). + * + * @param client client to query + * @param ptr pointer to user context + * @param size number of bytes in user context struct (for verification only) + */ +void +GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client *client, + void *ptr, + size_t size); +/** + * Return user context associated with the given client. + * + * @param client client to query + * @param type expected return type (i.e. 'struct Foo') + * @return pointer to user context of type 'type *'. + */ +#define GNUNET_SERVER_client_get_user_context(client,type) \ + (type *) GNUNET_SERVER_client_get_user_context_ (client, sizeof (type)) + +/** + * Set user context to be associated with the given client. + * + * @param client client to query + * @param value pointer to user context + */ +#define GNUNET_SERVER_client_set_user_context(client,value) \ + GNUNET_SERVER_client_set_user_context_ (client, value, sizeof (*value)) + + + +/** + * Notify us when the server has enough space to transmit + * a message of the given size to the given client. + * + * @param client client to transmit message to + * @param size requested amount of buffer space + * @param timeout after how long should we give up (and call + * notify with buf NULL and size 0)? + * @param callback function to call when space is available + * @param callback_cls closure for @a callback + * @return non-NULL if the notify callback was queued; can be used + * to cancel the request using + * #GNUNET_SERVER_notify_transmit_ready_cancel. + * NULL if we are already going to notify someone else (busy) + */ +struct GNUNET_SERVER_TransmitHandle * +GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client, + size_t size, + struct GNUNET_TIME_Relative timeout, + GNUNET_CONNECTION_TransmitReadyNotify callback, + void *callback_cls); + +/** + * Abort transmission request. + * + * @param th request to abort + */ +void +GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th); + + + + +/** + * Notify the server that the given client handle should + * be kept (keeps the connection up if possible, increments + * the internal reference counter). + * + * @param client the client to keep + */ +void +GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client); + + +/** + * Notify the server that the given client handle is no + * longer required. Decrements the reference counter. If + * that counter reaches zero an inactive connection maybe + * closed. + * + * @param client the client to drop + */ +void +GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client); + + +/** + * Function called by the service's run + * method to run service-specific setup code. + * + * @param cls closure + * @param server the initialized server + * @param cfg configuration to use + */ +typedef void +(*LEGACY_SERVICE_Main) (void *cls, + struct GNUNET_SERVER_Handle *server, + const struct GNUNET_CONFIGURATION_Handle *cfg); + + + +/** + * Suspend accepting connections from the listen socket temporarily. + * Resume activity using #GNUNET_SERVER_resume. + * + * @param server server to stop accepting connections. + */ +void +GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server); + +/** + * Notify us when the server has enough space to transmit + * a message of the given size to the given client. + * + * @param client client to transmit message to + * @param size requested amount of buffer space + * @param timeout after how long should we give up (and call + * notify with buf NULL and size 0)? + * @param callback function to call when space is available + * @param callback_cls closure for @a callback + * @return non-NULL if the notify callback was queued; can be used + * to cancel the request using + * #GNUNET_SERVER_notify_transmit_ready_cancel. + * NULL if we are already going to notify someone else (busy) + */ +struct GNUNET_SERVER_TransmitHandle * +GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client, + size_t size, + struct GNUNET_TIME_Relative timeout, + GNUNET_CONNECTION_TransmitReadyNotify callback, + void *callback_cls); + + +/** + * Add a TCP socket-based connection to the set of handles managed by + * this server. Use this function for outgoing (P2P) connections that + * we initiated (and where this server should process incoming + * messages). + * + * @param server the server to use + * @param connection the connection to manage (client must + * stop using this connection from now on) + * @return the client handle + */ +struct GNUNET_SERVER_Client * +GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server, + struct GNUNET_CONNECTION_Handle *connection); + + +/** + * Resume accepting connections from the listen socket. + * + * @param server server to resume accepting connections. + */ +void +GNUNET_SERVER_resume (struct GNUNET_SERVER_Handle *server); + +/** + * Free resources held by this server. + * + * @param server server to destroy + */ +void +GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server); + + + + +#include "tcp_connection_legacy.c" +#include "tcp_server_mst_legacy.c" +#include "tcp_server_legacy.c" +#include "tcp_service_legacy.c" + +GNUNET_NETWORK_STRUCT_BEGIN + /** * Initial handshake message for a session. */ @@ -154,7 +682,7 @@ struct IPv4TcpAddress * Optional options and flags for this address, * see `enum TcpAddressOptions` */ - uint32_t options; + uint32_t options GNUNET_PACKED; /** * IPv4 address, in network byte order. @@ -177,7 +705,7 @@ struct IPv6TcpAddress * Optional flags for this address * see `enum TcpAddressOptions` */ - uint32_t options; + uint32_t options GNUNET_PACKED; /** * IPv6 address. @@ -248,7 +776,7 @@ struct PendingMessage /** * Session handle for TCP connections. */ -struct Session +struct GNUNET_ATS_Session { /** * To whom are we talking to (set to our identity @@ -434,7 +962,7 @@ struct Plugin /** * Handle to the network service. */ - struct GNUNET_SERVICE_Context *service; + struct LEGACY_SERVICE_Context *service; /** * Handle to the server for this service. @@ -462,11 +990,6 @@ struct Plugin */ struct TCPProbeContext *probe_tail; - /** - * Handle for (DYN)DNS lookup of our external IP. - */ - struct GNUNET_RESOLVER_RequestHandle *ext_dns; - /** * Function to call about session status changes. */ @@ -526,6 +1049,350 @@ struct Plugin }; +/** + * Get the list of addresses that a server for the given service + * should bind to. + * + * @param service_name name of the service + * @param cfg configuration (which specifies the addresses) + * @param addrs set (call by reference) to an array of pointers to the + * addresses the server should bind to and listen on; the + * array will be NULL-terminated (on success) + * @param addr_lens set (call by reference) to an array of the lengths + * of the respective `struct sockaddr` struct in the @a addrs + * array (on success) + * @return number of addresses found on success, + * #GNUNET_SYSERR if the configuration + * did not specify reasonable finding information or + * if it specified a hostname that could not be resolved; + * #GNUNET_NO if the number of addresses configured is + * zero (in this case, `*addrs` and `*addr_lens` will be + * set to NULL). + */ +static int +get_server_addresses (const char *service_name, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct sockaddr ***addrs, + socklen_t ** addr_lens) +{ + int disablev6; + struct GNUNET_NETWORK_Handle *desc; + unsigned long long port; + char *unixpath; + struct addrinfo hints; + struct addrinfo *res; + struct addrinfo *pos; + struct addrinfo *next; + unsigned int i; + int resi; + int ret; + int abstract; + struct sockaddr **saddrs; + socklen_t *saddrlens; + char *hostname; + + *addrs = NULL; + *addr_lens = NULL; + desc = NULL; + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6")) + { + if (GNUNET_SYSERR == + (disablev6 = + GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6"))) + return GNUNET_SYSERR; + } + else + disablev6 = GNUNET_NO; + + if (! disablev6) + { + /* probe IPv6 support */ + desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); + if (NULL == desc) + { + if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || + (EACCES == errno)) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + return GNUNET_SYSERR; + } + LOG (GNUNET_ERROR_TYPE_INFO, + _("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), + service_name, STRERROR (errno)); + disablev6 = GNUNET_YES; + } + else + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); + desc = NULL; + } + } + + port = 0; + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) + { + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (cfg, service_name, + "PORT", &port)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Require valid port number for service `%s' in configuration!\n"), + service_name); + } + if (port > 65535) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Require valid port number for service `%s' in configuration!\n"), + service_name); + return GNUNET_SYSERR; + } + } + + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) + { + GNUNET_break (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_string (cfg, service_name, + "BINDTO", &hostname)); + } + else + hostname = NULL; + + unixpath = NULL; + abstract = GNUNET_NO; +#ifdef AF_UNIX + if ((GNUNET_YES == + GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && + (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", + &unixpath)) && + (0 < strlen (unixpath))) + { + /* probe UNIX support */ + struct sockaddr_un s_un; + + if (strlen (unixpath) >= sizeof (s_un.sun_path)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath, + (unsigned long long) sizeof (s_un.sun_path)); + unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); + LOG (GNUNET_ERROR_TYPE_INFO, + _("Using `%s' instead\n"), + unixpath); + } +#ifdef LINUX + abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, + "TESTING", + "USE_ABSTRACT_SOCKETS"); + if (GNUNET_SYSERR == abstract) + abstract = GNUNET_NO; +#endif + if ((GNUNET_YES != abstract) + && (GNUNET_OK != + GNUNET_DISK_directory_create_for_file (unixpath))) + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, + "mkdir", + unixpath); + } + if (NULL != unixpath) + { + desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); + if (NULL == desc) + { + if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || + (EACCES == errno)) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free_non_null (hostname); + GNUNET_free (unixpath); + return GNUNET_SYSERR; + } + LOG (GNUNET_ERROR_TYPE_INFO, + _("Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), + service_name, + STRERROR (errno)); + GNUNET_free (unixpath); + unixpath = NULL; + } + else + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); + desc = NULL; + } + } +#endif + + if ((0 == port) && (NULL == unixpath)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), + service_name); + GNUNET_free_non_null (hostname); + return GNUNET_SYSERR; + } + if (0 == port) + { + saddrs = GNUNET_malloc (2 * sizeof (struct sockaddr *)); + saddrlens = GNUNET_malloc (2 * sizeof (socklen_t)); + add_unixpath (saddrs, saddrlens, unixpath, abstract); + GNUNET_free_non_null (unixpath); + GNUNET_free_non_null (hostname); + *addrs = saddrs; + *addr_lens = saddrlens; + return 1; + } + + if (NULL != hostname) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Resolving `%s' since that is where `%s' will bind to.\n", + hostname, + service_name); + memset (&hints, 0, sizeof (struct addrinfo)); + if (disablev6) + hints.ai_family = AF_INET; + hints.ai_protocol = IPPROTO_TCP; + if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || + (NULL == res)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Failed to resolve `%s': %s\n"), + hostname, + gai_strerror (ret)); + GNUNET_free (hostname); + GNUNET_free_non_null (unixpath); + return GNUNET_SYSERR; + } + next = res; + i = 0; + while (NULL != (pos = next)) + { + next = pos->ai_next; + if ((disablev6) && (pos->ai_family == AF_INET6)) + continue; + i++; + } + if (0 == i) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Failed to find %saddress for `%s'.\n"), + disablev6 ? "IPv4 " : "", + hostname); + freeaddrinfo (res); + GNUNET_free (hostname); + GNUNET_free_non_null (unixpath); + return GNUNET_SYSERR; + } + resi = i; + if (NULL != unixpath) + resi++; + saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *)); + saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t)); + i = 0; + if (NULL != unixpath) + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + next = res; + while (NULL != (pos = next)) + { + next = pos->ai_next; + if ((disablev6) && (AF_INET6 == pos->ai_family)) + continue; + if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) + continue; /* not TCP */ + if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) + continue; /* huh? */ + LOG (GNUNET_ERROR_TYPE_DEBUG, "Service `%s' will bind to `%s'\n", + service_name, GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); + if (AF_INET == pos->ai_family) + { + GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen); + saddrlens[i] = pos->ai_addrlen; + saddrs[i] = GNUNET_malloc (saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); + } + else + { + GNUNET_assert (AF_INET6 == pos->ai_family); + GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen); + saddrlens[i] = pos->ai_addrlen; + saddrs[i] = GNUNET_malloc (saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); + } + i++; + } + GNUNET_free (hostname); + freeaddrinfo (res); + resi = i; + } + else + { + /* will bind against everything, just set port */ + if (disablev6) + { + /* V4-only */ + resi = 1; + if (NULL != unixpath) + resi++; + i = 0; + saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *)); + saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t)); + if (NULL != unixpath) + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + saddrlens[i] = sizeof (struct sockaddr_in); + saddrs[i] = GNUNET_malloc (saddrlens[i]); +#if HAVE_SOCKADDR_IN_SIN_LEN + ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; +#endif + ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); + } + else + { + /* dual stack */ + resi = 2; + if (NULL != unixpath) + resi++; + saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *)); + saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t)); + i = 0; + if (NULL != unixpath) + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + saddrlens[i] = sizeof (struct sockaddr_in6); + saddrs[i] = GNUNET_malloc (saddrlens[i]); +#if HAVE_SOCKADDR_IN_SIN_LEN + ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; +#endif + ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; + ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); + i++; + saddrlens[i] = sizeof (struct sockaddr_in); + saddrs[i] = GNUNET_malloc (saddrlens[i]); +#if HAVE_SOCKADDR_IN_SIN_LEN + ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; +#endif + ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); + } + } + GNUNET_free_non_null (unixpath); + *addrs = saddrs; + *addr_lens = saddrlens; + return resi; +} +/* end ancient copy-and-paste */ + + /** * If a session monitor is attached, notify it about the new * session state. @@ -536,7 +1403,7 @@ struct Plugin */ static void notify_session_monitor (struct Plugin *plugin, - struct Session *session, + struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state) { struct GNUNET_TRANSPORT_SessionInfo info; @@ -545,9 +1412,8 @@ notify_session_monitor (struct Plugin *plugin, return; memset (&info, 0, sizeof (info)); info.state = state; - info.is_inbound = (0 != (GNUNET_HELLO_ADDRESS_INFO_INBOUND & session->address->local_info)) - ? GNUNET_YES - : GNUNET_NO; + info.is_inbound = GNUNET_HELLO_address_check_option (session->address, + GNUNET_HELLO_ADDRESS_INFO_INBOUND); info.num_msg_pending = session->msgs_in_queue; info.num_bytes_pending = session->bytes_in_queue; if (NULL != session->receive_delay_task) @@ -566,13 +1432,15 @@ notify_session_monitor (struct Plugin *plugin, * @param cls closure, the `struct Plugin` * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean * the previous (now invalid) one + * @param ac address class the address belongs to * @param addr either the previous or the new public IP address * @param addrlen actual length of @a addr */ static void tcp_nat_port_map_callback (void *cls, int add_remove, - const struct sockaddr *addr, + enum GNUNET_NAT_AddressClass ac, + const struct sockaddr *addr, socklen_t addrlen) { struct Plugin *plugin = cls; @@ -582,10 +1450,10 @@ tcp_nat_port_map_callback (void *cls, void *arg; size_t args; - LOG(GNUNET_ERROR_TYPE_INFO, - "NAT notification to %s address `%s'\n", - (GNUNET_YES == add_remove) ? "add" : "remove", - GNUNET_a2s (addr, addrlen)); + LOG (GNUNET_ERROR_TYPE_INFO, + "NAT notification to %s address `%s'\n", + (GNUNET_YES == add_remove) ? "add" : "remove", + GNUNET_a2s (addr, addrlen)); /* convert 'addr' to our internal format */ switch (addr->sa_family) { @@ -601,8 +1469,9 @@ tcp_nat_port_map_callback (void *cls, case AF_INET6: GNUNET_assert(addrlen == sizeof(struct sockaddr_in6)); memset (&t6, 0, sizeof(t6)); - memcpy (&t6.ipv6_addr, &((struct sockaddr_in6 *) addr)->sin6_addr, - sizeof(struct in6_addr)); + GNUNET_memcpy (&t6.ipv6_addr, + &((struct sockaddr_in6 *) addr)->sin6_addr, + sizeof(struct in6_addr)); t6.options = htonl (plugin->myoptions); t6.t6_port = ((struct sockaddr_in6 *) addr)->sin6_port; arg = &t6; @@ -614,11 +1483,17 @@ tcp_nat_port_map_callback (void *cls, } /* modify our published address list */ GNUNET_assert ((args == sizeof (struct IPv4TcpAddress)) || - (args == sizeof (struct IPv6TcpAddress))); + (args == sizeof (struct IPv6TcpAddress))); + /* TODO: use 'ac' here in the future... */ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity, - PLUGIN_NAME, arg, args, GNUNET_HELLO_ADDRESS_INFO_NONE); - plugin->env->notify_address (plugin->env->cls, add_remove, address); - GNUNET_HELLO_address_free(address); + PLUGIN_NAME, + arg, + args, + GNUNET_HELLO_ADDRESS_INFO_NONE); + plugin->env->notify_address (plugin->env->cls, + add_remove, + address); + GNUNET_HELLO_address_free (address); } @@ -656,7 +1531,7 @@ tcp_plugin_address_to_string (void *cls, af = AF_INET6; port = ntohs (t6->t6_port); options = ntohl (t6->options); - memcpy (&a6, &t6->ipv6_addr, sizeof(a6)); + GNUNET_memcpy (&a6, &t6->ipv6_addr, sizeof(a6)); sb = &a6; break; case sizeof(struct IPv4TcpAddress): @@ -664,7 +1539,7 @@ tcp_plugin_address_to_string (void *cls, af = AF_INET; port = ntohs (t4->t4_port); options = ntohl (t4->options); - memcpy (&a4, &t4->ipv4_addr, sizeof(a4)); + GNUNET_memcpy (&a4, &t4->ipv4_addr, sizeof(a4)); sb = &a4; break; default: @@ -807,12 +1682,12 @@ tcp_plugin_string_to_address (void *cls, * @param client which client to find the session handle for * @return NULL if no matching session exists */ -static struct Session * +static struct GNUNET_ATS_Session * lookup_session_by_client (struct Plugin *plugin, struct GNUNET_SERVER_Client *client) { return GNUNET_SERVER_client_get_user_context (client, - struct Session); + struct GNUNET_ATS_Session); } @@ -827,7 +1702,7 @@ lookup_session_by_client (struct Plugin *plugin, */ static int tcp_plugin_disconnect_session (void *cls, - struct Session *session) + struct GNUNET_ATS_Session *session) { struct Plugin *plugin = cls; struct PendingMessage *pm; @@ -956,14 +1831,12 @@ tcp_plugin_query_keepalive_factor (void *cls) /** * Session was idle for too long, so disconnect it * - * @param cls the `struct Session` of the idle session - * @param tc scheduler context + * @param cls the `struct GNUNET_ATS_Session` of the idle session */ static void -session_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +session_timeout (void *cls) { - struct Session *s = cls; + struct GNUNET_ATS_Session *s = cls; struct GNUNET_TIME_Relative left; s->timeout_task = NULL; @@ -997,7 +1870,7 @@ session_timeout (void *cls, * @param s session to increment timeout for */ static void -reschedule_session_timeout (struct Session *s) +reschedule_session_timeout (struct GNUNET_ATS_Session *s) { GNUNET_assert (NULL != s->timeout_task); s->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); @@ -1016,14 +1889,14 @@ reschedule_session_timeout (struct Session *s) * the session * @return new session object */ -static struct Session * +static struct GNUNET_ATS_Session * create_session (struct Plugin *plugin, const struct GNUNET_HELLO_Address *address, enum GNUNET_ATS_Network_Type scope, struct GNUNET_SERVER_Client *client, int is_nat) { - struct Session *session; + struct GNUNET_ATS_Session *session; struct PendingMessage *pm; if (GNUNET_YES != is_nat) @@ -1032,12 +1905,12 @@ create_session (struct Plugin *plugin, GNUNET_assert (NULL == client); LOG (GNUNET_ERROR_TYPE_DEBUG, - "Creating new session for peer `%4s' at address %s\n", + "Creating new session for peer `%s' at address %s\n", GNUNET_i2s (&address->peer), tcp_plugin_address_to_string (plugin, address->address, address->address_length)); - session = GNUNET_new (struct Session); + session = GNUNET_new (struct GNUNET_ATS_Session); session->last_activity = GNUNET_TIME_absolute_get (); session->plugin = plugin; session->is_nat = is_nat; @@ -1055,7 +1928,7 @@ create_session (struct Plugin *plugin, sizeof (struct WelcomeMessage)); pm->msg = (const char *) &pm[1]; pm->message_size = sizeof(struct WelcomeMessage); - memcpy (&pm[1], + GNUNET_memcpy (&pm[1], &plugin->my_welcome, sizeof(struct WelcomeMessage)); pm->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; @@ -1102,7 +1975,7 @@ create_session (struct Plugin *plugin, * @param session for which session should we do this */ static void -process_pending_messages (struct Session *session); +process_pending_messages (struct GNUNET_ATS_Session *session); /** @@ -1121,7 +1994,7 @@ do_transmit (void *cls, size_t size, void *buf) { - struct Session *session = cls; + struct GNUNET_ATS_Session *session = cls; struct GNUNET_PeerIdentity pid; struct Plugin *plugin; struct PendingMessage *pos; @@ -1136,7 +2009,7 @@ do_transmit (void *cls, if (NULL == buf) { LOG (GNUNET_ERROR_TYPE_DEBUG, - "Timeout trying to transmit to peer `%4s', discarding message queue.\n", + "Timeout trying to transmit to peer `%s', discarding message queue.\n", GNUNET_i2s (&session->target)); /* timeout; cancel all messages that have already expired */ hd = NULL; @@ -1154,7 +2027,7 @@ do_transmit (void *cls, GNUNET_assert (pos->message_size <= session->bytes_in_queue); session->bytes_in_queue -= pos->message_size; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Failed to transmit %u byte message to `%4s'.\n", + "Failed to transmit %u byte message to `%s'.\n", pos->message_size, GNUNET_i2s (&session->target)); ret += pos->message_size; @@ -1221,8 +2094,8 @@ do_transmit (void *cls, tcp_plugin_address_to_string (session->plugin, session->address->address, session->address->address_length)); - /* FIXME: this memcpy can be up to 7% of our total runtime */ - memcpy (cbuf, + /* FIXME: this GNUNET_memcpy can be up to 7% of our total runtime */ + GNUNET_memcpy (cbuf, pos->msg, pos->message_size); cbuf += pos->message_size; @@ -1275,7 +2148,7 @@ do_transmit (void *cls, * @param session for which session should we do this */ static void -process_pending_messages (struct Session *session) +process_pending_messages (struct GNUNET_ATS_Session *session) { struct PendingMessage *pm; @@ -1323,7 +2196,7 @@ process_pending_messages (struct Session *session) */ static ssize_t tcp_plugin_send (void *cls, - struct Session *session, + struct GNUNET_ATS_Session *session, const char *msgbuf, size_t msgbuf_size, unsigned int priority, @@ -1337,16 +2210,16 @@ tcp_plugin_send (void *cls, /* create new message entry */ pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size); pm->msg = (const char *) &pm[1]; - memcpy (&pm[1], msgbuf, msgbuf_size); + GNUNET_memcpy (&pm[1], msgbuf, msgbuf_size); pm->message_size = msgbuf_size; pm->timeout = GNUNET_TIME_relative_to_absolute (to); pm->transmit_cont = cont; pm->transmit_cont_cls = cont_cls; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Asked to transmit %u bytes to `%s', added message to list.\n", - msgbuf_size, - GNUNET_i2s (&session->target)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Asked to transmit %u bytes to `%s', added message to list.\n", + msgbuf_size, + GNUNET_i2s (&session->target)); if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap, @@ -1413,7 +2286,7 @@ tcp_plugin_send (void *cls, /** * Closure for #session_lookup_it(). */ -struct SessionItCtx +struct GNUNET_ATS_SessionItCtx { /** * Address we are looking for. @@ -1423,7 +2296,7 @@ struct SessionItCtx /** * Where to store the session (if we found it). */ - struct Session *result; + struct GNUNET_ATS_Session *result; }; @@ -1431,9 +2304,9 @@ struct SessionItCtx /** * Look for a session by address. * - * @param cls the `struct SessionItCtx` + * @param cls the `struct GNUNET_ATS_SessionItCtx` * @param key unused - * @param value a `struct Session` + * @param value a `struct GNUNET_ATS_Session` * @return #GNUNET_YES to continue looking, #GNUNET_NO if we found the session */ static int @@ -1441,8 +2314,8 @@ session_lookup_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value) { - struct SessionItCtx *si_ctx = cls; - struct Session *session = value; + struct GNUNET_ATS_SessionItCtx *si_ctx = cls; + struct GNUNET_ATS_Session *session = value; if (0 != GNUNET_HELLO_address_cmp (si_ctx->address, @@ -1456,14 +2329,12 @@ session_lookup_it (void *cls, /** * Task cleaning up a NAT connection attempt after timeout * - * @param cls the `struct Session` - * @param tc scheduler context (unused) + * @param cls the `struct GNUNET_ATS_Session` */ static void -nat_connect_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +nat_connect_timeout (void *cls) { - struct Session *session = cls; + struct GNUNET_ATS_Session *session = cls; session->nat_connection_timeout = NULL; LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -1489,7 +2360,7 @@ nat_connect_timeout (void *cls, static void tcp_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, - struct Session *session) + struct GNUNET_ATS_Session *session) { reschedule_session_timeout (session); } @@ -1499,14 +2370,12 @@ tcp_plugin_update_session_timeout (void *cls, * Task to signal the server that we can continue * receiving from the TCP client now. * - * @param cls the `struct Session *` - * @param tc task context (unused) + * @param cls the `struct GNUNET_ATS_Session *` */ static void -delayed_done (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +delayed_done (void *cls) { - struct Session *session = cls; + struct GNUNET_ATS_Session *session = cls; session->receive_delay_task = NULL; reschedule_session_timeout (session); @@ -1528,7 +2397,7 @@ delayed_done (void *cls, static void tcp_plugin_update_inbound_delay (void *cls, const struct GNUNET_PeerIdentity *peer, - struct Session *session, + struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay) { if (NULL == session->receive_delay_task) @@ -1554,12 +2423,12 @@ tcp_plugin_update_inbound_delay (void *cls, * @param address the address to use * @return the session if the address is valid, NULL otherwise */ -static struct Session * +static struct GNUNET_ATS_Session * tcp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; - struct Session *session = NULL; + struct GNUNET_ATS_Session *session = NULL; int af; const void *sb; size_t sbs; @@ -1596,7 +2465,7 @@ tcp_plugin_get_session (void *cls, GNUNET_CONTAINER_multipeermap_contains (plugin->sessionmap, &address->peer)) { - struct SessionItCtx si_ctx; + struct GNUNET_ATS_SessionItCtx si_ctx; si_ctx.address = address; si_ctx.result = NULL; @@ -1615,6 +2484,13 @@ tcp_plugin_get_session (void *cls, address->address_length)); return session; } + /* This is a bit of a hack, limiting TCP to never allow more than + one TCP connection to any given peer at the same time. + Without this, peers sometimes disagree about which of the TCP + connections they should use, causing one side to believe that + they transmit successfully, while the other receives nothing. */ + return NULL; /* Refuse to have more than one TCP connection per + peer pair at the same time. */ } if (addrlen == sizeof(struct IPv6TcpAddress)) @@ -1631,7 +2507,7 @@ tcp_plugin_get_session (void *cls, a6.sin6_port = t6->t6_port; if (t6->t6_port == 0) is_natd = GNUNET_YES; - memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr)); + GNUNET_memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr)); sb = &a6; sbs = sizeof(a6); } @@ -1695,6 +2571,8 @@ tcp_plugin_get_session (void *cls, GNUNET_CONTAINER_multipeermap_contains (plugin->nat_wait_conns, &address->peer))) { + struct sockaddr_in local_sa; + LOG (GNUNET_ERROR_TYPE_DEBUG, "Found valid IPv4 NAT address (creating session)!\n"); session = create_session (plugin, @@ -1712,23 +2590,29 @@ tcp_plugin_get_session (void *cls, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); LOG (GNUNET_ERROR_TYPE_DEBUG, - "Created NAT WAIT connection to `%4s' at `%s'\n", + "Created NAT WAIT connection to `%s' at `%s'\n", GNUNET_i2s (&session->target), GNUNET_a2s (sb, sbs)); - if (GNUNET_OK == GNUNET_NAT_run_client (plugin->nat, &a4)) - { + memset (&local_sa, + 0, + sizeof (local_sa)); + local_sa.sin_family = AF_INET; + local_sa.sin_port = htons (plugin->open_port); + /* We leave sin_address at 0, let the kernel figure it out, + even if our bind() is more specific. (May want to reconsider + later.) */ + if (GNUNET_OK == + GNUNET_NAT_request_reversal (plugin->nat, + &local_sa, + &a4)) return session; - } - else - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Running NAT client for `%4s' at `%s' failed\n", - GNUNET_i2s (&session->target), - GNUNET_a2s (sb, sbs)); - tcp_plugin_disconnect_session (plugin, - session); - return NULL; - } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Running NAT client for `%s' at `%s' failed\n", + GNUNET_i2s (&session->target), + GNUNET_a2s (sb, sbs)); + tcp_plugin_disconnect_session (plugin, + session); + return NULL; } /* create new outbound session */ @@ -1778,13 +2662,13 @@ tcp_plugin_get_session (void *cls, if (NULL == sa) { LOG (GNUNET_ERROR_TYPE_DEBUG, - "Failed to create connection to `%4s' at `%s'\n", + "Failed to create connection to `%s' at `%s'\n", GNUNET_i2s (&address->peer), GNUNET_a2s (sb, sbs)); return NULL; } LOG (GNUNET_ERROR_TYPE_DEBUG, - "Asked to transmit to `%4s', creating fresh session using address `%s'.\n", + "Asked to transmit to `%s', creating fresh session using address `%s'.\n", GNUNET_i2s (&address->peer), GNUNET_a2s (sb, sbs)); @@ -1812,7 +2696,7 @@ tcp_plugin_get_session (void *cls, * * @param cls the `struct Plugin *` * @param key the peer which the session belongs to (unused) - * @param value the `struct Session` + * @param value the `struct GNUNET_ATS_Session` * @return #GNUNET_YES (continue to iterate) */ static int @@ -1821,7 +2705,7 @@ session_disconnect_it (void *cls, void *value) { struct Plugin *plugin = cls; - struct Session *session = value; + struct GNUNET_ATS_Session *session = value; GNUNET_STATISTICS_update (session->plugin->env->stats, gettext_noop ("# transport-service disconnect requests for TCP"), @@ -1856,7 +2740,7 @@ tcp_plugin_disconnect (void *cls, struct Plugin *plugin = cls; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting peer `%4s'\n", + "Disconnecting peer `%s'\n", GNUNET_i2s (target)); GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessionmap, target, @@ -1887,6 +2771,9 @@ append_port (void *cls, struct Plugin *plugin = ppc->plugin; char *ret; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "append_port called with hostname `%s'\n", + hostname); if (NULL == hostname) { /* Final call, done */ @@ -1961,7 +2848,7 @@ tcp_plugin_address_pretty_printer (void *cls, memset (&a6, 0, sizeof(a6)); a6.sin6_family = AF_INET6; a6.sin6_port = t6->t6_port; - memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr)); + GNUNET_memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr)); port = ntohs (t6->t6_port); options = ntohl (t6->options); sb = &a6; @@ -1982,6 +2869,9 @@ tcp_plugin_address_pretty_printer (void *cls, else { /* invalid address */ + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Unexpected address length: %u bytes\n"), + (unsigned int) addrlen); asc (asc_cls, NULL, GNUNET_SYSERR); asc (asc_cls, NULL, GNUNET_OK); return; @@ -1996,11 +2886,14 @@ tcp_plugin_address_pretty_printer (void *cls, ppc->asc_cls = asc_cls; ppc->port = port; ppc->options = options; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting DNS reverse lookup\n"); ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, sbs, ! numeric, timeout, - &append_port, ppc); + &append_port, + ppc); if (NULL == ppc->resolver_handle) { GNUNET_break (0); @@ -2013,27 +2906,6 @@ tcp_plugin_address_pretty_printer (void *cls, } -/** - * Check if the given port is plausible (must be either our listen - * port or our advertised port), or any port if we are behind NAT - * and do not have a port open. If it is neither, we return - * #GNUNET_SYSERR. - * - * @param plugin global variables - * @param in_port port number to check - * @return #GNUNET_OK if port is either open_port or adv_port - */ -static int -check_port (struct Plugin *plugin, - uint16_t in_port) -{ - if ( (in_port == plugin->adv_port) || - (in_port == plugin->open_port) ) - return GNUNET_OK; - return GNUNET_SYSERR; -} - - /** * Function that will be called to check if a binary address for this * plugin is well-formed and corresponds to an address for THIS peer @@ -2067,6 +2939,8 @@ tcp_plugin_check_address (void *cls, if (addrlen == sizeof(struct IPv4TcpAddress)) { + struct sockaddr_in s4; + v4 = (const struct IPv4TcpAddress *) addr; if (0 != memcmp (&v4->options, &plugin->myoptions, @@ -2075,17 +2949,24 @@ tcp_plugin_check_address (void *cls, GNUNET_break (0); return GNUNET_SYSERR; } - if (GNUNET_OK != check_port (plugin, - ntohs (v4->t4_port))) - return GNUNET_SYSERR; + memset (&s4, 0, sizeof (s4)); + s4.sin_family = AF_INET; +#if HAVE_SOCKADDR_IN_SIN_LEN + s4.sin_len = sizeof (s4); +#endif + s4.sin_port = v4->t4_port; + s4.sin_addr.s_addr = v4->ipv4_addr; + if (GNUNET_OK != GNUNET_NAT_test_address (plugin->nat, - &v4->ipv4_addr, - sizeof (struct in_addr))) + &s4, + sizeof (struct sockaddr_in))) return GNUNET_SYSERR; } else { + struct sockaddr_in6 s6; + v6 = (const struct IPv6TcpAddress *) addr; if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr)) { @@ -2099,13 +2980,18 @@ tcp_plugin_check_address (void *cls, GNUNET_break (0); return GNUNET_SYSERR; } - if (GNUNET_OK != check_port (plugin, - ntohs (v6->t6_port))) - return GNUNET_SYSERR; + memset (&s6, 0, sizeof (s6)); + s6.sin6_family = AF_INET6; +#if HAVE_SOCKADDR_IN_SIN_LEN + s6.sin6_len = sizeof (s6); +#endif + s6.sin6_port = v6->t6_port; + s6.sin6_addr = v6->ipv6_addr; + if (GNUNET_OK != GNUNET_NAT_test_address (plugin->nat, - &v6->ipv6_addr, - sizeof(struct in6_addr))) + &s6, + sizeof(struct sockaddr_in6))) return GNUNET_SYSERR; } return GNUNET_OK; @@ -2127,7 +3013,7 @@ handle_tcp_nat_probe (void *cls, const struct GNUNET_MessageHeader *message) { struct Plugin *plugin = cls; - struct Session *session; + struct GNUNET_ATS_Session *session; const struct TCP_NAT_ProbeMessage *tcp_nat_probe; size_t alen; void *vaddr; @@ -2147,7 +3033,8 @@ handle_tcp_nat_probe (void *cls, if (ntohs (message->size) != sizeof(struct TCP_NAT_ProbeMessage)) { GNUNET_break_op(0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); return; } @@ -2156,7 +3043,8 @@ handle_tcp_nat_probe (void *cls, sizeof(struct GNUNET_PeerIdentity))) { /* refuse connections from ourselves */ - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); return; } @@ -2166,7 +3054,8 @@ handle_tcp_nat_probe (void *cls, { LOG (GNUNET_ERROR_TYPE_DEBUG, "Did NOT find session for NAT probe!\n"); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_SERVER_receive_done (client, + GNUNET_OK); return; } LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -2223,7 +3112,7 @@ handle_tcp_nat_probe (void *cls, t6 = GNUNET_new (struct IPv6TcpAddress); t6->options = htonl (TCP_OPTIONS_NONE); t6->t6_port = s6->sin6_port; - memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr)); + GNUNET_memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr)); session->address = GNUNET_HELLO_address_allocate (&tcp_nat_probe->clientIdentity, PLUGIN_NAME, &t6, @@ -2235,7 +3124,8 @@ handle_tcp_nat_probe (void *cls, LOG(GNUNET_ERROR_TYPE_DEBUG, "Bad address for incoming connection!\n"); GNUNET_free(vaddr); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); tcp_plugin_disconnect_session (plugin, session); return; @@ -2269,7 +3159,7 @@ handle_tcp_welcome (void *cls, struct Plugin *plugin = cls; const struct WelcomeMessage *wm = (const struct WelcomeMessage *) message; struct GNUNET_HELLO_Address *address; - struct Session *session; + struct GNUNET_ATS_Session *session; size_t alen; void *vaddr; struct IPv4TcpAddress t4; @@ -2290,27 +3180,37 @@ handle_tcp_welcome (void *cls, &alen)) { LOG (GNUNET_ERROR_TYPE_INFO, - "Received WELCOME message from my own identity `%4s' on address `%s'\n", + "Received WELCOME message from my own identity `%s' on address `%s'\n", GNUNET_i2s (&wm->clientIdentity), GNUNET_a2s (vaddr, alen)); - GNUNET_free(vaddr); + GNUNET_free (vaddr); } return; } - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Received WELCOME message from `%4s' %p\n", - GNUNET_i2s (&wm->clientIdentity), - client); + if (GNUNET_OK == + GNUNET_SERVER_client_get_address (client, + &vaddr, + &alen)) + { + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Received WELCOME message from `%s' on address `%s'\n", + GNUNET_i2s (&wm->clientIdentity), + GNUNET_a2s (vaddr, alen)); + GNUNET_free (vaddr); + } GNUNET_STATISTICS_update (plugin->env->stats, gettext_noop ("# TCP WELCOME messages received"), 1, GNUNET_NO); - session = lookup_session_by_client (plugin, client); + session = lookup_session_by_client (plugin, + client); if (NULL != session) { if (GNUNET_OK == - GNUNET_SERVER_client_get_address (client, &vaddr, &alen)) + GNUNET_SERVER_client_get_address (client, + &vaddr, + &alen)) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p for peer `%s'\n", @@ -2343,7 +3243,7 @@ handle_tcp_welcome (void *cls, memset (&t6, '\0', sizeof (t6)); t6.options = htonl (TCP_OPTIONS_NONE); t6.t6_port = s6->sin6_port; - memcpy (&t6.ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr)); + GNUNET_memcpy (&t6.ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr)); address = GNUNET_HELLO_address_allocate (&wm->clientIdentity, PLUGIN_NAME, &t6, @@ -2354,6 +3254,8 @@ handle_tcp_welcome (void *cls, { GNUNET_break (0); GNUNET_free_non_null (vaddr); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); return; } session = create_session (plugin, @@ -2391,15 +3293,17 @@ handle_tcp_welcome (void *cls, LOG(GNUNET_ERROR_TYPE_DEBUG, "Did not obtain TCP socket address for incoming connection\n"); GNUNET_break(0); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); return; } } - if (session->expecting_welcome != GNUNET_YES) + if (GNUNET_YES != session->expecting_welcome) { - GNUNET_break_op(0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - GNUNET_break(0); + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, + GNUNET_SYSERR); return; } session->last_activity = GNUNET_TIME_absolute_get (); @@ -2408,7 +3312,8 @@ handle_tcp_welcome (void *cls, process_pending_messages (session); GNUNET_SERVER_client_set_timeout (client, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_SERVER_receive_done (client, + GNUNET_OK); } @@ -2426,7 +3331,7 @@ handle_tcp_data (void *cls, const struct GNUNET_MessageHeader *message) { struct Plugin *plugin = cls; - struct Session *session; + struct GNUNET_ATS_Session *session; struct GNUNET_TIME_Relative delay; uint16_t type; @@ -2467,7 +3372,9 @@ handle_tcp_data (void *cls, void *vaddr; size_t alen; - GNUNET_SERVER_client_get_address (client, &vaddr, &alen); + GNUNET_SERVER_client_get_address (client, + &vaddr, + &alen); LOG (GNUNET_ERROR_TYPE_ERROR, "Received unexpected %u bytes of type %u from `%s'\n", (unsigned int) ntohs (message->size), @@ -2481,11 +3388,21 @@ handle_tcp_data (void *cls, } session->last_activity = GNUNET_TIME_absolute_get (); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Passing %u bytes of type %u from `%4s' to transport service.\n", - (unsigned int) ntohs (message->size), - (unsigned int) ntohs (message->type), - GNUNET_i2s (&session->target)); + { + void *vaddr; + size_t alen; + + GNUNET_SERVER_client_get_address (client, + &vaddr, + &alen); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Passing %u bytes of type %u from `%s' at %s to transport service.\n", + (unsigned int) ntohs (message->size), + (unsigned int) ntohs (message->type), + GNUNET_i2s (&session->target), + GNUNET_a2s (vaddr, alen)); + GNUNET_free_non_null (vaddr); + } GNUNET_STATISTICS_update (plugin->env->stats, gettext_noop ("# bytes received via TCP"), @@ -2502,17 +3419,21 @@ handle_tcp_data (void *cls, reschedule_session_timeout (session); if (0 == delay.rel_value_us) { - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_SERVER_receive_done (client, + GNUNET_OK); } else { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Throttling receiving from `%s' for %s\n", - GNUNET_i2s (&session->target), - GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Throttling receiving from `%s' for %s\n", + GNUNET_i2s (&session->target), + GNUNET_STRINGS_relative_time_to_string (delay, + GNUNET_YES)); GNUNET_SERVER_disable_receive_done_warning (client); + GNUNET_assert (NULL == session->receive_delay_task); session->receive_delay_task = GNUNET_SCHEDULER_add_delayed (delay, - &delayed_done, session); + &delayed_done, + session); } } @@ -2531,11 +3452,17 @@ connect_notify (void *cls, { struct Plugin *plugin = cls; + if (NULL == client) + return; plugin->cur_connections++; GNUNET_STATISTICS_set (plugin->env->stats, - gettext_noop ("# TCP server connections"), + gettext_noop ("# TCP server connections active"), plugin->cur_connections, GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + gettext_noop ("# TCP server connect events"), + 1, + GNUNET_NO); if (plugin->cur_connections != plugin->max_connections) return; GNUNET_log (GNUNET_ERROR_TYPE_WARNING, @@ -2561,15 +3488,18 @@ disconnect_notify (void *cls, struct GNUNET_SERVER_Client *client) { struct Plugin *plugin = cls; - struct Session *session; + struct GNUNET_ATS_Session *session; if (NULL == client) return; - session = lookup_session_by_client (plugin, client); + GNUNET_assert (plugin->cur_connections >= 1); + plugin->cur_connections--; + session = lookup_session_by_client (plugin, + client); if (NULL == session) return; /* unknown, nothing to do */ LOG (GNUNET_ERROR_TYPE_DEBUG, - "Destroying session of `%4s' with %s due to network-level disconnect.\n", + "Destroying session of `%s' with %s due to network-level disconnect.\n", GNUNET_i2s (&session->target), tcp_plugin_address_to_string (session->plugin, session->address->address, @@ -2583,10 +3513,8 @@ disconnect_notify (void *cls, GNUNET_NO); GNUNET_SERVER_resume (plugin->server); /* Resume server */ } - GNUNET_assert (plugin->cur_connections >= 1); - plugin->cur_connections--; GNUNET_STATISTICS_set (plugin->env->stats, - gettext_noop ("# TCP server connections"), + gettext_noop ("# TCP server connections active"), plugin->cur_connections, GNUNET_NO); GNUNET_STATISTICS_update (session->plugin->env->stats, @@ -2626,7 +3554,7 @@ notify_send_probe (void *cls, return 0; } GNUNET_assert(size >= sizeof(tcp_probe_ctx->message)); - memcpy (buf, + GNUNET_memcpy (buf, &tcp_probe_ctx->message, sizeof(tcp_probe_ctx->message)); GNUNET_SERVER_connect_socket (tcp_probe_ctx->plugin->server, @@ -2698,19 +3626,79 @@ try_connection_reversal (void *cls, */ static enum GNUNET_ATS_Network_Type tcp_plugin_get_network (void *cls, - struct Session *session) + struct GNUNET_ATS_Session *session) { return session->scope; } +/** + * Function obtain the network type for an address. + * + * @param cls closure (`struct Plugin *`) + * @param address the address + * @return the network type + */ +static enum GNUNET_ATS_Network_Type +tcp_plugin_get_network_for_address (void *cls, + const struct GNUNET_HELLO_Address *address) +{ + struct Plugin *plugin = cls; + size_t addrlen; + struct sockaddr_in a4; + struct sockaddr_in6 a6; + const struct IPv4TcpAddress *t4; + const struct IPv6TcpAddress *t6; + const void *sb; + size_t sbs; + + addrlen = address->address_length; + if (addrlen == sizeof(struct IPv6TcpAddress)) + { + GNUNET_assert (NULL != address->address); /* make static analysis happy */ + t6 = address->address; + memset (&a6, 0, sizeof(a6)); +#if HAVE_SOCKADDR_IN_SIN_LEN + a6.sin6_len = sizeof (a6); +#endif + a6.sin6_family = AF_INET6; + a6.sin6_port = t6->t6_port; + GNUNET_memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr)); + sb = &a6; + sbs = sizeof(a6); + } + else if (addrlen == sizeof(struct IPv4TcpAddress)) + { + GNUNET_assert (NULL != address->address); /* make static analysis happy */ + t4 = address->address; + memset (&a4, 0, sizeof(a4)); +#if HAVE_SOCKADDR_IN_SIN_LEN + a4.sin_len = sizeof (a4); +#endif + a4.sin_family = AF_INET; + a4.sin_port = t4->t4_port; + a4.sin_addr.s_addr = t4->ipv4_addr; + sb = &a4; + sbs = sizeof(a4); + } + else + { + GNUNET_break (0); + return GNUNET_ATS_NET_UNSPECIFIED; + } + return plugin->env->get_address_type (plugin->env->cls, + sb, + sbs); +} + + /** * Return information about the given session to the * monitor callback. * * @param cls the `struct Plugin` with the monitor callback (`sic`) * @param peer peer we send information about - * @param value our `struct Session` to send information about + * @param value our `struct GNUNET_ATS_Session` to send information about * @return #GNUNET_OK (continue to iterate) */ static int @@ -2719,7 +3707,7 @@ send_session_info_iter (void *cls, void *value) { struct Plugin *plugin = cls; - struct Session *session = value; + struct GNUNET_ATS_Session *session = value; notify_session_monitor (plugin, session, @@ -2788,7 +3776,7 @@ 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; + struct LEGACY_SERVICE_Context *service; unsigned long long aport; unsigned long long bport; unsigned long long max_connections; @@ -2843,9 +3831,9 @@ libgnunet_plugin_transport_tcp_init (void *cls) aport = 0; if (0 != bport) { - service = GNUNET_SERVICE_start ("transport-tcp", + service = LEGACY_SERVICE_start ("transport-tcp", env->cfg, - GNUNET_SERVICE_OPTION_NONE); + LEGACY_SERVICE_OPTION_NONE); if (NULL == service) { LOG (GNUNET_ERROR_TYPE_WARNING, @@ -2876,7 +3864,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) { #ifdef TCP_STEALTH plugin->myoptions |= TCP_OPTIONS_TCP_STEALTH; - lsocks = GNUNET_SERVICE_get_listen_sockets (service); + lsocks = LEGACY_SERVICE_get_listen_sockets (service); if (NULL != lsocks) { uint32_t len = sizeof (struct WelcomeMessage); @@ -2914,10 +3902,10 @@ libgnunet_plugin_transport_tcp_init (void *cls) if ( (NULL != service) && (GNUNET_SYSERR != (ret_s = - GNUNET_SERVICE_get_server_addresses ("transport-tcp", - env->cfg, - &addrs, - &addrlens)))) + get_server_addresses ("transport-tcp", + env->cfg, + &addrs, + &addrlens)))) { for (ret = ret_s-1; ret >= 0; ret--) LOG (GNUNET_ERROR_TYPE_INFO, @@ -2925,10 +3913,11 @@ libgnunet_plugin_transport_tcp_init (void *cls) GNUNET_a2s (addrs[ret], addrlens[ret])); plugin->nat = GNUNET_NAT_register (env->cfg, - GNUNET_YES, - aport, + "transport-tcp", + IPPROTO_TCP, (unsigned int) ret_s, - (const struct sockaddr **) addrs, addrlens, + (const struct sockaddr **) addrs, + addrlens, &tcp_nat_port_map_callback, &try_connection_reversal, plugin); @@ -2940,8 +3929,8 @@ libgnunet_plugin_transport_tcp_init (void *cls) else { plugin->nat = GNUNET_NAT_register (plugin->env->cfg, - GNUNET_YES, - 0, + "transport-tcp", + IPPROTO_TCP, 0, NULL, NULL, @@ -2961,13 +3950,14 @@ libgnunet_plugin_transport_tcp_init (void *cls) api->address_to_string = &tcp_plugin_address_to_string; api->string_to_address = &tcp_plugin_string_to_address; api->get_network = &tcp_plugin_get_network; + api->get_network_for_address = &tcp_plugin_get_network_for_address; api->update_session_timeout = &tcp_plugin_update_session_timeout; api->update_inbound_delay = &tcp_plugin_update_inbound_delay; api->setup_monitor = &tcp_plugin_setup_monitor; plugin->service = service; if (NULL != service) { - plugin->server = GNUNET_SERVICE_get_server (service); + plugin->server = LEGACY_SERVICE_get_server (service); } else { @@ -2990,7 +3980,9 @@ libgnunet_plugin_transport_tcp_init (void *cls) GNUNET_YES); } plugin->handlers = GNUNET_malloc (sizeof (my_handlers)); - memcpy (plugin->handlers, my_handlers, sizeof(my_handlers)); + GNUNET_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; @@ -3028,7 +4020,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) GNUNET_NAT_unregister (plugin->nat); GNUNET_CONTAINER_multipeermap_destroy (plugin->sessionmap); if (NULL != service) - GNUNET_SERVICE_stop (service); + LEGACY_SERVICE_stop (service); GNUNET_free (plugin); GNUNET_free_non_null (api); return NULL; @@ -3081,10 +4073,10 @@ libgnunet_plugin_transport_tcp_done (void *cls) } if (NULL != plugin->service) - GNUNET_SERVICE_stop (plugin->service); + LEGACY_SERVICE_stop (plugin->service); else GNUNET_SERVER_destroy (plugin->server); - GNUNET_free(plugin->handlers); + GNUNET_free (plugin->handlers); if (NULL != plugin->nat) GNUNET_NAT_unregister (plugin->nat); while (NULL != (tcp_probe = plugin->probe_head)) @@ -3093,7 +4085,7 @@ libgnunet_plugin_transport_tcp_done (void *cls) plugin->probe_tail, tcp_probe); GNUNET_CONNECTION_destroy (tcp_probe->sock); - GNUNET_free(tcp_probe); + GNUNET_free (tcp_probe); } GNUNET_CONTAINER_multipeermap_destroy (plugin->nat_wait_conns); GNUNET_CONTAINER_multipeermap_destroy (plugin->sessionmap);