Client library

Generic client-side communication with services. More...

Collaboration diagram for Client library:

Functions
int	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. 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

Generic client-side communication with services.

See also

Documentation

Function Documentation

GNUNET_CLIENT_test()

int 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.

Parameters

cfg	our configuration
service_name	name of the service to connect to

Returns

GNUNET_YES if the service is (likely) up (or running remotely), GNUNET_NO if the service is (definitively) down, GNUNET_SYSERR if the configuration does not give us the necessary information about the service, or if we could not check (e.g. socket() failed)

Parameters

cfg	our configuration
service_name	name of the service to connect to

Returns

GNUNET_YES if the service is (likely) up, GNUNET_NO if the service is (definitively) down, GNUNET_SYSERR if the configuration does not give us the necessary information about the service, or if we could not check (e.g. socket() failed)

Definition at line 903 of file client.c.

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

References _, cfg, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_config_invalid(), GNUNET_log_strerror, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, ClientState::hostname, port, ret, and service_name.

Referenced by action_loop(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CLIENT_connect()

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.

If handlers are specified, receive messages from the connection.

Parameters

cfg	our configuration
service_name	name of the service to connect to
handlers	handlers for receiving messages, can be NULL
error_handler	error handler
error_handler_cls	closure for the error_handler

Returns

the message queue, NULL on error

Definition at line 1057 of file client.c.

{
  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_OK !=
            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;
}

References _, cfg, ClientState::cfg, connection_client_cancel_impl(), connection_client_destroy_impl(), connection_client_send_impl(), error_handler(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_MQ_queue_for_callbacks(), GNUNET_MST_create(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_YES, handlers, ClientState::hostname, LOG, ClientState::mq, ClientState::mst, ClientState::port, recv_message(), ClientState::retry_task, service_name, ClientState::service_name, start_connect(), and test_service_configuration().

Referenced by addr_cb(), announce_reconnect(), connect_task(), create_internal(), create_loc_uri(), do_connect(), do_reconnect(), GNUNET_CONSENSUS_create(), GNUNET_CONVERSATION_call_start(), GNUNET_DATASTORE_disconnect(), GNUNET_FS_get_indexed_files(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_create_session(), GNUNET_SECRETSHARING_decrypt(), GNUNET_SETI_create(), GNUNET_SETU_create(), hash_for_index_cb(), listen_connect(), reconnect(), reconnect_arm(), reconnect_arm_monitor(), reconnect_phone(), reconnect_task(), search_reconnect(), test_nat_punched(), try_connect(), try_reconnect(), and unindex_finish().

Here is the call graph for this function:

Here is the caller graph for this function: