d6/d3a/conversation__api__call_8c_source.html

 /*

    This file is part of GNUnet

    Copyright (C) 2013, 2016 GNUnet e.V.


    GNUnet is free software: you can redistribute it and/or modify it

    under the terms of the GNU Affero General Public License as published

    by the Free Software Foundation, either version 3 of the License,

    or (at your option) any later version.


    GNUnet is distributed in the hope that it will be useful, but

    WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Affero General Public License for more details.


    You should have received a copy of the GNU Affero General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.


      SPDX-License-Identifier: AGPL3.0-or-later

  */


 #include "platform.h"

 #include "gnunet_conversation_service.h"

 #include "gnunet_gnsrecord_lib.h"

 #include "gnunet_gns_service.h"

 #include "conversation.h"


 enum CallState

 {

   CS_LOOKUP = 0,


   CS_RINGING,


   CS_ACTIVE,


   CS_SHUTDOWN,


   CS_SUSPENDED_CALLER,


   CS_SUSPENDED_CALLEE,


   CS_SUSPENDED_BOTH

 };


 struct GNUNET_CONVERSATION_Call

 {

   const struct GNUNET_CONFIGURATION_Handle *cfg;


   struct GNUNET_IDENTITY_Ego *caller_id;


   char *callee;


   struct GNUNET_SPEAKER_Handle *speaker;


   struct GNUNET_MICROPHONE_Handle *mic;


   GNUNET_CONVERSATION_CallEventHandler event_handler;


   void *event_handler_cls;


   struct GNUNET_MQ_Handle *mq;


   struct GNUNET_GNS_Handle *gns;


   struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;


   struct GNUNET_CONVERSATION_PhoneRecord phone_record;


   enum CallState state;

 };


 static void

 fail_call (struct GNUNET_CONVERSATION_Call *call);


 static void

 transmit_call_audio (void *cls,

                      size_t data_size,

                      const void *data)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;

   struct GNUNET_MQ_Envelope *e;

   struct ClientAudioMessage *am;


   GNUNET_assert (CS_ACTIVE == call->state);

   e = GNUNET_MQ_msg_extra (am,

                            data_size,

                            GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);

   GNUNET_memcpy (&am[1],

                  data,

                  data_size);

   GNUNET_MQ_send (call->mq,

                   e);

 }


 static void

 handle_call_suspend (void *cls,

                      const struct ClientPhoneSuspendMessage *msg)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;


   (void) msg;

   switch (call->state)

   {

   case CS_LOOKUP:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_RINGING:

     GNUNET_break_op (0);

     fail_call (call);

     break;


   case CS_SUSPENDED_CALLER:

     call->state = CS_SUSPENDED_BOTH;

     call->event_handler (call->event_handler_cls,

                          GNUNET_CONVERSATION_EC_CALL_SUSPENDED);

     break;


   case CS_SUSPENDED_CALLEE:

   case CS_SUSPENDED_BOTH:

     GNUNET_break_op (0);

     break;


   case CS_ACTIVE:

     call->state = CS_SUSPENDED_CALLEE;

     call->speaker->disable_speaker (call->speaker->cls);

     call->mic->disable_microphone (call->mic->cls);

     call->event_handler (call->event_handler_cls,

                          GNUNET_CONVERSATION_EC_CALL_SUSPENDED);

     break;


   case CS_SHUTDOWN:

     GNUNET_CONVERSATION_call_stop (call);

     break;

   }

 }


 static void

 handle_call_resume (void *cls,

                     const struct ClientPhoneResumeMessage *msg)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;


   (void) msg;

   switch (call->state)

   {

   case CS_LOOKUP:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_RINGING:

     GNUNET_break_op (0);

     fail_call (call);

     break;


   case CS_SUSPENDED_CALLER:

     GNUNET_break_op (0);

     break;


   case CS_SUSPENDED_CALLEE:

     call->state = CS_ACTIVE;

     call->speaker->enable_speaker (call->speaker->cls);

     call->mic->enable_microphone (call->mic->cls,

                                   &transmit_call_audio,

                                   call);

     call->event_handler (call->event_handler_cls,

                          GNUNET_CONVERSATION_EC_CALL_RESUMED);

     break;


   case CS_SUSPENDED_BOTH:

     call->state = CS_SUSPENDED_CALLER;

     call->event_handler (call->event_handler_cls,

                          GNUNET_CONVERSATION_EC_CALL_RESUMED);

     break;


   case CS_ACTIVE:

     GNUNET_break_op (0);

     break;


   case CS_SHUTDOWN:

     GNUNET_CONVERSATION_call_stop (call);

     break;

   }

 }


 static void

 handle_call_picked_up (void *cls,

                        const struct ClientPhonePickedupMessage *msg)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;


   (void) msg;

   switch (call->state)

   {

   case CS_LOOKUP:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_RINGING:

     call->state = CS_ACTIVE;

     call->speaker->enable_speaker (call->speaker->cls);

     call->mic->enable_microphone (call->mic->cls,

                                   &transmit_call_audio,

                                   call);

     call->event_handler (call->event_handler_cls,

                          GNUNET_CONVERSATION_EC_CALL_PICKED_UP);

     break;


   case CS_SUSPENDED_CALLER:

   case CS_SUSPENDED_CALLEE:

   case CS_SUSPENDED_BOTH:

   case CS_ACTIVE:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_SHUTDOWN:

     GNUNET_CONVERSATION_call_stop (call);

     break;

   }

 }


 static void

 handle_call_hangup (void *cls,

                     const struct ClientPhoneHangupMessage *msg)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;

   GNUNET_CONVERSATION_CallEventHandler eh;

   void *eh_cls;


   (void) msg;

   switch (call->state)

   {

   case CS_LOOKUP:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_RINGING:

   case CS_SUSPENDED_CALLER:

   case CS_SUSPENDED_CALLEE:

   case CS_SUSPENDED_BOTH:

   case CS_ACTIVE:

     eh = call->event_handler;

     eh_cls = call->event_handler_cls;

     GNUNET_CONVERSATION_call_stop (call);

     eh (eh_cls,

         GNUNET_CONVERSATION_EC_CALL_HUNG_UP);

     return;


   case CS_SHUTDOWN:

     GNUNET_CONVERSATION_call_stop (call);

     break;

   }

 }


 static int

 check_call_audio (void *cls,

                   const struct ClientAudioMessage *am)

 {

   (void) cls;

   (void) am;

   /* any payload is OK */

   return GNUNET_OK;

 }


 static void

 handle_call_audio (void *cls,

                    const struct ClientAudioMessage *am)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;


   switch (call->state)

   {

   case CS_LOOKUP:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_RINGING:

     GNUNET_break (0);

     fail_call (call);

     break;


   case CS_SUSPENDED_CALLER:

     /* can happen: we suspended, other peer did not yet

        learn about this. */

     break;


   case CS_SUSPENDED_CALLEE:

   case CS_SUSPENDED_BOTH:

     /* can (rarely) also happen: other peer suspended, but cadet might

        have had delayed data on the unreliable channel */

     break;


   case CS_ACTIVE:

     call->speaker->play (call->speaker->cls,

                          ntohs (am->header.size) - sizeof(struct

                                                           ClientAudioMessage),

                          &am[1]);

     break;


   case CS_SHUTDOWN:

     GNUNET_CONVERSATION_call_stop (call);

     break;

   }

 }


 static void

 handle_gns_response (void *cls,

                      int was_gns,

                      uint32_t rd_count,

                      const struct GNUNET_GNSRECORD_Data *rd)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;

   struct GNUNET_MQ_Envelope *e;

   struct ClientCallMessage *ccm;


   (void) was_gns;

   GNUNET_break (NULL != call->gns_lookup);

   GNUNET_break (CS_LOOKUP == call->state);

   call->gns_lookup = NULL;

   for (uint32_t i = 0; i < rd_count; i++)

   {

     if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)

     {

       if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))

       {

         GNUNET_break_op (0);

         continue;

       }

       GNUNET_memcpy (&call->phone_record,

                      rd[i].data,

                      rd[i].data_size);

       e = GNUNET_MQ_msg (ccm,

                          GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);

       ccm->line_port = call->phone_record.line_port;

       ccm->target = call->phone_record.peer;

       ccm->caller_id = *GNUNET_IDENTITY_ego_get_private_key (call->caller_id);

       GNUNET_MQ_send (call->mq,

                       e);

       call->state = CS_RINGING;

       call->event_handler (call->event_handler_cls,

                            GNUNET_CONVERSATION_EC_CALL_RINGING);

       return;

     }

   }

   /* not found */

   call->event_handler (call->event_handler_cls,

                        GNUNET_CONVERSATION_EC_CALL_GNS_FAIL);

   GNUNET_CONVERSATION_call_stop (call);

 }


 static void

 call_error_handler (void *cls,

                     enum GNUNET_MQ_Error error)

 {

   struct GNUNET_CONVERSATION_Call *call = cls;


   (void) error;

   if (CS_SHUTDOWN == call->state)

   {

     GNUNET_CONVERSATION_call_stop (call);

     return;

   }

   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,

               _ (

                 "Connection to conversation service lost, trying to reconnect\n"));

   fail_call (call);

 }


 static void

 fail_call (struct GNUNET_CONVERSATION_Call *call)

 {

   if (CS_ACTIVE == call->state)

   {

     call->speaker->disable_speaker (call->speaker->cls);

     call->mic->disable_microphone (call->mic->cls);

   }

   if (NULL != call->mq)

   {

     GNUNET_MQ_destroy (call->mq);

     call->mq = NULL;

   }

   call->state = CS_SHUTDOWN;

   call->event_handler (call->event_handler_cls,

                        GNUNET_CONVERSATION_EC_CALL_ERROR);

   GNUNET_CONVERSATION_call_stop (call);

 }


 struct GNUNET_CONVERSATION_Call *

 GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg,

                                 struct GNUNET_IDENTITY_Ego *caller_id,

                                 const char *callee,

                                 struct GNUNET_SPEAKER_Handle *speaker,

                                 struct GNUNET_MICROPHONE_Handle *mic,

                                 GNUNET_CONVERSATION_CallEventHandler

                                 event_handler,

                                 void *event_handler_cls)

 {

   struct GNUNET_CONVERSATION_Call *call

     = GNUNET_new (struct GNUNET_CONVERSATION_Call);

   struct GNUNET_MQ_MessageHandler handlers[] = {

     GNUNET_MQ_hd_fixed_size (call_suspend,

                              GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,

                              struct ClientPhoneSuspendMessage,

                              call),

     GNUNET_MQ_hd_fixed_size (call_resume,

                              GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,

                              struct ClientPhoneResumeMessage,

                              call),

     GNUNET_MQ_hd_fixed_size (call_picked_up,

                              GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP,

                              struct ClientPhonePickedupMessage,

                              call),

     GNUNET_MQ_hd_fixed_size (call_hangup,

                              GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,

                              struct ClientPhoneHangupMessage,

                              call),

     GNUNET_MQ_hd_var_size (call_audio,

                            GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,

                            struct ClientAudioMessage,

                            call),

     GNUNET_MQ_handler_end ()

   };


   call->mq = GNUNET_CLIENT_connect (cfg,

                                     "conversation",

                                     handlers,

                                     &call_error_handler,

                                     call);

   if (NULL == call->mq)

   {

     GNUNET_break (0);

     GNUNET_free (call);

     return NULL;

   }

   call->cfg = cfg;

   call->caller_id = caller_id;

   call->callee = GNUNET_strdup (callee);

   call->speaker = speaker;

   call->mic = mic;

   call->event_handler = event_handler;

   call->event_handler_cls = event_handler_cls;

   call->gns = GNUNET_GNS_connect (cfg);

   if (NULL == call->gns)

   {

     GNUNET_CONVERSATION_call_stop (call);

     return NULL;

   }

   call->state = CS_LOOKUP;

   call->gns_lookup = GNUNET_GNS_lookup_with_tld (call->gns,

                                                  call->callee,

                                                  GNUNET_GNSRECORD_TYPE_PHONE,

                                                  GNUNET_NO,

                                                  &handle_gns_response,

                                                  call);

   if (NULL == call->gns_lookup)

   {

     GNUNET_CONVERSATION_call_stop (call);

     return NULL;

   }

   return call;

 }


 void

 GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)

 {

   if ((NULL != call->speaker) &&

       (CS_ACTIVE == call->state))

     call->speaker->disable_speaker (call->speaker->cls);

   if ((NULL != call->mic) &&

       (CS_ACTIVE == call->state))

     call->mic->disable_microphone (call->mic->cls);

   if (CS_SHUTDOWN != call->state)

   {

     call->state = CS_SHUTDOWN;

   }

   if (NULL != call->mq)

   {

     GNUNET_MQ_destroy (call->mq);

     call->mq = NULL;

   }

   if (NULL != call->gns_lookup)

   {

     GNUNET_GNS_lookup_with_tld_cancel (call->gns_lookup);

     call->gns_lookup = NULL;

   }

   if (NULL != call->gns)

   {

     GNUNET_GNS_disconnect (call->gns);

     call->gns = NULL;

   }

   GNUNET_free (call->callee);

   GNUNET_free (call);

 }


 void

 GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)

 {

   struct GNUNET_MQ_Envelope *e;

   struct ClientPhoneSuspendMessage *suspend;


   GNUNET_assert ((CS_SUSPENDED_CALLEE == call->state) ||

                  (CS_ACTIVE == call->state));

   if (CS_ACTIVE == call->state)

   {

     call->speaker->disable_speaker (call->speaker->cls);

     call->mic->disable_microphone (call->mic->cls);

   }

   call->speaker = NULL;

   call->mic = NULL;

   e = GNUNET_MQ_msg (suspend,

                      GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);

   GNUNET_MQ_send (call->mq,

                   e);

   if (CS_SUSPENDED_CALLER == call->state)

     call->state = CS_SUSPENDED_BOTH;

   else

     call->state = CS_SUSPENDED_CALLER;

 }


 void

 GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call,

                                  struct GNUNET_SPEAKER_Handle *speaker,

                                  struct GNUNET_MICROPHONE_Handle *mic)

 {

   struct GNUNET_MQ_Envelope *e;

   struct ClientPhoneResumeMessage *resume;


   GNUNET_assert ((CS_SUSPENDED_CALLER == call->state) ||

                  (CS_SUSPENDED_BOTH == call->state));

   e = GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);

   GNUNET_MQ_send (call->mq, e);

   call->speaker = speaker;

   call->mic = mic;

   if (CS_SUSPENDED_CALLER == call->state)

   {

     call->state = CS_ACTIVE;

     call->speaker->enable_speaker (call->speaker->cls);

     call->mic->enable_microphone (call->mic->cls,

                                   &transmit_call_audio,

                                   call);

   }

   else

   {

     call->state = CS_SUSPENDED_CALLEE;

   }

 }


 /* end of conversation_api_call.c */

msg
struct GNUNET_MessageHeader * msg
Definition: 005.c:2

GNUNET_GNSRECORD_TYPE_PHONE
#define GNUNET_GNSRECORD_TYPE_PHONE
Endpoint for conversation.
Definition: gnu_name_system_record_types.h:85

conversation.h
constants for network protocols

fail_call
static void fail_call(struct GNUNET_CONVERSATION_Call *call)
The call got disconnected, reconnect to the service.
Definition: conversation_api_call.c:526

handle_call_audio
static void handle_call_audio(void *cls, const struct ClientAudioMessage *am)
We received a struct ClientAudioMessage
Definition: conversation_api_call.c:399

check_call_audio
static int check_call_audio(void *cls, const struct ClientAudioMessage *am)
We received a struct ClientAudioMessage, check it is well-formed.
Definition: conversation_api_call.c:382

handle_call_picked_up
static void handle_call_picked_up(void *cls, const struct ClientPhonePickedupMessage *msg)
We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP.
Definition: conversation_api_call.c:295

handle_call_hangup
static void handle_call_hangup(void *cls, const struct ClientPhoneHangupMessage *msg)
We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP.
Definition: conversation_api_call.c:340

handle_gns_response
static void handle_gns_response(void *cls, int was_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Iterator called on obtained result for a GNS lookup.
Definition: conversation_api_call.c:450

transmit_call_audio
static void transmit_call_audio(void *cls, size_t data_size, const void *data)
Process recorded audio data.
Definition: conversation_api_call.c:161

CallState
CallState
Possible states of the phone.
Definition: conversation_api_call.c:39

CS_LOOKUP
@ CS_LOOKUP
We still need to lookup the callee.
Definition: conversation_api_call.c:43

CS_SUSPENDED_CALLEE
@ CS_SUSPENDED_CALLEE
The call was suspended by the callee.
Definition: conversation_api_call.c:68

CS_SHUTDOWN
@ CS_SHUTDOWN
The call is in termination.
Definition: conversation_api_call.c:58

CS_SUSPENDED_CALLER
@ CS_SUSPENDED_CALLER
The call was suspended by the caller.
Definition: conversation_api_call.c:63

CS_SUSPENDED_BOTH
@ CS_SUSPENDED_BOTH
The call was suspended by both caller and callee.
Definition: conversation_api_call.c:73

CS_ACTIVE
@ CS_ACTIVE
The call is in an active conversation.
Definition: conversation_api_call.c:53

CS_RINGING
@ CS_RINGING
The call is ringing.
Definition: conversation_api_call.c:48

handle_call_resume
static void handle_call_resume(void *cls, const struct ClientPhoneResumeMessage *msg)
We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME.
Definition: conversation_api_call.c:239

handle_call_suspend
static void handle_call_suspend(void *cls, const struct ClientPhoneSuspendMessage *msg)
We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND.
Definition: conversation_api_call.c:188

call_error_handler
static void call_error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error talking with the conversation service.
Definition: conversation_api_call.c:502

cfg
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36

data_size
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187

e
static struct Experiment * e
Definition: gnunet-ats-solver-eval.c:40

handlers
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Definition: gnunet-cadet-profiler.c:802

speaker
static struct GNUNET_SPEAKER_Handle * speaker
Handle to the speaker.
Definition: gnunet-conversation-test.c:72

call
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
Definition: gnunet-conversation.c:136

mic
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
Definition: gnunet-conversation.c:172

data
uint32_t data
The data value.
Definition: gnunet-helper-transport-wlan.c:21

gnunet_conversation_service.h
API to the conversation service.

gnunet_gns_service.h
API to the GNS service.

gnunet_gnsrecord_lib.h
API that can be used to manipulate GNS record data.

GNUNET_CLIENT_connect
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:1055

GNUNET_CONVERSATION_call_start
struct GNUNET_CONVERSATION_Call * GNUNET_CONVERSATION_call_start(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_IDENTITY_Ego *caller_id, const char *callee, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic, GNUNET_CONVERSATION_CallEventHandler event_handler, void *event_handler_cls)
Call the phone of another user.
Definition: conversation_api_call.c:561

GNUNET_CONVERSATION_call_suspend
void GNUNET_CONVERSATION_call_suspend(struct GNUNET_CONVERSATION_Call *call)
Pause a call.
Definition: conversation_api_call.c:681

GNUNET_CONVERSATION_call_resume
void GNUNET_CONVERSATION_call_resume(struct GNUNET_CONVERSATION_Call *call, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
Resumes a call after GNUNET_CONVERSATION_call_suspend.
Definition: conversation_api_call.c:715

GNUNET_CONVERSATION_call_stop
void GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call)
Terminate a call.
Definition: conversation_api_call.c:642

GNUNET_CONVERSATION_CallEventHandler
void(* GNUNET_CONVERSATION_CallEventHandler)(void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
Function called with an event emitted for a call.
Definition: gnunet_conversation_service.h:371

GNUNET_CONVERSATION_EC_CALL_SUSPENDED
@ GNUNET_CONVERSATION_EC_CALL_SUSPENDED
We are the caller and the callee suspended the call.
Definition: gnunet_conversation_service.h:346

GNUNET_CONVERSATION_EC_CALL_GNS_FAIL
@ GNUNET_CONVERSATION_EC_CALL_GNS_FAIL
We are the caller and failed to locate a phone record in GNS.
Definition: gnunet_conversation_service.h:331

GNUNET_CONVERSATION_EC_CALL_PICKED_UP
@ GNUNET_CONVERSATION_EC_CALL_PICKED_UP
We are the caller and are now ready to talk as the callee picked up.
Definition: gnunet_conversation_service.h:322

GNUNET_CONVERSATION_EC_CALL_RESUMED
@ GNUNET_CONVERSATION_EC_CALL_RESUMED
We are the caller and the callee suspended the call.
Definition: gnunet_conversation_service.h:353

GNUNET_CONVERSATION_EC_CALL_RINGING
@ GNUNET_CONVERSATION_EC_CALL_RINGING
We are the caller and are now ringing the other party (GNS lookup succeeded).
Definition: gnunet_conversation_service.h:317

GNUNET_CONVERSATION_EC_CALL_ERROR
@ GNUNET_CONVERSATION_EC_CALL_ERROR
We had an error handing the call, and are now restarting it (back to lookup).
Definition: gnunet_conversation_service.h:360

GNUNET_CONVERSATION_EC_CALL_HUNG_UP
@ GNUNET_CONVERSATION_EC_CALL_HUNG_UP
We are the caller and the callee called GNUNET_CONVERSATION_caller_hang_up.
Definition: gnunet_conversation_service.h:339

GNUNET_GNS_disconnect
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
Definition: gns_api.c:290

GNUNET_GNS_lookup_with_tld_cancel
void * GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
Cancel pending lookup request.
Definition: gns_tld_api.c:332

GNUNET_GNS_lookup_with_tld
struct GNUNET_GNS_LookupWithTldRequest * GNUNET_GNS_lookup_with_tld(struct GNUNET_GNS_Handle *handle, const char *name, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor2 proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given ...
Definition: gns_tld_api.c:241

GNUNET_GNS_connect
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
Definition: gns_api.c:268

GNUNET_IDENTITY_ego_get_private_key
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

GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:558

GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition: gnunet_common.h:1284

GNUNET_OK
@ GNUNET_OK
Definition: gnunet_common.h:99

GNUNET_NO
@ GNUNET_NO
Definition: gnunet_common.h:98

GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition: gnunet_common.h:1036

GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:933

GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Definition: gnunet_common.h:1014

GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition: gnunet_common.h:428

GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition: gnunet_common.h:1416

GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition: gnunet_common.h:1204

GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1402

GNUNET_MQ_Error
GNUNET_MQ_Error
Error codes for the queue.
Definition: gnunet_mq_lib.h:196

GNUNET_MQ_send
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:302

GNUNET_MQ_handler_end
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Definition: gnunet_mq_lib.h:525

GNUNET_MQ_msg_extra
#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:56

GNUNET_MQ_msg
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:71

GNUNET_MQ_hd_var_size
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Definition: gnunet_mq_lib.h:610

GNUNET_MQ_hd_fixed_size
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
Definition: gnunet_mq_lib.h:559

GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
Client <-> Server message to resume connection.
Definition: gnunet_protocols.h:2439

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
Client <-> Server message to suspend connection.
Definition: gnunet_protocols.h:2434

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP
Service -> Client message to notify that phone was picked up.
Definition: gnunet_protocols.h:2444

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
Client -> Server message to reject/hangup a call.
Definition: gnunet_protocols.h:2419

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
Definition: gnunet_protocols.h:2449

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
Client <- Server message to indicate a ringing phone.
Definition: gnunet_protocols.h:2424

platform.h

_
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

ClientAudioMessage
Message Client <-> Service to transmit the audio.
Definition: conversation.h:191

ClientAudioMessage::header
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:195

ClientCallMessage
Client -> Service message to call a phone.
Definition: conversation.h:211

ClientCallMessage::line_port
struct GNUNET_HashCode line_port
Which phone line to call at the peer?
Definition: conversation.h:230

ClientCallMessage::caller_id
struct GNUNET_IDENTITY_PrivateKey caller_id
Identity of the caller.
Definition: conversation.h:235

ClientCallMessage::target
struct GNUNET_PeerIdentity target
Which peer is hosting the line?
Definition: conversation.h:225

ClientPhoneHangupMessage
Client <-> Service hang up phone that may or may not be ringing.
Definition: conversation.h:173

ClientPhonePickedupMessage
Service -> Client: other peer has picked up the phone, we are now talking.
Definition: conversation.h:244

ClientPhoneResumeMessage
Service <-> Client message for phone was resumed.
Definition: conversation.h:136

ClientPhoneSuspendMessage
Service <-> Client message for phone was suspended.
Definition: conversation.h:118

GNUNET_CONFIGURATION_Handle
configuration data
Definition: configuration.c:153

GNUNET_CONVERSATION_Call
Handle for an outgoing call.
Definition: conversation_api_call.c:81

GNUNET_CONVERSATION_Call::event_handler_cls
void * event_handler_cls
Closure for event_handler.
Definition: conversation_api_call.c:115

GNUNET_CONVERSATION_Call::callee
char * callee
Target callee as a GNS address/name.
Definition: conversation_api_call.c:95

GNUNET_CONVERSATION_Call::gns_lookup
struct GNUNET_GNS_LookupWithTldRequest * gns_lookup
Active GNS lookup (or NULL).
Definition: conversation_api_call.c:130

GNUNET_CONVERSATION_Call::gns
struct GNUNET_GNS_Handle * gns
Connection to GNS (can be NULL).
Definition: conversation_api_call.c:125

GNUNET_CONVERSATION_Call::mic
struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
Definition: conversation_api_call.c:105

GNUNET_CONVERSATION_Call::state
enum CallState state
State machine for the call.
Definition: conversation_api_call.c:140

GNUNET_CONVERSATION_Call::mq
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
Definition: conversation_api_call.c:120

GNUNET_CONVERSATION_Call::speaker
struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
Definition: conversation_api_call.c:100

GNUNET_CONVERSATION_Call::phone_record
struct GNUNET_CONVERSATION_PhoneRecord phone_record
Target phone record, only valid after the lookup is done.
Definition: conversation_api_call.c:135

GNUNET_CONVERSATION_Call::cfg
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: conversation_api_call.c:85

GNUNET_CONVERSATION_Call::event_handler
GNUNET_CONVERSATION_CallEventHandler event_handler
Function to call with events.
Definition: conversation_api_call.c:110

GNUNET_CONVERSATION_Call::caller_id
struct GNUNET_IDENTITY_Ego * caller_id
Our caller identity.
Definition: conversation_api_call.c:90

GNUNET_CONVERSATION_PhoneRecord
A phone record specifies which peer is hosting a given user and may also specify the phone line that ...
Definition: gnunet_conversation_service.h:93

GNUNET_CONVERSATION_PhoneRecord::line_port
struct GNUNET_HashCode line_port
Phone line (CADET port) to connect to.
Definition: gnunet_conversation_service.h:114

GNUNET_CONVERSATION_PhoneRecord::peer
struct GNUNET_PeerIdentity peer
Identity of the peer hosting the phone service.
Definition: gnunet_conversation_service.h:109

GNUNET_GNSRECORD_Data
A GNS record.
Definition: gnunet_gnsrecord_lib.h:161

GNUNET_GNSRECORD_Data::data
const void * data
Binary value stored in the DNS record.
Definition: gnunet_gnsrecord_lib.h:167

GNUNET_GNSRECORD_Data::data_size
size_t data_size
Number of bytes in data.
Definition: gnunet_gnsrecord_lib.h:179

GNUNET_GNS_Handle
Connection to the GNS service.
Definition: gns_api.h:36

GNUNET_GNS_LookupWithTldRequest
Handle to a lookup request.
Definition: gns_tld_api.c:45

GNUNET_IDENTITY_Ego
Handle for an ego.
Definition: identity.h:37

GNUNET_MICROPHONE_Handle
A microphone is a device that can capture or otherwise produce audio data.
Definition: gnunet_microphone_lib.h:92

GNUNET_MICROPHONE_Handle::cls
void * cls
Closure for the callbacks.
Definition: gnunet_microphone_lib.h:111

GNUNET_MICROPHONE_Handle::disable_microphone
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
Definition: gnunet_microphone_lib.h:101

GNUNET_MICROPHONE_Handle::enable_microphone
GNUNET_MICROPHONE_EnableCallback enable_microphone
Turn on the microphone.
Definition: gnunet_microphone_lib.h:96

GNUNET_MQ_Envelope
Definition: mq.c:33

GNUNET_MQ_Handle
Handle to a message queue.
Definition: mq.c:86

GNUNET_MQ_MessageHandler
Message handler for a specific message type.
Definition: gnunet_mq_lib.h:485

GNUNET_MessageHeader::size
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Definition: gnunet_common.h:315

GNUNET_SPEAKER_Handle
A speaker is a device that can play or record audio data.
Definition: gnunet_speaker_lib.h:88

GNUNET_SPEAKER_Handle::cls
void * cls
Closure for the callbacks.
Definition: gnunet_speaker_lib.h:112

GNUNET_SPEAKER_Handle::play
GNUNET_SPEAKER_PlayCallback play
Play audio.
Definition: gnunet_speaker_lib.h:97

GNUNET_SPEAKER_Handle::enable_speaker
GNUNET_SPEAKER_EnableCallback enable_speaker
Turn on the speaker.
Definition: gnunet_speaker_lib.h:92

GNUNET_SPEAKER_Handle::disable_speaker
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.
Definition: gnunet_speaker_lib.h:102