GNUnet  0.10.x
Data Structures | Enumerations | Functions
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 void handle_phone_ring (void *cls, const struct ClientPhoneRingMessage *ring)
 We received a struct ClientPhoneRingMessage More...
 
static struct GNUNET_CONVERSATION_Callerfind_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_PhoneGNUNET_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

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.

37 {
41  CS_RINGING,
42 
46  CS_ACTIVE,
47 
52 
57 
62 };
The phone is in an active conversation.
The phone is ringing (user knows about incoming call).
We suspended the conversation.
Caller suspended the conversation.
Both sides suspended the conversation.

◆ 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 128 of file conversation_api.c.

129 {
133  PS_REGISTER = 0,
134 
138  PS_READY
139 
140 };
We still need to register the phone.
We are waiting for calls.

Function Documentation

◆ reconnect_phone()

static void reconnect_phone ( struct GNUNET_CONVERSATION_Phone phone)
static

The phone got disconnected, reconnect to the service.

Parameters
phonephone to reconnect

Definition at line 554 of file conversation_api.c.

References GNUNET_CONVERSATION_Phone::cfg, clean_up_callers(), e, 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(), ClientPhoneRegisterMessage::line_port, GNUNET_CONVERSATION_PhoneRecord::line_port, GNUNET_CONVERSATION_Phone::mq, GNUNET_CONVERSATION_Phone::my_record, phone_error_handler(), PS_READY, PS_REGISTER, and GNUNET_CONVERSATION_Phone::state.

Referenced by GNUNET_CONVERSATION_phone_create(), and phone_error_handler().

555 {
557  GNUNET_MQ_hd_fixed_size (phone_ring,
559  struct ClientPhoneRingMessage,
560  phone),
561  GNUNET_MQ_hd_fixed_size (phone_hangup,
564  phone),
565  GNUNET_MQ_hd_fixed_size (phone_suspend,
568  phone),
569  GNUNET_MQ_hd_fixed_size (phone_resume,
572  phone),
573  GNUNET_MQ_hd_var_size (phone_audio,
575  struct ClientAudioMessage,
576  phone),
578  };
579  struct GNUNET_MQ_Envelope *e;
580  struct ClientPhoneRegisterMessage *reg;
581 
582  clean_up_callers (phone);
583  if (NULL != phone->mq)
584  {
585  GNUNET_MQ_destroy (phone->mq);
586  phone->mq = NULL;
587  }
588  phone->state = PS_REGISTER;
589  phone->mq = GNUNET_CLIENT_connect (phone->cfg,
590  "conversation",
591  handlers,
593  phone);
594  if (NULL == phone->mq)
595  return;
596  e = GNUNET_MQ_msg (reg,
598  reg->line_port = phone->my_record.line_port;
599  GNUNET_MQ_send (phone->mq,
600  e);
601  phone->state = PS_READY;
602 }
We still need to register the phone.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
enum PhoneState state
State machine for the phone.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:901
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
Client -> Service message to register a phone.
Definition: conversation.h:70
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
static void clean_up_callers(struct GNUNET_CONVERSATION_Phone *phone)
Clean up all callers of the given phone.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING
Client <- Server message to indicate a ringing phone.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:174
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_CONVERSATION_PhoneRecord my_record
This phone&#39;s record.
Message handler for a specific message type.
We are waiting for calls.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
Client <-> Server message to resume connection.
struct GNUNET_HashCode line_port
Phone line / CADET port to register.
Definition: conversation.h:85
Service <-> Client message for phone was resumed.
Definition: conversation.h:135
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
Client -> Server message to register a phone.
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
Service -> Client message for phone is ringing.
Definition: conversation.h:92
Message Client <-> Service to transmit the audio.
Definition: conversation.h:193
struct GNUNET_HashCode line_port
Phone line (CADET port) to connect to.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
Client <-> Server message to suspend connection.
Service <-> Client message for phone was suspended.
Definition: conversation.h:116
static void phone_error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error talking with the conversation service.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
Client -> Server message to reject/hangup a call.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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
clsclosure with the struct GNUNET_CONVERSATION_Caller
data_sizenumber of bytes in data
dataaudio data to play

Definition at line 226 of file conversation_api.c.

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

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

229 {
230  struct GNUNET_CONVERSATION_Caller *caller = cls;
231  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
232  struct GNUNET_MQ_Envelope *e;
233  struct ClientAudioMessage *am;
234 
235  e = GNUNET_MQ_msg_extra (am,
236  data_size,
238  am->cid = caller->cid;
239  GNUNET_memcpy (&am[1],
240  data,
241  data_size);
242  GNUNET_MQ_send (phone->mq,
243  e);
244 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
static struct Experiment * e
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
#define GNUNET_memcpy(dst, src, n)
uint32_t cid
Internal handle to identify the caller with the service.
A caller is the handle we have for an incoming call.
struct GNUNET_CONVERSATION_Phone * phone
Our phone.
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
Message Client <-> Service to transmit the audio.
Definition: conversation.h:193
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
uint32_t data
The data value.
static size_t data_size
Number of bytes in data.
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:204
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_phone_ring()

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

We received a struct ClientPhoneRingMessage

Parameters
clsthe struct GNUNET_CONVERSATION_Phone
ringthe message

Definition at line 254 of file conversation_api.c.

References GNUNET_CONVERSATION_Phone::caller_head, ClientPhoneRingMessage::caller_id, 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_CONTAINER_DLL_insert, GNUNET_CONVERSATION_EC_PHONE_RING, GNUNET_new, GNUNET_CONVERSATION_Caller::phone, PS_READY, PS_REGISTER, GNUNET_CONVERSATION_Caller::state, and GNUNET_CONVERSATION_Phone::state.

256 {
257  struct GNUNET_CONVERSATION_Phone *phone = cls;
258  struct GNUNET_CONVERSATION_Caller *caller;
259 
260  switch (phone->state)
261  {
262  case PS_REGISTER:
263  GNUNET_assert (0);
264  break;
265  case PS_READY:
266  caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
267  caller->phone = phone;
269  phone->caller_tail,
270  caller);
271  caller->caller_id = ring->caller_id;
272  caller->cid = ring->cid;
273  caller->state = CS_RINGING;
274  phone->event_handler (phone->event_handler_cls,
276  caller,
277  &caller->caller_id);
278  break;
279  }
280 }
We still need to register the phone.
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
enum PhoneState state
State machine for the phone.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Who is calling us?
Definition: conversation.h:108
GNUNET_CONVERSATION_PhoneEventHandler event_handler
Function to call for phone events.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
enum CallerState state
State machine for the phone.
void * event_handler_cls
Closure for event_handler.
struct GNUNET_CONVERSATION_Caller * caller_tail
We keep all callers in a DLL.
The phone is ringing (user knows about incoming call).
uint32_t cid
Internal handle to identify the caller with the service.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Identity of the person calling us.
A caller is the handle we have for an incoming call.
We are waiting for calls.
uint32_t cid
CID, internal caller ID number used in the future to identify which active call we are talking about...
Definition: conversation.h:103
struct GNUNET_CONVERSATION_Phone * phone
Our phone.
We are the callee and the phone is ringing.
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.

◆ 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
phonephone to search
cidcaller ID to search for (in NBO)
Returns
NULL if cid was not found

Definition at line 291 of file conversation_api.c.

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

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

293 {
294  struct GNUNET_CONVERSATION_Caller *caller;
295 
296  for (caller = phone->caller_head;NULL != caller;caller = caller->next)
297  if (cid == caller->cid)
298  return caller;
299  return NULL;
300 }
struct GNUNET_CONVERSATION_Caller * next
We keep all callers in a DLL.
uint32_t cid
Internal handle to identify the caller with the service.
A caller is the handle we have for an incoming call.
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.
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
clsthe struct GNUNET_CONVERSATION_Phone *
msgthe message

Definition at line 310 of file conversation_api.c.

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, GNUNET_CONVERSATION_Caller::phone, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

312 {
313  struct GNUNET_CONVERSATION_Phone *phone = cls;
314  struct GNUNET_CONVERSATION_Caller *caller;
315 
316  caller = find_caller (phone,
317  hang->cid);
318  if (NULL == caller)
319  {
321  "Received HANG_UP message for unknown caller ID %u\n",
322  (unsigned int) hang->cid);
323  return;
324  }
325 
327  "Received HANG_UP message, terminating call with `%s'\n",
329  switch (caller->state)
330  {
331  case CS_RINGING:
332  phone->event_handler (phone->event_handler_cls,
334  caller,
335  &caller->caller_id);
336  break;
337  case CS_ACTIVE:
338  caller->speaker->disable_speaker (caller->speaker->cls);
339  caller->mic->disable_microphone (caller->mic->cls);
340  phone->event_handler (phone->event_handler_cls,
342  caller,
343  &caller->caller_id);
344  break;
345  case CS_CALLEE_SUSPENDED:
346  case CS_CALLER_SUSPENDED:
347  case CS_BOTH_SUSPENDED:
348  phone->event_handler (phone->event_handler_cls,
350  caller,
351  &caller->caller_id);
352  break;
353  }
355  phone->caller_tail,
356  caller);
357  GNUNET_free (caller);
358 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
The phone is in an active conversation.
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
GNUNET_CONVERSATION_PhoneEventHandler event_handler
Function to call for phone events.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:185
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
enum CallerState state
State machine for the phone.
void * event_handler_cls
Closure for event_handler.
struct GNUNET_CONVERSATION_Caller * caller_tail
We keep all callers in a DLL.
The phone is ringing (user knows about incoming call).
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
void * cls
Closure for the callbacks.
We suspended the conversation.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Identity of the person calling us.
Caller suspended the conversation.
A caller is the handle we have for an incoming call.
The conversation was terminated by the caller.
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
void * cls
Closure for the callbacks.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
Both sides suspended the conversation.
#define GNUNET_log(kind,...)
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe struct GNUNET_CONVERSATION_Phone
suspendthe message

Definition at line 368 of file conversation_api.c.

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, GNUNET_CONVERSATION_Caller::phone, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

370 {
371  struct GNUNET_CONVERSATION_Phone *phone = cls;
372  struct GNUNET_CONVERSATION_Caller *caller;
373 
374  caller = find_caller (phone,
375  suspend->cid);
376  if (NULL == caller)
377  return;
378  switch (caller->state)
379  {
380  case CS_RINGING:
381  GNUNET_break_op (0);
382  break;
383  case CS_ACTIVE:
384  caller->state = CS_CALLER_SUSPENDED;
385  caller->speaker->disable_speaker (caller->speaker->cls);
386  caller->mic->disable_microphone (caller->mic->cls);
387  caller->event_handler (caller->event_handler_cls,
389  break;
390  case CS_CALLEE_SUSPENDED:
391  caller->state = CS_BOTH_SUSPENDED;
392  caller->event_handler (caller->event_handler_cls,
394  break;
395  case CS_CALLER_SUSPENDED:
396  case CS_BOTH_SUSPENDED:
397  GNUNET_break_op (0);
398  break;
399  }
400 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
The phone is in an active conversation.
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
enum CallerState state
State machine for the phone.
The phone is ringing (user knows about incoming call).
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
GNUNET_CONVERSATION_CallerEventHandler event_handler
Function to call for phone events.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void * cls
Closure for the callbacks.
We suspended the conversation.
Caller suspended the conversation.
A caller is the handle we have for an incoming call.
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
void * cls
Closure for the callbacks.
Both sides suspended the conversation.
We are the callee and the caller suspended the call.
void * event_handler_cls
Closure for event_handler.
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:127
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
clsthe struct GNUNET_CONVERSATION_Phone
resumethe message

Definition at line 410 of file conversation_api.c.

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, GNUNET_CONVERSATION_Caller::phone, GNUNET_CONVERSATION_Caller::speaker, GNUNET_CONVERSATION_Caller::state, and transmit_phone_audio().

412 {
413  struct GNUNET_CONVERSATION_Phone *phone = cls;
414  struct GNUNET_CONVERSATION_Caller *caller;
415 
416  caller = find_caller (phone,
417  resume->cid);
418  if (NULL == caller)
419  return;
420  switch (caller->state)
421  {
422  case CS_RINGING:
423  GNUNET_break_op (0);
424  break;
425  case CS_ACTIVE:
426  case CS_CALLEE_SUSPENDED:
427  GNUNET_break_op (0);
428  break;
429  case CS_CALLER_SUSPENDED:
430  caller->state = CS_ACTIVE;
431  caller->speaker->enable_speaker (caller->speaker->cls);
432  caller->mic->enable_microphone (caller->mic->cls,
434  caller);
435  caller->event_handler (caller->event_handler_cls,
437  break;
438  case CS_BOTH_SUSPENDED:
439  caller->state = CS_CALLEE_SUSPENDED;
440  caller->event_handler (caller->event_handler_cls,
442  break;
443  }
444 }
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:146
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
The phone is in an active conversation.
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
We are the callee and the caller resumed the call.
GNUNET_MICROPHONE_EnableCallback enable_microphone
Turn on the microphone.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
enum CallerState state
State machine for the phone.
The phone is ringing (user knows about incoming call).
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
GNUNET_CONVERSATION_CallerEventHandler event_handler
Function to call for phone events.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void * cls
Closure for the callbacks.
We suspended the conversation.
Caller suspended the conversation.
A caller is the handle we have for an incoming call.
GNUNET_SPEAKER_EnableCallback enable_speaker
Turn on the speaker.
static void transmit_phone_audio(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
void * cls
Closure for the callbacks.
Both sides suspended the conversation.
void * event_handler_cls
Closure for event_handler.
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
clsthe struct GNUNET_CONVERSATION_Phone
amthe message
Returns
GNUNET_OK if am is well-formed

Definition at line 455 of file conversation_api.c.

References GNUNET_OK.

457 {
458  (void) cls;
459  (void) am;
460 
461  /* any variable-size payload is OK */
462  return GNUNET_OK;
463 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78

◆ handle_phone_audio()

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

We received a struct ClientAudioMessage

Parameters
clsthe struct GNUNET_CONVERSATION_Phone
amthe message

Definition at line 473 of file conversation_api.c.

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, GNUNET_CONVERSATION_Caller::phone, GNUNET_SPEAKER_Handle::play, GNUNET_MessageHeader::size, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

475 {
476  struct GNUNET_CONVERSATION_Phone *phone = cls;
477  struct GNUNET_CONVERSATION_Caller *caller;
478 
479  caller = find_caller (phone,
480  am->cid);
481  if (NULL == caller)
482  return;
483  switch (caller->state)
484  {
485  case CS_RINGING:
486  GNUNET_break_op (0);
487  break;
488  case CS_ACTIVE:
489  caller->speaker->play (caller->speaker->cls,
490  ntohs (am->header.size) - sizeof (struct ClientAudioMessage),
491  &am[1]);
492  break;
493  case CS_CALLEE_SUSPENDED:
494  case CS_CALLER_SUSPENDED:
495  case CS_BOTH_SUSPENDED:
496  break;
497  }
498 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
The phone is in an active conversation.
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
GNUNET_SPEAKER_PlayCallback play
Play audio.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
enum CallerState state
State machine for the phone.
The phone is ringing (user knows about incoming call).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We suspended the conversation.
Caller suspended the conversation.
A caller is the handle we have for an incoming call.
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
void * cls
Closure for the callbacks.
Both sides suspended the conversation.
Message Client <-> Service to transmit the audio.
Definition: conversation.h:193
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:198
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:204
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
clsthe struct GNUNET_CONVERSATION_Phone
errordetails about the error

Definition at line 508 of file conversation_api.c.

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

Referenced by reconnect_phone().

510 {
511  struct GNUNET_CONVERSATION_Phone *phone = cls;
512 
513  (void) error;
515  _("Connection to conversation service lost, trying to reconnect\n"));
516  reconnect_phone (phone);
517 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
static void reconnect_phone(struct GNUNET_CONVERSATION_Phone *phone)
The phone got disconnected, reconnect to the service.
#define GNUNET_log(kind,...)
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
phonephone to clean up callers for

Definition at line 526 of file conversation_api.c.

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, GNUNET_CONVERSATION_Caller::speaker, and GNUNET_CONVERSATION_Caller::state.

Referenced by GNUNET_CONVERSATION_phone_destroy(), and reconnect_phone().

527 {
528  struct GNUNET_CONVERSATION_Caller *caller;
529 
530  while (NULL != (caller = phone->caller_head))
531  {
532  /* make sure mic/speaker are disabled *before* callback */
533  if (CS_ACTIVE == caller->state)
534  {
535  caller->speaker->disable_speaker (caller->speaker->cls);
536  caller->mic->disable_microphone (caller->mic->cls);
537  caller->state = CS_CALLER_SUSPENDED;
538  }
539  phone->event_handler (phone->event_handler_cls,
541  caller,
542  &caller->caller_id);
544  }
545 }
The phone is in an active conversation.
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
GNUNET_CONVERSATION_PhoneEventHandler event_handler
Function to call for phone events.
void GNUNET_CONVERSATION_caller_hang_up(struct GNUNET_CONVERSATION_Caller *caller)
Hang up up a (possibly ringing) phone.
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.
enum CallerState state
State machine for the phone.
void * event_handler_cls
Closure for event_handler.
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
void * cls
Closure for the callbacks.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Identity of the person calling us.
Caller suspended the conversation.
A caller is the handle we have for an incoming call.
The conversation was terminated by the caller.
void * cls
Closure for the callbacks.
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.
Here is the call graph for this function:
Here is the caller graph for this function: