GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
gnunet-service-conversation.c File Reference

conversation service implementation More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_applications.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "gnunet_cadet_service.h"
#include "gnunet_conversation_service.h"
#include "conversation.h"
Include dependency graph for gnunet-service-conversation.c:

Go to the source code of this file.

Data Structures

struct  Channel
 A struct Channel represents a cadet channel, which is a P2P connection to another conversation service. More...
 
struct  Line
 A struct Line connects a local client with cadet channels. More...
 

Macros

#define RING_TIMEOUT   GNUNET_TIME_UNIT_DAYS
 How long is our signature on a call valid? Needs to be long enough for time zone differences and network latency to not matter. More...
 

Enumerations

enum  ChannelStatus {
  CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_CONNECTED, CS_CALLEE_SHUTDOWN,
  CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN
}
 The possible connection status. More...
 

Functions

static struct Channelfind_channel_by_line (struct Line *line, uint32_t cid)
 Given a cid, find the corresponding channel given a line. More...
 
static void handle_client_pickup_message (void *cls, const struct ClientPhonePickupMessage *msg)
 Function to handle a pickup request message from the client. More...
 
static void clean_up_channel (struct Channel *ch)
 Channel went down, notify client and free data structure. More...
 
static void destroy_line_cadet_channels (struct Channel *ch)
 Destroy a channel. More...
 
static void mq_done_finish_caller_shutdown (void *cls)
 We are done signalling shutdown to the other peer. More...
 
static void handle_client_hangup_message (void *cls, const struct ClientPhoneHangupMessage *msg)
 Function to handle a hangup request message from the client. More...
 
static void handle_client_suspend_message (void *cls, const struct ClientPhoneSuspendMessage *msg)
 Function to handle a suspend request message from the client. More...
 
static void handle_client_resume_message (void *cls, const struct ClientPhoneResumeMessage *msg)
 Function to handle a resume request message from the client. More...
 
static void channel_audio_sent_notify (void *cls)
 Transmission of audio data via cadet channel finished. More...
 
static int check_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
 Function to check audio data from the client. More...
 
static void handle_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
 Function to handle audio data from the client. More...
 
static void handle_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg)
 Function to handle a ring message incoming over cadet. More...
 
static void handle_cadet_hangup_message (void *cls, const struct CadetPhoneHangupMessage *message)
 Function to handle a hangup message incoming over cadet. More...
 
static void handle_cadet_pickup_message (void *cls, const struct CadetPhonePickupMessage *message)
 Function to handle a pickup message incoming over cadet. More...
 
static void handle_cadet_suspend_message (void *cls, const struct CadetPhoneSuspendMessage *message)
 Function to handle a suspend message incoming over cadet. More...
 
static void handle_cadet_resume_message (void *cls, const struct CadetPhoneResumeMessage *msg)
 Function to handle a resume message incoming over cadet. More...
 
static int check_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
 Function to check an audio message incoming over cadet. More...
 
static void handle_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
 Function to handle an audio message incoming over cadet. More...
 
static void inbound_end (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever an inbound channel is destroyed. More...
 
static void handle_client_call_message (void *cls, const struct ClientCallMessage *msg)
 Function to handle call request from the client. More...
 
static void * inbound_channel (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 * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 A client connected. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 A client disconnected. More...
 
static void handle_client_register_message (void *cls, const struct ClientPhoneRegisterMessage *msg)
 Function to register a phone. More...
 
static void do_shutdown (void *cls)
 Shutdown nicely. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Main function that will be run by the scheduler. More...
 
 GNUNET_SERVICE_MAIN ("conversation", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(client_register_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER, struct ClientPhoneRegisterMessage, NULL), GNUNET_MQ_hd_fixed_size(client_pickup_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP, struct ClientPhonePickupMessage, NULL), GNUNET_MQ_hd_fixed_size(client_suspend_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, struct ClientPhoneSuspendMessage, NULL), GNUNET_MQ_hd_fixed_size(client_resume_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, struct ClientPhoneResumeMessage, NULL), GNUNET_MQ_hd_fixed_size(client_hangup_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, struct ClientPhoneHangupMessage, NULL), GNUNET_MQ_hd_fixed_size(client_call_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, struct ClientCallMessage, NULL), GNUNET_MQ_hd_var_size(client_audio_message, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, struct ClientAudioMessage, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_CADET_Handlecadet
 Handle for cadet. More...
 
static struct GNUNET_PeerIdentity my_identity
 Identity of this peer. More...
 

Detailed Description

conversation service implementation

Author
Simon Dieterle
Andreas Fuchs
Christian Grothoff

Definition in file gnunet-service-conversation.c.

Macro Definition Documentation

◆ RING_TIMEOUT

#define RING_TIMEOUT   GNUNET_TIME_UNIT_DAYS

How long is our signature on a call valid? Needs to be long enough for time zone differences and network latency to not matter.

No strong need for it to be short, but we simply like all signatures to eventually expire.

Definition at line 43 of file gnunet-service-conversation.c.

Referenced by handle_client_call_message().

Enumeration Type Documentation

◆ ChannelStatus

The possible connection status.

Enumerator
CS_CALLEE_INIT 

We just got the connection, but no introduction yet.

CS_CALLEE_RINGING 

Our phone is ringing, waiting for the client to pick up.

CS_CALLEE_CONNECTED 

We are talking!

CS_CALLEE_SHUTDOWN 

We're in shutdown, sending hangup messages before cleaning up.

CS_CALLER_CALLING 

We are waiting for the phone to be picked up.

CS_CALLER_CONNECTED 

We are talking!

CS_CALLER_SHUTDOWN 

We're in shutdown, sending hangup messages before cleaning up.

Definition at line 55 of file gnunet-service-conversation.c.

56 {
61 
66 
71 
76 
81 
86 
91 };
We're in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
We're in shutdown, sending hangup messages before cleaning up.

Function Documentation

◆ find_channel_by_line()

static struct Channel* find_channel_by_line ( struct Line line,
uint32_t  cid 
)
static

Given a cid, find the corresponding channel given a line.

Parameters
linea line to search
cidwhat to search for
Returns
NULL for not found

Definition at line 222 of file gnunet-service-conversation.c.

References ch, and Line::channel_head.

Referenced by handle_client_audio_message().

223 {
224  for (struct Channel *ch = line->channel_head; NULL != ch; ch = ch->next)
225  if (cid == ch->cid)
226  return ch;
227  return NULL;
228 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
struct Channel * channel_head
This is a DLL.
Here is the caller graph for this function:

◆ handle_client_pickup_message()

static void handle_client_pickup_message ( void *  cls,
const struct ClientPhonePickupMessage msg 
)
static

Function to handle a pickup request message from the client.

Parameters
clsthe struct Line of the client from which the message is
msgthe message from the client

Definition at line 238 of file gnunet-service-conversation.c.

References ch, Line::channel_head, Channel::cid, ClientPhonePickupMessage::cid, Line::client, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, Channel::env, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), Channel::line, Channel::mq, Channel::next, Line::port, and Channel::status.

240 {
241  struct Line *line = cls;
242  struct CadetPhonePickupMessage *mppm;
243  struct GNUNET_MQ_Envelope *env;
244  struct Channel *ch;
245 
246  if (NULL == line->port)
247  {
248  /* we never opened the port, bad client! */
249  GNUNET_break_op (0);
251  return;
252  }
253  for (ch = line->channel_head; NULL != ch; ch = ch->next)
254  if (msg->cid == ch->cid)
255  break;
256  if (NULL == ch)
257  {
258  /* could have been destroyed asynchronously, ignore message */
259  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
261  return;
262  }
263  switch (ch->status)
264  {
265  case CS_CALLEE_INIT:
266  GNUNET_break (0);
268  return;
269 
270  case CS_CALLEE_RINGING:
272  break;
273 
274  case CS_CALLEE_CONNECTED:
275  GNUNET_break (0);
277  return;
278 
279  case CS_CALLEE_SHUTDOWN:
281  "Ignoring client's PICKUP message, line is in SHUTDOWN\n");
282  break;
283 
284  case CS_CALLER_CALLING:
285  case CS_CALLER_CONNECTED:
286  case CS_CALLER_SHUTDOWN:
287  GNUNET_break (0);
289  return;
290  }
292  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICK_UP message to cadet\n");
293  env =
295  GNUNET_MQ_send (ch->mq, env);
297 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CADET_Port * port
Our open port.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We're in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We just got the connection, but no introduction yet.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP
Cadet: pick up phone (establish audio channel)
Our phone is ringing, waiting for the client to pick up.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_SERVICE_Client * client
Handle to the line client.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:162
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
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
We're in shutdown, sending hangup messages before cleaning up.
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
Cadet message for picking up.
Definition: conversation.h:333
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
struct Channel * next
This is a DLL.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ clean_up_channel()

static void clean_up_channel ( struct Channel ch)
static

Channel went down, notify client and free data structure.

Parameters
chchannel that went down

Definition at line 307 of file gnunet-service-conversation.c.

References Line::channel_head, Line::channel_tail, Channel::cid, ClientPhoneHangupMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, Channel::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, GNUNET_MQ_msg, GNUNET_MQ_send(), Channel::line, Line::mq, and Channel::status.

Referenced by destroy_line_cadet_channels(), and inbound_end().

308 {
309  struct Line *line = ch->line;
310  struct GNUNET_MQ_Envelope *env;
311  struct ClientPhoneHangupMessage *hup;
312 
313  switch (ch->status)
314  {
315  case CS_CALLEE_INIT:
316  case CS_CALLEE_SHUTDOWN:
317  case CS_CALLER_SHUTDOWN:
318  break;
319 
320  case CS_CALLEE_RINGING:
321  case CS_CALLEE_CONNECTED:
322  case CS_CALLER_CALLING:
323  case CS_CALLER_CONNECTED:
324  if (NULL != line)
325  {
326  env =
328  hup->cid = ch->cid;
329  GNUNET_MQ_send (line->mq, env);
330  }
331  break;
332  }
333  if (NULL != line)
335  GNUNET_free (ch);
336 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
enum ChannelStatus status
Current status of this line.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:181
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct Channel * channel_tail
This is a DLL.
We're in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:170
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct Channel * channel_head
This is a DLL.
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
We&#39;re in shutdown, sending hangup messages before cleaning up.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
Client -> Server message to reject/hangup a call.
#define GNUNET_free(ptr)
Wrapper around free.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ destroy_line_cadet_channels()

static void destroy_line_cadet_channels ( struct Channel ch)
static

Destroy a channel.

Parameters
chchannel to destroy.

Definition at line 345 of file gnunet-service-conversation.c.

References Channel::channel, clean_up_channel(), GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by client_disconnect_cb(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), and mq_done_finish_caller_shutdown().

346 {
347  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying cadet channels\n");
348  if (NULL != ch->channel)
349  {
351  ch->channel = NULL;
352  }
353  clean_up_channel (ch);
354 }
struct GNUNET_CADET_Channel * channel
Handle for the channel.
static void clean_up_channel(struct Channel *ch)
Channel went down, notify client and free data structure.
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_done_finish_caller_shutdown()

static void mq_done_finish_caller_shutdown ( void *  cls)
static

We are done signalling shutdown to the other peer.

Close down the channel.

Parameters
clsthe struct Channel to reset/terminate

Definition at line 364 of file gnunet-service-conversation.c.

References ch, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, destroy_line_cadet_channels(), GNUNET_break, and Channel::status.

Referenced by handle_cadet_pickup_message(), and handle_client_hangup_message().

365 {
366  struct Channel *ch = cls;
367 
368  switch (ch->status)
369  {
370  case CS_CALLEE_INIT:
371  GNUNET_break (0);
372  break;
373 
374  case CS_CALLEE_RINGING:
375  GNUNET_break (0);
376  break;
377 
378  case CS_CALLEE_CONNECTED:
379  GNUNET_break (0);
380  break;
381 
382  case CS_CALLEE_SHUTDOWN:
384  break;
385 
386  case CS_CALLER_CALLING:
387  GNUNET_break (0);
388  break;
389 
390  case CS_CALLER_CONNECTED:
391  GNUNET_break (0);
392  break;
393 
394  case CS_CALLER_SHUTDOWN:
396  break;
397  }
398 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
We&#39;re in shutdown, sending hangup messages before cleaning up.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_client_hangup_message()

static void handle_client_hangup_message ( void *  cls,
const struct ClientPhoneHangupMessage msg 
)
static

Function to handle a hangup request message from the client.

Parameters
clsthe struct Line the hangup is for
msgthe message from the client

Definition at line 408 of file gnunet-service-conversation.c.

References ch, Line::channel_head, Channel::cid, ClientPhoneHangupMessage::cid, Line::client, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, e, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP, GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), Channel::line, Channel::mq, mq_done_finish_caller_shutdown(), Channel::next, and Channel::status.

410 {
411  struct Line *line = cls;
412  struct GNUNET_MQ_Envelope *e;
413  struct CadetPhoneHangupMessage *mhum;
414  struct Channel *ch;
415 
416  for (ch = line->channel_head; NULL != ch; ch = ch->next)
417  if (msg->cid == ch->cid)
418  break;
419  if (NULL == ch)
420  {
421  /* could have been destroyed asynchronously, ignore message */
422  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
424  return;
425  }
427  "Received HANGUP for channel %u which is in state %d\n",
428  msg->cid,
429  ch->status);
430  switch (ch->status)
431  {
432  case CS_CALLEE_INIT:
433  GNUNET_break (0);
435  return;
436 
437  case CS_CALLEE_RINGING:
439  break;
440 
441  case CS_CALLEE_CONNECTED:
443  break;
444 
445  case CS_CALLEE_SHUTDOWN:
446  /* maybe the other peer closed asynchronously... */
448  return;
449 
450  case CS_CALLER_CALLING:
452  break;
453 
454  case CS_CALLER_CONNECTED:
456  break;
457 
458  case CS_CALLER_SHUTDOWN:
459  /* maybe the other peer closed asynchronously... */
461  return;
462  }
463  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG_UP message via cadet\n");
464  e =
467  GNUNET_MQ_send (ch->mq, e);
469 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:181
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP
Cadet: hang up / refuse call.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
static char * line
Desired phone line (string to be converted to a hash).
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
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
static void mq_done_finish_caller_shutdown(void *cls)
We are done signalling shutdown to the other peer.
A struct Line connects a local client with cadet channels.
struct GNUNET_SERVICE_Client * client
Handle to the line client.
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
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
Cadet message for hanging up.
Definition: conversation.h:321
We&#39;re in shutdown, sending hangup messages before cleaning up.
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
struct Channel * next
This is a DLL.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_client_suspend_message()

static void handle_client_suspend_message ( void *  cls,
const struct ClientPhoneSuspendMessage msg 
)
static

Function to handle a suspend request message from the client.

Parameters
clsthe struct Line the message is about
msgthe message from the client

Definition at line 479 of file gnunet-service-conversation.c.

References ch, Line::channel_head, ClientPhoneSuspendMessage::cid, Channel::cid, Line::client, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, e, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, Channel::line, Channel::mq, Channel::next, Channel::status, and Channel::suspended_local.

481 {
482  struct Line *line = cls;
483  struct GNUNET_MQ_Envelope *e;
484  struct CadetPhoneSuspendMessage *mhum;
485  struct Channel *ch;
486 
487  for (ch = line->channel_head; NULL != ch; ch = ch->next)
488  if (msg->cid == ch->cid)
489  break;
490  if (NULL == ch)
491  {
492  /* could have been destroyed asynchronously, ignore message */
493  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
495  return;
496  }
497  if (GNUNET_YES == ch->suspended_local)
498  {
499  GNUNET_break (0);
501  return;
502  }
504  "Received SUSPEND for channel %u which is in state %d\n",
505  msg->cid,
506  ch->status);
507  switch (ch->status)
508  {
509  case CS_CALLEE_INIT:
510  GNUNET_break (0);
512  return;
513 
514  case CS_CALLEE_RINGING:
515  GNUNET_break (0);
517  return;
518 
519  case CS_CALLEE_CONNECTED:
521  break;
522 
523  case CS_CALLEE_SHUTDOWN:
524  /* maybe the other peer closed asynchronously... */
526  return;
527 
528  case CS_CALLER_CALLING:
529  GNUNET_break (0);
531  return;
532 
533  case CS_CALLER_CONNECTED:
535  break;
536 
537  case CS_CALLER_SHUTDOWN:
538  /* maybe the other peer closed asynchronously... */
540  return;
541  }
542  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUSPEND message via cadet\n");
543  e =
545  GNUNET_MQ_send (ch->mq, e);
547 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND
Cadet: phone suspended.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
int8_t suspended_local
GNUNET_YES if the channel was suspended by the local client.
static char * line
Desired phone line (string to be converted to a hash).
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
A struct Line connects a local client with cadet channels.
Cadet message for phone suspended.
Definition: conversation.h:345
struct GNUNET_SERVICE_Client * client
Handle to the line client.
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
#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:353
We&#39;re in shutdown, sending hangup messages before cleaning up.
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
struct Channel * next
This is a DLL.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:126
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_client_resume_message()

static void handle_client_resume_message ( void *  cls,
const struct ClientPhoneResumeMessage msg 
)
static

Function to handle a resume request message from the client.

Parameters
clsthe struct Line the message is about
msgthe message from the client

Definition at line 557 of file gnunet-service-conversation.c.

References ch, Line::channel_head, Channel::cid, ClientPhoneResumeMessage::cid, Line::client, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, e, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, Channel::line, Channel::mq, Channel::next, Channel::status, and Channel::suspended_local.

559 {
560  struct Line *line = cls;
561  struct GNUNET_MQ_Envelope *e;
562  struct CadetPhoneResumeMessage *mhum;
563  struct Channel *ch;
564 
565  for (ch = line->channel_head; NULL != ch; ch = ch->next)
566  if (msg->cid == ch->cid)
567  break;
568  if (NULL == ch)
569  {
570  /* could have been destroyed asynchronously, ignore message */
571  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
573  return;
574  }
575  if (GNUNET_YES != ch->suspended_local)
576  {
577  GNUNET_break (0);
579  return;
580  }
582  "Received RESUME for channel %u which is in state %d\n",
583  msg->cid,
584  ch->status);
585  switch (ch->status)
586  {
587  case CS_CALLEE_INIT:
588  GNUNET_break (0);
590  return;
591 
592  case CS_CALLEE_RINGING:
593  GNUNET_break (0);
595  return;
596 
597  case CS_CALLEE_CONNECTED:
599  break;
600 
601  case CS_CALLEE_SHUTDOWN:
602  /* maybe the other peer closed asynchronously... */
604  return;
605 
606  case CS_CALLER_CALLING:
607  GNUNET_break (0);
609  return;
610 
611  case CS_CALLER_CONNECTED:
613  break;
614 
615  case CS_CALLER_SHUTDOWN:
616  /* maybe the other peer closed asynchronously... */
618  return;
619  }
620  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RESUME message via cadet\n");
622  GNUNET_MQ_send (ch->mq, e);
624 }
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:144
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
int8_t suspended_local
GNUNET_YES if the channel was suspended by the local client.
static char * line
Desired phone line (string to be converted to a hash).
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME
Cadet: phone resumed.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
A struct Line connects a local client with cadet channels.
struct GNUNET_SERVICE_Client * client
Handle to the line client.
Cadet message for phone resumed.
Definition: conversation.h:357
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
#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:353
We&#39;re in shutdown, sending hangup messages before cleaning up.
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
struct Channel * next
This is a DLL.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ channel_audio_sent_notify()

static void channel_audio_sent_notify ( void *  cls)
static

Transmission of audio data via cadet channel finished.

Parameters
clsthe struct Channel we are transmitting for

Definition at line 633 of file gnunet-service-conversation.c.

References ch, and Channel::env.

Referenced by handle_client_audio_message().

634 {
635  struct Channel *ch = cls;
636 
637  ch->env = NULL;
638 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
struct GNUNET_MQ_Envelope * env
Temporary buffer for audio data in the mq.
Here is the caller graph for this function:

◆ check_client_audio_message()

static int check_client_audio_message ( void *  cls,
const struct ClientAudioMessage msg 
)
static

Function to check audio data from the client.

Parameters
clsthe struct Line the message is about
msgthe message from the client
Returns
GNUNET_OK (any data is ok)

Definition at line 649 of file gnunet-service-conversation.c.

References GNUNET_OK.

650 {
651  (void) cls;
652  (void) msg;
653  return GNUNET_OK;
654 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ handle_client_audio_message()

static void handle_client_audio_message ( void *  cls,
const struct ClientAudioMessage msg 
)
static

Function to handle audio data from the client.

Parameters
clsthe struct Line the message is about
msgthe message from the client

Definition at line 664 of file gnunet-service-conversation.c.

References ch, channel_audio_sent_notify(), ClientAudioMessage::cid, Line::client, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, Channel::env, find_channel_by_line(), GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_MQ_send_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, ClientAudioMessage::header, Channel::line, Channel::mq, size, GNUNET_MessageHeader::size, Channel::status, and Channel::suspended_local.

665 {
666  struct Line *line = cls;
667  struct CadetAudioMessage *mam;
668  struct Channel *ch;
669  size_t size;
670 
671  size = ntohs (msg->header.size) - sizeof(struct ClientAudioMessage);
672  ch = find_channel_by_line (line, msg->cid);
673  if (NULL == ch)
674  {
675  /* could have been destroyed asynchronously, ignore message */
676  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
678  return;
679  }
680 
681  switch (ch->status)
682  {
683  case CS_CALLEE_INIT:
684  case CS_CALLEE_RINGING:
685  case CS_CALLER_CALLING:
686  GNUNET_break (0);
688  return;
689 
690  case CS_CALLEE_CONNECTED:
691  case CS_CALLER_CONNECTED:
692  /* common case, handled below */
693  break;
694 
695  case CS_CALLEE_SHUTDOWN:
696  case CS_CALLER_SHUTDOWN:
698  "Cadet audio channel in shutdown; audio data dropped\n");
700  return;
701  }
702  if (GNUNET_YES == ch->suspended_local)
703  {
705  "This channel is suspended locally\n");
707  return;
708  }
709  if (NULL != ch->env)
710  {
711  /* NOTE: we may want to not do this and instead combine the data */
713  "Bandwidth insufficient; dropping previous audio data segment\n");
715  ch->env = NULL;
716  }
717 
719  "Received %u bytes of AUDIO data from client CID %u\n",
720  (unsigned int) size,
721  msg->cid);
722  ch->env = GNUNET_MQ_msg_extra (mam,
723  size,
725  GNUNET_memcpy (&mam[1], &msg[1], size);
726  /* FIXME: set options for unreliable transmission */
728  GNUNET_MQ_send (ch->mq, ch->env);
730 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO
Cadet: audio data.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static void channel_audio_sent_notify(void *cls)
Transmission of audio data via cadet channel finished.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
int8_t suspended_local
GNUNET_YES if the channel was suspended by the local client.
#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
static char * line
Desired phone line (string to be converted to a hash).
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
struct GNUNET_MQ_Envelope * env
Temporary buffer for audio data in the mq.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
static struct Channel * find_channel_by_line(struct Line *line, uint32_t cid)
Given a cid, find the corresponding channel given a line.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
A struct Line connects a local client with cadet channels.
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_SERVICE_Client * client
Handle to the line client.
#define GNUNET_log(kind,...)
Message Client <-> Service to transmit the audio.
Definition: conversation.h:188
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:193
#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:353
We&#39;re in shutdown, sending hangup messages before cleaning up.
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:916
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
Cadet message to transmit the audio.
Definition: conversation.h:369
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:199
Here is the call graph for this function:

◆ handle_cadet_ring_message()

static void handle_cadet_ring_message ( void *  cls,
const struct CadetPhoneRingMessage msg 
)
static

Function to handle a ring message incoming over cadet.

Parameters
clsclosure, NULL
msgthe incoming message

Definition at line 740 of file gnunet-service-conversation.c.

References ClientPhoneRingMessage::caller_id, CadetPhoneRingMessage::caller_id, ch, Channel::channel, ClientPhoneRingMessage::cid, Channel::cid, CS_CALLEE_INIT, CS_CALLEE_RINGING, destroy_line_cadet_channels(), Channel::env, CadetPhoneRingInfoPS::expiration_time, CadetPhoneRingMessage::expiration_time, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_ecdsa_verify(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), Channel::line, Line::line_port, CadetPhoneRingInfoPS::line_port, Line::mq, my_identity, GNUNET_CRYPTO_EccSignaturePurpose::purpose, CadetPhoneRingInfoPS::purpose, GNUNET_TIME_Relative::rel_value_us, CadetPhoneRingMessage::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, Channel::status, and CadetPhoneRingInfoPS::target_peer.

741 {
742  struct Channel *ch = cls;
743  struct Line *line = ch->line;
744  struct GNUNET_MQ_Envelope *env;
745  struct ClientPhoneRingMessage *cring;
746  struct CadetPhoneRingInfoPS rs;
747 
749  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
750  rs.line_port = line->line_port;
751  rs.target_peer = my_identity;
752  rs.expiration_time = msg->expiration_time;
753 
754  if (GNUNET_OK !=
756  &rs.purpose,
757  &msg->signature,
758  &msg->caller_id))
759  {
760  GNUNET_break_op (0);
762  return;
763  }
766  .rel_value_us)
767  {
768  /* ancient call, replay? */
769  GNUNET_break_op (0);
770  /* Note that our reliance on time here is awkward; better would be
771  to use a more complex challenge-response protocol against
772  replay attacks. Left for future work ;-). */
774  return;
775  }
776  if (CS_CALLEE_INIT != ch->status)
777  {
778  GNUNET_break_op (0);
780  return;
781  }
785  cring->cid = ch->cid;
786  cring->caller_id = msg->caller_id;
788  "Sending RING message to client. CID is %u\n",
789  (unsigned int) ch->cid);
790  GNUNET_MQ_send (line->mq, env);
791 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
uint64_t rel_value_us
The actual value.
int GNUNET_CRYPTO_ecdsa_verify(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition: crypto_ecc.c:1045
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Who is calling us?
Definition: conversation.h:108
#define GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING
Signature of a conversation ring.
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
Information signed in a struct CadetPhoneRingMessage whereby the caller self-identifies to the receiv...
Definition: conversation.h:260
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
struct GNUNET_CADET_Channel * channel
Handle for the channel.
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature over a struct CadetPhoneRingInfoPS
Definition: conversation.h:314
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING
Client <- Server message to indicate a ringing phone.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
A struct Line connects a local client with cadet channels.
uint32_t cid
CID, internal caller ID number used in the future to identify which active call we are talking about...
Definition: conversation.h:103
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose for the signature, must be GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING.
Definition: conversation.h:266
struct GNUNET_HashCode line_port
Port number we are listening on (to verify signatures).
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:954
Service -> Client message for phone is ringing.
Definition: conversation.h:92
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
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_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: conversation.h:309
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Who is calling us? (also who is signing).
Definition: conversation.h:304
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_cadet_hangup_message()

static void handle_cadet_hangup_message ( void *  cls,
const struct CadetPhoneHangupMessage message 
)
static

Function to handle a hangup message incoming over cadet.

Parameters
clsclosure, our struct Channel *
messagethe incoming message

Definition at line 801 of file gnunet-service-conversation.c.

References ch, Channel::channel, Channel::cid, ClientPhoneHangupMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, destroy_line_cadet_channels(), Channel::env, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, GNUNET_MQ_msg, GNUNET_MQ_send(), Channel::line, Line::mq, and Channel::status.

803 {
804  struct Channel *ch = cls;
805  struct Line *line = ch->line;
806  struct GNUNET_MQ_Envelope *env;
807  struct ClientPhoneHangupMessage *hup;
808  enum ChannelStatus status;
809  uint32_t cid;
810 
811  (void) message;
813  cid = ch->cid;
814  status = ch->status;
816  switch (status)
817  {
818  case CS_CALLEE_INIT:
819  GNUNET_break_op (0);
820  return;
821 
822  case CS_CALLEE_RINGING:
823  case CS_CALLEE_CONNECTED:
824  break;
825 
826  case CS_CALLEE_SHUTDOWN:
827  return;
828 
829  case CS_CALLER_CALLING:
830  case CS_CALLER_CONNECTED:
831  break;
832 
833  case CS_CALLER_SHUTDOWN:
834  return;
835  }
836  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG UP message to client\n");
838  hup->cid = cid;
839  GNUNET_MQ_send (line->mq, env);
840 }
ChannelStatus
The possible connection status.
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:181
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CADET_Channel * channel
Handle for the channel.
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:170
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We just got the connection, but no introduction yet.
uint16_t status
See PRISM_STATUS_*-constants.
Our phone is ringing, waiting for the client to pick up.
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:954
#define GNUNET_log(kind,...)
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
We&#39;re in shutdown, sending hangup messages before cleaning up.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
Client -> Server message to reject/hangup a call.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_cadet_pickup_message()

static void handle_cadet_pickup_message ( void *  cls,
const struct CadetPhonePickupMessage message 
)
static

Function to handle a pickup message incoming over cadet.

Parameters
clsclosure, our struct Channel *
messagethe incoming message

Definition at line 850 of file gnunet-service-conversation.c.

References ch, Channel::channel, Channel::cid, ClientPhonePickedupMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, destroy_line_cadet_channels(), Channel::env, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP, GNUNET_MQ_msg, GNUNET_MQ_send(), Channel::line, Line::mq, mq_done_finish_caller_shutdown(), and Channel::status.

852 {
853  struct Channel *ch = cls;
854  struct Line *line = ch->line;
855  struct GNUNET_MQ_Envelope *env;
856  struct ClientPhonePickedupMessage *pick;
857 
858  (void) message;
860  switch (ch->status)
861  {
862  case CS_CALLEE_INIT:
863  case CS_CALLEE_RINGING:
864  case CS_CALLEE_CONNECTED:
865  GNUNET_break_op (0);
867  return;
868 
869  case CS_CALLEE_SHUTDOWN:
870  GNUNET_break_op (0);
872  return;
873 
874  case CS_CALLER_CALLING:
876  break;
877 
878  case CS_CALLER_CONNECTED:
879  GNUNET_break_op (0);
880  return;
881 
882  case CS_CALLER_SHUTDOWN:
883  GNUNET_break_op (0);
885  return;
886  }
887  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICKED UP message to client\n");
888  env =
890  pick->cid = ch->cid;
891  GNUNET_MQ_send (line->mq, env);
892 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CADET_Channel * channel
Handle for the channel.
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint32_t cid
Call ID of the corresponding GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL.
Definition: conversation.h:252
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP
Service -> Client message to notify that phone was picked up.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
static void mq_done_finish_caller_shutdown(void *cls)
We are done signalling shutdown to the other peer.
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Service -> Client: other peer has picked up the phone, we are now talking.
Definition: conversation.h:241
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:954
#define GNUNET_log(kind,...)
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
We&#39;re in shutdown, sending hangup messages before cleaning up.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_cadet_suspend_message()

static void handle_cadet_suspend_message ( void *  cls,
const struct CadetPhoneSuspendMessage message 
)
static

Function to handle a suspend message incoming over cadet.

Parameters
clsclosure, our struct Channel *
messagethe incoming message

Definition at line 902 of file gnunet-service-conversation.c.

References ch, Channel::channel, ClientPhoneSuspendMessage::cid, Channel::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, Channel::env, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, Channel::line, Line::mq, Channel::status, and Channel::suspended_remote.

904 {
905  struct Channel *ch = cls;
906  struct Line *line = ch->line;
907  struct GNUNET_MQ_Envelope *env;
908  struct ClientPhoneSuspendMessage *suspend;
909 
910  (void) message;
912  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suspending channel CID: %u\n", ch->cid);
913  switch (ch->status)
914  {
915  case CS_CALLEE_INIT:
916  GNUNET_break_op (0);
917  break;
918 
919  case CS_CALLEE_RINGING:
920  GNUNET_break_op (0);
921  break;
922 
923  case CS_CALLEE_CONNECTED:
925  break;
926 
927  case CS_CALLEE_SHUTDOWN:
928  return;
929 
930  case CS_CALLER_CALLING:
931  GNUNET_break_op (0);
932  break;
933 
934  case CS_CALLER_CONNECTED:
936  break;
937 
938  case CS_CALLER_SHUTDOWN:
939  return;
940  }
941  env =
943  suspend->cid = ch->cid;
944  GNUNET_MQ_send (line->mq, env);
945 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_CADET_Channel * channel
Handle for the channel.
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:954
#define GNUNET_log(kind,...)
#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:353
We&#39;re in shutdown, sending hangup messages before cleaning up.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
Client <-> Server message to suspend connection.
Service <-> Client message for phone was suspended.
Definition: conversation.h:115
int8_t suspended_remote
GNUNET_YES if the channel was suspended by the other peer.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:126
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ handle_cadet_resume_message()

static void handle_cadet_resume_message ( void *  cls,
const struct CadetPhoneResumeMessage msg 
)
static

Function to handle a resume message incoming over cadet.

Parameters
clsclosure, our struct Channel *
msgthe incoming message

Definition at line 955 of file gnunet-service-conversation.c.

References ch, Channel::channel, Channel::cid, ClientPhoneResumeMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, destroy_line_cadet_channels(), Channel::env, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, Channel::line, Line::mq, Channel::status, and Channel::suspended_remote.

957 {
958  struct Channel *ch = cls;
959  struct Line *line;
960  struct GNUNET_MQ_Envelope *env;
961  struct ClientPhoneResumeMessage *resume;
962 
963  (void) msg;
964  line = ch->line;
966  if (GNUNET_YES != ch->suspended_remote)
967  {
968  GNUNET_log (
970  "RESUME message received for non-suspended channel, dropping channel.\n");
972  return;
973  }
974  switch (ch->status)
975  {
976  case CS_CALLEE_INIT:
977  GNUNET_break (0);
978  break;
979 
980  case CS_CALLEE_RINGING:
981  GNUNET_break (0);
982  break;
983 
984  case CS_CALLEE_CONNECTED:
986  break;
987 
988  case CS_CALLEE_SHUTDOWN:
989  return;
990 
991  case CS_CALLER_CALLING:
992  GNUNET_break (0);
993  break;
994 
995  case CS_CALLER_CONNECTED:
997  break;
998 
999  case CS_CALLER_SHUTDOWN:
1000  return;
1001  }
1002  env =
1004  resume->cid = ch->cid;
1005  GNUNET_MQ_send (line->mq, env);
1006 }
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:144
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_CADET_Channel * channel
Handle for the channel.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re in shutdown, sending hangup messages before cleaning up.
We are waiting for the phone to be picked up.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
We just got the connection, but no introduction yet.
Our phone is ringing, waiting for the client to pick up.
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
A struct Line connects a local client with cadet channels.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
Client <-> Server message to resume connection.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Service <-> Client message for phone was resumed.
Definition: conversation.h:133
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:954
#define GNUNET_log(kind,...)
#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:353
We&#39;re in shutdown, sending hangup messages before cleaning up.
int8_t suspended_remote
GNUNET_YES if the channel was suspended by the other peer.
uint32_t cid
Channel identifier we use for this call with the client.
Here is the call graph for this function:

◆ check_cadet_audio_message()

static int check_cadet_audio_message ( void *  cls,
const struct CadetAudioMessage msg 
)
static

Function to check an audio message incoming over cadet.

Parameters
clsclosure, our struct Channel *
msgthe incoming message
Returns
GNUNET_OK (always)

Definition at line 1017 of file gnunet-service-conversation.c.

References GNUNET_OK.

1018 {
1019  (void) cls;
1020  (void) msg;
1021  return GNUNET_OK; /* any payload is fine */
1022 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ handle_cadet_audio_message()

static void handle_cadet_audio_message ( void *  cls,
const struct CadetAudioMessage msg 
)
static

Function to handle an audio message incoming over cadet.

Parameters
clsclosure, our struct Channel *
msgthe incoming message

Definition at line 1032 of file gnunet-service-conversation.c.

References ch, Channel::channel, Channel::cid, ClientAudioMessage::cid, Channel::env, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, CadetAudioMessage::header, Channel::line, Line::mq, GNUNET_MessageHeader::size, Channel::suspended_local, and Channel::suspended_remote.

1033 {
1034  struct Channel *ch = cls;
1035  size_t msize = ntohs (msg->header.size) - sizeof(struct CadetAudioMessage);
1036  struct GNUNET_MQ_Envelope *env;
1037  struct ClientAudioMessage *cam;
1038 
1040  if ((GNUNET_YES == ch->suspended_local) ||
1041  (GNUNET_YES == ch->suspended_remote))
1042  {
1043  GNUNET_log (
1045  "Received %u bytes of AUDIO data on suspended channel CID %u; dropping\n",
1046  (unsigned int) msize,
1047  ch->cid);
1048  return;
1049  }
1051  "Forwarding %u bytes of AUDIO data to client CID %u\n",
1052  (unsigned int) msize,
1053  ch->cid);
1054  env =
1056  cam->cid = ch->cid;
1057  GNUNET_memcpy (&cam[1], &msg[1], msize);
1058  GNUNET_MQ_send (ch->line->mq, env);
1059 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO.
Definition: conversation.h:374
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_CADET_Channel * channel
Handle for the channel.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
int8_t suspended_local
GNUNET_YES if the channel was suspended by the local client.
#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 Line * line
Line associated with the channel.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:954
#define GNUNET_log(kind,...)
Message Client <-> Service to transmit the audio.
Definition: conversation.h:188
#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:353
int8_t suspended_remote
GNUNET_YES if the channel was suspended by the other peer.
Cadet message to transmit the audio.
Definition: conversation.h:369
uint32_t cid
Channel identifier we use for this call with the client.
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:199
Here is the call graph for this function:

◆ inbound_end()

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

Function called whenever an inbound channel is destroyed.

Should clean up any associated state.

Parameters
clsclosure (set from GNUNET_CADET_connect)
channelconnection to the other end (henceforth invalid)

Definition at line 1070 of file gnunet-service-conversation.c.

References ch, Channel::channel, clean_up_channel(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and Channel::status.

Referenced by handle_client_call_message(), and handle_client_register_message().

1071 {
1072  struct Channel *ch = cls;
1073 
1074  GNUNET_assert (channel == ch->channel);
1075  ch->channel = NULL;
1077  "Channel destroyed by CADET in state %d\n",
1078  ch->status);
1079  clean_up_channel (ch);
1080 }
enum ChannelStatus status
Current status of this line.
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.
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
struct GNUNET_CADET_Channel * channel
Handle for the channel.
static void clean_up_channel(struct Channel *ch)
Channel went down, notify client and free data structure.
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_client_call_message()

static void handle_client_call_message ( void *  cls,
const struct ClientCallMessage msg 
)
static

Function to handle call request from the client.

Parameters
clsthe struct Line the message is about
msgthe message from the client

Definition at line 1090 of file gnunet-service-conversation.c.

References ClientCallMessage::caller_id, CadetPhoneRingMessage::caller_id, ch, Channel::channel, Line::channel_head, Line::channel_tail, Line::client, CS_CALLER_CALLING, e, CadetPhoneRingInfoPS::expiration_time, CadetPhoneRingMessage::expiration_time, GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_ecdsa_sign(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), inbound_end(), Channel::line, Line::line_port, ClientCallMessage::line_port, CadetPhoneRingInfoPS::line_port, Channel::mq, GNUNET_CRYPTO_EccSignaturePurpose::purpose, CadetPhoneRingInfoPS::purpose, RING_TIMEOUT, CadetPhoneRingMessage::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, Channel::status, ClientCallMessage::target, and CadetPhoneRingInfoPS::target_peer.

1091 {
1092  struct Line *line = cls;
1093  struct Channel *ch = GNUNET_new (struct Channel);
1094  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
1095  { GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
1097  struct CadetPhoneHangupMessage,
1098  ch),
1099  GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
1101  struct CadetPhonePickupMessage,
1102  ch),
1103  GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
1105  struct CadetPhoneSuspendMessage,
1106  ch),
1107  GNUNET_MQ_hd_fixed_size (cadet_resume_message,
1109  struct CadetPhoneResumeMessage,
1110  ch),
1111  GNUNET_MQ_hd_var_size (cadet_audio_message,
1113  struct CadetAudioMessage,
1114  ch),
1115  GNUNET_MQ_handler_end () };
1116  struct GNUNET_MQ_Envelope *e;
1117  struct CadetPhoneRingMessage *ring;
1118  struct CadetPhoneRingInfoPS rs;
1119 
1120  line->line_port = msg->line_port;
1121  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
1122  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
1123  rs.line_port = line->line_port;
1124  rs.target_peer = msg->target;
1125  rs.expiration_time =
1127  ch->line = line;
1129  ch->status = CS_CALLER_CALLING;
1131  ch,
1132  &msg->target,
1133  &msg->line_port,
1134  NULL,
1135  &inbound_end,
1136  cadet_handlers);
1137  ch->mq = GNUNET_CADET_get_mq (ch->channel);
1140  ring->expiration_time = rs.expiration_time;
1142  &rs.purpose,
1143  &ring->signature));
1144  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n");
1145  GNUNET_MQ_send (ch->mq, e);
1147 }
static void inbound_end(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever an inbound channel is destroyed.
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
Cadet message to make a phone ring.
Definition: conversation.h:289
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define RING_TIMEOUT
How long is our signature on a call valid? Needs to be long enough for time zone differences and netw...
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING
Signature of a conversation ring.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
Information signed in a struct CadetPhoneRingMessage whereby the caller self-identifies to the receiv...
Definition: conversation.h:260
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO
Cadet: audio data.
struct GNUNET_PeerIdentity target
Which peer is hosting the line?
Definition: conversation.h:223
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND
Cadet: phone suspended.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_CADET_Channel * channel
Handle for the channel.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP
Cadet: hang up / refuse call.
struct Channel * channel_tail
This is a DLL.
struct GNUNET_CRYPTO_EcdsaPrivateKey caller_id
Identity of the caller.
Definition: conversation.h:233
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature over a struct CadetPhoneRingInfoPS
Definition: conversation.h:314
We are waiting for the phone to be picked up.
int GNUNET_CRYPTO_ecdsa_sign(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
ECDSA Sign a given block.
Definition: crypto_ecc.c:928
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP
Cadet: pick up phone (establish audio channel)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME
Cadet: phone resumed.
Message handler for a specific message type.
A struct Line connects a local client with cadet channels.
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:239
Cadet message for phone suspended.
Definition: conversation.h:345
struct GNUNET_HashCode line_port
Port number we are listening on (to verify signatures).
struct GNUNET_SERVICE_Client * client
Handle to the line client.
struct GNUNET_HashCode line_port
Which phone line to call at the peer?
Definition: conversation.h:228
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:1068
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING
Cadet: call initiation.
Cadet message for phone resumed.
Definition: conversation.h:357
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
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
Cadet message for hanging up.
Definition: conversation.h:321
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
Cadet message for picking up.
Definition: conversation.h:333
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: conversation.h:309
Cadet message to transmit the audio.
Definition: conversation.h:369
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Who is calling us? (also who is signing).
Definition: conversation.h:304
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:1119
Here is the call graph for this function:

◆ inbound_channel()

static void* inbound_channel ( 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.

Parameters
clsthe struct Line receiving a connection
channelnew handle to the channel
initiatorpeer that started the channel
Returns
initial channel context for the channel

Definition at line 1160 of file gnunet-service-conversation.c.

References ch, Channel::channel, Line::channel_head, Line::channel_tail, Channel::cid, Line::cid_gen, CS_CALLEE_INIT, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, Channel::line, Channel::mq, and Channel::status.

Referenced by handle_client_register_message().

1163 {
1164  struct Line *line = cls;
1165  struct Channel *ch;
1166 
1167  (void) initiator;
1169  "Received incoming cadet channel on line %p\n",
1170  line);
1171  ch = GNUNET_new (struct Channel);
1172  ch->status = CS_CALLEE_INIT;
1173  ch->line = line;
1174  ch->channel = channel;
1175  ch->mq = GNUNET_CADET_get_mq (ch->channel);
1176  ch->cid = line->cid_gen++;
1178  return ch;
1179 }
enum ChannelStatus status
Current status of this line.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_CADET_Channel * channel
Handle for the channel.
uint32_t cid_gen
Generator for channel IDs.
struct Channel * channel_tail
This is a DLL.
struct Line * line
Line associated with the channel.
static char * line
Desired phone line (string to be converted to a hash).
We just got the connection, but no introduction yet.
A struct Line connects a local client with cadet channels.
struct Channel * channel_head
This is a DLL.
#define GNUNET_log(kind,...)
struct GNUNET_MQ_Handle * mq
Message queue for control messages.
uint32_t cid
Channel identifier we use for this call with the client.
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:1119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void* client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

A client connected.

Initialize the struct Line data structure.

Parameters
clsclosure, NULL
clientidentification of the client
mqmessage queue for client
Returns
the struct Line for the client

Definition at line 1191 of file gnunet-service-conversation.c.

References Line::client, GNUNET_new, Channel::line, Channel::mq, and Line::mq.

Referenced by run().

1194 {
1195  struct Line *line;
1196 
1197  (void) cls;
1198  line = GNUNET_new (struct Line);
1199  line->client = client;
1200  line->mq = mq;
1201  return line;
1202 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static char * line
Desired phone line (string to be converted to a hash).
A struct Line connects a local client with cadet channels.
struct GNUNET_MQ_Handle * mq
Message queue for client.
struct GNUNET_SERVICE_Client * client
Handle to the line client.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Here is the caller graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_ctx 
)
static

A client disconnected.

Remove all of its data structure entries.

Parameters
clsclosure, NULL
clientidentification of the client
app_ctxour struct Line * for client

Definition at line 1213 of file gnunet-service-conversation.c.

References ch, Line::channel_head, destroy_line_cadet_channels(), GNUNET_CADET_close_port(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, Channel::line, and Line::port.

Referenced by run().

1216 {
1217  struct Line *line = app_ctx;
1218  struct Channel *chn;
1219 
1220  (void) cls;
1221  (void) client;
1222  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, closing line\n");
1223  if (NULL != line->port)
1224  {
1225  GNUNET_CADET_close_port (line->port);
1226  line->port = NULL;
1227  }
1228  for (struct Channel *ch = line->channel_head; NULL != ch; ch = chn)
1229  {
1230  chn = ch->next;
1231  ch->line = NULL;
1233  }
1234  GNUNET_free (line);
1235 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
A struct Channel represents a cadet channel, which is a P2P connection to another conversation servic...
struct GNUNET_CADET_Port * port
Our open port.
static char * line
Desired phone line (string to be converted to a hash).
static void destroy_line_cadet_channels(struct Channel *ch)
Destroy a channel.
A struct Line connects a local client with cadet channels.
struct Channel * channel_head
This is a DLL.
#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:874
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_client_register_message()

static void handle_client_register_message ( void *  cls,
const struct ClientPhoneRegisterMessage msg 
)
static

Function to register a phone.

Parameters
clsthe struct Line of the client from which the message is
msgthe message from the client

Definition at line 1245 of file gnunet-service-conversation.c.

References _, Line::client, GNUNET_CADET_open_port(), GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), inbound_channel(), inbound_end(), Channel::line, ClientPhoneRegisterMessage::line_port, Line::line_port, and Line::port.

1247 {
1248  struct Line *line = cls;
1249  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
1250  { GNUNET_MQ_hd_fixed_size (cadet_ring_message,
1252  struct CadetPhoneRingMessage,
1253  NULL),
1254  GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
1256  struct CadetPhoneHangupMessage,
1257  NULL),
1258  GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
1260  struct CadetPhonePickupMessage,
1261  NULL),
1262  GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
1264  struct CadetPhoneSuspendMessage,
1265  NULL),
1266  GNUNET_MQ_hd_fixed_size (cadet_resume_message,
1268  struct CadetPhoneResumeMessage,
1269  NULL),
1270  GNUNET_MQ_hd_var_size (cadet_audio_message,
1272  struct CadetAudioMessage,
1273  NULL),
1274  GNUNET_MQ_handler_end () };
1275 
1276  line->line_port = msg->line_port;
1278  &msg->line_port,
1279  &inbound_channel,
1280  line,
1281  NULL,
1282  &inbound_end,
1283  cadet_handlers);
1284  if (NULL == line->port)
1285  {
1287  _ ("Could not open line, port %s already in use!\n"),
1288  GNUNET_h2s (&msg->line_port));
1290  return;
1291  }
1293 }
static void inbound_end(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever an inbound channel is destroyed.
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
Cadet message to make a phone ring.
Definition: conversation.h:289
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO
Cadet: audio data.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND
Cadet: phone suspended.
struct GNUNET_CADET_Port * port
Our open port.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP
Cadet: hang up / refuse call.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:1010
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP
Cadet: pick up phone (establish audio channel)
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME
Cadet: phone resumed.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
Message handler for a specific message type.
A struct Line connects a local client with cadet channels.
Cadet message for phone suspended.
Definition: conversation.h:345
struct GNUNET_HashCode line_port
Phone line / CADET port to register.
Definition: conversation.h:85
struct GNUNET_HashCode line_port
Port number we are listening on (to verify signatures).
struct GNUNET_SERVICE_Client * client
Handle to the line client.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING
Cadet: call initiation.
Cadet message for phone resumed.
Definition: conversation.h:357
#define GNUNET_log(kind,...)
static void * inbound_channel(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.
Cadet message for hanging up.
Definition: conversation.h:321
Cadet message for picking up.
Definition: conversation.h:333
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Cadet message to transmit the audio.
Definition: conversation.h:369
Here is the call graph for this function:

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Shutdown nicely.

Parameters
clsclosure, NULL

Definition at line 1302 of file gnunet-service-conversation.c.

References GNUNET_CADET_disconnect().

Referenced by run().

1303 {
1304  (void) cls;
1305  if (NULL != cadet)
1306  {
1308  cadet = NULL;
1309  }
1310 }
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:841
void * cls
Closure for mv and cb.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Main function that will be run by the scheduler.

Parameters
clsclosure
cconfiguration
serviceservice handle

Definition at line 1321 of file gnunet-service-conversation.c.

References client_connect_cb(), client_disconnect_cb(), do_shutdown(), GNUNET_assert, GNUNET_break, GNUNET_CADET_connect(), GNUNET_CRYPTO_get_peer_identity(), GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, and my_identity.

1324 {
1325  (void) cls;
1326  (void) service;
1327  cfg = c;
1331  if (NULL == cadet)
1332  {
1333  GNUNET_break (0);
1335  return;
1336  }
1338 }
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
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:1300
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:976
void * cls
Closure for mv and cb.
static void do_shutdown(void *cls)
Shutdown nicely.
int GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host&#39;s peer.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

Define "main" method using service macro.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

Definition at line 200 of file gnunet-service-conversation.c.

◆ cadet

struct GNUNET_CADET_Handle* cadet
static

Handle for cadet.

Definition at line 205 of file gnunet-service-conversation.c.

Referenced by cadet_disconnect_adapter(), start_test(), and warmup().

◆ my_identity

struct GNUNET_PeerIdentity my_identity
static

Identity of this peer.

Definition at line 210 of file gnunet-service-conversation.c.

Referenced by core_init(), core_startup_cb(), handle_cadet_ring_message(), occ_cache_get_handle_core_cb(), and run().