/*
- This file is part of GNUnet.
- (C 2013 Christian Grothoff (and other contributing authors)
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, 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
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
-*/
+ This file is part of GNUnet
+ (C) 2013 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, 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
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
/**
* @file conversation/conversation_api.c
- * @brief API for conversation
+ * @brief phone and caller API to the conversation service
* @author Simon Dieterle
* @author Andreas Fuchs
- * STRUCTURE:
- * - DATA STRUCTURES
- * - DECLARATIONS
- * - AUXILIARY FUNCTIONS
- * - RECEIVE HANDLERS
- * - SEND FUNCTIONS
- * - API CALL DEFINITIONS
- *
+ * @author Christian Grothoff
*/
-
#include "platform.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_dnsparser_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_gnsrecord_lib.h"
#include "gnunet_gns_service.h"
-#include "gnunet_protocols.h"
#include "conversation.h"
-#include "gnunet_conversation_service.h"
-#define MAX_TRANSMIT_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
-
-/******************************************************************************/
-/************************ DATA STRUCTURES ****************************/
-/******************************************************************************/
-
-enum GNUNET_CONVERSATION_CallType
-{
- CALLER = 0,
- CALLEE
-};
/**
-* Information about a call
-*/
-struct GNUNET_CONVERSATION_CallInformation
+ * Possible states of a caller.
+ */
+enum CallerState
{
+ /**
+ * We still need to reverse lookup the caller ID.
+ */
+ CS_RESOLVE,
- /**
- * Peer interacting with
- */
- struct GNUNET_PeerIdentity peer;
+ /**
+ * The phone is ringing (user knows about incoming call).
+ */
+ CS_RINGING,
+
+ /**
+ * The phone is in an active conversation.
+ */
+ CS_ACTIVE,
- /**
- * Type of call (incoming or outgoing)
- */
- int type;
+ /**
+ * We suspended the conversation.
+ */
+ CS_CALLEE_SUSPENDED,
- /**
- * Shows if the call ist fully established
- */
- int established;
+ /**
+ * Caller suspended the conversation.
+ */
+ CS_CALLER_SUSPENDED,
+
+ /**
+ * Both sides suspended the conversation.
+ */
+ CS_BOTH_SUSPENDED
};
+
+
/**
- * Opaque handle to the service.
+ * A caller is the handle we have for an incoming call.
*/
-struct GNUNET_CONVERSATION_Handle
+struct GNUNET_CONVERSATION_Caller
{
/**
- * Our configuration.
+ * We keep all callers in a DLL.
*/
- const struct GNUNET_CONFIGURATION_Handle *cfg;
+ struct GNUNET_CONVERSATION_Caller *next;
/**
- * Handle to the server connection, to send messages later
+ * We keep all callers in a DLL.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_CONVERSATION_Caller *prev;
/**
- * GNS handle
+ * Our phone.
*/
- struct GNUNET_GNS_Handle *gns;
+ struct GNUNET_CONVERSATION_Phone *phone;
/**
- * Namestore handle
+ * Function to call for phone events.
*/
- struct GNUNET_NAMESTORE_Handle *namestore;
+ GNUNET_CONVERSATION_CallerEventHandler event_handler;
/**
- * TXT record for gns
+ * Closure for @e event_handler
*/
- int txt_record_set;
+ void *event_handler_cls;
/**
- * Callback for incoming calls
+ * Speaker, or NULL if none is attached.
*/
- GNUNET_CONVERSATION_CallHandler *call_handler;
+ struct GNUNET_SPEAKER_Handle *speaker;
/**
- * Callback for rejected calls
+ * Microphone, or NULL if none is attached.
*/
- GNUNET_CONVERSATION_RejectHandler *reject_handler;
-
+ struct GNUNET_MICROPHONE_Handle *mic;
+
/**
- * Callback for notifications
+ * Active NAMESTORE lookup (or NULL).
*/
- GNUNET_CONVERSATION_NotificationHandler *notification_handler;
+ struct GNUNET_NAMESTORE_QueueEntry *qe;
/**
- * Callback for missed calls
+ * Identity of the person calling us.
*/
- GNUNET_CONVERSATION_MissedCallHandler *missed_call_handler;
+ struct GNUNET_CRYPTO_EcdsaPublicKey caller_id;
/**
- * The pointer to the call
+ * Caller ID of the person calling us as a string.
*/
- struct GNUNET_CONVERSATION_CallInformation *call;
-};
-
-/******************************************************************************/
-/*********************** AUXILIARY FUNCTIONS *************************/
-/******************************************************************************/
-
-/**
-* Initialize the conversation txt record in GNS
-*/
-static void
-setup_gns_txt (struct GNUNET_CONVERSATION_Handle *handle)
-{
- struct GNUNET_CRYPTO_EccPublicSignKey zone_pkey;
- struct GNUNET_CRYPTO_EccPrivateKey *zone_key;
- struct GNUNET_CRYPTO_EccPrivateKey *peer_key;
- struct GNUNET_NAMESTORE_RecordData rd;
- struct GNUNET_PeerIdentity peer;
+ char *caller_id_str;
- char *zone_keyfile;
- char *peer_keyfile;
-
- rd.expiration_time = UINT64_MAX;
+ /**
+ * Internal handle to identify the caller with the service.
+ */
+ uint32_t cid;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (handle->cfg, "gns", "ZONEKEY",
- &zone_keyfile))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
- return;
- }
+ /**
+ * State machine for the phone.
+ */
+ enum CallerState state;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (handle->cfg, "PEER",
- "PRIVATE_KEY", &peer_keyfile))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
- return;
- }
+};
- zone_key = GNUNET_CRYPTO_ecc_key_create_from_file (zone_keyfile);
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (zone_key, &zone_pkey);
- peer_key = GNUNET_CRYPTO_ecc_key_create_from_file (peer_keyfile);
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (peer_key,
- &peer.public_key);
- const char *h = GNUNET_i2s_full (&peer);
-
- rd.data_size = strlen (h) + 1;
- rd.data = h;
- rd.record_type = GNUNET_DNSPARSER_TYPE_TXT;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
-
- /* FIXME: continuation? return value? */
- GNUNET_NAMESTORE_records_store (handle->namestore,
- zone_key,
- "conversation",
- 1, &rd,
- NULL, NULL);
-}
/**
-* Callback for checking the conversation txt gns record
-*
-* @param cls closure
-* @param rd_count
-* @param rd
-*/
-static void
-check_gns_cb (void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ * Possible states of a phone.
+ */
+enum PhoneState
{
- struct GNUNET_CONVERSATION_Handle *h = (struct GNUNET_CONVERSATION_Handle *) cls;
+ /**
+ * We still need to register the phone.
+ */
+ PS_REGISTER = 0,
- if (0 == rd_count)
- {
- setup_gns_txt (h);
- }
- else
- {
- h->txt_record_set = GNUNET_YES;
- }
-}
+ /**
+ * We are waiting for calls.
+ */
+ PS_READY
+
+};
/**
- * Check if the gns txt record for conversation exits
+ * A phone is a device that can ring to signal an incoming call and
+ * that you can pick up to answer the call and hang up to terminate
+ * the call. You can also hang up a ringing phone immediately
+ * (without picking it up) to stop it from ringing. Phones have
+ * caller ID. You can ask the phone for its record and make that
+ * record available (via GNS) to enable others to call you.
+ * Multiple phones maybe connected to the same line (the line is
+ * something rather internal to a phone and not obvious from it).
+ * You can only have one conversation per phone at any time.
*/
-static void
-check_gns (struct GNUNET_CONVERSATION_Handle *h)
+struct GNUNET_CONVERSATION_Phone
{
- GNUNET_GNS_lookup (h->gns, "conversation.gns",
- NULL /* FIXME_ZONE */,
- GNUNET_DNSPARSER_TYPE_TXT,
- GNUNET_NO,
- NULL,
- &check_gns_cb, h);
-}
-
+ /**
+ * Our configuration.
+ */
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
-/******************************************************************************/
-/*********************** RECEIVE HANDLERS ****************************/
-/******************************************************************************/
+ /**
+ * Handle to talk with CONVERSATION service.
+ */
+ struct GNUNET_CLIENT_Connection *client;
-/**
- * Function to process all messages received from the service
- *
- * @param cls closure
- * @param msg message received, NULL on timeout or fatal error
- */
-static void
-receive_message_cb (void *cls,
- const struct GNUNET_MessageHeader *msg)
-{
- struct GNUNET_CONVERSATION_Handle *h = cls;
- struct ServerClientSessionInitiateMessage *imsg;
- struct ServerClientSessionRejectMessage *rmsg;
- struct GNUNET_CONVERSATION_MissedCallNotification *missed_calls;
+ /**
+ * We keep all callers in a DLL.
+ */
+ struct GNUNET_CONVERSATION_Caller *caller_head;
- if (NULL != msg)
- {
- switch (ntohs (msg->type))
- {
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_SESSION_ACCEPT:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("%s has accepted your call.\n"),
- GNUNET_i2s_full (&(h->call->peer)));
-
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_CALL_ACCEPTED,
- &(h->call->peer));
- h->call->type = CALLEE;
-
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_SESSION_REJECT:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("%s has rejected your call.\n"),
- GNUNET_i2s_full (&(h->call->peer)));
-
- rmsg = (struct ServerClientSessionRejectMessage *) msg;
- h->reject_handler (NULL, h, ntohs (rmsg->reason), &(h->call->peer));
- GNUNET_free (h->call);
- h->call = NULL;
-
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_SESSION_TERMINATE:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("%s has terminated the call.\n"),
- GNUNET_i2s_full (&(h->call->peer)));
-
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_CALL_TERMINATED,
- &(h->call->peer));
- GNUNET_free (h->call);
- h->call = NULL;
-
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_SESSION_INITIATE:
- imsg = (struct ServerClientSessionInitiateMessage *) msg;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("%s wants to call you.\n"),
- GNUNET_i2s_full (&(imsg->peer)));
-
- h->call =
- (struct GNUNET_CONVERSATION_CallInformation *)
- GNUNET_malloc (sizeof (struct GNUNET_CONVERSATION_CallInformation));
- memcpy (&(h->call->peer), &(imsg->peer),
- sizeof (struct GNUNET_PeerIdentity));
- h->call_handler (NULL, h, &(h->call->peer));
- h->call->type = CALLEE;
-
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_MISSED_CALL:
- missed_calls =
- (struct GNUNET_CONVERSATION_MissedCallNotification *) (msg +
- (sizeof
- (struct
- GNUNET_MessageHeader)));
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("You &d have missed a calls.\n"),
- missed_calls->number);
- h->missed_call_handler (NULL, h, missed_calls);
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_SERVICE_BLOCKED:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("The service is blocked.\n"));
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_SERVICE_BLOCKED,
- NULL);
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_PEER_NOT_CONNECTED:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("The peer you are calling is not connected.\n"));
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_NO_PEER, NULL);
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_NO_ANSWER:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("The peer you are calling does not answer.\n"));
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_NO_ANSWER,
- &(h->call->peer));
- break;
-
- case GNUNET_MESSAGE_TYPE_CONVERSATION_SC_ERROR:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Generic error occured.\n"));
- break;
-
- default:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Got unknown message type.\n"));
- break;
- }
+ /**
+ * We keep all callers in a DLL.
+ */
+ struct GNUNET_CONVERSATION_Caller *caller_tail;
- }
+ /**
+ * Function to call for phone events.
+ */
+ GNUNET_CONVERSATION_PhoneEventHandler event_handler;
- GNUNET_CLIENT_receive (h->client, &receive_message_cb, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
-}
+ /**
+ * Closure for @e event_handler
+ */
+ void *event_handler_cls;
-/******************************************************************************/
-/************************ SEND FUNCTIONS ****************************/
-/******************************************************************************/
+ /**
+ * Connection to NAMESTORE (for reverse lookup).
+ */
+ struct GNUNET_NAMESTORE_Handle *ns;
-/**
- * Function called to send a session initiate message to the service.
- * "buf" will be NULL and "size" zero if the socket was closed for writing in
- * the meantime.
- *
- * @param cls closure, NULL
- * @param size number of bytes available in buf
- * @param buf where the callee should write the initiate message
- * @return number of bytes written to buf
- */
-static size_t
-transmit_session_initiate_message (void *cls, size_t size, void *buf)
-{
- size_t msg_size;
- struct ClientServerSessionInitiateMessage *msg;
- struct GNUNET_CONVERSATION_Handle *h = (struct GNUNET_CONVERSATION_Handle *) cls;
+ /**
+ * Handle for transmitting to the CONVERSATION service.
+ */
+ struct GNUNET_MQ_Handle *mq;
- msg_size = sizeof (struct ClientServerSessionInitiateMessage);
+ /**
+ * This phone's record.
+ */
+ struct GNUNET_CONVERSATION_PhoneRecord my_record;
- GNUNET_assert (size >= msg_size);
- msg = buf;
- msg->header.size = htons (msg_size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_SESSION_INITIATE);
- memcpy (&msg->peer, &(h->call->peer), sizeof (struct GNUNET_PeerIdentity));
+ /**
+ * My GNS zone.
+ */
+ struct GNUNET_CRYPTO_EcdsaPrivateKey my_zone;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _
- ("Sending ClientServerSessionInitiateMessage to the service for peer: %s\n"),
- GNUNET_i2s_full (&(h->call->peer)));
+ /**
+ * State machine for the phone.
+ */
+ enum PhoneState state;
- h->call->type = CALLER;
+};
- return msg_size;
-}
/**
- * Function called to send a session accept message to the service.
- * "buf" will be NULL and "size" zero if the socket was closed for writing in
- * the meantime.
+ * The phone got disconnected, reconnect to the service.
*
- * @param cls closure, NULL
- * @param size number of bytes available in buf
- * @param buf where the callee should write the accept message
- * @return number of bytes written to buf
+ * @param phone phone to reconnect
*/
-static size_t
-transmit_session_accept_message (void *cls, size_t size, void *buf)
-{
- size_t msg_size;
- struct ClientServerSessionAcceptMessage *msg;
- struct GNUNET_CONVERSATION_Handle *h = (struct GNUNET_CONVERSATION_Handle *) cls;
-
- msg_size = sizeof (struct ClientServerSessionAcceptMessage);
-
- GNUNET_assert (size >= msg_size);
- msg = buf;
- msg->header.size = htons (msg_size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_SESSION_ACCEPT);
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _
- ("Sending ClienServerSessionAcceptMessage to the service for peer: %s\n"),
- GNUNET_i2s_full (&(h->call->peer)));
+static void
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone);
- h->call->established = GNUNET_YES;
-
- return msg_size;
-}
/**
- * Function called to send a session reject message to the service.
- * "buf" will be NULL and "size" zero if the socket was closed for writing in
- * the meantime.
+ * We have resolved the caller ID using our name service.
*
- * @param cls closure, NULL
- * @param size number of bytes available in buf
- * @param buf where the callee should write the reject message
- * @return number of bytes written to buf
+ * @param cls the `struct GNUNET_CONVERSATION_Caller`
+ * @param zone our zone used for resolution
+ * @param label name of the caller
+ * @param rd_count number of records we have in @a rd
+ * @param rd records we have for the caller's label
*/
-static size_t
-transmit_session_reject_message (void *cls, size_t size, void *buf)
+static void
+handle_caller_name (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ const char *label,
+ unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd)
{
- size_t msg_size;
- struct ClientServerSessionRejectMessage *msg;
- struct GNUNET_CONVERSATION_Handle *h = (struct GNUNET_CONVERSATION_Handle *) cls;
-
- msg_size = sizeof (struct ClientServerSessionRejectMessage);
-
- GNUNET_assert (size >= msg_size);
- msg = buf;
- msg->header.size = htons (msg_size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_SESSION_REJECT);
- msg->reason = htons (GNUNET_CONVERSATION_REJECT_REASON_NOT_WANTED);
+ struct GNUNET_CONVERSATION_Caller *caller = cls;
+ struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+ char *name;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _
- ("Sending ClientServerSessionRejectMessage to the service for peer: %s\n"),
- GNUNET_i2s_full (&(h->call->peer)));
+ caller->qe = NULL;
+ if (NULL == label)
+ name = GNUNET_strdup (GNUNET_GNSRECORD_pkey_to_zkey (&caller->caller_id));
+ else
+ GNUNET_asprintf (&name, "%s.gnu", label);
+ caller->caller_id_str = name;
+ caller->state = CS_RINGING;
+ phone->event_handler (phone->event_handler_cls,
+ GNUNET_CONVERSATION_EC_PHONE_RING,
+ caller,
+ name);
+}
- GNUNET_free (h->call);
- h->call = NULL;
- return msg_size;
+/**
+ * Process recorded audio data.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Caller`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+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;
+ memcpy (&am[1], data, data_size);
+ GNUNET_MQ_send (phone->mq, e);
}
+
/**
- * Function called to send a session terminate message to the service.
- * "buf" will be NULL and "size" zero if the socket was closed for writing in
- * the meantime.
+ * We received a `struct ClientPhoneRingMessage`
*
- * @param cls closure, NULL
- * @param size number of bytes available in buf
- * @param buf where the callee should write the terminate message
- * @return number of bytes written to buf
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param msg the message
*/
-static size_t
-transmit_session_terminate_message (void *cls, size_t size, void *buf)
+static void
+handle_phone_ring (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- size_t msg_size;
- struct ClientServerSessionTerminateMessage *msg;
- struct GNUNET_CONVERSATION_Handle *h = (struct GNUNET_CONVERSATION_Handle *) cls;
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+ const struct ClientPhoneRingMessage *ring;
+ struct GNUNET_CONVERSATION_Caller *caller;
- msg_size = sizeof (struct ClientServerSessionTerminateMessage);
+ ring = (const struct ClientPhoneRingMessage *) msg;
+ 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->state = CS_RESOLVE;
+ caller->caller_id = ring->caller_id;
+ caller->cid = ring->cid;
+ caller->qe = GNUNET_NAMESTORE_zone_to_name (phone->ns,
+ &phone->my_zone,
+ &ring->caller_id,
+ &handle_caller_name,
+ caller);
+ break;
+ }
+}
- GNUNET_assert (size >= msg_size);
- msg = buf;
- msg->header.size = htons (msg_size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_SESSION_TERMINATE);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _
- ("Sending ClientServerSessionTerminateMessage to the service for peer: %s\n"),
- GNUNET_i2s_full (&(h->call->peer)));
+/**
+ * We received a `struct ClientPhoneHangupMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param msg the message
+ */
+static void
+handle_phone_hangup (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+ const struct ClientPhoneHangupMessage *hang;
+ struct GNUNET_CONVERSATION_Caller *caller;
- GNUNET_free (h->call);
- h->call = NULL;
+ hang = (const struct ClientPhoneHangupMessage *) msg;
+ for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+ if (hang->cid == caller->cid)
+ break;
+ if (NULL == caller)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received HANG_UP message for unknown caller ID %u\n",
+ (unsigned int) hang->cid);
+ return;
+ }
- return msg_size;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received HANG_UP message, terminating call with `%s'\n",
+ caller->caller_id_str);
+ switch (caller->state)
+ {
+ case CS_RESOLVE:
+ /* application doesn't even know about call yet */
+ GNUNET_NAMESTORE_cancel (caller->qe);
+ caller->qe = NULL;
+ break;
+ case CS_RINGING:
+ phone->event_handler (phone->event_handler_cls,
+ GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+ caller,
+ caller->caller_id_str);
+ 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_str);
+ 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_str);
+ break;
+ }
+ GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+ phone->caller_tail,
+ caller);
+ GNUNET_free (caller);
}
+
/**
- * Auxiliary function to call a peer.
- *
- * @param h conversation handle
- * @return
+ * We received a `struct ClientPhoneSuspendMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param msg the message
*/
static void
-initiate_call (struct GNUNET_CONVERSATION_Handle *h, struct GNUNET_PeerIdentity peer)
+handle_phone_suspend (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- h->call =
- (struct GNUNET_CONVERSATION_CallInformation *)
- GNUNET_malloc (sizeof (struct GNUNET_CONVERSATION_CallInformation));
- memcpy (&(h->call->peer), &peer, sizeof (struct GNUNET_PeerIdentity));
-
- GNUNET_CLIENT_notify_transmit_ready (h->client,
- sizeof (struct
- ClientServerSessionInitiateMessage),
- MAX_TRANSMIT_DELAY, GNUNET_YES,
- &transmit_session_initiate_message, h);
-
- return;
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+ struct GNUNET_CONVERSATION_Caller *caller;
+ const struct ClientPhoneSuspendMessage *suspend;
+
+ suspend = (const struct ClientPhoneSuspendMessage *) msg;
+ for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+ if (suspend->cid == caller->cid)
+ break;
+ if (NULL == caller)
+ return;
+ switch (caller->state)
+ {
+ case CS_RESOLVE:
+ GNUNET_break_op (0);
+ break;
+ 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;
+ }
}
+
/**
- * Auxiliary function to accept a call.
- *
- * @param h conversation handle
+ * We received a `struct ClientPhoneResumeMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param msg the message
*/
static void
-accept_call (struct GNUNET_CONVERSATION_Handle *h)
+handle_phone_resume (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- GNUNET_CLIENT_notify_transmit_ready (h->client,
- sizeof (struct
- ClientServerSessionAcceptMessage),
- MAX_TRANSMIT_DELAY, GNUNET_YES,
- &transmit_session_accept_message, h);
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+ struct GNUNET_CONVERSATION_Caller *caller;
+ const struct ClientPhoneResumeMessage *resume;
+
+ resume = (const struct ClientPhoneResumeMessage *) msg;
+ for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+ if (resume->cid == caller->cid)
+ break;
+ if (NULL == caller)
+ return;
+ switch (caller->state)
+ {
+ case CS_RESOLVE:
+ GNUNET_break_op (0);
+ break;
+ 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;
+ }
}
/**
- * Auxiliary function to reject a call.
- *
- * @param h conversation handle
+ * We received a `struct ClientAudioMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param msg the message
*/
static void
-reject_call (struct GNUNET_CONVERSATION_Handle *h)
+handle_phone_audio_message (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- GNUNET_CLIENT_notify_transmit_ready (h->client,
- sizeof (struct
- ClientServerSessionRejectMessage),
- MAX_TRANSMIT_DELAY, GNUNET_YES,
- &transmit_session_reject_message, h);
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+ const struct ClientAudioMessage *am;
+ struct GNUNET_CONVERSATION_Caller *caller;
+
+ am = (const struct ClientAudioMessage *) msg;
+ for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+ if (am->cid == caller->cid)
+ break;
+ if (NULL == caller)
+ return;
+ switch (caller->state)
+ {
+ case CS_RESOLVE:
+ GNUNET_break_op (0);
+ break;
+ case CS_RINGING:
+ GNUNET_break_op (0);
+ break;
+ case CS_ACTIVE:
+ caller->speaker->play (caller->speaker->cls,
+ ntohs (msg->size) - sizeof (struct ClientAudioMessage),
+ &am[1]);
+ break;
+ case CS_CALLEE_SUSPENDED:
+ case CS_CALLER_SUSPENDED:
+ case CS_BOTH_SUSPENDED:
+ break;
+ }
}
/**
- * Auxiliary function to terminate a call.
- *
- * @param h conversation handle
+ * We encountered an error talking with the conversation service.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param error details about the error
*/
static void
-terminate_call (struct GNUNET_CONVERSATION_Handle *h)
+phone_error_handler (void *cls,
+ enum GNUNET_MQ_Error error)
{
- GNUNET_CLIENT_notify_transmit_ready (h->client,
- sizeof (struct
- ClientServerSessionTerminateMessage),
- MAX_TRANSMIT_DELAY, GNUNET_YES,
- &transmit_session_terminate_message,
- h);
+ struct GNUNET_CONVERSATION_Phone *phone = cls;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Connection to conversation service lost, trying to reconnect\n"));
+ reconnect_phone (phone);
}
/**
+ * Clean up all callers of the given phone.
*
+ * @param phone phone to clean up callers for
*/
static void
-gns_call_cb (void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone)
{
- struct GNUNET_CONVERSATION_Handle *handle = cls;
- struct GNUNET_PeerIdentity peer;
- unsigned int i;
+ struct GNUNET_CONVERSATION_Caller *caller;
- for (i=0;i<rd_count;i++)
+ while (NULL != (caller = phone->caller_head))
{
- switch (rd[i].record_type)
+ /* make sure mic/speaker are disabled *before* callback */
+ if (CS_ACTIVE == caller->state)
{
- case GNUNET_DNSPARSER_TYPE_TXT: /* FIXME: use fresh record type for voide... */
- if (GNUNET_OK !=
- GNUNET_CRYPTO_ecc_public_sign_key_from_string (rd[i].data,
- rd[i].data_size,
- &peer.public_key))
- {
- GNUNET_break_op (0);
- continue;
- }
- initiate_call (handle, peer);
- return;
- default:
- break;
+ 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_str);
+ GNUNET_CONVERSATION_caller_hang_up (caller);
}
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Lookup failed\n");
- handle->notification_handler (NULL, handle,
- GNUNET_CONVERSATION_NT_NO_PEER,
- NULL);
}
/**
-* GNS lookup
-*/
+ * The phone got disconnected, reconnect to the service.
+ *
+ * @param phone phone to reconnect
+ */
static void
-gns_lookup_and_call (struct GNUNET_CONVERSATION_Handle *h, const char *callee)
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone)
{
- char domain[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- char *pos;
-
- pos = domain;
- strcpy (pos, "conversation");
- pos += strlen ("conversation");
- strcpy (pos, ".");
- pos++;
- strcpy (pos, callee);
- pos += strlen (callee);
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Lookup for %s\n", domain);
-
- GNUNET_GNS_lookup (h->gns,
- domain,
- NULL /* FIXME: ZONE! */,
- GNUNET_DNSPARSER_TYPE_TXT,
- GNUNET_NO,
- NULL,
- &gns_call_cb, h);
+ static struct GNUNET_MQ_MessageHandler handlers[] =
+ {
+ { &handle_phone_ring,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING,
+ sizeof (struct ClientPhoneRingMessage) },
+ { &handle_phone_hangup,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+ sizeof (struct ClientPhoneHangupMessage) },
+ { &handle_phone_suspend,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+ sizeof (struct ClientPhoneSuspendMessage) },
+ { &handle_phone_resume,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+ sizeof (struct ClientPhoneResumeMessage) },
+ { &handle_phone_audio_message,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+ 0 },
+ { NULL, 0, 0 }
+ };
+ struct GNUNET_MQ_Envelope *e;
+ struct ClientPhoneRegisterMessage *reg;
+
+ clean_up_callers (phone);
+ if (NULL != phone->mq)
+ {
+ GNUNET_MQ_destroy (phone->mq);
+ phone->mq = NULL;
+ }
+ if (NULL != phone->client)
+ {
+ GNUNET_CLIENT_disconnect (phone->client);
+ phone->client = NULL;
+ }
+ phone->state = PS_REGISTER;
+ phone->client = GNUNET_CLIENT_connect ("conversation", phone->cfg);
+ if (NULL == phone->client)
+ return;
+ phone->mq = GNUNET_MQ_queue_for_connection_client (phone->client,
+ handlers,
+ &phone_error_handler,
+ phone);
+ e = GNUNET_MQ_msg (reg, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER);
+ reg->line = phone->my_record.line;
+ GNUNET_MQ_send (phone->mq, e);
+ phone->state = PS_READY;
}
-/******************************************************************************/
-/********************** API CALL DEFINITIONS *************************/
-/******************************************************************************/
-
-struct GNUNET_CONVERSATION_Handle *
-GNUNET_CONVERSATION_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- void *cls,
- GNUNET_CONVERSATION_CallHandler call_handler,
- GNUNET_CONVERSATION_RejectHandler reject_handler,
- GNUNET_CONVERSATION_NotificationHandler notification_handler,
- GNUNET_CONVERSATION_MissedCallHandler missed_call_handler)
+/**
+ * Create a new phone.
+ *
+ * @param cfg configuration for the phone; specifies the phone service and
+ * which line the phone is to be connected to
+ * @param ego ego to use for name resolution (when determining caller ID)
+ * @param event_handler how to notify the owner of the phone about events
+ * @param event_handler_cls closure for @a event_handler
+ * @return NULL on error (no valid line configured)
+ */
+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_Handle *h;
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "GNUNET_CONVERSATION_connect()\n");
- h = GNUNET_malloc (sizeof (struct GNUNET_CONVERSATION_Handle));
-
- h->cfg = cfg;
- h->call_handler = call_handler;
- h->reject_handler = reject_handler;
- h->notification_handler = notification_handler;
- h->missed_call_handler = missed_call_handler;
-
- if (NULL == (h->client = GNUNET_CLIENT_connect ("conversation", cfg)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not access CONVERSATION service\n");
- GNUNET_break (0);
- GNUNET_free (h);
-
- return NULL;
- }
+ struct GNUNET_CONVERSATION_Phone *phone;
+ unsigned long long line;
- if (NULL == (h->gns = GNUNET_GNS_connect (cfg)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not access GNS service\n");
- GNUNET_break (0);
- GNUNET_CLIENT_disconnect (h->client);
- GNUNET_free (h);
-
- return NULL;
- }
-
- if (NULL == (h->namestore = GNUNET_NAMESTORE_connect (cfg)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Could not access NAMESTORE service\n");
- GNUNET_break (0);
- GNUNET_CLIENT_disconnect (h->client);
- GNUNET_GNS_disconnect (h->gns);
- GNUNET_free (h);
-
- return NULL;
- }
-
- check_gns (h);
- GNUNET_CLIENT_receive (h->client, &receive_message_cb, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
-
- return h;
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ "CONVERSATION",
+ "LINE",
+ &line))
+ return NULL;
+ if (line >= (1 << 31))
+ return NULL;
+ 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.line = htonl ((uint32_t) line);
+ phone->my_record.version = htonl (0);
+ reconnect_phone (phone);
+ if ( (NULL == phone->client) ||
+ (NULL == phone->ns) )
+ {
+ GNUNET_break (0);
+ GNUNET_CONVERSATION_phone_destroy (phone);
+ return NULL;
+ }
+ return phone;
}
+/**
+ * Fill in a namestore record with the contact information
+ * for this phone. Note that the filled in "data" value
+ * is only valid until the phone is destroyed.
+ *
+ * @param phone phone to create a record for
+ * @param rd namestore record to fill in
+ */
void
-GNUNET_CONVERSATION_disconnect (struct GNUNET_CONVERSATION_Handle *handle)
+GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,
+ struct GNUNET_GNSRECORD_Data *rd)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "CONVERSATION DISCONNECT\n");
+ 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;
+}
- GNUNET_CLIENT_disconnect (handle->client);
- GNUNET_GNS_disconnect (handle->gns);
- GNUNET_free (handle);
- handle = NULL;
+/**
+ * Picks up a (ringing) phone. This will connect the speaker
+ * to the microphone of the other party, and vice versa.
+ *
+ * @param caller handle that identifies which caller should be answered
+ * @param event_handler how to notify about events by the caller
+ * @param event_handler_cls closure for @a event_handler
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
+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);
}
+/**
+ * Hang up up a (possibly ringing) phone. This will notify the other
+ * party that we are no longer interested in talking with them.
+ *
+ * @param caller conversation to hang up on
+ */
void
-GNUNET_CONVERSATION_call (struct GNUNET_CONVERSATION_Handle *h,
- const char *callee,
- int doGnsLookup)
+GNUNET_CONVERSATION_caller_hang_up (struct GNUNET_CONVERSATION_Caller *caller)
{
- struct GNUNET_PeerIdentity peer;
+ struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+ struct GNUNET_MQ_Envelope *e;
+ struct ClientPhoneHangupMessage *hang;
- if (NULL == h || NULL == h->client)
- return;
-
- if (GNUNET_YES == doGnsLookup)
+ switch (caller->state)
{
- gns_lookup_and_call (h, callee);
- return;
+ case CS_RESOLVE:
+ GNUNET_NAMESTORE_cancel (caller->qe);
+ caller->qe = NULL;
+ break;
+ case CS_ACTIVE:
+ caller->speaker->disable_speaker (caller->speaker->cls);
+ caller->mic->disable_microphone (caller->mic->cls);
+ break;
+ default:
+ break;
}
- if (GNUNET_OK !=
- GNUNET_CRYPTO_ecc_public_sign_key_from_string (callee,
- strlen (callee),
- &peer.public_key))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' is not a valid public key\n"),
- callee);
- h->notification_handler (NULL, h, GNUNET_CONVERSATION_NT_NO_PEER, NULL);
- return;
- }
- initiate_call (h, peer);
+ GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+ phone->caller_tail,
+ caller);
+ GNUNET_free_non_null (caller->caller_id_str);
+ GNUNET_free (caller);
+ e = GNUNET_MQ_msg (hang,
+ GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+ GNUNET_MQ_send (phone->mq, e);
}
+/**
+ * Destroys a phone.
+ *
+ * @param phone phone to destroy
+ */
void
-GNUNET_CONVERSATION_hangup (struct GNUNET_CONVERSATION_Handle *h)
+GNUNET_CONVERSATION_phone_destroy (struct GNUNET_CONVERSATION_Phone *phone)
{
- if (NULL == h || NULL == h->client)
- return;
-
- terminate_call (h);
+ 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;
+ }
+ if (NULL != phone->client)
+ {
+ GNUNET_CLIENT_disconnect (phone->client);
+ phone->client = NULL;
+ }
+ GNUNET_free (phone);
}
+/**
+ * Pause conversation of an active call. This will disconnect the speaker
+ * and the microphone. The call can later be resumed with
+ * #GNUNET_CONVERSATION_caller_resume.
+ *
+ * @param caller call to suspend
+ */
void
-GNUNET_CONVERSATION_accept (struct GNUNET_CONVERSATION_Handle *h)
+GNUNET_CONVERSATION_caller_suspend (struct GNUNET_CONVERSATION_Caller *caller)
{
- if (NULL == h || NULL == h->client)
- return;
+ struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+ struct GNUNET_MQ_Envelope *e;
+ struct ClientPhoneSuspendMessage *suspend;
- accept_call (h);
+ 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;
}
+/**
+ * Resume suspended conversation of a phone.
+ *
+ * @param caller call to resume
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
void
-GNUNET_CONVERSATION_reject (struct GNUNET_CONVERSATION_Handle *h)
+GNUNET_CONVERSATION_caller_resume (struct GNUNET_CONVERSATION_Caller *caller,
+ struct GNUNET_SPEAKER_Handle *speaker,
+ struct GNUNET_MICROPHONE_Handle *mic)
{
- if (NULL == h || NULL == h->client)
- return;
-
- reject_call (h);
+ 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 */
projects / oweals / gnunet.git / blobdiff