client.c File Reference

code for access to services More...

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

Include dependency graph for client.c:

Go to the source code of this file.

Data Structures
struct	AddressProbe
	During connect, we try multiple possible IP addresses to find out which one might work. More...
struct	ClientState
	State we keep per client. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-client", __VA_ARGS__)
#define	CONNECT_RETRY_TIMEOUT
	Timeout we use on TCP connect before trying another result from the DNS resolver.

Functions
static void	start_connect (void *cls)
	Try to connect to the service.
static void	connect_fail_continuation (struct ClientState *cstate)
	We've failed for good to establish a connection (timeout or no more addresses to try).
static void	transmit_ready (void *cls)
	We are ready to send a message to the service.
static enum GNUNET_GenericReturnValue	recv_message (void *cls, const struct GNUNET_MessageHeader *msg)
	We have received a full message, pass to the MQ dispatcher.
static void	cancel_aps (struct ClientState *cstate)
	Cancel all remaining connect attempts.
static void	connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implement the destruction of a message queue.
static void	receive_ready (void *cls)
	This function is called once we have data ready to read.
static void	connect_success_continuation (struct ClientState *cstate)
	We've succeeded in establishing a connection.
static struct GNUNET_NETWORK_Handle *	try_unixpath (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Try connecting to the server using UNIX domain sockets.
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.
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 int	test_service_configuration (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Test whether the configuration has proper values for connection (UNIXPATH || (PORT && HOSTNAME)).
static void	connection_client_send_impl (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Implements the transmission functionality of a message queue.
static void	connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Cancel the currently sent message.
enum GNUNET_GenericReturnValue	GNUNET_CLIENT_test (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name)
	Test if the port or UNIXPATH of the given service_name is in use and thus (most likely) the respective service is up.
struct GNUNET_MQ_Handle *	GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
	Create a message queue to connect to a GNUnet service.

Detailed Description

code for access to services

Author

Christian Grothoff

Generic TCP code for reliable, record-oriented TCP connections between clients and service providers.

Definition in file client.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-client", __VA_ARGS__)

Definition at line 37 of file client.c.

CONNECT_RETRY_TIMEOUT

#define CONNECT_RETRY_TIMEOUT

Value:

    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 45 of file client.c.

{
  struct AddressProbe *next;
 
  struct AddressProbe *prev;
 
  const struct sockaddr *addr;
 
  struct GNUNET_NETWORK_Handle *sock;
 
  struct ClientState *cstate;
 
  socklen_t addrlen;
 
  struct GNUNET_SCHEDULER_Task *task;
};
 
 
struct ClientState
{
  struct GNUNET_NETWORK_Handle *sock;
 
  struct GNUNET_RESOLVER_RequestHandle *dns_active;
 
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct AddressProbe *ap_head;
 
  struct AddressProbe *ap_tail;
 
  char *service_name;
 
  char *hostname;
 
  const struct GNUNET_MessageHeader *msg;
 
  struct GNUNET_SCHEDULER_Task *retry_task;
 
  struct GNUNET_SCHEDULER_Task *send_task;
 
  struct GNUNET_SCHEDULER_Task *recv_task;
 
  struct GNUNET_MessageStreamTokenizer *mst;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_TIME_Absolute receive_timeout;
 
  struct GNUNET_TIME_Relative back_off;
 
  unsigned long long port;
 
  size_t msg_off;
 
  unsigned int attempts;
 
  int in_destroy;
};
 
 
static void
start_connect (void *cls);
 
 
static void
connect_fail_continuation (struct ClientState *cstate)
{
  GNUNET_break (NULL == cstate->ap_head);
  GNUNET_break (NULL == cstate->ap_tail);
  GNUNET_break (NULL == cstate->dns_active);
  GNUNET_break (NULL == cstate->sock);
  GNUNET_assert (NULL == cstate->send_task);
  GNUNET_assert (NULL == cstate->recv_task);
  // GNUNET_assert (NULL == cstate->proxy_handshake);
 
  cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
       cstate->service_name,
       GNUNET_STRINGS_relative_time_to_string (cstate->back_off,
                                               GNUNET_YES));
  cstate->retry_task
    = GNUNET_SCHEDULER_add_delayed (cstate->back_off,
                                    &start_connect,
                                    cstate);
}
 
 
static void
transmit_ready (void *cls)
{
  struct ClientState *cstate = cls;
  ssize_t ret;
  size_t len;
  const char *pos;
  int notify_in_flight;
 
  cstate->send_task = NULL;
  if (GNUNET_YES == cstate->in_destroy)
    return;
  pos = (const char *) cstate->msg;
  len = ntohs (cstate->msg->size);
  GNUNET_assert (cstate->msg_off < len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "message of type %u and size %u trying to send with socket %p (MQ: %p\n",
       ntohs (cstate->msg->type),
       ntohs (cstate->msg->size),
       cstate->sock,
       cstate->mq);
 
RETRY:
  ret = GNUNET_NETWORK_socket_send (cstate->sock,
                                    &pos[cstate->msg_off],
                                    len - cstate->msg_off);
  if ( (-1 == ret) &&
       ( (EAGAIN == errno) ||
         (EINTR == errno) ) )
  {
    /* ignore */
    ret = 0;
  }
  if (-1 == ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Error during sending message of type %u: %s\n",
         ntohs (cstate->msg->type),
         strerror (errno));
    if (EINTR == errno)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Retrying message of type %u\n",
           ntohs (cstate->msg->type));
      goto RETRY;
    }
    GNUNET_MQ_inject_error (cstate->mq,
                            GNUNET_MQ_ERROR_WRITE);
    return;
  }
  notify_in_flight = (0 == cstate->msg_off);
  cstate->msg_off += ret;
  if (cstate->msg_off < len)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "rescheduling message of type %u\n",
         ntohs (cstate->msg->type));
    cstate->send_task
      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                        cstate->sock,
                                        &transmit_ready,
                                        cstate);
    if (notify_in_flight)
      GNUNET_MQ_impl_send_in_flight (cstate->mq);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending message of type %u and size %u successful\n",
       ntohs (cstate->msg->type),
       ntohs (cstate->msg->size));
  cstate->msg = NULL;
  GNUNET_MQ_impl_send_continue (cstate->mq);
}
 
 
static enum GNUNET_GenericReturnValue
recv_message (void *cls,
              const struct GNUNET_MessageHeader *msg)
{
  struct ClientState *cstate = cls;
 
  if (GNUNET_YES == cstate->in_destroy)
    return GNUNET_NO;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received message of type %u and size %u from %s\n",
       ntohs (msg->type),
       ntohs (msg->size),
       cstate->service_name);
  GNUNET_MQ_inject_message (cstate->mq,
                            msg);
  if (GNUNET_YES == cstate->in_destroy)
    return GNUNET_NO;
  return GNUNET_OK;
}
 
 
static void
cancel_aps (struct ClientState *cstate)
{
  struct AddressProbe *pos;
 
  while (NULL != (pos = cstate->ap_head))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (pos->sock));
    GNUNET_SCHEDULER_cancel (pos->task);
    GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
                                 cstate->ap_tail,
                                 pos);
    GNUNET_free (pos);
  }
}
 
 
static void
connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq,
                                void *impl_state)
{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  if (NULL != cstate->dns_active)
  {
    GNUNET_RESOLVER_request_cancel (cstate->dns_active);
    cstate->dns_active = NULL;
  }
  if (NULL != cstate->send_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->send_task);
    cstate->send_task = NULL;
  }
  if (NULL != cstate->retry_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->retry_task);
    cstate->retry_task = NULL;
  }
  if (GNUNET_SYSERR == cstate->in_destroy)
  {
    /* defer destruction */
    cstate->in_destroy = GNUNET_YES;
    cstate->mq = NULL;
    return;
  }
  if (NULL != cstate->recv_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->recv_task);
    cstate->recv_task = NULL;
  }
  if (NULL != cstate->sock)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "destroying socket: %p\n",
         cstate->sock);
    GNUNET_NETWORK_socket_close (cstate->sock);
  }
  cancel_aps (cstate);
  GNUNET_free (cstate->service_name);
  GNUNET_free (cstate->hostname);
  GNUNET_MST_destroy (cstate->mst);
  GNUNET_free (cstate);
}
 
 
static void
receive_ready (void *cls)
{
  struct ClientState *cstate = cls;
  enum GNUNET_GenericReturnValue ret;
 
  cstate->recv_task = NULL;
  cstate->in_destroy = GNUNET_SYSERR;
  ret = GNUNET_MST_read (cstate->mst,
                         cstate->sock,
                         GNUNET_NO,
                         GNUNET_NO);
  if (GNUNET_SYSERR == ret)
  {
    if (NULL != cstate->mq)
      GNUNET_MQ_inject_error (cstate->mq,
                              GNUNET_MQ_ERROR_READ);
    if (GNUNET_YES == cstate->in_destroy)
      connection_client_destroy_impl (cstate->mq,
                                      cstate);
    return;
  }
  if (GNUNET_YES == cstate->in_destroy)
  {
    connection_client_destroy_impl (cstate->mq,
                                    cstate);
    return;
  }
  cstate->in_destroy = GNUNET_NO;
  GNUNET_assert (NULL == cstate->recv_task);
  cstate->recv_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     cstate->sock,
                                     &receive_ready,
                                     cstate);
}
 
 
static void
connect_success_continuation (struct ClientState *cstate)
{
  GNUNET_assert (NULL == cstate->recv_task);
  cstate->recv_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     cstate->sock,
                                     &receive_ready,
                                     cstate);
  if (NULL != cstate->msg)
  {
    GNUNET_assert (NULL == cstate->send_task);
    cstate->send_task
      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                        cstate->sock,
                                        &transmit_ready,
                                        cstate);
  }
}
 
 
static struct GNUNET_NETWORK_Handle *
try_unixpath (const char *service_name,
              const struct GNUNET_CONFIGURATION_Handle *cfg)
{
#if AF_UNIX
  struct GNUNET_NETWORK_Handle *sock;
  char *unixpath;
  struct sockaddr_un s_un;
 
  unixpath = NULL;
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                service_name,
                                                "UNIXPATH",
                                                &unixpath)) &&
      (0 < strlen (unixpath)))
  {
    /* We have a non-NULL unixpath, need to validate it */
    if (strlen (unixpath) >= sizeof(s_un.sun_path))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
           unixpath,
           (unsigned long long) sizeof(s_un.sun_path));
      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Using `%s' instead\n"),
           unixpath);
      if (NULL == unixpath)
        return NULL;
    }
    memset (&s_un,
            0,
            sizeof(s_un));
    s_un.sun_family = AF_UNIX;
    GNUNET_strlcpy (s_un.sun_path,
                    unixpath,
                    sizeof(s_un.sun_path));
#if HAVE_SOCKADDR_UN_SUN_LEN
    s_un.sun_len = (u_char) sizeof(struct sockaddr_un);
#endif
    sock = GNUNET_NETWORK_socket_create (AF_UNIX,
                                         SOCK_STREAM,
                                         0);
    if ((NULL != sock) &&
        ((GNUNET_OK ==
          GNUNET_NETWORK_socket_connect (sock,
                                         (struct sockaddr *) &s_un,
                                         sizeof(s_un))) ||
         (EINPROGRESS == errno)))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Successfully connected to unixpath `%s'!\n",
           unixpath);
      GNUNET_free (unixpath);
      return sock;
    }
    if (NULL != sock)
      GNUNET_NETWORK_socket_close (sock);
  }
  GNUNET_free (unixpath);
#endif
  return NULL;
}
 
 
static void
connect_probe_continuation (void *cls)
{
  struct AddressProbe *ap = cls;
  struct ClientState *cstate = ap->cstate;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  int error;
  socklen_t len;
 
  ap->task = NULL;
  GNUNET_assert (NULL != ap->sock);
  GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
                               cstate->ap_tail,
                               ap);
  len = sizeof(error);
  error = 0;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
      (GNUNET_OK !=
       GNUNET_NETWORK_socket_getsockopt (ap->sock,
                                         SOL_SOCKET,
                                         SO_ERROR,
                                         &error,
                                         &len)) ||
      (0 != error))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (ap->sock));
    GNUNET_free (ap);
    if ((NULL == cstate->ap_head) &&
        //       (NULL == cstate->proxy_handshake) &&
        (NULL == cstate->dns_active))
      connect_fail_continuation (cstate);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection to `%s' succeeded!\n",
       cstate->service_name);
  /* trigger jobs that waited for the connection */
  GNUNET_assert (NULL == cstate->sock);
  cstate->sock = ap->sock;
  GNUNET_free (ap);
  cancel_aps (cstate);
  connect_success_continuation (cstate);
}
 
 
static void
try_connect_using_address (void *cls,
                           const struct sockaddr *addr,
                           socklen_t addrlen)
{
  struct ClientState *cstate = cls;
  struct AddressProbe *ap;
 
  if (NULL == addr)
  {
    cstate->dns_active = NULL;
    if ((NULL == cstate->ap_head) &&
        //  (NULL == cstate->proxy_handshake) &&
        (NULL == cstate->sock))
      connect_fail_continuation (cstate);
    return;
  }
  if (NULL != cstate->sock)
    return;                     /* already connected */
  /* try to connect */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to connect using address `%s:%u'\n",
       GNUNET_a2s (addr,
                   addrlen),
       (unsigned int) cstate->port);
  ap = GNUNET_malloc (sizeof(struct AddressProbe) + addrlen);
  ap->addr = (const struct sockaddr *) &ap[1];
  GNUNET_memcpy (&ap[1],
                 addr,
                 addrlen);
  ap->addrlen = addrlen;
  ap->cstate = cstate;
 
  switch (ap->addr->sa_family)
  {
  case AF_INET:
    ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port);
    break;
 
  case AF_INET6:
    ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port);
    break;
 
  default:
    GNUNET_break (0);
    GNUNET_free (ap);
    return;                     /* not supported by us */
  }
  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
                                           SOCK_STREAM,
                                           0);
  if (NULL == ap->sock)
  {
    GNUNET_free (ap);
    return;                     /* not supported by OS */
  }
  if ((GNUNET_OK !=
       GNUNET_NETWORK_socket_connect (ap->sock,
                                      ap->addr,
                                      ap->addrlen)) &&
      (EINPROGRESS != errno))
  {
    /* maybe refused / unsupported address, try next */
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO,
                         "connect");
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (ap->sock));
    GNUNET_free (ap);
    return;
  }
  GNUNET_CONTAINER_DLL_insert (cstate->ap_head,
                               cstate->ap_tail,
                               ap);
  ap->task = GNUNET_SCHEDULER_add_write_net (CONNECT_RETRY_TIMEOUT,
                                             ap->sock,
                                             &connect_probe_continuation,
                                             ap);
}
 
 
static int
test_service_configuration (const char *service_name,
                            const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  int ret = GNUNET_SYSERR;
  char *hostname = NULL;
  unsigned long long port;
 
#if AF_UNIX
  char *unixpath = NULL;
 
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                service_name,
                                                "UNIXPATH",
                                                &unixpath)) &&
      (0 < strlen (unixpath)))
    ret = GNUNET_OK;
  else if ((GNUNET_OK ==
            GNUNET_CONFIGURATION_have_value (cfg,
                                             service_name,
                                             "UNIXPATH")))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               service_name,
                               "UNIXPATH",
                               _ ("not a valid filename"));
    GNUNET_free (unixpath);
    return GNUNET_SYSERR;   /* UNIXPATH specified but invalid! */
  }
  GNUNET_free (unixpath);
#endif
 
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_have_value (cfg,
                                        service_name,
                                        "PORT")) &&
      (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (cfg,
                                              service_name,
                                              "PORT",
                                              &port)) &&
      (port <= 65535) &&
      (0 != port) &&
      (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (cfg,
                                              service_name,
                                              "HOSTNAME",
                                              &hostname)) &&
      (0 != strlen (hostname)))
    ret = GNUNET_OK;
  GNUNET_free (hostname);
  return ret;
}
 
 
static void
start_connect (void *cls)
{
  struct ClientState *cstate = cls;
 
  cstate->retry_task = NULL;
#if 0
  /* Never use a local source if a proxy is configured */
  if (GNUNET_YES ==
      GNUNET_SOCKS_check_service (cstate->service_name,
                                  cstate->cfg))
  {
    socks_connect (cstate);
    return;
  }
#endif
 
  if ((0 == (cstate->attempts++ % 2)) ||
      (0 == cstate->port) ||
      (NULL == cstate->hostname))
  {
    /* on even rounds, try UNIX first, or always
       if we do not have a DNS name and TCP port. */
    cstate->sock = try_unixpath (cstate->service_name,
                                 cstate->cfg);
    if (NULL != cstate->sock)
    {
      connect_success_continuation (cstate);
      return;
    }
  }
  if ((NULL == cstate->hostname) ||
      (0 == cstate->port))
  {
    /* All options failed. Boo! */
    connect_fail_continuation (cstate);
    return;
  }
  cstate->dns_active
    = GNUNET_RESOLVER_ip_get (cstate->hostname,
                              AF_UNSPEC,
                              CONNECT_RETRY_TIMEOUT,
                              &try_connect_using_address,
                              cstate);
}
 
 
static void
connection_client_send_impl (struct GNUNET_MQ_Handle *mq,
                             const struct GNUNET_MessageHeader *msg,
                             void *impl_state)
{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  /* only one message at a time allowed */
  GNUNET_assert (NULL == cstate->msg);
  GNUNET_assert (NULL == cstate->send_task);
  cstate->msg = msg;
  cstate->msg_off = 0;
  if (NULL == cstate->sock)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "message of type %u waiting for socket\n",
         ntohs (msg->type));
    return;   /* still waiting for connection */
  }
  cstate->send_task
    = GNUNET_SCHEDULER_add_now (&transmit_ready,
                                cstate);
}
 
 
static void
connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq,
                               void *impl_state)
{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  GNUNET_assert (NULL != cstate->msg);
  GNUNET_assert (0 == cstate->msg_off);
  cstate->msg = NULL;
  if (NULL != cstate->send_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->send_task);
    cstate->send_task = NULL;
  }
}
 
 
enum GNUNET_GenericReturnValue
GNUNET_CLIENT_test (const struct GNUNET_CONFIGURATION_Handle *cfg,
                    const char *service_name)
{
  char *hostname = NULL;
  unsigned long long port;
  int ret;
 
#if AF_UNIX
  {
    char *unixpath = NULL;
 
    if (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                 service_name,
                                                 "UNIXPATH",
                                                 &unixpath))
    {
      if (0 == strlen (unixpath))
      {
        GNUNET_free (unixpath);
        return GNUNET_SYSERR; /* empty string not OK */
      }
      if (0 == access (unixpath,
                       F_OK))
      {
        GNUNET_free (unixpath);
        return GNUNET_OK; /* file exists, we assume service is running */
      }
      GNUNET_free (unixpath);
    }
    else if (GNUNET_OK ==
             GNUNET_CONFIGURATION_have_value (cfg,
                                              service_name,
                                              "UNIXPATH"))
    {
      /* UNIXPATH specified but not a valid path! */
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 service_name,
                                 "UNIXPATH",
                                 _ ("not a valid filename"));
      return GNUNET_SYSERR;
    }
  }
#endif
 
  if ( (GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_number (cfg,
                                               service_name,
                                               "PORT",
                                               &port)) ||
       (port > 65535) ||
       (0 == port) )
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
                               service_name,
                               "PORT");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             service_name,
                                             "HOSTNAME",
                                             &hostname))
  {
    /* We always assume remotes are up */
    ret = GNUNET_YES;
  }
  else
  {
    /* We look for evidence the service is up */
    ret = GNUNET_NO;
  }
  if ( (NULL == hostname) ||
       (0 == strcasecmp (hostname,
                         "localhost")) ||
       (0 == strcasecmp (hostname,
                         "ip6-localnet")) )
  {
    /* service runs on loopback */
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
    int sock;
 
    memset (&v4, 0, sizeof (v4));
    memset (&v6, 0, sizeof (v6));
    v4.sin_family = AF_INET;
    v4.sin_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SUN_LEN
    v4.sin_len = (u_char) sizeof(struct sockaddr_in);
#endif
    GNUNET_assert (1 == inet_pton (AF_INET,
                                   "127.0.0.1",
                                   &v4.sin_addr));
    ret = GNUNET_NO;
    sock = socket (AF_INET,
                   SOCK_STREAM,
                   0);
    if (-1 != sock)
    {
      if (0 != bind (sock,
                     (struct sockaddr *) &v4,
                     sizeof (v4)))
      {
        /* bind failed, so someone is listening! */
        ret = GNUNET_YES;
      }
      (void) close (sock);
    }
    else
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                           "socket");
      if (GNUNET_NO == ret)
        ret = GNUNET_SYSERR;
    }
    v6.sin6_family = AF_INET6;
    v6.sin6_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SUN_LEN
    v6.sin6_len = (u_char) sizeof(struct sockaddr_in6);
#endif
    inet_pton (AF_INET6,
               "::1",
               &v6.sin6_addr);
    sock = socket (AF_INET6,
                   SOCK_STREAM,
                   0);
    if (-1 != sock)
    {
      if (0 != bind (sock,
                     (struct sockaddr *) &v6,
                     sizeof (v6)))
      {
        /* bind failed, so someone is listening! */
        ret = GNUNET_YES;
      }
      (void) close (sock);
    }
    else
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                           "socket");
      /* not changing 'ret' intentionally here, as
         v4 succeeding and v6 failing just means we
         should use v4 */
    }
  }
  else
  {
    /* service running remotely */
    ret = GNUNET_OK;
  }
  GNUNET_free (hostname);
  return ret;
}
 
 
struct GNUNET_MQ_Handle *
GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                       const char *service_name,
                       const struct GNUNET_MQ_MessageHandler *handlers,
                       GNUNET_MQ_ErrorHandler error_handler,
                       void *error_handler_cls)
{
  struct ClientState *cstate;
 
  if (GNUNET_OK !=
      test_service_configuration (service_name,
                                  cfg))
    return NULL;
  cstate = GNUNET_new (struct ClientState);
  cstate->service_name = GNUNET_strdup (service_name);
  cstate->cfg = cfg;
  cstate->retry_task = GNUNET_SCHEDULER_add_now (&start_connect,
                                                 cstate);
  cstate->mst = GNUNET_MST_create (&recv_message,
                                   cstate);
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_have_value (cfg,
                                       service_name,
                                       "PORT"))
  {
    if (! ((GNUNET_OK !=
            GNUNET_CONFIGURATION_get_value_number (cfg,
                                                   service_name,
                                                   "PORT",
                                                   &cstate->port)) ||
           (cstate->port > 65535) ||
           (GNUNET_SYSERR ==
            GNUNET_CONFIGURATION_get_value_string (cfg,
                                                   service_name,
                                                   "HOSTNAME",
                                                   &cstate->hostname))) &&
        (0 == strlen (cstate->hostname)))
    {
      GNUNET_free (cstate->hostname);
      cstate->hostname = NULL;
      LOG (GNUNET_ERROR_TYPE_WARNING,
           _ ("Need a non-empty hostname for service `%s'.\n"),
           service_name);
    }
  }
  cstate->mq = GNUNET_MQ_queue_for_callbacks (&connection_client_send_impl,
                                              &connection_client_destroy_impl,
                                              &connection_client_cancel_impl,
                                              cstate,
                                              handlers,
                                              error_handler,
                                              error_handler_cls);
  return cstate->mq;
}
 
 
/* end of client.c */

Function Documentation

start_connect()

static void start_connect ( void *  cls )

static

Try to connect to the service.

Parameters

cls	the struct ClientState to try to connect to the service

Definition at line 787 of file client.c.

{
  struct ClientState *cstate = cls;
 
  cstate->retry_task = NULL;
#if 0
  /* Never use a local source if a proxy is configured */
  if (GNUNET_YES ==
      GNUNET_SOCKS_check_service (cstate->service_name,
                                  cstate->cfg))
  {
    socks_connect (cstate);
    return;
  }
#endif
 
  if ((0 == (cstate->attempts++ % 2)) ||
      (0 == cstate->port) ||
      (NULL == cstate->hostname))
  {
    /* on even rounds, try UNIX first, or always
       if we do not have a DNS name and TCP port. */
    cstate->sock = try_unixpath (cstate->service_name,
                                 cstate->cfg);
    if (NULL != cstate->sock)
    {
      connect_success_continuation (cstate);
      return;
    }
  }
  if ((NULL == cstate->hostname) ||
      (0 == cstate->port))
  {
    /* All options failed. Boo! */
    connect_fail_continuation (cstate);
    return;
  }
  cstate->dns_active
    = GNUNET_RESOLVER_ip_get (cstate->hostname,
                              AF_UNSPEC,
                              CONNECT_RETRY_TIMEOUT,
                              &try_connect_using_address,
                              cstate);
}

References ClientState::attempts, ClientState::cfg, connect_fail_continuation(), CONNECT_RETRY_TIMEOUT, connect_success_continuation(), ClientState::dns_active, GNUNET_RESOLVER_ip_get(), GNUNET_SOCKS_check_service(), GNUNET_YES, ClientState::hostname, ClientState::port, ClientState::retry_task, ClientState::service_name, ClientState::sock, try_connect_using_address(), and try_unixpath().

Referenced by connect_fail_continuation(), and GNUNET_CLIENT_connect().

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 ClientState *  cstate )

static

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

Parameters

cstate

the connection we tried to establish

Definition at line 221 of file client.c.

{
  GNUNET_break (NULL == cstate->ap_head);
  GNUNET_break (NULL == cstate->ap_tail);
  GNUNET_break (NULL == cstate->dns_active);
  GNUNET_break (NULL == cstate->sock);
  GNUNET_assert (NULL == cstate->send_task);
  GNUNET_assert (NULL == cstate->recv_task);
  // GNUNET_assert (NULL == cstate->proxy_handshake);
 
  cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
       cstate->service_name,
       GNUNET_STRINGS_relative_time_to_string (cstate->back_off,
                                               GNUNET_YES));
  cstate->retry_task
    = GNUNET_SCHEDULER_add_delayed (cstate->back_off,
                                    &start_connect,
                                    cstate);
}

References ClientState::ap_head, ClientState::ap_tail, ClientState::back_off, ClientState::dns_active, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, LOG, ClientState::recv_task, ClientState::retry_task, ClientState::send_task, ClientState::service_name, ClientState::sock, and start_connect().

Referenced by connect_probe_continuation(), start_connect(), and try_connect_using_address().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_ready()

static void transmit_ready ( void *  cls )

static

We are ready to send a message to the service.

Parameters

cls	the struct ClientState with the msg to transmit

Definition at line 250 of file client.c.

{
  struct ClientState *cstate = cls;
  ssize_t ret;
  size_t len;
  const char *pos;
  int notify_in_flight;
 
  cstate->send_task = NULL;
  if (GNUNET_YES == cstate->in_destroy)
    return;
  pos = (const char *) cstate->msg;
  len = ntohs (cstate->msg->size);
  GNUNET_assert (cstate->msg_off < len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "message of type %u and size %u trying to send with socket %p (MQ: %p\n",
       ntohs (cstate->msg->type),
       ntohs (cstate->msg->size),
       cstate->sock,
       cstate->mq);
 
RETRY:
  ret = GNUNET_NETWORK_socket_send (cstate->sock,
                                    &pos[cstate->msg_off],
                                    len - cstate->msg_off);
  if ( (-1 == ret) &&
       ( (EAGAIN == errno) ||
         (EINTR == errno) ) )
  {
    /* ignore */
    ret = 0;
  }
  if (-1 == ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Error during sending message of type %u: %s\n",
         ntohs (cstate->msg->type),
         strerror (errno));
    if (EINTR == errno)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Retrying message of type %u\n",
           ntohs (cstate->msg->type));
      goto RETRY;
    }
    GNUNET_MQ_inject_error (cstate->mq,
                            GNUNET_MQ_ERROR_WRITE);
    return;
  }
  notify_in_flight = (0 == cstate->msg_off);
  cstate->msg_off += ret;
  if (cstate->msg_off < len)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "rescheduling message of type %u\n",
         ntohs (cstate->msg->type));
    cstate->send_task
      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                        cstate->sock,
                                        &transmit_ready,
                                        cstate);
    if (notify_in_flight)
      GNUNET_MQ_impl_send_in_flight (cstate->mq);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending message of type %u and size %u successful\n",
       ntohs (cstate->msg->type),
       ntohs (cstate->msg->size));
  cstate->msg = NULL;
  GNUNET_MQ_impl_send_continue (cstate->mq);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_MQ_ERROR_WRITE, GNUNET_MQ_impl_send_continue(), GNUNET_MQ_impl_send_in_flight(), GNUNET_MQ_inject_error(), GNUNET_NETWORK_socket_send(), GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, ClientState::in_destroy, LOG, ClientState::mq, ClientState::msg, ClientState::msg_off, ret, ClientState::send_task, GNUNET_MessageHeader::size, ClientState::sock, transmit_ready(), and GNUNET_MessageHeader::type.

Referenced by connect_success_continuation(), connection_client_send_impl(), and transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

recv_message()

static enum GNUNET_GenericReturnValue recv_message ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

We have received a full message, pass to the MQ dispatcher.

Called by the tokenizer via receive_ready().

Parameters

cls	the struct ClientState
msg	message we received.

Returns

GNUNET_OK on success, GNUNET_NO to stop further processing due to disconnect (no error) GNUNET_SYSERR to stop further processing due to error

Definition at line 335 of file client.c.

{
  struct ClientState *cstate = cls;
 
  if (GNUNET_YES == cstate->in_destroy)
    return GNUNET_NO;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received message of type %u and size %u from %s\n",
       ntohs (msg->type),
       ntohs (msg->size),
       cstate->service_name);
  GNUNET_MQ_inject_message (cstate->mq,
                            msg);
  if (GNUNET_YES == cstate->in_destroy)
    return GNUNET_NO;
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_inject_message(), GNUNET_NO, GNUNET_OK, GNUNET_YES, ClientState::in_destroy, LOG, ClientState::mq, msg, ClientState::service_name, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GNUNET_CLIENT_connect(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_aps()

static void cancel_aps ( struct ClientState *  cstate )

static

Cancel all remaining connect attempts.

Parameters

cstate

handle of the client state to process

Definition at line 361 of file client.c.

{
  struct AddressProbe *pos;
 
  while (NULL != (pos = cstate->ap_head))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (pos->sock));
    GNUNET_SCHEDULER_cancel (pos->task);
    GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
                                 cstate->ap_tail,
                                 pos);
    GNUNET_free (pos);
  }
}

References ClientState::ap_head, ClientState::ap_tail, AddressProbe::cstate, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), AddressProbe::sock, and AddressProbe::task.

Referenced by connect_probe_continuation(), and connection_client_destroy_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

connection_client_destroy_impl()

static void connection_client_destroy_impl ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Implement the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	our struct ClientState

Definition at line 386 of file client.c.

{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  if (NULL != cstate->dns_active)
  {
    GNUNET_RESOLVER_request_cancel (cstate->dns_active);
    cstate->dns_active = NULL;
  }
  if (NULL != cstate->send_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->send_task);
    cstate->send_task = NULL;
  }
  if (NULL != cstate->retry_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->retry_task);
    cstate->retry_task = NULL;
  }
  if (GNUNET_SYSERR == cstate->in_destroy)
  {
    /* defer destruction */
    cstate->in_destroy = GNUNET_YES;
    cstate->mq = NULL;
    return;
  }
  if (NULL != cstate->recv_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->recv_task);
    cstate->recv_task = NULL;
  }
  if (NULL != cstate->sock)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "destroying socket: %p\n",
         cstate->sock);
    GNUNET_NETWORK_socket_close (cstate->sock);
  }
  cancel_aps (cstate);
  GNUNET_free (cstate->service_name);
  GNUNET_free (cstate->hostname);
  GNUNET_MST_destroy (cstate->mst);
  GNUNET_free (cstate);
}

References cancel_aps(), ClientState::dns_active, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MST_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_YES, ClientState::hostname, ClientState::in_destroy, LOG, ClientState::mq, mq, ClientState::mst, ClientState::recv_task, ClientState::retry_task, ClientState::send_task, ClientState::service_name, and ClientState::sock.

Referenced by GNUNET_CLIENT_connect(), and receive_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

receive_ready()

static void receive_ready ( void *  cls )

static

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

Parameters

cls	struct ClientState with connection to read from

Definition at line 440 of file client.c.

{
  struct ClientState *cstate = cls;
  enum GNUNET_GenericReturnValue ret;
 
  cstate->recv_task = NULL;
  cstate->in_destroy = GNUNET_SYSERR;
  ret = GNUNET_MST_read (cstate->mst,
                         cstate->sock,
                         GNUNET_NO,
                         GNUNET_NO);
  if (GNUNET_SYSERR == ret)
  {
    if (NULL != cstate->mq)
      GNUNET_MQ_inject_error (cstate->mq,
                              GNUNET_MQ_ERROR_READ);
    if (GNUNET_YES == cstate->in_destroy)
      connection_client_destroy_impl (cstate->mq,
                                      cstate);
    return;
  }
  if (GNUNET_YES == cstate->in_destroy)
  {
    connection_client_destroy_impl (cstate->mq,
                                    cstate);
    return;
  }
  cstate->in_destroy = GNUNET_NO;
  GNUNET_assert (NULL == cstate->recv_task);
  cstate->recv_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     cstate->sock,
                                     &receive_ready,
                                     cstate);
}

References connection_client_destroy_impl(), GNUNET_assert, GNUNET_MQ_ERROR_READ, GNUNET_MQ_inject_error(), GNUNET_MST_read(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, ClientState::in_destroy, ClientState::mq, ClientState::mst, receive_ready(), ClientState::recv_task, ret, and ClientState::sock.

Referenced by connect_success_continuation(), and receive_ready().

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 ClientState *  cstate )

static

We've succeeded in establishing a connection.

Parameters

cstate

the connection we tried to establish

Definition at line 483 of file client.c.

{
  GNUNET_assert (NULL == cstate->recv_task);
  cstate->recv_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     cstate->sock,
                                     &receive_ready,
                                     cstate);
  if (NULL != cstate->msg)
  {
    GNUNET_assert (NULL == cstate->send_task);
    cstate->send_task
      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                        cstate->sock,
                                        &transmit_ready,
                                        cstate);
  }
}

References GNUNET_assert, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, ClientState::msg, receive_ready(), ClientState::recv_task, ClientState::send_task, ClientState::sock, and transmit_ready().

Referenced by connect_probe_continuation(), and start_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

try_unixpath()

static struct GNUNET_NETWORK_Handle * try_unixpath ( const char *  service_name, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Try connecting to the server using UNIX domain sockets.

Parameters

service_name	name of service to connect to
cfg	configuration to use

Returns

NULL on error, socket connected to UNIX otherwise

Definition at line 511 of file client.c.

{
#if AF_UNIX
  struct GNUNET_NETWORK_Handle *sock;
  char *unixpath;
  struct sockaddr_un s_un;
 
  unixpath = NULL;
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                service_name,
                                                "UNIXPATH",
                                                &unixpath)) &&
      (0 < strlen (unixpath)))
  {
    /* We have a non-NULL unixpath, need to validate it */
    if (strlen (unixpath) >= sizeof(s_un.sun_path))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
           unixpath,
           (unsigned long long) sizeof(s_un.sun_path));
      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Using `%s' instead\n"),
           unixpath);
      if (NULL == unixpath)
        return NULL;
    }
    memset (&s_un,
            0,
            sizeof(s_un));
    s_un.sun_family = AF_UNIX;
    GNUNET_strlcpy (s_un.sun_path,
                    unixpath,
                    sizeof(s_un.sun_path));
#if HAVE_SOCKADDR_UN_SUN_LEN
    s_un.sun_len = (u_char) sizeof(struct sockaddr_un);
#endif
    sock = GNUNET_NETWORK_socket_create (AF_UNIX,
                                         SOCK_STREAM,
                                         0);
    if ((NULL != sock) &&
        ((GNUNET_OK ==
          GNUNET_NETWORK_socket_connect (sock,
                                         (struct sockaddr *) &s_un,
                                         sizeof(s_un))) ||
         (EINPROGRESS == errno)))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Successfully connected to unixpath `%s'!\n",
           unixpath);
      GNUNET_free (unixpath);
      return sock;
    }
    if (NULL != sock)
      GNUNET_NETWORK_socket_close (sock);
  }
  GNUNET_free (unixpath);
#endif
  return NULL;
}

References _, cfg, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_NETWORK_shorten_unixpath(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_OK, GNUNET_strlcpy(), LOG, and service_name.

Referenced by start_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_probe_continuation()

static void connect_probe_continuation ( void *  cls )

static

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

Do the right thing.

Parameters

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

Definition at line 583 of file client.c.

{
  struct AddressProbe *ap = cls;
  struct ClientState *cstate = ap->cstate;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  int error;
  socklen_t len;
 
  ap->task = NULL;
  GNUNET_assert (NULL != ap->sock);
  GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
                               cstate->ap_tail,
                               ap);
  len = sizeof(error);
  error = 0;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
      (GNUNET_OK !=
       GNUNET_NETWORK_socket_getsockopt (ap->sock,
                                         SOL_SOCKET,
                                         SO_ERROR,
                                         &error,
                                         &len)) ||
      (0 != error))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (ap->sock));
    GNUNET_free (ap);
    if ((NULL == cstate->ap_head) &&
        //       (NULL == cstate->proxy_handshake) &&
        (NULL == cstate->dns_active))
      connect_fail_continuation (cstate);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection to `%s' succeeded!\n",
       cstate->service_name);
  /* trigger jobs that waited for the connection */
  GNUNET_assert (NULL == cstate->sock);
  cstate->sock = ap->sock;
  GNUNET_free (ap);
  cancel_aps (cstate);
  connect_success_continuation (cstate);
}

References ClientState::ap_head, ClientState::ap_tail, cancel_aps(), connect_fail_continuation(), connect_success_continuation(), AddressProbe::cstate, ClientState::dns_active, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_getsockopt(), GNUNET_OK, GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_WRITE_READY, LOG, GNUNET_SCHEDULER_TaskContext::reason, ClientState::service_name, AddressProbe::sock, ClientState::sock, AddressProbe::task, and tc.

Referenced by try_connect_using_address().

Here is the call graph for this function:

Here is the caller graph for this function:

try_connect_using_address()

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

static

Try to establish a connection given the specified address.

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

Parameters

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

Definition at line 638 of file client.c.

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

References AddressProbe::addr, AddressProbe::addrlen, ClientState::ap_head, ClientState::ap_tail, connect_fail_continuation(), connect_probe_continuation(), CONNECT_RETRY_TIMEOUT, AddressProbe::cstate, ClientState::dns_active, GNUNET_a2s(), GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log_strerror, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_OK, GNUNET_SCHEDULER_add_write_net(), LOG, ClientState::port, AddressProbe::sock, ClientState::sock, and AddressProbe::task.

Referenced by start_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

test_service_configuration()

static int test_service_configuration ( const char *  service_name, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Test whether the configuration has proper values for connection (UNIXPATH || (PORT && HOSTNAME)).

Parameters

service_name	name of service to connect to
cfg	configuration to use

Returns

GNUNET_OK if the configuration is valid, GNUNET_SYSERR if not

Definition at line 726 of file client.c.

{
  int ret = GNUNET_SYSERR;
  char *hostname = NULL;
  unsigned long long port;
 
#if AF_UNIX
  char *unixpath = NULL;
 
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                service_name,
                                                "UNIXPATH",
                                                &unixpath)) &&
      (0 < strlen (unixpath)))
    ret = GNUNET_OK;
  else if ((GNUNET_OK ==
            GNUNET_CONFIGURATION_have_value (cfg,
                                             service_name,
                                             "UNIXPATH")))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               service_name,
                               "UNIXPATH",
                               _ ("not a valid filename"));
    GNUNET_free (unixpath);
    return GNUNET_SYSERR;   /* UNIXPATH specified but invalid! */
  }
  GNUNET_free (unixpath);
#endif
 
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_have_value (cfg,
                                        service_name,
                                        "PORT")) &&
      (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (cfg,
                                              service_name,
                                              "PORT",
                                              &port)) &&
      (port <= 65535) &&
      (0 != port) &&
      (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (cfg,
                                              service_name,
                                              "HOSTNAME",
                                              &hostname)) &&
      (0 != strlen (hostname)))
    ret = GNUNET_OK;
  GNUNET_free (hostname);
  return ret;
}

References _, cfg, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_invalid(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, port, ret, and service_name.

Referenced by GNUNET_CLIENT_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

connection_client_send_impl()

static void connection_client_send_impl ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Implements the transmission functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct ClientState

Definition at line 841 of file client.c.

{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  /* only one message at a time allowed */
  GNUNET_assert (NULL == cstate->msg);
  GNUNET_assert (NULL == cstate->send_task);
  cstate->msg = msg;
  cstate->msg_off = 0;
  if (NULL == cstate->sock)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "message of type %u waiting for socket\n",
         ntohs (msg->type));
    return;   /* still waiting for connection */
  }
  cstate->send_task
    = GNUNET_SCHEDULER_add_now (&transmit_ready,
                                cstate);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), LOG, mq, msg, ClientState::msg, ClientState::msg_off, ClientState::send_task, ClientState::sock, transmit_ready(), and GNUNET_MessageHeader::type.

Referenced by GNUNET_CLIENT_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

connection_client_cancel_impl()

static void connection_client_cancel_impl ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Cancel the currently sent message.

Parameters

mq	message queue
impl_state	our struct ClientState

Definition at line 873 of file client.c.

{
  struct ClientState *cstate = impl_state;
 
  (void) mq;
  GNUNET_assert (NULL != cstate->msg);
  GNUNET_assert (0 == cstate->msg_off);
  cstate->msg = NULL;
  if (NULL != cstate->send_task)
  {
    GNUNET_SCHEDULER_cancel (cstate->send_task);
    cstate->send_task = NULL;
  }
}

References GNUNET_assert, GNUNET_SCHEDULER_cancel(), mq, ClientState::msg, ClientState::msg_off, and ClientState::send_task.

Referenced by GNUNET_CLIENT_connect().

Here is the call graph for this function:

Here is the caller graph for this function: