GNUnet  0.11.x
Data Structures | Macros | Functions
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. 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_Handletry_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...
 
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_HandleGNUNET_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.

◆ CONNECT_RETRY_TIMEOUT

#define CONNECT_RETRY_TIMEOUT
Value:
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:311

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.

Function Documentation

◆ start_connect()

static void start_connect ( void *  cls)
static

Try to connect to the service.

Parameters
clsthe struct ClientState to try to connect to the service

Definition at line 783 of file client.c.

784 {
785  struct ClientState *cstate = cls;
786 
787  cstate->retry_task = NULL;
788 #if 0
789  /* Never use a local source if a proxy is configured */
790  if (GNUNET_YES ==
792  cstate->cfg))
793  {
794  socks_connect (cstate);
795  return;
796  }
797 #endif
798 
799  if ((0 == (cstate->attempts++ % 2)) ||
800  (0 == cstate->port) ||
801  (NULL == cstate->hostname))
802  {
803  /* on even rounds, try UNIX first, or always
804  if we do not have a DNS name and TCP port. */
805  cstate->sock = try_unixpath (cstate->service_name,
806  cstate->cfg);
807  if (NULL != cstate->sock)
808  {
810  return;
811  }
812  }
813  if ((NULL == cstate->hostname) ||
814  (0 == cstate->port))
815  {
816  /* All options failed. Boo! */
817  connect_fail_continuation (cstate);
818  return;
819  }
820  cstate->dns_active
821  = GNUNET_RESOLVER_ip_get (cstate->hostname,
822  AF_UNSPEC,
825  cstate);
826 }
static void try_connect_using_address(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Try to establish a connection given the specified address.
Definition: client.c:634
static void connect_success_continuation(struct ClientState *cstate)
We've succeeded in establishing a connection.
Definition: client.c:479
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.
Definition: client.c:507
static void connect_fail_continuation(struct ClientState *cstate)
We've failed for good to establish a connection (timeout or no more addresses to try).
Definition: client.c:220
#define CONNECT_RETRY_TIMEOUT
Timeout we use on TCP connect before trying another result from the DNS resolver.
Definition: client.c:44
@ GNUNET_YES
Definition: gnunet_common.h:97
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition: resolver_api.c:939
int GNUNET_SOCKS_check_service(const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
Check if a SOCKS proxy is required by a service.
Definition: socks.c:593
State we keep per client.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: client.c:115
unsigned int attempts
How often have we tried to connect?
Definition: client.c:193
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:147
char * hostname
Hostname, if any.
Definition: client.c:137
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
unsigned long long port
TCP port (0 for disabled).
Definition: client.c:183
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
char * service_name
Name of the service we interact with.
Definition: client.c:132

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
cstatethe connection we tried to establish

Definition at line 220 of file client.c.

221 {
222  GNUNET_break (NULL == cstate->ap_head);
223  GNUNET_break (NULL == cstate->ap_tail);
224  GNUNET_break (NULL == cstate->dns_active);
225  GNUNET_break (NULL == cstate->sock);
226  GNUNET_assert (NULL == cstate->send_task);
227  GNUNET_assert (NULL == cstate->recv_task);
228  // GNUNET_assert (NULL == cstate->proxy_handshake);
229 
230  cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off);
232  "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
233  cstate->service_name,
235  GNUNET_YES));
236  cstate->retry_task
238  &start_connect,
239  cstate);
240 }
static void start_connect(void *cls)
Try to connect to the service.
Definition: client.c:783
#define LOG(kind,...)
Definition: client.c:36
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:557
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_TIME_Relative back_off
Current value for our incremental back-off (for connect re-tries).
Definition: client.c:178
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:157
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:127
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:121

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
clsthe struct ClientState with the msg to transmit

Definition at line 249 of file client.c.

250 {
251  struct ClientState *cstate = cls;
252  ssize_t ret;
253  size_t len;
254  const char *pos;
255  int notify_in_flight;
256 
257  cstate->send_task = NULL;
258  if (GNUNET_YES == cstate->in_destroy)
259  return;
260  pos = (const char *) cstate->msg;
261  len = ntohs (cstate->msg->size);
262  GNUNET_assert (cstate->msg_off < len);
264  "message of type %u trying to send with socket %p (MQ: %p\n",
265  ntohs (cstate->msg->type),
266  cstate->sock,
267  cstate->mq);
268 
269 RETRY:
271  &pos[cstate->msg_off],
272  len - cstate->msg_off);
273  if ( (-1 == ret) &&
274  ( (EAGAIN == errno) ||
275  (EINTR == errno) ) )
276  {
277  /* ignore */
278  ret = 0;
279  }
280  if (-1 == ret)
281  {
283  "Error during sending message of type %u: %s\n",
284  ntohs (cstate->msg->type),
285  strerror (errno));
286  if (EINTR == errno)
287  {
289  "Retrying message of type %u\n",
290  ntohs (cstate->msg->type));
291  goto RETRY;
292  }
293  GNUNET_MQ_inject_error (cstate->mq,
295  return;
296  }
297  notify_in_flight = (0 == cstate->msg_off);
298  cstate->msg_off += ret;
299  if (cstate->msg_off < len)
300  {
302  "rescheduling message of type %u\n",
303  ntohs (cstate->msg->type));
304  cstate->send_task
306  cstate->sock,
308  cstate);
309  if (notify_in_flight)
311  return;
312  }
314  "sending message of type %u successful\n",
315  ntohs (cstate->msg->type));
316  cstate->msg = NULL;
318 }
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:249
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
@ GNUNET_ERROR_TYPE_WARNING
void GNUNET_MQ_inject_error(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
Call the error handler of a message queue with the given error code.
Definition: mq.c:300
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:499
void GNUNET_MQ_impl_send_in_flight(struct GNUNET_MQ_Handle *mq)
Call the send notification for the current message, but do not try to send the next message until #gn...
Definition: mq.c:532
@ GNUNET_MQ_ERROR_WRITE
FIXME: document!
ssize_t GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc, const void *buffer, size_t length)
Send data (always non-blocking).
Definition: network.c:812
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1588
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define RETRY
Return code we give on 'send' if we failed to send right now but it makes sense to retry later.
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default,...
Definition: client.c:200
const struct GNUNET_MessageHeader * msg
Next message to transmit to the service.
Definition: client.c:142
size_t msg_off
Offset in the message where we are for transmission.
Definition: client.c:188
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.

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

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
clsthe struct ClientState
msgmessage 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 332 of file client.c.

334 {
335  struct ClientState *cstate = cls;
336 
337  if (GNUNET_YES == cstate->in_destroy)
338  return GNUNET_NO;
340  "Received message of type %u and size %u from %s\n",
341  ntohs (msg->type),
342  ntohs (msg->size),
343  cstate->service_name);
344  GNUNET_MQ_inject_message (cstate->mq,
345  msg);
346  if (GNUNET_YES == cstate->in_destroy)
347  return GNUNET_NO;
348  return GNUNET_OK;
349 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_NO
Definition: gnunet_common.h:94
void GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given m...
Definition: mq.c:202

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
cstatehandle of the client state to process

Definition at line 358 of file client.c.

359 {
360  struct AddressProbe *pos;
361 
362  while (NULL != (pos = cstate->ap_head))
363  {
368  cstate->ap_tail,
369  pos);
370  GNUNET_free (pos);
371  }
372 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
During connect, we try multiple possible IP addresses to find out which one might work.
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
struct GNUNET_NETWORK_Handle * sock
Underlying OS's socket.
struct ClientState * cstate
Connection for which we are probing.
Definition: client.c:83

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
mqthe message queue to destroy
impl_stateour struct ClientState

Definition at line 383 of file client.c.

385 {
386  struct ClientState *cstate = impl_state;
387 
388  (void) mq;
389  if (NULL != cstate->dns_active)
390  {
392  cstate->dns_active = NULL;
393  }
394  if (NULL != cstate->send_task)
395  {
397  cstate->send_task = NULL;
398  }
399  if (NULL != cstate->retry_task)
400  {
402  cstate->retry_task = NULL;
403  }
404  if (GNUNET_SYSERR == cstate->in_destroy)
405  {
406  /* defer destruction */
407  cstate->in_destroy = GNUNET_YES;
408  cstate->mq = NULL;
409  return;
410  }
411  if (NULL != cstate->recv_task)
412  {
414  cstate->recv_task = NULL;
415  }
416  if (NULL != cstate->sock)
417  {
419  "destroying socket: %p\n",
420  cstate->sock);
422  }
423  cancel_aps (cstate);
424  GNUNET_free (cstate->service_name);
425  GNUNET_free (cstate->hostname);
426  GNUNET_MST_destroy (cstate->mst);
427  GNUNET_free (cstate);
428 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static void cancel_aps(struct ClientState *cstate)
Cancel all remaining connect attempts.
Definition: client.c:358
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:411
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
Definition: client.c:162

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

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
clsstruct ClientState with connection to read from

Definition at line 437 of file client.c.

438 {
439  struct ClientState *cstate = cls;
440  int ret;
441 
442  cstate->recv_task = NULL;
443  cstate->in_destroy = GNUNET_SYSERR;
444  ret = GNUNET_MST_read (cstate->mst,
445  cstate->sock,
446  GNUNET_NO,
447  GNUNET_NO);
448  if (GNUNET_SYSERR == ret)
449  {
450  if (NULL != cstate->mq)
451  GNUNET_MQ_inject_error (cstate->mq,
453  if (GNUNET_YES == cstate->in_destroy)
455  cstate);
456  return;
457  }
458  if (GNUNET_YES == cstate->in_destroy)
459  {
461  cstate);
462  return;
463  }
464  cstate->in_destroy = GNUNET_NO;
465  cstate->recv_task
467  cstate->sock,
468  &receive_ready,
469  cstate);
470 }
static void receive_ready(void *cls)
This function is called once we have data ready to read.
Definition: client.c:437
static void connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implement the destruction of a message queue.
Definition: client.c:383
@ GNUNET_MQ_ERROR_READ
Failed to read message from the network.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1517
int GNUNET_MST_read(struct GNUNET_MessageStreamTokenizer *mst, struct GNUNET_NETWORK_Handle *sock, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:345

References connection_client_destroy_impl(), 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().

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
cstatethe connection we tried to establish

Definition at line 479 of file client.c.

480 {
481  GNUNET_assert (NULL == cstate->recv_task);
482  cstate->recv_task
484  cstate->sock,
485  &receive_ready,
486  cstate);
487  if (NULL != cstate->msg)
488  {
489  GNUNET_assert (NULL == cstate->send_task);
490  cstate->send_task
492  cstate->sock,
494  cstate);
495  }
496 }

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_namename of service to connect to
cfgconfiguration to use
Returns
NULL on error, socket connected to UNIX otherwise

Definition at line 507 of file client.c.

509 {
510 #if AF_UNIX
511  struct GNUNET_NETWORK_Handle *sock;
512  char *unixpath;
513  struct sockaddr_un s_un;
514 
515  unixpath = NULL;
516  if ((GNUNET_OK ==
518  service_name,
519  "UNIXPATH",
520  &unixpath)) &&
521  (0 < strlen (unixpath)))
522  {
523  /* We have a non-NULL unixpath, need to validate it */
524  if (strlen (unixpath) >= sizeof(s_un.sun_path))
525  {
527  _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
528  unixpath,
529  (unsigned long long) sizeof(s_un.sun_path));
530  unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
532  _ ("Using `%s' instead\n"),
533  unixpath);
534  if (NULL == unixpath)
535  return NULL;
536  }
537  memset (&s_un,
538  0,
539  sizeof(s_un));
540  s_un.sun_family = AF_UNIX;
541  GNUNET_strlcpy (s_un.sun_path,
542  unixpath,
543  sizeof(s_un.sun_path));
544 #if HAVE_SOCKADDR_UN_SUN_LEN
545  s_un.sun_len = (u_char) sizeof(struct sockaddr_un);
546 #endif
547  sock = GNUNET_NETWORK_socket_create (AF_UNIX,
548  SOCK_STREAM,
549  0);
550  if ((NULL != sock) &&
551  ((GNUNET_OK ==
553  (struct sockaddr *) &s_un,
554  sizeof(s_un))) ||
555  (EINPROGRESS == errno)))
556  {
558  "Successfully connected to unixpath `%s'!\n",
559  unixpath);
560  GNUNET_free (unixpath);
561  return sock;
562  }
563  if (NULL != sock)
565  }
566  GNUNET_free (unixpath);
567 #endif
568  return NULL;
569 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:907
char * GNUNET_NETWORK_shorten_unixpath(char *unixpath)
Given a unixpath that is too long (larger than UNIX_PATH_MAX), shorten it to an acceptable length whi...
Definition: network.c:158
int GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:658
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:162
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
handle to a socket
Definition: network.c:53

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
clsthe struct AddressProbe * with the address that we are probing

Definition at line 579 of file client.c.

580 {
581  struct AddressProbe *ap = cls;
582  struct ClientState *cstate = ap->cstate;
583  const struct GNUNET_SCHEDULER_TaskContext *tc;
584  int error;
585  socklen_t len;
586 
587  ap->task = NULL;
588  GNUNET_assert (NULL != ap->sock);
590  cstate->ap_tail,
591  ap);
592  len = sizeof(error);
593  error = 0;
596  (GNUNET_OK !=
598  SOL_SOCKET,
599  SO_ERROR,
600  &error,
601  &len)) ||
602  (0 != error))
603  {
606  GNUNET_free (ap);
607  if ((NULL == cstate->ap_head) &&
608  // (NULL == cstate->proxy_handshake) &&
609  (NULL == cstate->dns_active))
610  connect_fail_continuation (cstate);
611  return;
612  }
614  "Connection to `%s' succeeded!\n",
615  cstate->service_name);
616  /* trigger jobs that waited for the connection */
617  GNUNET_assert (NULL == cstate->sock);
618  cstate->sock = ap->sock;
619  GNUNET_free (ap);
620  cancel_aps (cstate);
622 }
int GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc, int level, int optname, void *optval, socklen_t *optlen)
Get socket options.
Definition: network.c:683
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:752
@ GNUNET_SCHEDULER_REASON_WRITE_READY
The writing socket is ready.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
Context information passed to each scheduler task.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.

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, 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
clsour struct ClientState *
addraddress to try, NULL for "last call"
addrlenlength of addr

Definition at line 634 of file client.c.

637 {
638  struct ClientState *cstate = cls;
639  struct AddressProbe *ap;
640 
641  if (NULL == addr)
642  {
643  cstate->dns_active = NULL;
644  if ((NULL == cstate->ap_head) &&
645  // (NULL == cstate->proxy_handshake) &&
646  (NULL == cstate->sock))
648  return;
649  }
650  if (NULL != cstate->sock)
651  return; /* already connected */
652  /* try to connect */
654  "Trying to connect using address `%s:%u'\n",
655  GNUNET_a2s (addr,
656  addrlen),
657  (unsigned int) cstate->port);
658  ap = GNUNET_malloc (sizeof(struct AddressProbe) + addrlen);
659  ap->addr = (const struct sockaddr *) &ap[1];
660  GNUNET_memcpy (&ap[1],
661  addr,
662  addrlen);
663  ap->addrlen = addrlen;
664  ap->cstate = cstate;
665 
666  switch (ap->addr->sa_family)
667  {
668  case AF_INET:
669  ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port);
670  break;
671 
672  case AF_INET6:
673  ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port);
674  break;
675 
676  default:
677  GNUNET_break (0);
678  GNUNET_free (ap);
679  return; /* not supported by us */
680  }
681  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
682  SOCK_STREAM,
683  0);
684  if (NULL == ap->sock)
685  {
686  GNUNET_free (ap);
687  return; /* not supported by OS */
688  }
689  if ((GNUNET_OK !=
691  ap->addr,
692  ap->addrlen)) &&
693  (EINPROGRESS != errno))
694  {
695  /* maybe refused / unsupported address, try next */
697  "connect");
700  GNUNET_free (ap);
701  return;
702  }
704  cstate->ap_tail,
705  ap);
707  ap->sock,
709  ap);
710 }
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.
Definition: client.c:579
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
socklen_t addrlen
Length of addr.
const struct sockaddr * addr
The address; do not free (allocated at the end of this struct).

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_namename of service to connect to
cfgconfiguration to use
Returns
GNUNET_OK if the configuration is valid, GNUNET_SYSERR if not

Definition at line 722 of file client.c.

724 {
725  int ret = GNUNET_SYSERR;
726  char *hostname = NULL;
727  unsigned long long port;
728 
729 #if AF_UNIX
730  char *unixpath = NULL;
731 
732  if ((GNUNET_OK ==
734  service_name,
735  "UNIXPATH",
736  &unixpath)) &&
737  (0 < strlen (unixpath)))
738  ret = GNUNET_OK;
739  else if ((GNUNET_OK ==
741  service_name,
742  "UNIXPATH")))
743  {
745  service_name,
746  "UNIXPATH",
747  _ ("not a valid filename"));
748  GNUNET_free (unixpath);
749  return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
750  }
751  GNUNET_free (unixpath);
752 #endif
753 
754  if ((GNUNET_YES ==
756  service_name,
757  "PORT")) &&
758  (GNUNET_OK ==
760  service_name,
761  "PORT",
762  &port)) &&
763  (port <= 65535) &&
764  (0 != port) &&
765  (GNUNET_OK ==
767  service_name,
768  "HOSTNAME",
769  &hostname)) &&
770  (0 != strlen (hostname)))
771  ret = GNUNET_OK;
773  return ret;
774 }
static uint16_t port
Port number.
Definition: gnunet-bcd.c:83
static char * hostname
Our hostname; we give this to all the peers we start.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
@ GNUNET_ERROR_TYPE_ERROR

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, hostname, 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
mqthe message queue
msgthe message to send
impl_stateour struct ClientState

Definition at line 837 of file client.c.

840 {
841  struct ClientState *cstate = impl_state;
842 
843  (void) mq;
844  /* only one message at a time allowed */
845  GNUNET_assert (NULL == cstate->msg);
846  GNUNET_assert (NULL == cstate->send_task);
847  cstate->msg = msg;
848  cstate->msg_off = 0;
849  if (NULL == cstate->sock)
850  {
852  "message of type %u waiting for socket\n",
853  ntohs (msg->type));
854  return; /* still waiting for connection */
855  }
856  cstate->send_task
858  cstate);
859 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296

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
mqmessage queue
impl_stateour struct ClientState

Definition at line 869 of file client.c.

871 {
872  struct ClientState *cstate = impl_state;
873 
874  (void) mq;
875  GNUNET_assert (NULL != cstate->msg);
876  GNUNET_assert (0 == cstate->msg_off);
877  cstate->msg = NULL;
878  if (NULL != cstate->send_task)
879  {
881  cstate->send_task = NULL;
882  }
883 }

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: