1 /*

     2  * gabble-media-session.c - Source for GabbleMediaSession

     3  * Copyright (C) 2006 Collabora Ltd.

     4  * 

     5  *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>

     6  *

     7  * This library is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Lesser General Public

     9  * License as published by the Free Software Foundation; either

    10  * version 2.1 of the License, or (at your option) any later version.

    11  *

    12  * This library is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Lesser General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Lesser General Public

    18  * License along with this library; if not, write to the Free Software

    19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    20  */

    21 

    22 #include <dbus/dbus-glib.h>

    23 #include <stdio.h>

    24 #include <stdlib.h>

    25 #include <string.h>

    26 #include <time.h>

    27 

    28 #include "debug.h"

    29 #include "ansi.h"

    30 #include "handles.h"

    31 #include "namespaces.h"

    32 #include "util.h"

    33 

    34 #include "telepathy-errors.h"

    35 #include "telepathy-helpers.h"

    36 

    37 #include "gabble-connection.h"

    38 #include "gabble-media-channel.h"

    39 #include "gabble-media-stream.h"

    40 #include "gabble-presence-cache.h"

    41 #include "gabble-presence.h"

    42 

    43 #include "gabble-media-session.h"

    44 #include "gabble-media-session-signals-marshal.h"

    45 #include "gabble-media-session-glue.h"

    46 

    47 #include "gabble_enums.h"

    48 

    49 #ifndef EMULATOR

    50 G_DEFINE_TYPE(GabbleMediaSession, gabble_media_session, G_TYPE_OBJECT)

    51 #endif

    52 

    53 

    54 #define DEBUG_FLAG GABBLE_DEBUG_MEDIA

    55 //vinod

    56 #ifdef DEBUG_FLAG

    57 //#define DEBUG(format, ...)

    58 #define DEBUGGING 0

    59 //#define NODE_DEBUG(n, s);

    60 #endif /* DEBUG_FLAG */

    61 

    62 #define DEFAULT_SESSION_TIMEOUT 50000

    63 

    64 #define GTALK_STREAM_NAME "gtalk"

    65 

    66 /* 99 streams gives us a max name length of 8 (videoXX\0 or audioXX\0) */

    67 #define MAX_STREAMS 99

    68 

    69 #ifndef EMULATOR

    70 #define MAX_STREAM_NAME_LEN 8

    71 #endif

    72 

    73 //#define DEBUGGING 0

    74 

    75 /* signal enum */

    76 enum

    77 {

    78     NEW_STREAM_HANDLER,

    79     STREAM_ADDED,

    80     TERMINATED,

    81     LAST_SIGNAL

    82 };

    83 

    84 #ifdef EMULATOR

    85 #include "libgabble_wsd_solution.h"

    86 

    87 	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_sess,guint)

    88 	#define signals (GET_WSD_VAR_NAME(signals,gabble_med_sess, s)())	

    89 	

    90 	

    91 	GET_STATIC_VAR_FROM_TLS(google_audio_caps,gabble_med_sess,GabblePresenceCapabilities)

    92 	#define google_audio_caps (*GET_WSD_VAR_NAME(google_audio_caps,gabble_med_sess, s)())	

    93 	

    94 	GET_STATIC_VAR_FROM_TLS(jingle_audio_caps,gabble_med_sess,GabblePresenceCapabilities)

    95 	#define jingle_audio_caps (*GET_WSD_VAR_NAME(jingle_audio_caps,gabble_med_sess, s)())	

    96 	

    97 	GET_STATIC_VAR_FROM_TLS(jingle_video_caps,gabble_med_sess,GabblePresenceCapabilities)

    98 	#define jingle_video_caps (*GET_WSD_VAR_NAME(jingle_video_caps,gabble_med_sess, s)())	

    99 	

   100 	GET_STATIC_ARRAY_FROM_TLS(ret_sess,gabble_med_sess,gchar)

   101 	#define ret_sess (GET_WSD_VAR_NAME(ret_sess,gabble_med_sess, s)())	

   102 	

   103 	GET_STATIC_VAR_FROM_TLS(gabble_media_session_parent_class,gabble_med_sess,gpointer)

   104 	#define gabble_media_session_parent_class (*GET_WSD_VAR_NAME(gabble_media_session_parent_class,gabble_med_sess,s)())

   105 	

   106 	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_sess,GType)

   107 	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_med_sess,s)())	

   108 	

   109 	

   110 	static void gabble_media_session_init (GabbleMediaSession *self); 

   111 	static void gabble_media_session_class_init (GabbleMediaSessionClass *klass); 

   112 	static void gabble_media_session_class_intern_init (gpointer klass) 

   113 	{ 

   114 	gabble_media_session_parent_class = g_type_class_peek_parent (klass); 

   115 	gabble_media_session_class_init ((GabbleMediaSessionClass*) klass); }

   116 	

   117 	 EXPORT_C GType gabble_media_session_get_type (void) 

   118 	 { 

   119 	 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; 

   120 	 }

   121 

   122 	

   123 		

   124 #else

   125 

   126 	static guint signals[LAST_SIGNAL] = {0};

   127 

   128 #endif

   129 

   130 /* properties */

   131 enum

   132 {

   133   PROP_CONNECTION = 1,

   134   PROP_MEDIA_CHANNEL,

   135   PROP_OBJECT_PATH,

   136   PROP_SESSION_ID,

   137   PROP_INITIATOR,

   138   PROP_PEER,

   139   PROP_PEER_RESOURCE,

   140   PROP_STATE,

   141   LAST_PROPERTY

   142 };

   143 

   144 /* private structure */

   145 typedef struct _GabbleMediaSessionPrivate GabbleMediaSessionPrivate;

   146 

   147 struct _GabbleMediaSessionPrivate

   148 {

   149   GabbleConnection *conn;

   150   GabbleMediaChannel *channel;

   151   GabbleMediaSessionMode mode;

   152   gchar *object_path;

   153 

   154   GPtrArray *streams;

   155   GPtrArray *remove_requests;

   156 

   157   gchar *id;

   158   GabbleHandle peer;

   159   gchar *peer_resource;

   160 

   161   JingleSessionState state;

   162   gboolean ready;

   163   gboolean locally_accepted;

   164   gboolean terminated;

   165 

   166   guint timer_id;

   167 

   168   gboolean dispose_has_run;

   169 };

   170 

   171 #define GABBLE_MEDIA_SESSION_GET_PRIVATE(obj) \

   172     ((GabbleMediaSessionPrivate *)obj->priv)

   173 

   174 typedef struct {

   175     gchar *name;

   176     gchar *attributes;

   177 } SessionStateDescription;

   178 

   179 static const SessionStateDescription session_states[] =

   180 {

   181     { "JS_STATE_PENDING_CREATED",       ANSI_BOLD_ON ANSI_FG_BLACK ANSI_BG_WHITE   },

   182     { "JS_STATE_PENDING_INITIATE_SENT", ANSI_BOLD_ON               ANSI_BG_CYAN    },

   183     { "JS_STATE_PENDING_INITIATED",     ANSI_BOLD_ON               ANSI_BG_MAGENTA },

   184     { "JS_STATE_PENDING_ACCEPT_SENT",   ANSI_BOLD_ON               ANSI_BG_CYAN    },

   185     { "JS_STATE_ACTIVE",                ANSI_BOLD_ON               ANSI_BG_BLUE    },

   186     { "JS_STATE_ENDED",                                            ANSI_BG_RED     }

   187 };

   188 

   189 static void

   190 gabble_media_session_init (GabbleMediaSession *self)

   191 {

   192   GabbleMediaSessionPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

   193       GABBLE_TYPE_MEDIA_SESSION, GabbleMediaSessionPrivate);

   194 

   195   self->priv = priv;

   196 

   197   priv->mode = MODE_JINGLE;

   198   priv->state = JS_STATE_PENDING_CREATED;

   199   priv->streams = g_ptr_array_new ();

   200   priv->remove_requests = g_ptr_array_new ();

   201 }

   202 

   203 static void stream_connection_state_changed_cb (GabbleMediaStream *stream,

   204                                                 GParamSpec *param,

   205                                                 GabbleMediaSession *session);

   206 static void stream_got_local_codecs_changed_cb (GabbleMediaStream *stream,

   207                                                 GParamSpec *param,

   208                                                 GabbleMediaSession *session);

   209 

   210 static void

   211 _emit_new_stream (GabbleMediaSession *session,

   212                   GabbleMediaStream *stream)

   213 {

   214   gchar *object_path;

   215   guint id, media_type;

   216 

   217   g_object_get (stream,

   218                 "object-path", &object_path,

   219                 "id", &id,

   220                 "media-type", &media_type,

   221                 NULL);

   222 

   223   /* all of the streams are bidirectional from farsight's point of view, it's

   224    * just in the signalling they change */

   225   g_signal_emit (session, signals[NEW_STREAM_HANDLER], 0, object_path, id,

   226       media_type, TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL);

   227 

   228   g_free (object_path);

   229 }

   230 

   231 

   232 static GabbleMediaStream *

   233 _lookup_stream_by_name_and_initiator (GabbleMediaSession *session,

   234                                       const gchar *stream_name,

   235                                       JingleInitiator stream_initiator)

   236 {

   237   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   238   guint i;

   239 

   240   for (i = 0; i < priv->streams->len; i++)

   241     {

   242       GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);

   243 

   244       if (g_strdiff (stream->name, stream_name))

   245         continue;

   246 

   247       if (stream_initiator != INITIATOR_INVALID &&

   248           stream_initiator != stream->initiator)

   249         continue;

   250 

   251       return stream;

   252     }

   253 

   254   return NULL;

   255 }

   256 

   257 

   258 static GabbleMediaStream *

   259 create_media_stream (GabbleMediaSession *session,

   260                      const gchar *name,

   261                      JingleInitiator initiator,

   262                      guint media_type)

   263 {

   264   GabbleMediaSessionPrivate *priv;

   265   gchar *object_path;

   266   GabbleMediaStream *stream;

   267   guint id;

   268 

   269   g_assert (GABBLE_IS_MEDIA_SESSION (session));

   270   g_assert (name != NULL);

   271 

   272   priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   273 

   274   /* assert that if we're in google mode:

   275    *  - we only try to make one stream

   276    *  - it's an audio stream

   277    *  - it's called GTALK_STREAM_NAME */

   278   if (priv->mode == MODE_GOOGLE)

   279     {

   280       g_assert (priv->streams->len == 0);

   281       g_assert (media_type == TP_MEDIA_STREAM_TYPE_AUDIO);

   282       g_assert (!g_strdiff (name, GTALK_STREAM_NAME));

   283     }

   284 

   285   g_assert (priv->streams->len < MAX_STREAMS);

   286   g_assert (_lookup_stream_by_name_and_initiator (session, name, initiator) ==

   287       NULL);

   288 

   289   id = _gabble_media_channel_get_stream_id (priv->channel);

   290 

   291   _gabble_media_session_debug (session, DEBUG_MSG_INFO,

   292       "creating new %s %s stream called \"%s\" with id %u",

   293       priv->mode == MODE_GOOGLE ? "google" : "jingle",

   294       media_type == TP_MEDIA_STREAM_TYPE_AUDIO ? "audio" : "video",

   295       name, id);

   296 

   297   object_path = g_strdup_printf ("%s/MediaStream%u", priv->object_path, id);

   298 

   299   stream = g_object_new (GABBLE_TYPE_MEDIA_STREAM,

   300                          "connection", priv->conn,

   301                          "media-session", session,

   302                          "object-path", object_path,

   303                          "mode", priv->mode,

   304                          "name", name,

   305                          "id", id,

   306                          "initiator", initiator,

   307                          "media-type", media_type,

   308                          NULL);

   309 

   310   g_signal_connect (stream, "notify::connection-state",

   311                     (GCallback) stream_connection_state_changed_cb,

   312                     session);

   313   g_signal_connect (stream, "notify::got-local-codecs",

   314                     (GCallback) stream_got_local_codecs_changed_cb,

   315                     session);

   316 

   317   g_ptr_array_add (priv->streams, stream);

   318 

   319   g_free (object_path);

   320 

   321   if (priv->ready)

   322     _emit_new_stream (session, stream);

   323 

   324   g_signal_emit (session, signals[STREAM_ADDED], 0, stream);

   325 

   326   return stream;

   327 }

   328 

   329 static void

   330 destroy_media_stream (GabbleMediaSession *session,

   331                       GabbleMediaStream *stream)

   332 {

   333   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   334 

   335   _gabble_media_stream_close (stream);

   336   g_ptr_array_remove_fast (priv->streams, stream);

   337   g_object_unref (stream);

   338 }

   339 

   340 static GObject *

   341 gabble_media_session_constructor (GType type, guint n_props,

   342                                   GObjectConstructParam *props)

   343 {

   344   GObject *obj;

   345   GabbleMediaSessionPrivate *priv;

   346   DBusGConnection *bus;

   347 

   348   obj = G_OBJECT_CLASS (gabble_media_session_parent_class)->

   349            constructor (type, n_props, props);

   350   priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (GABBLE_MEDIA_SESSION (obj));

   351 

   352   bus = tp_get_bus ();

   353   dbus_g_connection_register_g_object (bus, priv->object_path, obj);

   354 

   355   return obj;

   356 }

   357 

   358 static void

   359 gabble_media_session_get_property (GObject    *object,

   360                                    guint       property_id,

   361                                    GValue     *value,

   362                                    GParamSpec *pspec)

   363 {

   364   GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);

   365   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   366 

   367   switch (property_id) {

   368     case PROP_CONNECTION:

   369       g_value_set_object (value, priv->conn);

   370       break;

   371     case PROP_MEDIA_CHANNEL:

   372       g_value_set_object (value, priv->channel);

   373       break;

   374     case PROP_OBJECT_PATH:

   375       g_value_set_string (value, priv->object_path);

   376       break;

   377     case PROP_SESSION_ID:

   378       g_value_set_string (value, priv->id);

   379       break;

   380     case PROP_INITIATOR:

   381       g_value_set_uint (value, session->initiator);

   382       break;

   383     case PROP_PEER:

   384       g_value_set_uint (value, priv->peer);

   385       break;

   386     case PROP_PEER_RESOURCE:

   387       g_value_set_string (value, priv->peer_resource);

   388       break;

   389     case PROP_STATE:

   390       g_value_set_uint (value, priv->state);

   391       break;

   392     default:

   393       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   394       break;

   395   }

   396 }

   397 

   398 static void session_state_changed (GabbleMediaSession *session,

   399                                    JingleSessionState prev_state,

   400                                    JingleSessionState new_state);

   401 

   402 static void

   403 gabble_media_session_set_property (GObject      *object,

   404                                    guint         property_id,

   405                                    const GValue *value,

   406                                    GParamSpec   *pspec)

   407 {

   408   GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);

   409   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   410   JingleSessionState prev_state;

   411 

   412   switch (property_id) {

   413     case PROP_CONNECTION:

   414       priv->conn = g_value_get_object (value);

   415       break;

   416     case PROP_MEDIA_CHANNEL:

   417       priv->channel = g_value_get_object (value);

   418       break;

   419     case PROP_OBJECT_PATH:

   420       g_free (priv->object_path);

   421       priv->object_path = g_value_dup_string (value);

   422       break;

   423     case PROP_SESSION_ID:

   424       g_free (priv->id);

   425       priv->id = g_value_dup_string (value);

   426       break;

   427     case PROP_INITIATOR:

   428       session->initiator = g_value_get_uint (value);

   429       break;

   430     case PROP_PEER:

   431       priv->peer = g_value_get_uint (value);

   432       break;

   433     case PROP_PEER_RESOURCE:

   434       g_free (priv->peer_resource);

   435       priv->peer_resource = g_value_dup_string (value);

   436       break;

   437     case PROP_STATE:

   438       prev_state = priv->state;

   439       priv->state = g_value_get_uint (value);

   440 

   441       if (priv->state == JS_STATE_ENDED)

   442         g_assert (priv->terminated);

   443 

   444       if (priv->state != prev_state)

   445         session_state_changed (session, prev_state, priv->state);

   446 

   447       break;

   448     default:

   449       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   450       break;

   451   }

   452 }

   453 

   454 static void gabble_media_session_dispose (GObject *object);

   455 static void gabble_media_session_finalize (GObject *object);

   456 

   457 static void

   458 gabble_media_session_class_init (GabbleMediaSessionClass *gabble_media_session_class)

   459 {

   460   GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_session_class);

   461   GParamSpec *param_spec;

   462 

   463   g_type_class_add_private (gabble_media_session_class, sizeof (GabbleMediaSessionPrivate));

   464 

   465   object_class->constructor = gabble_media_session_constructor;

   466 

   467   object_class->get_property = gabble_media_session_get_property;

   468   object_class->set_property = gabble_media_session_set_property;

   469 

   470   object_class->dispose = gabble_media_session_dispose;

   471   object_class->finalize = gabble_media_session_finalize;

   472 

   473   param_spec = g_param_spec_object ("connection", "GabbleConnection object",

   474                                     "Gabble connection object that owns this "

   475                                     "media session's channel.",

   476                                     GABBLE_TYPE_CONNECTION,

   477                                     G_PARAM_CONSTRUCT_ONLY |

   478                                     G_PARAM_READWRITE |

   479                                     G_PARAM_STATIC_NICK |

   480                                     G_PARAM_STATIC_BLURB);

   481   g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);

   482 

   483   param_spec = g_param_spec_object ("media-channel", "GabbleMediaChannel object",

   484                                     "Gabble media channel object that owns this "

   485                                     "media session object.",

   486                                     GABBLE_TYPE_MEDIA_CHANNEL,

   487                                     G_PARAM_CONSTRUCT_ONLY |

   488                                     G_PARAM_READWRITE |

   489                                     G_PARAM_STATIC_NICK |

   490                                     G_PARAM_STATIC_BLURB);

   491   g_object_class_install_property (object_class, PROP_MEDIA_CHANNEL, param_spec);

   492 

   493   param_spec = g_param_spec_string ("object-path", "D-Bus object path",

   494                                     "The D-Bus object path used for this "

   495                                     "object on the bus.",

   496                                     NULL,

   497                                     G_PARAM_CONSTRUCT_ONLY |

   498                                     G_PARAM_READWRITE |

   499                                     G_PARAM_STATIC_NAME |

   500                                     G_PARAM_STATIC_BLURB);

   501   g_object_class_install_property (object_class, PROP_OBJECT_PATH, param_spec);

   502 

   503   param_spec = g_param_spec_string ("session-id", "Session ID",

   504                                     "A unique session identifier used "

   505                                     "throughout all communication.",

   506                                     NULL,

   507                                     G_PARAM_CONSTRUCT_ONLY |

   508                                     G_PARAM_READWRITE |

   509                                     G_PARAM_STATIC_NAME |

   510                                     G_PARAM_STATIC_BLURB);

   511   g_object_class_install_property (object_class, PROP_SESSION_ID, param_spec);

   512 

   513   param_spec = g_param_spec_uint ("initiator", "Session initiator",

   514                                   "An enum signifying which end initiated "

   515                                   "the session.",

   516                                   INITIATOR_LOCAL,

   517                                   INITIATOR_REMOTE,

   518                                   INITIATOR_LOCAL,

   519                                   G_PARAM_CONSTRUCT_ONLY |

   520                                   G_PARAM_READWRITE |

   521                                   G_PARAM_STATIC_NAME |

   522                                   G_PARAM_STATIC_BLURB);

   523   g_object_class_install_property (object_class, PROP_INITIATOR, param_spec);

   524 

   525   param_spec = g_param_spec_uint ("peer", "Session peer",

   526                                   "The GabbleHandle representing the contact "

   527                                   "with whom this session communicates.",

   528                                   0, G_MAXUINT32, 0,

   529                                   G_PARAM_CONSTRUCT_ONLY |

   530                                   G_PARAM_READWRITE |

   531                                   G_PARAM_STATIC_NAME |

   532                                   G_PARAM_STATIC_BLURB);

   533   g_object_class_install_property (object_class, PROP_PEER, param_spec);

   534 

   535   param_spec = g_param_spec_string ("peer-resource",

   536                                     "Session peer's resource",

   537                                     "The resource of the contact "

   538                                     "with whom this session communicates, "

   539                                     "if applicable",

   540                                     NULL,

   541                                     G_PARAM_CONSTRUCT_ONLY |

   542                                     G_PARAM_WRITABLE |

   543                                     G_PARAM_STATIC_NAME |

   544                                     G_PARAM_STATIC_BLURB);

   545   g_object_class_install_property (object_class, PROP_PEER_RESOURCE,

   546                                    param_spec);

   547 

   548   param_spec = g_param_spec_uint ("state", "Session state",

   549                                   "The current state that the session is in.",

   550                                   0, G_MAXUINT32, 0,

   551                                   G_PARAM_READWRITE |

   552                                   G_PARAM_STATIC_NAME |

   553                                   G_PARAM_STATIC_BLURB);

   554   g_object_class_install_property (object_class, PROP_STATE, param_spec);

   555 

   556   signals[NEW_STREAM_HANDLER] =

   557     g_signal_new ("new-stream-handler",

   558                   G_OBJECT_CLASS_TYPE (gabble_media_session_class),

   559                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   560                   0,

   561                   NULL, NULL,

   562                   gabble_media_session_marshal_VOID__STRING_UINT_UINT_UINT,

   563                   G_TYPE_NONE, 4, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);

   564 

   565   signals[STREAM_ADDED] =

   566     g_signal_new ("stream-added",

   567                   G_OBJECT_CLASS_TYPE (gabble_media_session_class),

   568                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   569                   0,

   570                   NULL, NULL,

   571                   g_cclosure_marshal_VOID__OBJECT,

   572                   G_TYPE_NONE, 1, G_TYPE_OBJECT);

   573 

   574   signals[TERMINATED] =

   575     g_signal_new ("terminated",

   576                   G_OBJECT_CLASS_TYPE (gabble_media_session_class),

   577                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   578                   0,

   579                   NULL, NULL,

   580                   gabble_media_session_marshal_VOID__UINT_UINT,

   581                   G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);

   582 

   583   dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_media_session_class), &dbus_glib_gabble_media_session_object_info);

   584 }

   585 

   586 static void

   587 gabble_media_session_dispose (GObject *object)

   588 {

   589   GabbleMediaSession *self = GABBLE_MEDIA_SESSION (object);

   590   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);

   591   guint i;

   592 

   593   gabble_debug (DEBUG_FLAG, "called");

   594 

   595   if (priv->dispose_has_run)

   596     return;

   597 

   598   priv->dispose_has_run = TRUE;

   599 

   600   _gabble_media_session_terminate (self, INITIATOR_LOCAL,

   601       TP_CHANNEL_GROUP_CHANGE_REASON_NONE);

   602 

   603   if (priv->timer_id != 0)

   604     g_source_remove (priv->timer_id);

   605 

   606   if (priv->streams != NULL)

   607     {

   608       for (i = 0; i < priv->streams->len; i++)

   609         g_object_unref (g_ptr_array_index (priv->streams, i));

   610       g_ptr_array_free (priv->streams, TRUE);

   611       priv->streams = NULL;

   612     }

   613 

   614   for (i = 0; i < priv->remove_requests->len; i++)

   615     g_ptr_array_free (g_ptr_array_index (priv->remove_requests, i), TRUE);

   616   g_ptr_array_free (priv->remove_requests, TRUE);

   617   priv->remove_requests = NULL;

   618 

   619   if (G_OBJECT_CLASS (gabble_media_session_parent_class)->dispose)

   620     G_OBJECT_CLASS (gabble_media_session_parent_class)->dispose (object);

   621 }

   622 

   623 static void

   624 gabble_media_session_finalize (GObject *object)

   625 {

   626   GabbleMediaSession *self = GABBLE_MEDIA_SESSION (object);

   627   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);

   628 

   629   g_free (priv->id);

   630   g_free (priv->object_path);

   631   g_free (priv->peer_resource);

   632   G_OBJECT_CLASS (gabble_media_session_parent_class)->finalize (object);

   633 }

   634 

   635 

   636 /**

   637  * gabble_media_session_error

   638  *

   639  * Implements D-Bus method Error

   640  * on interface org.freedesktop.Telepathy.Media.SessionHandler

   641  *

   642  * @error: Used to return a pointer to a GError detailing any error

   643  *         that occurred, D-Bus will throw the error only if this

   644  *         function returns FALSE.

   645  *

   646  * Returns: TRUE if successful, FALSE if an error was thrown.

   647  */

   648 gboolean

   649 gabble_media_session_error (GabbleMediaSession *self,

   650                             guint errno,

   651                             const gchar *message,

   652                             GError **error)

   653 {

   654   GabbleMediaSessionPrivate *priv;

   655   GPtrArray *tmp;

   656   guint i;

   657 

   658   g_assert (GABBLE_IS_MEDIA_SESSION (self));

   659 

   660   priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);

   661 

   662   _gabble_media_session_debug (self, DEBUG_MSG_INFO, "Media.SessionHandler::Error called, error %u (%s) -- "

   663       "emitting error on each stream", errno, message);

   664 

   665   if (priv->state == JS_STATE_ENDED)

   666     {

   667       return TRUE;

   668     }

   669   else if (priv->state == JS_STATE_PENDING_CREATED)

   670     {

   671       /* shortcut to prevent sending remove actions if we haven't sent an

   672        * initiate yet */

   673       g_object_set (self, "state", JS_STATE_ENDED, NULL);

   674       return TRUE;

   675     }

   676 

   677   g_assert (priv->streams != NULL);

   678 

   679   tmp = priv->streams;

   680   priv->streams = NULL;

   681 

   682   for (i = 0; i < tmp->len; i++)

   683     {

   684       GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);

   685       //FIXME: Temporary fix to comment "errno" to resolve the mecevo integration build break, fix me when this method is being used.

   686       gabble_media_stream_error (stream, /*errno*/0, message, NULL);

   687     }

   688 

   689   g_ptr_array_free (tmp, TRUE);

   690 

   691   return TRUE;

   692 }

   693 

   694 

   695 /**

   696  * gabble_media_session_ready

   697  *

   698  * Implements D-Bus method Ready

   699  * on interface org.freedesktop.Telepathy.Media.SessionHandler

   700  *

   701  * @error: Used to return a pointer to a GError detailing any error

   702  *         that occurred, D-Bus will throw the error only if this

   703  *         function returns FALSE.

   704  *

   705  * Returns: TRUE if successful, FALSE if an error was thrown.

   706  */

   707 gboolean

   708 gabble_media_session_ready (GabbleMediaSession *self,

   709                             GError **error)

   710 {

   711   GabbleMediaSessionPrivate *priv;

   712   guint i;

   713 

   714   g_assert (GABBLE_IS_MEDIA_SESSION (self));

   715 

   716   priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (self);

   717 

   718   priv->ready = TRUE;

   719 

   720   for (i = 0; i < priv->streams->len; i++)

   721     _emit_new_stream (self, g_ptr_array_index (priv->streams, i));

   722 

   723   return TRUE;

   724 }

   725 

   726 

   727 static gboolean

   728 _handle_create (GabbleMediaSession *session,

   729                 LmMessage *message,

   730                 LmMessageNode *content_node,

   731                 const gchar *stream_name,

   732                 GabbleMediaStream *stream,

   733                 LmMessageNode *desc_node,

   734                 LmMessageNode *trans_node,

   735                 GError **error)

   736 {

   737   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   738   GabbleMediaSessionMode session_mode;

   739   TpMediaStreamType stream_type;

   740   gboolean override_existing = FALSE;

   741 

   742   if ((priv->state == JS_STATE_PENDING_CREATED) &&

   743       (session->initiator == INITIATOR_LOCAL))

   744     {

   745       gabble_debug (DEBUG_FLAG, "we're trying to call ourselves, rejecting with busy");

   746       _gabble_media_session_terminate (session, INITIATOR_REMOTE,

   747           TP_CHANNEL_GROUP_CHANGE_REASON_BUSY);

   748           return FALSE;

   749     }

   750 

   751 

   752   if (stream != NULL)

   753     {

   754       /* streams added by the session initiator may replace similarly-named

   755        * streams which we are trying to add (but havn't had acknowledged) */

   756       if (stream->signalling_state < STREAM_SIG_STATE_ACKNOWLEDGED)

   757         {

   758           if (session->initiator == INITIATOR_REMOTE)

   759             {

   760               override_existing = TRUE;

   761             }

   762           else

   763             {

   764               g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_CONFLICT,

   765                   "session initiator is creating a stream named \"%s\" already",

   766                   stream_name);

   767               return FALSE;

   768             }

   769         }

   770       else

   771         {

   772           g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_CONFLICT,

   773               "can't create new stream called \"%s\", it already exists, "

   774               "rejecting", stream_name);

   775           return FALSE;

   776         }

   777     }

   778 

   779   if (desc_node == NULL)

   780     {

   781       g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,

   782           "unable to create stream without a content description");

   783       return FALSE;

   784     }

   785 

   786   if (lm_message_node_has_namespace (desc_node,

   787         NS_GOOGLE_SESSION_PHONE, NULL))

   788     {

   789       session_mode = MODE_GOOGLE;

   790       stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;

   791     }

   792   else if (lm_message_node_has_namespace (desc_node,

   793         NS_JINGLE_DESCRIPTION_AUDIO, NULL))

   794     {

   795       session_mode = MODE_JINGLE;

   796       stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;

   797     }

   798   else if (lm_message_node_has_namespace (desc_node,

   799         NS_JINGLE_DESCRIPTION_VIDEO, NULL))

   800     {

   801       session_mode = MODE_JINGLE;

   802       stream_type = TP_MEDIA_STREAM_TYPE_VIDEO;

   803     }

   804   else

   805     {

   806       g_set_error (error, GABBLE_XMPP_ERROR,

   807           XMPP_ERROR_JINGLE_UNSUPPORTED_CONTENT,

   808           "refusing to create stream for unsupported content description");

   809       return FALSE;

   810     }

   811 

   812   /* MODE_GOOGLE is allowed to have a null transport node */

   813   if (session_mode == MODE_JINGLE && trans_node == NULL)

   814     {

   815       g_set_error (error, GABBLE_XMPP_ERROR,

   816           XMPP_ERROR_JINGLE_UNSUPPORTED_TRANSPORT,

   817           "refusing to create stream for unsupported transport");

   818       return FALSE;

   819     }

   820 

   821   if (session_mode != priv->mode)

   822     {

   823       if (priv->streams->len > 0)

   824         {

   825           g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_UNEXPECTED_REQUEST,

   826               "refusing to change mode because streams already exist");

   827           return FALSE;

   828         }

   829       else

   830         {

   831           _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting session mode to %s",

   832               session_mode == MODE_GOOGLE ? "google" : "jingle");

   833           priv->mode = session_mode;

   834         }

   835     }

   836 

   837   if (override_existing)

   838     {

   839       _gabble_media_session_debug (session, DEBUG_MSG_INFO, "removing our unacknowledged stream \"%s\" "

   840           "in favour of the session initiator's", stream_name);

   841 

   842       /* disappear this stream */

   843       destroy_media_stream (session, stream);

   844 

   845       stream = NULL;

   846     }

   847 

   848   if (priv->streams->len == MAX_STREAMS)

   849     {

   850       g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_RESOURCE_CONSTRAINT,

   851           "refusing to create more than " G_STRINGIFY (MAX_STREAMS)

   852           " streams");

   853       return FALSE;

   854     }

   855 

   856   stream = create_media_stream (session, stream_name, INITIATOR_REMOTE,

   857       stream_type);

   858 

   859   /* set the signalling state to ACKNOWLEDGED */

   860   g_object_set (stream,

   861       "signalling-state", STREAM_SIG_STATE_ACKNOWLEDGED,

   862       NULL);

   863 

   864   /* for jingle streams, set the direction to none, so that the

   865    * direction handler adds the right flags */

   866   if (priv->mode == MODE_JINGLE)

   867     g_object_set (stream,

   868         "combined-direction", TP_MEDIA_STREAM_DIRECTION_NONE,

   869         NULL);

   870 

   871   return TRUE;

   872 }

   873 

   874 

   875 static TpMediaStreamDirection

   876 _senders_to_direction (GabbleMediaSession *session,

   877                        const gchar *senders)

   878 {

   879   TpMediaStreamDirection ret = TP_MEDIA_STREAM_DIRECTION_NONE;

   880 

   881   if (!g_strdiff (senders, "initiator"))

   882     {

   883       if (session->initiator == INITIATOR_LOCAL)

   884         ret = TP_MEDIA_STREAM_DIRECTION_SEND;

   885       else

   886         ret = TP_MEDIA_STREAM_DIRECTION_RECEIVE;

   887     }

   888   else if (!g_strdiff (senders, "responder"))

   889     {

   890       if (session->initiator == INITIATOR_REMOTE)

   891         ret = TP_MEDIA_STREAM_DIRECTION_SEND;

   892       else

   893         ret = TP_MEDIA_STREAM_DIRECTION_RECEIVE;

   894     }

   895   else if (!g_strdiff (senders, "both"))

   896     {

   897       ret = TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL;

   898     }

   899 

   900   return ret;

   901 }

   902 

   903 static gboolean

   904 _handle_direction (GabbleMediaSession *session,

   905                    LmMessage *message,

   906                    LmMessageNode *content_node,

   907                    const gchar *stream_name,

   908                    GabbleMediaStream *stream,

   909                    LmMessageNode *desc_node,

   910                    LmMessageNode *trans_node,

   911                    GError **error)

   912 {

   913   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

   914   const gchar *senders;

   915   CombinedStreamDirection new_combined_dir;

   916   TpMediaStreamDirection requested_dir, current_dir;

   917   TpMediaStreamPendingSend pending_send;

   918 

   919   if (priv->mode == MODE_GOOGLE)

   920     return TRUE;

   921 

   922   requested_dir = TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL;

   923 

   924   senders = lm_message_node_get_attribute (content_node, "senders");

   925   if (senders != NULL)

   926     requested_dir = _senders_to_direction (session, senders);

   927 

   928   if (requested_dir == TP_MEDIA_STREAM_DIRECTION_NONE)

   929     {

   930       g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,

   931           "received invalid content senders value \"%s\" on stream \"%s\"; "

   932           "rejecting", senders, stream_name);

   933       return FALSE;

   934     }

   935 

   936   current_dir = COMBINED_DIRECTION_GET_DIRECTION (stream->combined_direction);

   937   pending_send = COMBINED_DIRECTION_GET_PENDING_SEND

   938     (stream->combined_direction);

   939 

   940   _gabble_media_session_debug (session, DEBUG_MSG_INFO, "received request for senders \"%s\" on stream "

   941       "\"%s\"", senders, stream_name);

   942 

   943   /* if local sending has been added, remove it,

   944    * and set the pending local send flag */

   945   if (((current_dir & TP_MEDIA_STREAM_DIRECTION_SEND) == 0) &&

   946     ((requested_dir & TP_MEDIA_STREAM_DIRECTION_SEND) != 0))

   947     {

   948       _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting pending local send flag");

   949       requested_dir &= ~TP_MEDIA_STREAM_DIRECTION_SEND;

   950       pending_send |= TP_MEDIA_STREAM_PENDING_LOCAL_SEND;

   951     }

   952 

   953 #if 0

   954   /* clear any pending remote send */

   955   if ((pending_send & TP_MEDIA_STREAM_PENDING_REMOTE_SEND) != 0)

   956     {

   957       _gabble_media_session_debug (session, DEBUG_MSG_INFO, "setting pending local send flag");

   958       pending_send &= ~TP_MEDIA_STREAM_PENDING_REMOTE_SEND;

   959     }

   960 #endif

   961 

   962   /* make any necessary changes */

   963   new_combined_dir = MAKE_COMBINED_DIRECTION (requested_dir, pending_send);

   964   if (new_combined_dir != stream->combined_direction)

   965     {

   966       g_object_set (stream, "combined-direction", new_combined_dir, NULL);

   967       _gabble_media_stream_update_sending (stream, FALSE);

   968     }

   969 

   970   return TRUE;

   971 }

   972 

   973 

   974 static gboolean

   975 _handle_accept (GabbleMediaSession *session,

   976                 LmMessage *message,

   977                 LmMessageNode *content_node,

   978                 const gchar *stream_name,

   979                 GabbleMediaStream *stream,

   980                 LmMessageNode *desc_node,

   981                 LmMessageNode *trans_node,

   982                 GError **error)

   983 {

   984   g_object_set (stream, "playing", TRUE, NULL);

   985 

   986   _gabble_media_stream_update_sending (stream, TRUE);

   987 

   988   return TRUE;

   989 }

   990 

   991 

   992 static gboolean

   993 _handle_codecs (GabbleMediaSession *session,

   994                 LmMessage *message,

   995                 LmMessageNode *content_node,

   996                 const gchar *stream_name,

   997                 GabbleMediaStream *stream,

   998                 LmMessageNode *desc_node,

   999                 LmMessageNode *trans_node,

  1000                 GError **error)

  1001 {

  1002   if (desc_node == NULL)

  1003     {

  1004       g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,

  1005           "unable to handle codecs without a content description node");

  1006       return FALSE;

  1007     }

  1008 

  1009   if (!_gabble_media_stream_post_remote_codecs (stream, message, desc_node,

  1010         error))

  1011     return FALSE;

  1012 

  1013   return TRUE;

  1014 }

  1015 

  1016 

  1017 static gboolean

  1018 _handle_candidates (GabbleMediaSession *session,

  1019                     LmMessage *message,

  1020                     LmMessageNode *content_node,

  1021                     const gchar *stream_name,

  1022                     GabbleMediaStream *stream,

  1023                     LmMessageNode *desc_node,

  1024                     LmMessageNode *trans_node,

  1025                     GError **error)

  1026 {

  1027   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  1028 

  1029   if (trans_node == NULL)

  1030     {

  1031       if (priv->mode == MODE_GOOGLE)

  1032         {

  1033           trans_node = content_node;

  1034         }

  1035       else

  1036         {

  1037           g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,

  1038               "unable to handle candidates without a transport node");

  1039           return FALSE;

  1040         }

  1041     }

  1042 

  1043   if (!_gabble_media_stream_post_remote_candidates (stream, message,

  1044         trans_node, error))

  1045     return FALSE;

  1046 

  1047   return TRUE;

  1048 }

  1049 

  1050 static guint

  1051 _count_non_removing_streams (GabbleMediaSession *session)

  1052 {

  1053   GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  1054   guint i, ret = 0;

  1055 

  1056   for (i = 0; i < priv->streams->len; i++)

  1057     {

  1058       GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);

  1059 

  1060       if (stream->signalling_state < STREAM_SIG_STATE_REMOVING)

  1061         ret++;

  1062     }

  1063 

  1064   return ret;

  1065 }

  1066 

  1067 static gboolean

  1068 _handle_remove (GabbleMediaSession *session,

  1069                 LmMessage *message,

  1070                 LmMessageNode *content_node,

  1071                 const gchar *stream_name,

  1072                 GabbleMediaStream *stream,

  1073                 LmMessageNode *desc_node,

  1074                 LmMessageNode *trans_node,

  1075                 GError **error)

  1076 {

  1077   /* reducing a session to contain 0 streams is invalid; instead the peer

  1078    * should terminate the session. I guess we'll do it for them... */

  1079   if (_count_non_removing_streams (session) == 1)

  1080     {

  1081       g_set_error (error, GABBLE_XMPP_ERROR, XMPP_ERROR_BAD_REQUEST,

  1082           "unable to remove the last stream in a Jingle call");

  1083       return FALSE;

  1084     }

  1085 

  1086   /* close the stream */

  1087   destroy_media_stream (session, stream);

  1088 

  1089   return TRUE;

  1090 }

  1091 

  1092 

  1093 static gboolean

  1094 _handle_terminate (GabbleMediaSession *session,

  1095                    LmMessage *message,

  1096                    LmMessageNode *content_node,

  1097                    const gchar *stream_name,

  1098                    GabbleMediaStream *stream,

  1099                    LmMessageNode *desc_node,

  1100                    LmMessageNode *trans_node,

  1101                    GError **error)

  1102 {

  1103   gabble_debug (DEBUG_FLAG, "called for %s", stream_name);

  1104 

  1105   _gabble_media_session_terminate (session, INITIATOR_REMOTE,

  1106       TP_CHANNEL_GROUP_CHANGE_REASON_NONE);

  1107 

  1108   return TRUE;

  1109 }

  1110 

  1111 

  1112 #ifndef EMULATOR

  1113 

  1114 typedef gboolean (*StreamHandlerFunc)(GabbleMediaSession *session,

  1115                                       LmMessage *message,

  1116                                       LmMessageNode *content_node,

  1117                                       const gchar *stream_name,

  1118                                       GabbleMediaStream *stream,

  1119                                       LmMessageNode *desc_node,

  1120                                       LmMessageNode *trans_node,

  1121                                       GError **error);

  1122                                       

  1123 typedef struct _Handler Handler;

  1124 

  1125 struct _Handler {

  1126   const gchar *actions[3];

  1127   JingleSessionState min_allowed_state;

  1128   JingleSessionState max_allowed_state;

  1129   StreamHandlerFunc stream_handlers[4];

  1130   JingleSessionState new_state;

  1131 };

  1132 

  1133 static Handler handlers[] = {

  1134   {

  1135     { "initiate", "session-initiate", NULL },