d2/d53/conversation__api_8c_source.html

/*

   This file is part of GNUnet

   Copyright (C) 2013, 2014 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 "conversation.h"


enum CallerState

{

  CS_RINGING,


  CS_ACTIVE,


  CS_CALLEE_SUSPENDED,


  CS_CALLER_SUSPENDED,


  CS_BOTH_SUSPENDED

};


struct GNUNET_CONVERSATION_Caller

{

  struct GNUNET_CONVERSATION_Caller *next;


  struct GNUNET_CONVERSATION_Caller *prev;


  struct GNUNET_CONVERSATION_Phone *phone;


  GNUNET_CONVERSATION_CallerEventHandler event_handler;


  void *event_handler_cls;


  struct GNUNET_SPEAKER_Handle *speaker;


  struct GNUNET_MICROPHONE_Handle *mic;


  struct GNUNET_CRYPTO_BlindablePublicKey caller_id;


  uint32_t cid;


  enum CallerState state;

};


enum PhoneState

{

  PS_REGISTER = 0,


  PS_READY

};


struct GNUNET_CONVERSATION_Phone

{

  const struct GNUNET_CONFIGURATION_Handle *cfg;


  struct GNUNET_CONVERSATION_Caller *caller_head;


  struct GNUNET_CONVERSATION_Caller *caller_tail;


  GNUNET_CONVERSATION_PhoneEventHandler event_handler;


  void *event_handler_cls;


  struct GNUNET_NAMESTORE_Handle *ns;


  struct GNUNET_MQ_Handle *mq;


  struct GNUNET_CONVERSATION_PhoneRecord my_record;


  struct GNUNET_CRYPTO_BlindablePrivateKey my_zone;


  enum PhoneState state;

};


static void

reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone);


static void


transmit_phone_audio (void *cls,

                      size_t data_size,

                      const void *data)

{

  struct GNUNET_CONVERSATION_Caller *caller = cls;

  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;

  struct GNUNET_MQ_Envelope *e;

  struct ClientAudioMessage *am;


  e = GNUNET_MQ_msg_extra (am,

                           data_size,

                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);

  am->cid = caller->cid;

  GNUNET_memcpy (&am[1],

                 data,

                 data_size);

  GNUNET_MQ_send (phone->mq,

                  e);

}


static enum GNUNET_GenericReturnValue


check_phone_ring (void *cls,

                  const struct ClientPhoneRingMessage *ring)

{

  // FIXME

  return GNUNET_OK;

}


static void


handle_phone_ring (void *cls,

                   const struct ClientPhoneRingMessage *ring)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;

  struct GNUNET_CONVERSATION_Caller *caller;

  struct GNUNET_CRYPTO_BlindablePublicKey caller_id;

  size_t key_len;

  size_t read;


  key_len = ntohl (ring->key_len);

  switch (phone->state)

  {

  case PS_REGISTER:

    GNUNET_assert (0);

    break;


  case PS_READY:

    if ((GNUNET_SYSERR ==

         GNUNET_CRYPTO_read_public_key_from_buffer (&ring[1],

                                                    key_len,

                                                    &caller_id,

                                                    &read)) ||

        (read != key_len))

    {

      GNUNET_break (0);

      break;

    }

    caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);

    caller->phone = phone;

    GNUNET_CONTAINER_DLL_insert (phone->caller_head,

                                 phone->caller_tail,

                                 caller);

    caller->caller_id = caller_id;

    caller->cid = ring->cid;

    caller->state = CS_RINGING;

    phone->event_handler (phone->event_handler_cls,

                          GNUNET_CONVERSATION_EC_PHONE_RING,

                          caller,

                          &caller->caller_id);

    break;

  }

}


static struct GNUNET_CONVERSATION_Caller *


find_caller (struct GNUNET_CONVERSATION_Phone *phone,

             uint32_t cid)

{

  struct GNUNET_CONVERSATION_Caller *caller;


  for (caller = phone->caller_head; NULL != caller; caller = caller->next)

    if (cid == caller->cid)

      return caller;

  return NULL;

}


static void


handle_phone_hangup (void *cls,

                     const struct ClientPhoneHangupMessage *hang)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;

  struct GNUNET_CONVERSATION_Caller *caller;


  caller = find_caller (phone,

                        hang->cid);

  if (NULL == caller)

  {

    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

                "Received HANG_UP message for unknown caller ID %u\n",

                (unsigned int) hang->cid);

    return;

  }


  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

              "Received HANG_UP message, terminating call with `%s'\n",

              GNUNET_GNSRECORD_pkey_to_zkey (&caller->caller_id));

  switch (caller->state)

  {

  case CS_RINGING:

    phone->event_handler (phone->event_handler_cls,

                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,

                          caller,

                          &caller->caller_id);

    break;


  case CS_ACTIVE:

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

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

    phone->event_handler (phone->event_handler_cls,

                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,

                          caller,

                          &caller->caller_id);

    break;


  case CS_CALLEE_SUSPENDED:

  case CS_CALLER_SUSPENDED:

  case CS_BOTH_SUSPENDED:

    phone->event_handler (phone->event_handler_cls,

                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,

                          caller,

                          &caller->caller_id);

    break;

  }

  GNUNET_CONTAINER_DLL_remove (phone->caller_head,

                               phone->caller_tail,

                               caller);

  GNUNET_free (caller);

}


static void


handle_phone_suspend (void *cls,

                      const struct ClientPhoneSuspendMessage *suspend)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;

  struct GNUNET_CONVERSATION_Caller *caller;


  caller = find_caller (phone,

                        suspend->cid);

  if (NULL == caller)

    return;

  switch (caller->state)

  {

  case CS_RINGING:

    GNUNET_break_op (0);

    break;


  case CS_ACTIVE:

    caller->state = CS_CALLER_SUSPENDED;

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

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

    caller->event_handler (caller->event_handler_cls,

                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);

    break;


  case CS_CALLEE_SUSPENDED:

    caller->state = CS_BOTH_SUSPENDED;

    caller->event_handler (caller->event_handler_cls,

                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);

    break;


  case CS_CALLER_SUSPENDED:

  case CS_BOTH_SUSPENDED:

    GNUNET_break_op (0);

    break;

  }

}


static void


handle_phone_resume (void *cls,

                     const struct ClientPhoneResumeMessage *resume)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;

  struct GNUNET_CONVERSATION_Caller *caller;


  caller = find_caller (phone,

                        resume->cid);

  if (NULL == caller)

    return;

  switch (caller->state)

  {

  case CS_RINGING:

    GNUNET_break_op (0);

    break;


  case CS_ACTIVE:

  case CS_CALLEE_SUSPENDED:

    GNUNET_break_op (0);

    break;


  case CS_CALLER_SUSPENDED:

    caller->state = CS_ACTIVE;

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

    caller->mic->enable_microphone (caller->mic->cls,

                                    &transmit_phone_audio,

                                    caller);

    caller->event_handler (caller->event_handler_cls,

                           GNUNET_CONVERSATION_EC_CALLER_RESUME);

    break;


  case CS_BOTH_SUSPENDED:

    caller->state = CS_CALLEE_SUSPENDED;

    caller->event_handler (caller->event_handler_cls,

                           GNUNET_CONVERSATION_EC_CALLER_RESUME);

    break;

  }

}


static int


check_phone_audio (void *cls,

                   const struct ClientAudioMessage *am)

{

  (void) cls;

  (void) am;


  /* any variable-size payload is OK */

  return GNUNET_OK;

}


static void


handle_phone_audio (void *cls,

                    const struct ClientAudioMessage *am)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;

  struct GNUNET_CONVERSATION_Caller *caller;


  caller = find_caller (phone,

                        am->cid);

  if (NULL == caller)

    return;

  switch (caller->state)

  {

  case CS_RINGING:

    GNUNET_break_op (0);

    break;


  case CS_ACTIVE:

    caller->speaker->play (caller->speaker->cls,

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

                                                            ClientAudioMessage),

                           &am[1]);

    break;


  case CS_CALLEE_SUSPENDED:

  case CS_CALLER_SUSPENDED:

  case CS_BOTH_SUSPENDED:

    break;

  }

}


static void


phone_error_handler (void *cls,

                     enum GNUNET_MQ_Error error)

{

  struct GNUNET_CONVERSATION_Phone *phone = cls;


  (void) error;

  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,

              _ (

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

  reconnect_phone (phone);

}


static void


clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone)

{

  struct GNUNET_CONVERSATION_Caller *caller;


  while (NULL != (caller = phone->caller_head))

  {

    /* make sure mic/speaker are disabled *before* callback */

    if (CS_ACTIVE == caller->state)

    {

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

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

      caller->state = CS_CALLER_SUSPENDED;

    }

    phone->event_handler (phone->event_handler_cls,

                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,

                          caller,

                          &caller->caller_id);

    GNUNET_CONVERSATION_caller_hang_up (caller);

  }

}


static void


reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone)

{

  struct GNUNET_MQ_MessageHandler handlers[] = {

    GNUNET_MQ_hd_var_size (phone_ring,

                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING,

                           struct ClientPhoneRingMessage,

                           phone),

    GNUNET_MQ_hd_fixed_size (phone_hangup,

                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,

                             struct ClientPhoneHangupMessage,

                             phone),

    GNUNET_MQ_hd_fixed_size (phone_suspend,

                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,

                             struct ClientPhoneSuspendMessage,

                             phone),

    GNUNET_MQ_hd_fixed_size (phone_resume,

                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,

                             struct ClientPhoneResumeMessage,

                             phone),

    GNUNET_MQ_hd_var_size (phone_audio,

                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,

                           struct ClientAudioMessage,

                           phone),

    GNUNET_MQ_handler_end ()

  };

  struct GNUNET_MQ_Envelope *e;

  struct ClientPhoneRegisterMessage *reg;


  clean_up_callers (phone);

  if (NULL != phone->mq)

  {

    GNUNET_MQ_destroy (phone->mq);

    phone->mq = NULL;

  }

  phone->state = PS_REGISTER;

  phone->mq = GNUNET_CLIENT_connect (phone->cfg,

                                     "conversation",

                                     handlers,

                                     &phone_error_handler,

                                     phone);

  if (NULL == phone->mq)

    return;

  e = GNUNET_MQ_msg (reg,

                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER);

  reg->line_port = phone->my_record.line_port;

  GNUNET_MQ_send (phone->mq,

                  e);

  phone->state = PS_READY;

}


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)

{

  struct GNUNET_CONVERSATION_Phone *phone;

  char *line;

  struct GNUNET_HashCode line_port;


  if (GNUNET_OK !=

      GNUNET_CONFIGURATION_get_value_string (cfg,

                                             "CONVERSATION",

                                             "LINE",

                                             &line))

  {

    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,

                               "CONVERSATION",

                               "LINE");

    return NULL;

  }

  GNUNET_CRYPTO_hash (line,

                      strlen (line),

                      &line_port);

  GNUNET_free (line);

  phone = GNUNET_new (struct GNUNET_CONVERSATION_Phone);

  if (GNUNET_OK !=

      GNUNET_CRYPTO_get_peer_identity (cfg,

                                       &phone->my_record.peer))

  {

    GNUNET_break (0);

    GNUNET_free (phone);

    return NULL;

  }

  phone->cfg = cfg;

  phone->my_zone = *GNUNET_IDENTITY_ego_get_private_key (ego);

  phone->event_handler = event_handler;

  phone->event_handler_cls = event_handler_cls;

  phone->ns = GNUNET_NAMESTORE_connect (cfg);

  phone->my_record.version = htonl (1);

  phone->my_record.reserved = htonl (0);

  phone->my_record.line_port = line_port;

  reconnect_phone (phone);

  if ((NULL == phone->mq) ||

      (NULL == phone->ns))

  {

    GNUNET_break (0);

    GNUNET_CONVERSATION_phone_destroy (phone);

    return NULL;

  }

  return phone;

}


void


GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,

                                      struct GNUNET_GNSRECORD_Data *rd)

{

  rd->data = &phone->my_record;

  rd->expiration_time = 0;

  rd->data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);

  rd->record_type = GNUNET_GNSRECORD_TYPE_PHONE;

  rd->flags = GNUNET_GNSRECORD_RF_NONE;

}


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)

{

  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;

  struct GNUNET_MQ_Envelope *e;

  struct ClientPhonePickupMessage *pick;


  GNUNET_assert (CS_RINGING == caller->state);

  caller->speaker = speaker;

  caller->mic = mic;

  e = GNUNET_MQ_msg (pick,

                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP);

  pick->cid = caller->cid;

  GNUNET_MQ_send (phone->mq,

                  e);

  caller->state = CS_ACTIVE;

  caller->event_handler = event_handler;

  caller->event_handler_cls = event_handler_cls;

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

  caller->mic->enable_microphone (caller->mic->cls,

                                  &transmit_phone_audio,

                                  caller);

}


void


GNUNET_CONVERSATION_caller_hang_up (struct GNUNET_CONVERSATION_Caller *caller)

{

  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;

  struct GNUNET_MQ_Envelope *e;

  struct ClientPhoneHangupMessage *hang;


  switch (caller->state)

  {

  case CS_ACTIVE:

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

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

    break;


  default:

    break;

  }

  GNUNET_CONTAINER_DLL_remove (phone->caller_head,

                               phone->caller_tail,

                               caller);

  e = GNUNET_MQ_msg (hang,

                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);

  hang->cid = caller->cid;

  GNUNET_MQ_send (phone->mq,

                  e);

  GNUNET_free (caller);

}


void


GNUNET_CONVERSATION_phone_destroy (struct GNUNET_CONVERSATION_Phone *phone)

{

  clean_up_callers (phone);

  if (NULL != phone->ns)

  {

    GNUNET_NAMESTORE_disconnect (phone->ns);

    phone->ns = NULL;

  }

  if (NULL != phone->mq)

  {

    GNUNET_MQ_destroy (phone->mq);

    phone->mq = NULL;

  }

  GNUNET_free (phone);

}


void


GNUNET_CONVERSATION_caller_suspend (struct GNUNET_CONVERSATION_Caller *caller)

{

  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;

  struct GNUNET_MQ_Envelope *e;

  struct ClientPhoneSuspendMessage *suspend;


  GNUNET_assert ((CS_ACTIVE == caller->state) ||

                 (CS_CALLER_SUSPENDED == caller->state));

  if (CS_ACTIVE == caller->state)

  {

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

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

  }

  caller->speaker = NULL;

  caller->mic = NULL;

  e = GNUNET_MQ_msg (suspend,

                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);

  suspend->cid = caller->cid;

  GNUNET_MQ_send (phone->mq,

                  e);

  if (CS_ACTIVE == caller->state)

    caller->state = CS_CALLEE_SUSPENDED;

  else

    caller->state = CS_BOTH_SUSPENDED;

}


void


GNUNET_CONVERSATION_caller_resume (struct GNUNET_CONVERSATION_Caller *caller,

                                   struct GNUNET_SPEAKER_Handle *speaker,

                                   struct GNUNET_MICROPHONE_Handle *mic)

{

  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;

  struct GNUNET_MQ_Envelope *e;

  struct ClientPhoneResumeMessage *resume;


  GNUNET_assert ((CS_CALLEE_SUSPENDED == caller->state) ||

                 (CS_BOTH_SUSPENDED == caller->state));

  caller->speaker = speaker;

  caller->mic = mic;

  e = GNUNET_MQ_msg (resume,

                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);

  resume->cid = caller->cid;

  GNUNET_MQ_send (phone->mq,

                  e);

  if (CS_CALLEE_SUSPENDED == caller->state)

  {

    caller->state = CS_ACTIVE;

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

    caller->mic->enable_microphone (caller->mic->cls,

                                    &transmit_phone_audio,

                                    caller);

  }

  else

  {

    caller->state = CS_CALLER_SUSPENDED;

  }

}


/* end of conversation_api.c */

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

conversation.h
constants for network protocols

CallerState
CallerState
Possible states of a caller.
Definition conversation_api.c:37

CS_CALLEE_SUSPENDED
@ CS_CALLEE_SUSPENDED
We suspended the conversation.
Definition conversation_api.c:51

CS_BOTH_SUSPENDED
@ CS_BOTH_SUSPENDED
Both sides suspended the conversation.
Definition conversation_api.c:61

CS_ACTIVE
@ CS_ACTIVE
The phone is in an active conversation.
Definition conversation_api.c:46

CS_CALLER_SUSPENDED
@ CS_CALLER_SUSPENDED
Caller suspended the conversation.
Definition conversation_api.c:56

CS_RINGING
@ CS_RINGING
The phone is ringing (user knows about incoming call).
Definition conversation_api.c:41

check_phone_ring
static enum GNUNET_GenericReturnValue check_phone_ring(void *cls, const struct ClientPhoneRingMessage *ring)
We received a struct ClientPhoneRingMessage
Definition conversation_api.c:249

clean_up_callers
static void clean_up_callers(struct GNUNET_CONVERSATION_Phone *phone)
Clean up all callers of the given phone.
Definition conversation_api.c:563

handle_phone_ring
static void handle_phone_ring(void *cls, const struct ClientPhoneRingMessage *ring)
We received a struct ClientPhoneRingMessage
Definition conversation_api.c:264

find_caller
static struct GNUNET_CONVERSATION_Caller * find_caller(struct GNUNET_CONVERSATION_Phone *phone, uint32_t cid)
Find the record of the caller matching the cid.
Definition conversation_api.c:316

handle_phone_hangup
static void handle_phone_hangup(void *cls, const struct ClientPhoneHangupMessage *hang)
We received a struct ClientPhoneHangupMessage.
Definition conversation_api.c:335

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

handle_phone_resume
static void handle_phone_resume(void *cls, const struct ClientPhoneResumeMessage *resume)
We received a struct ClientPhoneResumeMessage.
Definition conversation_api.c:440

reconnect_phone
static void reconnect_phone(struct GNUNET_CONVERSATION_Phone *phone)
The phone got disconnected, reconnect to the service.
Definition conversation_api.c:591

handle_phone_suspend
static void handle_phone_suspend(void *cls, const struct ClientPhoneSuspendMessage *suspend)
We received a struct ClientPhoneSuspendMessage.
Definition conversation_api.c:395

phone_error_handler
static void phone_error_handler(void *cls, enum GNUNET_MQ_Error error)
We encountered an error talking with the conversation service.
Definition conversation_api.c:544

transmit_phone_audio
static void transmit_phone_audio(void *cls, size_t data_size, const void *data)
Process recorded audio data.
Definition conversation_api.c:221

handle_phone_audio
static void handle_phone_audio(void *cls, const struct ClientAudioMessage *am)
We received a struct ClientAudioMessage
Definition conversation_api.c:506

PhoneState
PhoneState
Possible states of a phone.
Definition conversation_api.c:126

PS_REGISTER
@ PS_REGISTER
We still need to register the phone.
Definition conversation_api.c:130

PS_READY
@ PS_READY
We are waiting for calls.
Definition conversation_api.c:135

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

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

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

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

line
static char * line
Desired phone line (string to be converted to a hash).
Definition gnunet-conversation.c:155

phone
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
Definition gnunet-conversation.c:129

data
static char * data
The data to insert into the dht.
Definition gnunet-dht-put.c:88

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

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

gnunet_conversation_service.h
API to the conversation service.

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

GNUNET_CONFIGURATION_get_value_string
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.
Definition configuration.c:1921

GNUNET_CONVERSATION_phone_get_record
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.
Definition conversation_api.c:716

GNUNET_CONVERSATION_phone_create
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.
Definition conversation_api.c:653

GNUNET_CONVERSATION_CallerEventHandler
void(* GNUNET_CONVERSATION_CallerEventHandler)(void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
Function called with an event emitted by a caller.
Definition gnunet_conversation_service.h:190

GNUNET_CONVERSATION_caller_suspend
void GNUNET_CONVERSATION_caller_suspend(struct GNUNET_CONVERSATION_Caller *caller)
Pause conversation of an active call.
Definition conversation_api.c:833

GNUNET_CONVERSATION_phone_destroy
void GNUNET_CONVERSATION_phone_destroy(struct GNUNET_CONVERSATION_Phone *phone)
Destroys a phone.
Definition conversation_api.c:808

GNUNET_CONVERSATION_PhoneEventHandler
void(* GNUNET_CONVERSATION_PhoneEventHandler)(void *cls, enum GNUNET_CONVERSATION_PhoneEventCode code, struct GNUNET_CONVERSATION_Caller *caller, const struct GNUNET_CRYPTO_BlindablePublicKey *caller_id)
Function called with an event emitted by a phone.
Definition gnunet_conversation_service.h:148

GNUNET_CONVERSATION_caller_resume
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.
Definition conversation_api.c:868

GNUNET_CONVERSATION_caller_hang_up
void GNUNET_CONVERSATION_caller_hang_up(struct GNUNET_CONVERSATION_Caller *caller)
Hang up up a (possibly ringing) phone.
Definition conversation_api.c:774

GNUNET_CONVERSATION_caller_pick_up
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.
Definition conversation_api.c:738

GNUNET_CONVERSATION_EC_CALLER_RESUME
@ GNUNET_CONVERSATION_EC_CALLER_RESUME
We are the callee and the caller resumed the call.
Definition gnunet_conversation_service.h:177

GNUNET_CONVERSATION_EC_CALLER_SUSPEND
@ GNUNET_CONVERSATION_EC_CALLER_SUSPEND
We are the callee and the caller suspended the call.
Definition gnunet_conversation_service.h:170

GNUNET_CONVERSATION_EC_PHONE_HUNG_UP
@ GNUNET_CONVERSATION_EC_PHONE_HUNG_UP
The conversation was terminated by the caller.
Definition gnunet_conversation_service.h:135

GNUNET_CONVERSATION_EC_PHONE_RING
@ GNUNET_CONVERSATION_EC_PHONE_RING
We are the callee and the phone is ringing.
Definition gnunet_conversation_service.h:129

GNUNET_CRYPTO_get_peer_identity
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.
Definition crypto_ecc_setup.c:275

GNUNET_CONTAINER_DLL_remove
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Definition gnunet_container_lib.h:1920

GNUNET_CONTAINER_DLL_insert
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Definition gnunet_container_lib.h:1797

GNUNET_GNSRECORD_pkey_to_zkey
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_BlindablePublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
Definition gnsrecord_misc.c:228

GNUNET_GNSRECORD_RF_NONE
@ GNUNET_GNSRECORD_RF_NONE
Entry for no flags / cleared flags.
Definition gnunet_gnsrecord_lib.h:104

GNUNET_CRYPTO_hash
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

GNUNET_IDENTITY_ego_get_private_key
const struct GNUNET_CRYPTO_BlindablePrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition identity_api.c:522

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

GNUNET_CRYPTO_read_public_key_from_buffer
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_CRYPTO_BlindablePublicKey *key, size_t *read)
Reads a GNUNET_CRYPTO_BlindablePublicKey from a compact buffer.
Definition crypto_pkey.c:102

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

GNUNET_GenericReturnValue
GNUNET_GenericReturnValue
Named constants for return values.
Definition gnunet_common.h:111

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

GNUNET_OK
@ GNUNET_OK
Definition gnunet_common.h:114

GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:112

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

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

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

GNUNET_log_config_missing
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
Definition common_logging.c:1451

GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition gnunet_common.h:418

GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_ERROR
Definition gnunet_common.h:417

GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_DEBUG
Definition gnunet_common.h:424

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

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

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

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

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

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

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

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

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

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

GNUNET_NAMESTORE_disconnect
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
Definition namestore_api.c:1063

GNUNET_NAMESTORE_connect
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
Definition namestore_api.c:1040

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

GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
Client -> Server message to register a phone.
Definition gnunet_protocols.h:2399

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

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

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

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

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

platform.h

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

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

ClientAudioMessage::cid
uint32_t cid
CID, internal caller ID to identify which active call we are sending data to.
Definition conversation.h:205

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

ClientPhoneHangupMessage::cid
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition conversation.h:187

ClientPhonePickupMessage
Client -> Service pick up phone that is ringing.
Definition conversation.h:158

ClientPhonePickupMessage::cid
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition conversation.h:168

ClientPhoneRegisterMessage
Client -> Service message to register a phone.
Definition conversation.h:73

ClientPhoneRegisterMessage::line_port
struct GNUNET_HashCode line_port
Phone line / CADET port to register.
Definition conversation.h:87

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

ClientPhoneResumeMessage::cid
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition conversation.h:150

ClientPhoneRingMessage
Service -> Client message for phone is ringing.
Definition conversation.h:95

ClientPhoneRingMessage::cid
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

ClientPhoneRingMessage::key_len
uint32_t key_len
The identity key length.
Definition conversation.h:110

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

ClientPhoneSuspendMessage::cid
uint32_t cid
CID, internal caller ID to identify which active call we are talking about.
Definition conversation.h:132

GNUNET_CONFIGURATION_Handle
configuration data
Definition configuration.c:149

GNUNET_CONVERSATION_Caller
A caller is the handle we have for an incoming call.
Definition conversation_api.c:69

GNUNET_CONVERSATION_Caller::cid
uint32_t cid
Internal handle to identify the caller with the service.
Definition conversation_api.c:113

GNUNET_CONVERSATION_Caller::next
struct GNUNET_CONVERSATION_Caller * next
We keep all callers in a DLL.
Definition conversation_api.c:73

GNUNET_CONVERSATION_Caller::mic
struct GNUNET_MICROPHONE_Handle * mic
Microphone, or NULL if none is attached.
Definition conversation_api.c:103

GNUNET_CONVERSATION_Caller::event_handler_cls
void * event_handler_cls
Closure for event_handler.
Definition conversation_api.c:93

GNUNET_CONVERSATION_Caller::speaker
struct GNUNET_SPEAKER_Handle * speaker
Speaker, or NULL if none is attached.
Definition conversation_api.c:98

GNUNET_CONVERSATION_Caller::phone
struct GNUNET_CONVERSATION_Phone * phone
Our phone.
Definition conversation_api.c:83

GNUNET_CONVERSATION_Caller::state
enum CallerState state
State machine for the phone.
Definition conversation_api.c:118

GNUNET_CONVERSATION_Caller::prev
struct GNUNET_CONVERSATION_Caller * prev
We keep all callers in a DLL.
Definition conversation_api.c:78

GNUNET_CONVERSATION_Caller::event_handler
GNUNET_CONVERSATION_CallerEventHandler event_handler
Function to call for phone events.
Definition conversation_api.c:88

GNUNET_CONVERSATION_Caller::caller_id
struct GNUNET_CRYPTO_BlindablePublicKey caller_id
Identity of the person calling us.
Definition conversation_api.c:108

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_CONVERSATION_PhoneRecord::reserved
uint32_t reserved
Reserved.
Definition gnunet_conversation_service.h:105

GNUNET_CONVERSATION_PhoneRecord::version
uint32_t version
Version of the phone record, for now always one.
Definition gnunet_conversation_service.h:100

GNUNET_CONVERSATION_Phone
A phone is a device that can ring to signal an incoming call and that you can pick up to answer the c...
Definition conversation_api.c:151

GNUNET_CONVERSATION_Phone::event_handler
GNUNET_CONVERSATION_PhoneEventHandler event_handler
Function to call for phone events.
Definition conversation_api.c:170

GNUNET_CONVERSATION_Phone::mq
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
Definition conversation_api.c:185

GNUNET_CONVERSATION_Phone::caller_tail
struct GNUNET_CONVERSATION_Caller * caller_tail
We keep all callers in a DLL.
Definition conversation_api.c:165

GNUNET_CONVERSATION_Phone::my_zone
struct GNUNET_CRYPTO_BlindablePrivateKey my_zone
My GNS zone.
Definition conversation_api.c:195

GNUNET_CONVERSATION_Phone::ns
struct GNUNET_NAMESTORE_Handle * ns
Connection to NAMESTORE (for reverse lookup).
Definition conversation_api.c:180

GNUNET_CONVERSATION_Phone::cfg
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition conversation_api.c:155

GNUNET_CONVERSATION_Phone::caller_head
struct GNUNET_CONVERSATION_Caller * caller_head
We keep all callers in a DLL.
Definition conversation_api.c:160

GNUNET_CONVERSATION_Phone::my_record
struct GNUNET_CONVERSATION_PhoneRecord my_record
This phone's record.
Definition conversation_api.c:190

GNUNET_CONVERSATION_Phone::state
enum PhoneState state
State machine for the phone.
Definition conversation_api.c:200

GNUNET_CONVERSATION_Phone::event_handler_cls
void * event_handler_cls
Closure for event_handler.
Definition conversation_api.c:175

GNUNET_CRYPTO_BlindablePrivateKey
A private key for an identity as per LSD0001.
Definition gnunet_crypto_lib.h:400

GNUNET_CRYPTO_BlindablePublicKey
An identity key as per LSD0001.
Definition gnunet_crypto_lib.h:427

GNUNET_GNSRECORD_Data
A GNS record.
Definition gnunet_gnsrecord_lib.h:177

GNUNET_GNSRECORD_Data::record_type
uint32_t record_type
Type of the GNS/DNS record.
Definition gnunet_gnsrecord_lib.h:200

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_GNSRECORD_Data::flags
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
Definition gnunet_gnsrecord_lib.h:205

GNUNET_GNSRECORD_Data::expiration_time
uint64_t expiration_time
Expiration time for the DNS record.
Definition gnunet_gnsrecord_lib.h:190

GNUNET_HashCode
A 512-bit hashcode.
Definition gnunet_common.h:287

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

GNUNET_NAMESTORE_Handle
Connection to the NAMESTORE service.
Definition namestore_api.c:200

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