tcp_connection_legacy.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_resolver_service.h"

Include dependency graph for tcp_connection_legacy.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GNUNET_CONNECTION_TransmitHandle
	Transmission handle. More...
struct	AddressProbe
	During connect, we try multiple possible IP addresses to find out which one might work. More...
struct	GNUNET_CONNECTION_Handle
	handle for a network connection More...

Macros
#define	CONNECT_RETRY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	Timeout we use on TCP connect before trying another result from the DNS resolver. More...
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-connection", syscall)

Functions
void	GNUNET_CONNECTION_persist_ (struct GNUNET_CONNECTION_Handle *connection)
	Set the persist option on this connection handle. More...
int	GNUNET_CONNECTION_disable_corking (struct GNUNET_CONNECTION_Handle *connection)
	Disable the "CORK" feature for communication with the given connection, forcing the OS to immediately flush the buffer on transmission instead of potentially buffering multiple messages. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle *osSocket)
	Create a connection handle by boxing an existing OS socket. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb, void *access_cb_cls, struct GNUNET_NETWORK_Handle *lsock)
	Create a connection handle by accepting on a listen socket. More...
int	GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *connection, void **addr, size_t *addrlen)
	Obtain the network address of the other party. More...
static void	signal_receive_error (struct GNUNET_CONNECTION_Handle *connection, int errcode)
	Tell the receiver callback that we had an IO error. More...
static void	signal_receive_timeout (struct GNUNET_CONNECTION_Handle *connection)
	Tell the receiver callback that a timeout was reached. More...
static void	signal_transmit_error (struct GNUNET_CONNECTION_Handle *connection, int ecode)
	We failed to transmit data to the service, signal the error. More...
static void	connect_fail_continuation (struct GNUNET_CONNECTION_Handle *connection)
	We've failed for good to establish a connection (timeout or no more addresses to try). More...
static void	transmit_ready (void *cls)
	We are ready to transmit (or got a timeout). More...
static void	receive_ready (void *cls)
	This function is called once we either timeout or have data ready to read. More...
static void	connect_success_continuation (struct GNUNET_CONNECTION_Handle *connection)
	We've succeeded in establishing a connection. More...
static void	connect_probe_continuation (void *cls)
	Scheduler let us know that we're either ready to write on the socket OR connect timed out. More...
static void	try_connect_using_address (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Try to establish a connection given the specified address. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *hostname, uint16_t port)
	Create a connection handle by (asynchronously) connecting to a host. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *unixpath)
	Create a connection handle by connecting to a UNIX domain service. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_connect_socket (struct GNUNET_NETWORK_Handle *s, const struct sockaddr *serv_addr, socklen_t addrlen)
	Create a connection handle by (asynchronously) connecting to a host. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_from_sockaddr (int af_family, const struct sockaddr *serv_addr, socklen_t addrlen)
	Create a connection handle by creating a socket and (asynchronously) connecting to a host. More...
int	GNUNET_CONNECTION_check (struct GNUNET_CONNECTION_Handle *connection)
	Check if connection is valid (no fatal errors have happened so far). More...
void	GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection)
	Close the connection and free associated resources. More...
int	GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *connection, size_t max, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_Receiver receiver, void *receiver_cls)
	Receive data from the given connection. More...
void *	GNUNET_CONNECTION_receive_cancel (struct GNUNET_CONNECTION_Handle *connection)
	Cancel receive job on the given connection. More...
static int	process_notify (struct GNUNET_CONNECTION_Handle *connection)
	Try to call the transmit notify method (check if we do have enough space available first)! More...
static void	transmit_timeout (void *cls)
	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). More...
static void	connect_error (void *cls)
	Task invoked by the scheduler when we failed to connect at the time of being asked to transmit. More...
struct GNUNET_CONNECTION_TransmitHandle *	GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *connection, size_t size, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_TransmitReadyNotify notify, void *notify_cls)
	Ask the connection to call us once the specified number of bytes are free in the transmission buffer. More...
void	GNUNET_CONNECTION_notify_transmit_ready_cancel (struct GNUNET_CONNECTION_TransmitHandle *th)
	Cancel the specified transmission-ready notification. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_CONNECTION_create_proxied_from_handshake (struct GNUNET_CONNECTION_Handle *cph)
	Create a connection to be proxied using a given connection. More...
void	GNUNET_CONNECTION_acivate_proxied (struct GNUNET_CONNECTION_Handle *proxied)
	Activate proxied connection and destroy initial proxy handshake connection. More...

Macro Definition Documentation

CONNECT_RETRY_TIMEOUT

#define CONNECT_RETRY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

Timeout we use on TCP connect before trying another result from the DNS resolver.

Actual value used is this value divided by the number of address families. Default is 5s.

Definition at line 44 of file tcp_connection_legacy.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-connection", syscall)

Definition at line 48 of file tcp_connection_legacy.c.

Function Documentation

GNUNET_CONNECTION_persist_()

void GNUNET_CONNECTION_persist_

(

struct GNUNET_CONNECTION_Handle *

connection

)

Set the persist option on this connection handle.

Indicates that the underlying socket or fd should never really be closed. Used for indicating process death.

Parameters

connection

the connection to set persistent

Definition at line 274 of file tcp_connection_legacy.c.

{
  connection->persist = GNUNET_YES;
}

References GNUNET_YES, and GNUNET_CONNECTION_Handle::persist.

Referenced by GNUNET_SERVER_client_disconnect().

Here is the caller graph for this function:

GNUNET_CONNECTION_disable_corking()

int GNUNET_CONNECTION_disable_corking

(

struct GNUNET_CONNECTION_Handle *

connection

)

Disable the "CORK" feature for communication with the given connection, forcing the OS to immediately flush the buffer on transmission instead of potentially buffering multiple messages.

Essentially reduces the OS send buffers to zero. Used to make sure that the last messages sent through the connection reach the other side before the process is terminated.

Parameters

connection

the connection to make flushing and blocking

Returns

GNUNET_OK on success

Definition at line 292 of file tcp_connection_legacy.c.

{
  return GNUNET_NETWORK_socket_disable_corking (connection->sock);
}

References GNUNET_NETWORK_socket_disable_corking(), and GNUNET_CONNECTION_Handle::sock.

Referenced by GNUNET_SERVER_client_disable_corking().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_create_from_existing()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_from_existing

(

struct GNUNET_NETWORK_Handle *

osSocket

)

Create a connection handle by boxing an existing OS socket.

The OS socket should henceforth be no longer used directly. #GNUNET_connection_destroy() will close it.

Parameters

osSocket

existing socket to box

Returns

the boxed connection handle

Definition at line 307 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection;
 
  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
  connection->write_buffer_size = GNUNET_MIN_MESSAGE_SIZE;
  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
  connection->sock = osSocket;
  return connection;
}

References GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, GNUNET_CONNECTION_Handle::sock, GNUNET_CONNECTION_Handle::write_buffer, and GNUNET_CONNECTION_Handle::write_buffer_size.

Referenced by GNUNET_CONNECTION_connect_socket(), and GNUNET_CONNECTION_create_proxied_from_handshake().

Here is the caller graph for this function:

GNUNET_CONNECTION_create_from_accept()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_from_accept	(	GNUNET_CONNECTION_AccessCheck	access_cb,
		void *	access_cb_cls,
		struct GNUNET_NETWORK_Handle *	lsock
	)

Create a connection handle by accepting on a listen socket.

This function may block if the listen socket has no connection ready.

Parameters

access_cb	function to use to check if access is allowed
access_cb_cls	closure for access_cb
lsock	listen socket

Returns

the connection handle, NULL on error

Definition at line 329 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection;
  char addr[128];
  socklen_t addrlen;
  struct GNUNET_NETWORK_Handle *sock;
  int aret;
  struct sockaddr_in *v4;
  struct sockaddr_in6 *v6;
  struct sockaddr *sa;
  void *uaddr;
 
#ifdef SO_PEERCRED
  struct ucred uc;
  socklen_t olen;
#endif
  struct GNUNET_CONNECTION_Credentials *gcp;
#if HAVE_GETPEEREID || defined(SO_PEERCRED) || HAVE_GETPEERUCRED
  struct GNUNET_CONNECTION_Credentials gc;
 
  gc.uid = 0;
  gc.gid = 0;
#endif
 
  addrlen = sizeof(addr);
  sock =
    GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
  if (NULL == sock)
  {
    if (EAGAIN != errno)
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "accept");
    return NULL;
  }
  if ((addrlen > sizeof(addr)) || (addrlen < sizeof(sa_family_t)))
  {
    GNUNET_break (0);
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
    return NULL;
  }
 
  sa = (struct sockaddr *) addr;
  v6 = (struct sockaddr_in6 *) addr;
  if ((AF_INET6 == sa->sa_family) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
  {
    /* convert to V4 address */
    v4 = GNUNET_new (struct sockaddr_in);
    memset (v4, 0, sizeof(struct sockaddr_in));
    v4->sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
    v4->sin_len = (u_char) sizeof(struct sockaddr_in);
#endif
    GNUNET_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);
    GNUNET_memcpy (uaddr, addr, addrlen);
  }
  gcp = NULL;
  if (AF_UNIX == sa->sa_family)
  {
#if HAVE_GETPEEREID
    /* most BSDs */
    if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock), &gc.uid, &gc.gid))
      gcp = &gc;
#else
#ifdef SO_PEERCRED
    /* largely traditional GNU/Linux */
    olen = sizeof(uc);
    if ((0 == getsockopt (GNUNET_NETWORK_get_fd (sock),
                          SOL_SOCKET,
                          SO_PEERCRED,
                          &uc,
                          &olen)) &&
        (olen == sizeof(uc)))
    {
      gc.uid = uc.uid;
      gc.gid = uc.gid;
      gcp = &gc;
    }
#else
#if HAVE_GETPEERUCRED
    /* this is for Solaris 10 */
    ucred_t *uc;
 
    uc = NULL;
    if (0 == getpeerucred (GNUNET_NETWORK_get_fd (sock), &uc))
    {
      gc.uid = ucred_geteuid (uc);
      gc.gid = ucred_getegid (uc);
      gcp = &gc;
    }
    ucred_free (uc);
#endif
#endif
#endif
  }
 
  if ((NULL != access_cb) &&
      (GNUNET_YES != (aret = access_cb (access_cb_cls, gcp, uaddr, addrlen))))
  {
    if (GNUNET_NO == aret)
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Access denied to `%s'\n"),
           GNUNET_a2s (uaddr, addrlen));
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
    GNUNET_free (uaddr);
    return NULL;
  }
  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
  connection->write_buffer_size = GNUNET_MIN_MESSAGE_SIZE;
  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
  connection->addr = uaddr;
  connection->addrlen = addrlen;
  connection->sock = sock;
  LOG (GNUNET_ERROR_TYPE_INFO,
       _ ("Accepting connection from `%s': %p\n"),
       GNUNET_a2s (uaddr, addrlen),
       connection);
  return connection;
}

References _, GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_Credentials::gid, GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_MIN_MESSAGE_SIZE, GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_shutdown(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_YES, LOG, LOG_STRERROR, GNUNET_CONNECTION_Handle::sock, uc, GNUNET_CONNECTION_Credentials::uid, GNUNET_CONNECTION_Handle::write_buffer, and GNUNET_CONNECTION_Handle::write_buffer_size.

Referenced by process_listen_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_get_address()

int GNUNET_CONNECTION_get_address	(	struct GNUNET_CONNECTION_Handle *	connection,
		void **	addr,
		size_t *	addrlen
	)

Obtain the network address of the other party.

Parameters

connection	the client to get the address for
addr	where to store the address
addrlen	where to store the length of the addr

Returns

GNUNET_OK on success

Definition at line 471 of file tcp_connection_legacy.c.

{
  if ((NULL == connection->addr) || (0 == connection->addrlen))
    return GNUNET_NO;
  *addr = GNUNET_malloc (connection->addrlen);
  GNUNET_memcpy (*addr, connection->addr, connection->addrlen);
  *addrlen = connection->addrlen;
  return GNUNET_OK;
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, and GNUNET_OK.

Referenced by GNUNET_SERVER_client_get_address().

Here is the caller graph for this function:

signal_receive_error()

static void signal_receive_error ( struct GNUNET_CONNECTION_Handle *  connection, int  errcode  )

static

Tell the receiver callback that we had an IO error.

Parameters

connection	connection to signal error
errcode	error code to send

Definition at line 491 of file tcp_connection_legacy.c.

{
  GNUNET_CONNECTION_Receiver receiver;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Receive encounters error (%s), connection closed (%p)\n",
       strerror (errcode),
       connection);
  GNUNET_assert (NULL != (receiver = connection->receiver));
  connection->receiver = NULL;
  receiver (connection->receiver_cls,
            NULL,
            0,
            connection->addr,
            connection->addrlen,
            errcode);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, LOG, GNUNET_CONNECTION_Handle::receiver, receiver(), and GNUNET_CONNECTION_Handle::receiver_cls.

Referenced by connect_fail_continuation(), and receive_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

signal_receive_timeout()

static void signal_receive_timeout ( struct GNUNET_CONNECTION_Handle *  connection )

static

Tell the receiver callback that a timeout was reached.

Parameters

connection

connection to signal for

Definition at line 516 of file tcp_connection_legacy.c.

{
  GNUNET_CONNECTION_Receiver receiver;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection signals timeout to receiver (%p)!\n",
       connection);
  GNUNET_assert (NULL != (receiver = connection->receiver));
  connection->receiver = NULL;
  receiver (connection->receiver_cls, NULL, 0, NULL, 0, 0);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, LOG, GNUNET_CONNECTION_Handle::receiver, receiver(), and GNUNET_CONNECTION_Handle::receiver_cls.

Referenced by receive_ready(), and signal_transmit_error().

Here is the call graph for this function:

Here is the caller graph for this function:

signal_transmit_error()

static void signal_transmit_error ( struct GNUNET_CONNECTION_Handle *  connection, int  ecode  )

static

We failed to transmit data to the service, signal the error.

Parameters

connection	handle that had trouble
ecode	error code (errno)

Definition at line 536 of file tcp_connection_legacy.c.

{
  GNUNET_CONNECTION_TransmitReadyNotify notify;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmission encountered error (%s), connection closed (%p)\n",
       strerror (ecode),
       connection);
  if (NULL != connection->sock)
  {
    (void) GNUNET_NETWORK_socket_shutdown (connection->sock, SHUT_RDWR);
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (connection->sock));
    connection->sock = NULL;
    GNUNET_assert (NULL == connection->write_task);
  }
  if (NULL != connection->read_task)
  {
    /* send errors trigger read errors... */
    GNUNET_SCHEDULER_cancel (connection->read_task);
    connection->read_task = NULL;
    signal_receive_timeout (connection);
    return;
  }
  if (NULL == connection->nth.notify_ready)
    return; /* nobody to tell about it */
  notify = connection->nth.notify_ready;
  connection->nth.notify_ready = NULL;
  notify (connection->nth.notify_ready_cls, 0, NULL);
}

References GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_shutdown(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::read_task, signal_receive_timeout(), GNUNET_CONNECTION_Handle::sock, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_fail_continuation(), and transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_fail_continuation()

static void connect_fail_continuation ( struct GNUNET_CONNECTION_Handle *  connection )

static

We've failed for good to establish a connection (timeout or no more addresses to try).

Parameters

connection

the connection we tried to establish

Definition at line 574 of file tcp_connection_legacy.c.

{
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Failed to establish TCP connection to `%s:%u', no further addresses to try.\n",
       connection->hostname,
       connection->port);
  GNUNET_break (NULL == connection->ap_head);
  GNUNET_break (NULL == connection->ap_tail);
  GNUNET_break (GNUNET_NO == connection->dns_active);
  GNUNET_break (NULL == connection->sock);
  GNUNET_assert (NULL == connection->write_task);
  GNUNET_assert (NULL == connection->proxy_handshake);
 
  /* signal errors for jobs that used to wait on the connection */
  connection->destroy_later = 1;
  if (NULL != connection->receiver)
    signal_receive_error (connection, ECONNREFUSED);
  if (NULL != connection->nth.notify_ready)
  {
    GNUNET_assert (NULL != connection->nth.timeout_task);
    GNUNET_SCHEDULER_cancel (connection->nth.timeout_task);
    connection->nth.timeout_task = NULL;
    signal_transmit_error (connection, ECONNREFUSED);
  }
  if (-1 == connection->destroy_later)
  {
    /* do it now */
    connection->destroy_later = 0;
    GNUNET_CONNECTION_destroy (connection);
    return;
  }
  connection->destroy_later = 0;
}

References GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::ap_tail, GNUNET_CONNECTION_Handle::destroy_later, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_break, GNUNET_CONNECTION_destroy(), GNUNET_ERROR_TYPE_INFO, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_CONNECTION_Handle::hostname, LOG, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::port, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_CONNECTION_Handle::receiver, signal_receive_error(), signal_transmit_error(), GNUNET_CONNECTION_Handle::sock, GNUNET_CONNECTION_TransmitHandle::timeout_task, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_probe_continuation(), and try_connect_using_address().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_ready()

static void transmit_ready ( void *  cls )

static

We are ready to transmit (or got a timeout).

Parameters

cls	our connection handle

Definition at line 1348 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection = cls;
  GNUNET_CONNECTION_TransmitReadyNotify notify;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  ssize_t ret;
  size_t have;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "transmit_ready running (%p).\n", connection);
  GNUNET_assert (NULL != connection->write_task);
  connection->write_task = NULL;
  GNUNET_assert (NULL == connection->nth.timeout_task);
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Transmit to `%s' fails, time out reached (%p).\n",
         GNUNET_a2s (connection->addr, connection->addrlen),
         connection);
    notify = connection->nth.notify_ready;
    GNUNET_assert (NULL != notify);
    connection->nth.notify_ready = NULL;
    notify (connection->nth.notify_ready_cls, 0, NULL);
    return;
  }
  GNUNET_assert (NULL != connection->sock);
  if (NULL == tc->write_ready)
  {
    /* special circumstances (in particular, PREREQ_DONE after
     * connect): not yet ready to write, but no "fatal" error either.
     * Hence retry.  */
    goto SCHEDULE_WRITE;
  }
  if (! GNUNET_NETWORK_fdset_isset (tc->write_ready, connection->sock))
  {
    GNUNET_assert (NULL == connection->write_task);
    /* special circumstances (in particular, shutdown): not yet ready
     * to write, but no "fatal" error either.  Hence retry.  */
    goto SCHEDULE_WRITE;
  }
  GNUNET_assert (connection->write_buffer_off >= connection->write_buffer_pos);
  if ((NULL != connection->nth.notify_ready) &&
      (connection->write_buffer_size < connection->nth.notify_size))
  {
    connection->write_buffer =
      GNUNET_realloc (connection->write_buffer, connection->nth.notify_size);
    connection->write_buffer_size = connection->nth.notify_size;
  }
  process_notify (connection);
  have = connection->write_buffer_off - connection->write_buffer_pos;
  if (0 == have)
  {
    /* no data ready for writing, terminate write loop */
    return;
  }
  GNUNET_assert (have <= connection->write_buffer_size);
  GNUNET_assert (have + connection->write_buffer_pos <=
                 connection->write_buffer_size);
  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_size);
RETRY:
  ret =
    GNUNET_NETWORK_socket_send (connection->sock,
                                &connection
                                ->write_buffer[connection->write_buffer_pos],
                                have);
  if (-1 == ret)
  {
    if (EINTR == errno)
      goto RETRY;
    if (NULL != connection->write_task)
    {
      GNUNET_SCHEDULER_cancel (connection->write_task);
      connection->write_task = NULL;
    }
    signal_transmit_error (connection, errno);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection transmitted %lu/%lu bytes to `%s' (%p)\n",
       (unsigned long) ret,
       (unsigned long) have,
       GNUNET_a2s (connection->addr, connection->addrlen),
       connection);
  connection->write_buffer_pos += ret;
  if (connection->write_buffer_pos == connection->write_buffer_off)
  {
    /* transmitted all pending data */
    connection->write_buffer_pos = 0;
    connection->write_buffer_off = 0;
  }
  if ((0 == connection->write_buffer_off) &&
      (NULL == connection->nth.notify_ready))
    return; /* all data sent! */
  /* not done writing, schedule more */
SCHEDULE_WRITE:
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Re-scheduling transmit_ready (more to do) (%p).\n",
       connection);
  have = connection->write_buffer_off - connection->write_buffer_pos;
  GNUNET_assert ((NULL != connection->nth.notify_ready) || (have > 0));
  if (NULL == connection->write_task)
    connection->write_task =
      GNUNET_SCHEDULER_add_write_net ((connection->nth.notify_ready == NULL)
                                      ? GNUNET_TIME_UNIT_FOREVER_REL
                                      : GNUNET_TIME_absolute_get_remaining (
                                        connection->nth.transmit_timeout),
                                      connection->sock,
                                      &transmit_ready,
                                      connection);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_fdset_isset(), GNUNET_NETWORK_socket_send(), GNUNET_realloc, GNUNET_SCHEDULER_add_write_net(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_TIMEOUT, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_TransmitHandle::notify_size, GNUNET_CONNECTION_Handle::nth, process_notify(), GNUNET_SCHEDULER_TaskContext::reason, ret, RETRY, signal_transmit_error(), GNUNET_CONNECTION_Handle::sock, tc, GNUNET_CONNECTION_TransmitHandle::timeout_task, GNUNET_CONNECTION_TransmitHandle::transmit_timeout, GNUNET_CONNECTION_Handle::write_buffer, GNUNET_CONNECTION_Handle::write_buffer_off, GNUNET_CONNECTION_Handle::write_buffer_pos, GNUNET_CONNECTION_Handle::write_buffer_size, GNUNET_SCHEDULER_TaskContext::write_ready, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_success_continuation(), and GNUNET_CONNECTION_notify_transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

receive_ready()

static void receive_ready ( void *  cls )

static

This function is called once we either timeout or have data ready to read.

Parameters

cls	connection to read from

Definition at line 1105 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection = cls;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  char buffer[connection->max];
  ssize_t ret;
  GNUNET_CONNECTION_Receiver receiver;
 
  connection->read_task = NULL;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Receive from `%s' encounters error: timeout (%s, %p)\n",
         GNUNET_a2s (connection->addr, connection->addrlen),
         GNUNET_STRINGS_relative_time_to_string (
           GNUNET_TIME_absolute_get_duration (
             connection->receive_timeout),
           GNUNET_YES),
         connection);
    signal_receive_timeout (connection);
    return;
  }
  if (NULL == connection->sock)
  {
    /* connect failed for good */
    signal_receive_error (connection, ECONNREFUSED);
    return;
  }
  GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, connection->sock));
RETRY:
  ret = GNUNET_NETWORK_socket_recv (connection->sock, buffer, connection->max);
  if (-1 == ret)
  {
    if (EINTR == errno)
      goto RETRY;
    signal_receive_error (connection, errno);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "receive_ready read %lu/%lu bytes from `%s' (%p)!\n",
       (unsigned long) ret,
       (unsigned long) connection->max,
       GNUNET_a2s (connection->addr, connection->addrlen),
       connection);
  GNUNET_assert (NULL != (receiver = connection->receiver));
  connection->receiver = NULL;
  receiver (connection->receiver_cls,
            buffer,
            ret,
            connection->addr,
            connection->addrlen,
            0);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_fdset_isset(), GNUNET_NETWORK_socket_recv(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_TIMEOUT, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, LOG, GNUNET_CONNECTION_Handle::max, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_CONNECTION_Handle::read_task, GNUNET_SCHEDULER_TaskContext::reason, GNUNET_CONNECTION_Handle::receive_timeout, GNUNET_CONNECTION_Handle::receiver, receiver(), GNUNET_CONNECTION_Handle::receiver_cls, ret, RETRY, signal_receive_error(), signal_receive_timeout(), GNUNET_CONNECTION_Handle::sock, and tc.

Referenced by connect_success_continuation(), and GNUNET_CONNECTION_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_success_continuation()

static void connect_success_continuation ( struct GNUNET_CONNECTION_Handle *  connection )

static

We've succeeded in establishing a connection.

Parameters

connection

the connection we tried to establish

Definition at line 634 of file tcp_connection_legacy.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection to `%s' succeeded! (%p)\n",
       GNUNET_a2s (connection->addr, connection->addrlen),
       connection);
  /* trigger jobs that waited for the connection */
  if (NULL != connection->receiver)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Connection succeeded, starting with receiving data (%p)\n",
         connection);
    GNUNET_assert (NULL == connection->read_task);
    connection->read_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
                                       connection->receive_timeout),
                                     connection->sock,
                                     &receive_ready,
                                     connection);
  }
  if (NULL != connection->nth.notify_ready)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Connection succeeded, starting with sending data (%p)\n",
         connection);
    GNUNET_assert (connection->nth.timeout_task != NULL);
    GNUNET_SCHEDULER_cancel (connection->nth.timeout_task);
    connection->nth.timeout_task = NULL;
    GNUNET_assert (connection->write_task == NULL);
    connection->write_task =
      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining (
                                        connection->nth.transmit_timeout),
                                      connection->sock,
                                      &transmit_ready,
                                      connection);
  }
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_write_net(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get_remaining(), LOG, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::read_task, receive_ready(), GNUNET_CONNECTION_Handle::receive_timeout, GNUNET_CONNECTION_Handle::receiver, GNUNET_CONNECTION_Handle::sock, GNUNET_CONNECTION_TransmitHandle::timeout_task, transmit_ready(), GNUNET_CONNECTION_TransmitHandle::transmit_timeout, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_probe_continuation(), GNUNET_CONNECTION_acivate_proxied(), and GNUNET_CONNECTION_create_from_connect_to_unixpath().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_probe_continuation()

static void connect_probe_continuation ( void *  cls )

static

Scheduler let us know that we're either ready to write on the socket OR connect timed out.

Do the right thing.

Parameters

cls	the struct AddressProbe * with the address that we are probing

Definition at line 680 of file tcp_connection_legacy.c.

{
  struct AddressProbe *ap = cls;
  struct GNUNET_CONNECTION_Handle *connection = ap->connection;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  struct AddressProbe *pos;
  int error;
  socklen_t len;
 
  GNUNET_assert (NULL != ap->sock);
  GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, ap);
  len = sizeof(error);
  errno = 0;
  error = 0;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
      (GNUNET_OK != GNUNET_NETWORK_socket_getsockopt (ap->sock,
                                                      SOL_SOCKET,
                                                      SO_ERROR,
                                                      &error,
                                                      &len)) ||
      (0 != error))
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
    GNUNET_free (ap);
    if ((NULL == connection->ap_head) &&
        (GNUNET_NO == connection->dns_active) &&
        (NULL == connection->proxy_handshake))
      connect_fail_continuation (connection);
    return;
  }
  GNUNET_assert (NULL == connection->sock);
  connection->sock = ap->sock;
  GNUNET_assert (NULL == connection->addr);
  connection->addr = GNUNET_malloc (ap->addrlen);
  GNUNET_memcpy (connection->addr, ap->addr, ap->addrlen);
  connection->addrlen = ap->addrlen;
  GNUNET_free (ap);
  /* cancel all other attempts */
  while (NULL != (pos = connection->ap_head))
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
    GNUNET_SCHEDULER_cancel (pos->task);
    GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, pos);
    GNUNET_free (pos);
  }
  connect_success_continuation (connection);
}

References AddressProbe::addr, GNUNET_CONNECTION_Handle::addr, AddressProbe::addrlen, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::ap_tail, connect_fail_continuation(), connect_success_continuation(), AddressProbe::connection, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_getsockopt(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_WRITE_READY, len, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_SCHEDULER_TaskContext::reason, AddressProbe::sock, GNUNET_CONNECTION_Handle::sock, AddressProbe::task, and tc.

Referenced by try_connect_using_address().

Here is the call graph for this function:

Here is the caller graph for this function:

try_connect_using_address()

static void try_connect_using_address ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Try to establish a connection given the specified address.

This function is called by the resolver once we have a DNS reply.

Parameters

cls	our struct GNUNET_CONNECTION_Handle *
addr	address to try, NULL for "last call"
addrlen	length of addr

Definition at line 739 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection = cls;
  struct AddressProbe *ap;
  struct GNUNET_TIME_Relative delay;
 
  if (NULL == addr)
  {
    connection->dns_active = NULL;
    if ((NULL == connection->ap_head) && (NULL == connection->sock) &&
        (NULL == connection->proxy_handshake))
      connect_fail_continuation (connection);
    return;
  }
  if (NULL != connection->sock)
    return; /* already connected */
  GNUNET_assert (NULL == connection->addr);
  /* try to connect */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to connect using address `%s:%u/%s:%u'\n",
       connection->hostname,
       connection->port,
       GNUNET_a2s (addr, addrlen),
       connection->port);
  ap = GNUNET_malloc (sizeof(struct AddressProbe) + addrlen);
  ap->addr = (const struct sockaddr *) &ap[1];
  GNUNET_memcpy (&ap[1], addr, addrlen);
  ap->addrlen = addrlen;
  ap->connection = connection;
 
  switch (ap->addr->sa_family)
  {
  case AF_INET:
    ((struct sockaddr_in *) ap->addr)->sin_port = htons (connection->port);
    break;
 
  case AF_INET6:
    ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (connection->port);
    break;
 
  default:
    GNUNET_break (0);
    GNUNET_free (ap);
    return;   /* not supported by us */
  }
  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);
  if (NULL == ap->sock)
  {
    GNUNET_free (ap);
    return;   /* not supported by OS */
  }
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Trying to connect to `%s' (%p)\n",
       GNUNET_a2s (ap->addr, ap->addrlen),
       connection);
  if ((GNUNET_OK !=
       GNUNET_NETWORK_socket_connect (ap->sock, ap->addr, ap->addrlen)) &&
      (EINPROGRESS != errno))
  {
    /* maybe refused / unsupported address, try next */
    LOG_STRERROR (GNUNET_ERROR_TYPE_INFO, "connect");
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
    GNUNET_free (ap);
    return;
  }
  GNUNET_CONTAINER_DLL_insert (connection->ap_head, connection->ap_tail, ap);
  delay = CONNECT_RETRY_TIMEOUT;
  if (NULL != connection->nth.notify_ready)
    delay = GNUNET_TIME_relative_min (delay,
                                      GNUNET_TIME_absolute_get_remaining (
                                        connection->nth.transmit_timeout));
  if (NULL != connection->receiver)
    delay = GNUNET_TIME_relative_min (delay,
                                      GNUNET_TIME_absolute_get_remaining (
                                        connection->receive_timeout));
  ap->task = GNUNET_SCHEDULER_add_write_net (delay,
                                             ap->sock,
                                             &connect_probe_continuation,
                                             ap);
}

References AddressProbe::addr, GNUNET_CONNECTION_Handle::addr, AddressProbe::addrlen, GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::ap_tail, connect_fail_continuation(), connect_probe_continuation(), CONNECT_RETRY_TIMEOUT, AddressProbe::connection, delay, GNUNET_CONNECTION_Handle::dns_active, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_OK, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_CONNECTION_Handle::hostname, LOG, LOG_STRERROR, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::port, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_CONNECTION_Handle::receive_timeout, GNUNET_CONNECTION_Handle::receiver, AddressProbe::sock, GNUNET_CONNECTION_Handle::sock, AddressProbe::task, and GNUNET_CONNECTION_TransmitHandle::transmit_timeout.

Referenced by GNUNET_CONNECTION_create_from_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_create_from_connect()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_from_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	hostname,
		uint16_t	port
	)

Create a connection 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.

Parameters

cfg	configuration to use
hostname	name of the host to connect to
port	port to connect to

Returns

the connection handle

Definition at line 834 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection;
 
  GNUNET_assert (0 < strlen (hostname));   /* sanity check */
  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
  connection->cfg = cfg;
  connection->write_buffer_size = GNUNET_MIN_MESSAGE_SIZE;
  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
  connection->port = port;
  connection->hostname = GNUNET_strdup (hostname);
  connection->dns_active = GNUNET_RESOLVER_ip_get (connection->hostname,
                                                   AF_UNSPEC,
                                                   CONNECT_RETRY_TIMEOUT,
                                                   &try_connect_using_address,
                                                   connection);
  return connection;
}

References cfg, GNUNET_CONNECTION_Handle::cfg, CONNECT_RETRY_TIMEOUT, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, GNUNET_RESOLVER_ip_get(), GNUNET_strdup, hostname, GNUNET_CONNECTION_Handle::hostname, port, GNUNET_CONNECTION_Handle::port, try_connect_using_address(), GNUNET_CONNECTION_Handle::write_buffer, and GNUNET_CONNECTION_Handle::write_buffer_size.

Referenced by GNUNET_SOCKS_do_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_create_from_connect_to_unixpath()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_from_connect_to_unixpath	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	unixpath
	)

Create a connection handle by connecting to a UNIX domain service.

This function returns immediately, even if the connection has not yet been established. This function only creates UNIX connections.

Parameters

cfg	configuration to use
unixpath	path to connect to

Returns

the connection handle, NULL on systems without UNIX support

Definition at line 867 of file tcp_connection_legacy.c.

{
#ifdef AF_UNIX
  struct GNUNET_CONNECTION_Handle *connection;
  struct sockaddr_un *un;
 
  GNUNET_assert (0 < strlen (unixpath));   /* sanity check */
  un = GNUNET_new (struct sockaddr_un);
  un->sun_family = AF_UNIX;
  GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path));
#ifdef __linux__
  {
    int abstract;
 
    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                     "TESTING",
                                                     "USE_ABSTRACT_SOCKETS");
    if (GNUNET_YES == abstract)
      un->sun_path[0] = '\0';
  }
#endif
#if HAVE_SOCKADDR_UN_SUN_LEN
  un->sun_len = (u_char) sizeof(struct sockaddr_un);
#endif
  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
  connection->cfg = cfg;
  connection->write_buffer_size = GNUNET_MIN_MESSAGE_SIZE;
  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
  connection->port = 0;
  connection->hostname = NULL;
  connection->addr = (struct sockaddr *) un;
  connection->addrlen = sizeof(struct sockaddr_un);
  connection->sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
  if (NULL == connection->sock)
  {
    GNUNET_free (connection->addr);
    GNUNET_free (connection->write_buffer);
    GNUNET_free (connection);
    return NULL;
  }
  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (connection->sock,
                                                   connection->addr,
                                                   connection->addrlen)) &&
      (EINPROGRESS != errno))
  {
    /* Just return; we expect everything to work eventually so don't fail HARD */
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (connection->sock));
    connection->sock = NULL;
    return connection;
  }
  connect_success_continuation (connection);
  return connection;
#else
  return NULL;
#endif
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, cfg, GNUNET_CONNECTION_Handle::cfg, connect_success_continuation(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_free, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_new, GNUNET_OK, GNUNET_strlcpy(), GNUNET_YES, GNUNET_CONNECTION_Handle::hostname, GNUNET_CONNECTION_Handle::port, GNUNET_CONNECTION_Handle::sock, GNUNET_CONNECTION_Handle::write_buffer, and GNUNET_CONNECTION_Handle::write_buffer_size.

Here is the call graph for this function:

GNUNET_CONNECTION_connect_socket()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_connect_socket	(	struct GNUNET_NETWORK_Handle *	s,
		const struct sockaddr *	serv_addr,
		socklen_t	addrlen
	)

Create a connection 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.

Parameters

s	socket to connect
serv_addr	server address
addrlen	length of serv_addr

Returns

the connection handle

Definition at line 938 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection;
 
  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) &&
      (EINPROGRESS != errno))
  {
    /* maybe refused / unsupported address, try next */
    LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "connect");
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Attempt to connect to `%s' failed\n",
         GNUNET_a2s (serv_addr, addrlen));
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
    return NULL;
  }
  connection = GNUNET_CONNECTION_create_from_existing (s);
  connection->addr = GNUNET_malloc (addrlen);
  GNUNET_memcpy (connection->addr, serv_addr, addrlen);
  connection->addrlen = addrlen;
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Trying to connect to `%s' (%p)\n",
       GNUNET_a2s (serv_addr, addrlen),
       connection);
  return connection;
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_a2s(), GNUNET_break, GNUNET_CONNECTION_create_from_existing(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_OK, LOG, and LOG_STRERROR.

Referenced by GNUNET_CONNECTION_create_from_sockaddr(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_create_from_sockaddr()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_from_sockaddr	(	int	af_family,
		const struct sockaddr *	serv_addr,
		socklen_t	addrlen
	)

Create a connection handle by creating a socket and (asynchronously) connecting to a host.

This function returns immediately, even if the connection has not yet been established. This function only creates TCP connections.

Parameters

af_family	address family to use
serv_addr	server address
addrlen	length of serv_addr

Returns

the connection handle

Definition at line 979 of file tcp_connection_legacy.c.

{
  struct GNUNET_NETWORK_Handle *s;
 
  s = GNUNET_NETWORK_socket_create (af_family, SOCK_STREAM, 0);
  if (NULL == s)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, "socket");
    return NULL;
  }
  return GNUNET_CONNECTION_connect_socket (s, serv_addr, addrlen);
}

References GNUNET_NETWORK_Handle::addrlen, GNUNET_CONNECTION_connect_socket(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_WARNING, GNUNET_NETWORK_socket_create(), and LOG_STRERROR.

Referenced by tcp_plugin_get_network(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_check()

int GNUNET_CONNECTION_check

(

struct GNUNET_CONNECTION_Handle *

connection

)

Check if connection is valid (no fatal errors have happened so far).

Note that a connection that is still trying to connect is considered valid.

Parameters

connection

connection to check

Returns

GNUNET_YES if valid, GNUNET_NO otherwise

Definition at line 1004 of file tcp_connection_legacy.c.

{
  if ((NULL != connection->ap_head) || (NULL != connection->dns_active) ||
      (NULL != connection->proxy_handshake))
    return GNUNET_YES; /* still trying to connect */
  if ((0 != connection->destroy_later) || (NULL == connection->sock))
    return GNUNET_NO;
  return GNUNET_YES;
}

References GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::destroy_later, GNUNET_CONNECTION_Handle::dns_active, GNUNET_NO, GNUNET_YES, GNUNET_CONNECTION_Handle::proxy_handshake, and GNUNET_CONNECTION_Handle::sock.

Referenced by process_incoming().

Here is the caller graph for this function:

GNUNET_CONNECTION_destroy()

void GNUNET_CONNECTION_destroy

(

struct GNUNET_CONNECTION_Handle *

connection

)

Close the connection and free associated resources.

There must not be any pending requests for reading or writing to the connection at this time.

Parameters

connection

connection to destroy

Definition at line 1023 of file tcp_connection_legacy.c.

{
  struct AddressProbe *pos;
 
  if (0 != connection->destroy_later)
  {
    connection->destroy_later = -1;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down connection (%p)\n", connection);
  GNUNET_assert (NULL == connection->nth.notify_ready);
  GNUNET_assert (NULL == connection->receiver);
  if (NULL != connection->write_task)
  {
    GNUNET_SCHEDULER_cancel (connection->write_task);
    connection->write_task = NULL;
    connection->write_buffer_off = 0;
  }
  if (NULL != connection->read_task)
  {
    GNUNET_SCHEDULER_cancel (connection->read_task);
    connection->read_task = NULL;
  }
  if (NULL != connection->nth.timeout_task)
  {
    GNUNET_SCHEDULER_cancel (connection->nth.timeout_task);
    connection->nth.timeout_task = NULL;
  }
  connection->nth.notify_ready = NULL;
  if (NULL != connection->dns_active)
  {
    GNUNET_RESOLVER_request_cancel (connection->dns_active);
    connection->dns_active = NULL;
  }
  if (NULL != connection->proxy_handshake)
  {
    /* GNUNET_CONNECTION_destroy (connection->proxy_handshake); */
    connection->proxy_handshake->destroy_later = -1;
    connection->proxy_handshake = NULL;   /* Not leaked ??? */
  }
  while (NULL != (pos = connection->ap_head))
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
    GNUNET_SCHEDULER_cancel (pos->task);
    GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, pos);
    GNUNET_free (pos);
  }
  if ((NULL != connection->sock) && (GNUNET_YES != connection->persist))
  {
    if ((GNUNET_OK !=
         GNUNET_NETWORK_socket_shutdown (connection->sock, SHUT_RDWR)) &&
        (ENOTCONN != errno) && (ECONNRESET != errno))
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "shutdown");
  }
  if (NULL != connection->sock)
  {
    if (GNUNET_YES != connection->persist)
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_NETWORK_socket_close (connection->sock));
    }
    else
    {
      GNUNET_NETWORK_socket_free_memory_only_ (
        connection->sock);     /* at least no memory leak (we deliberately
                                * leak the socket in this special case) ... */
    }
  }
  GNUNET_free (connection->addr);
  GNUNET_free (connection->hostname);
  GNUNET_free (connection->write_buffer);
  GNUNET_free (connection);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::ap_tail, AddressProbe::connection, GNUNET_CONNECTION_Handle::destroy_later, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_NETWORK_socket_shutdown(), GNUNET_OK, GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_CONNECTION_Handle::hostname, LOG, LOG_STRERROR, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::persist, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_CONNECTION_Handle::read_task, GNUNET_CONNECTION_Handle::receiver, AddressProbe::sock, GNUNET_CONNECTION_Handle::sock, AddressProbe::task, GNUNET_CONNECTION_TransmitHandle::timeout_task, GNUNET_CONNECTION_Handle::write_buffer, GNUNET_CONNECTION_Handle::write_buffer_off, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_fail_continuation(), GNUNET_CONNECTION_acivate_proxied(), GNUNET_SERVER_client_disconnect(), libgnunet_plugin_transport_tcp_done(), and notify_send_probe().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_receive()

int GNUNET_CONNECTION_receive	(	struct GNUNET_CONNECTION_Handle *	connection,
		size_t	max,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_CONNECTION_Receiver	receiver,
		void *	receiver_cls
	)

Receive data from the given connection.

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 connection at any given point in time (so do not call receive again until the receiver callback has been invoked).

Parameters

connection	connection handle
max	maximum number of bytes to read
timeout	maximum amount of time to wait
receiver	function to call with received data
receiver_cls	closure for receiver

Returns

GNUNET_SYSERR if connection died (receiver was called with error)

Definition at line 1177 of file tcp_connection_legacy.c.

{
  GNUNET_assert ((NULL == connection->read_task) &&
                 (NULL == connection->receiver));
  GNUNET_assert (NULL != receiver);
  connection->receiver = receiver;
  connection->receiver_cls = receiver_cls;
  connection->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
  connection->max = max;
  if (NULL != connection->sock)
  {
    connection->read_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
                                       connection->receive_timeout),
                                     connection->sock,
                                     &receive_ready,
                                     connection);
    return GNUNET_OK;
  }
  if ((NULL == connection->dns_active) && (NULL == connection->ap_head) &&
      (NULL == connection->proxy_handshake))
  {
    connection->receiver = NULL;
    receiver (receiver_cls, NULL, 0, NULL, 0, ETIMEDOUT);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), max, GNUNET_CONNECTION_Handle::max, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_CONNECTION_Handle::read_task, receive_ready(), GNUNET_CONNECTION_Handle::receive_timeout, GNUNET_CONNECTION_Handle::receiver, receiver(), GNUNET_CONNECTION_Handle::receiver_cls, GNUNET_CONNECTION_Handle::sock, and timeout.

Referenced by GNUNET_SERVER_connect_socket(), process_incoming(), process_mst(), register_reciever(), and restart_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_receive_cancel()

void* GNUNET_CONNECTION_receive_cancel

(

struct GNUNET_CONNECTION_Handle *

connection

)

Cancel receive job on the given connection.

Note that the receiver callback must not have been called yet in order for the cancellation to be valid.

Parameters

connection

connection handle

Returns

closure of the original receiver callback closure

Definition at line 1220 of file tcp_connection_legacy.c.

{
  if (NULL != connection->read_task)
  {
    GNUNET_assert (connection ==
                   GNUNET_SCHEDULER_cancel (connection->read_task));
    connection->read_task = NULL;
  }
  connection->receiver = NULL;
  return connection->receiver_cls;
}

References GNUNET_assert, GNUNET_SCHEDULER_cancel(), GNUNET_CONNECTION_Handle::read_task, GNUNET_CONNECTION_Handle::receiver, and GNUNET_CONNECTION_Handle::receiver_cls.

Referenced by GNUNET_SERVER_client_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

process_notify()

static int process_notify ( struct GNUNET_CONNECTION_Handle *  connection )

static

Try to call the transmit notify method (check if we do have enough space available first)!

Parameters

connection

connection for which we should do this processing

Returns

GNUNET_YES if we were able to call notify

Definition at line 1241 of file tcp_connection_legacy.c.

{
  size_t used;
  size_t avail;
  size_t size;
  GNUNET_CONNECTION_TransmitReadyNotify notify;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "process_notify is running\n");
  GNUNET_assert (NULL == connection->write_task);
  if (NULL == (notify = connection->nth.notify_ready))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "No one to notify\n");
    return GNUNET_NO;
  }
  used = connection->write_buffer_off - connection->write_buffer_pos;
  avail = connection->write_buffer_size - used;
  size = connection->nth.notify_size;
  if (size > avail)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Not enough buffer\n");
    return GNUNET_NO;
  }
  connection->nth.notify_ready = NULL;
  if (connection->write_buffer_size - connection->write_buffer_off < size)
  {
    /* need to compact */
    memmove (connection->write_buffer,
             &connection->write_buffer[connection->write_buffer_pos],
             used);
    connection->write_buffer_off -= connection->write_buffer_pos;
    connection->write_buffer_pos = 0;
  }
  avail = connection->write_buffer_size - connection->write_buffer_off;
  GNUNET_assert (avail >= size);
  size = notify (connection->nth.notify_ready_cls,
                 avail,
                 &connection->write_buffer[connection->write_buffer_off]);
  GNUNET_assert (size <= avail);
  if (0 != size)
    connection->write_buffer_off += size;
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_YES, LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_TransmitHandle::notify_size, GNUNET_CONNECTION_Handle::nth, size, GNUNET_CONNECTION_Handle::write_buffer, GNUNET_CONNECTION_Handle::write_buffer_off, GNUNET_CONNECTION_Handle::write_buffer_pos, GNUNET_CONNECTION_Handle::write_buffer_size, and GNUNET_CONNECTION_Handle::write_task.

Referenced by transmit_ready().

Here is the caller graph for this function:

transmit_timeout()

static void transmit_timeout ( void *  cls )

static

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.

Parameters

cls	the struct GNUNET_CONNECTION_Handle

Definition at line 1296 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection = cls;
  GNUNET_CONNECTION_TransmitReadyNotify notify;
 
  connection->nth.timeout_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
       connection->hostname,
       connection->port,
       GNUNET_a2s (connection->addr, connection->addrlen),
       connection);
  notify = connection->nth.notify_ready;
  GNUNET_assert (NULL != notify);
  connection->nth.notify_ready = NULL;
  notify (connection->nth.notify_ready_cls, 0, NULL);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_CONNECTION_Handle::hostname, LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::port, and GNUNET_CONNECTION_TransmitHandle::timeout_task.

Referenced by GNUNET_CONNECTION_notify_transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_error()

static void connect_error ( void *  cls )

static

Task invoked by the scheduler when we failed to connect at the time of being asked to transmit.

This task notifies the client about the error.

Parameters

cls	the struct GNUNET_CONNECTION_Handle

Definition at line 1324 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *connection = cls;
  GNUNET_CONNECTION_TransmitReadyNotify notify;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmission request of size %lu fails (%s/%u), connection failed (%p).\n",
       (unsigned long) connection->nth.notify_size,
       connection->hostname,
       connection->port,
       connection);
  connection->write_task = NULL;
  notify = connection->nth.notify_ready;
  connection->nth.notify_ready = NULL;
  notify (connection->nth.notify_ready_cls, 0, NULL);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_CONNECTION_Handle::hostname, LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_TransmitHandle::notify_size, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::port, and GNUNET_CONNECTION_Handle::write_task.

Referenced by GNUNET_CONNECTION_notify_transmit_ready().

Here is the caller graph for this function:

GNUNET_CONNECTION_notify_transmit_ready()

struct GNUNET_CONNECTION_TransmitHandle* GNUNET_CONNECTION_notify_transmit_ready	(	struct GNUNET_CONNECTION_Handle *	connection,
		size_t	size,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_CONNECTION_TransmitReadyNotify	notify,
		void *	notify_cls
	)

Ask the connection to call us once the specified number of bytes are free in the transmission buffer.

Will never call the notify callback in this task, but always first go into the scheduler.

Parameters

connection	connection
size	number of bytes to send
timeout	after how long should we give up (and call notify with buf NULL and size 0)?
notify	function to call
notify_cls	closure for notify

Returns

non-NULL if the notify callback was queued, NULL if we are already going to notify someone else (busy)

Definition at line 1475 of file tcp_connection_legacy.c.

{
  if (NULL != connection->nth.notify_ready)
  {
    GNUNET_assert (0);
    return NULL;
  }
  GNUNET_assert (NULL != notify);
  GNUNET_assert (size < GNUNET_MAX_MESSAGE_SIZE);
  GNUNET_assert (connection->write_buffer_off <= connection->write_buffer_size);
  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_size);
  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_off);
  connection->nth.notify_ready = notify;
  connection->nth.notify_ready_cls = notify_cls;
  connection->nth.connection = connection;
  connection->nth.notify_size = size;
  connection->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
  GNUNET_assert (NULL == connection->nth.timeout_task);
  if ((NULL == connection->sock) && (NULL == connection->ap_head) &&
      (NULL == connection->dns_active) && (NULL == connection->proxy_handshake))
  {
    if (NULL != connection->write_task)
      GNUNET_SCHEDULER_cancel (connection->write_task);
    connection->write_task =
      GNUNET_SCHEDULER_add_now (&connect_error, connection);
    return &connection->nth;
  }
  if (NULL != connection->write_task)
    return &connection->nth; /* previous transmission still in progress */
  if (NULL != connection->sock)
  {
    /* connected, try to transmit now */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Scheduling transmission (%p).\n",
         connection);
    connection->write_task =
      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining (
                                        connection->nth.transmit_timeout),
                                      connection->sock,
                                      &transmit_ready,
                                      connection);
    return &connection->nth;
  }
  /* not yet connected, wait for connection */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Need to wait to schedule transmission for connection, adding timeout task (%p).\n",
       connection);
  connection->nth.timeout_task =
    GNUNET_SCHEDULER_add_delayed (timeout, &transmit_timeout, connection);
  return &connection->nth;
}

References GNUNET_CONNECTION_Handle::ap_head, connect_error(), GNUNET_CONNECTION_TransmitHandle::connection, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX_MESSAGE_SIZE, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_write_net(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), LOG, notify, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::notify_ready_cls, GNUNET_CONNECTION_TransmitHandle::notify_size, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::proxy_handshake, size, GNUNET_CONNECTION_Handle::sock, timeout, GNUNET_CONNECTION_TransmitHandle::timeout_task, transmit_ready(), GNUNET_CONNECTION_TransmitHandle::transmit_timeout, transmit_timeout(), GNUNET_CONNECTION_Handle::write_buffer_off, GNUNET_CONNECTION_Handle::write_buffer_pos, GNUNET_CONNECTION_Handle::write_buffer_size, and GNUNET_CONNECTION_Handle::write_task.

Referenced by GNUNET_SERVER_notify_transmit_ready(), register_sender(), and tcp_plugin_get_network().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_notify_transmit_ready_cancel()

void GNUNET_CONNECTION_notify_transmit_ready_cancel

(

struct GNUNET_CONNECTION_TransmitHandle *

th

)

Cancel the specified transmission-ready notification.

Parameters

th	notification to cancel

Definition at line 1539 of file tcp_connection_legacy.c.

{
  GNUNET_assert (NULL != th->notify_ready);
  th->notify_ready = NULL;
  if (NULL != th->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (th->timeout_task);
    th->timeout_task = NULL;
  }
  if (NULL != th->connection->write_task)
  {
    GNUNET_SCHEDULER_cancel (th->connection->write_task);
    th->connection->write_task = NULL;
  }
}

References GNUNET_CONNECTION_TransmitHandle::connection, GNUNET_assert, GNUNET_SCHEDULER_cancel(), GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_TransmitHandle::timeout_task, and GNUNET_CONNECTION_Handle::write_task.

Referenced by GNUNET_SERVER_notify_transmit_ready_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_create_proxied_from_handshake()

struct GNUNET_CONNECTION_Handle* GNUNET_CONNECTION_create_proxied_from_handshake

(

struct GNUNET_CONNECTION_Handle *

cph

)

Create a connection to be proxied using a given connection.

Parameters

cph	connection to proxy server

Returns

connection to be proxied

Definition at line 1564 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *proxied =
    GNUNET_CONNECTION_create_from_existing (NULL);
 
  proxied->proxy_handshake = cph;
  return proxied;
}

References GNUNET_CONNECTION_create_from_existing(), and GNUNET_CONNECTION_Handle::proxy_handshake.

Referenced by GNUNET_SOCKS_run_handshake().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_acivate_proxied()

void GNUNET_CONNECTION_acivate_proxied

(

struct GNUNET_CONNECTION_Handle *

proxied

)

Activate proxied connection and destroy initial proxy handshake connection.

There must not be any pending requests for reading or writing to the proxy hadshake connection at this time.

Parameters

proxied

connection connection to proxy server

Definition at line 1583 of file tcp_connection_legacy.c.

{
  struct GNUNET_CONNECTION_Handle *cph = proxied->proxy_handshake;
 
  GNUNET_assert (NULL != cph);
  GNUNET_assert (NULL == proxied->sock);
  GNUNET_assert (NULL != cph->sock);
  proxied->sock = cph->sock;
  cph->sock = NULL;
  GNUNET_CONNECTION_destroy (cph);
  connect_success_continuation (proxied);
}

References connect_success_continuation(), GNUNET_assert, GNUNET_CONNECTION_destroy(), GNUNET_CONNECTION_Handle::proxy_handshake, and GNUNET_CONNECTION_Handle::sock.

Referenced by SOCKS5_handshake_done().

Here is the call graph for this function:

Here is the caller graph for this function: