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;

  const struct GNUNET_CRYPTO_PrivateKey *caller_id;

  size_t key_len;


  (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);

      caller_id = GNUNET_IDENTITY_ego_get_private_key (call->caller_id);

      key_len = GNUNET_CRYPTO_private_key_get_length (caller_id);

      e = GNUNET_MQ_msg_extra (ccm, key_len,

                               GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);

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

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

      GNUNET_CRYPTO_write_private_key_to_buffer (caller_id,

                                                   &ccm[1], key_len);

      ccm->key_len = htonl (key_len);

      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_GNS_LO_DEFAULT,

                                                 &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 */

handlers
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1

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

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:532

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:508

cfg
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109

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
static char * data
The data to insert into the dht.
Definition: gnunet-dht-put.c:88

rd_count
static unsigned int rd_count
Number of records for currently parsed set.
Definition: gnunet-namestore-zonefile.c:61

rd
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
Definition: gnunet-namestore-zonefile.c:46

data_size
static size_t data_size
Number of bytes in data.
Definition: gnunet-namestore.c:315

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:1057

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

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:721

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:567

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

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:372

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:347

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:332

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:323

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:354

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:318

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:361

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:340

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

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:240

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:331

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:267

GNUNET_GNS_LO_DEFAULT
@ GNUNET_GNS_LO_DEFAULT
Defaults, look in cache, then in DHT.
Definition: gnunet_gns_service.h:110

GNUNET_IDENTITY_ego_get_private_key
const struct GNUNET_CRYPTO_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:517

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

GNUNET_CRYPTO_private_key_get_length
ssize_t GNUNET_CRYPTO_private_key_get_length(const struct GNUNET_CRYPTO_PrivateKey *key)
Get the compacted length of a GNUNET_CRYPTO_PrivateKey.
Definition: crypto_pkey.c:47

GNUNET_CRYPTO_write_private_key_to_buffer
ssize_t GNUNET_CRYPTO_write_private_key_to_buffer(const struct GNUNET_CRYPTO_PrivateKey *key, void *buffer, size_t len)
Writes a GNUNET_CRYPTO_PrivateKey to a compact buffer.
Definition: crypto_pkey.c:171

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

GNUNET_OK
@ GNUNET_OK
Definition: gnunet_common.h:109

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

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

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:1018

GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition: gnunet_common.h:432

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

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

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

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

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:304

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

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:63

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

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

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

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

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:178

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

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

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

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

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

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

ClientCallMessage::key_len
uint32_t key_len
The identity key length.
Definition: conversation.h:239

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

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

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

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

GNUNET_CONFIGURATION_Handle
configuration data
Definition: configuration.c:149

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:94

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

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

GNUNET_CRYPTO_PrivateKey
A private key for an identity as per LSD0001.
Definition: gnunet_crypto_lib.h:387

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

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

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

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:44

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:93

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

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

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

GNUNET_MQ_Envelope
Definition: mq.c:34

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

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

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:319

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

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

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

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

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