conversation_api_call.c File Reference

call API to the conversation service More...

#include "platform.h"
#include "gnunet_conversation_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_gns_service.h"
#include "conversation.h"

Include dependency graph for conversation_api_call.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_CONVERSATION_Call
	Handle for an outgoing call. More...

Enumerations
enum	CallState {   CS_LOOKUP = 0 , CS_RINGING , CS_ACTIVE , CS_SHUTDOWN ,   CS_SUSPENDED_CALLER , CS_SUSPENDED_CALLEE , CS_SUSPENDED_BOTH , CS_RESOLVING ,   CS_RINGING , CS_CONNECTED , CS_SUSPENDED }
	Possible states of the phone. More...

Functions
static void	fail_call (struct GNUNET_CONVERSATION_Call *call)
	The call got disconnected, reconnect to the service. More...
static void	transmit_call_audio (void *cls, size_t data_size, const void *data)
	Process recorded audio data. More...
static void	handle_call_suspend (void *cls, const struct ClientPhoneSuspendMessage *msg)
	We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND. More...
static void	handle_call_resume (void *cls, const struct ClientPhoneResumeMessage *msg)
	We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME. More...
static void	handle_call_picked_up (void *cls, const struct ClientPhonePickedupMessage *msg)
	We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP. More...
static void	handle_call_hangup (void *cls, const struct ClientPhoneHangupMessage *msg)
	We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP. More...
static int	check_call_audio (void *cls, const struct ClientAudioMessage *am)
	We received a struct ClientAudioMessage, check it is well-formed. More...
static void	handle_call_audio (void *cls, const struct ClientAudioMessage *am)
	We received a struct ClientAudioMessage More...
static void	handle_gns_response (void *cls, int was_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Iterator called on obtained result for a GNS lookup. More...
static void	call_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We encountered an error talking with the conversation service. More...
struct GNUNET_CONVERSATION_Call *	GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_IDENTITY_Ego *caller_id, const char *callee, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic, GNUNET_CONVERSATION_CallEventHandler event_handler, void *event_handler_cls)
	Call the phone of another user. More...
void	GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)
	Terminate a call. More...
void	GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)
	Pause a call. More...
void	GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
	Resumes a call after GNUNET_CONVERSATION_call_suspend. More...

Detailed Description

call API to the conversation service

Author

Simon Dieterle

Andreas Fuchs

Christian Grothoff

Definition in file conversation_api_call.c.

Enumeration Type Documentation

CallState

enum CallState

Possible states of the phone.

Enumerator
CS_LOOKUP	We still need to lookup the callee.
CS_RINGING	The call is ringing.
CS_ACTIVE	The call is in an active conversation.
CS_SHUTDOWN	The call is in termination.
CS_SUSPENDED_CALLER	The call was suspended by the caller.
CS_SUSPENDED_CALLEE	The call was suspended by the callee.
CS_SUSPENDED_BOTH	The call was suspended by both caller and callee.
CS_RESOLVING	We are looking up some other participant.
CS_RINGING	We are now ringing the other participant.
CS_CONNECTED	The other party accepted our call and we are now connected.
CS_SUSPENDED	The call is currently suspended (by us).

Definition at line 38 of file conversation_api_call.c.

{
  CS_LOOKUP = 0,
 
  CS_RINGING,
 
  CS_ACTIVE,
 
  CS_SHUTDOWN,
 
  CS_SUSPENDED_CALLER,
 
  CS_SUSPENDED_CALLEE,
 
  CS_SUSPENDED_BOTH
};

Function Documentation

fail_call()

static void fail_call ( struct GNUNET_CONVERSATION_Call *  call )

static

The call got disconnected, reconnect to the service.

The call got disconnected, destroy the handle.

Parameters

call	call to reconnect

Definition at line 532 of file conversation_api_call.c.

{
  if (CS_ACTIVE == call->state)
  {
    call->speaker->disable_speaker (call->speaker->cls);
    call->mic->disable_microphone (call->mic->cls);
  }
  if (NULL != call->mq)
  {
    GNUNET_MQ_destroy (call->mq);
    call->mq = NULL;
  }
  call->state = CS_SHUTDOWN;
  call->event_handler (call->event_handler_cls,
                       GNUNET_CONVERSATION_EC_CALL_ERROR);
  GNUNET_CONVERSATION_call_stop (call);
}

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_SHUTDOWN, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_ERROR, GNUNET_MQ_destroy(), GNUNET_CONVERSATION_Call::mic, GNUNET_CONVERSATION_Call::mq, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Referenced by call_error_handler(), handle_call_audio(), handle_call_hangup(), handle_call_picked_up(), handle_call_resume(), and handle_call_suspend().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_call_audio()

static void transmit_call_audio ( void *  cls, size_t  data_size, const void *  data  )

static

Process recorded audio data.

Parameters

cls	closure with the struct GNUNET_CONVERSATION_Call
data_size	number of bytes in data
data	audio data to play

Definition at line 161 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
  struct GNUNET_MQ_Envelope *e;
  struct ClientAudioMessage *am;
 
  GNUNET_assert (CS_ACTIVE == call->state);
  e = GNUNET_MQ_msg_extra (am,
                           data_size,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
  GNUNET_memcpy (&am[1],
                 data,
                 data_size);
  GNUNET_MQ_send (call->mq,
                  e);
}

References call, CS_ACTIVE, data, data_size, GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_CONVERSATION_Call::mq, and GNUNET_CONVERSATION_Call::state.

Referenced by GNUNET_CONVERSATION_call_resume(), handle_call_picked_up(), and handle_call_resume().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_call_suspend()

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

static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
msg	the message

Definition at line 188 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
 
  (void) msg;
  switch (call->state)
  {
  case CS_LOOKUP:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_RINGING:
    GNUNET_break_op (0);
    fail_call (call);
    break;
 
  case CS_SUSPENDED_CALLER:
    call->state = CS_SUSPENDED_BOTH;
    call->event_handler (call->event_handler_cls,
                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
    break;
 
  case CS_SUSPENDED_CALLEE:
  case CS_SUSPENDED_BOTH:
    GNUNET_break_op (0);
    break;
 
  case CS_ACTIVE:
    call->state = CS_SUSPENDED_CALLEE;
    call->speaker->disable_speaker (call->speaker->cls);
    call->mic->disable_microphone (call->mic->cls);
    call->event_handler (call->event_handler_cls,
                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
    break;
 
  case CS_SHUTDOWN:
    GNUNET_CONVERSATION_call_stop (call);
    break;
  }
}

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_SUSPENDED, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

handle_call_resume()

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

static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
msg	the message

Definition at line 239 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
 
  (void) msg;
  switch (call->state)
  {
  case CS_LOOKUP:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_RINGING:
    GNUNET_break_op (0);
    fail_call (call);
    break;
 
  case CS_SUSPENDED_CALLER:
    GNUNET_break_op (0);
    break;
 
  case CS_SUSPENDED_CALLEE:
    call->state = CS_ACTIVE;
    call->speaker->enable_speaker (call->speaker->cls);
    call->mic->enable_microphone (call->mic->cls,
                                  &transmit_call_audio,
                                  call);
    call->event_handler (call->event_handler_cls,
                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
    break;
 
  case CS_SUSPENDED_BOTH:
    call->state = CS_SUSPENDED_CALLER;
    call->event_handler (call->event_handler_cls,
                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
    break;
 
  case CS_ACTIVE:
    GNUNET_break_op (0);
    break;
 
  case CS_SHUTDOWN:
    GNUNET_CONVERSATION_call_stop (call);
    break;
  }
}

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_RESUMED, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, GNUNET_CONVERSATION_Call::state, and transmit_call_audio().

Here is the call graph for this function:

handle_call_picked_up()

static void handle_call_picked_up ( void *  cls, const struct ClientPhonePickedupMessage *  msg  )

static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
msg	the message

Definition at line 295 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
 
  (void) msg;
  switch (call->state)
  {
  case CS_LOOKUP:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_RINGING:
    call->state = CS_ACTIVE;
    call->speaker->enable_speaker (call->speaker->cls);
    call->mic->enable_microphone (call->mic->cls,
                                  &transmit_call_audio,
                                  call);
    call->event_handler (call->event_handler_cls,
                         GNUNET_CONVERSATION_EC_CALL_PICKED_UP);
    break;
 
  case CS_SUSPENDED_CALLER:
  case CS_SUSPENDED_CALLEE:
  case CS_SUSPENDED_BOTH:
  case CS_ACTIVE:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_SHUTDOWN:
    GNUNET_CONVERSATION_call_stop (call);
    break;
  }
}

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_PICKED_UP, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, GNUNET_CONVERSATION_Call::state, and transmit_call_audio().

Here is the call graph for this function:

handle_call_hangup()

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

static

We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
msg	the message

Definition at line 340 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
  GNUNET_CONVERSATION_CallEventHandler eh;
  void *eh_cls;
 
  (void) msg;
  switch (call->state)
  {
  case CS_LOOKUP:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_RINGING:
  case CS_SUSPENDED_CALLER:
  case CS_SUSPENDED_CALLEE:
  case CS_SUSPENDED_BOTH:
  case CS_ACTIVE:
    eh = call->event_handler;
    eh_cls = call->event_handler_cls;
    GNUNET_CONVERSATION_call_stop (call);
    eh (eh_cls,
        GNUNET_CONVERSATION_EC_CALL_HUNG_UP);
    return;
 
  case CS_SHUTDOWN:
    GNUNET_CONVERSATION_call_stop (call);
    break;
  }
}

References call, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_HUNG_UP, msg, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

check_call_audio()

static int check_call_audio ( void *  cls, const struct ClientAudioMessage *  am  )

static

We received a struct ClientAudioMessage, check it is well-formed.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
am	the message

Returns

GNUNET_OK (always well-formed)

Definition at line 382 of file conversation_api_call.c.

{
  (void) cls;
  (void) am;
  /* any payload is OK */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_call_audio()

static void handle_call_audio ( void *  cls, const struct ClientAudioMessage *  am  )

static

We received a struct ClientAudioMessage

Parameters

cls	the struct GNUNET_CONVERSATION_Call
am	the message

Definition at line 399 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
 
  switch (call->state)
  {
  case CS_LOOKUP:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_RINGING:
    GNUNET_break (0);
    fail_call (call);
    break;
 
  case CS_SUSPENDED_CALLER:
    /* can happen: we suspended, other peer did not yet
       learn about this. */
    break;
 
  case CS_SUSPENDED_CALLEE:
  case CS_SUSPENDED_BOTH:
    /* can (rarely) also happen: other peer suspended, but cadet might
       have had delayed data on the unreliable channel */
    break;
 
  case CS_ACTIVE:
    call->speaker->play (call->speaker->cls,
                         ntohs (am->header.size) - sizeof(struct
                                                          ClientAudioMessage),
                         &am[1]);
    break;
 
  case CS_SHUTDOWN:
    GNUNET_CONVERSATION_call_stop (call);
    break;
  }
}

References call, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), ClientAudioMessage::header, GNUNET_SPEAKER_Handle::play, GNUNET_MessageHeader::size, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

handle_gns_response()

static void handle_gns_response ( void *  cls, int  was_gns, uint32_t  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Iterator called on obtained result for a GNS lookup.

Parameters

cls	closure with the struct GNUNET_CONVERSATION_Call
was_gns	GNUNET_NO if name was not a GNS name
rd_count	number of records in rd
rd	the records in reply

Definition at line 450 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
  struct GNUNET_MQ_Envelope *e;
  struct ClientCallMessage *ccm;
  const struct GNUNET_CRYPTO_PrivateKey *caller_id;
  size_t key_len;
 
  (void) was_gns;
  GNUNET_break (NULL != call->gns_lookup);
  GNUNET_break (CS_LOOKUP == call->state);
  call->gns_lookup = NULL;
  for (uint32_t i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)
    {
      if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
      {
        GNUNET_break_op (0);
        continue;
      }
      GNUNET_memcpy (&call->phone_record,
                     rd[i].data,
                     rd[i].data_size);
      caller_id = GNUNET_IDENTITY_ego_get_private_key (call->caller_id);
      key_len = GNUNET_CRYPTO_private_key_get_length (caller_id);
      e = GNUNET_MQ_msg_extra (ccm, key_len,
                               GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);
      ccm->line_port = call->phone_record.line_port;
      ccm->target = call->phone_record.peer;
      GNUNET_CRYPTO_write_private_key_to_buffer (caller_id,
                                                   &ccm[1], key_len);
      ccm->key_len = htonl (key_len);
      GNUNET_MQ_send (call->mq,
                      e);
      call->state = CS_RINGING;
      call->event_handler (call->event_handler_cls,
                           GNUNET_CONVERSATION_EC_CALL_RINGING);
      return;
    }
  }
  /* not found */
  call->event_handler (call->event_handler_cls,
                       GNUNET_CONVERSATION_EC_CALL_GNS_FAIL);
  GNUNET_CONVERSATION_call_stop (call);
}

References call, GNUNET_CONVERSATION_Call::caller_id, CS_LOOKUP, CS_RINGING, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, GNUNET_CONVERSATION_Call::gns_lookup, GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_GNS_FAIL, GNUNET_CONVERSATION_EC_CALL_RINGING, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_GNSRECORD_TYPE_PHONE, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), ClientCallMessage::key_len, ClientCallMessage::line_port, GNUNET_CONVERSATION_PhoneRecord::line_port, GNUNET_CONVERSATION_Call::mq, GNUNET_CONVERSATION_PhoneRecord::peer, GNUNET_CONVERSATION_Call::phone_record, rd, rd_count, GNUNET_CONVERSATION_Call::state, and ClientCallMessage::target.

Referenced by GNUNET_CONVERSATION_call_start().

Here is the call graph for this function:

Here is the caller graph for this function:

call_error_handler()

static void call_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

We encountered an error talking with the conversation service.

Parameters

cls	the struct GNUNET_CONVERSATION_Call
error	details about the error

Definition at line 508 of file conversation_api_call.c.

{
  struct GNUNET_CONVERSATION_Call *call = cls;
 
  (void) error;
  if (CS_SHUTDOWN == call->state)
  {
    GNUNET_CONVERSATION_call_stop (call);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _ (
                "Connection to conversation service lost, trying to reconnect\n"));
  fail_call (call);
}

References _, call, CS_SHUTDOWN, fail_call(), GNUNET_CONVERSATION_call_stop(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and GNUNET_CONVERSATION_Call::state.

Referenced by GNUNET_CONVERSATION_call_start().

Here is the call graph for this function:

Here is the caller graph for this function: