GNUnet  0.10.x
Macros | Functions | Variables
gnunet-cadet.c File Reference

Print information about cadet tunnels and peers. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "cadet.h"
Include dependency graph for gnunet-cadet.c:

Go to the source code of this file.

Macros

#define STREAM_BUFFER_SIZE   1024
 

Functions

static void listen_stdio (void)
 Wait for input on STDIO and send it out over the ch. More...
 
static const char * enc_2s (uint16_t status)
 Convert encryption status to human readable string. More...
 
static const char * conn_2s (uint16_t status)
 Convert connection status to human readable string. More...
 
static void shutdown_task (void *cls)
 Task to shut down this application. More...
 
void mq_cb (void *cls)
 
static void read_stdio (void *cls)
 Task run in stdio mode, after some data is available at stdin. More...
 
static void channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
static void * channel_incoming (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
 Method called whenever another peer has added us to a channel the other peer initiated. More...
 
static void send_echo (void *cls)
 Send an echo request to the remote peer. More...
 
static int check_data (void *cls, const struct GNUNET_MessageHeader *message)
 Check data message sanity. More...
 
static void handle_data (void *cls, const struct GNUNET_MessageHeader *message)
 Function called whenever a message is received. More...
 
static void peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
 Method called to retrieve information about all peers in CADET, called once per peer. More...
 
static void path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
 Method called to retrieve information about paths to a specific peer known to the service. More...
 
static void tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
 Method called to retrieve information about all tunnels in CADET. More...
 
static void get_peers (void *cls)
 Call CADET's meta API, get all peers known to a peer. More...
 
static void show_peer (void *cls)
 Call CADET's monitor API, get info of one peer. More...
 
static void get_tunnels (void *cls)
 Call CADET's meta API, get all tunnels known to a peer. More...
 
static void show_channel (void *cls)
 Call CADET's monitor API, get info of one channel. More...
 
static void show_connection (void *cls)
 Call CADET's monitor API, get info of one connection. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Main function that will be run by the scheduler. More...
 
int main (int argc, char *const *argv)
 The main function to obtain peer information. More...
 

Variables

static int request_peers
 Option -P. More...
 
static char * peer_id
 Option –peer. More...
 
static int request_tunnels
 Option -T. More...
 
static char * conn_id
 Option –connection. More...
 
static char * channel_id
 Option –channel. More...
 
static char * listen_port
 Port to listen on (-o). More...
 
static int echo
 Request echo service. More...
 
static struct GNUNET_TIME_Absolute echo_time
 Time of last echo request. More...
 
static struct GNUNET_SCHEDULER_Taskecho_task
 Task for next echo request. More...
 
static char * target_id
 Peer to connect to. More...
 
static char * target_port = "default"
 Port to connect to. More...
 
static struct GNUNET_CADET_Handlemh
 Cadet handle. More...
 
static const struct GNUNET_CONFIGURATION_Handlemy_cfg
 Our configuration. More...
 
static struct GNUNET_CADET_GetPathgpo
 Active get path operation. More...
 
static struct GNUNET_CADET_PeersListerplo
 Active peer listing operation. More...
 
static struct GNUNET_CADET_ListTunnelstio
 Active tunnel listing operation. More...
 
static struct GNUNET_CADET_Channelch
 Channel handle. More...
 
static struct GNUNET_HashCode porthash
 HashCode of the given port string. More...
 
struct GNUNET_CADET_Portlp
 Data structure for ongoing reception of incoming virtual circuits. More...
 
static struct GNUNET_SCHEDULER_Taskrd_task
 Task for reading from stdin. More...
 
static struct GNUNET_SCHEDULER_Taskjob
 Task for main job. More...
 
static unsigned int sent_pkt
 

Detailed Description

Print information about cadet tunnels and peers.

Author
Bartlomiej Polot
Christian Grothoff

Definition in file gnunet-cadet.c.

Macro Definition Documentation

◆ STREAM_BUFFER_SIZE

#define STREAM_BUFFER_SIZE   1024

Definition at line 32 of file gnunet-cadet.c.

Referenced by read_stdio().

Function Documentation

◆ listen_stdio()

static void listen_stdio ( void  )
static

Wait for input on STDIO and send it out over the ch.

Definition at line 330 of file gnunet-cadet.c.

References GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set_native(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, and read_stdio().

Referenced by channel_incoming(), mq_cb(), read_stdio(), and run().

331 {
332  struct GNUNET_NETWORK_FDSet *rs;
333 
334  /* FIXME: why use 'rs' here, seems overly complicated... */
337  0); /* STDIN */
340  rs,
341  NULL,
342  &read_stdio,
343  NULL);
345 }
static void read_stdio(void *cls)
Task run in stdio mode, after some data is available at stdin.
Definition: gnunet-cadet.c:274
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1325
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1554
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1538
collection of IO descriptors
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1829
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static struct GNUNET_SCHEDULER_Task * rd_task
Task for reading from stdin.
Definition: gnunet-cadet.c:132
Run with the default priority (normal P2P operations).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ enc_2s()

static const char* enc_2s ( uint16_t  status)
static

Convert encryption status to human readable string.

Parameters
statusEncryption status.
Returns
Human readable string.

Definition at line 157 of file gnunet-cadet.c.

Referenced by tunnels_callback().

158 {
159  switch (status)
160  {
161  case 0:
162  return "NULL ";
163  case 1:
164  return "KSENT";
165  case 2:
166  return "KRECV";
167  case 3:
168  return "READY";
169  default:
170  return "";
171  }
172 }
uint16_t status
See PRISM_STATUS_*-constants.
Here is the caller graph for this function:

◆ conn_2s()

static const char* conn_2s ( uint16_t  status)
static

Convert connection status to human readable string.

Parameters
statusConnection status.
Returns
Human readable string.

Definition at line 183 of file gnunet-cadet.c.

Referenced by tunnels_callback().

184 {
185  switch (status)
186  {
187  case 0:
188  return "NEW ";
189  case 1:
190  return "SRCH ";
191  case 2:
192  return "WAIT ";
193  case 3:
194  return "READY";
195  case 4:
196  return "SHUTD";
197  default:
198  return "";
199  }
200 }
uint16_t status
See PRISM_STATUS_*-constants.
Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task to shut down this application.

Parameters
clsClosure (unused).

Definition at line 210 of file gnunet-cadet.c.

References GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CADET_disconnect(), GNUNET_CADET_get_path_cancel(), GNUNET_CADET_list_peers_cancel(), GNUNET_CADET_list_tunnels_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_SCHEDULER_cancel().

Referenced by run().

211 {
213  "Shutdown\n");
214  if (NULL != lp)
215  {
217  lp = NULL;
218  }
219  if (NULL != ch)
220  {
222  ch = NULL;
223  }
224  if (NULL != gpo)
225  {
227  gpo = NULL;
228  }
229  if (NULL != plo)
230  {
232  plo = NULL;
233  }
234  if (NULL != tio)
235  {
237  tio = NULL;
238  }
239  if (NULL != mh)
240  {
242  mh = NULL;
243  }
244  if (NULL != rd_task)
245  {
247  rd_task = NULL;
248  }
249  if (NULL != echo_task)
250  {
252  echo_task = NULL;
253  }
254  if (NULL != job)
255  {
257  job = NULL;
258  }
259 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:849
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
void * GNUNET_CADET_list_tunnels_cancel(struct GNUNET_CADET_ListTunnels *lt)
Cancel a monitor request.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
void * GNUNET_CADET_list_peers_cancel(struct GNUNET_CADET_PeersLister *pl)
Cancel a peer info request.
struct GNUNET_CADET_Port * lp
Data structure for ongoing reception of incoming virtual circuits.
Definition: gnunet-cadet.c:127
void * GNUNET_CADET_get_path_cancel(struct GNUNET_CADET_GetPath *gp)
Cancel gp operation.
static struct GNUNET_CADET_PeersLister * plo
Active peer listing operation.
Definition: gnunet-cadet.c:107
static struct GNUNET_SCHEDULER_Task * echo_task
Task for next echo request.
Definition: gnunet-cadet.c:77
static struct GNUNET_SCHEDULER_Task * rd_task
Task for reading from stdin.
Definition: gnunet-cadet.c:132
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
#define GNUNET_log(kind,...)
static struct GNUNET_CADET_GetPath * gpo
Active get path operation.
Definition: gnunet-cadet.c:102
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:882
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:911
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:

◆ mq_cb()

void mq_cb ( void *  cls)

Definition at line 262 of file gnunet-cadet.c.

References listen_stdio().

Referenced by read_stdio().

263 {
264  listen_stdio ();
265 }
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:330
Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_stdio()

static void read_stdio ( void *  cls)
static

Task run in stdio mode, after some data is available at stdin.

Parameters
clsClosure (unused).

Definition at line 274 of file gnunet-cadet.c.

References buf, data_size, echo, echo_time, env, GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_get(), listen_stdio(), mq_cb(), msg, sent_pkt, and STREAM_BUFFER_SIZE.

Referenced by listen_stdio().

275 {
276  struct GNUNET_MQ_Envelope *env;
277  struct GNUNET_MessageHeader *msg;
278  char buf[60000];
279  ssize_t data_size;
280 
281  rd_task = NULL;
282  data_size = read (0,
283  buf,
284  60000);
285  if (data_size < 1)
286  {
288  "read() returned %s\n", strerror(errno));
290  return;
291  }
293  "Read %u bytes from stdio\n",
294  (unsigned int) data_size);
295  env = GNUNET_MQ_msg_extra (msg,
296  data_size,
298  GNUNET_memcpy (&msg[1],
299  buf,
300  data_size);
302  env);
303 
304  sent_pkt++;
305 
306  if (GNUNET_NO == echo)
307  {
308  // Use MQ's notification if too much data of stdin is pooring in too fast.
310  {
311  GNUNET_MQ_notify_sent (env, mq_cb, cls);
312  sent_pkt = 0;
313  }
314  else
315  {
316  listen_stdio ();
317  }
318  }
319  else
320  {
322  }
323 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
static struct GNUNET_TIME_Absolute echo_time
Time of last echo request.
Definition: gnunet-cadet.c:72
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
#define GNUNET_memcpy(dst, src, n)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
#define STREAM_BUFFER_SIZE
Definition: gnunet-cadet.c:32
static char buf[2048]
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_SCHEDULER_Task * rd_task
Task for reading from stdin.
Definition: gnunet-cadet.c:132
void mq_cb(void *cls)
Definition: gnunet-cadet.c:262
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:330
static unsigned int sent_pkt
Definition: gnunet-cadet.c:139
#define GNUNET_log(kind,...)
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static size_t data_size
Number of bytes in data.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1142
Here is the call graph for this function:
Here is the caller graph for this function:

◆ channel_ended()

static void channel_ended ( void *  cls,
const struct GNUNET_CADET_Channel channel 
)
static

Function called whenever a channel is destroyed.

Should clean up any associated state.

It must NOT call GNUNET_CADET_channel_destroy on the channel.

Parameters
clsclosure
channelconnection to the other end (henceforth invalid)

Definition at line 358 of file gnunet-cadet.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_SCHEDULER_shutdown().

Referenced by run().

360 {
362  "Channel ended!\n");
363  GNUNET_assert (channel == ch);
364  ch = NULL;
366 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ channel_incoming()

static void* channel_incoming ( void *  cls,
struct GNUNET_CADET_Channel channel,
const struct GNUNET_PeerIdentity initiator 
)
static

Method called whenever another peer has added us to a channel the other peer initiated.

Only called (once) upon reception of data with a message type which was subscribed to in GNUNET_CADET_connect.

A call to GNUNET_CADET_channel_destroy causes the channel to be ignored. In this case the handler MUST return NULL.

Parameters
clsclosure
channelnew handle to the channel
initiatorpeer that started the channel
Returns
initial channel context for the channel, we use channel

Definition at line 384 of file gnunet-cadet.c.

References echo, GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_ERROR_TYPE_MESSAGE, GNUNET_i2s_full(), GNUNET_log, GNUNET_NO, and listen_stdio().

Referenced by run().

387 {
389  "Incoming connection from %s\n",
390  GNUNET_i2s_full (initiator));
391  GNUNET_assert (NULL == ch);
392  GNUNET_assert (NULL != lp);
394  lp = NULL;
395  ch = channel;
396  if (GNUNET_NO == echo)
397  listen_stdio ();
398  return channel;
399 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
#define GNUNET_NO
Definition: gnunet_common.h:81
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CADET_Port * lp
Data structure for ongoing reception of incoming virtual circuits.
Definition: gnunet-cadet.c:127
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:330
#define GNUNET_log(kind,...)
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:882
Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_echo()

static void send_echo ( void *  cls)
static

Send an echo request to the remote peer.

Parameters
clsClosure (NULL).

Definition at line 408 of file gnunet-cadet.c.

References env, GNUNET_CADET_get_mq(), GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg, GNUNET_MQ_send(), and msg.

Referenced by handle_data(), and run().

409 {
410  struct GNUNET_MQ_Envelope *env;
411  struct GNUNET_MessageHeader *msg;
412 
413  echo_task = NULL;
414  if (NULL == ch)
415  return;
416  env = GNUNET_MQ_msg (msg,
419  env);
420 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
static struct GNUNET_SCHEDULER_Task * echo_task
Task for next echo request.
Definition: gnunet-cadet.c:77
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1142
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_data()

static int check_data ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Check data message sanity.

Does nothing so far (all messages are OK).

Parameters
clsClosure (unused).
messageThe message to check.
Returns
GNUNET_OK to keep the channel open, GNUNET_SYSERR to close it (signal serious error).

Definition at line 432 of file gnunet-cadet.c.

References GNUNET_OK.

434 {
435  return GNUNET_OK; /* all is well-formed */
436 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78

◆ handle_data()

static void handle_data ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Function called whenever a message is received.

Each time the function must call GNUNET_CADET_receive_done on the channel in order to receive the next message. This doesn't need to be immediate: can be delayed if some processing is done on the message.

Parameters
clsNULL
messageThe actual message.

Definition at line 450 of file gnunet-cadet.c.

References buf, done(), echo, echo_time, env, GNUNET_CADET_get_mq(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, len, listen_port, msg, send_echo(), and GNUNET_MessageHeader::size.

452 {
453  size_t payload_size = ntohs (message->size) - sizeof (*message);
454  uint16_t len;
455  ssize_t done;
456  uint16_t off;
457  const char *buf;
458 
460  if (GNUNET_YES == echo)
461  {
462  if (NULL != listen_port)
463  {
464  struct GNUNET_MQ_Envelope *env;
465  struct GNUNET_MessageHeader *msg;
466 
467  env = GNUNET_MQ_msg_extra (msg,
468  payload_size,
470  GNUNET_memcpy (&msg[1],
471  &message[1],
472  payload_size);
474  env);
475  return;
476  }
477  else
478  {
479  struct GNUNET_TIME_Relative latency;
480 
484  "time: %s\n",
486  GNUNET_NO));
488  &send_echo,
489  NULL);
490  }
491  }
492 
493  len = ntohs (message->size) - sizeof (*message);
495  "Got %u bytes\n",
496  len);
497  buf = (const char *) &message[1];
498  off = 0;
499  while (off < len)
500  {
501  done = write (1,
502  &buf[off],
503  len - off);
504  if (done <= 0)
505  {
506  if (-1 == done)
508  "write");
510  return;
511  }
512  off += done;
513  }
514 }
static char * listen_port
Port to listen on (-o).
Definition: gnunet-cadet.c:62
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static void done()
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static struct GNUNET_TIME_Absolute echo_time
Time of last echo request.
Definition: gnunet-cadet.c:72
#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...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
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
#define GNUNET_memcpy(dst, src, n)
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
static char buf[2048]
static struct GNUNET_SCHEDULER_Task * echo_task
Task for next echo request.
Definition: gnunet-cadet.c:77
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void send_echo(void *cls)
Send an echo request to the remote peer.
Definition: gnunet-cadet.c:408
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:973
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
#define GNUNET_log(kind,...)
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
Time for relative time used by GNUnet, in microseconds.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1142
Here is the call graph for this function:

◆ peers_callback()

static void peers_callback ( void *  cls,
const struct GNUNET_CADET_PeerListEntry ple 
)
static

Method called to retrieve information about all peers in CADET, called once per peer.

After last peer has been reported, an additional call with NULL is done.

Parameters
clsClosure.
pleinformation about peer, or NULL on "EOF".

Definition at line 527 of file gnunet-cadet.c.

References FPRINTF, GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), GNUNET_CADET_PeerListEntry::have_tunnel, GNUNET_CADET_PeerListEntry::n_paths, and GNUNET_CADET_PeerListEntry::peer.

Referenced by get_peers().

529 {
530  if (NULL == ple)
531  {
532  plo = NULL;
534  return;
535  }
536  FPRINTF (stdout,
537  "%s tunnel: %c, paths: %u\n",
538  GNUNET_i2s_full (&ple->peer),
539  ple->have_tunnel ? 'Y' : 'N',
540  ple->n_paths);
541 }
#define FPRINTF
Definition: plibc.h:683
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_PeerIdentity peer
Which peer is the information about?
static struct GNUNET_CADET_PeersLister * plo
Active peer listing operation.
Definition: gnunet-cadet.c:107
int have_tunnel
Do we have a tunnel to this peer?
unsigned int n_paths
Number of disjoint known paths to peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ path_callback()

static void path_callback ( void *  cls,
const struct GNUNET_CADET_PeerPathDetail ppd 
)
static

Method called to retrieve information about paths to a specific peer known to the service.

Parameters
clsClosure.
ppdpath detail

Definition at line 552 of file gnunet-cadet.c.

References FPRINTF, GNUNET_i2s(), GNUNET_SCHEDULER_shutdown(), GNUNET_CADET_PeerPathDetail::path, GNUNET_CADET_PeerPathDetail::path_length, and GNUNET_CADET_PeerPathDetail::target_offset.

Referenced by show_peer().

554 {
555  if (NULL == ppd)
556  {
557  gpo = NULL;
559  return;
560  }
561  FPRINTF (stdout,
562  "Path of length %u: ",
563  ppd->path_length);
564  for (unsigned int i = 0; i < ppd->path_length; i++)
565  FPRINTF (stdout,
566  (i == ppd->target_offset) ? "*%s* " : "%s ",
567  GNUNET_i2s (&ppd->path[i]));
568  FPRINTF (stdout,
569  "\n");
570 }
#define FPRINTF
Definition: plibc.h:683
unsigned int path_length
Number of entries on the path.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
unsigned int target_offset
Offset of the target peer on the path.
const struct GNUNET_PeerIdentity * path
Array of PEER_IDs representing all paths to reach the peer.
static struct GNUNET_CADET_GetPath * gpo
Active get path operation.
Definition: gnunet-cadet.c:102
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ tunnels_callback()

static void tunnels_callback ( void *  cls,
const struct GNUNET_CADET_TunnelDetails td 
)
static

Method called to retrieve information about all tunnels in CADET.

Parameters
clsClosure.
tdtunnel details

Definition at line 580 of file gnunet-cadet.c.

References GNUNET_CADET_TunnelDetails::channels, conn_2s(), GNUNET_CADET_TunnelDetails::connections, GNUNET_CADET_TunnelDetails::cstate, enc_2s(), GNUNET_CADET_TunnelDetails::estate, FPRINTF, GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), and GNUNET_CADET_TunnelDetails::peer.

Referenced by get_tunnels().

582 {
583  if (NULL == td)
584  {
585  tio = NULL;
587  return;
588  }
589  FPRINTF (stdout,
590  "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
591  GNUNET_i2s_full (&td->peer),
592  enc_2s (td->estate),
593  conn_2s (td->cstate),
594  td->channels,
595  td->connections);
596 }
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
#define FPRINTF
Definition: plibc.h:683
uint16_t cstate
What is our connectivity state?
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_PeerIdentity peer
Target of the tunnel.
static const char * enc_2s(uint16_t status)
Convert encryption status to human readable string.
Definition: gnunet-cadet.c:157
uint32_t channels
How many channels use the tunnel.
uint16_t estate
What is our encryption state?
static const char * conn_2s(uint16_t status)
Convert connection status to human readable string.
Definition: gnunet-cadet.c:183
uint32_t connections
How many connections support the tunnel.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_peers()

static void get_peers ( void *  cls)
static

Call CADET's meta API, get all peers known to a peer.

Parameters
clsClosure (unused).

Definition at line 605 of file gnunet-cadet.c.

References GNUNET_CADET_list_peers(), and peers_callback().

Referenced by reconnect(), and run().

606 {
607  job = NULL;
610  NULL);
611 }
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
struct GNUNET_CADET_PeersLister * GNUNET_CADET_list_peers(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_PeersCB callback, void *callback_cls)
Request information about peers known to the running cadet service.
static void peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
Method called to retrieve information about all peers in CADET, called once per peer.
Definition: gnunet-cadet.c:527
static struct GNUNET_CADET_PeersLister * plo
Active peer listing operation.
Definition: gnunet-cadet.c:107
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
Here is the call graph for this function:
Here is the caller graph for this function:

◆ show_peer()

static void show_peer ( void *  cls)
static

Call CADET's monitor API, get info of one peer.

Parameters
clsClosure (unused).

Definition at line 620 of file gnunet-cadet.c.

References _, GNUNET_CADET_get_path(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_OK, GNUNET_SCHEDULER_shutdown(), path_callback(), peer_id, and GNUNET_PeerIdentity::public_key.

Referenced by run().

621 {
622  struct GNUNET_PeerIdentity pid;
623 
624  job = NULL;
625  if (GNUNET_OK !=
627  strlen (peer_id),
628  &pid.public_key))
629  {
630  fprintf (stderr,
631  _("Invalid peer ID `%s'\n"),
632  peer_id);
634  return;
635  }
637  &pid,
638  &path_callback,
639  NULL);
640 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_CADET_GetPath * GNUNET_CADET_get_path(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *id, GNUNET_CADET_PathCB callback, void *callback_cls)
Request information about paths known to the running cadet peer.
static void path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
Method called to retrieve information about paths to a specific peer known to the service...
Definition: gnunet-cadet.c:552
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:501
The identity of the host (wraps the signing key of the peer).
static struct GNUNET_CADET_GetPath * gpo
Active get path operation.
Definition: gnunet-cadet.c:102
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_tunnels()

static void get_tunnels ( void *  cls)
static

Call CADET's meta API, get all tunnels known to a peer.

Parameters
clsClosure (unused).

Definition at line 649 of file gnunet-cadet.c.

References GNUNET_CADET_list_tunnels(), and tunnels_callback().

Referenced by reconnect(), and run().

650 {
651  job = NULL;
654  NULL);
655 }
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
struct GNUNET_CADET_ListTunnels * GNUNET_CADET_list_tunnels(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_TunnelsCB callback, void *callback_cls)
Request information about tunnels of the running cadet peer.
static void tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
Method called to retrieve information about all tunnels in CADET.
Definition: gnunet-cadet.c:580
Here is the call graph for this function:
Here is the caller graph for this function:

◆ show_channel()

static void show_channel ( void *  cls)
static

Call CADET's monitor API, get info of one channel.

Parameters
clsClosure (unused).

Definition at line 664 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

665 {
666  job = NULL;
667  GNUNET_break (0);
668 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
Here is the caller graph for this function:

◆ show_connection()

static void show_connection ( void *  cls)
static

Call CADET's monitor API, get info of one connection.

Parameters
clsClosure (unused).

Definition at line 677 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

678 {
679  job = NULL;
680  GNUNET_break (0);
681 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
char *const *  args,
const char *  cfgfile,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Main function that will be run by the scheduler.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 693 of file gnunet-cadet.c.

References _, cfg, channel_ended(), channel_id, channel_incoming(), conn_id, data, echo, FPRINTF, get_peers(), get_tunnels(), GNUNET_CADET_channel_create(), GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_CADET_OPTION_DEFAULT, GNUNET_CADET_OPTION_RELIABLE, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, listen_port, listen_stdio(), peer_id, porthash, GNUNET_PeerIdentity::public_key, request_peers, request_tunnels, send_echo(), show_channel(), show_connection(), show_peer(), shutdown_task(), target_id, and target_port.

Referenced by main().

697 {
701  struct GNUNET_MessageHeader,
702  NULL),
704  };
705 
706  /* FIXME add option to monitor apps */
707  my_cfg = cfg;
708  target_id = args[0];
709  if (target_id && args[1])
710  target_port = args[1];
711 
712  if ( (0 != (request_peers | request_tunnels)
713  || NULL != conn_id
714  || NULL != channel_id)
715  && target_id != NULL)
716  {
717  FPRINTF (stderr,
718  _("Extra arguments are not applicable "
719  "in combination with this option.\n"));
720  return;
721  }
722 
723  if (NULL != peer_id)
724  {
726  "Show peer\n");
728  NULL);
729  }
730  else if (NULL != channel_id)
731  {
733  "Show channel\n");
735  NULL);
736  }
737  else if (NULL != conn_id)
738  {
740  "Show connection\n");
742  NULL);
743  }
744  else if (GNUNET_YES == request_peers)
745  {
747  "Show all peers\n");
749  NULL);
750  }
751  else if (GNUNET_YES == request_tunnels)
752  {
754  "Show all tunnels\n");
756  NULL);
757  }
758 
760  "Connecting to CADET service\n");
761  mh = GNUNET_CADET_connect (cfg);
763  NULL);
764  if (NULL == mh)
765  {
767  return;
768  }
769  if (NULL != listen_port)
770  {
772  "Opening CADET listen port\n");
774  strlen (listen_port),
775  &porthash);
777  &porthash,
779  NULL,
780  NULL /* window changes */,
781  &channel_ended,
782  handlers);
783  }
784  if (NULL != target_id)
785  {
786  struct GNUNET_PeerIdentity pid;
788 
789  if (GNUNET_OK !=
791  strlen (target_id),
792  &pid.public_key))
793  {
795  _("Invalid target `%s'\n"),
796  target_id);
798  return;
799  }
801  "Connecting to `%s:%s'\n",
802  target_id,
803  target_port);
806  strlen(target_port),
807  &porthash);
809  NULL,
810  &pid,
811  &porthash,
812  opt,
813  NULL /* window changes */,
814  &channel_ended,
815  handlers);
816  if (GNUNET_YES == echo)
817  {
819  NULL);
820  }
821  else
822  {
823  listen_stdio ();
824  }
825  }
826 
827  if ( (NULL == lp) &&
828  (NULL == job) &&
829  (NULL == ch) )
830  {
832  _("No action requested\n"));
834  return;
835  }
836 }
static char * listen_port
Port to listen on (-o).
Definition: gnunet-cadet.c:62
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static void shutdown_task(void *cls)
Task to shut down this application.
Definition: gnunet-cadet.c:210
#define FPRINTF
Definition: plibc.h:683
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
static void get_tunnels(void *cls)
Call CADET&#39;s meta API, get all tunnels known to a peer.
Definition: gnunet-cadet.c:649
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
static int request_tunnels
Option -T.
Definition: gnunet-cadet.c:47
Enable channel reliability, lost messages will be retransmitted.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:995
struct GNUNET_CADET_Port * lp
Data structure for ongoing reception of incoming virtual circuits.
Definition: gnunet-cadet.c:127
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static char * conn_id
Option –connection.
Definition: gnunet-cadet.c:52
static void channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
Definition: gnunet-cadet.c:358
static void * channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Method called whenever another peer has added us to a channel the other peer initiated.
Definition: gnunet-cadet.c:384
static char * target_port
Port to connect to.
Definition: gnunet-cadet.c:87
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incomming MQ-based channels.
Definition: cadet_api.c:1029
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static char * channel_id
Option –channel.
Definition: gnunet-cadet.c:57
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
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:1273
static struct GNUNET_HashCode porthash
HashCode of the given port string.
Definition: gnunet-cadet.c:122
static void show_peer(void *cls)
Call CADET&#39;s monitor API, get info of one peer.
Definition: gnunet-cadet.c:620
Default options: unreliable, default buffering, not out of order.
static void get_peers(void *cls)
Call CADET&#39;s meta API, get all peers known to a peer.
Definition: gnunet-cadet.c:605
static void show_channel(void *cls)
Call CADET&#39;s monitor API, get info of one channel.
Definition: gnunet-cadet.c:664
Message handler for a specific message type.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
static struct GNUNET_SCHEDULER_Task * echo_task
Task for next echo request.
Definition: gnunet-cadet.c:77
static void send_echo(void *cls)
Send an echo request to the remote peer.
Definition: gnunet-cadet.c:408
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:501
The identity of the host (wraps the signing key of the peer).
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:330
#define GNUNET_log(kind,...)
static int request_peers
Option -P.
Definition: gnunet-cadet.c:37
static char * target_id
Peer to connect to.
Definition: gnunet-cadet.c:82
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
uint32_t data
The data value.
GNUNET_CADET_ChannelOption
Channel options.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static void show_connection(void *cls)
Call CADET&#39;s monitor API, get info of one connection.
Definition: gnunet-cadet.c:677
struct GNUNET_CRYPTO_EddsaPublicKey public_key
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, enum GNUNET_CADET_ChannelOption options, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1088
Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char *const *  argv 
)

The main function to obtain peer information.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 847 of file gnunet-cadet.c.

References conn_id, echo, gettext_noop, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), listen_port, peer_id, request_peers, request_tunnels, res, and run().

849 {
850  int res;
851  const char helpstr[] = "Create tunnels and retrieve info about CADET's status.";
853  /* I would use the terminology 'circuit' here... --lynX */
855  "connection",
856  "CONNECTION_ID",
857  gettext_noop ("Provide information about a particular connection"),
858  &conn_id),
860  "echo",
861  gettext_noop ("Activate echo mode"),
862  &echo),
864  "open-port",
865  "SHARED_SECRET",
866  gettext_noop ("Listen for connections using a shared secret among sender and recipient"),
867  &listen_port),
869  "peer",
870  "PEER_ID",
871  gettext_noop ("Provide information about a patricular peer"),
872  &peer_id),
874  "peers",
875  gettext_noop ("Provide information about all peers"),
876  &request_peers),
878  "tunnels",
879  gettext_noop ("Provide information about all tunnels"),
880  &request_tunnels),
882  };
883 
884  if (GNUNET_OK !=
885  GNUNET_STRINGS_get_utf8_args (argc, argv,
886  &argc, &argv))
887  return 2;
888 
889  res = GNUNET_PROGRAM_run (argc, argv,
890  "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
891  gettext_noop (helpstr),
892  options, &run, NULL);
893 
894  GNUNET_free ((void *) argv);
895 
896  if (GNUNET_OK == res)
897  return 0;
898  return 1;
899 }
static char * listen_port
Port to listen on (-o).
Definition: gnunet-cadet.c:62
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
static int request_tunnels
Option -T.
Definition: gnunet-cadet.c:47
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Definition of a command line option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run by the scheduler.
Definition: gnunet-cadet.c:693
static char * conn_id
Option –connection.
Definition: gnunet-cadet.c:52
static int res
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
static int request_peers
Option -P.
Definition: gnunet-cadet.c:37
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:361
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

Variable Documentation

◆ request_peers

int request_peers
static

Option -P.

Definition at line 37 of file gnunet-cadet.c.

Referenced by main(), and run().

◆ peer_id

char* peer_id
static

◆ request_tunnels

int request_tunnels
static

Option -T.

Definition at line 47 of file gnunet-cadet.c.

Referenced by main(), and run().

◆ conn_id

char* conn_id
static

Option –connection.

Definition at line 52 of file gnunet-cadet.c.

Referenced by main(), and run().

◆ channel_id

char* channel_id
static

Option –channel.

Definition at line 57 of file gnunet-cadet.c.

Referenced by run().

◆ listen_port

char* listen_port
static

Port to listen on (-o).

Definition at line 62 of file gnunet-cadet.c.

Referenced by handle_data(), main(), and run().

◆ echo

int echo
static

◆ echo_time

struct GNUNET_TIME_Absolute echo_time
static

Time of last echo request.

Definition at line 72 of file gnunet-cadet.c.

Referenced by handle_data(), and read_stdio().

◆ echo_task

struct GNUNET_SCHEDULER_Task* echo_task
static

Task for next echo request.

Definition at line 77 of file gnunet-cadet.c.

◆ target_id

char* target_id
static

Peer to connect to.

Definition at line 82 of file gnunet-cadet.c.

Referenced by run().

◆ target_port

char* target_port = "default"
static

Port to connect to.

Definition at line 87 of file gnunet-cadet.c.

Referenced by run().

◆ mh

struct GNUNET_CADET_Handle* mh
static

◆ my_cfg

const struct GNUNET_CONFIGURATION_Handle* my_cfg
static

Our configuration.

Definition at line 97 of file gnunet-cadet.c.

◆ gpo

struct GNUNET_CADET_GetPath* gpo
static

Active get path operation.

Definition at line 102 of file gnunet-cadet.c.

◆ plo

struct GNUNET_CADET_PeersLister* plo
static

Active peer listing operation.

Definition at line 107 of file gnunet-cadet.c.

◆ tio

struct GNUNET_CADET_ListTunnels* tio
static

Active tunnel listing operation.

Definition at line 112 of file gnunet-cadet.c.

Referenced by handle_issue_ticket_message(), and issue_ticket_result_cb().

◆ ch

struct GNUNET_CADET_Channel* ch
static

Channel handle.

Definition at line 117 of file gnunet-cadet.c.

Referenced by adjust_running_peers(), cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_error_handler(), cadet_mq_send_impl(), cadet_mq_send_now(), channel_audio_sent_notify(), client_connect_cb(), client_disconnect_cb(), client_schedule(), conclude_autoconfig_request(), create_channel(), debug_channel(), destroy_channel_cb(), destroy_remaining_channels(), disconnect_cadet_peers(), dyndns_lookup(), error_handler(), find_channel_by_line(), GCT_add_channel(), GNUNET_CADET_channel_create(), GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_TRANSPORT_communicator_connect(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_TRANSPORT_core_get_mq(), handle_autoconfig_request(), handle_backchannel_incoming(), handle_cadet_audio_message(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), handle_cadet_suspend_message(), handle_channel_create(), handle_channel_created(), handle_channel_destroy(), handle_client_audio_message(), handle_client_call_message(), handle_client_hangup_message(), handle_client_pickup_message(), handle_client_resume_message(), handle_client_suspend_message(), handle_create_queue(), handle_incoming_ack(), handle_local_ack(), handle_local_data(), handle_plaintext_channel_destroy(), handle_plaintext_channel_open(), handle_plaintext_channel_open_ack(), handle_plaintext_data(), handle_plaintext_data_ack(), handle_register(), handle_request_connection_reversal(), handle_send_msg(), handle_stun(), inbound_channel(), inbound_end(), iterate_channels_cb(), mq_done_finish_caller_shutdown(), notify_client_external_ipv4_change(), notify_clients(), notify_clients_stun_change(), notify_tunnel_up_cb(), process_external_ip(), reversal_callback(), send_ack_cb(), start_test(), and upnp_addr_change_cb().

◆ porthash

struct GNUNET_HashCode porthash
static

HashCode of the given port string.

Definition at line 122 of file gnunet-cadet.c.

Referenced by run().

◆ lp

struct GNUNET_CADET_Port* lp

Data structure for ongoing reception of incoming virtual circuits.

Definition at line 127 of file gnunet-cadet.c.

◆ rd_task

struct GNUNET_SCHEDULER_Task* rd_task
static

Task for reading from stdin.

Definition at line 132 of file gnunet-cadet.c.

◆ job

struct GNUNET_SCHEDULER_Task* job
static

Task for main job.

Definition at line 137 of file gnunet-cadet.c.

Referenced by GNUNET_CURL_job_add(), GNUNET_CURL_job_add2(), GNUNET_CURL_perform2(), and main().

◆ sent_pkt

unsigned int sent_pkt
static

Definition at line 139 of file gnunet-cadet.c.

Referenced by read_stdio().