*/
struct GNUNET_PeerIdentity target;
+ /**
+ * Temporary buffer for audio data.
+ */
+ void *audio_data;
+
+ /**
+ * Number of bytes in @e audio_data.
+ */
+ size_t audio_size;
+
/**
* Our line number.
*/
GNUNET_MQ_destroy (line->reliable_mq);
line->reliable_mq = NULL;
}
+ if (NULL != line->unreliable_mth)
+ {
+ GNUNET_MESH_notify_transmit_ready_cancel (line->unreliable_mth);
+ line->unreliable_mth = NULL;
+ }
if (NULL != line->tunnel_unreliable)
{
GNUNET_MESH_tunnel_destroy (line->tunnel_unreliable);
GNUNET_CONTAINER_DLL_remove (lines_head,
lines_tail,
line);
+ GNUNET_free_non_null (line->audio_data);
GNUNET_free (line);
break;
}
line = GNUNET_SERVER_client_get_user_context (client, struct Line);
if (NULL != line)
{
+ GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
}
+/**
+ * Transmit audio data via unreliable mesh channel.
+ *
+ * @param cls the `struct Line` we are transmitting for
+ * @param size number of bytes available in @a buf
+ * @param buf where to copy the data
+ * @return number of bytes copied to @buf
+ */
+static size_t
+transmit_line_audio (void *cls,
+ size_t size,
+ void *buf)
+{
+ struct Line *line = cls;
+ struct MeshAudioMessage *mam = buf;
+
+ line->unreliable_mth = NULL;
+ if ( (NULL == buf) ||
+ (size < sizeof (struct MeshAudioMessage) + line->audio_size) )
+ {
+ /* eh, other error handling? */
+ return 0;
+ }
+ mam->header.size = htons (sizeof (struct MeshAudioMessage) + line->audio_size);
+ mam->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_MESH_AUDIO);
+ mam->remote_line = htonl (line->remote_line);
+ memcpy (&mam[1], line->audio_data, line->audio_size);
+ GNUNET_free (line->audio_data);
+ line->audio_data = NULL;
+ return sizeof (struct MeshAudioMessage) + line->audio_size;
+}
+
+
/**
* Function to handle audio data from the client
*
const struct GNUNET_MessageHeader *message)
{
const struct ClientAudioMessage *msg;
+ struct Line *line;
+ size_t size;
+ size = ntohs (message->size) - sizeof (struct ClientAudioMessage);
msg = (struct ClientAudioMessage *) message;
- GNUNET_break (0); // FIXME
+ line = GNUNET_SERVER_client_get_user_context (client, struct Line);
+ if (NULL == line)
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ switch (line->status)
+ {
+ case LS_CALLEE_LISTEN:
+ case LS_CALLEE_RINGING:
+ case LS_CALLER_CALLING:
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ case LS_CALLEE_CONNECTED:
+ case LS_CALLER_CONNECTED:
+ /* common case, handled below */
+ break;
+ case LS_CALLEE_SHUTDOWN:
+ case LS_CALLER_SHUTDOWN:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Mesh audio channel in shutdown; audio data dropped\n");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ if (NULL == line->tunnel_unreliable)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Mesh audio channel not ready; audio data dropped\n"));
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ if (NULL != line->unreliable_mth)
+ {
+ /* NOTE: we may want to not do this and instead combine the data */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Dropping previous audio data segment with %u bytes\n",
+ line->audio_size);
+ GNUNET_MESH_notify_transmit_ready_cancel (line->unreliable_mth);
+ GNUNET_free (line->audio_data);
+ }
+ line->audio_size = size;
+ line->audio_data = GNUNET_malloc (line->audio_size);
+ memcpy (line->audio_data,
+ &msg[1],
+ size);
+ line->unreliable_mth = GNUNET_MESH_notify_transmit_ready (line->tunnel_unreliable,
+ GNUNET_NO,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ sizeof (struct MeshAudioMessage)
+ + line->audio_size,
+ &transmit_line_audio,
+ line);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
"HANGUP message received for non-existing line, dropping tunnel.\n");
return GNUNET_SYSERR;
}
- hup = (struct ClientPhoneHangupMessage *) buf;
- hup->header.size = sizeof (buf);
- hup->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
- memcpy (&hup[1], reason, len);
- GNUNET_SERVER_notification_context_unicast (nc,
- line->client,
- &hup->header,
- GNUNET_NO);
- GNUNET_MESH_receive_done (tunnel);
*tunnel_ctx = NULL;
switch (line->status)
{
case LS_CALLEE_SHUTDOWN:
line->status = LS_CALLEE_LISTEN;
destroy_line_mesh_tunnels (line);
- break;
+ return GNUNET_OK;
case LS_CALLER_CALLING:
line->status = LS_CALLER_SHUTDOWN;
mq_done_finish_caller_shutdown (line);
break;
case LS_CALLER_SHUTDOWN:
mq_done_finish_caller_shutdown (line);
- break;
+ return GNUNET_OK;
}
+ hup = (struct ClientPhoneHangupMessage *) buf;
+ hup->header.size = sizeof (buf);
+ hup->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+ memcpy (&hup[1], reason, len);
+ GNUNET_SERVER_notification_context_unicast (nc,
+ line->client,
+ &hup->header,
+ GNUNET_NO);
+ GNUNET_MESH_receive_done (tunnel);
return GNUNET_OK;
}
{
const struct MeshPhonePickupMessage *msg;
struct Line *line = *tunnel_ctx;
+ const char *metadata;
+ size_t len = ntohs (message->size) - sizeof (struct MeshPhonePickupMessage);
+ char buf[len + sizeof (struct ClientPhonePickupMessage)];
+ struct ClientPhonePickupMessage *pick;
msg = (const struct MeshPhonePickupMessage *) message;
- GNUNET_break (0); // FIXME
-
-
+ len = ntohs (msg->header.size) - sizeof (struct MeshPhonePickupMessage);
+ metadata = (const char *) &msg[1];
+ if ( (0 == len) ||
+ ('\0' != metadata[len - 1]) )
+ {
+ metadata = NULL;
+ len = 0;
+ }
+ if (NULL == line)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "PICKUP message received for non-existing line, dropping tunnel.\n");
+ return GNUNET_SYSERR;
+ }
+ GNUNET_MESH_receive_done (tunnel);
+ switch (line->status)
+ {
+ case LS_CALLEE_LISTEN:
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ case LS_CALLEE_RINGING:
+ case LS_CALLEE_CONNECTED:
+ GNUNET_break_op (0);
+ destroy_line_mesh_tunnels (line);
+ line->status = LS_CALLEE_LISTEN;
+ return GNUNET_SYSERR;
+ case LS_CALLEE_SHUTDOWN:
+ GNUNET_break_op (0);
+ line->status = LS_CALLEE_LISTEN;
+ destroy_line_mesh_tunnels (line);
+ break;
+ case LS_CALLER_CALLING:
+ line->status = LS_CALLER_CONNECTED;
+ break;
+ case LS_CALLER_CONNECTED:
+ GNUNET_break_op (0);
+ return GNUNET_OK;
+ case LS_CALLER_SHUTDOWN:
+ GNUNET_break_op (0);
+ mq_done_finish_caller_shutdown (line);
+ return GNUNET_SYSERR;
+ }
+ pick = (struct ClientPhonePickupMessage *) buf;
+ pick->header.size = sizeof (buf);
+ pick->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP);
+ memcpy (&pick[1], metadata, len);
+ GNUNET_SERVER_notification_context_unicast (nc,
+ line->client,
+ &pick->header,
+ GNUNET_NO);
line->tunnel_unreliable = GNUNET_MESH_tunnel_create (mesh,
line,
&line->target,
GNUNET_APPLICATION_TYPE_CONVERSATION_AUDIO,
GNUNET_YES,
GNUNET_NO);
-
-
- GNUNET_MESH_receive_done (tunnel);
return GNUNET_OK;
}
const struct GNUNET_MessageHeader *message)
{
struct Line *line = *tunnel_ctx;
- const struct MeshPhoneBusyMessage *msg;
struct ClientPhoneBusyMessage busy;
-
- msg = (const struct MeshPhoneBusyMessage *) message;
+
if (NULL == line)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
const struct GNUNET_MessageHeader *message)
{
const struct MeshAudioMessage *msg;
+ struct Line *line = *tunnel_ctx;
+ struct GNUNET_PeerIdentity sender;
+ size_t msize = ntohs (message->size) - sizeof (struct MeshAudioMessage);
+ char buf[msize + sizeof (struct ClientAudioMessage)];
+ struct ClientAudioMessage *cam;
msg = (const struct MeshAudioMessage *) message;
- GNUNET_break (0); // FIXME
+ if (NULL == line)
+ {
+ sender = *GNUNET_MESH_tunnel_get_info (tunnel,
+ GNUNET_MESH_OPTION_PEER)->peer;
+ for (line = lines_head; NULL != line; line = line->next)
+ if ( (line->local_line == ntohl (msg->remote_line)) &&
+ (LS_CALLEE_CONNECTED == line->status) &&
+ (0 == memcmp (&line->target,
+ &sender,
+ sizeof (struct GNUNET_PeerIdentity))) &&
+ (NULL == line->tunnel_unreliable) )
+ break;
+ if (NULL == line)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received AUDIO data for non-existing line %u, dropping.\n",
+ ntohl (msg->remote_line));
+ return GNUNET_SYSERR;
+ }
+ line->tunnel_unreliable = tunnel;
+ *tunnel_ctx = line;
+ }
+ cam = (struct ClientAudioMessage *) buf;
+ cam->header.size = htons (sizeof (buf));
+ cam->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+ memcpy (&cam[1], &msg[1], msize);
+ GNUNET_SERVER_notification_context_unicast (nc,
+ line->client,
+ &cam->header,
+ GNUNET_YES);
GNUNET_MESH_receive_done (tunnel);
return GNUNET_OK;
}
GNUNET_CONTAINER_DLL_remove (lines_head,
lines_tail,
line);
+ GNUNET_free_non_null (line->audio_data);
GNUNET_free (line);
break;
case LS_CALLER_SHUTDOWN:
projects / oweals / gnunet.git / blobdiff