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

Functions

static void start_connect (void *cls)
 Try to connect to the service. More...
 
static void connect_fail_continuation (struct ClientState *cstate)
 We've failed for good to establish a connection (timeout or no more addresses to try). More...
 
static void transmit_ready (void *cls)
 We are ready to send a message to the service. More...
 
static int recv_message (void *cls, const struct GNUNET_MessageHeader *msg)
 We have received a full message, pass to the MQ dispatcher. More...
 
static void cancel_aps (struct ClientState *cstate)
 Cancel all remaining connect attempts. More...
 
static void connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implement the destruction of a message queue. More...
 
static void receive_ready (void *cls)
 This function is called once we have data ready to read. More...
 
static void connect_success_continuation (struct ClientState *cstate)
 We've succeeded in establishing a connection. More...
 
static struct GNUNET_NETWORK_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...
 
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   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

Timeout we use on TCP connect before trying another result from the DNS resolver.

Actual value used is this value divided by the number of address families. Default is 5s.

Definition at line 44 of file client.c.

Referenced by start_connect(), and try_connect_using_address().

Function Documentation

◆ start_connect()

static void start_connect ( void *  cls)
static

Try to connect to the service.

Parameters
clsthe struct ClientState to try to connect to the service

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

785 {
786  struct ClientState *cstate = cls;
787 
788  cstate->retry_task = NULL;
789 #if 0
790  /* Never use a local source if a proxy is configured */
791  if (GNUNET_YES ==
793  cstate->cfg))
794  {
795  socks_connect (cstate);
796  return;
797  }
798 #endif
799 
800  if ( (0 == (cstate->attempts++ % 2)) ||
801  (0 == cstate->port) ||
802  (NULL == cstate->hostname) )
803  {
804  /* on even rounds, try UNIX first, or always
805  if we do not have a DNS name and TCP port. */
806  cstate->sock = try_unixpath (cstate->service_name,
807  cstate->cfg);
808  if (NULL != cstate->sock)
809  {
811  return;
812  }
813  }
814  if ( (NULL == cstate->hostname) ||
815  (0 == cstate->port) )
816  {
817  /* All options failed. Boo! */
818  connect_fail_continuation (cstate);
819  return;
820  }
821  cstate->dns_active
822  = GNUNET_RESOLVER_ip_get (cstate->hostname,
823  AF_UNSPEC,
826  cstate);
827 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:112
State we keep per client.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: client.c:117
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:927
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:501
char * service_name
Name of the service we interact with.
Definition: client.c:134
static void connect_success_continuation(struct ClientState *cstate)
We've succeeded in establishing a connection.
Definition: client.c:473
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:223
unsigned int attempts
How often have we tried to connect?
Definition: client.c:195
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:639
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:575
unsigned long long port
TCP port (0 for disabled).
Definition: client.c:185
char * hostname
Hostname, if any.
Definition: client.c:139
#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:107
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:149
#define GNUNET_YES
Definition: gnunet_common.h:80
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 223 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().

224 {
225  GNUNET_break (NULL == cstate->ap_head);
226  GNUNET_break (NULL == cstate->ap_tail);
227  GNUNET_break (NULL == cstate->dns_active);
228  GNUNET_break (NULL == cstate->sock);
229  GNUNET_assert (NULL == cstate->send_task);
230  GNUNET_assert (NULL == cstate->recv_task);
231  // GNUNET_assert (NULL == cstate->proxy_handshake);
232 
233  cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off);
235  "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
236  cstate->service_name,
238  GNUNET_YES));
239  cstate->retry_task
241  &start_connect,
242  cstate);
243 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:112
#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:134
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:1246
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:159
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:154
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:129
static void start_connect(void *cls)
Try to connect to the service.
Definition: client.c:784
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:727
#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:123
struct GNUNET_TIME_Relative back_off
Current value for our incremental back-off (for connect re-tries).
Definition: client.c:180
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:149
#define GNUNET_YES
Definition: gnunet_common.h:80
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 252 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().

253 {
254  struct ClientState *cstate = cls;
255  ssize_t ret;
256  size_t len;
257  const char *pos;
258  int notify_in_flight;
259 
260  cstate->send_task = NULL;
261  if (GNUNET_YES == cstate->in_destroy)
262  return;
263  pos = (const char *) cstate->msg;
264  len = ntohs (cstate->msg->size);
265  GNUNET_assert (cstate->msg_off < len);
267  "message of type %u trying to send with socket %p (MQ: %p\n",
268  ntohs(cstate->msg->type),
269  cstate->sock,
270  cstate->mq);
271 
272  RETRY:
273  ret = GNUNET_NETWORK_socket_send (cstate->sock,
274  &pos[cstate->msg_off],
275  len - cstate->msg_off);
276  if (-1 == ret)
277  {
279  "Error during sending message of type %u\n",
280  ntohs(cstate->msg->type));
281  if (EINTR == errno){
283  "Retrying message of type %u\n",
284  ntohs(cstate->msg->type));
285  goto RETRY;
286  }
287  GNUNET_MQ_inject_error (cstate->mq,
289  return;
290  }
291  notify_in_flight = (0 == cstate->msg_off);
292  cstate->msg_off += ret;
293  if (cstate->msg_off < len)
294  {
296  "rescheduling message of type %u\n",
297  ntohs(cstate->msg->type));
298  cstate->send_task
300  cstate->sock,
302  cstate);
303  if (notify_in_flight)
305  return;
306  }
308  "sending message of type %u successful\n",
309  ntohs(cstate->msg->type));
310  cstate->msg = NULL;
312 }
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:927
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:1548
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:202
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:252
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static int ret
Final status code.
Definition: gnunet-arm.c:89
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:519
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:154
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:144
size_t msg_off
Offset in the message where we are for transmission.
Definition: client.c:190
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
#define GNUNET_YES
Definition: gnunet_common.h:80
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:486
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 326 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().

328 {
329  struct ClientState *cstate = cls;
330 
331  if (GNUNET_YES == cstate->in_destroy)
332  return GNUNET_NO;
334  "Received message of type %u and size %u from %s\n",
335  ntohs (msg->type),
336  ntohs (msg->size),
337  cstate->service_name);
338  GNUNET_MQ_inject_message (cstate->mq,
339  msg);
340  if (GNUNET_YES == cstate->in_destroy)
341  return GNUNET_NO;
342  return GNUNET_OK;
343 }
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:202
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:134
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
#define GNUNET_YES
Definition: gnunet_common.h:80
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 352 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().

353 {
354  struct AddressProbe *pos;
355 
356  while (NULL != (pos = cstate->ap_head))
357  {
362  cstate->ap_tail,
363  pos);
364  GNUNET_free (pos);
365  }
366 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:129
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:123
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
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:965
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 377 of file client.c.

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

Referenced by GNUNET_CLIENT_connect(), and receive_ready().

379 {
380  struct ClientState *cstate = impl_state;
381 
382  (void) mq;
383  if (NULL != cstate->dns_active)
384  {
386  cstate->dns_active = NULL;
387  }
388  if (NULL != cstate->send_task)
389  {
391  cstate->send_task = NULL;
392  }
393  if (NULL != cstate->retry_task)
394  {
396  cstate->retry_task = NULL;
397  }
398  if (GNUNET_SYSERR == cstate->in_destroy)
399  {
400  /* defer destruction */
401  cstate->in_destroy = GNUNET_YES;
402  cstate->mq = NULL;
403  return;
404  }
405  if (NULL != cstate->recv_task)
406  {
408  cstate->recv_task = NULL;
409  }
410  if (NULL != cstate->sock)
411  {
413  "destroying socket: %p\n",
414  cstate->sock);
416  }
417  cancel_aps (cstate);
418  GNUNET_free (cstate->service_name);
419  GNUNET_free_non_null (cstate->hostname);
420  GNUNET_MST_destroy (cstate->mst);
421  GNUNET_free (cstate);
422 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:112
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:352
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:202
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
char * service_name
Name of the service we interact with.
Definition: client.c:134
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:159
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:413
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:154
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
Definition: client.c:164
char * hostname
Hostname, if any.
Definition: client.c:139
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
struct GNUNET_SCHEDULER_Task * retry_task
Task for trying to connect to the service.
Definition: client.c:149
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#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:965
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 431 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().

432 {
433  struct ClientState *cstate = cls;
434  int ret;
435 
436  cstate->recv_task = NULL;
437  cstate->in_destroy = GNUNET_SYSERR;
438  ret = GNUNET_MST_read (cstate->mst,
439  cstate->sock,
440  GNUNET_NO,
441  GNUNET_NO);
442  if (GNUNET_SYSERR == ret)
443  {
444  if (NULL != cstate->mq)
445  GNUNET_MQ_inject_error (cstate->mq,
447  if (GNUNET_YES == cstate->in_destroy)
449  cstate);
450  return;
451  }
452  if (GNUNET_YES == cstate->in_destroy)
453  {
455  cstate);
456  return;
457  }
458  cstate->in_destroy = GNUNET_NO;
459  cstate->recv_task
461  cstate->sock,
462  &receive_ready,
463  cstate);
464 }
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:377
int in_destroy
Are we supposed to die? GNUNET_SYSERR if destruction must be deferred, GNUNET_NO by default...
Definition: client.c:202
#define GNUNET_NO
Definition: gnunet_common.h:81
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:159
Failed to read message from the network.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
Definition: client.c:164
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:347
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
#define GNUNET_YES
Definition: gnunet_common.h:80
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:1478
static void receive_ready(void *cls)
This function is called once we have data ready to read.
Definition: client.c:431
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 473 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().

474 {
475  GNUNET_assert (NULL == cstate->recv_task);
476  cstate->recv_task
478  cstate->sock,
479  &receive_ready,
480  cstate);
481  if (NULL != cstate->msg)
482  {
483  GNUNET_assert (NULL == cstate->send_task);
484  cstate->send_task
486  cstate->sock,
488  cstate);
489  }
490 }
#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:1548
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:252
struct GNUNET_SCHEDULER_Task * recv_task
Task for sending messages to the service.
Definition: client.c:159
struct GNUNET_SCHEDULER_Task * send_task
Task for sending messages to the service.
Definition: client.c:154
#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:144
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
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:1478
static void receive_ready(void *cls)
This function is called once we have data ready to read.
Definition: client.c:431
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 501 of file client.c.

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

Referenced by start_connect().

503 {
504 #if AF_UNIX
505  struct GNUNET_NETWORK_Handle *sock;
506  char *unixpath;
507  struct sockaddr_un s_un;
508 
509  unixpath = NULL;
510  if ((GNUNET_OK ==
512  service_name,
513  "UNIXPATH",
514  &unixpath)) &&
515  (0 < strlen (unixpath)))
516  {
517  /* We have a non-NULL unixpath, need to validate it */
518  if (strlen (unixpath) >= sizeof (s_un.sun_path))
519  {
521  _("UNIXPATH `%s' too long, maximum length is %llu\n"),
522  unixpath,
523  (unsigned long long) sizeof (s_un.sun_path));
524  unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
526  _("Using `%s' instead\n"),
527  unixpath);
528  if (NULL == unixpath)
529  return NULL;
530  }
531  memset (&s_un,
532  0,
533  sizeof (s_un));
534  s_un.sun_family = AF_UNIX;
535  GNUNET_strlcpy (s_un.sun_path,
536  unixpath,
537  sizeof (s_un.sun_path));
538 #ifdef LINUX
539  {
540  int abstract;
541 
542  abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
543  "TESTING",
544  "USE_ABSTRACT_SOCKETS");
545  if (GNUNET_YES == abstract)
546  s_un.sun_path[0] = '\0';
547  }
548 #endif
549 #if HAVE_SOCKADDR_UN_SUN_LEN
550  s_un.sun_len = (u_char) sizeof (struct sockaddr_un);
551 #endif
552  sock = GNUNET_NETWORK_socket_create (AF_UNIX,
553  SOCK_STREAM,
554  0);
555  if ( (NULL != sock) &&
556  ( (GNUNET_OK ==
558  (struct sockaddr *) &s_un,
559  sizeof (s_un))) ||
560  (EINPROGRESS == errno) ) )
561  {
563  "Successfully connected to unixpath `%s'!\n",
564  unixpath);
565  GNUNET_free (unixpath);
566  return sock;
567  }
568  if (NULL != sock)
570  }
571  GNUNET_free_non_null (unixpath);
572 #endif
573  return NULL;
574 }
#define LOG(kind,...)
Definition: client.c:36
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
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:731
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:46
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:157
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#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:1037
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 584 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().

585 {
586  struct AddressProbe *ap = cls;
587  struct ClientState *cstate = ap->cstate;
588  const struct GNUNET_SCHEDULER_TaskContext *tc;
589  int error;
590  socklen_t len;
591 
592  ap->task = NULL;
593  GNUNET_assert (NULL != ap->sock);
595  cstate->ap_tail,
596  ap);
597  len = sizeof (error);
598  error = 0;
600  if ( (0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
601  (GNUNET_OK !=
603  SOL_SOCKET,
604  SO_ERROR,
605  &error,
606  &len)) ||
607  (0 != error) )
608  {
611  GNUNET_free (ap);
612  if ( (NULL == cstate->ap_head) &&
613  // (NULL == cstate->proxy_handshake) &&
614  (NULL == cstate->dns_active) )
615  connect_fail_continuation (cstate);
616  return;
617  }
619  "Connection to `%s' succeeded!\n",
620  cstate->service_name);
621  /* trigger jobs that waited for the connection */
622  GNUNET_assert (NULL == cstate->sock);
623  cstate->sock = ap->sock;
624  GNUNET_free (ap);
625  cancel_aps (cstate);
627 }
#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:112
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:746
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:417
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:763
static void cancel_aps(struct ClientState *cstate)
Cancel all remaining connect attempts.
Definition: client.c:352
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:134
static void connect_success_continuation(struct ClientState *cstate)
We&#39;ve succeeded in establishing a connection.
Definition: client.c:473
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:129
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:223
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:123
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
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:84
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 639 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().

642 {
643  struct ClientState *cstate = cls;
644  struct AddressProbe *ap;
645 
646  if (NULL == addr)
647  {
648  cstate->dns_active = NULL;
649  if ( (NULL == cstate->ap_head) &&
650  // (NULL == cstate->proxy_handshake) &&
651  (NULL == cstate->sock) )
652  connect_fail_continuation (cstate);
653  return;
654  }
655  if (NULL != cstate->sock)
656  return; /* already connected */
657  /* try to connect */
659  "Trying to connect using address `%s:%u'\n",
660  GNUNET_a2s (addr,
661  addrlen),
662  cstate->port);
663  ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
664  ap->addr = (const struct sockaddr *) &ap[1];
665  GNUNET_memcpy (&ap[1],
666  addr,
667  addrlen);
668  ap->addrlen = addrlen;
669  ap->cstate = cstate;
670 
671  switch (ap->addr->sa_family)
672  {
673  case AF_INET:
674  ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port);
675  break;
676  case AF_INET6:
677  ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port);
678  break;
679  default:
680  GNUNET_break (0);
681  GNUNET_free (ap);
682  return; /* not supported by us */
683  }
684  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
685  SOCK_STREAM,
686  0);
687  if (NULL == ap->sock)
688  {
689  GNUNET_free (ap);
690  return; /* not supported by OS */
691  }
692  if ( (GNUNET_OK !=
694  ap->addr,
695  ap->addrlen)) &&
696  (EINPROGRESS != errno) )
697  {
698  /* maybe refused / unsupported address, try next */
700  "connect");
703  GNUNET_free (ap);
704  return;
705  }
707  cstate->ap_tail,
708  ap);
710  ap->sock,
712  ap);
713 }
struct GNUNET_RESOLVER_RequestHandle * dns_active
Handle to a pending DNS lookup request, NULL if DNS is finished.
Definition: client.c:112
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:1548
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:731
#define GNUNET_memcpy(dst, src, n)
struct AddressProbe * ap_tail
Linked list of sockets we are currently trying out (during connect).
Definition: client.c:129
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:223
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:123
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:584
unsigned long long port
TCP port (0 for disabled).
Definition: client.c:185
#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:107
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:604
#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:1037
struct ClientState * cstate
Connection for which we are probing.
Definition: client.c:84
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 725 of file client.c.

References _, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free_non_null, GNUNET_log_config_invalid(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, hostname, port, and ret.

Referenced by GNUNET_CLIENT_connect().

727 {
728  int ret = GNUNET_SYSERR;
729  char *hostname = NULL;
730  unsigned long long port;
731 #if AF_UNIX
732  char *unixpath = NULL;
733 
734  if ((GNUNET_OK ==
736  service_name,
737  "UNIXPATH",
738  &unixpath)) &&
739  (0 < strlen (unixpath)))
740  ret = GNUNET_OK;
741  else if ((GNUNET_OK ==
743  service_name,
744  "UNIXPATH")))
745  {
747  service_name,
748  "UNIXPATH",
749  _("not a valid filename"));
750  return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
751  }
752  GNUNET_free_non_null (unixpath);
753 #endif
754 
755  if ( (GNUNET_YES ==
757  service_name,
758  "PORT")) &&
759  (GNUNET_OK ==
761  service_name,
762  "PORT",
763  &port)) &&
764  (port <= 65535) &&
765  (0 != port) &&
766  (GNUNET_OK ==
768  service_name,
769  "HOSTNAME",
770  &hostname)) &&
771  (0 != strlen (hostname)) )
772  ret = GNUNET_OK;
773  GNUNET_free_non_null (hostname);
774  return ret;
775 }
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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
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.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static char * hostname
Our hostname; we give this to all the peers we start.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
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_YES
Definition: gnunet_common.h:80
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 838 of file client.c.

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

Referenced by GNUNET_CLIENT_connect().

841 {
842  struct ClientState *cstate = impl_state;
843 
844  (void) mq;
845  /* only one message at a time allowed */
846  GNUNET_assert (NULL == cstate->msg);
847  GNUNET_assert (NULL == cstate->send_task);
848  cstate->msg = msg;
849  cstate->msg_off = 0;
850  if (NULL == cstate->sock)
851  {
853  "message of type %u waiting for socket\n",
854  ntohs(msg->type));
855  return; /* still waiting for connection */
856  }
857  cstate->send_task
859  cstate->sock,
861  cstate);
862 }
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.
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:1548
static void transmit_ready(void *cls)
We are ready to send a message to the service.
Definition: client.c:252
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:154
#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:144
size_t msg_off
Offset in the message where we are for transmission.
Definition: client.c:190
struct GNUNET_NETWORK_Handle * sock
The connection handle, NULL if not live.
Definition: client.c:107
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 872 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().

874 {
875  struct ClientState *cstate = impl_state;
876 
877  (void) mq;
878  GNUNET_assert (NULL != cstate->msg);
879  GNUNET_assert (0 == cstate->msg_off);
880  cstate->msg = NULL;
881  if (NULL != cstate->send_task)
882  {
884  cstate->send_task = NULL;
885  }
886 }
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:154
const struct GNUNET_MessageHeader * msg
Next message to transmit to the service.
Definition: client.c:144
size_t msg_off
Offset in the message where we are for transmission.
Definition: client.c:190
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function: