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__)

◆ 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:442

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
clsthe struct ClientState to try to connect to the service

Definition at line 782 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().

783 {
784  struct ClientState *cstate = cls;
785 
786  cstate->retry_task = NULL;
787 #if 0
788  /* Never use a local source if a proxy is configured */
789  if (GNUNET_YES ==
791  cstate->cfg))
792  {
793  socks_connect (cstate);
794  return;
795  }
796 #endif
797 
798  if ((0 == (cstate->attempts++ % 2)) ||
799  (0 == cstate->port) ||
800  (NULL == cstate->hostname))
801  {
802  /* on even rounds, try UNIX first, or always
803  if we do not have a DNS name and TCP port. */
804  cstate->sock = try_unixpath (cstate->service_name,
805  cstate->cfg);
806  if (NULL != cstate->sock)
807  {
809  return;
810  }
811  }
812  if ((NULL == cstate->hostname) ||
813  (0 == cstate->port))
814  {
815  /* All options failed. Boo! */
816  connect_fail_continuation (cstate);
817  return;
818  }
819  cstate->dns_active
820  = GNUNET_RESOLVER_ip_get (cstate->hostname,
821  AF_UNSPEC,
824  cstate);
825 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
State we keep per client.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: client.c:115
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
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
char * service_name
Name of the service we interact with.
Definition: client.c:132
static void connect_success_continuation(struct ClientState *cstate)
We've succeeded in establishing a connection.
Definition: client.c:479
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
unsigned int attempts
How often have we tried to connect?
Definition: client.c:193
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
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
unsigned long long port
TCP port (0 for disabled).
Definition: client.c:183
char * hostname
Hostname, if any.
Definition: client.c:137
#define CONNECT_RETRY_TIMEOUT
Timeout we use on TCP connect before trying another result from the DNS resolver. ...
Definition: client.c:44
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:147
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.

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

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 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
#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...
char * service_name
Name of the service we interact with.
Definition: client.c:132
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
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:157
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:127
static void start_connect(void *cls)
Try to connect to the service.
Definition: client.c:782
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:702
#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 AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:121
struct GNUNET_TIME_Relative back_off
Current value for our incremental back-off (for connect re-tries).
Definition: client.c:178
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:147
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.

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

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:
270  ret = GNUNET_NETWORK_socket_send (cstate->sock,
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 }
State we keep per client.
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
#define RETRY
Return code we give on &#39;send&#39; if we failed to send right now but it makes sense to retry later...
ssize_t GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc, const void *buffer, size_t length)
Send data (always non-blocking).
Definition: network.c:816
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
#define LOG(kind,...)
Definition: client.c:36
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1588
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:200
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:249
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
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
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
FIXME: document!
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
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
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
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
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

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

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 }
State we keep per client.
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
#define LOG(kind,...)
Definition: client.c:36
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:200
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
char * service_name
Name of the service we interact with.
Definition: client.c:132
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
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
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.

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

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.
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:127
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:121
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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.

References cancel_aps(), AddressProbe::cstate, 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, 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().

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_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
State we keep per client.
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
#define LOG(kind,...)
Definition: client.c:36
static void cancel_aps(struct ClientState *cstate)
Cancel all remaining connect attempts.
Definition: client.c:358
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:200
char * service_name
Name of the service we interact with.
Definition: client.c:132
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:157
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:411
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
Definition: client.c:162
char * hostname
Hostname, if any.
Definition: client.c:137
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:147
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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.

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

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 }
State we keep per client.
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
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
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
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:200
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:157
Failed to read message from the network.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
Definition: client.c:162
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
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
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
static void receive_ready(void *cls)
This function is called once we have data ready to read.
Definition: client.c:437
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.

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

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 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1588
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:249
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:157
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const struct GNUNET_MessageHeader * msg
Next message to transmit to the service.
Definition: client.c:142
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
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
static void receive_ready(void *cls)
This function is called once we have data ready to read.
Definition: client.c:437
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.

References _, 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 AddressProbe::sock.

Referenced by start_connect().

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 }
#define LOG(kind,...)
Definition: client.c:36
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
int 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.
handle to a socket
Definition: network.c:52
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
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:221
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:912
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.

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

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;
595  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:752
State we keep per client.
Context information passed to each scheduler task.
#define LOG(kind,...)
Definition: client.c:36
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
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
static void cancel_aps(struct ClientState *cstate)
Cancel all remaining connect attempts.
Definition: client.c:358
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
char * service_name
Name of the service we interact with.
Definition: client.c:132
static void connect_success_continuation(struct ClientState *cstate)
We&#39;ve succeeded in establishing a connection.
Definition: client.c:479
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:127
static void connect_fail_continuation(struct ClientState *cstate)
We&#39;ve failed for good to establish a connection (timeout or no more addresses to try).
Definition: client.c:220
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
The writing socket is ready.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:121
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct ClientState * cstate
Connection for which we are probing.
Definition: client.c:83
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.

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

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))
647  connect_fail_continuation (cstate);
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 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:110
const struct sockaddr * addr
The address; do not free (allocated at the end of this struct).
State we keep per client.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define LOG(kind,...)
Definition: client.c:36
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_SCHEDULER_Task * task
Task waiting for the connection to finish connecting.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
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
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:127
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)...
static void connect_fail_continuation(struct ClientState *cstate)
We&#39;ve failed for good to establish a connection (timeout or no more addresses to try).
Definition: client.c:220
socklen_t addrlen
Lenth of addr.
struct GNUNET_NETWORK_Handle * sock
Underlying OS&#39;s socket.
struct AddressProbe * ap_head
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:121
static void connect_probe_continuation(void *cls)
Scheduler let us know that we&#39;re either ready to write on the socket OR connect timed out...
Definition: client.c:579
unsigned long long port
TCP port (0 for disabled).
Definition: client.c:183
#define CONNECT_RETRY_TIMEOUT
Timeout we use on TCP connect before trying another result from the DNS resolver. ...
Definition: client.c:44
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
#define GNUNET_malloc(size)
Wrapper around malloc.
During connect, we try multiple possible IP addresses to find out which one might work...
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:912
struct ClientState * cstate
Connection for which we are probing.
Definition: client.c:83
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.

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

Referenced by GNUNET_CLIENT_connect().

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  return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
749  }
750  GNUNET_free (unixpath);
751 #endif
752 
753  if ((GNUNET_YES ==
755  service_name,
756  "PORT")) &&
757  (GNUNET_OK ==
759  service_name,
760  "PORT",
761  &port)) &&
762  (port <= 65535) &&
763  (0 != port) &&
764  (GNUNET_OK ==
766  service_name,
767  "HOSTNAME",
768  &hostname)) &&
769  (0 != strlen (hostname)))
770  ret = GNUNET_OK;
771  GNUNET_free (hostname);
772  return ret;
773 }
int 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.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
int 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.
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
int 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.
static char * hostname
Our hostname; we give this to all the peers we start.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
int 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.
#define GNUNET_free(ptr)
Wrapper around free.
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 836 of file client.c.

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

Referenced by GNUNET_CLIENT_connect().

839 {
840  struct ClientState *cstate = impl_state;
841 
842  (void) mq;
843  /* only one message at a time allowed */
844  GNUNET_assert (NULL == cstate->msg);
845  GNUNET_assert (NULL == cstate->send_task);
846  cstate->msg = msg;
847  cstate->msg_off = 0;
848  if (NULL == cstate->sock)
849  {
851  "message of type %u waiting for socket\n",
852  ntohs (msg->type));
853  return; /* still waiting for connection */
854  }
855  cstate->send_task
857  cstate);
858 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
State we keep per client.
#define LOG(kind,...)
Definition: client.c:36
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:249
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
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
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
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:105
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 868 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().

870 {
871  struct ClientState *cstate = impl_state;
872 
873  (void) mq;
874  GNUNET_assert (NULL != cstate->msg);
875  GNUNET_assert (0 == cstate->msg_off);
876  cstate->msg = NULL;
877  if (NULL != cstate->send_task)
878  {
880  cstate->send_task = NULL;
881  }
882 }
State we keep per client.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:152
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
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function: