GNUnet  0.10.x
Data Structures | Macros | Functions
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_HandleGNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle *osSocket)
 Create a connection handle by boxing an existing OS socket. More...
 
struct GNUNET_CONNECTION_HandleGNUNET_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_HandleGNUNET_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_HandleGNUNET_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_HandleGNUNET_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_HandleGNUNET_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_TransmitHandleGNUNET_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_HandleGNUNET_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.

Referenced by GNUNET_CONNECTION_create_from_connect(), and try_connect_using_address().

◆ LOG_STRERROR

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

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
connectionthe connection to set persistent

Definition at line 278 of file tcp_connection_legacy.c.

References GNUNET_YES, and GNUNET_CONNECTION_Handle::persist.

Referenced by GNUNET_SERVER_client_disconnect().

279 {
280  connection->persist = GNUNET_YES;
281 }
int8_t persist
When shutdown, do not ever actually close the socket, but free resources.
#define GNUNET_YES
Definition: gnunet_common.h:80
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
connectionthe connection to make flushing and blocking
Returns
GNUNET_OK on success

Definition at line 296 of file tcp_connection_legacy.c.

References GNUNET_NETWORK_socket_disable_corking(), and GNUNET_CONNECTION_Handle::sock.

Referenced by GNUNET_SERVER_client_disable_corking().

297 {
298  return GNUNET_NETWORK_socket_disable_corking (connection->sock);
299 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS's socket, set to NULL after fatal errors.
int GNUNET_NETWORK_socket_disable_corking(struct GNUNET_NETWORK_Handle *desc)
Disable the "CORK" feature for communication with the given socket, forcing the OS to immediately flu...
Definition: network.c:1089
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
osSocketexisting socket to box
Returns
the boxed connection handle

Definition at line 311 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_TransmitHandle::connection, 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().

312 {
313  struct GNUNET_CONNECTION_Handle *connection;
314 
315  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
317  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
318  connection->sock = osSocket;
319  return connection;
320 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS's socket, set to NULL after fatal errors.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
size_t write_buffer_size
Current size of our write_buffer.
#define GNUNET_MIN_MESSAGE_SIZE
Smallest supported message.
char * write_buffer
Pointer to our write buffer.
handle for a network connection
#define GNUNET_malloc(size)
Wrapper around malloc.
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_cbfunction to use to check if access is allowed
access_cb_clsclosure for access_cb
lsocklisten socket
Returns
the connection handle, NULL on error

Definition at line 333 of file tcp_connection_legacy.c.

References _, GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_TransmitHandle::connection, 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().

336 {
337  struct GNUNET_CONNECTION_Handle *connection;
338  char addr[128];
339  socklen_t addrlen;
340  struct GNUNET_NETWORK_Handle *sock;
341  int aret;
342  struct sockaddr_in *v4;
343  struct sockaddr_in6 *v6;
344  struct sockaddr *sa;
345  void *uaddr;
346 #ifdef SO_PEERCRED
347  struct ucred uc;
348  socklen_t olen;
349 #endif
350  struct GNUNET_CONNECTION_Credentials *gcp;
351 #if HAVE_GETPEEREID || defined(SO_PEERCRED) || HAVE_GETPEERUCRED
353 
354  gc.uid = 0;
355  gc.gid = 0;
356 #endif
357 
358  addrlen = sizeof (addr);
359  sock =
361  (struct sockaddr *) &addr,
362  &addrlen);
363  if (NULL == sock)
364  {
365  if (EAGAIN != errno)
367  return NULL;
368  }
369  if ((addrlen > sizeof (addr)) || (addrlen < sizeof (sa_family_t)))
370  {
371  GNUNET_break (0);
373  return NULL;
374  }
375 
376  sa = (struct sockaddr *) addr;
377  v6 = (struct sockaddr_in6 *) addr;
378  if ( (AF_INET6 == sa->sa_family) &&
379  (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)) )
380  {
381  /* convert to V4 address */
382  v4 = GNUNET_new (struct sockaddr_in);
383  memset (v4, 0, sizeof (struct sockaddr_in));
384  v4->sin_family = AF_INET;
385 #if HAVE_SOCKADDR_IN_SIN_LEN
386  v4->sin_len = (u_char) sizeof (struct sockaddr_in);
387 #endif
388  GNUNET_memcpy (&v4->sin_addr,
389  &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -
390  sizeof (struct in_addr)],
391  sizeof (struct in_addr));
392  v4->sin_port = v6->sin6_port;
393  uaddr = v4;
394  addrlen = sizeof (struct sockaddr_in);
395  }
396  else
397  {
398  uaddr = GNUNET_malloc (addrlen);
399  GNUNET_memcpy (uaddr, addr, addrlen);
400  }
401  gcp = NULL;
402  if (AF_UNIX == sa->sa_family)
403  {
404 #if HAVE_GETPEEREID
405  /* most BSDs */
406  if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock),
407  &gc.uid,
408  &gc.gid))
409  gcp = &gc;
410 #else
411 #ifdef SO_PEERCRED
412  /* largely traditional GNU/Linux */
413  olen = sizeof (uc);
414  if ( (0 ==
415  getsockopt (GNUNET_NETWORK_get_fd (sock),
416  SOL_SOCKET,
417  SO_PEERCRED,
418  &uc,
419  &olen)) &&
420  (olen == sizeof (uc)) )
421  {
422  gc.uid = uc.uid;
423  gc.gid = uc.gid;
424  gcp = &gc;
425  }
426 #else
427 #if HAVE_GETPEERUCRED
428  /* this is for Solaris 10 */
429  ucred_t *uc;
430 
431  uc = NULL;
432  if (0 == getpeerucred (GNUNET_NETWORK_get_fd (sock), &uc))
433  {
434  gc.uid = ucred_geteuid (uc);
435  gc.gid = ucred_getegid (uc);
436  gcp = &gc;
437  }
438  ucred_free (uc);
439 #endif
440 #endif
441 #endif
442  }
443 
444  if ( (NULL != access_cb) &&
445  (GNUNET_YES != (aret = access_cb (access_cb_cls,
446  gcp,
447  uaddr,
448  addrlen))) )
449  {
450  if (GNUNET_NO == aret)
452  _("Access denied to `%s'\n"),
453  GNUNET_a2s (uaddr,
454  addrlen));
457  SHUT_RDWR));
459  GNUNET_free (uaddr);
460  return NULL;
461  }
462  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
464  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
465  connection->addr = uaddr;
466  connection->addrlen = addrlen;
467  connection->sock = sock;
469  _("Accepting connection from `%s': %p\n"),
470  GNUNET_a2s (uaddr,
471  addrlen),
472  connection);
473  return connection;
474 }
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1268
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define LOG(kind,...)
Definition: arm_api.c:33
uid_t uid
UID of the other end of the connection.
static struct GNUNET_FS_UnindexContext * uc
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc, int how)
Shut down socket operations.
Definition: network.c:1065
size_t write_buffer_size
Current size of our write_buffer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_accept(const struct GNUNET_NETWORK_Handle *desc, struct sockaddr *address, socklen_t *address_len)
Accept a new connection on a socket.
Definition: network.c:468
#define GNUNET_memcpy(dst, src, n)
struct sockaddr * addr
Network address of the other end-point, may be NULL.
#define GNUNET_MIN_MESSAGE_SIZE
Smallest supported message.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
Credentials for UNIX domain sockets.
handle to a socket
Definition: network.c:46
#define GNUNET_YES
Definition: gnunet_common.h:80
socklen_t addrlen
Length of addr.
char * write_buffer
Pointer to our write buffer.
handle for a network connection
#define LOG_STRERROR(kind, syscall)
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
connectionthe client to get the address for
addrwhere to store the address
addrlenwhere to store the length of the addr
Returns
GNUNET_OK on success

Definition at line 486 of file tcp_connection_legacy.c.

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().

489 {
490  if ((NULL == connection->addr) || (0 == connection->addrlen))
491  return GNUNET_NO;
492  *addr = GNUNET_malloc (connection->addrlen);
493  GNUNET_memcpy (*addr, connection->addr, connection->addrlen);
494  *addrlen = connection->addrlen;
495  return GNUNET_OK;
496 }
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_memcpy(dst, src, n)
struct sockaddr * addr
Network address of the other end-point, may be NULL.
socklen_t addrlen
Length of addr.
#define GNUNET_malloc(size)
Wrapper around malloc.
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
connectionconnection to signal error
errcodeerror code to send

Definition at line 506 of file tcp_connection_legacy.c.

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

Referenced by connect_fail_continuation(), and receive_ready().

508 {
510 
512  "Receive encounters error (%s), connection closed (%p)\n",
513  STRERROR (errcode),
514  connection);
515  GNUNET_assert (NULL != (receiver = connection->receiver));
516  connection->receiver = NULL;
517  receiver (connection->receiver_cls,
518  NULL,
519  0,
520  connection->addr,
521  connection->addrlen,
522  errcode);
523 }
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define STRERROR(i)
Definition: plibc.h:676
void(* GNUNET_CONNECTION_Receiver)(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback function for data received from the network.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
socklen_t addrlen
Length of addr.
void * receiver_cls
Closure for receiver.
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
connectionconnection to signal for

Definition at line 532 of file tcp_connection_legacy.c.

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

Referenced by receive_ready(), and signal_transmit_error().

533 {
535 
537  "Connection signals timeout to receiver (%p)!\n",
538  connection);
539  GNUNET_assert (NULL != (receiver = connection->receiver));
540  connection->receiver = NULL;
541  receiver (connection->receiver_cls, NULL, 0, NULL, 0, 0);
542 }
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void(* GNUNET_CONNECTION_Receiver)(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback function for data received from the network.
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
void * receiver_cls
Closure for receiver.
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
connectionhandle that had trouble
ecodeerror code (errno)

Definition at line 552 of file tcp_connection_legacy.c.

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, STRERROR, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_fail_continuation(), and transmit_ready().

554 {
556 
558  "Transmission encounterd error (%s), connection closed (%p)\n",
559  STRERROR (ecode),
560  connection);
561  if (NULL != connection->sock)
562  {
563  (void) GNUNET_NETWORK_socket_shutdown (connection->sock,
564  SHUT_RDWR);
566  GNUNET_NETWORK_socket_close (connection->sock));
567  connection->sock = NULL;
568  GNUNET_assert (NULL == connection->write_task);
569  }
570  if (NULL != connection->read_task)
571  {
572  /* send errors trigger read errors... */
573  GNUNET_SCHEDULER_cancel (connection->read_task);
574  connection->read_task = NULL;
575  signal_receive_timeout (connection);
576  return;
577  }
578  if (NULL == connection->nth.notify_ready)
579  return; /* nobody to tell about it */
580  notify = connection->nth.notify_ready;
581  connection->nth.notify_ready = NULL;
582  notify (connection->nth.notify_ready_cls,
583  0,
584  NULL);
585 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define STRERROR(i)
Definition: plibc.h:676
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
int GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc, int how)
Shut down socket operations.
Definition: network.c:1065
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
size_t(* GNUNET_CONNECTION_TransmitReadyNotify)(void *cls, size_t size, void *buf)
Function called to notify a client about the connection begin ready to queue more data...
void * notify_ready_cls
Closure for notify_ready.
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
static void signal_receive_timeout(struct GNUNET_CONNECTION_Handle *connection)
Tell the receiver callback that a timeout was reached.
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
connectionthe connection we tried to establish

Definition at line 595 of file tcp_connection_legacy.c.

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, receive_ready(), GNUNET_CONNECTION_Handle::receiver, signal_receive_error(), signal_transmit_error(), GNUNET_CONNECTION_Handle::sock, GNUNET_CONNECTION_TransmitHandle::timeout_task, transmit_ready(), and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_probe_continuation(), and try_connect_using_address().

596 {
598  "Failed to establish TCP connection to `%s:%u', no further addresses to try.\n",
599  connection->hostname,
600  connection->port);
601  GNUNET_break (NULL == connection->ap_head);
602  GNUNET_break (NULL == connection->ap_tail);
603  GNUNET_break (GNUNET_NO == connection->dns_active);
604  GNUNET_break (NULL == connection->sock);
605  GNUNET_assert (NULL == connection->write_task);
606  GNUNET_assert (NULL == connection->proxy_handshake);
607 
608  /* signal errors for jobs that used to wait on the connection */
609  connection->destroy_later = 1;
610  if (NULL != connection->receiver)
611  signal_receive_error (connection,
612  ECONNREFUSED);
613  if (NULL != connection->nth.notify_ready)
614  {
615  GNUNET_assert (NULL != connection->nth.timeout_task);
617  connection->nth.timeout_task = NULL;
618  signal_transmit_error (connection,
619  ECONNREFUSED);
620  }
621  if (-1 == connection->destroy_later)
622  {
623  /* do it now */
624  connection->destroy_later = 0;
625  GNUNET_CONNECTION_destroy (connection);
626  return;
627  }
628  connection->destroy_later = 0;
629 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void signal_receive_error(struct GNUNET_CONNECTION_Handle *connection, int errcode)
Tell the receiver callback that we had an IO error.
#define GNUNET_NO
Definition: gnunet_common.h:81
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
uint16_t port
Port to connect to.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
void GNUNET_CONNECTION_destroy(struct GNUNET_CONNECTION_Handle *connection)
Close the connection and free associated resources.
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
static void signal_transmit_error(struct GNUNET_CONNECTION_Handle *connection, int ecode)
We failed to transmit data to the service, signal the error.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsour connection handle

Definition at line 1408 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_TransmitHandle::connection, 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_fail_continuation(), connect_success_continuation(), and GNUNET_CONNECTION_notify_transmit_ready().

1409 {
1410  struct GNUNET_CONNECTION_Handle *connection = cls;
1412  const struct GNUNET_SCHEDULER_TaskContext *tc;
1413  ssize_t ret;
1414  size_t have;
1415 
1417  "transmit_ready running (%p).\n",
1418  connection);
1419  GNUNET_assert (NULL != connection->write_task);
1420  connection->write_task = NULL;
1421  GNUNET_assert (NULL == connection->nth.timeout_task);
1423  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
1424  {
1426  "Transmit to `%s' fails, time out reached (%p).\n",
1427  GNUNET_a2s (connection->addr,
1428  connection->addrlen),
1429  connection);
1430  notify = connection->nth.notify_ready;
1431  GNUNET_assert (NULL != notify);
1432  connection->nth.notify_ready = NULL;
1433  notify (connection->nth.notify_ready_cls, 0, NULL);
1434  return;
1435  }
1436  GNUNET_assert (NULL != connection->sock);
1437  if (NULL == tc->write_ready)
1438  {
1439  /* special circumstances (in particular, PREREQ_DONE after
1440  * connect): not yet ready to write, but no "fatal" error either.
1441  * Hence retry. */
1442  goto SCHEDULE_WRITE;
1443  }
1445  connection->sock))
1446  {
1447  GNUNET_assert (NULL == connection->write_task);
1448  /* special circumstances (in particular, shutdown): not yet ready
1449  * to write, but no "fatal" error either. Hence retry. */
1450  goto SCHEDULE_WRITE;
1451  }
1452  GNUNET_assert (connection->write_buffer_off >= connection->write_buffer_pos);
1453  if ((NULL != connection->nth.notify_ready) &&
1454  (connection->write_buffer_size < connection->nth.notify_size))
1455  {
1456  connection->write_buffer =
1457  GNUNET_realloc (connection->write_buffer, connection->nth.notify_size);
1458  connection->write_buffer_size = connection->nth.notify_size;
1459  }
1460  process_notify (connection);
1461  have = connection->write_buffer_off - connection->write_buffer_pos;
1462  if (0 == have)
1463  {
1464  /* no data ready for writing, terminate write loop */
1465  return;
1466  }
1467  GNUNET_assert (have <= connection->write_buffer_size);
1468  GNUNET_assert (have + connection->write_buffer_pos <= connection->write_buffer_size);
1469  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_size);
1470 RETRY:
1471  ret =
1472  GNUNET_NETWORK_socket_send (connection->sock,
1473  &connection->write_buffer[connection->write_buffer_pos],
1474  have);
1475  if (-1 == ret)
1476  {
1477  if (EINTR == errno)
1478  goto RETRY;
1479  if (NULL != connection->write_task)
1480  {
1481  GNUNET_SCHEDULER_cancel (connection->write_task);
1482  connection->write_task = NULL;
1483  }
1484  signal_transmit_error (connection, errno);
1485  return;
1486  }
1488  "Connection transmitted %u/%u bytes to `%s' (%p)\n",
1489  (unsigned int) ret,
1490  have,
1491  GNUNET_a2s (connection->addr,
1492  connection->addrlen),
1493  connection);
1494  connection->write_buffer_pos += ret;
1495  if (connection->write_buffer_pos == connection->write_buffer_off)
1496  {
1497  /* transmitted all pending data */
1498  connection->write_buffer_pos = 0;
1499  connection->write_buffer_off = 0;
1500  }
1501  if ( (0 == connection->write_buffer_off) &&
1502  (NULL == connection->nth.notify_ready) )
1503  return; /* all data sent! */
1504  /* not done writing, schedule more */
1505 SCHEDULE_WRITE:
1507  "Re-scheduling transmit_ready (more to do) (%p).\n",
1508  connection);
1509  have = connection->write_buffer_off - connection->write_buffer_pos;
1510  GNUNET_assert ( (NULL != connection->nth.notify_ready) ||
1511  (have > 0) );
1512  if (NULL == connection->write_task)
1513  connection->write_task =
1517  (connection->nth.transmit_timeout),
1518  connection->sock,
1519  &transmit_ready, connection);
1520 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:746
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define RETRY
Return code we give on &#39;send&#39; if we failed to send right now but it makes sense to retry later...
ssize_t GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc, const void *buffer, size_t length)
Send data (always non-blocking).
Definition: network.c:927
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)! ...
Context information passed to each scheduler task.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
const struct GNUNET_NETWORK_FDSet * write_ready
Set of file descriptors ready for writing; note that additional bits may be set that were not in the ...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1548
static int ret
Final status code.
Definition: gnunet-arm.c:89
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
size_t write_buffer_size
Current size of our write_buffer.
size_t(* GNUNET_CONNECTION_TransmitReadyNotify)(void *cls, size_t size, void *buf)
Function called to notify a client about the connection begin ready to queue more data...
void * notify_ready_cls
Closure for notify_ready.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
#define GNUNET_realloc(ptr, size)
Wrapper around realloc.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
size_t write_buffer_off
Current write-offset in write_buffer (where would we write next).
static void transmit_ready(void *cls)
We are ready to transmit (or got a timeout).
size_t write_buffer_pos
Current read-offset in write_buffer (how many bytes have already been sent).
The specified timeout has expired.
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
size_t notify_size
At what number of bytes available in the write buffer should the notify method be called...
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
struct GNUNET_TIME_Absolute transmit_timeout
Timeout for receiving (in absolute time).
socklen_t addrlen
Length of addr.
char * write_buffer
Pointer to our write buffer.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition: network.c:1181
handle for a network connection
static void signal_transmit_error(struct GNUNET_CONNECTION_Handle *connection, int ecode)
We failed to transmit data to the service, signal the error.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsconnection to read from

Definition at line 1150 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_TransmitHandle::connection, 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, GNUNET_CONNECTION_Handle::receiver_cls, ret, RETRY, signal_receive_error(), signal_receive_timeout(), GNUNET_CONNECTION_Handle::sock, and tc.

Referenced by connect_fail_continuation(), connect_success_continuation(), and GNUNET_CONNECTION_receive().

1151 {
1152  struct GNUNET_CONNECTION_Handle *connection = cls;
1153  const struct GNUNET_SCHEDULER_TaskContext *tc;
1154  char buffer[connection->max];
1155  ssize_t ret;
1156  GNUNET_CONNECTION_Receiver receiver;
1157 
1158  connection->read_task = NULL;
1160  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
1161  {
1163  "Receive from `%s' encounters error: timeout (%s, %p)\n",
1164  GNUNET_a2s (connection->addr,
1165  connection->addrlen),
1167  GNUNET_YES),
1168  connection);
1169  signal_receive_timeout (connection);
1170  return;
1171  }
1172  if (NULL == connection->sock)
1173  {
1174  /* connect failed for good */
1175  signal_receive_error (connection, ECONNREFUSED);
1176  return;
1177  }
1179  connection->sock));
1180 RETRY:
1181  ret = GNUNET_NETWORK_socket_recv (connection->sock,
1182  buffer,
1183  connection->max);
1184  if (-1 == ret)
1185  {
1186  if (EINTR == errno)
1187  goto RETRY;
1188  signal_receive_error (connection, errno);
1189  return;
1190  }
1192  "receive_ready read %u/%u bytes from `%s' (%p)!\n",
1193  (unsigned int) ret,
1194  connection->max,
1195  GNUNET_a2s (connection->addr,
1196  connection->addrlen),
1197  connection);
1198  GNUNET_assert (NULL != (receiver = connection->receiver));
1199  connection->receiver = NULL;
1200  receiver (connection->receiver_cls,
1201  buffer,
1202  ret,
1203  connection->addr,
1204  connection->addrlen,
1205  0);
1206 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:746
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define RETRY
Return code we give on &#39;send&#39; if we failed to send right now but it makes sense to retry later...
Context information passed to each scheduler task.
ssize_t GNUNET_NETWORK_socket_recv(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length)
Read data from a connected socket (always non-blocking).
Definition: network.c:894
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
static void signal_receive_error(struct GNUNET_CONNECTION_Handle *connection, int errcode)
Tell the receiver callback that we had an IO error.
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...
static int ret
Final status code.
Definition: gnunet-arm.c:89
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
void(* GNUNET_CONNECTION_Receiver)(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback function for data received from the network.
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
struct GNUNET_TIME_Absolute receive_timeout
Timeout for receiving (in absolute time).
The specified timeout has expired.
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
static void signal_receive_timeout(struct GNUNET_CONNECTION_Handle *connection)
Tell the receiver callback that a timeout was reached.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
size_t max
Maximum number of bytes to read (for receiving).
#define GNUNET_YES
Definition: gnunet_common.h:80
socklen_t addrlen
Length of addr.
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition: network.c:1181
handle for a network connection
void * receiver_cls
Closure for receiver.
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
connectionthe connection we tried to establish

Definition at line 657 of file tcp_connection_legacy.c.

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().

658 {
660  "Connection to `%s' succeeded! (%p)\n",
661  GNUNET_a2s (connection->addr,
662  connection->addrlen),
663  connection);
664  /* trigger jobs that waited for the connection */
665  if (NULL != connection->receiver)
666  {
668  "Connection succeeded, starting with receiving data (%p)\n",
669  connection);
670  GNUNET_assert (NULL == connection->read_task);
671  connection->read_task =
673  (connection->receive_timeout),
674  connection->sock,
675  &receive_ready, connection);
676  }
677  if (NULL != connection->nth.notify_ready)
678  {
680  "Connection succeeded, starting with sending data (%p)\n",
681  connection);
682  GNUNET_assert (connection->nth.timeout_task != NULL);
684  connection->nth.timeout_task = NULL;
685  GNUNET_assert (connection->write_task == NULL);
686  connection->write_task =
688  (connection->nth.transmit_timeout), connection->sock,
689  &transmit_ready, connection);
690  }
691 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1548
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
struct GNUNET_TIME_Absolute receive_timeout
Timeout for receiving (in absolute time).
static void transmit_ready(void *cls)
We are ready to transmit (or got a timeout).
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1478
struct GNUNET_TIME_Absolute transmit_timeout
Timeout for receiving (in absolute time).
socklen_t addrlen
Length of addr.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
static void receive_ready(void *cls)
This function is called once we either timeout or have data ready to read.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsthe struct AddressProbe * with the address that we are probing

Definition at line 701 of file tcp_connection_legacy.c.

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(), GNUNET_CONNECTION_TransmitHandle::connection, 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().

702 {
703  struct AddressProbe *ap = cls;
704  struct GNUNET_CONNECTION_Handle *connection = ap->connection;
705  const struct GNUNET_SCHEDULER_TaskContext *tc;
706  struct AddressProbe *pos;
707  int error;
708  socklen_t len;
709 
710  GNUNET_assert (NULL != ap->sock);
712  connection->ap_tail,
713  ap);
714  len = sizeof (error);
715  errno = 0;
716  error = 0;
718  if ( (0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
719  (GNUNET_OK !=
721  SOL_SOCKET,
722  SO_ERROR,
723  &error,
724  &len)) ||
725  (0 != error) )
726  {
729  GNUNET_free (ap);
730  if ( (NULL == connection->ap_head) &&
731  (GNUNET_NO == connection->dns_active) &&
732  (NULL == connection->proxy_handshake) )
733  connect_fail_continuation (connection);
734  return;
735  }
736  GNUNET_assert (NULL == connection->sock);
737  connection->sock = ap->sock;
738  GNUNET_assert (NULL == connection->addr);
739  connection->addr = GNUNET_malloc (ap->addrlen);
740  GNUNET_memcpy (connection->addr, ap->addr, ap->addrlen);
741  connection->addrlen = ap->addrlen;
742  GNUNET_free (ap);
743  /* cancel all other attempts */
744  while (NULL != (pos = connection->ap_head))
745  {
749  connection->ap_tail,
750  pos);
751  GNUNET_free (pos);
752  }
753  connect_success_continuation (connection);
754 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:746
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
const struct sockaddr * addr
The address; do not free (allocated at the end of this struct).
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
Context information passed to each scheduler task.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
int GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc, int level, int optname, void *optval, socklen_t *optlen)
Get socket options.
Definition: network.c:763
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void connect_fail_continuation(struct GNUNET_CONNECTION_Handle *connection)
We&#39;ve failed for good to establish a connection (timeout or no more addresses to try).
#define GNUNET_memcpy(dst, src, n)
struct sockaddr * addr
Network address of the other end-point, may be NULL.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
socklen_t addrlen
Lenth of addr.
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
The writing socket is ready.
static void connect_success_continuation(struct GNUNET_CONNECTION_Handle *connection)
We&#39;ve succeeded in establishing a connection.
socklen_t addrlen
Length of addr.
handle for a network connection
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#define GNUNET_malloc(size)
Wrapper around malloc.
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_CONNECTION_Handle * connection
Connection for which we are probing.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsour struct GNUNET_CONNECTION_Handle *
addraddress to try, NULL for "last call"
addrlenlength of addr

Definition at line 766 of file tcp_connection_legacy.c.

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, GNUNET_CONNECTION_TransmitHandle::connection, AddressProbe::connection, 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().

769 {
770  struct GNUNET_CONNECTION_Handle *connection = cls;
771  struct AddressProbe *ap;
773 
774  if (NULL == addr)
775  {
776  connection->dns_active = NULL;
777  if ((NULL == connection->ap_head) &&
778  (NULL == connection->sock) &&
779  (NULL == connection->proxy_handshake))
780  connect_fail_continuation (connection);
781  return;
782  }
783  if (NULL != connection->sock)
784  return; /* already connected */
785  GNUNET_assert (NULL == connection->addr);
786  /* try to connect */
788  "Trying to connect using address `%s:%u/%s:%u'\n",
789  connection->hostname,
790  connection->port,
791  GNUNET_a2s (addr, addrlen),
792  connection->port);
793  ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
794  ap->addr = (const struct sockaddr *) &ap[1];
795  GNUNET_memcpy (&ap[1], addr, addrlen);
796  ap->addrlen = addrlen;
797  ap->connection = connection;
798 
799  switch (ap->addr->sa_family)
800  {
801  case AF_INET:
802  ((struct sockaddr_in *) ap->addr)->sin_port = htons (connection->port);
803  break;
804  case AF_INET6:
805  ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (connection->port);
806  break;
807  default:
808  GNUNET_break (0);
809  GNUNET_free (ap);
810  return; /* not supported by us */
811  }
812  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
813  SOCK_STREAM, 0);
814  if (NULL == ap->sock)
815  {
816  GNUNET_free (ap);
817  return; /* not supported by OS */
818  }
820  "Trying to connect to `%s' (%p)\n",
821  GNUNET_a2s (ap->addr, ap->addrlen),
822  connection);
823  if ((GNUNET_OK !=
825  ap->addr,
826  ap->addrlen)) &&
827  (EINPROGRESS != errno))
828  {
829  /* maybe refused / unsupported address, try next */
832  GNUNET_free (ap);
833  return;
834  }
835  GNUNET_CONTAINER_DLL_insert (connection->ap_head, connection->ap_tail, ap);
837  if (NULL != connection->nth.notify_ready)
840  if (NULL != connection->receiver)
844  ap->sock,
846  ap);
847 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
const struct sockaddr * addr
The address; do not free (allocated at the end of this struct).
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static void connect_probe_continuation(void *cls)
Scheduler let us know that we&#39;re either ready to write on the socket OR connect timed out...
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1548
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
uint16_t port
Port to connect to.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void connect_fail_continuation(struct GNUNET_CONNECTION_Handle *connection)
We&#39;ve failed for good to establish a connection (timeout or no more addresses to try).
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
int GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:731
#define GNUNET_memcpy(dst, src, n)
struct sockaddr * addr
Network address of the other end-point, may be NULL.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
socklen_t addrlen
Lenth of addr.
struct GNUNET_TIME_Absolute receive_timeout
Timeout for receiving (in absolute time).
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:271
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_TIME_Absolute transmit_timeout
Timeout for receiving (in absolute time).
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
handle for a network connection
#define LOG_STRERROR(kind, syscall)
#define CONNECT_RETRY_TIMEOUT
Timeout we use on TCP connect before trying another result from the DNS resolver. ...
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#define GNUNET_malloc(size)
Wrapper around malloc.
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_CONNECTION_Handle * connection
Connection for which we are probing.
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:1037
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
cfgconfiguration to use
hostnamename of the host to connect to
portport to connect to
Returns
the connection handle

Definition at line 861 of file tcp_connection_legacy.c.

References cfg, GNUNET_CONNECTION_Handle::cfg, CONNECT_RETRY_TIMEOUT, GNUNET_CONNECTION_TransmitHandle::connection, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, GNUNET_RESOLVER_ip_get(), GNUNET_strdup, 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().

864 {
865  struct GNUNET_CONNECTION_Handle *connection;
866 
867  GNUNET_assert (0 < strlen (hostname)); /* sanity check */
868  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
869  connection->cfg = cfg;
871  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
872  connection->port = port;
873  connection->hostname = GNUNET_strdup (hostname);
874  connection->dns_active =
875  GNUNET_RESOLVER_ip_get (connection->hostname,
876  AF_UNSPEC,
879  connection);
880  return connection;
881 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition: resolver_api.c:927
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint16_t port
Port to connect to.
size_t write_buffer_size
Current size of our write_buffer.
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
#define GNUNET_MIN_MESSAGE_SIZE
Smallest supported message.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
static char * hostname
Our hostname; we give this to all the peers we start.
static void try_connect_using_address(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Try to establish a connection given the specified address.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
char * write_buffer
Pointer to our write buffer.
handle for a network connection
#define CONNECT_RETRY_TIMEOUT
Timeout we use on TCP connect before trying another result from the DNS resolver. ...
#define GNUNET_malloc(size)
Wrapper around malloc.
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
cfgconfiguration to use
unixpathpath to connect to
Returns
the connection handle, NULL on systems without UNIX support

Definition at line 894 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, cfg, GNUNET_CONNECTION_Handle::cfg, connect_success_continuation(), GNUNET_CONNECTION_TransmitHandle::connection, 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.

896 {
897 #ifdef AF_UNIX
898  struct GNUNET_CONNECTION_Handle *connection;
899  struct sockaddr_un *un;
900 
901  GNUNET_assert (0 < strlen (unixpath)); /* sanity check */
902  un = GNUNET_new (struct sockaddr_un);
903  un->sun_family = AF_UNIX;
904  GNUNET_strlcpy (un->sun_path, unixpath, sizeof (un->sun_path));
905 #ifdef LINUX
906  {
907  int abstract;
908 
909  abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
910  "TESTING",
911  "USE_ABSTRACT_SOCKETS");
912  if (GNUNET_YES == abstract)
913  un->sun_path[0] = '\0';
914  }
915 #endif
916 #if HAVE_SOCKADDR_UN_SUN_LEN
917  un->sun_len = (u_char) sizeof (struct sockaddr_un);
918 #endif
919  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
920  connection->cfg = cfg;
922  connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
923  connection->port = 0;
924  connection->hostname = NULL;
925  connection->addr = (struct sockaddr *) un;
926  connection->addrlen = sizeof (struct sockaddr_un);
927  connection->sock = GNUNET_NETWORK_socket_create (AF_UNIX,
928  SOCK_STREAM,
929  0);
930  if (NULL == connection->sock)
931  {
932  GNUNET_free (connection->addr);
933  GNUNET_free (connection->write_buffer);
934  GNUNET_free (connection);
935  return NULL;
936  }
937  if ( (GNUNET_OK !=
938  GNUNET_NETWORK_socket_connect (connection->sock,
939  connection->addr,
940  connection->addrlen)) &&
941  (EINPROGRESS != errno) )
942  {
943  /* Just return; we expect everything to work eventually so don't fail HARD */
945  GNUNET_NETWORK_socket_close (connection->sock));
946  connection->sock = NULL;
947  return connection;
948  }
949  connect_success_continuation (connection);
950  return connection;
951 #else
952  return NULL;
953 #endif
954 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t port
Port to connect to.
size_t write_buffer_size
Current size of our write_buffer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
int GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:731
struct sockaddr * addr
Network address of the other end-point, may be NULL.
#define GNUNET_MIN_MESSAGE_SIZE
Smallest supported message.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
static void connect_success_continuation(struct GNUNET_CONNECTION_Handle *connection)
We&#39;ve succeeded in establishing a connection.
#define GNUNET_YES
Definition: gnunet_common.h:80
socklen_t addrlen
Length of addr.
char * write_buffer
Pointer to our write buffer.
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
handle for a network connection
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:1037
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
ssocket to connect
serv_addrserver address
addrlenlength of serv_addr
Returns
the connection handle

Definition at line 968 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_TransmitHandle::connection, 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().

971 {
972  struct GNUNET_CONNECTION_Handle *connection;
973 
974  if ( (GNUNET_OK !=
975  GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) &&
976  (EINPROGRESS != errno) )
977  {
978  /* maybe refused / unsupported address, try next */
980  "connect");
982  "Attempt to connect to `%s' failed\n",
983  GNUNET_a2s (serv_addr,
984  addrlen));
986  return NULL;
987  }
989  connection->addr = GNUNET_malloc (addrlen);
990  GNUNET_memcpy (connection->addr, serv_addr, addrlen);
991  connection->addrlen = addrlen;
993  "Trying to connect to `%s' (%p)\n",
994  GNUNET_a2s (serv_addr, addrlen),
995  connection);
996  return connection;
997 }
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_CONNECTION_Handle * GNUNET_CONNECTION_create_from_existing(struct GNUNET_NETWORK_Handle *osSocket)
Create a connection handle by boxing an existing OS socket.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:731
#define GNUNET_memcpy(dst, src, n)
struct sockaddr * addr
Network address of the other end-point, may be NULL.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
socklen_t addrlen
Length of addr.
handle for a network connection
#define LOG_STRERROR(kind, syscall)
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#define GNUNET_malloc(size)
Wrapper around malloc.
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_familyaddress family to use
serv_addrserver address
addrlenlength of serv_addr
Returns
the connection handle

Definition at line 1012 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_connect_socket(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_WARNING, GNUNET_NETWORK_socket_create(), and LOG_STRERROR.

Referenced by tcp_plugin_get_session(), and try_connection_reversal().

1015 {
1016  struct GNUNET_NETWORK_Handle *s;
1017 
1018  s = GNUNET_NETWORK_socket_create (af_family, SOCK_STREAM, 0);
1019  if (NULL == s)
1020  {
1022  "socket");
1023  return NULL;
1024  }
1026  serv_addr,
1027  addrlen);
1028 }
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.
socklen_t addrlen
Number of bytes in addr.
Definition: network.c:67
handle to a socket
Definition: network.c:46
#define LOG_STRERROR(kind, syscall)
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:1037
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
connectionconnection to check
Returns
GNUNET_YES if valid, GNUNET_NO otherwise

Definition at line 1040 of file tcp_connection_legacy.c.

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().

1041 {
1042  if ((NULL != connection->ap_head) ||
1043  (NULL != connection->dns_active) ||
1044  (NULL != connection->proxy_handshake))
1045  return GNUNET_YES; /* still trying to connect */
1046  if ( (0 != connection->destroy_later) ||
1047  (NULL == connection->sock) )
1048  return GNUNET_NO;
1049  return GNUNET_YES;
1050 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
#define GNUNET_YES
Definition: gnunet_common.h:80
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
connectionconnection to destroy

Definition at line 1061 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, 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_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, 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().

1062 {
1063  struct AddressProbe *pos;
1064 
1065  if (0 != connection->destroy_later)
1066  {
1067  connection->destroy_later = -1;
1068  return;
1069  }
1071  "Shutting down connection (%p)\n",
1072  connection);
1073  GNUNET_assert (NULL == connection->nth.notify_ready);
1074  GNUNET_assert (NULL == connection->receiver);
1075  if (NULL != connection->write_task)
1076  {
1077  GNUNET_SCHEDULER_cancel (connection->write_task);
1078  connection->write_task = NULL;
1079  connection->write_buffer_off = 0;
1080  }
1081  if (NULL != connection->read_task)
1082  {
1083  GNUNET_SCHEDULER_cancel (connection->read_task);
1084  connection->read_task = NULL;
1085  }
1086  if (NULL != connection->nth.timeout_task)
1087  {
1089  connection->nth.timeout_task = NULL;
1090  }
1091  connection->nth.notify_ready = NULL;
1092  if (NULL != connection->dns_active)
1093  {
1095  connection->dns_active = NULL;
1096  }
1097  if (NULL != connection->proxy_handshake)
1098  {
1099  /* GNUNET_CONNECTION_destroy (connection->proxy_handshake); */
1100  connection->proxy_handshake->destroy_later = -1;
1101  connection->proxy_handshake = NULL; /* Not leaked ??? */
1102  }
1103  while (NULL != (pos = connection->ap_head))
1104  {
1107  GNUNET_CONTAINER_DLL_remove (connection->ap_head,
1108  connection->ap_tail,
1109  pos);
1110  GNUNET_free (pos);
1111  }
1112  if ( (NULL != connection->sock) &&
1113  (GNUNET_YES != connection->persist) )
1114  {
1115  if ((GNUNET_OK !=
1116  GNUNET_NETWORK_socket_shutdown (connection->sock,
1117  SHUT_RDWR)) &&
1118  (ENOTCONN != errno) &&
1119  (ECONNRESET != errno) )
1121  "shutdown");
1122  }
1123  if (NULL != connection->sock)
1124  {
1125  if (GNUNET_YES != connection->persist)
1126  {
1128  GNUNET_NETWORK_socket_close (connection->sock));
1129  }
1130  else
1131  {
1132  GNUNET_NETWORK_socket_free_memory_only_ (connection->sock); /* at least no memory leak (we deliberately
1133  * leak the socket in this special case) ... */
1134  }
1135  }
1136  GNUNET_free_non_null (connection->addr);
1137  GNUNET_free_non_null (connection->hostname);
1138  GNUNET_free (connection->write_buffer);
1139  GNUNET_free (connection);
1140 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
int GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc, int how)
Shut down socket operations.
Definition: network.c:1065
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_NETWORK_socket_free_memory_only_(struct GNUNET_NETWORK_Handle *desc)
Only free memory of a socket, keep the file descriptor untouched.
Definition: network.c:680
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
size_t write_buffer_off
Current write-offset in write_buffer (where would we write next).
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
int8_t persist
When shutdown, do not ever actually close the socket, but free resources.
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
#define GNUNET_YES
Definition: gnunet_common.h:80
char * write_buffer
Pointer to our write buffer.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
#define LOG_STRERROR(kind, syscall)
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
connectionconnection handle
maxmaximum number of bytes to read
timeoutmaximum amount of time to wait
receiverfunction to call with received data
receiver_clsclosure for receiver
Returns
GNUNET_SYSERR if connection died (receiver was called with error)

Definition at line 1225 of file tcp_connection_legacy.c.

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(), 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, GNUNET_CONNECTION_Handle::receiver_cls, and GNUNET_CONNECTION_Handle::sock.

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

1230 {
1231  GNUNET_assert ((NULL == connection->read_task) &&
1232  (NULL == connection->receiver));
1233  GNUNET_assert (NULL != receiver);
1234  connection->receiver = receiver;
1235  connection->receiver_cls = receiver_cls;
1236  connection->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1237  connection->max = max;
1238  if (NULL != connection->sock)
1239  {
1240  connection->read_task =
1242  (connection->receive_timeout),
1243  connection->sock,
1244  &receive_ready,
1245  connection);
1246  return GNUNET_OK;
1247  }
1248  if ((NULL == connection->dns_active) &&
1249  (NULL == connection->ap_head) &&
1250  (NULL == connection->proxy_handshake))
1251  {
1252  connection->receiver = NULL;
1253  receiver (receiver_cls,
1254  NULL, 0,
1255  NULL, 0,
1256  ETIMEDOUT);
1257  return GNUNET_SYSERR;
1258  }
1259  return GNUNET_OK;
1260 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
struct GNUNET_TIME_Absolute receive_timeout
Timeout for receiving (in absolute time).
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
size_t max
Maximum number of bytes to read (for receiving).
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1478
void * receiver_cls
Closure for receiver.
static void receive_ready(void *cls)
This function is called once we either timeout or have data ready to read.
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
connectionconnection handle
Returns
closure of the original receiver callback closure

Definition at line 1272 of file tcp_connection_legacy.c.

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().

1273 {
1274  if (NULL != connection->read_task)
1275  {
1276  GNUNET_assert (connection ==
1277  GNUNET_SCHEDULER_cancel (connection->read_task));
1278  connection->read_task = NULL;
1279  }
1280  connection->receiver = NULL;
1281  return connection->receiver_cls;
1282 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * read_task
Read task that we may need to wait for.
GNUNET_CONNECTION_Receiver receiver
Function to call on data received, NULL if no receive is pending.
void * receiver_cls
Closure for receiver.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
connectionconnection for which we should do this processing
Returns
GNUNET_YES if we were able to call notify

Definition at line 1293 of file tcp_connection_legacy.c.

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().

1294 {
1295  size_t used;
1296  size_t avail;
1297  size_t size;
1299 
1301  "process_notify is running\n");
1302  GNUNET_assert (NULL == connection->write_task);
1303  if (NULL == (notify = connection->nth.notify_ready))
1304  {
1306  "No one to notify\n");
1307  return GNUNET_NO;
1308  }
1309  used = connection->write_buffer_off - connection->write_buffer_pos;
1310  avail = connection->write_buffer_size - used;
1311  size = connection->nth.notify_size;
1312  if (size > avail)
1313  {
1315  "Not enough buffer\n");
1316  return GNUNET_NO;
1317  }
1318  connection->nth.notify_ready = NULL;
1319  if (connection->write_buffer_size - connection->write_buffer_off < size)
1320  {
1321  /* need to compact */
1322  memmove (connection->write_buffer,
1323  &connection->write_buffer[connection->write_buffer_pos],
1324  used);
1325  connection->write_buffer_off -= connection->write_buffer_pos;
1326  connection->write_buffer_pos = 0;
1327  }
1328  avail = connection->write_buffer_size - connection->write_buffer_off;
1329  GNUNET_assert (avail >= size);
1330  size =
1331  notify (connection->nth.notify_ready_cls, avail,
1332  &connection->write_buffer[connection->write_buffer_off]);
1333  GNUNET_assert (size <= avail);
1334  if (0 != size)
1335  connection->write_buffer_off += size;
1336  return GNUNET_YES;
1337 }
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:81
size_t write_buffer_size
Current size of our write_buffer.
size_t(* GNUNET_CONNECTION_TransmitReadyNotify)(void *cls, size_t size, void *buf)
Function called to notify a client about the connection begin ready to queue more data...
void * notify_ready_cls
Closure for notify_ready.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
size_t write_buffer_off
Current write-offset in write_buffer (where would we write next).
size_t write_buffer_pos
Current read-offset in write_buffer (how many bytes have already been sent).
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
size_t notify_size
At what number of bytes available in the write buffer should the notify method be called...
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
#define GNUNET_YES
Definition: gnunet_common.h:80
char * write_buffer
Pointer to our write buffer.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
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
clsthe struct GNUNET_CONNECTION_Handle

Definition at line 1351 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::addrlen, GNUNET_CONNECTION_TransmitHandle::connection, 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.

1352 {
1353  struct GNUNET_CONNECTION_Handle *connection = cls;
1355 
1356  connection->nth.timeout_task = NULL;
1358  "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
1359  connection->hostname,
1360  connection->port,
1361  GNUNET_a2s (connection->addr,
1362  connection->addrlen),
1363  connection);
1364  notify = connection->nth.notify_ready;
1365  GNUNET_assert (NULL != notify);
1366  connection->nth.notify_ready = NULL;
1367  notify (connection->nth.notify_ready_cls,
1368  0,
1369  NULL);
1370 }
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint16_t port
Port to connect to.
size_t(* GNUNET_CONNECTION_TransmitReadyNotify)(void *cls, size_t size, void *buf)
Function called to notify a client about the connection begin ready to queue more data...
void * notify_ready_cls
Closure for notify_ready.
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
struct sockaddr * addr
Network address of the other end-point, may be NULL.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
socklen_t addrlen
Length of addr.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
handle for a network connection
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
Here is the call 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
clsthe struct GNUNET_CONNECTION_Handle

Definition at line 1382 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_TransmitHandle::connection, 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().

1383 {
1384  struct GNUNET_CONNECTION_Handle *connection = cls;
1386 
1388  "Transmission request of size %u fails (%s/%u), connection failed (%p).\n",
1389  connection->nth.notify_size,
1390  connection->hostname,
1391  connection->port,
1392  connection);
1393  connection->write_task = NULL;
1394  notify = connection->nth.notify_ready;
1395  connection->nth.notify_ready = NULL;
1396  notify (connection->nth.notify_ready_cls,
1397  0,
1398  NULL);
1399 }
#define LOG(kind,...)
Definition: arm_api.c:33
uint16_t port
Port to connect to.
size_t(* GNUNET_CONNECTION_TransmitReadyNotify)(void *cls, size_t size, void *buf)
Function called to notify a client about the connection begin ready to queue more data...
void * notify_ready_cls
Closure for notify_ready.
char * hostname
Pointer to the hostname if connection was created using DNS lookup, otherwise NULL.
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
size_t notify_size
At what number of bytes available in the write buffer should the notify method be called...
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
handle for a network connection
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
connectionconnection
sizenumber of bytes to send
timeoutafter how long should we give up (and call notify with buf NULL and size 0)?
notifyfunction to call
notify_clsclosure 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 1538 of file tcp_connection_legacy.c.

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, GNUNET_CONNECTION_TransmitHandle::timeout_task, transmit_ready(), GNUNET_CONNECTION_TransmitHandle::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 try_connection_reversal().

1543 {
1544  if (NULL != connection->nth.notify_ready)
1545  {
1546  GNUNET_assert (0);
1547  return NULL;
1548  }
1549  GNUNET_assert (NULL != notify);
1551  GNUNET_assert (connection->write_buffer_off <= connection->write_buffer_size);
1552  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_size);
1553  GNUNET_assert (connection->write_buffer_pos <= connection->write_buffer_off);
1554  connection->nth.notify_ready = notify;
1555  connection->nth.notify_ready_cls = notify_cls;
1556  connection->nth.connection = connection;
1557  connection->nth.notify_size = size;
1558  connection->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1559  GNUNET_assert (NULL == connection->nth.timeout_task);
1560  if ((NULL == connection->sock) &&
1561  (NULL == connection->ap_head) &&
1562  (NULL == connection->dns_active) &&
1563  (NULL == connection->proxy_handshake))
1564  {
1565  if (NULL != connection->write_task)
1566  GNUNET_SCHEDULER_cancel (connection->write_task);
1568  connection);
1569  return &connection->nth;
1570  }
1571  if (NULL != connection->write_task)
1572  return &connection->nth; /* previous transmission still in progress */
1573  if (NULL != connection->sock)
1574  {
1575  /* connected, try to transmit now */
1577  "Scheduling transmission (%p).\n",
1578  connection);
1579  connection->write_task =
1581  (connection->nth.transmit_timeout),
1582  connection->sock,
1583  &transmit_ready, connection);
1584  return &connection->nth;
1585  }
1586  /* not yet connected, wait for connection */
1588  "Need to wait to schedule transmission for connection, adding timeout task (%p).\n",
1589  connection);
1590  connection->nth.timeout_task =
1593  connection);
1594  return &connection->nth;
1595 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
static void connect_error(void *cls)
Task invoked by the scheduler when we failed to connect at the time of being asked to transmit...
#define LOG(kind,...)
Definition: arm_api.c:33
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:245
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1548
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...
size_t write_buffer_size
Current size of our write_buffer.
void * notify_ready_cls
Closure for notify_ready.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
static struct GNUNET_PEERINFO_NotifyContext * notify
Handle to the peerinfo notify service (NULL until we&#39;ve connected to it).
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request.
size_t write_buffer_off
Current write-offset in write_buffer (where would we write next).
static void transmit_ready(void *cls)
We are ready to transmit (or got a timeout).
size_t write_buffer_pos
Current read-offset in write_buffer (how many bytes have already been sent).
struct GNUNET_CONNECTION_Handle * connection
Our connection handle.
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_CONNECTION_TransmitHandle nth
The handle we return for GNUNET_CONNECTION_notify_transmit_ready().
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
size_t notify_size
At what number of bytes available in the write buffer should the notify method be called...
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
struct GNUNET_TIME_Absolute transmit_timeout
Timeout for receiving (in absolute time).
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
thnotification to cancel

Definition at line 1604 of file tcp_connection_legacy.c.

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().

1605 {
1606  GNUNET_assert (NULL != th->notify_ready);
1607  th->notify_ready = NULL;
1608  if (NULL != th->timeout_task)
1609  {
1611  th->timeout_task = NULL;
1612  }
1613  if (NULL != th->connection->write_task)
1614  {
1616  th->connection->write_task = NULL;
1617  }
1618 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONNECTION_Handle * connection
Our connection handle.
struct GNUNET_SCHEDULER_Task * write_task
Write task that we may need to wait for.
GNUNET_CONNECTION_TransmitReadyNotify notify_ready
Function to call if the send buffer has notify_size bytes available.
struct GNUNET_SCHEDULER_Task * timeout_task
Task called on timeout.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
cphconnection to proxy server
Returns
connection to be proxied

Definition at line 1628 of file tcp_connection_legacy.c.

References GNUNET_CONNECTION_create_from_existing(), and GNUNET_CONNECTION_Handle::proxy_handshake.

Referenced by GNUNET_SOCKS_run_handshake().

1629 {
1631 
1632  proxied->proxy_handshake = cph;
1633  return proxied;
1634 }
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
struct GNUNET_CONNECTION_Handle * GNUNET_CONNECTION_create_from_existing(struct GNUNET_NETWORK_Handle *osSocket)
Create a connection handle by boxing an existing OS socket.
handle for a network connection
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
proxiedconnection connection to proxy server

Definition at line 1645 of file tcp_connection_legacy.c.

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

Referenced by SOCKS5_handshake_done().

1646 {
1647  struct GNUNET_CONNECTION_Handle *cph = proxied->proxy_handshake;
1648 
1649  GNUNET_assert (NULL != cph);
1650  GNUNET_assert (NULL == proxied->sock);
1651  GNUNET_assert (NULL != cph->sock);
1652  proxied->sock = cph->sock;
1653  cph->sock = NULL;
1655  connect_success_continuation (proxied);
1656 }
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket, set to NULL after fatal errors.
struct GNUNET_CONNECTION_Handle * proxy_handshake
Handle to subsequent connection after proxy handshake completes,.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_CONNECTION_destroy(struct GNUNET_CONNECTION_Handle *connection)
Close the connection and free associated resources.
static void connect_success_continuation(struct GNUNET_CONNECTION_Handle *connection)
We&#39;ve succeeded in establishing a connection.
handle for a network connection
Here is the call graph for this function:
Here is the caller graph for this function: