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   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
	Timeout we use on TCP connect before trying another result from the DNS resolver. More...

Functions
static void	start_connect (void *cls)
	Try to connect to the service. More...
static void	connect_fail_continuation (struct ClientState *cstate)
	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 send a message to the service. More...
static int	recv_message (void *cls, const struct GNUNET_MessageHeader *msg)
	We have received a full message, pass to the MQ dispatcher. More...
static void	cancel_aps (struct ClientState *cstate)
	Cancel all remaining connect attempts. More...
static void	connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implement the destruction of a message queue. More...
static void	receive_ready (void *cls)
	This function is called once we have data ready to read. More...
static void	connect_success_continuation (struct ClientState *cstate)
	We've succeeded in establishing a connection. More...
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. 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...
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)). More...
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. More...
static void	connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Cancel the currently sent message. More...
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. More...

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

Referenced by connect_fail_continuation(), connect_probe_continuation(), connection_client_destroy_impl(), connection_client_send_impl(), GNUNET_CLIENT_connect(), recv_message(), transmit_ready(), try_connect_using_address(), and try_unixpath().

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 client.c.

Referenced by start_connect(), and try_connect_using_address().

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

References ClientState::attempts, ClientState::cfg, connect_fail_continuation(), CONNECT_RETRY_TIMEOUT, connect_success_continuation(), AddressProbe::cstate, 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().

{
  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);
}

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

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

{
  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);
}

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

References AddressProbe::cstate, 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, len, LOG, ClientState::mq, ClientState::msg, ClientState::msg_off, ret, RETRY, ClientState::send_task, GNUNET_MessageHeader::size, ClientState::sock, and GNUNET_MessageHeader::type.

Referenced by connect_success_continuation(), and connection_client_send_impl().

{
  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 trying to send with socket %p (MQ: %p\n",
      ntohs(cstate->msg->type),
      cstate->sock,
      cstate->mq);

RETRY:
  ret = GNUNET_NETWORK_socket_send(cstate->sock,
                                   &pos[cstate->msg_off],
                                   len - cstate->msg_off);
  if (-1 == ret)
    {
      LOG(GNUNET_ERROR_TYPE_WARNING,
          "Error during sending message of type %u\n",
          ntohs(cstate->msg->type));
      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 successful\n",
      ntohs(cstate->msg->type));
  cstate->msg = NULL;
  GNUNET_MQ_impl_send_continue(cstate->mq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

recv_message()

static int 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 322 of file client.c.

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

Referenced by GNUNET_CLIENT_connect().

{
  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;
}

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

References ClientState::ap_head, ClientState::ap_tail, 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().

{
  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);
    }
}

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

References cancel_aps(), AddressProbe::cstate, ClientState::dns_active, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, 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, 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().

{
  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_non_null(cstate->hostname);
  GNUNET_MST_destroy(cstate->mst);
  GNUNET_free(cstate);
}

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

References connection_client_destroy_impl(), AddressProbe::cstate, 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, ClientState::recv_task, ret, and ClientState::sock.

Referenced by connect_success_continuation().

{
  struct ClientState *cstate = cls;
  int 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;
  cstate->recv_task
    = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                    cstate->sock,
                                    &receive_ready,
                                    cstate);
}

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

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

{
  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);
    }
}

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

References _, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_NETWORK_shorten_unixpath(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_OK, GNUNET_strlcpy(), GNUNET_YES, LOG, and AddressProbe::sock.

Referenced by start_connect().

{
#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));
#ifdef LINUX
      {
        int abstract;

        abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg,
                                                        "TESTING",
                                                        "USE_ABSTRACT_SOCKETS");
        if (GNUNET_YES == abstract)
          s_un.sun_path[0] = '\0';
      }
#endif
#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_non_null(unixpath);
#endif
  return NULL;
}

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

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, len, LOG, GNUNET_SCHEDULER_TaskContext::reason, ClientState::service_name, ClientState::sock, AddressProbe::sock, AddressProbe::task, and tc.

Referenced by try_connect_using_address().

{
  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);
}

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

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, ClientState::sock, AddressProbe::sock, and AddressProbe::task.

Referenced by start_connect().

{
  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),
      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);
}

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

References _, 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_non_null, GNUNET_log_config_invalid(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, hostname, port, and ret.

Referenced by GNUNET_CLIENT_connect().

{
  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"));
      return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
    }
  GNUNET_free_non_null(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_non_null(hostname);
  return ret;
}

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

References AddressProbe::cstate, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, msg, ClientState::msg, ClientState::msg_off, ClientState::send_task, ClientState::sock, transmit_ready(), and GNUNET_MessageHeader::type.

Referenced by GNUNET_CLIENT_connect().

{
  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_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                     cstate->sock,
                                     &transmit_ready,
                                     cstate);
}

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

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

Referenced by GNUNET_CLIENT_connect().

{
  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;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: