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:

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 Channel *	find_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 enum GNUNET_GenericReturnValue	check_cadet_ring_message (void cls, const struct CadetPhoneRingMessage msg)
	Function to handle a ring message incoming over cadet. 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 enum GNUNET_GenericReturnValue	check_client_call_message (void cls, const struct ClientCallMessage msg)
	Function to handle call request from the client. 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_var_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_Handle *	cfg
	Our configuration. More...

static struct GNUNET_CADET_Handle *	cadet
	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.

Enumeration Type Documentation

◆ ChannelStatus

enum 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.

{
  CS_CALLEE_INIT,
 
  CS_CALLEE_RINGING,
 
  CS_CALLEE_CONNECTED,
 
  CS_CALLEE_SHUTDOWN,
 
  CS_CALLER_CALLING,
 
  CS_CALLER_CONNECTED,
 
  CS_CALLER_SHUTDOWN
};

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

line	a line to search
cid	what to search for

Returns: NULL for not found

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

{
  for (struct Channel *ch = line->channel_head; NULL != ch; ch = ch->next)
    if (cid == ch->cid)
      return ch;
  return NULL;
}

References ch, Channel::cid, and line.

Referenced by handle_client_audio_message().

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

cls	the `struct Line` of the client from which the message is
msg	the message from the client

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

{
  struct Line *line = cls;
  struct CadetPhonePickupMessage *mppm;
  struct GNUNET_MQ_Envelope *env;
  struct Channel *ch;
 
  if (NULL == line->port)
  {
    /* we never opened the port, bad client! */
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  for (ch = line->channel_head; NULL != ch; ch = ch->next)
    if (msg->cid == ch->cid)
      break;
  if (NULL == ch)
  {
    /* could have been destroyed asynchronously, ignore message */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_RINGING:
    ch->status = CS_CALLEE_CONNECTED;
    break;
 
  case CS_CALLEE_CONNECTED:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_SHUTDOWN:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Ignoring client's PICKUP message, line is in SHUTDOWN\n");
    break;
 
  case CS_CALLER_CALLING:
  case CS_CALLER_CONNECTED:
  case CS_CALLER_SHUTDOWN:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  GNUNET_break (CS_CALLEE_CONNECTED == ch->status);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICK_UP message to cadet\n");
  env =
    GNUNET_MQ_msg (mppm, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP);
  GNUNET_MQ_send (ch->mq, env);
  GNUNET_SERVICE_client_continue (line->client);
}

References ch, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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(), line, GNUNET_CADET_Channel::mq, and msg.

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

ch	channel that went down

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

{
  struct Line *line = ch->line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhoneHangupMessage *hup;
 
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
  case CS_CALLEE_SHUTDOWN:
  case CS_CALLER_SHUTDOWN:
    break;
 
  case CS_CALLEE_RINGING:
  case CS_CALLEE_CONNECTED:
  case CS_CALLER_CALLING:
  case CS_CALLER_CONNECTED:
    if (NULL != line)
    {
      env =
        GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
      hup->cid = ch->cid;
      GNUNET_MQ_send (line->mq, env);
    }
    break;
  }
  if (NULL != line)
    GNUNET_CONTAINER_DLL_remove (line->channel_head, line->channel_tail, ch);
  GNUNET_free (ch);
}

References ch, ClientPhoneHangupMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, GNUNET_MQ_msg, GNUNET_MQ_send(), and line.

Referenced by destroy_line_cadet_channels(), and inbound_end().

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

ch	channel to destroy.

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying cadet channels\n");
  if (NULL != ch->channel)
  {
    GNUNET_CADET_channel_destroy (ch->channel);
    ch->channel = NULL;
  }
  clean_up_channel (ch);
}

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

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

cls	the `struct Channel` to reset/terminate

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

{
  struct Channel *ch = cls;
 
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    break;
 
  case CS_CALLEE_RINGING:
    GNUNET_break (0);
    break;
 
  case CS_CALLEE_CONNECTED:
    GNUNET_break (0);
    break;
 
  case CS_CALLEE_SHUTDOWN:
    destroy_line_cadet_channels (ch);
    break;
 
  case CS_CALLER_CALLING:
    GNUNET_break (0);
    break;
 
  case CS_CALLER_CONNECTED:
    GNUNET_break (0);
    break;
 
  case CS_CALLER_SHUTDOWN:
    destroy_line_cadet_channels (ch);
    break;
  }
}

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

Referenced by handle_cadet_pickup_message(), and handle_client_hangup_message().

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

cls	the `struct Line` the hangup is for
msg	the message from the client

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

{
  struct Line *line = cls;
  struct GNUNET_MQ_Envelope *e;
  struct CadetPhoneHangupMessage *mhum;
  struct Channel *ch;
 
  for (ch = line->channel_head; NULL != ch; ch = ch->next)
    if (msg->cid == ch->cid)
      break;
  if (NULL == ch)
  {
    /* could have been destroyed asynchronously, ignore message */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received HANGUP for channel %u which is in state %d\n",
              msg->cid,
              ch->status);
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_RINGING:
    ch->status = CS_CALLEE_SHUTDOWN;
    break;
 
  case CS_CALLEE_CONNECTED:
    ch->status = CS_CALLEE_SHUTDOWN;
    break;
 
  case CS_CALLEE_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_continue (line->client);
    return;
 
  case CS_CALLER_CALLING:
    ch->status = CS_CALLER_SHUTDOWN;
    break;
 
  case CS_CALLER_CONNECTED:
    ch->status = CS_CALLER_SHUTDOWN;
    break;
 
  case CS_CALLER_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG_UP message via cadet\n");
  e =
    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP);
  GNUNET_MQ_notify_sent (e, &mq_done_finish_caller_shutdown, ch);
  GNUNET_MQ_send (ch->mq, e);
  GNUNET_SERVICE_client_continue (line->client);
}

References ch, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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(), line, GNUNET_CADET_Channel::mq, mq_done_finish_caller_shutdown(), and msg.

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

cls	the `struct Line` the message is about
msg	the message from the client

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

{
  struct Line *line = cls;
  struct GNUNET_MQ_Envelope *e;
  struct CadetPhoneSuspendMessage *mhum;
  struct Channel *ch;
 
  for (ch = line->channel_head; NULL != ch; ch = ch->next)
    if (msg->cid == ch->cid)
      break;
  if (NULL == ch)
  {
    /* could have been destroyed asynchronously, ignore message */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  if (GNUNET_YES == ch->suspended_local)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received SUSPEND for channel %u which is in state %d\n",
              msg->cid,
              ch->status);
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_RINGING:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_CONNECTED:
    ch->suspended_local = GNUNET_YES;
    break;
 
  case CS_CALLEE_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_continue (line->client);
    return;
 
  case CS_CALLER_CALLING:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLER_CONNECTED:
    ch->suspended_local = GNUNET_YES;
    break;
 
  case CS_CALLER_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUSPEND message via cadet\n");
  e =
    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND);
  GNUNET_MQ_send (ch->mq, e);
  GNUNET_SERVICE_client_continue (line->client);
}

References ch, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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, line, GNUNET_CADET_Channel::mq, and msg.

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

cls	the `struct Line` the message is about
msg	the message from the client

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

{
  struct Line *line = cls;
  struct GNUNET_MQ_Envelope *e;
  struct CadetPhoneResumeMessage *mhum;
  struct Channel *ch;
 
  for (ch = line->channel_head; NULL != ch; ch = ch->next)
    if (msg->cid == ch->cid)
      break;
  if (NULL == ch)
  {
    /* could have been destroyed asynchronously, ignore message */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  if (GNUNET_YES != ch->suspended_local)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received RESUME for channel %u which is in state %d\n",
              msg->cid,
              ch->status);
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_RINGING:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_CONNECTED:
    ch->suspended_local = GNUNET_NO;
    break;
 
  case CS_CALLEE_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_continue (line->client);
    return;
 
  case CS_CALLER_CALLING:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLER_CONNECTED:
    ch->suspended_local = GNUNET_NO;
    break;
 
  case CS_CALLER_SHUTDOWN:
    /* maybe the other peer closed asynchronously... */
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RESUME message via cadet\n");
  e = GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME);
  GNUNET_MQ_send (ch->mq, e);
  GNUNET_SERVICE_client_continue (line->client);
}

References ch, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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, line, GNUNET_CADET_Channel::mq, and msg.

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

cls	the `struct Channel` we are transmitting for

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

{
  struct Channel *ch = cls;
 
  ch->env = NULL;
}

References ch.

Referenced by handle_client_audio_message().

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

cls	the `struct Line` the message is about
msg	the message from the client

Returns: GNUNET_OK (any data is ok)

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

{
  (void) cls;
  (void) msg;
  return GNUNET_OK;
}

References GNUNET_OK, and msg.

◆ 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

cls	the `struct Line` the message is about
msg	the message from the client

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

{
  struct Line *line = cls;
  struct CadetAudioMessage *mam;
  struct Channel *ch;
  size_t size;
 
  size = ntohs (msg->header.size) - sizeof(struct ClientAudioMessage);
  ch = find_channel_by_line (line, msg->cid);
  if (NULL == ch)
  {
    /* could have been destroyed asynchronously, ignore message */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
 
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
  case CS_CALLEE_RINGING:
  case CS_CALLER_CALLING:
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (line->client);
    return;
 
  case CS_CALLEE_CONNECTED:
  case CS_CALLER_CONNECTED:
    /* common case, handled below */
    break;
 
  case CS_CALLEE_SHUTDOWN:
  case CS_CALLER_SHUTDOWN:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                "Cadet audio channel in shutdown; audio data dropped\n");
    GNUNET_SERVICE_client_continue (line->client);
    return;
  }
  if (GNUNET_YES == ch->suspended_local)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "This channel is suspended locally\n");
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  if (NULL != ch->env)
  {
    /* NOTE: we may want to not do this and instead combine the data */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Bandwidth insufficient; dropping previous audio data segment\n");
    GNUNET_MQ_send_cancel (ch->env);
    ch->env = NULL;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u bytes of AUDIO data from client CID %u\n",
              (unsigned int) size,
              msg->cid);
  ch->env = GNUNET_MQ_msg_extra (mam,
                                 size,
                                 GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO);
  GNUNET_memcpy (&mam[1], &msg[1], size);
  /* FIXME: set options for unreliable transmission */
  GNUNET_MQ_notify_sent (ch->env, &channel_audio_sent_notify, ch);
  GNUNET_MQ_send (ch->mq, ch->env);
  GNUNET_SERVICE_client_continue (line->client);
}

References ch, channel_audio_sent_notify(), CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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, line, GNUNET_CADET_Channel::mq, msg, GNUNET_MessageHeader::size, and size.

Here is the call graph for this function:

◆ check_cadet_ring_message()

static enum GNUNET_GenericReturnValue check_cadet_ring_message	(	void *	cls,
		const struct CadetPhoneRingMessage *	msg
	)

static

Function to handle a ring message incoming over cadet.

Parameters

cls	closure, NULL
msg	the incoming message

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

{
  // FIXME
  return GNUNET_OK;
}

References GNUNET_OK.

◆ 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

cls	closure, NULL
msg	the incoming message

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

{
  struct Channel *ch = cls;
  struct Line *line = ch->line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhoneRingMessage *cring;
  struct CadetPhoneRingInfoPS rs;
  struct GNUNET_CRYPTO_PublicKey identity;
  struct GNUNET_CRYPTO_Signature sig;
  size_t key_len;
  size_t sig_len;
  size_t read;
 
  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
  rs.line_port = line->line_port;
  rs.target_peer = my_identity;
  rs.expiration_time = msg->expiration_time;
  key_len = ntohl (msg->key_len);
  sig_len = ntohl (msg->sig_len);
 
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_public_key_from_buffer (&msg[1],
                                                    key_len,
                                                    &identity,
                                                    &read)) ||
      (read != key_len))
  {
    GNUNET_break_op (0);
    destroy_line_cadet_channels (ch);
    return;
  }
  GNUNET_CRYPTO_read_signature_from_buffer (&sig,
                                              (char*) &msg[1] + read,
                                              sig_len);
  if (GNUNET_OK !=
      GNUNET_CRYPTO_signature_verify (
        GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING,
        &rs,
        &sig,
        &identity))
  {
    GNUNET_break_op (0);
    destroy_line_cadet_channels (ch);
    return;
  }
  if (0 == GNUNET_TIME_absolute_get_remaining (
        GNUNET_TIME_absolute_ntoh (msg->expiration_time))
      .rel_value_us)
  {
    /* ancient call, replay? */
    GNUNET_break_op (0);
    /* Note that our reliance on time here is awkward; better would be
       to use a more complex challenge-response protocol against
       replay attacks.  Left for future work ;-). */
    destroy_line_cadet_channels (ch);
    return;
  }
  if (CS_CALLEE_INIT != ch->status)
  {
    GNUNET_break_op (0);
    destroy_line_cadet_channels (ch);
    return;
  }
  GNUNET_CADET_receive_done (ch->channel);
  ch->status = CS_CALLEE_RINGING;
  env = GNUNET_MQ_msg_extra (cring,
                             key_len,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING);
  cring->cid = ch->cid;
  memcpy (&cring[1], &msg[1], key_len);
  cring->key_len = msg->key_len;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending RING message to client. CID is %u\n",
              (unsigned int) ch->cid);
  GNUNET_MQ_send (line->mq, env);
}

References ch, ClientPhoneRingMessage::cid, CS_CALLEE_INIT, CS_CALLEE_RINGING, destroy_line_cadet_channels(), env, CadetPhoneRingInfoPS::expiration_time, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_CRYPTO_read_signature_from_buffer(), GNUNET_CRYPTO_signature_verify, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), identity, ClientPhoneRingMessage::key_len, line, CadetPhoneRingInfoPS::line_port, msg, my_identity, CadetPhoneRingInfoPS::purpose, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_TIME_Relative::rel_value_us, GNUNET_CRYPTO_EccSignaturePurpose::size, and CadetPhoneRingInfoPS::target_peer.

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

cls	closure, our `struct Channel *`
message	the incoming message

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

{
  struct Channel *ch = cls;
  struct Line *line = ch->line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhoneHangupMessage *hup;
  enum ChannelStatus status;
  uint32_t cid;
 
  (void) message;
  GNUNET_CADET_receive_done (ch->channel);
  cid = ch->cid;
  status = ch->status;
  destroy_line_cadet_channels (ch);
  switch (status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break_op (0);
    return;
 
  case CS_CALLEE_RINGING:
  case CS_CALLEE_CONNECTED:
    break;
 
  case CS_CALLEE_SHUTDOWN:
    return;
 
  case CS_CALLER_CALLING:
  case CS_CALLER_CONNECTED:
    break;
 
  case CS_CALLER_SHUTDOWN:
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG UP message to client\n");
  env = GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
  hup->cid = cid;
  GNUNET_MQ_send (line->mq, env);
}

References ch, 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(), 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(), line, and status.

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

cls	closure, our `struct Channel *`
message	the incoming message

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

{
  struct Channel *ch = cls;
  struct Line *line = ch->line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhonePickedupMessage *pick;
 
  (void) message;
  GNUNET_CADET_receive_done (ch->channel);
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
  case CS_CALLEE_RINGING:
  case CS_CALLEE_CONNECTED:
    GNUNET_break_op (0);
    destroy_line_cadet_channels (ch);
    return;
 
  case CS_CALLEE_SHUTDOWN:
    GNUNET_break_op (0);
    destroy_line_cadet_channels (ch);
    return;
 
  case CS_CALLER_CALLING:
    ch->status = CS_CALLER_CONNECTED;
    break;
 
  case CS_CALLER_CONNECTED:
    GNUNET_break_op (0);
    return;
 
  case CS_CALLER_SHUTDOWN:
    GNUNET_break_op (0);
    mq_done_finish_caller_shutdown (ch);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICKED UP message to client\n");
  env =
    GNUNET_MQ_msg (pick, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP);
  pick->cid = ch->cid;
  GNUNET_MQ_send (line->mq, env);
}

References ch, 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(), 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(), line, and mq_done_finish_caller_shutdown().

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

cls	closure, our `struct Channel *`
message	the incoming message

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

{
  struct Channel *ch = cls;
  struct Line *line = ch->line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhoneSuspendMessage *suspend;
 
  (void) message;
  GNUNET_CADET_receive_done (ch->channel);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suspending channel CID: %u\n", ch->cid);
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break_op (0);
    break;
 
  case CS_CALLEE_RINGING:
    GNUNET_break_op (0);
    break;
 
  case CS_CALLEE_CONNECTED:
    ch->suspended_remote = GNUNET_YES;
    break;
 
  case CS_CALLEE_SHUTDOWN:
    return;
 
  case CS_CALLER_CALLING:
    GNUNET_break_op (0);
    break;
 
  case CS_CALLER_CONNECTED:
    ch->suspended_remote = GNUNET_YES;
    break;
 
  case CS_CALLER_SHUTDOWN:
    return;
  }
  env =
    GNUNET_MQ_msg (suspend, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
  suspend->cid = ch->cid;
  GNUNET_MQ_send (line->mq, env);
}

References ch, ClientPhoneSuspendMessage::cid, CS_CALLEE_CONNECTED, CS_CALLEE_INIT, CS_CALLEE_RINGING, CS_CALLEE_SHUTDOWN, CS_CALLER_CALLING, CS_CALLER_CONNECTED, CS_CALLER_SHUTDOWN, 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, and line.

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

cls	closure, our `struct Channel *`
msg	the incoming message

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

{
  struct Channel *ch = cls;
  struct Line *line;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPhoneResumeMessage *resume;
 
  (void) msg;
  line = ch->line;
  GNUNET_CADET_receive_done (ch->channel);
  if (GNUNET_YES != ch->suspended_remote)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "RESUME message received for non-suspended channel, dropping channel.\n");
    destroy_line_cadet_channels (ch);
    return;
  }
  switch (ch->status)
  {
  case CS_CALLEE_INIT:
    GNUNET_break (0);
    break;
 
  case CS_CALLEE_RINGING:
    GNUNET_break (0);
    break;
 
  case CS_CALLEE_CONNECTED:
    ch->suspended_remote = GNUNET_NO;
    break;
 
  case CS_CALLEE_SHUTDOWN:
    return;
 
  case CS_CALLER_CALLING:
    GNUNET_break (0);
    break;
 
  case CS_CALLER_CONNECTED:
    ch->suspended_remote = GNUNET_NO;
    break;
 
  case CS_CALLER_SHUTDOWN:
    return;
  }
  env =
    GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
  resume->cid = ch->cid;
  GNUNET_MQ_send (line->mq, env);
}

References ch, 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(), 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, line, and msg.

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

cls	closure, our `struct Channel *`
msg	the incoming message

Returns: GNUNET_OK (always)

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

{
  (void) cls;
  (void) msg;
  return GNUNET_OK; /* any payload is fine */
}

References GNUNET_OK, and msg.

◆ 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

cls	closure, our `struct Channel *`
msg	the incoming message

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

{
  struct Channel *ch = cls;
  size_t msize = ntohs (msg->header.size) - sizeof(struct CadetAudioMessage);
  struct GNUNET_MQ_Envelope *env;
  struct ClientAudioMessage *cam;
 
  GNUNET_CADET_receive_done (ch->channel);
  if ((GNUNET_YES == ch->suspended_local) ||
      (GNUNET_YES == ch->suspended_remote))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received %u bytes of AUDIO data on suspended channel CID %u; dropping\n",
      (unsigned int) msize,
      ch->cid);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding %u bytes of AUDIO data to client CID %u\n",
              (unsigned int) msize,
              ch->cid);
  env =
    GNUNET_MQ_msg_extra (cam, msize, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
  cam->cid = ch->cid;
  GNUNET_memcpy (&cam[1], &msg[1], msize);
  GNUNET_MQ_send (ch->line->mq, env);
}

References ch, ClientAudioMessage::cid, 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, GNUNET_CADET_Channel::mq, msg, and GNUNET_MessageHeader::size.

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

cls	closure (set from GNUNET_CADET_connect)
channel	connection to the other end (henceforth invalid)

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

{
  struct Channel *ch = cls;
 
  GNUNET_assert (channel == ch->channel);
  ch->channel = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Channel destroyed by CADET in state %d\n",
              ch->status);
  clean_up_channel (ch);
}

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

Referenced by handle_client_call_message(), and handle_client_register_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_client_call_message()

static enum GNUNET_GenericReturnValue check_client_call_message	(	void *	cls,
		const struct ClientCallMessage *	msg
	)

static

Function to handle call request from the client.

Parameters

cls	the `struct Line` the message is about
msg	the message from the client

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

{
  // FIXME
  return GNUNET_OK;
}

References GNUNET_OK.

◆ 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

cls	the `struct Line` the message is about
msg	the message from the client

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

{
  struct Line *line = cls;
  struct Channel *ch = GNUNET_new (struct Channel);
  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
  { GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
                             struct CadetPhoneHangupMessage,
                             ch),
    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
                             struct CadetPhonePickupMessage,
                             ch),
    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
                             struct CadetPhoneSuspendMessage,
                             ch),
    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
                             struct CadetPhoneResumeMessage,
                             ch),
    GNUNET_MQ_hd_var_size (cadet_audio_message,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
                           struct CadetAudioMessage,
                           ch),
    GNUNET_MQ_handler_end () };
  struct GNUNET_MQ_Envelope *e;
  struct CadetPhoneRingMessage *ring;
  struct CadetPhoneRingInfoPS rs;
  struct GNUNET_CRYPTO_PrivateKey caller_id;
  struct GNUNET_CRYPTO_PublicKey caller_id_pub;
  struct GNUNET_CRYPTO_Signature sig;
  ssize_t written;
  size_t key_len;
  size_t pkey_len;
  size_t sig_len;
  size_t read;
 
  line->line_port = msg->line_port;
  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
  rs.line_port = line->line_port;
  rs.target_peer = msg->target;
  rs.expiration_time =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (RING_TIMEOUT));
  key_len = ntohl (msg->key_len);
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
                                                    key_len,
                                                    &caller_id,
                                                    &read))
  {
    GNUNET_break_op (0);
    GNUNET_free (ch);
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  ch->line = line;
  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
  ch->status = CS_CALLER_CALLING;
  ch->channel = GNUNET_CADET_channel_create (cadet,
                                             ch,
                                             &msg->target,
                                             &msg->line_port,
                                             NULL,
                                             &inbound_end,
                                             cadet_handlers);
  ch->mq = GNUNET_CADET_get_mq (ch->channel);
  GNUNET_assert (read == key_len);
  GNUNET_CRYPTO_sign (&caller_id, &rs, &sig);
  sig_len = GNUNET_CRYPTO_signature_get_length (&sig);
  GNUNET_CRYPTO_key_get_public (&caller_id, &caller_id_pub);
  pkey_len = GNUNET_CRYPTO_public_key_get_length (&caller_id_pub);
  e = GNUNET_MQ_msg_extra (ring, pkey_len + sig_len,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING);
  written = GNUNET_CRYPTO_write_public_key_to_buffer (&caller_id_pub,
                                                        &ring[1],
                                                        pkey_len);
  ring->expiration_time = rs.expiration_time;
  ring->key_len = htonl (pkey_len);
  ring->sig_len = htonl (sig_len);
  GNUNET_CRYPTO_write_signature_to_buffer (&sig,
                                             (char *) &ring[1] + written,
                                             sig_len);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n");
  GNUNET_MQ_send (ch->mq, e);
  GNUNET_SERVICE_client_continue (line->client);
}

References cadet, ch, CS_CALLER_CALLING, CadetPhoneRingInfoPS::expiration_time, CadetPhoneRingMessage::expiration_time, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_channel_create(), GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_key_get_public(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_CRYPTO_sign, GNUNET_CRYPTO_signature_get_length(), GNUNET_CRYPTO_write_public_key_to_buffer(), GNUNET_CRYPTO_write_signature_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, 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_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, GNUNET_SYSERR, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), inbound_end(), CadetPhoneRingMessage::key_len, line, CadetPhoneRingInfoPS::line_port, GNUNET_CADET_Channel::mq, msg, CadetPhoneRingInfoPS::purpose, GNUNET_CRYPTO_EccSignaturePurpose::purpose, RING_TIMEOUT, CadetPhoneRingMessage::sig_len, GNUNET_CRYPTO_EccSignaturePurpose::size, and CadetPhoneRingInfoPS::target_peer.

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

cls	the `struct Line` receiving a connection
channel	new handle to the channel
initiator	peer that started the channel

Returns: initial channel context for the channel

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

{
  struct Line *line = cls;
  struct Channel *ch;
 
  (void) initiator;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received incoming cadet channel on line %p\n",
              line);
  ch = GNUNET_new (struct Channel);
  ch->status = CS_CALLEE_INIT;
  ch->line = line;
  ch->channel = channel;
  ch->mq = GNUNET_CADET_get_mq (ch->channel);
  ch->cid = line->cid_gen++;
  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
  return ch;
}

References ch, Channel::channel, CS_CALLEE_INIT, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, line, and GNUNET_CADET_Channel::mq.

Referenced by handle_client_register_message().

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

cls	closure, NULL
client	identification of the client
mq	message queue for client

Returns: the struct Line for the client

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

{
  struct Line *line;
 
  (void) cls;
  line = GNUNET_new (struct Line);
  line->client = client;
  line->mq = mq;
  return line;
}

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

◆ 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

cls	closure, NULL
client	identification of the client
app_ctx	our `struct Line ` for client*

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

{
  struct Line *line = app_ctx;
  struct Channel *chn;
 
  (void) cls;
  (void) client;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, closing line\n");
  if (NULL != line->port)
  {
    GNUNET_CADET_close_port (line->port);
    line->port = NULL;
  }
  for (struct Channel *ch = line->channel_head; NULL != ch; ch = chn)
  {
    chn = ch->next;
    ch->line = NULL;
    destroy_line_cadet_channels (ch);
  }
  GNUNET_free (line);
}

References ch, destroy_line_cadet_channels(), GNUNET_CADET_close_port(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and line.

Here is the call 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

cls	the `struct Line` of the client from which the message is
msg	the message from the client

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

{
  struct Line *line = cls;
  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
  { GNUNET_MQ_hd_var_size (cadet_ring_message,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING,
                           struct CadetPhoneRingMessage,
                           NULL),
    GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
                             struct CadetPhoneHangupMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
                             struct CadetPhonePickupMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
                             struct CadetPhoneSuspendMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
                             struct CadetPhoneResumeMessage,
                             NULL),
    GNUNET_MQ_hd_var_size (cadet_audio_message,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
                           struct CadetAudioMessage,
                           NULL),
    GNUNET_MQ_handler_end () };
 
  line->line_port = msg->line_port;
  line->port = GNUNET_CADET_open_port (cadet,
                                       &msg->line_port,
                                       &inbound_channel,
                                       line,
                                       NULL,
                                       &inbound_end,
                                       cadet_handlers);
  if (NULL == line->port)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Could not open line, port %s already in use!\n"),
                GNUNET_h2s (&msg->line_port));
    GNUNET_SERVICE_client_drop (line->client);
    return;
  }
  GNUNET_SERVICE_client_continue (line->client);
}

References _, cadet, 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(), line, and msg.

Here is the call graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Shutdown nicely.

Parameters

cls	closure, NULL

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

{
  (void) cls;
  if (NULL != cadet)
  {
    GNUNET_CADET_disconnect (cadet);
    cadet = NULL;
  }
}

References cadet, GNUNET_MQ_MessageHandler::cls, and GNUNET_CADET_disconnect().

Referenced by run().

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

cls	closure
c	configuration
service	service handle

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

{
  (void) cls;
  (void) service;
  cfg = c;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_get_peer_identity (cfg, &my_identity));
  cadet = GNUNET_CADET_connect (cfg);
  if (NULL == cadet)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
}

References cadet, cfg, GNUNET_MQ_MessageHandler::cls, do_shutdown(), GNUNET_assert, GNUNET_break, GNUNET_CADET_connect(), GNUNET_CRYPTO_get_peer_identity(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), my_identity, and service.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

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_var_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.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

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

Referenced by run().

◆ cadet

struct GNUNET_CADET_Handle* cadet

static

Handle for cadet.

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

Referenced by connect_tunnel(), do_shutdown(), handle_client_call_message(), handle_client_register_message(), open_srv_room(), and run().

◆ my_identity

struct GNUNET_PeerIdentity my_identity

static

Identity of this peer.

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

Referenced by handle_cadet_ring_message(), and run().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ RING_TIMEOUT

Enumeration Type Documentation

◆ ChannelStatus

Function Documentation

◆ find_channel_by_line()

◆ handle_client_pickup_message()

◆ clean_up_channel()

◆ destroy_line_cadet_channels()

◆ mq_done_finish_caller_shutdown()

◆ handle_client_hangup_message()

◆ handle_client_suspend_message()

◆ handle_client_resume_message()

◆ channel_audio_sent_notify()

◆ check_client_audio_message()

◆ handle_client_audio_message()

◆ check_cadet_ring_message()

◆ handle_cadet_ring_message()

◆ handle_cadet_hangup_message()

◆ handle_cadet_pickup_message()

◆ handle_cadet_suspend_message()

◆ handle_cadet_resume_message()

◆ check_cadet_audio_message()

◆ handle_cadet_audio_message()

◆ inbound_end()

◆ check_client_call_message()

◆ handle_client_call_message()

◆ inbound_channel()

◆ client_connect_cb()

◆ client_disconnect_cb()

◆ handle_client_register_message()

◆ do_shutdown()

◆ run()

◆ GNUNET_SERVICE_MAIN()

Variable Documentation

◆ cfg

◆ cadet

◆ my_identity