--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telepathygabble/src/gabble-media-session.c Tue Feb 02 01:10:06 2010 +0200
@@ -0,0 +1,3026 @@
+/*
+ * gabble-media-session.c - Source for GabbleMediaSession
+ * Copyright (C) 2006 Collabora Ltd.
+ *
+ * @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <dbus/dbus-glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "debug.h"
+#include "ansi.h"
+#include "handles.h"
+#include "namespaces.h"
+#include "util.h"
+
+#include "telepathy-errors.h"
+#include "telepathy-helpers.h"
+
+#include "gabble-connection.h"
+#include "gabble-media-channel.h"
+#include "gabble-media-stream.h"
+#include "gabble-presence-cache.h"
+#include "gabble-presence.h"
+
+#include "gabble-media-session.h"
+#include "gabble-media-session-signals-marshal.h"
+#include "gabble-media-session-glue.h"
+
+#include "gabble_enums.h"
+
+#ifndef EMULATOR
+G_DEFINE_TYPE(GabbleMediaSession, gabble_media_session, G_TYPE_OBJECT)
+#endif
+
+
+#define DEBUG_FLAG GABBLE_DEBUG_MEDIA
+//vinod
+#ifdef DEBUG_FLAG
+//#define DEBUG(format, ...)
+#define DEBUGGING 0
+//#define NODE_DEBUG(n, s);
+#endif /* DEBUG_FLAG */
+
+#define DEFAULT_SESSION_TIMEOUT 50000
+
+#define GTALK_STREAM_NAME "gtalk"
+
+/* 99 streams gives us a max name length of 8 (videoXX\0 or audioXX\0) */
+#define MAX_STREAMS 99
+
+#ifndef EMULATOR
+#define MAX_STREAM_NAME_LEN 8
+#endif
+
+//#define DEBUGGING 0
+
+/* signal enum */
+enum
+{
+ NEW_STREAM_HANDLER,
+ STREAM_ADDED,
+ TERMINATED,
+ LAST_SIGNAL
+};
+
+#ifdef EMULATOR
+#include "libgabble_wsd_solution.h"
+
+ GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_sess,guint)
+ #define signals (GET_WSD_VAR_NAME(signals,gabble_med_sess, s)())
+
+
+ GET_STATIC_VAR_FROM_TLS(google_audio_caps,gabble_med_sess,GabblePresenceCapabilities)
+ #define google_audio_caps (*GET_WSD_VAR_NAME(google_audio_caps,gabble_med_sess, s)())
+
+ GET_STATIC_VAR_FROM_TLS(jingle_audio_caps,gabble_med_sess,GabblePresenceCapabilities)
+ #define jingle_audio_caps (*GET_WSD_VAR_NAME(jingle_audio_caps,gabble_med_sess, s)())
+
+ GET_STATIC_VAR_FROM_TLS(jingle_video_caps,gabble_med_sess,GabblePresenceCapabilities)
+ #define jingle_video_caps (*GET_WSD_VAR_NAME(jingle_video_caps,gabble_med_sess, s)())
+
+ GET_STATIC_ARRAY_FROM_TLS(ret_sess,gabble_med_sess,gchar)
+ #define ret_sess (GET_WSD_VAR_NAME(ret_sess,gabble_med_sess, s)())
+
+ GET_STATIC_VAR_FROM_TLS(gabble_media_session_parent_class,gabble_med_sess,gpointer)
+ #define gabble_media_session_parent_class (*GET_WSD_VAR_NAME(gabble_media_session_parent_class,gabble_med_sess,s)())
+
+ GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_sess,GType)
+ #define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_med_sess,s)())
+
+
+ static void gabble_media_session_init (GabbleMediaSession *self);
+ static void gabble_media_session_class_init (GabbleMediaSessionClass *klass);
+ static void gabble_media_session_class_intern_init (gpointer klass)
+ {
+ gabble_media_session_parent_class = g_type_class_peek_parent (klass);
+ gabble_media_session_class_init ((GabbleMediaSessionClass*) klass); }
+
+ EXPORT_C GType gabble_media_session_get_type (void)
+ {
+ if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleMediaSessionClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_media_session_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMediaSession), 0, (GInstanceInitFunc) gabble_media_session_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMediaSession"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id;
+ }
+
+
+
+#else
+
+ static guint signals[LAST_SIGNAL] = {0};
+
+#endif
+
+/* properties */
+enum
+{
+ PROP_CONNECTION = 1,
+ PROP_MEDIA_CHANNEL,
+ PROP_OBJECT_PATH,
+ PROP_SESSION_ID,
+ PROP_INITIATOR,
+ PROP_PEER,
+ PROP_PEER_RESOURCE,
+ PROP_STATE,
+ LAST_PROPERTY
+};
+
+/* private structure */
+typedef struct _GabbleMediaSessionPrivate GabbleMediaSessionPrivate;
+
+struct _GabbleMediaSessionPrivate
+{
+ GabbleConnection *conn;
+ GabbleMediaChannel *channel;
+ GabbleMediaSessionMode mode;
+ gchar *object_path;
+
+ GPtrArray *streams;
+ GPtrArray *remove_requests;
+
+ gchar *id;
+ GabbleHandle peer;
+ gchar *peer_resource;
+
+ JingleSessionState state;
+ gboolean ready;
+ gboolean locally_accepted;
+ gboolean terminated;
+
+ guint timer_id;
+
+ gboolean dispose_has_run;
+};
+
+#define GABBLE_MEDIA_SESSION_GET_PRIVATE(obj) \
+ ((GabbleMediaSessionPrivate *)obj->priv)
+
+typedef struct {
+ gchar *name;
+ gchar *attributes;
+} SessionStateDescription;
+
+static const SessionStateDescription session_states[] =
+{
+ { "JS_STATE_PENDING_CREATED", ANSI_BOLD_ON ANSI_FG_BLACK ANSI_BG_WHITE },
+ { "JS_STATE_PENDING_INITIATE_SENT", ANSI_BOLD_ON ANSI_BG_CYAN },
+ { "JS_STATE_PENDING_INITIATED", ANSI_BOLD_ON ANSI_BG_MAGENTA },
+ { "JS_STATE_PENDING_ACCEPT_SENT", ANSI_BOLD_ON ANSI_BG_CYAN },
+ { "JS_STATE_ACTIVE", ANSI_BOLD_ON ANSI_BG_BLUE },
+ { "JS_STATE_ENDED", ANSI_BG_RED }
+};
+
+static void
+gabble_media_session_init (GabbleMediaSession *self)
+{
+ GabbleMediaSessionPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GABBLE_TYPE_MEDIA_SESSION, GabbleMediaSessionPrivate);
+
+ self->priv = priv;
+
+ priv->mode = MODE_JINGLE;
+ priv->state = JS_STATE_PENDING_CREATED;
+ priv->streams = g_ptr_array_new ();
+ priv->remove_requests = g_ptr_array_new ();
+}
+
+static void stream_connection_state_changed_cb (GabbleMediaStream *stream,
+ GParamSpec *param,
+ GabbleMediaSession *session);
+static void stream_got_local_codecs_changed_cb (GabbleMediaStream *stream,
+ GParamSpec *param,
+ GabbleMediaSession *session);
+
+static void
+_emit_new_stream (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ gchar *object_path;
+ guint id, media_type;
+
+ g_object_get (stream,
+ "object-path", &object_path,
+ "id", &id,
+ "media-type", &media_type,
+ NULL);
+
+ /* all of the streams are bidirectional from farsight's point of view, it's
+ * just in the signalling they change */
+ g_signal_emit (session, signals[NEW_STREAM_HANDLER], 0, object_path, id,
+ media_type, TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL);
+
+ g_free (object_path);
+}
+
+
+static GabbleMediaStream *
+_lookup_stream_by_name_and_initiator (GabbleMediaSession *session,
+ const gchar *stream_name,
+ JingleInitiator stream_initiator)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (g_strdiff (stream->name, stream_name))
+ continue;
+
+ if (stream_initiator != INITIATOR_INVALID &&
+ stream_initiator != stream->initiator)
+ continue;
+
+ return stream;
+ }
+
+ return NULL;
+}
+
+
+static GabbleMediaStream *
+create_media_stream (GabbleMediaSession *session,
+ const gchar *name,
+ JingleInitiator initiator,
+ guint media_type)
+{
+ GabbleMediaSessionPrivate *priv;
+ gchar *object_path;
+ GabbleMediaStream *stream;
+ guint id;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+ g_assert (name != NULL);
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ /* assert that if we're in google mode:
+ * - we only try to make one stream
+ * - it's an audio stream
+ * - it's called GTALK_STREAM_NAME */
+ if (priv->mode == MODE_GOOGLE)
+ {
+ g_assert (priv->streams->len == 0);
+ g_assert (media_type == TP_MEDIA_STREAM_TYPE_AUDIO);
+ g_assert (!g_strdiff (name, GTALK_STREAM_NAME));
+ }
+
+ g_assert (priv->streams->len < MAX_STREAMS);
+ g_assert (_lookup_stream_by_name_and_initiator (session, name, initiator) ==
+ NULL);
+
+ id = _gabble_media_channel_get_stream_id (priv->channel);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "creating new %s %s stream called \"%s\" with id %u",
+ priv->mode == MODE_GOOGLE ? "google" : "jingle",
+ media_type == TP_MEDIA_STREAM_TYPE_AUDIO ? "audio" : "video",
+ name, id);
+
+ object_path = g_strdup_printf ("%s/MediaStream%u", priv->object_path, id);
+
+ stream = g_object_new (GABBLE_TYPE_MEDIA_STREAM,
+ "connection", priv->conn,
+ "media-session", session,
+ "object-path", object_path,
+ "mode", priv->mode,
+ "name", name,
+ "id", id,
+ "initiator", initiator,
+ "media-type", media_type,
+ NULL);
+
+ g_signal_connect (stream, "notify::connection-state",
+ (GCallback) stream_connection_state_changed_cb,
+ session);
+ g_signal_connect (stream, "notify::got-local-codecs",
+ (GCallback) stream_got_local_codecs_changed_cb,
+ session);
+
+ g_ptr_array_add (priv->streams, stream);
+
+ g_free (object_path);
+
+ if (priv->ready)
+ _emit_new_stream (session, stream);
+
+ g_signal_emit (session, signals[STREAM_ADDED], 0, stream);
+
+ return stream;
+}
+
+static void
+destroy_media_stream (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ _gabble_media_stream_close (stream);
+ g_ptr_array_remove_fast (priv->streams, stream);
+ g_object_unref (stream);
+}
+
+static GObject *
+gabble_media_session_constructor (GType type, guint n_props,
+ GObjectConstructParam *props)
+{
+ GObject *obj;
+ GabbleMediaSessionPrivate *priv;
+ DBusGConnection *bus;
+
+ obj = G_OBJECT_CLASS (gabble_media_session_parent_class)->
+ constructor (type, n_props, props);
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (GABBLE_MEDIA_SESSION (obj));
+
+ bus = tp_get_bus ();
+ dbus_g_connection_register_g_object (bus, priv->object_path, obj);
+
+ return obj;
+}
+
+static void
+gabble_media_session_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ switch (property_id) {
+ case PROP_CONNECTION:
+ g_value_set_object (value, priv->conn);
+ break;
+ case PROP_MEDIA_CHANNEL:
+ g_value_set_object (value, priv->channel);
+ break;
+ case PROP_OBJECT_PATH:
+ g_value_set_string (value, priv->object_path);
+ break;
+ case PROP_SESSION_ID:
+ g_value_set_string (value, priv->id);
+ break;
+ case PROP_INITIATOR:
+ g_value_set_uint (value, session->initiator);
+ break;
+ case PROP_PEER:
+ g_value_set_uint (value, priv->peer);
+ break;
+ case PROP_PEER_RESOURCE:
+ g_value_set_string (value, priv->peer_resource);
+ break;
+ case PROP_STATE:
+ g_value_set_uint (value, priv->state);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void session_state_changed (GabbleMediaSession *session,
+ JingleSessionState prev_state,
+ JingleSessionState new_state);
+
+static void
+gabble_media_session_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ JingleSessionState prev_state;
+
+ switch (property_id) {
+ case PROP_CONNECTION:
+ priv->conn = g_value_get_object (value);
+ break;
+ case PROP_MEDIA_CHANNEL:
+ priv->channel = g_value_get_object (value);
+ break;
+ case PROP_OBJECT_PATH:
+ g_free (priv->object_path);
+ priv->object_path = g_value_dup_string (value);
+ break;
+ case PROP_SESSION_ID:
+ g_free (priv->id);
+ priv->id = g_value_dup_string (value);
+ break;
+ case PROP_INITIATOR:
+ session->initiator = g_value_get_uint (value);
+ break;
+ case PROP_PEER:
+ priv->peer = g_value_get_uint (value);
+ break;
+ case PROP_PEER_RESOURCE:
+ g_free (priv->peer_resource);
+ priv->peer_resource = g_value_dup_string (value);
+ break;
+ case PROP_STATE:
+ prev_state = priv->state;
+ priv->state = g_value_get_uint (value);
+
+ if (priv->state == JS_STATE_ENDED)
+ g_assert (priv->terminated);
+
+ if (priv->state != prev_state)
+ session_state_changed (session, prev_state, priv->state);
+
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void gabble_media_session_dispose (GObject *object);
+static void gabble_media_session_finalize (GObject *object);
+
+static void
+gabble_media_session_class_init (GabbleMediaSessionClass *gabble_media_session_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_session_class);
+ GParamSpec *param_spec;
+
+ g_type_class_add_private (gabble_media_session_class, sizeof (GabbleMediaSessionPrivate));
+
+ object_class->constructor = gabble_media_session_constructor;
+
+ object_class->get_property = gabble_media_session_get_property;
+ object_class->set_property = gabble_media_session_set_property;
+
+ object_class->dispose = gabble_media_session_dispose;
+ object_class->finalize = gabble_media_session_finalize;
+
+ param_spec = g_param_spec_object ("connection", "GabbleConnection object",
+ "Gabble connection object that owns this "
+ "media session's channel.",
+ GABBLE_TYPE_CONNECTION,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);
+
+ param_spec = g_param_spec_object ("media-channel", "GabbleMediaChannel object",
+ "Gabble media channel object that owns this "
+ "media session object.",
+ GABBLE_TYPE_MEDIA_CHANNEL,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_MEDIA_CHANNEL, param_spec);
+
+ param_spec = g_param_spec_string ("object-path", "D-Bus object path",
+ "The D-Bus object path used for this "
+ "object on the bus.",
+ NULL,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_OBJECT_PATH, param_spec);
+
+ param_spec = g_param_spec_string ("session-id", "Session ID",
+ "A unique session identifier used "
+ "throughout all communication.",
+ NULL,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_SESSION_ID, param_spec);
+
+ param_spec = g_param_spec_uint ("initiator", "Session initiator",
+ "An enum signifying which end initiated "
+ "the session.",
+ INITIATOR_LOCAL,
+ INITIATOR_REMOTE,
+ INITIATOR_LOCAL,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_INITIATOR, param_spec);
+
+ param_spec = g_param_spec_uint ("peer", "Session peer",
+ "The GabbleHandle representing the contact "
+ "with whom this session communicates.",
+ 0, G_MAXUINT32, 0,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_PEER, param_spec);
+
+ param_spec = g_param_spec_string ("peer-resource",
+ "Session peer's resource",
+ "The resource of the contact "
+ "with whom this session communicates, "
+ "if applicable",
+ NULL,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_WRITABLE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_PEER_RESOURCE,
+ param_spec);
+
+ param_spec = g_param_spec_uint ("state", "Session state",
+ "The current state that the session is in.",
+ 0, G_MAXUINT32, 0,
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_BLURB);
+ g_object_class_install_property (object_class, PROP_STATE, param_spec);
+
+ signals[NEW_STREAM_HANDLER] =
+ g_signal_new ("new-stream-handler",
+ G_OBJECT_CLASS_TYPE (gabble_media_session_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+ 0,
+ NULL, NULL,
+ gabble_media_session_marshal_VOID__STRING_UINT_UINT_UINT,
+ G_TYPE_NONE, 4, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+ signals[STREAM_ADDED] =
+ g_signal_new ("stream-added",
+ G_OBJECT_CLASS_TYPE (gabble_media_session_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+ 0,
+ NULL, NULL,
+ g_cclosure_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1, G_TYPE_OBJECT);
+
+ signals[TERMINATED] =
+ g_signal_new ("terminated",
+ G_OBJECT_CLASS_TYPE (gabble_media_session_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+ 0,
+ NULL, NULL,
+ gabble_media_session_marshal_VOID__UINT_UINT,
+ G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
+
+ dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_media_session_class), &dbus_glib_gabble_media_session_object_info);
+}
+
+static void
+gabble_media_session_dispose (GObject *object)
+{
+ GabbleMediaSession *self = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);
+ guint i;
+
+ gabble_debug (DEBUG_FLAG, "called");
+
+ if (priv->dispose_has_run)
+ return;
+
+ priv->dispose_has_run = TRUE;
+
+ _gabble_media_session_terminate (self, INITIATOR_LOCAL,
+ TP_CHANNEL_GROUP_CHANGE_REASON_NONE);
+
+ if (priv->timer_id != 0)
+ g_source_remove (priv->timer_id);
+
+ if (priv->streams != NULL)
+ {
+ for (i = 0; i < priv->streams->len; i++)
+ g_object_unref (g_ptr_array_index (priv->streams, i));
+ g_ptr_array_free (priv->streams, TRUE);
+ priv->streams = NULL;
+ }
+
+ for (i = 0; i < priv->remove_requests->len; i++)
+ g_ptr_array_free (g_ptr_array_index (priv->remove_requests, i), TRUE);
+ g_ptr_array_free (priv->remove_requests, TRUE);
+ priv->remove_requests = NULL;
+
+ if (G_OBJECT_CLASS (gabble_media_session_parent_class)->dispose)
+ G_OBJECT_CLASS (gabble_media_session_parent_class)->dispose (object);
+}
+
+static void
+gabble_media_session_finalize (GObject *object)
+{
+ GabbleMediaSession *self = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);
+
+ g_free (priv->id);
+ g_free (priv->object_path);
+ g_free (priv->peer_resource);
+ G_OBJECT_CLASS (gabble_media_session_parent_class)->finalize (object);
+}
+
+
+/**
+ * gabble_media_session_error
+ *
+ * Implements D-Bus method Error
+ * on interface org.freedesktop.Telepathy.Media.SessionHandler
+ *
+ * @error: Used to return a pointer to a GError detailing any error
+ * that occurred, D-Bus will throw the error only if this
+ * function returns FALSE.
+ *
+ * Returns: TRUE if successful, FALSE if an error was thrown.
+ */
+gboolean
+gabble_media_session_error (GabbleMediaSession *self,
+ guint errno,
+ const gchar *message,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv;
+ GPtrArray *tmp;
+ guint i;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (self));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);
+
+ _gabble_media_session_debug (self, DEBUG_MSG_INFO, "Media.SessionHandler::Error called, error %u (%s) -- "
+ "emitting error on each stream", errno, message);
+
+ if (priv->state == JS_STATE_ENDED)
+ {
+ return TRUE;
+ }
+ else if (priv->state == JS_STATE_PENDING_CREATED)
+ {
+ /* shortcut to prevent sending remove actions if we haven't sent an
+ * initiate yet */
+ g_object_set (self, "state", JS_STATE_ENDED, NULL);
+ return TRUE;
+ }
+
+ g_assert (priv->streams != NULL);
+
+ tmp = priv->streams;
+ priv->streams = NULL;
+
+ for (i = 0; i < tmp->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+ //FIXME: Temporary fix to comment "errno" to resolve the mecevo integration build break, fix me when this method is being used.
+ gabble_media_stream_error (stream, /*errno*/0, message, NULL);
+ }
+
+ g_ptr_array_free (tmp, TRUE);
+
+ return TRUE;
+}
+
+
+/**
+ * gabble_media_session_ready
+ *
+ * Implements D-Bus method Ready
+ * on interface org.freedesktop.Telepathy.Media.SessionHandler
+ *
+ * @error: Used to return a pointer to a GError detailing any error
+ * that occurred, D-Bus will throw the error only if this
+ * function returns FALSE.
+ *
+ * Returns: TRUE if successful, FALSE if an error was thrown.
+ */
+gboolean
+gabble_media_session_ready (GabbleMediaSession *self,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv;
+ guint i;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (self));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);
+
+ priv->ready = TRUE;
+
+ for (i = 0; i < priv->streams->len; i++)
+ _emit_new_stream (self, g_ptr_array_index (priv->streams, i));
+
+ return TRUE;
+}
+
+
+static gboolean
+_handle_create (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ GabbleMediaSessionMode session_mode;
+ TpMediaStreamType stream_type;
+ gboolean override_existing = FALSE;
+
+ if ((priv->state == JS_STATE_PENDING_CREATED) &&
+ (session->initiator == INITIATOR_LOCAL))
+ {
+ gabble_debug (DEBUG_FLAG, "we're trying to call ourselves, rejecting with busy");
+ _gabble_media_session_terminate (session, INITIATOR_REMOTE,
+ TP_CHANNEL_GROUP_CHANGE_REASON_BUSY);
+ return FALSE;
+ }
+
+
+ if (stream != NULL)
+ {
+ /* streams added by the session initiator may replace similarly-named
+ * streams which we are trying to add (but havn't had acknowledged) */
+ if (stream->signalling_state < STREAM_SIG_STATE_ACKNOWLEDGED)
+ {
+ if (session->initiator == INITIATOR_REMOTE)
+ {
+ override_existing = TRUE;
+ }
+ else
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_CONFLICT,
+ "session initiator is creating a stream named \"%s\" already",
+ stream_name);
+ return FALSE;
+ }
+ }
+ else
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_CONFLICT,
+ "can't create new stream called \"%s\", it already exists, "
+ "rejecting", stream_name);
+ return FALSE;
+ }
+ }
+
+ if (desc_node == NULL)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "unable to create stream without a content description");
+ return FALSE;
+ }
+
+ if (lm_message_node_has_namespace (desc_node,
+ NS_GOOGLE_SESSION_PHONE, NULL))
+ {
+ session_mode = MODE_GOOGLE;
+ stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;
+ }
+ else if (lm_message_node_has_namespace (desc_node,
+ NS_JINGLE_DESCRIPTION_AUDIO, NULL))
+ {
+ session_mode = MODE_JINGLE;
+ stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;
+ }
+ else if (lm_message_node_has_namespace (desc_node,
+ NS_JINGLE_DESCRIPTION_VIDEO, NULL))
+ {
+ session_mode = MODE_JINGLE;
+ stream_type = TP_MEDIA_STREAM_TYPE_VIDEO;
+ }
+ else
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR,
+ XMPP_ERROR_JINGLE_UNSUPPORTED_CONTENT,
+ "refusing to create stream for unsupported content description");
+ return FALSE;
+ }
+
+ /* MODE_GOOGLE is allowed to have a null transport node */
+ if (session_mode == MODE_JINGLE && trans_node == NULL)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR,
+ XMPP_ERROR_JINGLE_UNSUPPORTED_TRANSPORT,
+ "refusing to create stream for unsupported transport");
+ return FALSE;
+ }
+
+ if (session_mode != priv->mode)
+ {
+ if (priv->streams->len > 0)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_UNEXPECTED_REQUEST,
+ "refusing to change mode because streams already exist");
+ return FALSE;
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting session mode to %s",
+ session_mode == MODE_GOOGLE ? "google" : "jingle");
+ priv->mode = session_mode;
+ }
+ }
+
+ if (override_existing)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "removing our unacknowledged stream \"%s\" "
+ "in favour of the session initiator's", stream_name);
+
+ /* disappear this stream */
+ destroy_media_stream (session, stream);
+
+ stream = NULL;
+ }
+
+ if (priv->streams->len == MAX_STREAMS)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_RESOURCE_CONSTRAINT,
+ "refusing to create more than " G_STRINGIFY (MAX_STREAMS)
+ " streams");
+ return FALSE;
+ }
+
+ stream = create_media_stream (session, stream_name, INITIATOR_REMOTE,
+ stream_type);
+
+ /* set the signalling state to ACKNOWLEDGED */
+ g_object_set (stream,
+ "signalling-state", STREAM_SIG_STATE_ACKNOWLEDGED,
+ NULL);
+
+ /* for jingle streams, set the direction to none, so that the
+ * direction handler adds the right flags */
+ if (priv->mode == MODE_JINGLE)
+ g_object_set (stream,
+ "combined-direction", TP_MEDIA_STREAM_DIRECTION_NONE,
+ NULL);
+
+ return TRUE;
+}
+
+
+static TpMediaStreamDirection
+_senders_to_direction (GabbleMediaSession *session,
+ const gchar *senders)
+{
+ TpMediaStreamDirection ret = TP_MEDIA_STREAM_DIRECTION_NONE;
+
+ if (!g_strdiff (senders, "initiator"))
+ {
+ if (session->initiator == INITIATOR_LOCAL)
+ ret = TP_MEDIA_STREAM_DIRECTION_SEND;
+ else
+ ret = TP_MEDIA_STREAM_DIRECTION_RECEIVE;
+ }
+ else if (!g_strdiff (senders, "responder"))
+ {
+ if (session->initiator == INITIATOR_REMOTE)
+ ret = TP_MEDIA_STREAM_DIRECTION_SEND;
+ else
+ ret = TP_MEDIA_STREAM_DIRECTION_RECEIVE;
+ }
+ else if (!g_strdiff (senders, "both"))
+ {
+ ret = TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL;
+ }
+
+ return ret;
+}
+
+static gboolean
+_handle_direction (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ const gchar *senders;
+ CombinedStreamDirection new_combined_dir;
+ TpMediaStreamDirection requested_dir, current_dir;
+ TpMediaStreamPendingSend pending_send;
+
+ if (priv->mode == MODE_GOOGLE)
+ return TRUE;
+
+ requested_dir = TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL;
+
+ senders = lm_message_node_get_attribute (content_node, "senders");
+ if (senders != NULL)
+ requested_dir = _senders_to_direction (session, senders);
+
+ if (requested_dir == TP_MEDIA_STREAM_DIRECTION_NONE)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "received invalid content senders value \"%s\" on stream \"%s\"; "
+ "rejecting", senders, stream_name);
+ return FALSE;
+ }
+
+ current_dir = COMBINED_DIRECTION_GET_DIRECTION (stream->combined_direction);
+ pending_send = COMBINED_DIRECTION_GET_PENDING_SEND
+ (stream->combined_direction);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "received request for senders \"%s\" on stream "
+ "\"%s\"", senders, stream_name);
+
+ /* if local sending has been added, remove it,
+ * and set the pending local send flag */
+ if (((current_dir & TP_MEDIA_STREAM_DIRECTION_SEND) == 0) &&
+ ((requested_dir & TP_MEDIA_STREAM_DIRECTION_SEND) != 0))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting pending local send flag");
+ requested_dir &= ~TP_MEDIA_STREAM_DIRECTION_SEND;
+ pending_send |= TP_MEDIA_STREAM_PENDING_LOCAL_SEND;
+ }
+
+#if 0
+ /* clear any pending remote send */
+ if ((pending_send & TP_MEDIA_STREAM_PENDING_REMOTE_SEND) != 0)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting pending local send flag");
+ pending_send &= ~TP_MEDIA_STREAM_PENDING_REMOTE_SEND;
+ }
+#endif
+
+ /* make any necessary changes */
+ new_combined_dir = MAKE_COMBINED_DIRECTION (requested_dir, pending_send);
+ if (new_combined_dir != stream->combined_direction)
+ {
+ g_object_set (stream, "combined-direction", new_combined_dir, NULL);
+ _gabble_media_stream_update_sending (stream, FALSE);
+ }
+
+ return TRUE;
+}
+
+
+static gboolean
+_handle_accept (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ g_object_set (stream, "playing", TRUE, NULL);
+
+ _gabble_media_stream_update_sending (stream, TRUE);
+
+ return TRUE;
+}
+
+
+static gboolean
+_handle_codecs (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ if (desc_node == NULL)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "unable to handle codecs without a content description node");
+ return FALSE;
+ }
+
+ if (!_gabble_media_stream_post_remote_codecs (stream, message, desc_node,
+ error))
+ return FALSE;
+
+ return TRUE;
+}
+
+
+static gboolean
+_handle_candidates (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ if (trans_node == NULL)
+ {
+ if (priv->mode == MODE_GOOGLE)
+ {
+ trans_node = content_node;
+ }
+ else
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "unable to handle candidates without a transport node");
+ return FALSE;
+ }
+ }
+
+ if (!_gabble_media_stream_post_remote_candidates (stream, message,
+ trans_node, error))
+ return FALSE;
+
+ return TRUE;
+}
+
+static guint
+_count_non_removing_streams (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i, ret = 0;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->signalling_state < STREAM_SIG_STATE_REMOVING)
+ ret++;
+ }
+
+ return ret;
+}
+
+static gboolean
+_handle_remove (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ /* reducing a session to contain 0 streams is invalid; instead the peer
+ * should terminate the session. I guess we'll do it for them... */
+ if (_count_non_removing_streams (session) == 1)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "unable to remove the last stream in a Jingle call");
+ return FALSE;
+ }
+
+ /* close the stream */
+ destroy_media_stream (session, stream);
+
+ return TRUE;
+}
+
+
+static gboolean
+_handle_terminate (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error)
+{
+ gabble_debug (DEBUG_FLAG, "called for %s", stream_name);
+
+ _gabble_media_session_terminate (session, INITIATOR_REMOTE,
+ TP_CHANNEL_GROUP_CHANGE_REASON_NONE);
+
+ return TRUE;
+}
+
+
+#ifndef EMULATOR
+
+typedef gboolean (*StreamHandlerFunc)(GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ GabbleMediaStream *stream,
+ LmMessageNode *desc_node,
+ LmMessageNode *trans_node,
+ GError **error);
+
+typedef struct _Handler Handler;
+
+struct _Handler {
+ const gchar *actions[3];
+ JingleSessionState min_allowed_state;
+ JingleSessionState max_allowed_state;
+ StreamHandlerFunc stream_handlers[4];
+ JingleSessionState new_state;
+};
+
+static Handler handlers[] = {
+ {
+ { "initiate", "session-initiate", NULL },
+ JS_STATE_PENDING_CREATED,
+ JS_STATE_PENDING_CREATED,
+ { _handle_create, _handle_direction, _handle_codecs, NULL },
+ JS_STATE_PENDING_INITIATED
+ },
+ {
+ { "accept", "session-accept", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_PENDING_INITIATED,
+ { _handle_direction, _handle_codecs, _handle_accept, NULL },
+ JS_STATE_ACTIVE
+ },
+ {
+ { "reject", NULL },
+ JS_STATE_PENDING_INITIATE_SENT,
+ JS_STATE_PENDING_INITIATED,
+ { _handle_terminate, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { "terminate", "session-terminate", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_ENDED,
+ { _handle_terminate, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { "candidates", "transport-info", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_ACTIVE,
+ { _handle_candidates, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { "content-add", NULL },
+ JS_STATE_ACTIVE,
+ JS_STATE_ACTIVE,
+ { _handle_create, _handle_direction, _handle_codecs, NULL },
+ JS_STATE_INVALID,
+ },
+ {
+ { "content-modify", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_ACTIVE,
+ { _handle_direction, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { "content-accept", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_ACTIVE,
+ { _handle_direction, _handle_codecs, _handle_accept, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { "content-remove", "content-decline", NULL },
+ JS_STATE_PENDING_INITIATED,
+ JS_STATE_ACTIVE,
+ { _handle_remove, NULL },
+ JS_STATE_INVALID
+ },
+ {
+ { NULL },
+ JS_STATE_INVALID,
+ JS_STATE_INVALID,
+ { NULL },
+ JS_STATE_INVALID
+ }
+};
+#else
+
+Handler *_s_gabble_med_sess_handlers()
+ {
+ Handler* handler = libgabble_ImpurePtr()->_s_gabble_med_sess_handlers;
+ handler[0].stream_handlers[0] = _handle_create;
+ handler[0].stream_handlers[1] = _handle_direction;
+ handler[0].stream_handlers[2] = _handle_codecs;
+
+ handler[1].stream_handlers[0] = _handle_direction;
+ handler[1].stream_handlers[1] = _handle_codecs;
+ handler[1].stream_handlers[2] = _handle_accept;
+
+ handler[2].stream_handlers[0] = _handle_terminate;
+
+ handler[3].stream_handlers[0] = _handle_terminate;
+
+ handler[4].stream_handlers[0] = _handle_candidates;
+
+ handler[5].stream_handlers[0] = _handle_create;
+ handler[5].stream_handlers[0] = _handle_direction;
+ handler[5].stream_handlers[0] = _handle_codecs;
+
+ handler[6].stream_handlers[0] = _handle_direction;
+
+ handler[7].stream_handlers[0] = _handle_direction;
+ handler[7].stream_handlers[2] = _handle_codecs;
+ handler[7].stream_handlers[3] = _handle_accept;
+
+ handler[8].stream_handlers[0] = _handle_remove;
+
+
+ return handler;
+
+
+
+
+ }
+ #define handlers (GET_WSD_VAR_NAME(handlers,gabble_med_sess, s)())
+
+
+
+#endif
+
+
+static gboolean
+_call_handlers_on_stream (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *content_node,
+ const gchar *stream_name,
+ JingleInitiator stream_creator,
+ StreamHandlerFunc *func,
+ GError **error)
+{
+ GabbleMediaStream *stream = NULL;
+ LmMessageNode *desc_node = NULL, *trans_node = NULL;
+ StreamHandlerFunc *tmp;
+ gboolean stream_created = FALSE;
+
+ if (content_node != NULL)
+ {
+ desc_node = lm_message_node_get_child (content_node, "description");
+
+ trans_node = lm_message_node_get_child_with_namespace (content_node,
+ "transport", NS_GOOGLE_TRANSPORT_P2P);
+ }
+
+ for (tmp = func; *tmp != NULL; tmp++)
+ {
+ /* handlers may create the stream */
+ if (stream == NULL && stream_name != NULL)
+ stream = _lookup_stream_by_name_and_initiator (session, stream_name,
+ stream_creator);
+
+ /* the create handler is able to check whether or not the stream
+ * exists, and act accordingly (sometimes it will replace an existing
+ * stream, sometimes it will reject). the termination handler
+ * also requires no stream to do it's job. */
+ if (*tmp != _handle_create && *tmp != _handle_terminate)
+ {
+ /* all other handlers require the stream to exist */
+ if (stream == NULL)
+ {
+ const gchar *created = "";
+
+ if (stream_creator == INITIATOR_LOCAL)
+ created = "locally-created ";
+ else if (stream_creator == INITIATOR_REMOTE)
+ created = "remotely-created ";
+
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_ITEM_NOT_FOUND,
+ "unable to handle action for unknown %sstream \"%s\" ",
+ created, stream_name);
+
+ return FALSE;
+ }
+ else
+ {
+ /* don't do anything with actions on streams which have not been
+ * acknowledged, or that we're trying to remove, to deal with
+ * adding/removing race conditions (actions sent by the other end
+ * before they're aware that we've added or removed a stream) */
+ if (stream->signalling_state != STREAM_SIG_STATE_ACKNOWLEDGED)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_WARNING, "ignoring action because stream "
+ "%s is in state %d, not ACKNOWLEDGED", stream->name,
+ stream->signalling_state);
+ return TRUE;
+ }
+ }
+ }
+
+ if (!(*tmp) (session, message, content_node, stream_name, stream,
+ desc_node, trans_node, error))
+ {
+ /* if we successfully created the stream but failed to do something
+ * with it later, remove it */
+ if (stream_created)
+ destroy_media_stream (session, stream);
+
+ return FALSE;
+ }
+
+ if (*tmp == _handle_create)
+ {
+ stream_created = TRUE;
+ /* force a stream lookup after the create handler, even if we
+ * already had one (it has replacement semantics in certain
+ * situations) */
+ stream = NULL;
+ }
+ }
+
+ return TRUE;
+}
+
+
+static JingleInitiator
+_creator_to_initiator (GabbleMediaSession *session, const gchar *creator)
+{
+ if (!g_strdiff (creator, "initiator"))
+ {
+ if (session->initiator == INITIATOR_LOCAL)
+ return INITIATOR_LOCAL;
+ else
+ return INITIATOR_REMOTE;
+ }
+ else if (!g_strdiff (creator, "responder"))
+ {
+ if (session->initiator == INITIATOR_LOCAL)
+ return INITIATOR_REMOTE;
+ else
+ return INITIATOR_LOCAL;
+ }
+ else
+ return INITIATOR_INVALID;
+}
+
+
+static gboolean
+_call_handlers_on_streams (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *session_node,
+ StreamHandlerFunc *func,
+ GError **error)
+{
+ LmMessageNode *content_node;
+
+ if (lm_message_node_has_namespace (session_node, NS_GOOGLE_SESSION, NULL))
+ return _call_handlers_on_stream (session, message, session_node,
+ GTALK_STREAM_NAME, INITIATOR_INVALID, func, error);
+
+ if (session_node->children == NULL)
+ return _call_handlers_on_stream (session, message, NULL, NULL,
+ INITIATOR_INVALID, func, error);
+
+ for (content_node = session_node->children;
+ NULL != content_node;
+ content_node = content_node->next)
+ {
+ const gchar *stream_name, *stream_creator;
+ JingleInitiator stream_initiator;
+
+ if (g_strdiff (content_node->name, "content"))
+ continue;
+
+ stream_name = lm_message_node_get_attribute (content_node, "name");
+
+ if (stream_name == NULL)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "rejecting content node with no name");
+ return FALSE;
+ }
+
+ stream_creator = lm_message_node_get_attribute (content_node, "creator");
+ stream_initiator = _creator_to_initiator (session, stream_creator);
+
+ /* we allow NULL creator to mean INITIATOR_INVALID for backwards
+ * compatibility with clients that don't put a creator attribute in */
+ if (stream_creator != NULL && stream_initiator == INITIATOR_INVALID)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "rejecting content node with invalid creators value");
+ return FALSE;
+ }
+
+ if (!_call_handlers_on_stream (session, message, content_node,
+ stream_name, stream_initiator, func, error))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+gboolean
+_gabble_media_session_handle_action (GabbleMediaSession *session,
+ LmMessage *message,
+ LmMessageNode *session_node,
+ const gchar *action,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv;
+ StreamHandlerFunc *funcs = NULL;
+ JingleSessionState new_state = JS_STATE_INVALID;
+ Handler *i;
+
+#ifdef EMULATOR
+ gchar **tmp;
+#else
+ const gchar **tmp;
+#endif
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "got jingle session action \"%s\" from peer",
+ action);
+
+ /* do the state machine dance */
+
+ /* search the table of handlers for the action */
+ for (i = handlers; NULL != i->actions[0]; i++)
+ {
+ for (tmp = (char**)i->actions; NULL != *tmp; tmp++)
+ if (0 == strcmp (*tmp, action))
+ break;
+
+ if (NULL == *tmp)
+ continue;
+
+ /* if we're outside the allowable states for this action, return an error
+ * immediately */
+ if (priv->state < i->min_allowed_state ||
+ priv->state > i->max_allowed_state)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR,
+ XMPP_ERROR_JINGLE_OUT_OF_ORDER,
+ "action \"%s\" not allowed in current state", action);
+ goto ERROR;
+ }
+
+ funcs = i->stream_handlers;
+ new_state = i->new_state;
+
+ break;
+ }
+
+ /* pointer is not NULL if we found a matching action */
+ if (NULL == funcs)
+ {
+ g_set_error (error, GABBLE_XMPP_ERROR,
+ XMPP_ERROR_FEATURE_NOT_IMPLEMENTED, "action \"%s\" not implemented",
+ action);
+ goto ERROR;
+ }
+
+ /* call handlers if there are any (NULL-terminated array) */
+ if (NULL != *funcs)
+ {
+ if (!_call_handlers_on_streams (session, message, session_node, funcs,
+ error))
+ {
+ if (*error == NULL)
+ g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,
+ "unknown error encountered with action \"%s\"",
+ action);
+
+ goto ERROR;
+ }
+ }
+
+ /* acknowledge the IQ before changing the state because the new state
+ * could perform some actions which the other end will only accept
+ * if this action has been acknowledged */
+ _gabble_connection_acknowledge_set_iq (priv->conn, message);
+
+ /* if the action specified a new state to go to, set it */
+ if (JS_STATE_INVALID != new_state)
+ g_object_set (session, "state", new_state, NULL);
+
+ return TRUE;
+
+ERROR:
+ g_assert (error != NULL);
+ _gabble_media_session_debug (session, DEBUG_MSG_ERROR, (*error)->message);
+ return FALSE;
+}
+
+static gboolean
+timeout_session (gpointer data)
+{
+ GabbleMediaSession *session = data;
+
+ gabble_debug (DEBUG_FLAG, "session timed out");
+
+ _gabble_media_session_terminate (session, INITIATOR_LOCAL,
+ TP_CHANNEL_GROUP_CHANGE_REASON_ERROR);
+
+ return FALSE;
+}
+
+static void do_content_add (GabbleMediaSession *, GabbleMediaStream *);
+
+void
+_add_ready_new_streams (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_DUMP, "pondering accept-time add for stream: %s, got "
+ "local codecs: %s, initiator: %s, signalling state: %d", stream->name,
+ stream->got_local_codecs ? "true" : "false",
+ stream->initiator == INITIATOR_LOCAL ? "local" : "remote",
+ stream->signalling_state);
+
+ if (stream->got_local_codecs == FALSE)
+ continue;
+
+ if (stream->initiator == INITIATOR_REMOTE)
+ continue;
+
+ if (stream->signalling_state > STREAM_SIG_STATE_NEW)
+ continue;
+
+ do_content_add (session, stream);
+ }
+}
+
+static void
+session_state_changed (GabbleMediaSession *session,
+ JingleSessionState prev_state,
+ JingleSessionState new_state)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_EVENT, "state changed from %s to %s",
+ session_states[prev_state].name,
+ session_states[new_state].name);
+
+ /*
+ * If the state goes from CREATED to INITIATED (which means the remote
+ * end initiated), set the timer. If, OTOH, we're the end which just sent an
+ * initiate, set the timer.
+ */
+ if ((prev_state == JS_STATE_PENDING_CREATED &&
+ new_state == JS_STATE_PENDING_INITIATED) ||
+ (new_state == JS_STATE_PENDING_INITIATE_SENT))
+ {
+ priv->timer_id =
+ g_timeout_add (DEFAULT_SESSION_TIMEOUT, timeout_session, session);
+ }
+ else if (new_state == JS_STATE_ACTIVE)
+ {
+ g_source_remove (priv->timer_id);
+ priv->timer_id = 0;
+
+ /* signal any streams to the remote end which were added locally & became
+ * ready before the session was accepted, so haven't been mentioned yet */
+ _add_ready_new_streams (session);
+ }
+}
+
+static void
+_mark_local_streams_sent (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->initiator == INITIATOR_REMOTE)
+ continue;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "marking local stream %s as signalled", stream->name);
+
+ g_object_set (stream, "signalling-state", STREAM_SIG_STATE_SENT, NULL);
+ }
+}
+
+static void
+_mark_local_streams_acked (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->initiator == INITIATOR_REMOTE)
+ continue;
+
+ if (stream->signalling_state != STREAM_SIG_STATE_SENT)
+ continue;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "marking local stream %s as acknowledged", stream->name);
+
+ g_object_set (stream,
+ "signalling-state", STREAM_SIG_STATE_ACKNOWLEDGED,
+ NULL);
+ }
+}
+
+static void
+_set_remote_streams_playing (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->initiator == INITIATOR_LOCAL)
+ continue;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting remote stream %s as playing", stream->name);
+
+ g_object_set (stream, "playing", TRUE, NULL);
+ }
+}
+
+static const gchar *_direction_to_senders (GabbleMediaSession *,
+ TpMediaStreamDirection);
+
+static void
+_add_content_descriptions_one (GabbleMediaSession *session,
+ GabbleMediaStream *stream,
+ LmMessageNode *session_node)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessageNode *content_node;
+
+ if (priv->mode == MODE_GOOGLE)
+ {
+ content_node = session_node;
+ }
+ else
+ {
+ TpMediaStreamDirection direction;
+ TpMediaStreamPendingSend pending_send;
+
+ content_node = _gabble_media_stream_add_content_node (stream,
+ session_node);
+
+ direction = COMBINED_DIRECTION_GET_DIRECTION (stream->combined_direction);
+ pending_send = COMBINED_DIRECTION_GET_PENDING_SEND
+ (stream->combined_direction);
+
+ /* if we have a pending local send flag set, the signalled (ie understood
+ * by both ends) direction of the stream is assuming that we are actually
+ * sending, so we should OR that into the direction before deciding what
+ * to signal the stream with. we don't need to consider pending remote
+ * send because it doesn't happen in Jingle */
+
+ if ((pending_send & TP_MEDIA_STREAM_PENDING_LOCAL_SEND) != 0)
+ direction |= TP_MEDIA_STREAM_DIRECTION_SEND;
+
+ if (direction != TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL)
+ {
+ const gchar *senders;
+ senders = _direction_to_senders (session, direction);
+ lm_message_node_set_attribute (content_node, "senders", senders);
+ }
+ }
+
+ _gabble_media_stream_content_node_add_description (stream, content_node);
+
+ _gabble_media_stream_content_node_add_transport (stream, content_node);
+}
+
+static void
+_add_content_descriptions (GabbleMediaSession *session,
+ LmMessageNode *session_node,
+ JingleInitiator stream_initiator)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->initiator != stream_initiator)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "not adding content description for %s stream %s",
+ stream->initiator == INITIATOR_LOCAL ? "local" : "remote",
+ stream->name);
+ continue;
+ }
+
+ _add_content_descriptions_one (session, stream, session_node);
+ }
+}
+
+static LmHandlerResult
+accept_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ MSG_REPLY_CB_END_SESSION_IF_NOT_SUCCESSFUL (session, "accept failed");
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (stream->initiator == INITIATOR_LOCAL)
+ continue;
+
+ _gabble_media_stream_update_sending (stream, TRUE);
+ }
+
+ g_object_set (session, "state", JS_STATE_ACTIVE, NULL);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static gboolean
+_stream_not_ready_for_accept (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ /* locally initiated streams shouldn't delay acceptance */
+ if (stream->initiator == INITIATOR_LOCAL)
+ return FALSE;
+
+ if (!stream->got_local_codecs)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream %s does not yet have local codecs",
+ stream->name);
+
+ return TRUE;
+ }
+
+ if (stream->connection_state != TP_MEDIA_STREAM_STATE_CONNECTED)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream %s is not yet connected", stream->name);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+try_session_accept (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessage *msg;
+ LmMessageNode *session_node;
+ const gchar *action;
+ guint i;
+
+ if (priv->state < JS_STATE_ACTIVE && !priv->locally_accepted)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending accept yet, waiting for local "
+ "user to accept call");
+ return;
+ }
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (_stream_not_ready_for_accept (session, stream))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending accept yet, found a stream "
+ "which was not yet connected or was missing local codecs");
+ return;
+ }
+ }
+
+ if (priv->mode == MODE_GOOGLE)
+ action = "accept";
+ else
+ action = "session-accept";
+
+ /* construct a session acceptance message */
+ msg = _gabble_media_session_message_new (session, action, &session_node);
+
+ /* only accept REMOTE streams; any LOCAL streams were added by the local
+ * user before accepting and should be signalled after the accept */
+ _add_content_descriptions (session, session_node, INITIATOR_REMOTE);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action \"%s\" to peer",
+ action);
+
+ /* send the final acceptance message */
+ _gabble_connection_send_with_reply (priv->conn, msg, accept_msg_reply_cb,
+ G_OBJECT (session), NULL, NULL);
+
+ lm_message_unref (msg);
+
+ /* set remote streams playing */
+ _set_remote_streams_playing (session);
+
+ g_object_set (session, "state", JS_STATE_PENDING_ACCEPT_SENT, NULL);
+}
+
+static LmHandlerResult
+content_accept_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (user_data);
+ GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);
+
+ if (lm_message_get_sub_type (reply_msg) != LM_MESSAGE_SUB_TYPE_RESULT)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_ERROR, "content-accept failed; removing stream");
+ NODE_DEBUG (sent_msg->node, "message sent");
+ NODE_DEBUG (reply_msg->node, "message reply");
+
+ _gabble_media_session_remove_streams (session, &stream, 1);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+ }
+
+ _gabble_media_stream_update_sending (stream, TRUE);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static void
+try_content_accept (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessage *msg;
+ LmMessageNode *session_node;
+
+ g_assert (priv->state == JS_STATE_ACTIVE);
+ g_assert (priv->mode == MODE_JINGLE);
+
+ if (_stream_not_ready_for_accept (session, stream))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending content-accept yet, stream %s "
+ "is disconnected or missing local codecs", stream->name);
+ return;
+ }
+
+ /* send a content acceptance message */
+ msg = _gabble_media_session_message_new (session, "content-accept",
+ &session_node);
+
+ _add_content_descriptions_one (session, stream, session_node);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action \"content-accept\" "
+ "to peer for stream %s", stream->name);
+
+ _gabble_connection_send_with_reply (priv->conn, msg,
+ content_accept_msg_reply_cb, G_OBJECT (stream), session, NULL);
+
+ lm_message_unref (msg);
+
+ /* set stream playing */
+ g_object_set (stream, "playing", TRUE, NULL);
+}
+
+static LmHandlerResult
+initiate_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);
+
+ MSG_REPLY_CB_END_SESSION_IF_NOT_SUCCESSFUL (session, "initiate failed");
+
+ g_object_set (session, "state", JS_STATE_PENDING_INITIATED, NULL);
+
+ /* mark all of the streams that we sent in the initiate as acknowledged */
+ _mark_local_streams_acked (session);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static gboolean
+_stream_not_ready_for_initiate (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ if (!stream->got_local_codecs)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream %s does not yet have local codecs",
+ stream->name);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+try_session_initiate (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessage *msg;
+ LmMessageNode *session_node;
+ const gchar *action;
+ guint i;
+
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+
+ if (_stream_not_ready_for_initiate (session, stream))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending initiate yet, found a stream "
+ "which was missing local codecs");
+ return;
+ }
+ }
+
+ if (priv->mode == MODE_GOOGLE)
+ action = "initiate";
+ else
+ action = "session-initiate";
+
+ msg = _gabble_media_session_message_new (session, action, &session_node);
+
+ _add_content_descriptions (session, session_node, INITIATOR_LOCAL);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle action \"%s\" to peer", action);
+
+ _gabble_connection_send_with_reply (priv->conn, msg, initiate_msg_reply_cb,
+ G_OBJECT (session), NULL, NULL);
+
+ lm_message_unref (msg);
+
+ /* mark local streams as sent (so that eg candidates will be sent) */
+ _mark_local_streams_sent (session);
+
+ g_object_set (session, "state", JS_STATE_PENDING_INITIATE_SENT, NULL);
+}
+
+static LmHandlerResult
+content_add_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (user_data);
+ GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);
+
+ if (lm_message_get_sub_type (reply_msg) != LM_MESSAGE_SUB_TYPE_RESULT)
+ {
+ if (session->initiator == INITIATOR_REMOTE &&
+ stream->signalling_state == STREAM_SIG_STATE_ACKNOWLEDGED)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "ignoring content-add failure, stream has "
+ "been successfully created by the session initiator");
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_ERROR, "content-add failed; removing stream");
+ NODE_DEBUG (sent_msg->node, "message sent");
+ NODE_DEBUG (reply_msg->node, "message reply");
+
+ _gabble_media_stream_close (stream);
+ }
+ }
+ else
+ {
+ if (stream->signalling_state == STREAM_SIG_STATE_SENT)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "content-add succeeded, marking stream as "
+ "ACKNOWLEDGED");
+
+ g_object_set (stream,
+ "signalling-state", STREAM_SIG_STATE_ACKNOWLEDGED,
+ NULL);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "content-add succeeded, but not marking"
+ "stream as ACKNOWLEDGED, it's in state %d",
+ stream->signalling_state);
+ }
+ }
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static void
+do_content_add (GabbleMediaSession *session,
+ GabbleMediaStream *stream)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessage *msg;
+ LmMessageNode *session_node;
+
+ g_assert (priv->state == JS_STATE_ACTIVE);
+ g_assert (priv->mode == MODE_JINGLE);
+
+ if (_stream_not_ready_for_initiate (session, stream))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_ERROR, "trying to send content-add for stream %s "
+ "but we have no local codecs. what?!", stream->name);
+ g_assert_not_reached ();
+ return;
+ }
+
+ msg = _gabble_media_session_message_new (session, "content-add",
+ &session_node);
+
+ _add_content_descriptions_one (session, stream, session_node);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle action \"content-add\" to peer for "
+ "stream %s", stream->name);
+
+ _gabble_connection_send_with_reply (priv->conn, msg,
+ content_add_msg_reply_cb, G_OBJECT (stream), session, NULL);
+
+ lm_message_unref (msg);
+
+ /* mark stream as sent */
+ g_object_set (stream, "signalling-state", STREAM_SIG_STATE_SENT, NULL);
+}
+
+static void
+stream_connection_state_changed_cb (GabbleMediaStream *stream,
+ GParamSpec *param,
+ GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ if (stream->connection_state != TP_MEDIA_STREAM_STATE_CONNECTED)
+ return;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream %s has gone connected", stream->name);
+
+ if (stream->playing)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "doing nothing, stream is already playing");
+ return;
+ }
+
+ /* after session is active, we do things per-stream with content-* actions */
+ if (priv->state < JS_STATE_ACTIVE)
+ {
+ /* send a session accept if the session was initiated by the peer */
+ if (session->initiator == INITIATOR_REMOTE)
+ {
+ try_session_accept (session);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "session initiated by us, so we're not "
+ "going to consider sending an accept");
+ }
+ }
+ else
+ {
+ /* send a content accept if the stream was added by the peer */
+ if (stream->initiator == INITIATOR_REMOTE)
+ {
+ try_content_accept (session, stream);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream added by us, so we're not going "
+ "to send an accept");
+ }
+ }
+}
+
+static void
+stream_got_local_codecs_changed_cb (GabbleMediaStream *stream,
+ GParamSpec *param,
+ GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ if (!stream->got_local_codecs)
+ return;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream %s has got local codecs", stream->name);
+
+ if (stream->playing)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_ERROR, "stream was already playing and we got local "
+ "codecs. what?!");
+ g_assert_not_reached ();
+ return;
+ }
+
+ /* after session is active, we do things per-stream with content-* actions */
+ if (priv->state < JS_STATE_ACTIVE)
+ {
+ if (session->initiator == INITIATOR_REMOTE)
+ {
+ if (priv->state < JS_STATE_PENDING_ACCEPT_SENT)
+ {
+ try_session_accept (session);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream added after sending accept; "
+ "not doing content-add until remote end acknowledges");
+ }
+ }
+ else
+ {
+ if (priv->state < JS_STATE_PENDING_INITIATE_SENT)
+ {
+ try_session_initiate (session);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "stream added after sending initiate; "
+ "not doing content-add until remote end accepts");
+ }
+ }
+ }
+ else
+ {
+ if (stream->initiator == INITIATOR_REMOTE)
+ {
+ try_content_accept (session, stream);
+ }
+ else
+ {
+ do_content_add (session, stream);
+ }
+ }
+}
+
+static gchar *
+get_jid_for_contact (GabbleMediaSession *session,
+ GabbleHandle handle)
+{
+ GabbleMediaSessionPrivate *priv;
+ const gchar *base_jid;
+ GabbleHandle self;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ self = priv->conn->self_handle;
+
+ base_jid = gabble_handle_inspect (priv->conn->handles,
+ TP_HANDLE_TYPE_CONTACT, handle);
+ g_assert (base_jid != NULL);
+
+ if (handle == self)
+ {
+ gchar *resource, *ret;
+ g_object_get (priv->conn, "resource", &resource, NULL);
+ g_assert (resource != NULL);
+ ret = g_strdup_printf ("%s/%s", base_jid, resource);
+ g_free (resource);
+ return ret;
+ }
+ else
+ {
+ g_assert (priv->peer_resource != NULL);
+ return g_strdup_printf ("%s/%s", base_jid, priv->peer_resource);
+ }
+}
+
+LmMessage *
+_gabble_media_session_message_new (GabbleMediaSession *session,
+ const gchar *action,
+ LmMessageNode **session_node)
+{
+ GabbleMediaSessionPrivate *priv;
+ LmMessage *msg;
+ LmMessageNode *iq_node, *node;
+ gchar *peer_jid, *initiator_jid;
+ GabbleHandle initiator_handle;
+ const gchar *element, *xmlns;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ peer_jid = get_jid_for_contact (session, priv->peer);
+
+ msg = lm_message_new_with_sub_type (
+ peer_jid,
+ LM_MESSAGE_TYPE_IQ,
+ LM_MESSAGE_SUB_TYPE_SET);
+
+ g_free (peer_jid);
+
+ iq_node = lm_message_get_node (msg);
+
+ if (priv->mode == MODE_GOOGLE)
+ element = "session";
+ else
+ element = "jingle";
+
+ if (session->initiator == INITIATOR_LOCAL)
+ initiator_handle = priv->conn->self_handle;
+ else
+ initiator_handle = priv->peer;
+
+ node = lm_message_node_add_child (iq_node, element, NULL);
+ initiator_jid = get_jid_for_contact (session, initiator_handle);
+
+ lm_message_node_set_attributes (node,
+ (priv->mode == MODE_GOOGLE) ? "id" : "sid", priv->id,
+ (priv->mode == MODE_GOOGLE) ? "type" : "action", action,
+ "initiator", initiator_jid,
+ NULL);
+
+ if (priv->mode == MODE_GOOGLE)
+ xmlns = NS_GOOGLE_SESSION;
+ else
+ xmlns = NS_JINGLE;
+
+ lm_message_node_set_attribute (node, "xmlns", xmlns);
+ g_free (initiator_jid);
+
+ if (session_node)
+ *session_node = node;
+
+ return msg;
+}
+
+void
+_gabble_media_session_accept (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ guint i;
+
+ priv->locally_accepted = TRUE;
+
+ /* accept any local pending sends */
+ for (i = 0; i < priv->streams->len; i++)
+ {
+ GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);
+ CombinedStreamDirection combined_dir = stream->combined_direction;
+ TpMediaStreamDirection current_dir;
+ TpMediaStreamPendingSend pending_send;
+
+ current_dir = COMBINED_DIRECTION_GET_DIRECTION (combined_dir);
+ pending_send = COMBINED_DIRECTION_GET_PENDING_SEND (combined_dir);
+
+ if ((pending_send & TP_MEDIA_STREAM_PENDING_LOCAL_SEND) != 0)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "accepting pending local send on stream %s",
+ stream->name);
+
+ current_dir |= TP_MEDIA_STREAM_DIRECTION_SEND;
+ pending_send &= ~TP_MEDIA_STREAM_PENDING_LOCAL_SEND;
+ combined_dir = MAKE_COMBINED_DIRECTION (current_dir, pending_send);
+ g_object_set (stream, "combined-direction", combined_dir, NULL);
+ _gabble_media_stream_update_sending (stream, FALSE);
+ }
+ }
+
+ try_session_accept (session);
+}
+
+static LmHandlerResult
+content_remove_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ GPtrArray *removing = (GPtrArray *) user_data;
+ guint i;
+
+ MSG_REPLY_CB_END_SESSION_IF_NOT_SUCCESSFUL (session, "stream removal failed");
+
+ for (i = 0; i < removing->len; i++)
+ destroy_media_stream (session,
+ GABBLE_MEDIA_STREAM (g_ptr_array_index (removing, i)));
+
+ g_ptr_array_remove_fast (priv->remove_requests, removing);
+ g_ptr_array_free (removing, TRUE);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+void
+_gabble_media_session_remove_streams (GabbleMediaSession *session,
+ GabbleMediaStream **streams,
+ guint len)
+{
+ GabbleMediaSessionPrivate *priv;
+ LmMessage *msg = NULL;
+ LmMessageNode *session_node;
+ GPtrArray *removing = NULL;
+ guint i;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ /* end the session if there'd be no streams left after reducing it */
+ if (_count_non_removing_streams (session) == len)
+ {
+ _gabble_media_session_terminate (session, INITIATOR_LOCAL,
+ TP_CHANNEL_GROUP_CHANGE_REASON_NONE);
+ return;
+ }
+
+ /* construct a remove message if we're in a state greater than CREATED (ie
+ * something has been sent/received about this session) */
+ if (priv->state > JS_STATE_PENDING_CREATED)
+ {
+ msg = _gabble_media_session_message_new (session, "content-remove",
+ &session_node);
+ removing = g_ptr_array_sized_new (len);
+ }
+
+ /* right, remove them */
+ for (i = 0; i < len; i++)
+ {
+ GabbleMediaStream *stream = streams[i];
+
+ switch (stream->signalling_state)
+ {
+ case STREAM_SIG_STATE_NEW:
+ destroy_media_stream (session, stream);
+ break;
+ case STREAM_SIG_STATE_SENT:
+ case STREAM_SIG_STATE_ACKNOWLEDGED:
+ {
+ LmMessageNode *content_node;
+
+ g_assert (msg != NULL);
+ g_assert (removing != NULL);
+
+ content_node = _gabble_media_stream_add_content_node (stream,
+ session_node);
+
+ g_object_set (stream,
+ "playing", FALSE,
+ "signalling-state", STREAM_SIG_STATE_REMOVING,
+ NULL);
+
+ /* close the stream now, but don't forget about it until the
+ * removal message is acknowledged, since we need to be able to
+ * detect content-remove cross-talk */
+ _gabble_media_stream_close (stream);
+ g_ptr_array_add (removing, stream);
+ }
+ break;
+ case STREAM_SIG_STATE_REMOVING:
+ break;
+ }
+ }
+
+ /* send the remove message if necessary */
+ if (msg != NULL)
+ {
+ if (removing->len > 0)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action "
+ "\"content-remove\" to peer");
+
+ _gabble_connection_send_with_reply (priv->conn, msg,
+ content_remove_msg_reply_cb, G_OBJECT (session), removing, NULL);
+
+ g_ptr_array_add (priv->remove_requests, removing);
+ }
+ else
+ {
+ g_ptr_array_free (removing, TRUE);
+ }
+
+ lm_message_unref (msg);
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending jingle session action "
+ "\"content-remove\" to peer, no initiates or adds sent for "
+ "these streams");
+ }
+}
+
+/* for when you want the reply to be removed from
+ * the handler chain, but don't care what it is */
+static LmHandlerResult
+ignore_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static void
+send_reject_message (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ LmMessage *msg;
+ LmMessageNode *session_node;
+
+ /* this should only happen in google mode, and we should only arrive in that
+ * mode when we've ended up talking to a resource that doesn't support
+ * jingle */
+ g_assert (priv->mode == MODE_GOOGLE);
+ g_assert (priv->peer_resource != NULL);
+
+ /* construct a session terminate message */
+ msg = _gabble_media_session_message_new (session, "reject", &session_node);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action \"reject\" to peer");
+
+ /* send it */
+ _gabble_connection_send_with_reply (priv->conn, msg, ignore_reply_cb,
+ G_OBJECT (session), NULL, NULL);
+
+ lm_message_unref (msg);
+}
+
+static void
+send_terminate_message (GabbleMediaSession *session)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ const gchar *action;
+ LmMessage *msg;
+ LmMessageNode *session_node;
+
+ /* construct a session terminate message */
+ if (priv->mode == MODE_GOOGLE)
+ action = "terminate";
+ else
+ action = "session-terminate";
+
+ msg = _gabble_media_session_message_new (session, action, &session_node);
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action \"%s\" to peer",
+ action);
+
+ /* send it */
+ _gabble_connection_send_with_reply (priv->conn, msg, ignore_reply_cb,
+ G_OBJECT (session), NULL, NULL);
+
+ lm_message_unref (msg);
+}
+
+void
+_gabble_media_session_terminate (GabbleMediaSession *session,
+ JingleInitiator who,
+ TpChannelGroupChangeReason why)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ GabbleHandle actor;
+
+ if (priv->state == JS_STATE_ENDED)
+ return;
+
+ if (who == INITIATOR_REMOTE)
+ {
+ actor = priv->peer;
+ }
+ else
+ {
+ actor = priv->conn->self_handle;
+
+ /* Need to tell them that it's all over. */
+
+ /* Jingle doesn't have a "reject" action; a termination before an
+ * acceptance indicates that the call has been declined */
+
+ if (session->initiator == INITIATOR_REMOTE &&
+ priv->state == JS_STATE_PENDING_INITIATED &&
+ priv->mode == MODE_GOOGLE)
+ {
+ send_reject_message (session);
+ }
+
+ /* if we're still in CREATED, then we've not sent or received any
+ * messages about this session yet, so no terminate is necessary */
+ else if (priv->state > JS_STATE_PENDING_CREATED)
+ {
+ send_terminate_message (session);
+ }
+
+ while (priv->streams->len > 0)
+ destroy_media_stream (session, g_ptr_array_index (priv->streams, 0));
+ }
+
+ priv->terminated = TRUE;
+ g_object_set (session, "state", JS_STATE_ENDED, NULL);
+ g_signal_emit (session, signals[TERMINATED], 0, actor, why);
+}
+
+#if _GMS_DEBUG_LEVEL
+void
+_gabble_media_session_debug (GabbleMediaSession *session,
+ DebugMessageType type,
+ const gchar *format, ...)
+{
+ if (DEBUGGING)
+ {
+ va_list list;
+ gchar buf[512];
+ GabbleMediaSessionPrivate *priv;
+ time_t curtime;
+ struct tm *loctime;
+ gchar stamp[10];
+ const gchar *type_str;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ curtime = time (NULL);
+ loctime = localtime (&curtime);
+
+ strftime (stamp, sizeof (stamp), "%T", loctime);
+
+ va_start (list, format);
+
+ vsnprintf (buf, sizeof (buf), format, list);
+
+ va_end (list);
+
+ switch (type) {
+ case DEBUG_MSG_INFO:
+ type_str = ANSI_BOLD_ON ANSI_FG_WHITE;
+ break;
+ case DEBUG_MSG_DUMP:
+ type_str = ANSI_BOLD_ON ANSI_FG_GREEN;
+ break;
+ case DEBUG_MSG_WARNING:
+ type_str = ANSI_BOLD_ON ANSI_FG_YELLOW;
+ break;
+ case DEBUG_MSG_ERROR:
+ type_str = ANSI_BOLD_ON ANSI_FG_WHITE ANSI_BG_RED;
+ break;
+ case DEBUG_MSG_EVENT:
+ type_str = ANSI_BOLD_ON ANSI_FG_CYAN;
+ break;
+ default:
+ g_assert_not_reached ();
+ return;
+ }
+
+ g_message ("[%s%s%s] %s%-26s%s %s%s%s\n",
+ ANSI_BOLD_ON ANSI_FG_WHITE,
+ stamp,
+ ANSI_RESET,
+ session_states[priv->state].attributes,
+ session_states[priv->state].name,
+ ANSI_RESET,
+ type_str,
+ buf,
+ ANSI_RESET);
+
+ fflush (stdout);
+ }
+}
+
+#endif /* _GMS_DEBUG_LEVEL */
+
+static const gchar *
+_name_stream (GabbleMediaSession *session,
+ TpMediaStreamType media_type)
+{
+ GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+#ifndef EMULATOR
+ static gchar ret_sess[MAX_STREAM_NAME_LEN] = GTALK_STREAM_NAME;
+#endif
+
+ if (priv->mode != MODE_GOOGLE)
+ {
+ guint i = 1;
+
+ do {
+ g_snprintf (ret_sess, MAX_STREAM_NAME_LEN, "%s%u",
+ media_type == TP_MEDIA_STREAM_TYPE_AUDIO ? "audio" : "video",
+ i++);
+
+ /* even though we now have seperate namespaces for local and remote,
+ * actually check in both so that we can still support clients which
+ * have 1 namespace (such as our older selves :D) */
+ if (_lookup_stream_by_name_and_initiator (session, ret_sess,
+ INITIATOR_INVALID) != NULL)
+ {
+ ret_sess[0] = '\0';
+ }
+ } while (ret_sess[0] == '\0');
+ }
+
+ return ret_sess;
+}
+
+
+gboolean
+_gabble_media_session_request_streams (GabbleMediaSession *session,
+ const GArray *media_types,
+ GPtrArray **ret,
+ GError **error)
+{
+
+#ifndef EMULATOR
+ static GabblePresenceCapabilities google_audio_caps =
+ PRESENCE_CAP_GOOGLE_VOICE;
+ static GabblePresenceCapabilities jingle_audio_caps =
+ PRESENCE_CAP_JINGLE | PRESENCE_CAP_JINGLE_DESCRIPTION_AUDIO |
+ PRESENCE_CAP_GOOGLE_TRANSPORT_P2P;
+ static GabblePresenceCapabilities jingle_video_caps =
+ PRESENCE_CAP_JINGLE | PRESENCE_CAP_JINGLE_DESCRIPTION_VIDEO |
+ PRESENCE_CAP_GOOGLE_TRANSPORT_P2P;
+#endif
+
+ GabbleMediaSessionPrivate *priv;
+ GabblePresence *presence;
+ gboolean want_audio, want_video;
+ GabblePresenceCapabilities jingle_desired_caps;
+ guint idx;
+ gchar *dump;
+
+ g_assert (GABBLE_IS_MEDIA_SESSION (session));
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ presence = gabble_presence_cache_get (priv->conn->presence_cache,
+ priv->peer);
+
+ if (presence == NULL)
+ {
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "member has no audio/video capabilities");
+
+ return FALSE;
+ }
+
+ dump = gabble_presence_dump (presence);
+ _gabble_media_session_debug (session, DEBUG_MSG_DUMP, "presence for peer %d:\n%s", priv->peer, dump);
+ g_free (dump);
+
+ want_audio = want_video = FALSE;
+
+ for (idx = 0; idx < media_types->len; idx++)
+ {
+ guint media_type = g_array_index (media_types, guint, idx);
+
+ if (media_type == TP_MEDIA_STREAM_TYPE_AUDIO)
+ {
+ want_audio = TRUE;
+ }
+ else if (media_type == TP_MEDIA_STREAM_TYPE_VIDEO)
+ {
+ want_video = TRUE;
+ }
+ else
+ {
+ g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,
+ "given media type %u is invalid", media_type);
+ return FALSE;
+ }
+ }
+
+ /* work out what we'd need to do these streams with jingle */
+ jingle_desired_caps = 0;
+
+ if (want_audio)
+ jingle_desired_caps |= jingle_audio_caps;
+
+ if (want_video)
+ jingle_desired_caps |= jingle_video_caps;
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "want audio: %s; want video: %s",
+ want_audio ? "yes" : "no", want_video ? "yes" : "no");
+
+ /* existing call; the recipient and the mode has already been decided */
+ if (priv->peer_resource)
+ {
+ /* is a google call... we have no other option */
+ if (priv->mode == MODE_GOOGLE)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "already in Google mode; can't add new "
+ "stream");
+
+ g_assert (priv->streams->len == 1);
+
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "Google Talk calls may only contain one stream");
+
+ return FALSE;
+ }
+
+ if (!gabble_presence_resource_has_caps (presence, priv->peer_resource,
+ jingle_desired_caps))
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "in Jingle mode but have insufficient caps for requested streams");
+
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "existing call member doesn't support all requested media"
+ " types");
+
+ return FALSE;
+ }
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "in Jingle mode, and have necessary caps");
+ }
+
+ /* no existing call; we should choose a recipient and a mode */
+ else
+ {
+ const gchar *resource;
+
+ g_assert (priv->streams->len == 0);
+
+ /* see if we have a fully-capable jingle resource; regardless of the
+ * desired media type it's best if we can add/remove the others later */
+ resource = gabble_presence_pick_resource_by_caps (presence,
+ jingle_audio_caps | jingle_video_caps);
+
+ if (resource == NULL)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "contact is not fully jingle-capable");
+
+ /* ok, no problem. see if we can do just what's wanted with jingle */
+ resource = gabble_presence_pick_resource_by_caps (presence,
+ jingle_desired_caps);
+
+ if (resource == NULL && want_audio && !want_video)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "contact doesn't have desired Jingle capabilities");
+
+ /* last ditch... if we want only audio and not video, we can make
+ * do with google talk */
+ resource = gabble_presence_pick_resource_by_caps (presence,
+ google_audio_caps);
+
+ if (resource != NULL)
+ {
+ /* only one stream possible with google */
+ if (media_types->len == 1)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "contact has no Jingle capabilities; "
+ "falling back to Google audio call");
+ priv->mode = MODE_GOOGLE;
+ }
+ else
+ {
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "Google Talk calls may only contain one stream");
+
+ return FALSE;
+ }
+ }
+ else
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "contact doesn't have desired Google capabilities");
+ }
+ }
+ }
+
+ if (resource == NULL)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO,
+ "contact doesn't have a resource with suitable capabilities");
+
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "member does not have the desired audio/video capabilities");
+
+ return FALSE;
+ }
+
+ priv->peer_resource = g_strdup (resource);
+ }
+
+ /* check it's not a ridiculous number of streams */
+ if ((priv->streams->len + media_types->len) > MAX_STREAMS)
+ {
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "I think that's quite enough streams already");
+ return FALSE;
+ }
+
+ /* if we've got here, we're good to make the streams */
+
+ *ret = g_ptr_array_sized_new (media_types->len);
+
+ for (idx = 0; idx < media_types->len; idx++)
+ {
+ guint media_type = g_array_index (media_types, guint, idx);
+ GabbleMediaStream *stream;
+ const gchar *stream_name;
+
+ if (priv->mode == MODE_GOOGLE)
+ stream_name = GTALK_STREAM_NAME;
+ else
+ stream_name = _name_stream (session, media_type);
+
+ stream = create_media_stream (session, stream_name, INITIATOR_LOCAL,
+ media_type);
+
+ g_ptr_array_add (*ret, stream);
+ }
+
+ return TRUE;
+}
+
+static const gchar *
+_direction_to_senders (GabbleMediaSession *session,
+ TpMediaStreamDirection dir)
+{
+ const gchar *ret = NULL;
+
+ switch (dir)
+ {
+ case TP_MEDIA_STREAM_DIRECTION_NONE:
+ g_assert_not_reached ();
+ break;
+ case TP_MEDIA_STREAM_DIRECTION_SEND:
+ if (session->initiator == INITIATOR_LOCAL)
+ ret = "initiator";
+ else
+ ret = "responder";
+ break;
+ case TP_MEDIA_STREAM_DIRECTION_RECEIVE:
+ if (session->initiator == INITIATOR_REMOTE)
+ ret = "initiator";
+ else
+ ret = "responder";
+ break;
+ case TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL:
+ ret = "both";
+ break;
+ }
+
+ g_assert (ret != NULL);
+
+ return ret;
+}
+
+static LmHandlerResult
+direction_msg_reply_cb (GabbleConnection *conn,
+ LmMessage *sent_msg,
+ LmMessage *reply_msg,
+ GObject *object,
+ gpointer user_data)
+{
+ GabbleMediaSession *session = GABBLE_MEDIA_SESSION (user_data);
+ GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);
+
+ MSG_REPLY_CB_END_SESSION_IF_NOT_SUCCESSFUL (session, "direction change failed");
+
+ if (stream->playing)
+ {
+ _gabble_media_stream_update_sending (stream, TRUE);
+ }
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static gboolean
+send_direction_change (GabbleMediaSession *session,
+ GabbleMediaStream *stream,
+ TpMediaStreamDirection dir,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv;
+ const gchar *senders;
+ LmMessage *msg;
+ LmMessageNode *session_node, *content_node;
+ gboolean ret;
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+ senders = _direction_to_senders (session, dir);
+
+ if (stream->signalling_state == STREAM_SIG_STATE_NEW ||
+ stream->signalling_state == STREAM_SIG_STATE_REMOVING)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "not sending content-modify for %s stream %s",
+ stream->signalling_state == STREAM_SIG_STATE_NEW ? "new" : "removing",
+ stream->name);
+ return TRUE;
+ }
+
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "sending jingle session action \"content-modify\" "
+ "to peer for stream %s (senders=%s)", stream->name, senders);
+
+ msg = _gabble_media_session_message_new (session, "content-modify",
+ &session_node);
+ content_node = _gabble_media_stream_add_content_node (stream, session_node);
+
+ lm_message_node_set_attribute (content_node, "senders", senders);
+
+ ret = _gabble_connection_send_with_reply (priv->conn, msg,
+ direction_msg_reply_cb, G_OBJECT (stream), session, error);
+
+ lm_message_unref (msg);
+
+ return ret;
+}
+
+gboolean
+_gabble_media_session_request_stream_direction (GabbleMediaSession *session,
+ GabbleMediaStream *stream,
+ TpMediaStreamDirection requested_dir,
+ GError **error)
+{
+ GabbleMediaSessionPrivate *priv;
+ CombinedStreamDirection new_combined_dir;
+ TpMediaStreamDirection current_dir; //, new_dir;
+ TpMediaStreamPendingSend pending_send;
+
+ priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);
+
+ current_dir = COMBINED_DIRECTION_GET_DIRECTION (stream->combined_direction);
+ pending_send = COMBINED_DIRECTION_GET_PENDING_SEND
+ (stream->combined_direction);
+
+ if (priv->mode == MODE_GOOGLE)
+ {
+ g_assert (current_dir == TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL);
+
+ if (requested_dir == TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL)
+ return TRUE;
+
+ g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
+ "Google Talk calls can only be bi-directional");
+ return FALSE;
+ }
+
+ if (requested_dir == TP_MEDIA_STREAM_DIRECTION_NONE)
+ {
+ _gabble_media_session_debug (session, DEBUG_MSG_INFO, "request for NONE direction; removing stream");
+
+ _gabble_media_session_remove_streams (session, &stream, 1);
+
+ return TRUE;
+ }
+
+ /* if we're awaiting a local decision on sending... */
+ if ((pending_send & TP_MEDIA_STREAM_PENDING_LOCAL_SEND) != 0)
+ {
+ /* clear the flag */
+ pending_send &= ~TP_MEDIA_STREAM_PENDING_LOCAL_SEND;
+
+ /* make our current_dir match what other end thinks (he thinks we're
+ * bidirectional) so that we send the correct transitions */
+ current_dir ^= TP_MEDIA_STREAM_DIRECTION_SEND;
+ }
+
+#if 0
+ /* if we're asking the remote end to start sending, set the pending flag and
+ * don't change our directionality just yet */
+ new_dir = requested_dir;
+ if (((current_dir & TP_MEDIA_STREAM_DIRECTION_RECEIVE) == 0) &&
+ ((new_dir & TP_MEDIA_STREAM_DIRECTION_RECEIVE) != 0))
+ {
+ pending_send ^= TP_MEDIA_STREAM_PENDING_REMOTE_SEND;
+ new_dir &= ~TP_MEDIA_STREAM_DIRECTION_RECEIVE;
+ }
+#endif
+
+ /* make any necessary changes */
+ new_combined_dir = MAKE_COMBINED_DIRECTION (requested_dir, pending_send);
+ if (new_combined_dir != stream->combined_direction)
+ {
+ g_object_set (stream, "combined-direction", new_combined_dir, NULL);
+ _gabble_media_stream_update_sending (stream, FALSE);
+ }
+
+ /* short-circuit sending a request if we're not asking for anything new */
+ if (current_dir == requested_dir)
+ return TRUE;
+
+ /* send request */
+ return send_direction_change (session, stream, requested_dir, error);
+}
+