conversation_api.c

Go to the documentation of this file.

/*
   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_EcdsaPublicKey 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_EcdsaPrivateKey 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 void
handle_phone_ring (void *cls,
                   const struct ClientPhoneRingMessage *ring)
{
  struct GNUNET_CONVERSATION_Phone *phone = cls;
  struct GNUNET_CONVERSATION_Caller *caller;

  switch (phone->state)
  {
  case PS_REGISTER:
    GNUNET_assert (0);
    break;

  case PS_READY:
    caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
    caller->phone = phone;
    GNUNET_CONTAINER_DLL_insert (phone->caller_head,
                                 phone->caller_tail,
                                 caller);
    caller->caller_id = ring->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_fixed_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);
  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 */