conversation_api.c File Reference

phone and caller API to the conversation service More...

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

Include dependency graph for conversation_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_CONVERSATION_Caller
	A caller is the handle we have for an incoming call. More...
struct	GNUNET_CONVERSATION_Phone
	A phone is a device that can ring to signal an incoming call and that you can pick up to answer the call and hang up to terminate the call. More...

Enumerations
enum	CallerState {   CS_RINGING , CS_ACTIVE , CS_CALLEE_SUSPENDED , CS_CALLER_SUSPENDED ,   CS_BOTH_SUSPENDED }
	Possible states of a caller. More...
enum	PhoneState {   PS_REGISTER = 0 , PS_READY , PS_LOOKUP_EGO , PS_LISTEN ,   PS_ACCEPTED , PS_ERROR }
	Possible states of a phone. More...

Functions
static void	reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone)
	The phone got disconnected, reconnect to the service. More...
static void	transmit_phone_audio (void *cls, size_t data_size, const void *data)
	Process recorded audio data. More...
static enum GNUNET_GenericReturnValue	check_phone_ring (void *cls, const struct ClientPhoneRingMessage *ring)
	We received a struct ClientPhoneRingMessage More...
static void	handle_phone_ring (void *cls, const struct ClientPhoneRingMessage *ring)
	We received a struct ClientPhoneRingMessage More...
static struct GNUNET_CONVERSATION_Caller *	find_caller (struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
	Find the record of the caller matching the cid. More...
static void	handle_phone_hangup (void *cls, const struct ClientPhoneHangupMessage *hang)
	We received a struct ClientPhoneHangupMessage. More...
static void	handle_phone_suspend (void *cls, const struct ClientPhoneSuspendMessage *suspend)
	We received a struct ClientPhoneSuspendMessage. More...
static void	handle_phone_resume (void *cls, const struct ClientPhoneResumeMessage *resume)
	We received a struct ClientPhoneResumeMessage. More...
static int	check_phone_audio (void *cls, const struct ClientAudioMessage *am)
	We received a struct ClientAudioMessage, check it is well-formed. More...
static void	handle_phone_audio (void *cls, const struct ClientAudioMessage *am)
	We received a struct ClientAudioMessage More...
static void	phone_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We encountered an error talking with the conversation service. More...
static void	clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone)
	Clean up all callers of the given phone. More...
struct GNUNET_CONVERSATION_Phone *	GNUNET_CONVERSATION_phone_create (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_IDENTITY_Ego *ego, GNUNET_CONVERSATION_PhoneEventHandler event_handler, void *event_handler_cls)
	Create a new phone. More...
void	GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone, struct GNUNET_GNSRECORD_Data *rd)
	Fill in a namestore record with the contact information for this phone. More...
void	GNUNET_CONVERSATION_caller_pick_up (struct GNUNET_CONVERSATION_Caller *caller, GNUNET_CONVERSATION_CallerEventHandler event_handler, void *event_handler_cls, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
	Picks up a (ringing) phone. More...
void	GNUNET_CONVERSATION_caller_hang_up (struct GNUNET_CONVERSATION_Caller *caller)
	Hang up up a (possibly ringing) phone. More...
void	GNUNET_CONVERSATION_phone_destroy (struct GNUNET_CONVERSATION_Phone *phone)
	Destroys a phone. More...
void	GNUNET_CONVERSATION_caller_suspend (struct GNUNET_CONVERSATION_Caller *caller)
	Pause conversation of an active call. More...
void	GNUNET_CONVERSATION_caller_resume (struct GNUNET_CONVERSATION_Caller *caller, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
	Resume suspended conversation of a phone. More...

Detailed Description

phone and caller API to the conversation service

Author

Simon Dieterle

Andreas Fuchs

Christian Grothoff

Definition in file conversation_api.c.

Enumeration Type Documentation

CallerState

enum CallerState

Possible states of a caller.

Enumerator
CS_RINGING	The phone is ringing (user knows about incoming call).
CS_ACTIVE	The phone is in an active conversation.
CS_CALLEE_SUSPENDED	We suspended the conversation.
CS_CALLER_SUSPENDED	Caller suspended the conversation.
CS_BOTH_SUSPENDED	Both sides suspended the conversation.

Definition at line 36 of file conversation_api.c.

{
  CS_RINGING,
 
  CS_ACTIVE,
 
  CS_CALLEE_SUSPENDED,
 
  CS_CALLER_SUSPENDED,
 
  CS_BOTH_SUSPENDED
};

PhoneState

enum PhoneState

Possible states of a phone.

Enumerator
PS_REGISTER	We still need to register the phone.
PS_READY	We are waiting for calls.
PS_LOOKUP_EGO	We're waiting for our own idenitty.
PS_LISTEN	We're listening for calls.
PS_ACCEPTED	We accepted an incoming phone call.
PS_ERROR	Internal error.

Definition at line 125 of file conversation_api.c.

{
  PS_REGISTER = 0,
 
  PS_READY
};

Function Documentation

reconnect_phone()

static void reconnect_phone ( struct GNUNET_CONVERSATION_Phone *  phone )

static

The phone got disconnected, reconnect to the service.

Parameters

phone

phone to reconnect

Definition at line 588 of file conversation_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (phone_ring,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING,
                           struct ClientPhoneRingMessage,
                           phone),
    GNUNET_MQ_hd_fixed_size (phone_hangup,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
                             struct ClientPhoneHangupMessage,
                             phone),
    GNUNET_MQ_hd_fixed_size (phone_suspend,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
                             struct ClientPhoneSuspendMessage,
                             phone),
    GNUNET_MQ_hd_fixed_size (phone_resume,
                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
                             struct ClientPhoneResumeMessage,
                             phone),
    GNUNET_MQ_hd_var_size (phone_audio,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
                           struct ClientAudioMessage,
                           phone),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *e;
  struct ClientPhoneRegisterMessage *reg;
 
  clean_up_callers (phone);
  if (NULL != phone->mq)
  {
    GNUNET_MQ_destroy (phone->mq);
    phone->mq = NULL;
  }
  phone->state = PS_REGISTER;
  phone->mq = GNUNET_CLIENT_connect (phone->cfg,
                                     "conversation",
                                     handlers,
                                     &phone_error_handler,
                                     phone);
  if (NULL == phone->mq)
    return;
  e = GNUNET_MQ_msg (reg,
                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER);
  reg->line_port = phone->my_record.line_port;
  GNUNET_MQ_send (phone->mq,
                  e);
  phone->state = PS_READY;
}

References GNUNET_CONVERSATION_Phone::cfg, clean_up_callers(), GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, GNUNET_MQ_destroy(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), handlers, ClientPhoneRegisterMessage::line_port, GNUNET_CONVERSATION_PhoneRecord::line_port, GNUNET_CONVERSATION_Phone::mq, GNUNET_CONVERSATION_Phone::my_record, phone, phone_error_handler(), PS_READY, PS_REGISTER, and GNUNET_CONVERSATION_Phone::state.

Referenced by GNUNET_CONVERSATION_phone_create(), and phone_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_phone_audio()

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

static

Process recorded audio data.

Parameters

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

Definition at line 221 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Caller *caller = cls;
  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
  struct GNUNET_MQ_Envelope *e;
  struct ClientAudioMessage *am;
 
  e = GNUNET_MQ_msg_extra (am,
                           data_size,
                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
  am->cid = caller->cid;
  GNUNET_memcpy (&am[1],
                 data,
                 data_size);
  GNUNET_MQ_send (phone->mq,
                  e);
}

References ClientAudioMessage::cid, GNUNET_CONVERSATION_Caller::cid, data, data_size, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_CONVERSATION_Phone::mq, GNUNET_CONVERSATION_Caller::phone, and phone.

Referenced by GNUNET_CONVERSATION_caller_pick_up(), GNUNET_CONVERSATION_caller_resume(), and handle_phone_resume().

Here is the call graph for this function:

Here is the caller graph for this function:

check_phone_ring()

static enum GNUNET_GenericReturnValue check_phone_ring ( void *  cls, const struct ClientPhoneRingMessage *  ring  )

static

We received a struct ClientPhoneRingMessage

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
ring	the message

Definition at line 248 of file conversation_api.c.

{
  //FIXME
  return GNUNET_OK;
}

References GNUNET_OK.

handle_phone_ring()

static void handle_phone_ring ( void *  cls, const struct ClientPhoneRingMessage *  ring  )

static

We received a struct ClientPhoneRingMessage

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
ring	the message

Definition at line 261 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;
  struct GNUNET_CRYPTO_PublicKey caller_id;
  size_t key_len;
  size_t read;
 
  key_len = ntohl (ring->key_len);
  switch (phone->state)
  {
  case PS_REGISTER:
    GNUNET_assert (0);
    break;
 
  case PS_READY:
    if ((GNUNET_SYSERR ==
         GNUNET_CRYPTO_read_public_key_from_buffer (&ring[1],
                                                      key_len,
                                                      &caller_id,
                                                      &read)) ||
        (read != key_len))
    {
      GNUNET_break (0);
      break;
    }
    caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
    caller->phone = phone;
    GNUNET_CONTAINER_DLL_insert (phone->caller_head,
                                 phone->caller_tail,
                                 caller);
    caller->caller_id = caller_id;
    caller->cid = ring->cid;
    caller->state = CS_RINGING;
    phone->event_handler (phone->event_handler_cls,
                          GNUNET_CONVERSATION_EC_PHONE_RING,
                          caller,
                          &caller->caller_id);
    break;
  }
}

References GNUNET_CONVERSATION_Phone::caller_head, GNUNET_CONVERSATION_Caller::caller_id, GNUNET_CONVERSATION_Phone::caller_tail, ClientPhoneRingMessage::cid, GNUNET_CONVERSATION_Caller::cid, CS_RINGING, GNUNET_CONVERSATION_Phone::event_handler, GNUNET_CONVERSATION_Phone::event_handler_cls, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONVERSATION_EC_PHONE_RING, GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_new, GNUNET_SYSERR, ClientPhoneRingMessage::key_len, GNUNET_CONVERSATION_Caller::phone, phone, PS_READY, PS_REGISTER, GNUNET_CONVERSATION_Caller::state, and GNUNET_CONVERSATION_Phone::state.

Here is the call graph for this function:

find_caller()

static struct GNUNET_CONVERSATION_Caller * find_caller ( struct GNUNET_CONVERSATION_Phone *  phone, uint32_t  cid  )

static

Find the record of the caller matching the cid.

Parameters

phone	phone to search
cid	caller ID to search for (in NBO)

Returns

NULL if cid was not found

Definition at line 313 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Caller *caller;
 
  for (caller = phone->caller_head; NULL != caller; caller = caller->next)
    if (cid == caller->cid)
      return caller;
  return NULL;
}

References GNUNET_CONVERSATION_Phone::caller_head, GNUNET_CONVERSATION_Caller::cid, GNUNET_CONVERSATION_Caller::next, and phone.

Referenced by handle_phone_audio(), handle_phone_hangup(), handle_phone_resume(), and handle_phone_suspend().

Here is the caller graph for this function:

handle_phone_hangup()

static void handle_phone_hangup ( void *  cls, const struct ClientPhoneHangupMessage *  hang  )

static

We received a struct ClientPhoneHangupMessage.

Parameters

cls	the struct GNUNET_CONVERSATION_Phone *
hang	the message

Definition at line 332 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;
 
  caller = find_caller (phone,
                        hang->cid);
  if (NULL == caller)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received HANG_UP message for unknown caller ID %u\n",
                (unsigned int) hang->cid);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received HANG_UP message, terminating call with `%s'\n",
              GNUNET_GNSRECORD_pkey_to_zkey (&caller->caller_id));
  switch (caller->state)
  {
  case CS_RINGING:
    phone->event_handler (phone->event_handler_cls,
                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
                          caller,
                          &caller->caller_id);
    break;
 
  case CS_ACTIVE:
    caller->speaker->disable_speaker (caller->speaker->cls);
    caller->mic->disable_microphone (caller->mic->cls);
    phone->event_handler (phone->event_handler_cls,
                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
                          caller,
                          &caller->caller_id);
    break;
 
  case CS_CALLEE_SUSPENDED:
  case CS_CALLER_SUSPENDED:
  case CS_BOTH_SUSPENDED:
    phone->event_handler (phone->event_handler_cls,
                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
                          caller,
                          &caller->caller_id);
    break;
  }
  GNUNET_CONTAINER_DLL_remove (phone->caller_head,
                               phone->caller_tail,
                               caller);
  GNUNET_free (caller);
}

References GNUNET_CONVERSATION_Phone::caller_head, GNUNET_CONVERSATION_Caller::caller_id, GNUNET_CONVERSATION_Phone::caller_tail, ClientPhoneHangupMessage::cid, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_BOTH_SUSPENDED, CS_CALLEE_SUSPENDED, CS_CALLER_SUSPENDED, CS_RINGING, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Phone::event_handler, GNUNET_CONVERSATION_Phone::event_handler_cls, find_caller(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONVERSATION_EC_PHONE_HUNG_UP, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_log, GNUNET_CONVERSATION_Caller::mic, phone, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

Here is the call graph for this function:

handle_phone_suspend()

static void handle_phone_suspend ( void *  cls, const struct ClientPhoneSuspendMessage *  suspend  )

static

We received a struct ClientPhoneSuspendMessage.

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
suspend	the message

Definition at line 392 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;
 
  caller = find_caller (phone,
                        suspend->cid);
  if (NULL == caller)
    return;
  switch (caller->state)
  {
  case CS_RINGING:
    GNUNET_break_op (0);
    break;
 
  case CS_ACTIVE:
    caller->state = CS_CALLER_SUSPENDED;
    caller->speaker->disable_speaker (caller->speaker->cls);
    caller->mic->disable_microphone (caller->mic->cls);
    caller->event_handler (caller->event_handler_cls,
                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
    break;
 
  case CS_CALLEE_SUSPENDED:
    caller->state = CS_BOTH_SUSPENDED;
    caller->event_handler (caller->event_handler_cls,
                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
    break;
 
  case CS_CALLER_SUSPENDED:
  case CS_BOTH_SUSPENDED:
    GNUNET_break_op (0);
    break;
  }
}

References ClientPhoneSuspendMessage::cid, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_BOTH_SUSPENDED, CS_CALLEE_SUSPENDED, CS_CALLER_SUSPENDED, CS_RINGING, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Caller::event_handler, GNUNET_CONVERSATION_Caller::event_handler_cls, find_caller(), GNUNET_break_op, GNUNET_CONVERSATION_EC_CALLER_SUSPEND, GNUNET_CONVERSATION_Caller::mic, phone, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

Here is the call graph for this function:

handle_phone_resume()

static void handle_phone_resume ( void *  cls, const struct ClientPhoneResumeMessage *  resume  )

static

We received a struct ClientPhoneResumeMessage.

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
resume	the message

Definition at line 437 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;
 
  caller = find_caller (phone,
                        resume->cid);
  if (NULL == caller)
    return;
  switch (caller->state)
  {
  case CS_RINGING:
    GNUNET_break_op (0);
    break;
 
  case CS_ACTIVE:
  case CS_CALLEE_SUSPENDED:
    GNUNET_break_op (0);
    break;
 
  case CS_CALLER_SUSPENDED:
    caller->state = CS_ACTIVE;
    caller->speaker->enable_speaker (caller->speaker->cls);
    caller->mic->enable_microphone (caller->mic->cls,
                                    &transmit_phone_audio,
                                    caller);
    caller->event_handler (caller->event_handler_cls,
                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
    break;
 
  case CS_BOTH_SUSPENDED:
    caller->state = CS_CALLEE_SUSPENDED;
    caller->event_handler (caller->event_handler_cls,
                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
    break;
  }
}

References ClientPhoneResumeMessage::cid, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_BOTH_SUSPENDED, CS_CALLEE_SUSPENDED, CS_CALLER_SUSPENDED, CS_RINGING, GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_CONVERSATION_Caller::event_handler, GNUNET_CONVERSATION_Caller::event_handler_cls, find_caller(), GNUNET_break_op, GNUNET_CONVERSATION_EC_CALLER_RESUME, GNUNET_CONVERSATION_Caller::mic, phone, GNUNET_CONVERSATION_Caller::speaker, GNUNET_CONVERSATION_Caller::state, and transmit_phone_audio().

Here is the call graph for this function:

check_phone_audio()

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

static

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

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
am	the message

Returns

GNUNET_OK if am is well-formed

Definition at line 485 of file conversation_api.c.

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

References GNUNET_OK.

handle_phone_audio()

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

static

We received a struct ClientAudioMessage

Parameters

cls	the struct GNUNET_CONVERSATION_Phone
am	the message

Definition at line 503 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;
 
  caller = find_caller (phone,
                        am->cid);
  if (NULL == caller)
    return;
  switch (caller->state)
  {
  case CS_RINGING:
    GNUNET_break_op (0);
    break;
 
  case CS_ACTIVE:
    caller->speaker->play (caller->speaker->cls,
                           ntohs (am->header.size) - sizeof(struct
                                                            ClientAudioMessage),
                           &am[1]);
    break;
 
  case CS_CALLEE_SUSPENDED:
  case CS_CALLER_SUSPENDED:
  case CS_BOTH_SUSPENDED:
    break;
  }
}

References ClientAudioMessage::cid, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_BOTH_SUSPENDED, CS_CALLEE_SUSPENDED, CS_CALLER_SUSPENDED, CS_RINGING, find_caller(), GNUNET_break_op, ClientAudioMessage::header, phone, GNUNET_SPEAKER_Handle::play, GNUNET_MessageHeader::size, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

Here is the call graph for this function:

phone_error_handler()

static void phone_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_Phone
error	details about the error

Definition at line 541 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
 
  (void) error;
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _ (
                "Connection to conversation service lost, trying to reconnect\n"));
  reconnect_phone (phone);
}

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, phone, and reconnect_phone().

Referenced by reconnect_phone().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_up_callers()

static void clean_up_callers ( struct GNUNET_CONVERSATION_Phone *  phone )

static

Clean up all callers of the given phone.

Parameters

phone

phone to clean up callers for

Definition at line 560 of file conversation_api.c.

{
  struct GNUNET_CONVERSATION_Caller *caller;
 
  while (NULL != (caller = phone->caller_head))
  {
    /* make sure mic/speaker are disabled *before* callback */
    if (CS_ACTIVE == caller->state)
    {
      caller->speaker->disable_speaker (caller->speaker->cls);
      caller->mic->disable_microphone (caller->mic->cls);
      caller->state = CS_CALLER_SUSPENDED;
    }
    phone->event_handler (phone->event_handler_cls,
                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
                          caller,
                          &caller->caller_id);
    GNUNET_CONVERSATION_caller_hang_up (caller);
  }
}

References GNUNET_CONVERSATION_Phone::caller_head, GNUNET_CONVERSATION_Caller::caller_id, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_CALLER_SUSPENDED, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Phone::event_handler, GNUNET_CONVERSATION_Phone::event_handler_cls, GNUNET_CONVERSATION_caller_hang_up(), GNUNET_CONVERSATION_EC_PHONE_HUNG_UP, GNUNET_CONVERSATION_Caller::mic, phone, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

Referenced by GNUNET_CONVERSATION_phone_destroy(), and reconnect_phone().

Here is the call graph for this function:

Here is the caller graph for this function: