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

332 {
333  struct GNUNET_NETWORK_FDSet *rs;
334 
335  /* FIXME: why use 'rs' here, seems overly complicated... */
337  GNUNET_NETWORK_fdset_set_native(rs, 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:281
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1125
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1254
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1238
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:1784
#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 
164  case 1:
165  return "KSENT";
166 
167  case 2:
168  return "KRECV";
169 
170  case 3:
171  return "READY";
172 
173  default:
174  return "";
175  }
176 }
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 187 of file gnunet-cadet.c.

Referenced by tunnels_callback().

188 {
189  switch (status)
190  {
191  case 0:
192  return "NEW ";
193 
194  case 1:
195  return "SRCH ";
196 
197  case 2:
198  return "WAIT ";
199 
200  case 3:
201  return "READY";
202 
203  case 4:
204  return "SHUTD";
205 
206  default:
207  return "";
208  }
209 }
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 218 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().

219 {
220  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
221  if (NULL != lp)
222  {
224  lp = NULL;
225  }
226  if (NULL != ch)
227  {
229  ch = NULL;
230  }
231  if (NULL != gpo)
232  {
234  gpo = NULL;
235  }
236  if (NULL != plo)
237  {
239  plo = NULL;
240  }
241  if (NULL != tio)
242  {
244  tio = NULL;
245  }
246  if (NULL != mh)
247  {
249  mh = NULL;
250  }
251  if (NULL != rd_task)
252  {
254  rd_task = NULL;
255  }
256  if (NULL != echo_task)
257  {
259  echo_task = NULL;
260  }
261  if (NULL != job)
262  {
264  job = NULL;
265  }
266 }
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:838
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:871
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:900
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 269 of file gnunet-cadet.c.

References listen_stdio().

Referenced by read_stdio().

270 {
271  listen_stdio();
272 }
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:331
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 281 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().

282 {
283  struct GNUNET_MQ_Envelope *env;
284  struct GNUNET_MessageHeader *msg;
285  char buf[60000];
286  ssize_t data_size;
287 
288  rd_task = NULL;
289  data_size = read(0, buf, 60000);
290  if (data_size < 1)
291  {
293  "read() returned %s\n",
294  strerror(errno));
296  return;
297  }
299  "Read %u bytes from stdio\n",
300  (unsigned int)data_size);
301  env = GNUNET_MQ_msg_extra(msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
302  GNUNET_memcpy(&msg[1], buf, data_size);
304 
305  sent_pkt++;
306 
307  if (GNUNET_NO == echo)
308  {
309  // Use MQ's notification if too much data of stdin is pooring in too fast.
311  {
312  GNUNET_MQ_notify_sent(env, mq_cb, cls);
313  sent_pkt = 0;
314  }
315  else
316  {
317  listen_stdio();
318  }
319  }
320  else
321  {
323  }
324 }
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#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:517
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
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:772
#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:269
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:331
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:351
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:1116
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().

359 {
360  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
361  GNUNET_assert(channel == ch);
362  ch = NULL;
364 }
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:517
#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 382 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().

385 {
387  "Incoming connection from %s\n",
388  GNUNET_i2s_full(initiator));
389  GNUNET_assert(NULL == ch);
390  GNUNET_assert(NULL != lp);
392  lp = NULL;
393  ch = channel;
394  if (GNUNET_NO == echo)
395  listen_stdio();
396  return channel;
397 }
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:78
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:331
#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:871
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 406 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().

407 {
408  struct GNUNET_MQ_Envelope *env;
409  struct GNUNET_MessageHeader *msg;
410 
411  echo_task = NULL;
412  if (NULL == ch)
413  return;
416 }
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:351
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:1116
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 428 of file gnunet-cadet.c.

References GNUNET_OK.

429 {
430  return GNUNET_OK; /* all is well-formed */
431 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ 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 445 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.

446 {
447  size_t payload_size = ntohs(message->size) - sizeof(*message);
448  uint16_t len;
449  ssize_t done;
450  uint16_t off;
451  const char *buf;
452 
454  if (GNUNET_YES == echo)
455  {
456  if (NULL != listen_port)
457  {
458  struct GNUNET_MQ_Envelope *env;
459  struct GNUNET_MessageHeader *msg;
460 
461  env =
463  GNUNET_memcpy(&msg[1], &message[1], payload_size);
465  return;
466  }
467  else
468  {
469  struct GNUNET_TIME_Relative latency;
470 
474  "time: %s\n",
477  &send_echo,
478  NULL);
479  }
480  }
481 
482  len = ntohs(message->size) - sizeof(*message);
483  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
484  buf = (const char *)&message[1];
485  off = 0;
486  while (off < len)
487  {
488  done = write(1, &buf[off], len - off);
489  if (done <= 0)
490  {
491  if (-1 == done)
494  return;
495  }
496  off += done;
497  }
498 }
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#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:517
#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:1237
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:686
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:406
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:951
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:77
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:351
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:1116
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 511 of file gnunet-cadet.c.

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

512 {
513  if (NULL == ple)
514  {
515  plo = NULL;
517  return;
518  }
519  fprintf(stdout,
520  "%s tunnel: %c, paths: %u\n",
521  GNUNET_i2s_full(&ple->peer),
522  ple->have_tunnel ? 'Y' : 'N',
523  ple->n_paths);
524 }
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:517
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 535 of file gnunet-cadet.c.

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

Referenced by show_peer().

536 {
537  if (NULL == ppd)
538  {
539  gpo = NULL;
541  return;
542  }
543  fprintf(stdout, "Path of length %u: ", ppd->path_length);
544  for (unsigned int i = 0; i < ppd->path_length; i++)
545  fprintf(stdout,
546  (i == ppd->target_offset) ? "*%s* " : "%s ",
547  GNUNET_i2s(&ppd->path[i]));
548  fprintf(stdout, "\n");
549 }
unsigned int path_length
Number of entries on the path.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
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 559 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, GNUNET_i2s_full(), GNUNET_SCHEDULER_shutdown(), and GNUNET_CADET_TunnelDetails::peer.

Referenced by get_tunnels().

560 {
561  if (NULL == td)
562  {
563  tio = NULL;
565  return;
566  }
567  fprintf(stdout,
568  "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
569  GNUNET_i2s_full(&td->peer),
570  enc_2s(td->estate),
571  conn_2s(td->cstate),
572  td->channels,
573  td->connections);
574 }
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
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:517
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:187
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 583 of file gnunet-cadet.c.

References GNUNET_CADET_list_peers(), and peers_callback().

Referenced by reconnect(), and run().

584 {
585  job = NULL;
587 }
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:511
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 596 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().

597 {
598  struct GNUNET_PeerIdentity pid;
599 
600  job = NULL;
602  strlen(peer_id),
603  &pid.public_key))
604  {
605  fprintf(stderr, _("Invalid peer ID `%s'\n"), peer_id);
607  return;
608  }
610 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:517
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:535
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 619 of file gnunet-cadet.c.

References GNUNET_CADET_list_tunnels(), and tunnels_callback().

Referenced by reconnect(), and run().

620 {
621  job = NULL;
623 }
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:559
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 632 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

633 {
634  job = NULL;
635  GNUNET_break(0);
636 }
#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 645 of file gnunet-cadet.c.

References GNUNET_break.

Referenced by run().

646 {
647  job = NULL;
648  GNUNET_break(0);
649 }
#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 661 of file gnunet-cadet.c.

References _, cfg, channel_ended(), channel_id, channel_incoming(), conn_id, data, echo, get_peers(), get_tunnels(), GNUNET_CADET_channel_create(), GNUNET_CADET_connect(), GNUNET_CADET_open_port(), 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().

665 {
669  struct GNUNET_MessageHeader,
670  NULL),
672 
673  /* FIXME add option to monitor apps */
674  my_cfg = cfg;
675  target_id = args[0];
676  if (target_id && args[1])
677  target_port = args[1];
678 
679  if ((0 != (request_peers | request_tunnels) || NULL != conn_id ||
680  NULL != channel_id) &&
681  target_id != NULL)
682  {
683  fprintf(stderr,
684  _("Extra arguments are not applicable "
685  "in combination with this option.\n"));
686  return;
687  }
688 
689  if (NULL != peer_id)
690  {
691  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
693  }
694  else if (NULL != channel_id)
695  {
696  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
698  }
699  else if (NULL != conn_id)
700  {
701  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
703  }
704  else if (GNUNET_YES == request_peers)
705  {
706  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
708  }
709  else if (GNUNET_YES == request_tunnels)
710  {
711  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
713  }
714 
715  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
716  mh = GNUNET_CADET_connect(cfg);
718  if (NULL == mh)
719  {
721  return;
722  }
723  if (NULL != listen_port)
724  {
725  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
728  &porthash,
730  NULL,
731  NULL /* window changes */,
732  &channel_ended,
733  handlers);
734  }
735  if (NULL != target_id)
736  {
737  struct GNUNET_PeerIdentity pid;
738 
739  if (GNUNET_OK !=
741  strlen(target_id),
742  &pid.public_key))
743  {
745  _("Invalid target `%s'\n"),
746  target_id);
748  return;
749  }
751  "Connecting to `%s:%s'\n",
752  target_id,
753  target_port);
756  NULL,
757  &pid,
758  &porthash,
759  NULL /* window changes */,
760  &channel_ended,
761  handlers);
762  if (GNUNET_YES == echo)
763  {
765  }
766  else
767  {
768  listen_stdio();
769  }
770  }
771 
772  if ((NULL == lp) && (NULL == job) && (NULL == ch))
773  {
774  GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, _("No action requested\n"));
776  return;
777  }
778 }
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:218
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:1284
static void get_tunnels(void *cls)
Call CADET&#39;s meta API, get all tunnels known to a peer.
Definition: gnunet-cadet.c:619
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
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:517
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:973
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:181
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:382
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:1007
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:1264
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:596
static void get_peers(void *cls)
Call CADET&#39;s meta API, get all peers known to a peer.
Definition: gnunet-cadet.c:583
static void show_channel(void *cls)
Call CADET&#39;s monitor API, get info of one channel.
Definition: gnunet-cadet.c:632
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:406
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).
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, 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:1065
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:331
#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:77
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
uint32_t data
The data value.
#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:645
struct GNUNET_CRYPTO_EddsaPublicKey public_key
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 789 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().

790 {
791  int res;
792  const char helpstr[] =
793  "Create tunnels and retrieve info about CADET's status.";
795  { /* I would use the terminology 'circuit' here... --lynX */
797  'C',
798  "connection",
799  "CONNECTION_ID",
800  gettext_noop("Provide information about a particular connection"),
801  &conn_id),
803  "echo",
804  gettext_noop("Activate echo mode"),
805  &echo),
807  'o',
808  "open-port",
809  "SHARED_SECRET",
810  gettext_noop(
811  "Listen for connections using a shared secret among sender and recipient"),
812  &listen_port),
814  "peer",
815  "PEER_ID",
816  gettext_noop(
817  "Provide information about a patricular peer"),
818  &peer_id),
820  "peers",
821  gettext_noop(
822  "Provide information about all peers"),
823  &request_peers),
825  "tunnels",
826  gettext_noop(
827  "Provide information about all tunnels"),
828  &request_tunnels),
830  };
831 
832  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
833  return 2;
834 
835  res = GNUNET_PROGRAM_run(argc,
836  argv,
837  "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
838  gettext_noop(helpstr),
839  options,
840  &run,
841  NULL);
842 
843  GNUNET_free((void *)argv);
844 
845  if (GNUNET_OK == res)
846  return 0;
847  return 1;
848 }
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:1439
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:75
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:661
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:367
#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(), and GNUNET_CURL_perform2().

◆ sent_pkt

unsigned int sent_pkt
static

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

Referenced by read_stdio().