GNUnet  0.19.3
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 
247 static enum GNUNET_GenericReturnValue
248 check_phone_ring (void *cls,
249  const struct ClientPhoneRingMessage *ring)
250 {
251  //FIXME
252  return GNUNET_OK;
253 }
260 static void
261 handle_phone_ring (void *cls,
262  const struct ClientPhoneRingMessage *ring)
263 {
264  struct GNUNET_CONVERSATION_Phone *phone = cls;
265  struct GNUNET_CONVERSATION_Caller *caller;
266  struct GNUNET_IDENTITY_PublicKey caller_id;
267  size_t key_len;
268  size_t read;
269 
270  key_len = ntohl (ring->key_len);
271  switch (phone->state)
272  {
273  case PS_REGISTER:
274  GNUNET_assert (0);
275  break;
276 
277  case PS_READY:
278  if ((GNUNET_SYSERR ==
280  key_len,
281  &caller_id,
282  &read)) ||
283  (read != key_len))
284  {
285  GNUNET_break (0);
286  break;
287  }
288  caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
289  caller->phone = phone;
292  caller);
293  caller->caller_id = caller_id;
294  caller->cid = ring->cid;
295  caller->state = CS_RINGING;
298  caller,
299  &caller->caller_id);
300  break;
301  }
302 }
303 
304 
312 static struct GNUNET_CONVERSATION_Caller *
314  uint32_t cid)
315 {
316  struct GNUNET_CONVERSATION_Caller *caller;
317 
318  for (caller = phone->caller_head; NULL != caller; caller = caller->next)
319  if (cid == caller->cid)
320  return caller;
321  return NULL;
322 }
323 
324 
331 static void
333  const struct ClientPhoneHangupMessage *hang)
334 {
335  struct GNUNET_CONVERSATION_Phone *phone = cls;
336  struct GNUNET_CONVERSATION_Caller *caller;
337 
338  caller = find_caller (phone,
339  hang->cid);
340  if (NULL == caller)
341  {
343  "Received HANG_UP message for unknown caller ID %u\n",
344  (unsigned int) hang->cid);
345  return;
346  }
347 
349  "Received HANG_UP message, terminating call with `%s'\n",
351  switch (caller->state)
352  {
353  case CS_RINGING:
356  caller,
357  &caller->caller_id);
358  break;
359 
360  case CS_ACTIVE:
361  caller->speaker->disable_speaker (caller->speaker->cls);
362  caller->mic->disable_microphone (caller->mic->cls);
365  caller,
366  &caller->caller_id);
367  break;
368 
369  case CS_CALLEE_SUSPENDED:
370  case CS_CALLER_SUSPENDED:
371  case CS_BOTH_SUSPENDED:
374  caller,
375  &caller->caller_id);
376  break;
377  }
380  caller);
381  GNUNET_free (caller);
382 }
383 
384 
391 static void
393  const struct ClientPhoneSuspendMessage *suspend)
394 {
395  struct GNUNET_CONVERSATION_Phone *phone = cls;
396  struct GNUNET_CONVERSATION_Caller *caller;
397 
398  caller = find_caller (phone,
399  suspend->cid);
400  if (NULL == caller)
401  return;
402  switch (caller->state)
403  {
404  case CS_RINGING:
405  GNUNET_break_op (0);
406  break;
407 
408  case CS_ACTIVE:
409  caller->state = CS_CALLER_SUSPENDED;
410  caller->speaker->disable_speaker (caller->speaker->cls);
411  caller->mic->disable_microphone (caller->mic->cls);
412  caller->event_handler (caller->event_handler_cls,
414  break;
415 
416  case CS_CALLEE_SUSPENDED:
417  caller->state = CS_BOTH_SUSPENDED;
418  caller->event_handler (caller->event_handler_cls,
420  break;
421 
422  case CS_CALLER_SUSPENDED:
423  case CS_BOTH_SUSPENDED:
424  GNUNET_break_op (0);
425  break;
426  }
427 }
428 
429 
436 static void
438  const struct ClientPhoneResumeMessage *resume)
439 {
440  struct GNUNET_CONVERSATION_Phone *phone = cls;
441  struct GNUNET_CONVERSATION_Caller *caller;
442 
443  caller = find_caller (phone,
444  resume->cid);
445  if (NULL == caller)
446  return;
447  switch (caller->state)
448  {
449  case CS_RINGING:
450  GNUNET_break_op (0);
451  break;
452 
453  case CS_ACTIVE:
454  case CS_CALLEE_SUSPENDED:
455  GNUNET_break_op (0);
456  break;
457 
458  case CS_CALLER_SUSPENDED:
459  caller->state = CS_ACTIVE;
460  caller->speaker->enable_speaker (caller->speaker->cls);
461  caller->mic->enable_microphone (caller->mic->cls,
463  caller);
464  caller->event_handler (caller->event_handler_cls,
466  break;
467 
468  case CS_BOTH_SUSPENDED:
469  caller->state = CS_CALLEE_SUSPENDED;
470  caller->event_handler (caller->event_handler_cls,
472  break;
473  }
474 }
475 
476 
484 static int
485 check_phone_audio (void *cls,
486  const struct ClientAudioMessage *am)
487 {
488  (void) cls;
489  (void) am;
490 
491  /* any variable-size payload is OK */
492  return GNUNET_OK;
493 }
494 
495 
502 static void
504  const struct ClientAudioMessage *am)
505 {
506  struct GNUNET_CONVERSATION_Phone *phone = cls;
507  struct GNUNET_CONVERSATION_Caller *caller;
508 
509  caller = find_caller (phone,
510  am->cid);
511  if (NULL == caller)
512  return;
513  switch (caller->state)
514  {
515  case CS_RINGING:
516  GNUNET_break_op (0);
517  break;
518 
519  case CS_ACTIVE:
520  caller->speaker->play (caller->speaker->cls,
521  ntohs (am->header.size) - sizeof(struct
523  &am[1]);
524  break;
525 
526  case CS_CALLEE_SUSPENDED:
527  case CS_CALLER_SUSPENDED:
528  case CS_BOTH_SUSPENDED:
529  break;
530  }
531 }
532 
533 
540 static void
542  enum GNUNET_MQ_Error error)
543 {
544  struct GNUNET_CONVERSATION_Phone *phone = cls;
545 
546  (void) error;
548  _ (
549  "Connection to conversation service lost, trying to reconnect\n"));
551 }
552 
553 
559 static void
561 {
562  struct GNUNET_CONVERSATION_Caller *caller;
563 
564  while (NULL != (caller = phone->caller_head))
565  {
566  /* make sure mic/speaker are disabled *before* callback */
567  if (CS_ACTIVE == caller->state)
568  {
569  caller->speaker->disable_speaker (caller->speaker->cls);
570  caller->mic->disable_microphone (caller->mic->cls);
571  caller->state = CS_CALLER_SUSPENDED;
572  }
575  caller,
576  &caller->caller_id);
578  }
579 }
580 
581 
587 static void
589 {
591  GNUNET_MQ_hd_var_size (phone_ring,
593  struct ClientPhoneRingMessage,
594  phone),
595  GNUNET_MQ_hd_fixed_size (phone_hangup,
598  phone),
599  GNUNET_MQ_hd_fixed_size (phone_suspend,
602  phone),
603  GNUNET_MQ_hd_fixed_size (phone_resume,
606  phone),
607  GNUNET_MQ_hd_var_size (phone_audio,
609  struct ClientAudioMessage,
610  phone),
612  };
613  struct GNUNET_MQ_Envelope *e;
614  struct ClientPhoneRegisterMessage *reg;
615 
617  if (NULL != phone->mq)
618  {
620  phone->mq = NULL;
621  }
624  "conversation",
625  handlers,
627  phone);
628  if (NULL == phone->mq)
629  return;
630  e = GNUNET_MQ_msg (reg,
634  e);
635  phone->state = PS_READY;
636 }
637 
638 
651  const struct GNUNET_IDENTITY_Ego *ego,
654  void *event_handler_cls)
655 {
657  char *line;
658  struct GNUNET_HashCode line_port;
659 
660  if (GNUNET_OK !=
662  "CONVERSATION",
663  "LINE",
664  &line))
665  {
667  "CONVERSATION",
668  "LINE");
669  return NULL;
670  }
672  strlen (line),
673  &line_port);
674  GNUNET_free (line);
676  if (GNUNET_OK !=
678  &phone->my_record.peer))
679  {
680  GNUNET_break (0);
681  GNUNET_free (phone);
682  return NULL;
683  }
684  phone->cfg = cfg;
686  phone->event_handler = event_handler;
687  phone->event_handler_cls = event_handler_cls;
689  phone->my_record.version = htonl (1);
690  phone->my_record.reserved = htonl (0);
691  phone->my_record.line_port = line_port;
693  if ((NULL == phone->mq) ||
694  (NULL == phone->ns))
695  {
696  GNUNET_break (0);
698  return NULL;
699  }
700  return phone;
701 }
702 
703 
712 void
714  struct GNUNET_GNSRECORD_Data *rd)
715 {
716  rd->data = &phone->my_record;
717  rd->expiration_time = 0;
718  rd->data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
721 }
722 
723 
734 void
737  event_handler,
738  void *event_handler_cls,
741 {
742  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
743  struct GNUNET_MQ_Envelope *e;
744  struct ClientPhonePickupMessage *pick;
745 
746  GNUNET_assert (CS_RINGING == caller->state);
747  caller->speaker = speaker;
748  caller->mic = mic;
749  e = GNUNET_MQ_msg (pick,
751  pick->cid = caller->cid;
753  e);
754  caller->state = CS_ACTIVE;
755  caller->event_handler = event_handler;
756  caller->event_handler_cls = event_handler_cls;
757  caller->speaker->enable_speaker (caller->speaker->cls);
758  caller->mic->enable_microphone (caller->mic->cls,
760  caller);
761 }
762 
763 
770 void
772 {
773  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
774  struct GNUNET_MQ_Envelope *e;
775  struct ClientPhoneHangupMessage *hang;
776 
777  switch (caller->state)
778  {
779  case CS_ACTIVE:
780  caller->speaker->disable_speaker (caller->speaker->cls);
781  caller->mic->disable_microphone (caller->mic->cls);
782  break;
783 
784  default:
785  break;
786  }
789  caller);
790  e = GNUNET_MQ_msg (hang,
792  hang->cid = caller->cid;
794  e);
795  GNUNET_free (caller);
796 }
797 
798 
804 void
806 {
808  if (NULL != phone->ns)
809  {
811  phone->ns = NULL;
812  }
813  if (NULL != phone->mq)
814  {
816  phone->mq = NULL;
817  }
818  GNUNET_free (phone);
819 }
820 
821 
829 void
831 {
832  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
833  struct GNUNET_MQ_Envelope *e;
834  struct ClientPhoneSuspendMessage *suspend;
835 
836  GNUNET_assert ((CS_ACTIVE == caller->state) ||
837  (CS_CALLER_SUSPENDED == caller->state));
838  if (CS_ACTIVE == caller->state)
839  {
840  caller->speaker->disable_speaker (caller->speaker->cls);
841  caller->mic->disable_microphone (caller->mic->cls);
842  }
843  caller->speaker = NULL;
844  caller->mic = NULL;
845  e = GNUNET_MQ_msg (suspend,
847  suspend->cid = caller->cid;
849  e);
850  if (CS_ACTIVE == caller->state)
851  caller->state = CS_CALLEE_SUSPENDED;
852  else
853  caller->state = CS_BOTH_SUSPENDED;
854 }
855 
856 
864 void
868 {
869  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
870  struct GNUNET_MQ_Envelope *e;
871  struct ClientPhoneResumeMessage *resume;
872 
873  GNUNET_assert ((CS_CALLEE_SUSPENDED == caller->state) ||
874  (CS_BOTH_SUSPENDED == caller->state));
875  caller->speaker = speaker;
876  caller->mic = mic;
877  e = GNUNET_MQ_msg (resume,
879  resume->cid = caller->cid;
881  e);
882  if (CS_CALLEE_SUSPENDED == caller->state)
883  {
884  caller->state = CS_ACTIVE;
885  caller->speaker->enable_speaker (caller->speaker->cls);
886  caller->mic->enable_microphone (caller->mic->cls,
888  caller);
889  }
890  else
891  {
892  caller->state = CS_CALLER_SUSPENDED;
893  }
894 }
895 
896 
897 /* end of conversation_api.c */
#define GNUNET_GNSRECORD_TYPE_PHONE
Endpoint for conversation.
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 enum GNUNET_GenericReturnValue check_phone_ring(void *cls, const struct ClientPhoneRingMessage *ring)
We received a struct ClientPhoneRingMessage
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.
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.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
API to the conversation service.
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:1057
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_GNSRECORD_RF_NONE
Entry for no flags / cleared flags.
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.
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:560
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
Definition: identity_api.c:865
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_SYSERR
#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:304
#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:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#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:683
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:195
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:199
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition: conversation.h:205
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:177
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:187
Client -> Service pick up phone that is ringing.
Definition: conversation.h:158
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:168
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:140
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:150
Service -> Client message for phone is ringing.
Definition: conversation.h:95
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
uint32_t key_len
The identity key length.
Definition: conversation.h:110
Service <-> Client message for phone was suspended.
Definition: conversation.h:122
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition: conversation.h:132
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:87
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.