GNUnet  0.11.x
conversation_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2013, 2014 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
28 #include "platform.h"
30 #include "conversation.h"
31 
32 
37 {
42 
47 
52 
57 
62 };
63 
64 
69 {
74 
79 
84 
89 
94 
99 
104 
109 
113  uint32_t cid;
114 
118  enum CallerState state;
119 };
120 
121 
126 {
131 
135  PS_READY
136 };
137 
138 
151 {
156 
161 
166 
171 
176 
181 
186 
191 
196 
200  enum PhoneState state;
201 };
202 
203 
209 static void
211 
212 
220 static void
222  size_t data_size,
223  const void *data)
224 {
225  struct GNUNET_CONVERSATION_Caller *caller = cls;
226  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
227  struct GNUNET_MQ_Envelope *e;
228  struct ClientAudioMessage *am;
229 
230  e = GNUNET_MQ_msg_extra (am,
231  data_size,
233  am->cid = caller->cid;
234  GNUNET_memcpy (&am[1],
235  data,
236  data_size);
238  e);
239 }
240 
241 
248 static void
249 handle_phone_ring (void *cls,
250  const struct ClientPhoneRingMessage *ring)
251 {
252  struct GNUNET_CONVERSATION_Phone *phone = cls;
253  struct GNUNET_CONVERSATION_Caller *caller;
254 
255  switch (phone->state)
256  {
257  case PS_REGISTER:
258  GNUNET_assert (0);
259  break;
260 
261  case PS_READY:
262  caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
263  caller->phone = phone;
266  caller);
267  caller->caller_id = ring->caller_id;
268  caller->cid = ring->cid;
269  caller->state = CS_RINGING;
272  caller,
273  &caller->caller_id);
274  break;
275  }
276 }
277 
278 
286 static struct GNUNET_CONVERSATION_Caller *
288  uint32_t cid)
289 {
290  struct GNUNET_CONVERSATION_Caller *caller;
291 
292  for (caller = phone->caller_head; NULL != caller; caller = caller->next)
293  if (cid == caller->cid)
294  return caller;
295  return NULL;
296 }
297 
298 
305 static void
307  const struct ClientPhoneHangupMessage *hang)
308 {
309  struct GNUNET_CONVERSATION_Phone *phone = cls;
310  struct GNUNET_CONVERSATION_Caller *caller;
311 
312  caller = find_caller (phone,
313  hang->cid);
314  if (NULL == caller)
315  {
317  "Received HANG_UP message for unknown caller ID %u\n",
318  (unsigned int) hang->cid);
319  return;
320  }
321 
323  "Received HANG_UP message, terminating call with `%s'\n",
325  switch (caller->state)
326  {
327  case CS_RINGING:
330  caller,
331  &caller->caller_id);
332  break;
333 
334  case CS_ACTIVE:
335  caller->speaker->disable_speaker (caller->speaker->cls);
336  caller->mic->disable_microphone (caller->mic->cls);
339  caller,
340  &caller->caller_id);
341  break;
342 
343  case CS_CALLEE_SUSPENDED:
344  case CS_CALLER_SUSPENDED:
345  case CS_BOTH_SUSPENDED:
348  caller,
349  &caller->caller_id);
350  break;
351  }
354  caller);
355  GNUNET_free (caller);
356 }
357 
358 
365 static void
367  const struct ClientPhoneSuspendMessage *suspend)
368 {
369  struct GNUNET_CONVERSATION_Phone *phone = cls;
370  struct GNUNET_CONVERSATION_Caller *caller;
371 
372  caller = find_caller (phone,
373  suspend->cid);
374  if (NULL == caller)
375  return;
376  switch (caller->state)
377  {
378  case CS_RINGING:
379  GNUNET_break_op (0);
380  break;
381 
382  case CS_ACTIVE:
383  caller->state = CS_CALLER_SUSPENDED;
384  caller->speaker->disable_speaker (caller->speaker->cls);
385  caller->mic->disable_microphone (caller->mic->cls);
386  caller->event_handler (caller->event_handler_cls,
388  break;
389 
390  case CS_CALLEE_SUSPENDED:
391  caller->state = CS_BOTH_SUSPENDED;
392  caller->event_handler (caller->event_handler_cls,
394  break;
395 
396  case CS_CALLER_SUSPENDED:
397  case CS_BOTH_SUSPENDED:
398  GNUNET_break_op (0);
399  break;
400  }
401 }
402 
403 
410 static void
412  const struct ClientPhoneResumeMessage *resume)
413 {
414  struct GNUNET_CONVERSATION_Phone *phone = cls;
415  struct GNUNET_CONVERSATION_Caller *caller;
416 
417  caller = find_caller (phone,
418  resume->cid);
419  if (NULL == caller)
420  return;
421  switch (caller->state)
422  {
423  case CS_RINGING:
424  GNUNET_break_op (0);
425  break;
426 
427  case CS_ACTIVE:
428  case CS_CALLEE_SUSPENDED:
429  GNUNET_break_op (0);
430  break;
431 
432  case CS_CALLER_SUSPENDED:
433  caller->state = CS_ACTIVE;
434  caller->speaker->enable_speaker (caller->speaker->cls);
435  caller->mic->enable_microphone (caller->mic->cls,
437  caller);
438  caller->event_handler (caller->event_handler_cls,
440  break;
441 
442  case CS_BOTH_SUSPENDED:
443  caller->state = CS_CALLEE_SUSPENDED;
444  caller->event_handler (caller->event_handler_cls,
446  break;
447  }
448 }
449 
450 
458 static int
459 check_phone_audio (void *cls,
460  const struct ClientAudioMessage *am)
461 {
462  (void) cls;
463  (void) am;
464 
465  /* any variable-size payload is OK */
466  return GNUNET_OK;
467 }
468 
469 
476 static void
478  const struct ClientAudioMessage *am)
479 {
480  struct GNUNET_CONVERSATION_Phone *phone = cls;
481  struct GNUNET_CONVERSATION_Caller *caller;
482 
483  caller = find_caller (phone,
484  am->cid);
485  if (NULL == caller)
486  return;
487  switch (caller->state)
488  {
489  case CS_RINGING:
490  GNUNET_break_op (0);
491  break;
492 
493  case CS_ACTIVE:
494  caller->speaker->play (caller->speaker->cls,
495  ntohs (am->header.size) - sizeof(struct
497  &am[1]);
498  break;
499 
500  case CS_CALLEE_SUSPENDED:
501  case CS_CALLER_SUSPENDED:
502  case CS_BOTH_SUSPENDED:
503  break;
504  }
505 }
506 
507 
514 static void
516  enum GNUNET_MQ_Error error)
517 {
518  struct GNUNET_CONVERSATION_Phone *phone = cls;
519 
520  (void) error;
522  _ (
523  "Connection to conversation service lost, trying to reconnect\n"));
525 }
526 
527 
533 static void
535 {
536  struct GNUNET_CONVERSATION_Caller *caller;
537 
538  while (NULL != (caller = phone->caller_head))
539  {
540  /* make sure mic/speaker are disabled *before* callback */
541  if (CS_ACTIVE == caller->state)
542  {
543  caller->speaker->disable_speaker (caller->speaker->cls);
544  caller->mic->disable_microphone (caller->mic->cls);
545  caller->state = CS_CALLER_SUSPENDED;
546  }
549  caller,
550  &caller->caller_id);
552  }
553 }
554 
555 
561 static void
563 {
565  GNUNET_MQ_hd_fixed_size (phone_ring,
567  struct ClientPhoneRingMessage,
568  phone),
569  GNUNET_MQ_hd_fixed_size (phone_hangup,
572  phone),
573  GNUNET_MQ_hd_fixed_size (phone_suspend,
576  phone),
577  GNUNET_MQ_hd_fixed_size (phone_resume,
580  phone),
581  GNUNET_MQ_hd_var_size (phone_audio,
583  struct ClientAudioMessage,
584  phone),
586  };
587  struct GNUNET_MQ_Envelope *e;
588  struct ClientPhoneRegisterMessage *reg;
589 
591  if (NULL != phone->mq)
592  {
594  phone->mq = NULL;
595  }
598  "conversation",
599  handlers,
601  phone);
602  if (NULL == phone->mq)
603  return;
604  e = GNUNET_MQ_msg (reg,
608  e);
609  phone->state = PS_READY;
610 }
611 
612 
625  const struct GNUNET_IDENTITY_Ego *ego,
628  void *event_handler_cls)
629 {
631  char *line;
632  struct GNUNET_HashCode line_port;
633 
634  if (GNUNET_OK !=
636  "CONVERSATION",
637  "LINE",
638  &line))
639  {
641  "CONVERSATION",
642  "LINE");
643  return NULL;
644  }
646  strlen (line),
647  &line_port);
648  GNUNET_free (line);
650  if (GNUNET_OK !=
652  &phone->my_record.peer))
653  {
654  GNUNET_break (0);
655  GNUNET_free (phone);
656  return NULL;
657  }
658  phone->cfg = cfg;
660  phone->event_handler = event_handler;
661  phone->event_handler_cls = event_handler_cls;
663  phone->my_record.version = htonl (1);
664  phone->my_record.reserved = htonl (0);
665  phone->my_record.line_port = line_port;
667  if ((NULL == phone->mq) ||
668  (NULL == phone->ns))
669  {
670  GNUNET_break (0);
672  return NULL;
673  }
674  return phone;
675 }
676 
677 
686 void
688  struct GNUNET_GNSRECORD_Data *rd)
689 {
690  rd->data = &phone->my_record;
691  rd->expiration_time = 0;
692  rd->data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
695 }
696 
697 
708 void
711  event_handler,
712  void *event_handler_cls,
715 {
716  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
717  struct GNUNET_MQ_Envelope *e;
718  struct ClientPhonePickupMessage *pick;
719 
720  GNUNET_assert (CS_RINGING == caller->state);
721  caller->speaker = speaker;
722  caller->mic = mic;
723  e = GNUNET_MQ_msg (pick,
725  pick->cid = caller->cid;
727  e);
728  caller->state = CS_ACTIVE;
729  caller->event_handler = event_handler;
730  caller->event_handler_cls = event_handler_cls;
731  caller->speaker->enable_speaker (caller->speaker->cls);
732  caller->mic->enable_microphone (caller->mic->cls,
734  caller);
735 }
736 
737 
744 void
746 {
747  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
748  struct GNUNET_MQ_Envelope *e;
749  struct ClientPhoneHangupMessage *hang;
750 
751  switch (caller->state)
752  {
753  case CS_ACTIVE:
754  caller->speaker->disable_speaker (caller->speaker->cls);
755  caller->mic->disable_microphone (caller->mic->cls);
756  break;
757 
758  default:
759  break;
760  }
763  caller);
764  e = GNUNET_MQ_msg (hang,
766  hang->cid = caller->cid;
768  e);
769  GNUNET_free (caller);
770 }
771 
772 
778 void
780 {
782  if (NULL != phone->ns)
783  {
785  phone->ns = NULL;
786  }
787  if (NULL != phone->mq)
788  {
790  phone->mq = NULL;
791  }
792  GNUNET_free (phone);
793 }
794 
795 
803 void
805 {
806  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
807  struct GNUNET_MQ_Envelope *e;
808  struct ClientPhoneSuspendMessage *suspend;
809 
810  GNUNET_assert ((CS_ACTIVE == caller->state) ||
811  (CS_CALLER_SUSPENDED == caller->state));
812  if (CS_ACTIVE == caller->state)
813  {
814  caller->speaker->disable_speaker (caller->speaker->cls);
815  caller->mic->disable_microphone (caller->mic->cls);
816  }
817  caller->speaker = NULL;
818  caller->mic = NULL;
819  e = GNUNET_MQ_msg (suspend,
821  suspend->cid = caller->cid;
823  e);
824  if (CS_ACTIVE == caller->state)
825  caller->state = CS_CALLEE_SUSPENDED;
826  else
827  caller->state = CS_BOTH_SUSPENDED;
828 }
829 
830 
838 void
842 {
843  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
844  struct GNUNET_MQ_Envelope *e;
845  struct ClientPhoneResumeMessage *resume;
846 
847  GNUNET_assert ((CS_CALLEE_SUSPENDED == caller->state) ||
848  (CS_BOTH_SUSPENDED == caller->state));
849  caller->speaker = speaker;
850  caller->mic = mic;
851  e = GNUNET_MQ_msg (resume,
853  resume->cid = caller->cid;
855  e);
856  if (CS_CALLEE_SUSPENDED == caller->state)
857  {
858  caller->state = CS_ACTIVE;
859  caller->speaker->enable_speaker (caller->speaker->cls);
860  caller->mic->enable_microphone (caller->mic->cls,
862  caller);
863  }
864  else
865  {
866  caller->state = CS_CALLER_SUSPENDED;
867  }
868 }
869 
870 
871 /* end of conversation_api.c */
constants for network protocols
CallerState
Possible states of a caller.
@ CS_CALLEE_SUSPENDED
We suspended the conversation.
@ CS_BOTH_SUSPENDED
Both sides suspended the conversation.
@ CS_ACTIVE
The phone is in an active conversation.
@ CS_CALLER_SUSPENDED
Caller suspended the conversation.
@ CS_RINGING
The phone is ringing (user knows about incoming call).
static void clean_up_callers(struct GNUNET_CONVERSATION_Phone *phone)
Clean up all callers of the given phone.
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
static void handle_phone_ring(void *cls, const struct ClientPhoneRingMessage *ring)
We received a struct ClientPhoneRingMessage
static void handle_phone_hangup(void *cls, const struct ClientPhoneHangupMessage *hang)
We received a struct ClientPhoneHangupMessage.
static int check_phone_audio(void *cls, const struct ClientAudioMessage *am)
We received a struct ClientAudioMessage, check it is well-formed.
static void handle_phone_resume(void *cls, const struct ClientPhoneResumeMessage *resume)
We received a struct ClientPhoneResumeMessage.
static void reconnect_phone(struct GNUNET_CONVERSATION_Phone *phone)
The phone got disconnected, reconnect to the service.
static void handle_phone_suspend(void *cls, const struct ClientPhoneSuspendMessage *suspend)
We received a struct ClientPhoneSuspendMessage.
static void phone_error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error talking with the conversation service.
static void transmit_phone_audio(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static void handle_phone_audio(void *cls, const struct ClientAudioMessage *am)
We received a struct ClientAudioMessage
PhoneState
Possible states of a phone.
@ PS_REGISTER
We still need to register the phone.
@ PS_READY
We are waiting for calls.
#define GNUNET_GNSRECORD_TYPE_PHONE
Endpoint for conversation.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static struct Experiment * e
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_SPEAKER_Handle * speaker
Handle to the speaker.
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
static char * line
Desired phone line (string to be converted to a hash).
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
uint32_t data
The data value.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
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:1064
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
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.
void(* GNUNET_CONVERSATION_CallerEventHandler)(void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
Function called with an event emitted by a caller.
void GNUNET_CONVERSATION_caller_suspend(struct GNUNET_CONVERSATION_Caller *caller)
Pause conversation of an active call.
void(* GNUNET_CONVERSATION_PhoneEventHandler)(void *cls, enum GNUNET_CONVERSATION_PhoneEventCode code, struct GNUNET_CONVERSATION_Caller *caller, const struct GNUNET_IDENTITY_PublicKey *caller_id)
Function called with an event emitted by a phone.
void GNUNET_CONVERSATION_phone_destroy(struct GNUNET_CONVERSATION_Phone *phone)
Destroys a phone.
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.
void GNUNET_CONVERSATION_caller_hang_up(struct GNUNET_CONVERSATION_Caller *caller)
Hang up up a (possibly ringing) phone.
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.
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.
@ GNUNET_CONVERSATION_EC_CALLER_RESUME
We are the callee and the caller resumed the call.
@ GNUNET_CONVERSATION_EC_CALLER_SUSPEND
We are the callee and the caller suspended the call.
@ GNUNET_CONVERSATION_EC_PHONE_HUNG_UP
The conversation was terminated by the caller.
@ GNUNET_CONVERSATION_EC_PHONE_RING
We are the callee and the phone is ringing.
int GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host's peer.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_IDENTITY_PublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
@ GNUNET_GNSRECORD_RF_NONE
No special options.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:639
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_Error
Error codes for the queue.
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:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
Client <-> Server message to resume connection.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
Client -> Server message to register a phone.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP
Client -> Server message to reject/hangup a call.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
Client <-> Server message to suspend connection.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
Client -> Server message to reject/hangup a call.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING
Client <- Server message to indicate a ringing phone.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Message Client <-> Service to transmit the audio.
Definition: conversation.h:191
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:195
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:201
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:173
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:183
Client -> Service pick up phone that is ringing.
Definition: conversation.h:154
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:164
Client -> Service message to register a phone.
Definition: conversation.h:73
struct GNUNET_HashCode line_port
Phone line / CADET port to register.
Definition: conversation.h:87
Service <-> Client message for phone was resumed.
Definition: conversation.h:136
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:146
Service -> Client message for phone is ringing.
Definition: conversation.h:95
struct GNUNET_IDENTITY_PublicKey caller_id
Who is calling us?
Definition: conversation.h:110
uint32_t cid
CID, internal caller ID number used in the future to identify which active call we are talking about.
Definition: conversation.h:105
Service <-> Client message for phone was suspended.
Definition: conversation.h:118
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:128
A caller is the handle we have for an incoming call.
uint32_t cid
Internal handle to identify the caller with the service.
struct GNUNET_CONVERSATION_Caller * next
We keep all callers in a DLL.
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
void * event_handler_cls
Closure for event_handler.
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
struct GNUNET_CONVERSATION_Phone * phone
Our phone.
enum CallerState state
State machine for the phone.
struct GNUNET_IDENTITY_PublicKey caller_id
Identity of the person calling us.
struct GNUNET_CONVERSATION_Caller * prev
We keep all callers in a DLL.
GNUNET_CONVERSATION_CallerEventHandler event_handler
Function to call for phone events.
A phone record specifies which peer is hosting a given user and may also specify the phone line that ...
struct GNUNET_HashCode line_port
Phone line (CADET port) to connect to.
struct GNUNET_PeerIdentity peer
Identity of the peer hosting the phone service.
uint32_t version
Version of the phone record, for now always one.
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
struct GNUNET_IDENTITY_PrivateKey my_zone
My GNS zone.
GNUNET_CONVERSATION_PhoneEventHandler event_handler
Function to call for phone events.
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
struct GNUNET_CONVERSATION_Caller * caller_tail
We keep all callers in a DLL.
struct GNUNET_NAMESTORE_Handle * ns
Connection to NAMESTORE (for reverse lookup).
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.
struct GNUNET_CONVERSATION_PhoneRecord my_record
This phone's record.
enum PhoneState state
State machine for the phone.
void * event_handler_cls
Closure for event_handler.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
A 512-bit hashcode.
Handle for an ego.
Definition: identity.h:37
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
A microphone is a device that can capture or otherwise produce audio data.
void * cls
Closure for the callbacks.
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
GNUNET_MICROPHONE_EnableCallback enable_microphone
Turn on the microphone.
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Connection to the NAMESTORE service.
A speaker is a device that can play or record audio data.
void * cls
Closure for the callbacks.
GNUNET_SPEAKER_PlayCallback play
Play audio.
GNUNET_SPEAKER_EnableCallback enable_speaker
Turn on the speaker.
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.