-/*
- 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 util/network/network.c
- * @brief basic, low-level TCP networking interface
- * @author Christian Grothoff
- *
- * This code is rather complex. Only modify it if you
- * 1) Have a NEW testcase showing that the new code
- * is needed and correct
- * 2) All EXISTING testcases pass with the new code
- * These rules should apply in general, but for this
- * module they are VERY, VERY important.
- *
- * TODO:
- * - can we merge receive_ready and receive_again?
- * - can we integrate the nth.timeout_task with the write_task's timeout?
- */
-
-#include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_connection_lib.h"
-#include "gnunet_scheduler_lib.h"
-
-#define DEBUG_NETWORK GNUNET_NO
-
-/**
- * List of address families to give as hints to
- * getaddrinfo, in reverse order of preference.
- */
-static int address_families[] =
- { AF_INET, AF_INET6, AF_UNSPEC };
-
-struct GNUNET_NETWORK_TransmitHandle
-{
-
- /**
- * Function to call if the send buffer has notify_size
- * bytes available.
- */
- GNUNET_NETWORK_TransmitReadyNotify notify_ready;
-
- /**
- * Closure for notify_ready.
- */
- void *notify_ready_cls;
-
- /**
- * Our socket handle.
- */
- struct GNUNET_NETWORK_ConnectionHandle *sh;
-
- /**
- * Timeout for receiving (in absolute time).
- */
- struct GNUNET_TIME_Absolute transmit_timeout;
-
- /**
- * Task called on timeout.
- */
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
-
- /**
- * At what number of bytes available in the
- * write buffer should the notify method be called?
- */
- size_t notify_size;
-
-};
-
-/**
- * @brief handle for a network socket
- */
-struct GNUNET_NETWORK_ConnectionHandle
-{
-
- /**
- * Scheduler that was used for the connect task.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
- /**
- * Address information for connect (may be NULL).
- */
- struct addrinfo *ai;
-
- /**
- * Index for the next struct addrinfo for connect attempts (may be NULL)
- */
- struct addrinfo *ai_pos;
-
- /**
- * Network address of the other end-point, may be NULL.
- */
- struct sockaddr *addr;
-
- /**
- * Pointer to the hostname if socket was
- * created using DNS lookup, otherwise NULL.
- */
- char *hostname;
-
- /**
- * Pointer to our write buffer.
- */
- char *write_buffer;
-
- /**
- * Size of our write buffer.
- */
- size_t write_buffer_size;
-
- /**
- * Current write-offset in write buffer (where
- * would we write next).
- */
- size_t write_buffer_off;
-
- /**
- * Current read-offset in write buffer (how many
- * bytes have already been send).
- */
- size_t write_buffer_pos;
-
- /**
- * Length of addr.
- */
- socklen_t addrlen;
-
- /**
- * Offset in our address family list
- * that we used last.
- */
- int af_fam_offset;
-
- /**
- * Connect task that we may need to wait for.
- */
- GNUNET_SCHEDULER_TaskIdentifier connect_task;
-
- /**
- * Read task that we may need to wait for.
- */
- GNUNET_SCHEDULER_TaskIdentifier read_task;
-
- /**
- * Write task that we may need to wait for.
- */
- GNUNET_SCHEDULER_TaskIdentifier write_task;
-
- /**
- * The handle we return for GNUNET_CONNECTION_notify_transmit_ready.
- */
- struct GNUNET_NETWORK_TransmitHandle nth;
-
- /**
- * Underlying OS's socket, set to NULL after fatal errors.
- */
- struct GNUNET_NETWORK_Descriptor *sock;
-
- /**
- * Port to connect to.
- */
- uint16_t port;
-
- /**
- * Function to call on data received, NULL
- * if no receive is pending.
- */
- GNUNET_NETWORK_Receiver receiver;
-
- /**
- * Closure for receiver.
- */
- void *receiver_cls;
-
- /**
- * Timeout for receiving (in absolute time).
- */
- struct GNUNET_TIME_Absolute receive_timeout;
-
- /**
- * Maximum number of bytes to read
- * (for receiving).
- */
- size_t max;
-
-};
-
-
-/**
- * Create a socket handle by boxing an existing OS socket. The OS
- * socket should henceforth be no longer used directly.
- * GNUNET_socket_destroy will close it.
- *
- * @param sched scheduler to use
- * @param osSocket existing socket to box
- * @param maxbuf maximum write buffer size for the socket (use
- * 0 for sockets that need no write buffers, such as listen sockets)
- * @return the boxed socket handle
- */
-struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
- *sched, struct GNUNET_NETWORK_Descriptor *osSocket,
- size_t maxbuf)
-{
- struct GNUNET_NETWORK_ConnectionHandle *ret;
- ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_ConnectionHandle) + maxbuf);
- ret->write_buffer = (char *) &ret[1];
- ret->write_buffer_size = maxbuf;
- ret->sock = osSocket;
- ret->sched = sched;
- return ret;
-}
-
-
-/**
- * Create a socket handle by accepting on a listen socket. This
- * function may block if the listen socket has no connection ready.
- *
- * @param sched scheduler to use
- * @param access function to use to check if access is allowed
- * @param access_cls closure for access
- * @param lsock listen socket
- * @param maxbuf maximum write buffer size for the socket (use
- * 0 for sockets that need no write buffers, such as listen sockets)
- * @return the socket handle, NULL on error
- */
-struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
- *sched,
- GNUNET_NETWORK_AccessCheck access,
- void *access_cls, struct GNUNET_NETWORK_Descriptor *lsock,
- size_t maxbuf)
-{
- struct GNUNET_NETWORK_ConnectionHandle *ret;
- char addr[32];
- socklen_t addrlen;
- struct GNUNET_NETWORK_Descriptor *sock;
- int aret;
- struct sockaddr_in *v4;
- struct sockaddr_in6 *v6;
- struct sockaddr *sa;
- void *uaddr;
-
- addrlen = sizeof (addr);
- sock = GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
- if (NULL == sock)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
- return NULL;
- }
-#ifndef MINGW
- if (GNUNET_OK != GNUNET_NETWORK_socket_set_inheritable (sock))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "fcntl");
-#endif
- if (addrlen > sizeof (addr))
- {
- GNUNET_break (0);
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock));
- return NULL;
- }
-
- sa = (struct sockaddr *) addr;
- v6 = (struct sockaddr_in6 *) addr;
- if ((sa->sa_family == AF_INET6) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
- {
- /* convert to V4 address */
- v4 = GNUNET_malloc (sizeof (struct sockaddr_in));
- memset (v4, 0, sizeof (struct sockaddr_in));
- v4->sin_family = AF_INET;
- memcpy (&v4->sin_addr,
- &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -
- sizeof (struct in_addr)],
- sizeof (struct in_addr));
- v4->sin_port = v6->sin6_port;
- uaddr = v4;
- addrlen = sizeof (struct sockaddr_in);
- }
- else
- {
- uaddr = GNUNET_malloc (addrlen);
- memcpy (uaddr, addr, addrlen);
- }
-
- if ((access != NULL) &&
- (GNUNET_YES != (aret = access (access_cls, uaddr, addrlen))))
- {
- if (aret == GNUNET_NO)
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Access denied to `%s'\n"),
- GNUNET_a2s(uaddr, addrlen));
- GNUNET_break (0 == GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock));
- GNUNET_free (uaddr);
- return NULL;
- }
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Accepting connection from `%s'\n"),
- GNUNET_a2s(uaddr, addrlen));
-#endif
- ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_ConnectionHandle) + maxbuf);
- ret->write_buffer = (char *) &ret[1];
- ret->write_buffer_size = maxbuf;
- ret->addr = uaddr;
- ret->addrlen = addrlen;
- ret->sock = sock;
- ret->sched = sched;
- return ret;
-}
-
-/**
- * Obtain the network address of the other party.
- *
- * @param sock the client to get the address for
- * @param addr where to store the address
- * @param addrlen where to store the length of the address
- * @return GNUNET_OK on success
- */
-int
-GNUNET_CONNECTION_get_address (struct GNUNET_NETWORK_ConnectionHandle *sock,
- void **addr, size_t * addrlen)
-{
- if ((sock->addr == NULL) || (sock->addrlen == 0))
- return GNUNET_NO;
- *addr = GNUNET_malloc (sock->addrlen);
- memcpy (*addr, sock->addr, sock->addrlen);
- *addrlen = sock->addrlen;
- return GNUNET_OK;
-}
-
-/**
- * Perform a DNS lookup for the hostname associated
- * with the current socket, iterating over the address
- * families as specified in the "address_families" array.
- */
-static void
-try_lookup (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- struct addrinfo hints;
- int ec;
-
- while ( (sock->ai_pos == NULL) &&
- (sock->af_fam_offset > 0) )
- {
- if (sock->ai != NULL)
- freeaddrinfo (sock->ai);
- memset (&hints, 0, sizeof (hints));
- hints.ai_family = address_families[--sock->af_fam_offset];
- hints.ai_socktype = SOCK_STREAM;
- if (0 != (ec = getaddrinfo (sock->hostname, NULL, &hints, &sock->ai)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
- "`%s' failed for hostname `%s': %s\n",
- "getaddrinfo", sock->hostname, gai_strerror (ec));
- sock->ai = NULL;
- }
- sock->ai_pos = sock->ai;
- }
-}
-
-
-/**
- * Initiate asynchronous TCP connect request.
- *
- * @param sock what socket to connect
- * @return GNUNET_SYSERR error (no more addresses to try)
- */
-static int
-try_connect (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- struct GNUNET_NETWORK_Descriptor *s;
-
- if (sock->addr != NULL)
- {
- GNUNET_free (sock->addr);
- sock->addr = NULL;
- sock->addrlen = 0;
- }
- while (1)
- {
- if (sock->ai_pos == NULL)
- try_lookup (sock);
- if (sock->ai_pos == NULL)
- {
- /* no more addresses to try, fatal! */
- return GNUNET_SYSERR;
- }
- switch (sock->ai_pos->ai_family)
- {
- case AF_INET:
- ((struct sockaddr_in *) sock->ai_pos->ai_addr)->sin_port =
- htons (sock->port);
- break;
- case AF_INET6:
- ((struct sockaddr_in6 *) sock->ai_pos->ai_addr)->sin6_port =
- htons (sock->port);
- break;
- default:
- sock->ai_pos = sock->ai_pos->ai_next;
- continue;
- }
- s = GNUNET_NETWORK_socket_socket (sock->ai_pos->ai_family, SOCK_STREAM, 0);
- if (s == NULL)
- {
- /* maybe unsupported address family, try next */
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "socket");
- sock->ai_pos = sock->ai_pos->ai_next;
- continue;
- }
-#ifndef MINGW
- if (GNUNET_OK != GNUNET_NETWORK_socket_set_inheritable (s))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "GNUNET_NETWORK_socket_set_inheritable");
-#endif
- if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (s, GNUNET_NO))
- {
- /* we'll treat this one as fatal */
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (s));
- return GNUNET_SYSERR;
- }
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Trying to connect to `%s'\n"),
- GNUNET_a2s(sock->ai_pos->ai_addr,
- sock->ai_pos->ai_addrlen));
-#endif
- if ((0 != GNUNET_NETWORK_socket_connect (s,
- sock->ai_pos->ai_addr,
- sock->ai_pos->ai_addrlen)) && (errno != EINPROGRESS))
- {
- /* maybe refused / unsupported address, try next */
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (s));
- sock->ai_pos = sock->ai_pos->ai_next;
- continue;
- }
- break;
- }
- /* got one! copy address information! */
- sock->addrlen = sock->ai_pos->ai_addrlen;
- sock->addr = GNUNET_malloc (sock->addrlen);
- memcpy (sock->addr, sock->ai_pos->ai_addr, sock->addrlen);
- sock->ai_pos = sock->ai_pos->ai_next;
- sock->sock = s;
- return GNUNET_OK;
-}
-
-
-/**
- * Scheduler let us know that we're either ready to
- * write on the socket OR connect timed out. Do the
- * right thing.
- */
-static void
-connect_continuation (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sock = cls;
- unsigned int len;
- int error;
-
- /* nobody needs to wait for us anymore... */
- sock->connect_task = GNUNET_SCHEDULER_NO_TASK;
- /* Note: write-ready does NOT mean connect succeeded,
- we need to use getsockopt to be sure */
- len = sizeof (error);
- errno = 0;
- error = 0;
- if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
- (0 != GNUNET_NETWORK_socket_getsockopt (sock->sock, SOL_SOCKET, SO_ERROR, &error, &len)) ||
- (error != 0) || (errno != 0))
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to establish TCP connection to `%s'\n",
- GNUNET_a2s(sock->addr, sock->addrlen));
-#endif
- /* connect failed / timed out */
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock->sock));
- sock->sock = NULL;
- if (GNUNET_SYSERR == try_connect (sock))
- {
- /* failed for good */
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to establish TCP connection, no further addresses to try.\n");
-#endif
- /* connect failed / timed out */
- GNUNET_break (sock->ai_pos == NULL);
- freeaddrinfo (sock->ai);
- sock->ai = NULL;
- return;
- }
- sock->connect_task = GNUNET_SCHEDULER_add_write_net (tc->sched, GNUNET_NO, /* abort on shutdown */
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
- sock->sock,
- &connect_continuation,
- sock);
- return;
- }
- /* connect succeeded! clean up "ai" */
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection to `%s' succeeded!\n",
- GNUNET_a2s(sock->addr, sock->addrlen));
-#endif
- freeaddrinfo (sock->ai);
- sock->ai_pos = NULL;
- sock->ai = NULL;
-}
-
-
-/**
- * Create a socket handle by (asynchronously) connecting to a host.
- * This function returns immediately, even if the connection has not
- * yet been established. This function only creates TCP connections.
- *
- * @param sched scheduler to use
- * @param hostname name of the host to connect to
- * @param port port to connect to
- * @param maxbuf maximum write buffer size for the socket (use
- * 0 for sockets that need no write buffers, such as listen sockets)
- * @return the socket handle
- */
-struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle
- *sched, const char *hostname,
- uint16_t port, size_t maxbuf)
-{
- struct GNUNET_NETWORK_ConnectionHandle *ret;
-
- ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_ConnectionHandle) + maxbuf);
- ret->sock = NULL;
- ret->sched = sched;
- ret->write_buffer = (char *) &ret[1];
- ret->write_buffer_size = maxbuf;
- ret->port = port;
- ret->af_fam_offset = sizeof (address_families) / sizeof(address_families[0]);
- ret->hostname = GNUNET_strdup (hostname);
- if (GNUNET_SYSERR == try_connect (ret))
- {
- if (NULL != ret->ai)
- freeaddrinfo (ret->ai);
- GNUNET_free (ret->hostname);
- GNUNET_free (ret);
- return NULL;
- }
- ret->connect_task = GNUNET_SCHEDULER_add_write_net (sched, GNUNET_NO, /* abort on shutdown */
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
- ret->sock,
- &connect_continuation, ret);
- return ret;
-
-}
-
-
-/**
- * Create a socket handle by (asynchronously) connecting to a host.
- * This function returns immediately, even if the connection has not
- * yet been established. This function only creates TCP connections.
- *
- * @param sched scheduler to use
- * @param af_family address family to use
- * @param serv_addr server address
- * @param addrlen length of server address
- * @param maxbuf maximum write buffer size for the socket (use
- * 0 for sockets that need no write buffers, such as listen sockets)
- * @return the socket handle
- */
-struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
- *sched, int af_family,
- const struct sockaddr *serv_addr,
- socklen_t addrlen, size_t maxbuf)
-{
- struct GNUNET_NETWORK_Descriptor *s;
- struct GNUNET_NETWORK_ConnectionHandle *ret;
-
- s = GNUNET_NETWORK_socket_socket (af_family, SOCK_STREAM, 0);
- if (s == NULL)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
- GNUNET_ERROR_TYPE_BULK, "socket");
- return NULL;
- }
-#ifndef MINGW
-#if 0
- // FIXME NILS
- if (0 != fcntl (s, F_SETFD, fcntl (s, F_GETFD) | FD_CLOEXEC))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "fcntl");
-#endif
-#endif
- if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (s, GNUNET_NO))
- {
- /* we'll treat this one as fatal */
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (s));
- return NULL;
- }
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Trying to connect to `%s'\n"),
- GNUNET_a2s(serv_addr, addrlen));
-#endif
- if ((0 != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) && (errno != EINPROGRESS))
- {
- /* maybe refused / unsupported address, try next */
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (s));
- return NULL;
- }
- ret = GNUNET_CONNECTION_create_from_existing (sched, s, maxbuf);
- ret->addr = GNUNET_malloc (addrlen);
- memcpy (ret->addr, serv_addr, addrlen);
- ret->addrlen = addrlen;
- return ret;
-}
-
-
-/**
- * Check if socket is valid (no fatal errors have happened so far).
- * Note that a socket that is still trying to connect is considered
- * valid.
- *
- * @param sock socket to check
- * @return GNUNET_YES if valid, GNUNET_NO otherwise
- */
-int
-GNUNET_CONNECTION_check (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- if (sock->ai != NULL)
- return GNUNET_YES; /* still trying to connect */
- return (sock->sock == NULL) ? GNUNET_NO : GNUNET_YES;
-}
-
-
-/**
- * Scheduler let us know that the connect task is finished (or was
- * cancelled due to shutdown). Now really clean up.
- */
-static void
-destroy_continuation (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sock = cls;
- GNUNET_NETWORK_TransmitReadyNotify notify;
-
- if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sock->write_task,
- &destroy_continuation, sock);
- return;
- }
- if (sock->sock != NULL)
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down socket.\n");
-#endif
- GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
- }
- if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sock->read_task,
- &destroy_continuation, sock);
- return;
- }
- if (NULL != (notify = sock->nth.notify_ready))
- {
- sock->nth.notify_ready = NULL;
- notify (sock->nth.notify_ready_cls, 0, NULL);
- if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
- sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- }
- if (sock->sock != NULL)
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock->sock));
- GNUNET_free_non_null (sock->addr);
- if (sock->ai != NULL)
- freeaddrinfo (sock->ai);
- GNUNET_free_non_null (sock->hostname);
- GNUNET_free (sock);
-}
-
-
-/**
- * Close the socket and free associated resources. Pending
- * transmissions are simply dropped. A pending receive call will be
- * called with an error code of "EPIPE".
- *
- * @param sock socket to destroy
- */
-void
-GNUNET_CONNECTION_destroy (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- if (sock->write_buffer_off == 0)
- sock->ai_pos = NULL; /* if we're still trying to connect and have
- no message pending, stop trying! */
- GNUNET_assert (sock->sched != NULL);
- GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sock->connect_task,
- &destroy_continuation, sock);
-}
-
-/**
- * Tell the receiver callback that a timeout was reached.
- */
-static void
-signal_timeout (struct GNUNET_NETWORK_ConnectionHandle *sh)
-{
- GNUNET_NETWORK_Receiver receiver;
-
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Network signals time out to receiver!\n");
-#endif
- GNUNET_assert (NULL != (receiver = sh->receiver));
- sh->receiver = NULL;
- receiver (sh->receiver_cls, NULL, 0, NULL, 0, 0);
-}
-
-
-/**
- * Tell the receiver callback that we had an IO error.
- */
-static void
-signal_error (struct GNUNET_NETWORK_ConnectionHandle *sh, int errcode)
-{
- GNUNET_NETWORK_Receiver receiver;
- GNUNET_assert (NULL != (receiver = sh->receiver));
- sh->receiver = NULL;
- receiver (sh->receiver_cls, NULL, 0, sh->addr, sh->addrlen, errcode);
-}
-
-
-/**
- * This function is called once we either timeout
- * or have data ready to read.
- */
-static void
-receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sh = cls;
- struct GNUNET_TIME_Absolute now;
- char buffer[sh->max];
- ssize_t ret;
- GNUNET_NETWORK_Receiver receiver;
-
- sh->read_task = GNUNET_SCHEDULER_NO_TASK;
- now = GNUNET_TIME_absolute_get ();
- if ((now.value > sh->receive_timeout.value) ||
- (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
- (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error: time out...\n");
-#endif
- signal_timeout (sh);
- return;
- }
- if (sh->sock == NULL)
- {
- /* connect failed for good */
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error, socket closed...\n");
-#endif
- signal_error (sh, ECONNREFUSED);
- return;
- }
- GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, sh->sock));
-RETRY:
- ret = GNUNET_NETWORK_socket_recv (sh->sock, buffer, sh->max,
-#ifndef MINGW
- // FIXME MINGW
- MSG_DONTWAIT
-#else
- 0
-#endif
- );
- if (ret == -1)
- {
- if (errno == EINTR)
- goto RETRY;
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Error receiving: %s\n", STRERROR (errno));
-#endif
- signal_error (sh, errno);
- return;
- }
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "receive_ready read %u/%u bytes from `%s'!\n",
- (unsigned int) ret,
- sh->max,
- GNUNET_a2s(sh->addr, sh->addrlen));
-#endif
- GNUNET_assert (NULL != (receiver = sh->receiver));
- sh->receiver = NULL;
- receiver (sh->receiver_cls, buffer, ret, sh->addr, sh->addrlen, 0);
-}
-
-
-/**
- * This function is called after establishing a connection either has
- * succeeded or timed out. Note that it is possible that the attempt
- * timed out and that we're immediately retrying. If we are retrying,
- * we need to wait again (or timeout); if we succeeded, we need to
- * wait for data (or timeout).
- */
-static void
-receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sh = cls;
- struct GNUNET_TIME_Absolute now;
-
- sh->read_task = GNUNET_SCHEDULER_NO_TASK;
- if ((sh->sock == NULL) &&
- (sh->connect_task == GNUNET_SCHEDULER_NO_TASK))
- {
- /* not connected and no longer trying */
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error, socket closed...\n");
-#endif
- signal_error (sh, ECONNREFUSED);
- return;
- }
- now = GNUNET_TIME_absolute_get ();
- if ((now.value > sh->receive_timeout.value) ||
- (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error: time out...\n");
-#endif
- signal_timeout (sh);
- return;
- }
- if (sh->connect_task != GNUNET_SCHEDULER_NO_TASK)
- {
- /* connect was retried */
- sh->read_task = GNUNET_SCHEDULER_add_after (tc->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sh->connect_task,
- &receive_again, sh);
- return;
- }
- /* connect succeeded, wait for data! */
- sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sh->connect_task,
- GNUNET_TIME_absolute_get_remaining
- (sh->receive_timeout),
- sh->sock, &receive_ready,
- sh);
-}
-
-
-/**
- * Receive data from the given socket. Note that this function will
- * call "receiver" asynchronously using the scheduler. It will
- * "immediately" return. Note that there MUST only be one active
- * receive call per socket at any given point in time (so do not
- * call receive again until the receiver callback has been invoked).
- *
- * @param sched scheduler to use
- * @param sock socket handle
- * @param max maximum number of bytes to read
- * @param timeout maximum amount of time to wait (use -1 for "forever")
- * @param receiver function to call with received data
- * @param receiver_cls closure for receiver
- * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_TASK on error
- */
-GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_CONNECTION_receive (struct GNUNET_NETWORK_ConnectionHandle *sock,
- size_t max,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
-{
- struct GNUNET_SCHEDULER_TaskContext tc;
-
- GNUNET_assert ((sock->read_task == GNUNET_SCHEDULER_NO_TASK) &&
- (sock->receiver == NULL));
- sock->receiver = receiver;
- sock->receiver_cls = receiver_cls;
- sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
- sock->max = max;
- memset (&tc, 0, sizeof (tc));
- tc.sched = sock->sched;
- tc.reason = GNUNET_SCHEDULER_REASON_PREREQ_DONE;
- receive_again (sock, &tc);
- return sock->read_task;
-}
-
-
-/**
- * Cancel receive job on the given socket. Note that the
- * receiver callback must not have been called yet in order
- * for the cancellation to be valid.
- *
- * @param sock socket handle
- * @param task task identifier returned from the receive call
- * @return closure of the original receiver callback
- */
-void *
-GNUNET_CONNECTION_receive_cancel (struct GNUNET_NETWORK_ConnectionHandle *sock,
- GNUNET_SCHEDULER_TaskIdentifier task)
-{
- GNUNET_assert (sock->read_task == task);
- GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched, task));
- sock->read_task = GNUNET_SCHEDULER_NO_TASK;
- sock->receiver = NULL;
- return sock->receiver_cls;
-}
-
-
-/**
- * Try to call the transmit notify method (check if we do
- * have enough space available first)!
- *
- * @param sock socket for which we should do this processing
- * @return GNUNET_YES if we were able to call notify
- */
-static int
-process_notify (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- size_t used;
- size_t avail;
- size_t size;
- GNUNET_NETWORK_TransmitReadyNotify notify;
-
- GNUNET_assert (sock->write_task == GNUNET_SCHEDULER_NO_TASK);
- if (NULL == (notify = sock->nth.notify_ready))
- return GNUNET_NO;
- used = sock->write_buffer_off - sock->write_buffer_pos;
- avail = sock->write_buffer_size - used;
- size = sock->nth.notify_size;
- if (sock->nth.notify_size > avail)
- return GNUNET_NO;
- sock->nth.notify_ready = NULL;
- if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
- sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- if (sock->write_buffer_size - sock->write_buffer_off < size)
- {
- /* need to compact */
- memmove (sock->write_buffer,
- &sock->write_buffer[sock->write_buffer_pos], used);
- sock->write_buffer_off -= sock->write_buffer_pos;
- sock->write_buffer_pos = 0;
- }
- GNUNET_assert (sock->write_buffer_size - sock->write_buffer_off >= size);
- size = notify (sock->nth.notify_ready_cls,
- sock->write_buffer_size - sock->write_buffer_off,
- &sock->write_buffer[sock->write_buffer_off]);
- sock->write_buffer_off += size;
- return GNUNET_YES;
-}
-
-
-/**
- * Task invoked by the scheduler when a call to transmit
- * is timing out (we never got enough buffer space to call
- * the callback function before the specified timeout
- * expired).
- *
- * This task notifies the client about the timeout.
- */
-static void
-transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sock = cls;
- GNUNET_NETWORK_TransmitReadyNotify notify;
-
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmit fails, time out reached.\n");
-#endif
- notify = sock->nth.notify_ready;
- sock->nth.notify_ready = NULL;
- notify (sock->nth.notify_ready_cls, 0, NULL);
-}
-
-
-static void
-transmit_error (struct GNUNET_NETWORK_ConnectionHandle *sock)
-{
- if (sock->nth.notify_ready == NULL)
- return; /* nobody to tell about it */
- if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
- sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- transmit_timeout (sock, NULL);
-}
-
-
-/**
- * See if we are now connected. If not, wait longer for
- * connect to succeed. If connected, we should be able
- * to write now as well, unless we timed out.
- */
-static void
-transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct GNUNET_NETWORK_ConnectionHandle *sock = cls;
- ssize_t ret;
- size_t have;
-
- GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_TASK);
- sock->write_task = GNUNET_SCHEDULER_NO_TASK;
- if (sock->connect_task != GNUNET_SCHEDULER_NO_TASK)
- {
- /* still waiting for connect */
- GNUNET_assert (sock->write_task ==
- GNUNET_SCHEDULER_NO_TASK);
- sock->write_task =
- GNUNET_SCHEDULER_add_delayed (tc->sched, GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sock->connect_task,
- GNUNET_TIME_UNIT_ZERO, &transmit_ready,
- sock);
- return;
- }
- if ( (sock->sock == NULL) ||
- ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) &&
- (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) &&
- (!GNUNET_NETWORK_fdset_isset (tc->write_ready, sock->sock))) )
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Could not satisfy pending transmission request, socket closed or connect failed.\n"));
-#endif
- if (NULL != sock->sock)
- {
- GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock->sock));
- sock->sock = NULL;
- }
- transmit_error (sock);
- return; /* connect failed for good, we're finished */
- }
- if ((tc->write_ready == NULL) || (!GNUNET_NETWORK_fdset_isset (tc->write_ready, sock->sock)))
- {
- /* special circumstances (in particular,
- PREREQ_DONE after connect): not yet ready to write,
- but no "fatal" error either. Hence retry. */
- goto SCHEDULE_WRITE;
- }
- GNUNET_assert (sock->write_buffer_off >= sock->write_buffer_pos);
- process_notify (sock);
- have = sock->write_buffer_off - sock->write_buffer_pos;
- if (have == 0)
- {
- /* no data ready for writing, terminate write loop */
- return;
- }
-RETRY:
- ret = GNUNET_NETWORK_socket_send (sock->sock,
- &sock->write_buffer[sock->write_buffer_pos],
- have,
-#ifndef MINGW
- // FIXME NILS
- MSG_DONTWAIT | MSG_NOSIGNAL
-#else
- 0
-#endif
- );
- if (ret == -1)
- {
- if (errno == EINTR)
- goto RETRY;
-#if DEBUG_NETWORK
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
-#endif
- GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sock->sock));
- sock->sock = NULL;
- transmit_error (sock);
- return;
- }
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "transmit_ready transmitted %u/%u bytes to `%s'\n",
- (unsigned int) ret,
- have,
- GNUNET_a2s(sock->addr, sock->addrlen));
-#endif
- sock->write_buffer_pos += ret;
- if (sock->write_buffer_pos == sock->write_buffer_off)
- {
- /* transmitted all pending data */
- sock->write_buffer_pos = 0;
- sock->write_buffer_off = 0;
- }
- if ((sock->write_buffer_off == 0) && (NULL == sock->nth.notify_ready))
- return; /* all data sent! */
- /* not done writing, schedule more */
-SCHEDULE_WRITE:
- if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
- sock->write_task =
- GNUNET_SCHEDULER_add_write_net (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
- sock->sock, &transmit_ready, sock);
-}
-
-
-/**
- * Ask the socket to call us once the specified number of bytes
- * are free in the transmission buffer. May call the notify
- * method immediately if enough space is available.
- *
- * @param sock socket
- * @param size number of bytes to send
- * @param timeout after how long should we give up (and call
- * notify with buf NULL and size 0)?
- * @param notify function to call
- * @param notify_cls closure for notify
- * @return non-NULL if the notify callback was queued,
- * NULL if we are already going to notify someone else (busy)
- */
-struct GNUNET_NETWORK_TransmitHandle *
-GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_NETWORK_ConnectionHandle
- *sock, size_t size,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_NETWORK_TransmitReadyNotify
- notify, void *notify_cls)
-{
- if (sock->nth.notify_ready != NULL)
- return NULL;
- GNUNET_assert (notify != NULL);
- GNUNET_assert (sock->write_buffer_size >= size);
-
- if ((sock->sock == NULL) &&
- (sock->connect_task == GNUNET_SCHEDULER_NO_TASK))
- {
-#if DEBUG_NETWORK
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission request of size %u fails, connection failed.\n",
- size);
-#endif
- notify (notify_cls, 0, NULL);
- return &sock->nth;
- }
- GNUNET_assert (sock->write_buffer_off <= sock->write_buffer_size);
- GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
- GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_off);
- sock->nth.notify_ready = notify;
- sock->nth.notify_ready_cls = notify_cls;
- sock->nth.sh = sock;
- sock->nth.notify_size = size;
- sock->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
- sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- timeout,
- &transmit_timeout,
- sock);
- if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
- {
- if (sock->connect_task == GNUNET_SCHEDULER_NO_TASK)
- sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
- sock->sock,
- &transmit_ready, sock);
- else
- sock->write_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- sock->connect_task,
- GNUNET_TIME_UNIT_ZERO,
- &transmit_ready, sock);
- }
- return &sock->nth;
-}
-
-
-/**
- * Cancel the specified transmission-ready
- * notification.
- */
-void
-GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
- GNUNET_NETWORK_TransmitHandle *h)
-{
- GNUNET_assert (h->notify_ready != NULL);
- GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
- h->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- h->notify_ready = NULL;
-}
-
-
-#if 0 /* keep Emacsens' auto-indent happy */
-{
-#endif
-#ifdef __cplusplus
-}
-#endif
+/*\r
+ This file is part of GNUnet.\r
+ (C) 2009 Christian Grothoff (and other contributing authors)\r
+\r
+ GNUnet is free software; you can redistribute it and/or modify\r
+ it under the terms of the GNU General Public License as published\r
+ by the Free Software Foundation; either version 2, or (at your\r
+ option) any later version.\r
+\r
+ GNUnet is distributed in the hope that it will be useful, but\r
+ WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
+ General Public License for more details.\r
+\r
+ You should have received a copy of the GNU General Public License\r
+ along with GNUnet; see the file COPYING. If not, write to the\r
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
+ Boston, MA 02111-1307, USA.\r
+*/\r
+\r
+/**\r
+ * @file util/network.c\r
+ * @brief basic, low-level networking interface\r
+ * @author Nils Durner\r
+ */\r
+\r
+#include "platform.h"\r
+#include "gnunet_disk_lib.h"\r
+#include "disk.h"\r
+#include "gnunet_container_lib.h"\r
+\r
+#define DEBUG_SOCK GNUNET_NO\r
+\r
+struct GNUNET_NETWORK_Handle\r
+{\r
+ int fd;\r
+};\r
+\r
+struct GNUNET_NETWORK_FDSet\r
+{\r
+ /* socket descriptors */\r
+ int nsds;\r
+ fd_set sds;\r
+#ifdef WINDOWS\r
+ /* handles */\r
+ struct GNUNET_CONTAINER_SList *handles;\r
+#endif\r
+};\r
+\r
+#ifndef FD_COPY\r
+#define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))\r
+#endif\r
+\r
+/**\r
+ * accept a new connection on a socket\r
+ *\r
+ * @param desc bound socket\r
+ * @param address address of the connecting peer, may be NULL\r
+ * @param address_len length of address\r
+ * @return client socket\r
+ */\r
+struct GNUNET_NETWORK_Handle *\r
+GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,\r
+ struct sockaddr *address,\r
+ socklen_t * address_len)\r
+{\r
+ struct GNUNET_NETWORK_Handle *ret;\r
+\r
+ ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
+ ret->fd = accept (desc->fd, address, address_len);\r
+#ifdef MINGW\r
+ if (INVALID_SOCKET == ret->fd)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * Bind to a connected socket\r
+ * @param desc socket\r
+ * @param address address to be bound\r
+ * @param address_len length of address\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,\r
+ const struct sockaddr *address,\r
+ socklen_t address_len)\r
+{\r
+ int ret;\r
+\r
+ ret = bind (desc->fd, address, address_len);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Set if a socket should use blocking or non-blocking IO.\r
+ * @param fd socket\r
+ * @param doBlock blocking mode\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,\r
+ int doBlock)\r
+{\r
+#if MINGW\r
+ u_long mode;\r
+ mode = !doBlock;\r
+ if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)\r
+ {\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");\r
+ return GNUNET_SYSERR;\r
+ }\r
+ return GNUNET_OK;\r
+\r
+#else\r
+ /* not MINGW */\r
+ int flags = fcntl (fd->fd, F_GETFL);\r
+ if (flags == -1)\r
+ {\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
+ return GNUNET_SYSERR;\r
+ }\r
+ if (doBlock)\r
+ flags &= ~O_NONBLOCK;\r
+ else\r
+ flags |= O_NONBLOCK;\r
+ if (0 != fcntl (fd->fd, F_SETFL, flags))\r
+ {\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
+ return GNUNET_SYSERR;\r
+ }\r
+ return GNUNET_OK;\r
+#endif\r
+}\r
+\r
+/**\r
+ * Close a socket\r
+ * @param desc socket\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)\r
+{\r
+ int ret;\r
+#ifdef MINGW\r
+ ret = closesocket (desc->fd);\r
+ if (SOCKET_ERROR != ret)\r
+ GNUNET_free (desc);\r
+ else\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#else\r
+ /* FIXME: Nils, this is very strange code here... */\r
+ ret = close (desc->fd);\r
+ if (0 == ret)\r
+ GNUNET_free (desc);\r
+#endif\r
+\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Connect a socket\r
+ * @param desc socket\r
+ * @param address peer address\r
+ * @param address_len length of address\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,\r
+ const struct sockaddr *address,\r
+ socklen_t address_len)\r
+{\r
+ int ret;\r
+\r
+ ret = connect (desc->fd, address, address_len);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ {\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+ if (errno == EWOULDBLOCK)\r
+ errno = EINPROGRESS;\r
+ }\r
+#endif\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Get socket options\r
+ * @param desc socket\r
+ * @param level protocol level of the option\r
+ * @param optname identifier of the option\r
+ * @param optval options\r
+ * @param optlen length of optval\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,\r
+ int level, int optname, void *optval,\r
+ socklen_t * optlen)\r
+{\r
+ int ret;\r
+\r
+ ret = getsockopt (desc->fd, level, optname, optval, optlen);\r
+#ifdef MINGW\r
+ if (ret == 0 && level == SOL_SOCKET && optname == SO_ERROR)\r
+ *((int *) optval) = GetErrnoFromWinsockError (*((int *) optval));\r
+ else if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Listen on a socket\r
+ * @param desc socket\r
+ * @param backlog length of the listen queue\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,\r
+ int backlog)\r
+{\r
+ int ret;\r
+\r
+ ret = listen (desc->fd, backlog);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Read data from a connected socket\r
+ * @param desc socket\r
+ * @param buffer buffer\r
+ * @param length length of buffer\r
+ * @param flags type of message reception\r
+ */\r
+ssize_t\r
+GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,\r
+ void *buffer, size_t length, int flags)\r
+{\r
+ int ret;\r
+\r
+ ret = recv (desc->fd, buffer, length, flags);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * Send data\r
+ * @param desc socket\r
+ * @param buffer data to send\r
+ * @param length size of the buffer\r
+ * @param flags type of message transmission\r
+ * @return number of bytes sent, GNUNET_SYSERR on error\r
+ */\r
+ssize_t\r
+GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,\r
+ const void *buffer, size_t length, int flags)\r
+{\r
+ int ret;\r
+\r
+ ret = send (desc->fd, buffer, length, flags);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * Send data\r
+ * @param desc socket\r
+ * @param message data to send\r
+ * @param length size of the data\r
+ * @param flags type of message transmission\r
+ * @param dest_addr destination address\r
+ * @param dest_len length of address\r
+ * @return number of bytes sent, GNUNET_SYSERR on error\r
+ */\r
+ssize_t\r
+GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,\r
+ const void *message, size_t length, int flags,\r
+ const struct sockaddr * dest_addr,\r
+ socklen_t dest_len)\r
+{\r
+ int ret;\r
+\r
+ ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * Set socket option\r
+ * @param fd socket\r
+ * @param level protocol level of the option\r
+ * @param option_name option identifier\r
+ * @param option_value value to set\r
+ * @param option_len size of option_value\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,\r
+ int level, int option_name,\r
+ const void *option_value,\r
+ socklen_t option_len)\r
+{\r
+ int ret;\r
+\r
+ ret = setsockopt (fd->fd, level, option_name, option_value, option_len);\r
+#ifdef MINGW\r
+ if (SOCKET_ERROR == ret)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Create a new socket\r
+ * @param domain domain of the socket\r
+ * @param type socket type\r
+ * @param protocol network protocol\r
+ * @return new socket, NULL on error\r
+ */\r
+struct GNUNET_NETWORK_Handle *\r
+GNUNET_NETWORK_socket_socket (int domain, int type, int protocol)\r
+{\r
+ struct GNUNET_NETWORK_Handle *ret;\r
+\r
+ ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
+ ret->fd = socket (domain, type, protocol);\r
+#ifdef MINGW\r
+ if (INVALID_SOCKET == ret->fd)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ if (ret->fd < 0)\r
+ {\r
+ GNUNET_free (ret);\r
+ ret = NULL;\r
+ }\r
+\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * Shut down socket operations\r
+ * @param desc socket\r
+ * @param how type of shutdown\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,\r
+ int how)\r
+{\r
+ int ret;\r
+\r
+ ret = shutdown (desc->fd, how);\r
+#ifdef MINGW\r
+ if (ret != 0)\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+#endif\r
+\r
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+\r
+/**\r
+ * Make a non-inheritable to child processes\r
+ * @param socket\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ * @warning Not implemented on Windows\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_set_inheritable (const struct GNUNET_NETWORK_Handle\r
+ *desc)\r
+{\r
+#ifdef MINGW\r
+ errno = ENOSYS;\r
+ return GNUNET_SYSERR;\r
+#else\r
+ return fcntl (desc->fd, F_SETFD,\r
+ fcntl (desc->fd,\r
+ F_GETFD) | FD_CLOEXEC) ==\r
+ 0 ? GNUNET_OK : GNUNET_SYSERR;\r
+#endif\r
+}\r
+\r
+\r
+/**\r
+ * Reset FD set\r
+ * @param fds fd set\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)\r
+{\r
+ FD_ZERO (&fds->sds);\r
+ fds->nsds = 0;\r
+#ifdef MINGW\r
+ GNUNET_CONTAINER_slist_clear (fds->handles);\r
+#endif\r
+}\r
+\r
+\r
+/**\r
+ * Add a socket to the FD set\r
+ * @param fds fd set\r
+ * @param desc socket to add\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,\r
+ const struct GNUNET_NETWORK_Handle *desc)\r
+{\r
+ FD_SET (desc->fd, &fds->sds);\r
+\r
+ if (desc->fd + 1 > fds->nsds)\r
+ fds->nsds = desc->fd + 1;\r
+}\r
+\r
+\r
+/**\r
+ * Check whether a socket is part of the fd set\r
+ * @param fds fd set\r
+ * @param desc socket\r
+ * @return 0 if the FD is not set\r
+ */\r
+int\r
+GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
+ const struct GNUNET_NETWORK_Handle *desc)\r
+{\r
+ return FD_ISSET (desc->fd, &fds->sds);\r
+}\r
+\r
+\r
+/**\r
+ * Add one fd set to another\r
+ * @param dst the fd set to add to\r
+ * @param src the fd set to add from\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,\r
+ const struct GNUNET_NETWORK_FDSet *src)\r
+{\r
+ int nfds;\r
+\r
+ for (nfds = src->nsds; nfds > 0; nfds--)\r
+ if (FD_ISSET (nfds, &src->sds))\r
+ {\r
+ FD_SET (nfds, &dst->sds);\r
+ if (nfds + 1 > dst->nsds)\r
+ dst->nsds = nfds + 1;\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ * Copy one fd set to another\r
+ * @param to destination\r
+ * @param from source\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,\r
+ const struct GNUNET_NETWORK_FDSet *from)\r
+{\r
+ FD_COPY (&from->sds, &to->sds);\r
+ to->nsds = from->nsds;\r
+#ifdef MINGW\r
+ struct GNUNET_CONTAINER_SList_Iterator *iter;\r
+\r
+\r
+ GNUNET_CONTAINER_slist_clear (to->handles);\r
+\r
+ for (iter = GNUNET_CONTAINER_slist_begin (from->handles);\r
+ GNUNET_CONTAINER_slist_end (iter) != GNUNET_YES; GNUNET_CONTAINER_slist_next (iter))\r
+ {\r
+ void *handle;\r
+ size_t len;\r
+\r
+ handle = GNUNET_CONTAINER_slist_get (iter, &len);\r
+ GNUNET_CONTAINER_slist_add (to->handles, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, handle, len);\r
+ }\r
+#endif\r
+}\r
+\r
+\r
+/**\r
+ * Copy a native fd set\r
+ * @param to destination\r
+ * @param from native source set\r
+ * @param nfds the biggest socket number in from + 1\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,\r
+ const fd_set * from, int nfds)\r
+{\r
+ FD_COPY (from, &to->sds);\r
+ to->nsds = nfds;\r
+}\r
+\r
+\r
+/**\r
+ * Add a file handle to the fd set\r
+ * @param fds fd set\r
+ * @param h the file handle to add\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,\r
+ const struct GNUNET_DISK_FileHandle *h)\r
+{\r
+#ifdef MINGW\r
+ HANDLE hw;\r
+\r
+ GNUNET_internal_disk_file_handle (h, &hw, sizeof (HANDLE));\r
+ GNUNET_CONTAINER_slist_add (fds->handles, GNUNET_NO, &hw, sizeof (HANDLE));\r
+#else\r
+ int fd;\r
+\r
+ GNUNET_internal_disk_file_handle (h, &fd, sizeof (int));\r
+ FD_SET (fd, &fds->sds);\r
+ if (fd + 1 > fds->nsds)\r
+ fds->nsds = fd + 1;\r
+#endif\r
+}\r
+\r
+/**\r
+ * Check if a file handle is part of an fd set\r
+ * @param fds fd set\r
+ * @param h file handle\r
+ * @return GNUNET_YES if the file handle is part of the set\r
+ */\r
+int\r
+GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
+ const struct GNUNET_DISK_FileHandle *h)\r
+{\r
+#ifdef MINGW\r
+ return GNUNET_CONTAINER_slist_contains (fds->handles, h->h, sizeof (HANDLE));\r
+#else\r
+ return FD_ISSET (h->fd, &fds->sds);\r
+#endif\r
+}\r
+\r
+/**\r
+ * Checks if two fd sets overlap\r
+ * @param fds1 first fd set\r
+ * @param fds2 second fd set\r
+ * @return GNUNET_YES if they do overlap, GNUNET_NO otherwise\r
+ */\r
+int\r
+GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,\r
+ const struct GNUNET_NETWORK_FDSet *fds2)\r
+{\r
+ int nfds;\r
+\r
+ nfds = fds1->nsds;\r
+ if (nfds < fds2->nsds)\r
+ nfds = fds2->nsds;\r
+\r
+ for (; nfds >= 0; nfds--)\r
+ if (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))\r
+ return GNUNET_YES;\r
+\r
+ return GNUNET_NO;\r
+}\r
+\r
+/**\r
+ * Creates an fd set\r
+ * @return a new fd set\r
+ */\r
+struct GNUNET_NETWORK_FDSet *\r
+GNUNET_NETWORK_fdset_create ()\r
+{\r
+ struct GNUNET_NETWORK_FDSet *fds;\r
+\r
+ fds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));\r
+#ifdef MINGW\r
+ fds->handles = GNUNET_CONTAINER_slist_create ();\r
+#endif\r
+ GNUNET_NETWORK_fdset_zero (fds);\r
+ return fds;\r
+}\r
+\r
+\r
+/**\r
+ * Releases the associated memory of an fd set\r
+ * @param fds fd set\r
+ */\r
+void\r
+GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)\r
+{\r
+#ifdef MINGW\r
+ GNUNET_CONTAINER_slist_destroy (fds->handles);\r
+#endif\r
+ GNUNET_free (fds);\r
+}\r
+\r
+\r
+/**\r
+ * Check if sockets meet certain conditions\r
+ * @param rfds set of sockets to be checked for readability\r
+ * @param wfds set of sockets to be checked for writability\r
+ * @param efds set of sockets to be checked for exceptions\r
+ * @param timeout relative value when to return\r
+ * @return number of selected sockets, GNUNET_SYSERR on error\r
+ */\r
+int\r
+GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,\r
+ struct GNUNET_NETWORK_FDSet *wfds,\r
+ struct GNUNET_NETWORK_FDSet *efds,\r
+ const struct GNUNET_TIME_Relative timeout)\r
+{\r
+ int nfds;\r
+\r
+ nfds = 0;\r
+ if (NULL != rfds)\r
+ nfds = rfds->nsds;\r
+ if (NULL != wfds)\r
+ nfds = GNUNET_MAX (nfds, wfds->nsds);\r
+ if (NULL != efds)\r
+ nfds = GNUNET_MAX (nfds, efds->nsds);\r
+\r
+#ifndef MINGW\r
+ struct timeval tv;\r
+\r
+ tv.tv_sec = timeout.value / GNUNET_TIME_UNIT_SECONDS.value;\r
+ tv.tv_usec = 1000 * (timeout.value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.value));\r
+ if ( (nfds == 0) &&\r
+ (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) )\r
+ {\r
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,\r
+ _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),\r
+ "select");\r
+ GNUNET_break (0);\r
+ }\r
+ return select (nfds + 1, \r
+ (rfds != NULL) ? &rfds->sds : NULL, \r
+ (wfds != NULL) ? &wfds->sds : NULL,\r
+ (efds != NULL) ? &efds->sds : NULL, \r
+ (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) \r
+ ? NULL \r
+ : &tv);\r
+#else\r
+ DWORD limit;\r
+ fd_set sock_read, sock_write, sock_except;\r
+ fd_set aread, awrite, aexcept;\r
+ int i;\r
+ struct timeval tvslice;\r
+ int retcode;\r
+ DWORD ms_total;\r
+\r
+#define SAFE_FD_ISSET(fd, set) (set != NULL && FD_ISSET(fd, set))\r
+\r
+ /* calculate how long we need to wait in milliseconds */\r
+ if (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)\r
+ ms_total = INFINITE;\r
+ else\r
+ ms_total = timeout.value / GNUNET_TIME_UNIT_MILLISECONDS.value;\r
+\r
+ /* select() may be used as a portable way to sleep */\r
+ if (!(rfds || wfds || efds))\r
+ {\r
+ Sleep (ms_total);\r
+ return 0;\r
+ }\r
+\r
+ if (rfds)\r
+ sock_read = rfds->sds;\r
+ else\r
+ FD_ZERO(&sock_read);\r
+\r
+ if (wfds)\r
+ sock_write = wfds->sds;\r
+ else\r
+ FD_ZERO(&sock_write);\r
+\r
+ if (efds)\r
+ sock_except = efds->sds;\r
+ else\r
+ FD_ZERO(&sock_except);\r
+\r
+ /* multiplex between winsock select() and waiting on the handles */\r
+\r
+ FD_ZERO (&aread);\r
+ FD_ZERO (&awrite);\r
+ FD_ZERO (&aexcept);\r
+\r
+ limit = GetTickCount () + ms_total;\r
+ do\r
+ {\r
+ retcode = 0;\r
+\r
+ if (nfds > 0)\r
+ {\r
+ /* overwrite the zero'd sets here; the select call\r
+ * will clear those that are not active */\r
+\r
+ FD_COPY (&sock_read, &aread);\r
+ FD_COPY (&sock_write, &awrite);\r
+ FD_COPY (&sock_except, &aexcept);\r
+\r
+ tvslice.tv_sec = 0;\r
+ tvslice.tv_usec = 100000;\r
+\r
+ if ((retcode =\r
+ select (nfds + 1, &aread, &awrite, &aexcept,\r
+ &tvslice)) == SOCKET_ERROR)\r
+ {\r
+ SetErrnoFromWinsockError (WSAGetLastError ());\r
+ if (errno == ENOTSOCK)\r
+ errno = EBADF;\r
+\r
+#if DEBUG_SOCK\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");\r
+#endif\r
+\r
+ goto select_loop_end;\r
+ }\r
+ }\r
+\r
+ /* Poll read pipes */\r
+ if (rfds)\r
+ {\r
+ struct GNUNET_CONTAINER_SList_Iterator *i;\r
+ int on_next;\r
+\r
+ on_next = GNUNET_NO;\r
+ for (i = GNUNET_CONTAINER_slist_begin (rfds->handles);\r
+ GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
+ on_next || GNUNET_CONTAINER_slist_next (i))\r
+ {\r
+ HANDLE h;\r
+ DWORD dwBytes;\r
+\r
+ h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
+ on_next = GNUNET_NO;\r
+\r
+ if (!PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
+ {\r
+ GNUNET_CONTAINER_slist_erase (i);\r
+ on_next = GNUNET_YES;\r
+\r
+ retcode = -1;\r
+ SetErrnoFromWinError (GetLastError ());\r
+#if DEBUG_SOCK\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "PeekNamedPipe");\r
+#endif\r
+ goto select_loop_end;\r
+ }\r
+ else if (dwBytes)\r
+ {\r
+ retcode++;\r
+ }\r
+ else\r
+ {\r
+ GNUNET_CONTAINER_slist_erase (i);\r
+ on_next = GNUNET_YES;\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Poll for faulty pipes */\r
+ if (efds)\r
+ {\r
+ struct GNUNET_CONTAINER_SList_Iterator *i;\r
+ int on_next;\r
+\r
+ on_next = GNUNET_NO;\r
+ for (i = GNUNET_CONTAINER_slist_begin (efds->handles);\r
+ GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
+ on_next || GNUNET_CONTAINER_slist_next (i))\r
+ {\r
+ HANDLE h;\r
+ DWORD dwBytes;\r
+\r
+ h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
+\r
+ if (PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
+ {\r
+ GNUNET_CONTAINER_slist_erase (i);\r
+ on_next = GNUNET_YES;\r
+\r
+ retcode++;\r
+ }\r
+ else\r
+ on_next = GNUNET_NO;\r
+ }\r
+ }\r
+\r
+ /* FIXME */\r
+ if (wfds)\r
+ GNUNET_assert (GNUNET_CONTAINER_slist_count (wfds->handles) == 0);\r
+\r
+ /* Check for closed sockets */\r
+ for (i = 0; i < nfds; i++)\r
+ {\r
+ if (SAFE_FD_ISSET (i, &sock_read))\r
+ {\r
+ struct sockaddr addr;\r
+ int len;\r
+\r
+ if (getpeername (i, &addr, &len) == SOCKET_ERROR)\r
+ {\r
+ int err, len;\r
+\r
+ len = sizeof (err);\r
+ if (getsockopt\r
+ (i, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == 0\r
+ && err == WSAENOTCONN)\r
+ {\r
+ if (!SAFE_FD_ISSET (i, &aread))\r
+ {\r
+ FD_SET (i, &aread);\r
+ retcode++;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ select_loop_end:;\r
+ }\r
+ while (retcode == 0 && (ms_total == INFINITE || GetTickCount () < limit));\r
+\r
+ if (retcode != -1)\r
+ {\r
+ if (rfds)\r
+ {\r
+ GNUNET_NETWORK_fdset_zero (rfds);\r
+ GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);\r
+ }\r
+\r
+ if (wfds)\r
+ {\r
+ GNUNET_NETWORK_fdset_zero (wfds);\r
+ GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);\r
+ }\r
+\r
+ if (efds)\r
+ {\r
+ GNUNET_NETWORK_fdset_zero (efds);\r
+ GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);\r
+ }\r
+ }\r
+\r
+ return retcode;\r
+#endif\r
+}\r
+\r
+\r
+/* end of network.c */\r
projects / oweals / gnunet.git / blobdiff