1 /*

     2  * gabble-media-stream.c - Source for GabbleMediaStream

     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 

    27 

    28 #include "ansi.h"

    29 #include "debug.h"

    30 #include "handles.h"

    31 #include "namespaces.h"

    32 

    33 #include "gabble-connection.h"

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

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

    36 #include "gabble-media-session-enumtypes.h"

    37 

    38 #include "telepathy-helpers.h"

    39 #include "telepathy-constants.h"

    40 

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

    42 #include "gabble-media-stream-signals-marshal.h"

    43 #include "gabble-media-stream-glue.h"

    44 

    45 #include "gabble_enums.h"

    46 

    47 #ifndef EMULATOR

    48 G_DEFINE_TYPE(GabbleMediaStream, gabble_media_stream, G_TYPE_OBJECT)

    49 #endif

    50 

    51 #define DEBUG_FLAG GABBLE_DEBUG_MEDIA

    52 

    53 #ifdef DEBUG_FLAG

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

    55 #define DEBUGGING 0

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

    57 #endif /* DEBUG_FLAG */

    58 

    59 /* signal enum */

    60 enum

    61 {

    62     DESTROY,

    63 

    64     ADD_REMOTE_CANDIDATE,

    65     CLOSE,

    66     REMOVE_REMOTE_CANDIDATE,

    67     SET_ACTIVE_CANDIDATE_PAIR,

    68     SET_REMOTE_CANDIDATE_LIST,

    69     SET_REMOTE_CODECS,

    70     SET_STREAM_PLAYING,

    71     SET_STREAM_SENDING,

    72 

    73     NEW_ACTIVE_CANDIDATE_PAIR,

    74     NEW_NATIVE_CANDIDATE,

    75     SUPPORTED_CODECS,

    76     ERROR,

    77 

    78     LAST_SIGNAL 

    79 #ifdef EMULATOR    

    80     = LAST_SIGNAL_MED_STREAM

    81 #endif

    82     

    83 };

    84 

    85 #ifdef EMULATOR

    86 #include "libgabble_wsd_solution.h"

    87 

    88 	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_stream,guint)

    89 	#define signals (GET_WSD_VAR_NAME(signals,gabble_med_stream, s)())	

    90 	

    91 	GET_STATIC_VAR_FROM_TLS(gabble_media_stream_parent_class,gabble_med_stream,gpointer)

    92 	#define gabble_media_stream_parent_class (*GET_WSD_VAR_NAME(gabble_media_stream_parent_class,gabble_med_stream,s)())

    93 	

    94 	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_stream,GType)

    95 	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_med_stream,s)())

    96 

    97 	/*gchar** _s_gabble_med_stream_video_codec_params() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_med_stream_video_codec_params)); }

    98 

    99 	#define video_codec_params (GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream, s)())*/	

   100 

   101 	

   102 static void gabble_media_stream_init (GabbleMediaStream *self); 

   103 static void gabble_media_stream_class_init (GabbleMediaStreamClass *klass); 

   104 static void gabble_media_stream_class_intern_init (gpointer klass) 

   105 { 

   106 gabble_media_stream_parent_class = g_type_class_peek_parent (klass);

   107  gabble_media_stream_class_init ((GabbleMediaStreamClass*) klass);

   108 }

   109  EXPORT_C GType gabble_media_stream_get_type (void) 

   110  {

   111   if ((g_define_type_id == 0)) 

   112   {

   113    static const GTypeInfo g_define_type_info = { sizeof (GabbleMediaStreamClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_media_stream_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMediaStream), 0, (GInstanceInitFunc) gabble_media_stream_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMediaStream"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

   114   };

   115 

   116 		

   117 #else

   118 

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

   120 

   121 #endif

   122 

   123 

   124 /* properties */

   125 enum

   126 {

   127   PROP_CONNECTION = 1,

   128   PROP_MEDIA_SESSION,

   129   PROP_OBJECT_PATH,

   130   PROP_MODE,

   131   PROP_NAME,

   132   PROP_ID,

   133   PROP_INITIATOR,

   134   PROP_MEDIA_TYPE,

   135   PROP_CONNECTION_STATE,

   136   PROP_READY,

   137   PROP_GOT_LOCAL_CODECS,

   138   PROP_SIGNALLING_STATE,

   139   PROP_PLAYING,

   140   PROP_COMBINED_DIRECTION,

   141   LAST_PROPERTY

   142 };

   143 

   144 /* private structure */

   145 typedef struct _GabbleMediaStreamPrivate GabbleMediaStreamPrivate;

   146 

   147 struct _GabbleMediaStreamPrivate

   148 {

   149   GabbleConnection *conn;

   150   GabbleMediaSession *session;

   151   GabbleMediaSessionMode mode;

   152   gchar *object_path;

   153   guint id;

   154   guint media_type;

   155 

   156   gboolean ready;

   157   gboolean sending;

   158 

   159   GValue native_codecs;     /* intersected codec list */

   160   GValue native_candidates;

   161 

   162   GValue remote_codecs;

   163   GValue remote_candidates;

   164 

   165   guint remote_candidate_count;

   166 

   167   gboolean closed;

   168   gboolean dispose_has_run;

   169 };

   170 

   171 #define GABBLE_MEDIA_STREAM_GET_PRIVATE(obj) \

   172     ((GabbleMediaStreamPrivate *)obj->priv)

   173 //Vinod: add below definition

   174 #define ENABLE_DEBUG

   175 

   176 #ifdef ENABLE_DEBUG

   177 #if _GMS_DEBUG_LEVEL > 1

   178 static const char *tp_protocols[] = {

   179   "TP_MEDIA_STREAM_PROTO_UDP (0)",

   180   "TP_MEDIA_STREAM_PROTO_TCP (1)"

   181 };

   182 

   183 static const char *tp_transports[] = {

   184   "TP_MEDIA_STREAM_TRANSPORT_TYPE_LOCAL (0)",

   185   "TP_MEDIA_STREAM_TRANSPORT_TYPE_DERIVED (1)",

   186   "TP_MEDIA_STREAM_TRANSPORT_TYPE_RELAY (2)"

   187 };

   188 #endif

   189 #endif

   190 

   191 static void push_native_candidates (GabbleMediaStream *stream);

   192 static void push_remote_codecs (GabbleMediaStream *stream);

   193 static void push_remote_candidates (GabbleMediaStream *stream);

   194 static void push_playing (GabbleMediaStream *stream);

   195 static void push_sending (GabbleMediaStream *stream);

   196 

   197 static void

   198 gabble_media_stream_init (GabbleMediaStream *self)

   199 {

   200   GabbleMediaStreamPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

   201       GABBLE_TYPE_MEDIA_STREAM, GabbleMediaStreamPrivate);

   202 

   203   self->priv = priv;

   204 

   205   g_value_init (&priv->native_codecs, TP_TYPE_CODEC_LIST);

   206   g_value_take_boxed (&priv->native_codecs,

   207       dbus_g_type_specialized_construct (TP_TYPE_CODEC_LIST));

   208 

   209   g_value_init (&priv->native_candidates, TP_TYPE_CANDIDATE_LIST);

   210   g_value_take_boxed (&priv->native_candidates,

   211       dbus_g_type_specialized_construct (TP_TYPE_CANDIDATE_LIST));

   212 

   213   g_value_init (&priv->remote_codecs, TP_TYPE_CODEC_LIST);

   214   g_value_take_boxed (&priv->remote_codecs,

   215       dbus_g_type_specialized_construct (TP_TYPE_CODEC_LIST));

   216 

   217   g_value_init (&priv->remote_candidates, TP_TYPE_CANDIDATE_LIST);

   218   g_value_take_boxed (&priv->remote_candidates,

   219       dbus_g_type_specialized_construct (TP_TYPE_CANDIDATE_LIST));

   220 }

   221 

   222 static GObject *

   223 gabble_media_stream_constructor (GType type, guint n_props,

   224                                  GObjectConstructParam *props)

   225 {

   226   GObject *obj;

   227   GabbleMediaStreamPrivate *priv;

   228   DBusGConnection *bus;

   229 

   230   /* call base class constructor */

   231   obj = G_OBJECT_CLASS (gabble_media_stream_parent_class)->

   232            constructor (type, n_props, props);

   233   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (GABBLE_MEDIA_STREAM (obj));

   234 

   235   /* go for the bus */

   236   bus = tp_get_bus ();

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

   238 

   239   return obj;

   240 }

   241 

   242 static void

   243 gabble_media_stream_get_property (GObject    *object,

   244                                   guint       property_id,

   245                                   GValue     *value,

   246                                   GParamSpec *pspec)

   247 {

   248   GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);

   249   GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (stream);

   250 

   251   switch (property_id) {

   252     case PROP_CONNECTION:

   253       g_value_set_object (value, priv->conn);

   254       break;

   255     case PROP_MEDIA_SESSION:

   256       g_value_set_object (value, priv->session);

   257       break;

   258     case PROP_OBJECT_PATH:

   259       g_value_set_string (value, priv->object_path);

   260       break;

   261     case PROP_MODE:

   262       g_value_set_enum (value, priv->mode);

   263       break;

   264     case PROP_NAME:

   265       g_value_set_string (value, stream->name);

   266       break;

   267     case PROP_ID:

   268       g_value_set_uint (value, priv->id);

   269       break;

   270     case PROP_INITIATOR:

   271       g_value_set_uint (value, stream->initiator);

   272       break;

   273     case PROP_MEDIA_TYPE:

   274       g_value_set_uint (value, priv->media_type);

   275       break;

   276     case PROP_CONNECTION_STATE:

   277       g_value_set_uint (value, stream->connection_state);

   278       break;

   279     case PROP_READY:

   280       g_value_set_boolean (value, priv->ready);

   281       break;

   282     case PROP_GOT_LOCAL_CODECS:

   283       g_value_set_boolean (value, stream->got_local_codecs);

   284       break;

   285     case PROP_SIGNALLING_STATE:

   286       g_value_set_uint (value, stream->signalling_state);

   287       break;

   288     case PROP_PLAYING:

   289       g_value_set_boolean (value, stream->playing);

   290       break;

   291     case PROP_COMBINED_DIRECTION:

   292       g_value_set_uint (value, stream->combined_direction);

   293       break;

   294     default:

   295       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   296       break;

   297   }

   298 }

   299 

   300 static void

   301 gabble_media_stream_set_property (GObject      *object,

   302                                   guint         property_id,

   303                                   const GValue *value,

   304                                   GParamSpec   *pspec)

   305 {

   306   GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);

   307   GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (stream);

   308 

   309   switch (property_id) {

   310     case PROP_CONNECTION:

   311       priv->conn = g_value_get_object (value);

   312       break;

   313     case PROP_MEDIA_SESSION:

   314       priv->session = g_value_get_object (value);

   315       break;

   316     case PROP_OBJECT_PATH:

   317       g_free (priv->object_path);

   318       priv->object_path = g_value_dup_string (value);

   319       break;

   320     case PROP_MODE:

   321       priv->mode = g_value_get_enum (value);

   322       break;

   323     case PROP_NAME:

   324       g_free (stream->name);

   325       stream->name = g_value_dup_string (value);

   326       break;

   327     case PROP_ID:

   328       priv->id = g_value_get_uint (value);

   329       break;

   330     case PROP_INITIATOR:

   331       stream->initiator = g_value_get_uint (value);

   332       break;

   333     case PROP_MEDIA_TYPE:

   334       priv->media_type = g_value_get_uint (value);

   335       break;

   336     case PROP_CONNECTION_STATE:

   337       _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "stream %s connection state %d",

   338           stream->name, stream->connection_state);

   339       stream->connection_state = g_value_get_uint (value);

   340       break;

   341     case PROP_READY:

   342       priv->ready = g_value_get_boolean (value);

   343       break;

   344     case PROP_GOT_LOCAL_CODECS:

   345       stream->got_local_codecs = g_value_get_boolean (value);

   346       break;

   347     case PROP_SIGNALLING_STATE:

   348         {

   349           StreamSignallingState old = stream->signalling_state;

   350           stream->signalling_state = g_value_get_uint (value);

   351           _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "stream %s sig_state %d->%d",

   352               stream->name, old, stream->signalling_state);

   353           if (stream->signalling_state != old)

   354             push_native_candidates (stream);

   355         }

   356       break;

   357     case PROP_PLAYING:

   358         {

   359           gboolean old = stream->playing;

   360           stream->playing = g_value_get_boolean (value);

   361           if (stream->playing != old)

   362             push_playing (stream);

   363         }

   364       break;

   365     case PROP_COMBINED_DIRECTION:

   366       stream->combined_direction = g_value_get_uint (value);

   367       break;

   368     default:

   369       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   370       break;

   371   }

   372 }

   373 

   374 static void gabble_media_stream_dispose (GObject *object);

   375 static void gabble_media_stream_finalize (GObject *object);

   376 

   377 static void

   378 gabble_media_stream_class_init (GabbleMediaStreamClass *gabble_media_stream_class)

   379 {

   380   GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_stream_class);

   381   GParamSpec *param_spec;

   382 

   383   g_type_class_add_private (gabble_media_stream_class, sizeof (GabbleMediaStreamPrivate));

   384 

   385   object_class->constructor = gabble_media_stream_constructor;

   386 

   387   object_class->get_property = gabble_media_stream_get_property;

   388   object_class->set_property = gabble_media_stream_set_property;

   389 

   390   object_class->dispose = gabble_media_stream_dispose;

   391   object_class->finalize = gabble_media_stream_finalize;

   392 

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

   394                                     "Gabble connection object that owns this "

   395                                     "media stream's channel.",

   396                                     GABBLE_TYPE_CONNECTION,

   397                                     G_PARAM_CONSTRUCT_ONLY |

   398                                     G_PARAM_READWRITE |

   399                                     G_PARAM_STATIC_NICK |

   400                                     G_PARAM_STATIC_BLURB);

   401   g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);

   402 

   403   param_spec = g_param_spec_object ("media-session", "GabbleMediaSession object",

   404                                     "Gabble media session object that owns this "

   405                                     "media stream object.",

   406                                     GABBLE_TYPE_MEDIA_SESSION,

   407                                     G_PARAM_CONSTRUCT_ONLY |

   408                                     G_PARAM_READWRITE |

   409                                     G_PARAM_STATIC_NICK |

   410                                     G_PARAM_STATIC_BLURB);

   411   g_object_class_install_property (object_class, PROP_MEDIA_SESSION, param_spec);

   412 

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

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

   415                                     "object on the bus.",

   416                                     NULL,

   417                                     G_PARAM_CONSTRUCT_ONLY |

   418                                     G_PARAM_READWRITE |

   419                                     G_PARAM_STATIC_NAME |

   420                                     G_PARAM_STATIC_BLURB);

   421   g_object_class_install_property (object_class, PROP_OBJECT_PATH, param_spec);

   422 

   423   param_spec = g_param_spec_enum ("mode", "Signalling mode",

   424                                   "Which signalling mode used to control the "

   425                                   "stream.",

   426                                   gabble_media_session_mode_get_type(),

   427                                   MODE_JINGLE,

   428                                   G_PARAM_CONSTRUCT_ONLY |

   429                                   G_PARAM_READWRITE |

   430                                   G_PARAM_STATIC_NAME |

   431                                   G_PARAM_STATIC_BLURB);

   432   g_object_class_install_property (object_class, PROP_MODE, param_spec);

   433 

   434   param_spec = g_param_spec_string ("name", "Stream name",

   435                                     "An opaque name for the stream used in the "

   436                                     "signalling.",

   437                                     NULL,

   438                                     G_PARAM_CONSTRUCT_ONLY |

   439                                     G_PARAM_READWRITE |

   440                                     G_PARAM_STATIC_NAME |

   441                                     G_PARAM_STATIC_BLURB);

   442   g_object_class_install_property (object_class, PROP_NAME, param_spec);

   443 

   444   param_spec = g_param_spec_uint ("id", "Stream ID",

   445                                   "A stream number for the stream used in the "

   446                                   "D-Bus API.",

   447                                   0, G_MAXUINT, 0,

   448                                   G_PARAM_CONSTRUCT_ONLY |

   449                                   G_PARAM_READWRITE |

   450                                   G_PARAM_STATIC_NAME |

   451                                   G_PARAM_STATIC_BLURB);

   452   g_object_class_install_property (object_class, PROP_ID, param_spec);

   453 

   454   param_spec = g_param_spec_uint ("initiator", "Stream initiator",

   455                                   "An enum signifying which end initiated "

   456                                   "the stream.",

   457                                   INITIATOR_LOCAL,

   458                                   INITIATOR_REMOTE,

   459                                   INITIATOR_LOCAL,

   460                                   G_PARAM_CONSTRUCT_ONLY |

   461                                   G_PARAM_READWRITE |

   462                                   G_PARAM_STATIC_NAME |

   463                                   G_PARAM_STATIC_BLURB);

   464   g_object_class_install_property (object_class, PROP_INITIATOR, param_spec);

   465 

   466   param_spec = g_param_spec_uint ("media-type", "Stream media type",

   467                                   "A constant indicating which media type the "

   468                                   "stream carries.",

   469                                   TP_MEDIA_STREAM_TYPE_AUDIO,

   470                                   TP_MEDIA_STREAM_TYPE_VIDEO,

   471                                   TP_MEDIA_STREAM_TYPE_AUDIO,

   472                                   G_PARAM_CONSTRUCT_ONLY |

   473                                   G_PARAM_READWRITE |

   474                                   G_PARAM_STATIC_NAME |

   475                                   G_PARAM_STATIC_BLURB);

   476   g_object_class_install_property (object_class, PROP_MEDIA_TYPE, param_spec);

   477 

   478   param_spec = g_param_spec_uint ("connection-state", "Stream connection state",

   479                                   "An integer indicating the state of the"

   480                                   "stream's connection.",

   481                                   TP_MEDIA_STREAM_STATE_DISCONNECTED,

   482                                   TP_MEDIA_STREAM_STATE_CONNECTED,

   483                                   TP_MEDIA_STREAM_STATE_DISCONNECTED,

   484                                   G_PARAM_CONSTRUCT |

   485                                   G_PARAM_READWRITE |

   486                                   G_PARAM_STATIC_NAME |

   487                                   G_PARAM_STATIC_BLURB);

   488   g_object_class_install_property (object_class, PROP_CONNECTION_STATE, param_spec);

   489 

   490   param_spec = g_param_spec_boolean ("ready", "Ready?",

   491                                      "A boolean signifying whether the user "

   492                                      "is ready to handle signals from this "

   493                                      "object.",

   494                                      FALSE,

   495                                      G_PARAM_CONSTRUCT |

   496                                      G_PARAM_READWRITE |

   497                                      G_PARAM_STATIC_NAME |

   498                                      G_PARAM_STATIC_BLURB);

   499   g_object_class_install_property (object_class, PROP_READY, param_spec);

   500 

   501   param_spec = g_param_spec_boolean ("got-local-codecs", "Got local codecs?",

   502                                      "A boolean signifying whether we've got "

   503                                      "the locally supported codecs from the user.",

   504                                      FALSE,

   505                                      G_PARAM_CONSTRUCT |

   506                                      G_PARAM_READWRITE |

   507                                      G_PARAM_STATIC_NAME |

   508                                      G_PARAM_STATIC_BLURB);

   509   g_object_class_install_property (object_class, PROP_GOT_LOCAL_CODECS, param_spec);

   510 

   511   param_spec = g_param_spec_uint ("signalling-state", "Signalling state",

   512                                   "Whether the stream is newly created, "

   513                                   "sent to the peer, or acknowledged.",

   514                                   STREAM_SIG_STATE_NEW,

   515                                   STREAM_SIG_STATE_REMOVING,

   516                                   STREAM_SIG_STATE_NEW,

   517                                   G_PARAM_CONSTRUCT |

   518                                   G_PARAM_READWRITE |

   519                                   G_PARAM_STATIC_NAME |

   520                                   G_PARAM_STATIC_BLURB);

   521   g_object_class_install_property (object_class, PROP_SIGNALLING_STATE, param_spec);

   522 

   523   param_spec = g_param_spec_boolean ("playing", "Set playing",

   524                                      "A boolean signifying whether the stream "

   525                                      "has been set playing yet.",

   526                                      FALSE,

   527                                      G_PARAM_CONSTRUCT |

   528                                      G_PARAM_READWRITE |

   529                                      G_PARAM_STATIC_NAME |

   530                                      G_PARAM_STATIC_BLURB);

   531   g_object_class_install_property (object_class, PROP_PLAYING, param_spec);

   532 

   533   param_spec = g_param_spec_uint ("combined-direction",

   534       "Combined direction",

   535       "An integer indicating the directions the stream currently sends in, "

   536       "and the peers who have been asked to send.",

   537       TP_MEDIA_STREAM_DIRECTION_NONE,

   538       MAKE_COMBINED_DIRECTION (TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL,

   539         TP_MEDIA_STREAM_PENDING_LOCAL_SEND |

   540         TP_MEDIA_STREAM_PENDING_REMOTE_SEND),

   541       TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL,

   542       G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_NAME |

   543       G_PARAM_STATIC_BLURB);

   544   g_object_class_install_property (object_class, PROP_COMBINED_DIRECTION,

   545       param_spec);

   546 

   547   /* signals exported by D-Bus interface */

   548   signals[DESTROY] =

   549     g_signal_new ("destroy",

   550                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   551                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   552                   0,

   553                   NULL, NULL,

   554                   g_cclosure_marshal_VOID__VOID,

   555                   G_TYPE_NONE, 0);

   556 

   557   signals[ADD_REMOTE_CANDIDATE] =

   558     g_signal_new ("add-remote-candidate",

   559                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   560                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   561                   0,

   562                   NULL, NULL,

   563                   gabble_media_stream_marshal_VOID__STRING_BOXED,

   564                   G_TYPE_NONE, 2, G_TYPE_STRING, TP_TYPE_TRANSPORT_LIST);

   565 

   566   signals[CLOSE] =

   567     g_signal_new ("close",

   568                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   569                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   570                   0,

   571                   NULL, NULL,

   572                   g_cclosure_marshal_VOID__VOID,

   573                   G_TYPE_NONE, 0);

   574 

   575   signals[REMOVE_REMOTE_CANDIDATE] =

   576     g_signal_new ("remove-remote-candidate",

   577                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   578                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   579                   0,

   580                   NULL, NULL,

   581                   g_cclosure_marshal_VOID__STRING,

   582                   G_TYPE_NONE, 1, G_TYPE_STRING);

   583 

   584   signals[SET_ACTIVE_CANDIDATE_PAIR] =

   585     g_signal_new ("set-active-candidate-pair",

   586                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   587                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   588                   0,

   589                   NULL, NULL,

   590                   gabble_media_stream_marshal_VOID__STRING_STRING,

   591                   G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);

   592 

   593   signals[SET_REMOTE_CANDIDATE_LIST] =

   594     g_signal_new ("set-remote-candidate-list",

   595                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   596                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   597                   0,

   598                   NULL, NULL,

   599                   g_cclosure_marshal_VOID__BOXED,

   600                   G_TYPE_NONE, 1, TP_TYPE_CANDIDATE_LIST);

   601 

   602   signals[SET_REMOTE_CODECS] =

   603     g_signal_new ("set-remote-codecs",

   604                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   605                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   606                   0,

   607                   NULL, NULL,

   608                   g_cclosure_marshal_VOID__BOXED,

   609                   G_TYPE_NONE, 1, TP_TYPE_CODEC_LIST);

   610 

   611   /* signals not exported by D-Bus interface */

   612   signals[NEW_ACTIVE_CANDIDATE_PAIR] =

   613     g_signal_new ("new-active-candidate-pair",

   614                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   615                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   616                   0,

   617                   NULL, NULL,

   618                   gabble_media_stream_marshal_VOID__STRING_STRING,

   619                   G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);

   620 

   621   signals[NEW_NATIVE_CANDIDATE] =

   622     g_signal_new ("new-native-candidate",

   623                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   624                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   625                   0,

   626                   NULL, NULL,

   627                   gabble_media_stream_marshal_VOID__STRING_BOXED,

   628                   G_TYPE_NONE, 2, G_TYPE_STRING, TP_TYPE_TRANSPORT_LIST);

   629 

   630   signals[SUPPORTED_CODECS] =

   631     g_signal_new ("supported-codecs",

   632                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   633                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   634                   0,

   635                   NULL, NULL,

   636                   g_cclosure_marshal_VOID__BOXED,

   637                   G_TYPE_NONE, 1, TP_TYPE_CODEC_LIST);

   638 

   639   signals[SET_STREAM_PLAYING] =

   640     g_signal_new ("set-stream-playing",

   641                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   642                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   643                   0,

   644                   NULL, NULL,

   645                   g_cclosure_marshal_VOID__BOOLEAN,

   646                   G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

   647 

   648   signals[SET_STREAM_SENDING] =

   649     g_signal_new ("set-stream-sending",

   650                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   651                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   652                   0,

   653                   NULL, NULL,

   654                   g_cclosure_marshal_VOID__BOOLEAN,

   655                   G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

   656 

   657   signals[ERROR] =

   658     g_signal_new ("error",

   659                   G_OBJECT_CLASS_TYPE (gabble_media_stream_class),

   660                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   661                   0,

   662                   NULL, NULL,

   663                   gabble_media_stream_marshal_VOID__UINT_STRING,

   664                   G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING);

   665 

   666   dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_media_stream_class), &dbus_glib_gabble_media_stream_object_info);

   667 }

   668 

   669 void

   670 gabble_media_stream_dispose (GObject *object)

   671 {

   672   GabbleMediaStream *self = GABBLE_MEDIA_STREAM (object);

   673   GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   674 

   675   if (priv->dispose_has_run)

   676     return;

   677 

   678   _gabble_media_stream_close (self);

   679 

   680   g_signal_emit (self, signals[DESTROY], 0);

   681 

   682   priv->dispose_has_run = TRUE;

   683 

   684   if (G_OBJECT_CLASS (gabble_media_stream_parent_class)->dispose)

   685     G_OBJECT_CLASS (gabble_media_stream_parent_class)->dispose (object);

   686 }

   687 

   688 void

   689 gabble_media_stream_finalize (GObject *object)

   690 {

   691   GabbleMediaStream *self = GABBLE_MEDIA_STREAM (object);

   692   GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   693 

   694   g_free (priv->object_path);

   695 

   696   g_value_unset (&priv->native_codecs);

   697   g_value_unset (&priv->native_candidates);

   698 

   699   g_value_unset (&priv->remote_codecs);

   700   g_value_unset (&priv->remote_candidates);

   701 

   702   G_OBJECT_CLASS (gabble_media_stream_parent_class)->finalize (object);

   703 }

   704 

   705 /**

   706  * gabble_media_stream_codec_choice

   707  *

   708  * Implements D-Bus method CodecChoice

   709  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   710  *

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

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

   713  *         function returns FALSE.

   714  *

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

   716  */

   717 gboolean

   718 gabble_media_stream_codec_choice (GabbleMediaStream *self,

   719                                   guint codec_id,

   720                                   GError **error)

   721 {

   722   GabbleMediaStreamPrivate *priv;

   723 

   724   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   725 

   726   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   727 

   728   return TRUE;

   729 }

   730 

   731 

   732 /**

   733  * gabble_media_stream_error

   734  *

   735  * Implements D-Bus method Error

   736  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   737  *

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

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

   740  *         function returns FALSE.

   741  *

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

   743  */

   744 gboolean

   745 gabble_media_stream_error (GabbleMediaStream *self,

   746                            guint errno,

   747                            const gchar *message,

   748                            GError **error)

   749 {

   750   GabbleMediaStreamPrivate *priv;

   751 

   752   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   753 

   754   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   755 

   756  _gabble_media_session_debug (priv->session, DEBUG_MSG_WARNING, "Media.StreamHandler::Error called, error %u (%s) -- emitting signal", errno, message);

   757 

   758   g_signal_emit (self, signals[ERROR], 0, errno, message);

   759 

   760   return TRUE;

   761 }

   762 

   763 

   764 /**

   765  * gabble_media_stream_native_candidates_prepared

   766  *

   767  * Implements D-Bus method NativeCandidatesPrepared

   768  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   769  *

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

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

   772  *         function returns FALSE.

   773  *

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

   775  */

   776 gboolean

   777 gabble_media_stream_native_candidates_prepared (GabbleMediaStream *self,

   778                                                 GError **error)

   779 {

   780   GabbleMediaStreamPrivate *priv;

   781 

   782   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   783 

   784   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   785 

   786   return TRUE;

   787 }

   788 

   789 

   790 /**

   791  * gabble_media_stream_new_active_candidate_pair

   792  *

   793  * Implements D-Bus method NewActiveCandidatePair

   794  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   795  *

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

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

   798  *         function returns FALSE.

   799  *

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

   801  */

   802 gboolean

   803 gabble_media_stream_new_active_candidate_pair (GabbleMediaStream *self,

   804                                                const gchar *native_candidate_id,

   805                                                const gchar *remote_candidate_id,

   806                                                GError **error)

   807 {

   808   GabbleMediaStreamPrivate *priv;

   809 

   810   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   811 

   812   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   813 

   814   g_signal_emit (self, signals[NEW_ACTIVE_CANDIDATE_PAIR], 0,

   815                  native_candidate_id, remote_candidate_id);

   816 

   817   return TRUE;

   818 }

   819 

   820 

   821 /**

   822  * gabble_media_stream_new_native_candidate

   823  *

   824  * Implements D-Bus method NewNativeCandidate

   825  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   826  *

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

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

   829  *         function returns FALSE.

   830  *

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

   832  */

   833 gboolean

   834 gabble_media_stream_new_native_candidate (GabbleMediaStream *self,

   835                                           const gchar *candidate_id,

   836                                           const GPtrArray *transports,

   837                                           GError **error)

   838 {

   839   GabbleMediaStreamPrivate *priv;

   840   JingleSessionState state;

   841   GPtrArray *candidates;

   842   GValue candidate = { 0, };

   843   GValueArray *transport;

   844   const gchar *addr;

   845 

   846   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   847 

   848   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   849 

   850   g_object_get (priv->session, "state", &state, NULL);

   851 

   852   /* FIXME: maybe this should be an assertion in case the channel

   853    * isn't closed early enough right now? */

   854   if (state > JS_STATE_ACTIVE)

   855     {

   856       gabble_debug (DEBUG_FLAG, "state > JS_STATE_ACTIVE, doing nothing");

   857       return TRUE;

   858     }

   859 

   860   candidates = g_value_get_boxed (&priv->native_candidates);

   861 

   862   g_value_init (&candidate, TP_TYPE_CANDIDATE_STRUCT);

   863   g_value_take_boxed (&candidate,

   864       dbus_g_type_specialized_construct (TP_TYPE_CANDIDATE_STRUCT));

   865 

   866   dbus_g_type_struct_set (&candidate,

   867       0, candidate_id,

   868       1, transports,

   869       G_MAXUINT);

   870 

   871   transport = g_ptr_array_index (transports, 0);

   872   addr = g_value_get_string (g_value_array_get_nth (transport, 1));

   873   if (!strcmp (addr, "127.0.0.1"))

   874     {

   875      _gabble_media_session_debug (priv->session, DEBUG_MSG_WARNING, "%s: ignoring native localhost candidate",

   876                          G_STRFUNC);

   877       return TRUE;

   878     }

   879 

   880   g_ptr_array_add (candidates, g_value_get_boxed (&candidate));

   881 

   882   _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "put 1 native candidate from stream-engine into cache");

   883 

   884   push_native_candidates (self);

   885 

   886   g_signal_emit (self, signals[NEW_NATIVE_CANDIDATE], 0,

   887                  candidate_id, transports);

   888 

   889   return TRUE;

   890 }

   891 

   892 

   893 /**

   894  * gabble_media_stream_ready

   895  *

   896  * Implements D-Bus method Ready

   897  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   898  *

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

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

   901  *         function returns FALSE.

   902  *

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

   904  */

   905 gboolean

   906 gabble_media_stream_ready (GabbleMediaStream *self,

   907                            const GPtrArray *codecs,

   908                            GError **error)

   909 {

   910   GabbleMediaStreamPrivate *priv;

   911 

   912   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   913 

   914   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   915 

   916   _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "ready called");

   917 

   918   g_object_set (self, "ready", TRUE, NULL);

   919 

   920   push_remote_codecs (self);

   921   push_remote_candidates (self);

   922   push_playing (self);

   923   push_sending (self);

   924 

   925   return gabble_media_stream_set_local_codecs (self, codecs, error);

   926 }

   927 

   928 

   929 /**

   930  * gabble_media_stream_set_local_codecs

   931  *

   932  * Implements D-Bus method SetLocalCodecs

   933  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   934  *

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

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

   937  *         function returns FALSE.

   938  *

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

   940  */

   941 gboolean

   942 gabble_media_stream_set_local_codecs (GabbleMediaStream *self,

   943                                       const GPtrArray *codecs,

   944                                       GError **error)

   945 {

   946   GabbleMediaStreamPrivate *priv;

   947 

   948   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   949 

   950   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

   951 

   952   _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "putting list of all %d locally supported "

   953                   "codecs from stream-engine into cache", codecs->len);

   954 

   955   g_value_set_boxed (&priv->native_codecs, codecs);

   956 

   957   g_object_set (self, "got-local-codecs", TRUE, NULL);

   958 

   959   return TRUE;

   960 }

   961 

   962 

   963 /**

   964  * gabble_media_stream_stream_state

   965  *

   966  * Implements D-Bus method StreamState

   967  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   968  *

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

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

   971  *         function returns FALSE.

   972  *

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

   974  */

   975 gboolean

   976 gabble_media_stream_stream_state (GabbleMediaStream *self,

   977                                   guint connection_state,

   978                                   GError **error)

   979 {

   980   g_assert (GABBLE_IS_MEDIA_STREAM (self));

   981 

   982   g_object_set (self, "connection-state", connection_state, NULL);

   983 

   984   return TRUE;

   985 }

   986 

   987 

   988 /**

   989  * gabble_media_stream_supported_codecs

   990  *

   991  * Implements D-Bus method SupportedCodecs

   992  * on interface org.freedesktop.Telepathy.Media.StreamHandler

   993  *

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

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

   996  *         function returns FALSE.

   997  *

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

   999  */

  1000 gboolean

  1001 gabble_media_stream_supported_codecs (GabbleMediaStream *self,

  1002                                       const GPtrArray *codecs,

  1003                                       GError **error)

  1004 {

  1005   GabbleMediaStreamPrivate *priv;

  1006 

  1007   g_assert (GABBLE_IS_MEDIA_STREAM (self));

  1008 

  1009   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (self);

  1010 

  1011   _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "got codec intersection containing %d "

  1012                   "codecs from stream-engine", codecs->len);

  1013 

  1014   /* store the intersection for later on */

  1015   g_value_set_boxed (&priv->native_codecs, codecs);

  1016 

  1017   g_signal_emit (self, signals[SUPPORTED_CODECS], 0, codecs);

  1018 

  1019   return TRUE;

  1020 }

  1021 

  1022 static LmHandlerResult

  1023 candidates_msg_reply_cb (GabbleConnection *conn,

  1024                          LmMessage *sent_msg,

  1025                          LmMessage *reply_msg,

  1026                          GObject *object,

  1027                          gpointer user_data)

  1028 {

  1029   GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);

  1030   GabbleMediaStreamPrivate *priv;

  1031 

  1032   g_assert (GABBLE_IS_MEDIA_STREAM (stream));

  1033 

  1034   priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (stream);

  1035 

  1036   MSG_REPLY_CB_END_SESSION_IF_NOT_SUCCESSFUL (priv->session, "candidates failed");

  1037 

  1038   return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  1039 }

  1040 

  1041 static void

  1042 _add_rtp_candidate_node (GabbleMediaSession *session, LmMessageNode *parent,

  1043                          GValueArray *candidate)

  1044 {

  1045   gchar *addr;

  1046   gchar *user;

  1047   gchar *pass;

  1048   gchar *port_str;

  1049   gchar *pref_str;

  1050   gchar *xml;

  1051   const gchar *type_str;

  1052   const gchar *candidate_id;

  1053   guint port;

  1054   gdouble pref;

  1055   TpMediaStreamProto proto;

  1056   TpMediaStreamTransportType type;

  1057   const GPtrArray *transports;

  1058   GValue transport = { 0, };

  1059   LmMessageNode *cand_node;

  1060 

  1061   candidate_id = g_value_get_string (g_value_array_get_nth (candidate, 0));

  1062   transports = g_value_get_boxed (g_value_array_get_nth (candidate, 1));

  1063 

  1064   /* jingle audio only supports the concept of one transport per candidate */

  1065   g_assert (transports->len == 1);

  1066 

  1067   g_value_init (&transport, TP_TYPE_TRANSPORT_STRUCT);

  1068   g_value_set_static_boxed (&transport, g_ptr_array_index (transports, 0));

  1069 

  1070   dbus_g_type_struct_get (&transport,

  1071       1, &addr,

  1072       2, &port,

  1073       3, &proto,

  1074       6, &pref,

  1075       7, &type,

  1076       8, &user,

  1077       9, &pass,

  1078       G_MAXUINT);

  1079 

  1080   port_str = g_strdup_printf ("%d", port);

  1081   pref_str = g_strdup_printf ("%f", pref);

  1082 

  1083   switch (type) {

  1084     case TP_MEDIA_STREAM_TRANSPORT_TYPE_LOCAL:

  1085       type_str = "local";

  1086       break;

  1087     case TP_MEDIA_STREAM_TRANSPORT_TYPE_DERIVED:

  1088       type_str = "stun";

  1089       break;

  1090     case TP_MEDIA_STREAM_TRANSPORT_TYPE_RELAY:

  1091       type_str = "relay";

  1092       break;

  1093     default:

  1094       g_error ("%s: TpMediaStreamTransportType has an invalid value",

  1095         G_STRFUNC);

  1096       return;

  1097   }

  1098 

  1099   cand_node = lm_message_node_add_child (parent, "candidate", NULL);

  1100   lm_message_node_set_attributes (cand_node,

  1101       "name", "rtp",

  1102       "address", addr,

  1103       "port", port_str,

  1104       "username", user,

  1105       "password", pass,

  1106       "preference", pref_str,

  1107       "protocol", (proto == TP_MEDIA_STREAM_PROTO_UDP) ? "udp" : "tcp",

  1108       "type", type_str,

  1109       "network", "0",

  1110       "generation", "0",

  1111       NULL);

  1112 

  1113   xml = lm_message_node_to_string (cand_node);

  1114   _gabble_media_session_debug (session, DEBUG_MSG_DUMP,

  1115     "  from Telepathy D-Bus struct: [%s\"%s\", %s[%s1, \"%s\", %d, %s, "

  1116     "\"%s\", \"%s\", %f, %s, \"%s\", \"%s\"%s]]",

  1117     ANSI_BOLD_OFF, candidate_id, ANSI_BOLD_ON, ANSI_BOLD_OFF, addr, port,

  1118     tp_protocols[proto], "RTP", "AVP", pref, tp_transports[type], user, pass,

  1119     ANSI_BOLD_ON);

  1120   _gabble_media_session_debug (session, DEBUG_MSG_DUMP,

  1121     "  to Jingle XML: [%s%s%s]", ANSI_BOLD_OFF, xml, ANSI_BOLD_ON);

  1122   g_free (xml);

  1123 

  1124   g_free (addr);

  1125   g_free (user);

  1126   g_free (pass);

  1127   g_free (port_str);

  1128   g_free (pref_str);

  1129 }

  1130 

  1131 static LmMessage *

  1132 _gabble_media_stream_message_new (GabbleMediaStream *stream,

  1133                                   const gchar *action,

  1134                                   LmMessageNode **content_node)

  1135 {