gst/rtsp-server/rtsp-client.c

   1 /* GStreamer
   2  * Copyright (C) 2008 Wim Taymans <wim.taymans at gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19 /**
  20  * SECTION:rtsp-client
  21  * @short_description: A client connection state
  22  * @see_also: #GstRTSPServer, #GstRTSPThreadPool
  23  *
  24  * The client object handles the connection with a client for as long as a TCP
  25  * connection is open.
  26  *
  27  * A #GstRTSPClient is created by #GstRTSPServer when a new connection is
  28  * accepted and it inherits the #GstRTSPMountPoints, #GstRTSPSessionPool,
  29  * #GstRTSPAuth and #GstRTSPThreadPool from the server.
  30  *
  31  * The client connection should be configured with the #GstRTSPConnection using
  32  * gst_rtsp_client_set_connection() before it can be attached to a #GMainContext
  33  * using gst_rtsp_client_attach(). From then on the client will handle requests
  34  * on the connection.
  35  *
  36  * Use gst_rtsp_client_session_filter() to iterate or modify all the
  37  * #GstRTSPSession objects managed by the client object.
  38  *
  39  * Last reviewed on 2013-07-11 (1.0.0)
  40  */
  41
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 #include "rtsp-client.h"
  46 #include "rtsp-sdp.h"
  47 #include "rtsp-params.h"
  48
  49 #define GST_RTSP_CLIENT_GET_PRIVATE(obj)  \
  50    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTSP_CLIENT, GstRTSPClientPrivate))
  51
  52 /* locking order:
  53  * send_lock, lock, tunnels_lock
  54  */
  55
  56 struct _GstRTSPClientPrivate
  57 {
  58   GMutex lock;                  /* protects everything else */
  59   GMutex send_lock;
  60   GstRTSPConnection *connection;
  61   GstRTSPWatch *watch;
  62   guint close_seq;
  63   gchar *server_ip;
  64   gboolean is_ipv6;
  65   gboolean use_client_settings;
  66
  67   GstRTSPClientSendFunc send_func;      /* protected by send_lock */
  68   gpointer send_data;           /* protected by send_lock */
  69   GDestroyNotify send_notify;   /* protected by send_lock */
  70
  71   GstRTSPSessionPool *session_pool;
  72   GstRTSPMountPoints *mount_points;
  73   GstRTSPAuth *auth;
  74   GstRTSPThreadPool *thread_pool;
  75
  76   /* used to cache the media in the last requested DESCRIBE so that
  77    * we can pick it up in the next SETUP immediately */
  78   gchar *path;
  79   GstRTSPMedia *media;
  80
  81   GList *transports;
  82   GList *sessions;
  83 };
  84
  85 static GMutex tunnels_lock;
  86 static GHashTable *tunnels;     /* protected by tunnels_lock */
  87
  88 #define DEFAULT_SESSION_POOL            NULL
  89 #define DEFAULT_MOUNT_POINTS            NULL
  90 #define DEFAULT_USE_CLIENT_SETTINGS     FALSE
  91
  92 enum
  93 {
  94   PROP_0,
  95   PROP_SESSION_POOL,
  96   PROP_MOUNT_POINTS,
  97   PROP_USE_CLIENT_SETTINGS,
  98   PROP_LAST
  99 };
 100
 101 enum
 102 {
 103   SIGNAL_CLOSED,
 104   SIGNAL_NEW_SESSION,
 105   SIGNAL_OPTIONS_REQUEST,
 106   SIGNAL_DESCRIBE_REQUEST,
 107   SIGNAL_SETUP_REQUEST,
 108   SIGNAL_PLAY_REQUEST,
 109   SIGNAL_PAUSE_REQUEST,
 110   SIGNAL_TEARDOWN_REQUEST,
 111   SIGNAL_SET_PARAMETER_REQUEST,
 112   SIGNAL_GET_PARAMETER_REQUEST,
 113   SIGNAL_LAST
 114 };
 115
 116 GST_DEBUG_CATEGORY_STATIC (rtsp_client_debug);
 117 #define GST_CAT_DEFAULT rtsp_client_debug
 118
 119 static guint gst_rtsp_client_signals[SIGNAL_LAST] = { 0 };
 120
 121 static void gst_rtsp_client_get_property (GObject * object, guint propid,
 122     GValue * value, GParamSpec * pspec);
 123 static void gst_rtsp_client_set_property (GObject * object, guint propid,
 124     const GValue * value, GParamSpec * pspec);
 125 static void gst_rtsp_client_finalize (GObject * obj);
 126
 127 static GstSDPMessage *create_sdp (GstRTSPClient * client, GstRTSPMedia * media);
 128 static void client_session_finalized (GstRTSPClient * client,
 129     GstRTSPSession * session);
 130 static void unlink_session_transports (GstRTSPClient * client,
 131     GstRTSPSession * session, GstRTSPSessionMedia * sessmedia);
 132 static gboolean default_configure_client_transport (GstRTSPClient * client,
 133     GstRTSPClientState * state, GstRTSPTransport * ct);
 134 static GstRTSPResult default_params_set (GstRTSPClient * client,
 135     GstRTSPClientState * state);
 136 static GstRTSPResult default_params_get (GstRTSPClient * client,
 137     GstRTSPClientState * state);
 138
 139 G_DEFINE_TYPE (GstRTSPClient, gst_rtsp_client, G_TYPE_OBJECT);
 140
 141 static void
 142 gst_rtsp_client_class_init (GstRTSPClientClass * klass)
 143 {
 144   GObjectClass *gobject_class;
 145
 146   g_type_class_add_private (klass, sizeof (GstRTSPClientPrivate));
 147
 148   gobject_class = G_OBJECT_CLASS (klass);
 149
 150   gobject_class->get_property = gst_rtsp_client_get_property;
 151   gobject_class->set_property = gst_rtsp_client_set_property;
 152   gobject_class->finalize = gst_rtsp_client_finalize;
 153
 154   klass->create_sdp = create_sdp;
 155   klass->configure_client_transport = default_configure_client_transport;
 156   klass->params_set = default_params_set;
 157   klass->params_get = default_params_get;
 158
 159   g_object_class_install_property (gobject_class, PROP_SESSION_POOL,
 160       g_param_spec_object ("session-pool", "Session Pool",
 161           "The session pool to use for client session",
 162           GST_TYPE_RTSP_SESSION_POOL,
 163           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 164
 165   g_object_class_install_property (gobject_class, PROP_MOUNT_POINTS,
 166       g_param_spec_object ("mount-points", "Mount Points",
 167           "The mount points to use for client session",
 168           GST_TYPE_RTSP_MOUNT_POINTS,
 169           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 170
 171   g_object_class_install_property (gobject_class, PROP_USE_CLIENT_SETTINGS,
 172       g_param_spec_boolean ("use-client-settings", "Use Client Settings",
 173           "Use client settings for ttl and destination in multicast",
 174           DEFAULT_USE_CLIENT_SETTINGS,
 175           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 176
 177   gst_rtsp_client_signals[SIGNAL_CLOSED] =
 178       g_signal_new ("closed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 179       G_STRUCT_OFFSET (GstRTSPClientClass, closed), NULL, NULL,
 180       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 181
 182   gst_rtsp_client_signals[SIGNAL_NEW_SESSION] =
 183       g_signal_new ("new-session", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 184       G_STRUCT_OFFSET (GstRTSPClientClass, new_session), NULL, NULL,
 185       g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_RTSP_SESSION);
 186
 187   gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST] =
 188       g_signal_new ("options-request", G_TYPE_FROM_CLASS (klass),
 189       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, options_request),
 190       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 191       G_TYPE_POINTER);
 192
 193   gst_rtsp_client_signals[SIGNAL_DESCRIBE_REQUEST] =
 194       g_signal_new ("describe-request", G_TYPE_FROM_CLASS (klass),
 195       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, describe_request),
 196       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 197       G_TYPE_POINTER);
 198
 199   gst_rtsp_client_signals[SIGNAL_SETUP_REQUEST] =
 200       g_signal_new ("setup-request", G_TYPE_FROM_CLASS (klass),
 201       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, setup_request),
 202       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 203       G_TYPE_POINTER);
 204
 205   gst_rtsp_client_signals[SIGNAL_PLAY_REQUEST] =
 206       g_signal_new ("play-request", G_TYPE_FROM_CLASS (klass),
 207       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, play_request),
 208       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 209       G_TYPE_POINTER);
 210
 211   gst_rtsp_client_signals[SIGNAL_PAUSE_REQUEST] =
 212       g_signal_new ("pause-request", G_TYPE_FROM_CLASS (klass),
 213       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, pause_request),
 214       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 215       G_TYPE_POINTER);
 216
 217   gst_rtsp_client_signals[SIGNAL_TEARDOWN_REQUEST] =
 218       g_signal_new ("teardown-request", G_TYPE_FROM_CLASS (klass),
 219       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, teardown_request),
 220       NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 221       G_TYPE_POINTER);
 222
 223   gst_rtsp_client_signals[SIGNAL_SET_PARAMETER_REQUEST] =
 224       g_signal_new ("set-parameter-request", G_TYPE_FROM_CLASS (klass),
 225       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
 226           set_parameter_request), NULL, NULL, g_cclosure_marshal_VOID__POINTER,
 227       G_TYPE_NONE, 1, G_TYPE_POINTER);
 228
 229   gst_rtsp_client_signals[SIGNAL_GET_PARAMETER_REQUEST] =
 230       g_signal_new ("get-parameter-request", G_TYPE_FROM_CLASS (klass),
 231       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
 232           get_parameter_request), NULL, NULL, g_cclosure_marshal_VOID__POINTER,
 233       G_TYPE_NONE, 1, G_TYPE_POINTER);
 234
 235   tunnels =
 236       g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
 237   g_mutex_init (&tunnels_lock);
 238
 239   GST_DEBUG_CATEGORY_INIT (rtsp_client_debug, "rtspclient", 0, "GstRTSPClient");
 240 }
 241
 242 static void
 243 gst_rtsp_client_init (GstRTSPClient * client)
 244 {
 245   GstRTSPClientPrivate *priv = GST_RTSP_CLIENT_GET_PRIVATE (client);
 246
 247   client->priv = priv;
 248
 249   g_mutex_init (&priv->lock);
 250   g_mutex_init (&priv->send_lock);
 251   priv->use_client_settings = DEFAULT_USE_CLIENT_SETTINGS;
 252   priv->close_seq = 0;
 253 }
 254
 255 static GstRTSPFilterResult
 256 filter_session (GstRTSPSession * sess, GstRTSPSessionMedia * sessmedia,
 257     gpointer user_data)
 258 {
 259   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
 260
 261   gst_rtsp_session_media_set_state (sessmedia, GST_STATE_NULL);
 262   unlink_session_transports (client, sess, sessmedia);
 263
 264   /* unmanage the media in the session */
 265   return GST_RTSP_FILTER_REMOVE;
 266 }
 267
 268 static void
 269 client_unlink_session (GstRTSPClient * client, GstRTSPSession * session)
 270 {
 271   /* unlink all media managed in this session */
 272   gst_rtsp_session_filter (session, filter_session, client);
 273 }
 274
 275 static void
 276 client_watch_session (GstRTSPClient * client, GstRTSPSession * session)
 277 {
 278   GstRTSPClientPrivate *priv = client->priv;
 279   GList *walk;
 280
 281   for (walk = priv->sessions; walk; walk = g_list_next (walk)) {
 282     GstRTSPSession *msession = (GstRTSPSession *) walk->data;
 283
 284     /* we already know about this session */
 285     if (msession == session)
 286       return;
 287   }
 288
 289   GST_INFO ("watching session %p", session);
 290
 291   g_object_weak_ref (G_OBJECT (session), (GWeakNotify) client_session_finalized,
 292       client);
 293   priv->sessions = g_list_prepend (priv->sessions, session);
 294 }
 295
 296 static void
 297 client_unwatch_session (GstRTSPClient * client, GstRTSPSession * session)
 298 {
 299   GstRTSPClientPrivate *priv = client->priv;
 300
 301   GST_INFO ("unwatching session %p", session);
 302
 303   g_object_weak_unref (G_OBJECT (session),
 304       (GWeakNotify) client_session_finalized, client);
 305   priv->sessions = g_list_remove (priv->sessions, session);
 306 }
 307
 308 static void
 309 client_cleanup_session (GstRTSPClient * client, GstRTSPSession * session)
 310 {
 311   g_object_weak_unref (G_OBJECT (session),
 312       (GWeakNotify) client_session_finalized, client);
 313   client_unlink_session (client, session);
 314 }
 315
 316 static void
 317 client_cleanup_sessions (GstRTSPClient * client)
 318 {
 319   GstRTSPClientPrivate *priv = client->priv;
 320   GList *sessions;
 321
 322   /* remove weak-ref from sessions */
 323   for (sessions = priv->sessions; sessions; sessions = g_list_next (sessions)) {
 324     client_cleanup_session (client, (GstRTSPSession *) sessions->data);
 325   }
 326   g_list_free (priv->sessions);
 327   priv->sessions = NULL;
 328 }
 329
 330 /* A client is finalized when the connection is broken */
 331 static void
 332 gst_rtsp_client_finalize (GObject * obj)
 333 {
 334   GstRTSPClient *client = GST_RTSP_CLIENT (obj);
 335   GstRTSPClientPrivate *priv = client->priv;
 336
 337   GST_INFO ("finalize client %p", client);
 338
 339   gst_rtsp_client_set_send_func (client, NULL, NULL, NULL);
 340
 341   if (priv->watch)
 342     g_source_destroy ((GSource *) priv->watch);
 343
 344   client_cleanup_sessions (client);
 345
 346   if (priv->connection)
 347     gst_rtsp_connection_free (priv->connection);
 348   if (priv->session_pool)
 349     g_object_unref (priv->session_pool);
 350   if (priv->mount_points)
 351     g_object_unref (priv->mount_points);
 352   if (priv->auth)
 353     g_object_unref (priv->auth);
 354
 355   if (priv->path)
 356     g_free (priv->path);
 357   if (priv->media) {
 358     gst_rtsp_media_unprepare (priv->media);
 359     g_object_unref (priv->media);
 360   }
 361
 362   g_free (priv->server_ip);
 363   g_mutex_clear (&priv->lock);
 364   g_mutex_clear (&priv->send_lock);
 365
 366   G_OBJECT_CLASS (gst_rtsp_client_parent_class)->finalize (obj);
 367 }
 368
 369 static void
 370 gst_rtsp_client_get_property (GObject * object, guint propid,
 371     GValue * value, GParamSpec * pspec)
 372 {
 373   GstRTSPClient *client = GST_RTSP_CLIENT (object);
 374
 375   switch (propid) {
 376     case PROP_SESSION_POOL:
 377       g_value_take_object (value, gst_rtsp_client_get_session_pool (client));
 378       break;
 379     case PROP_MOUNT_POINTS:
 380       g_value_take_object (value, gst_rtsp_client_get_mount_points (client));
 381       break;
 382     case PROP_USE_CLIENT_SETTINGS:
 383       g_value_set_boolean (value,
 384           gst_rtsp_client_get_use_client_settings (client));
 385       break;
 386     default:
 387       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 388   }
 389 }
 390
 391 static void
 392 gst_rtsp_client_set_property (GObject * object, guint propid,
 393     const GValue * value, GParamSpec * pspec)
 394 {
 395   GstRTSPClient *client = GST_RTSP_CLIENT (object);
 396
 397   switch (propid) {
 398     case PROP_SESSION_POOL:
 399       gst_rtsp_client_set_session_pool (client, g_value_get_object (value));
 400       break;
 401     case PROP_MOUNT_POINTS:
 402       gst_rtsp_client_set_mount_points (client, g_value_get_object (value));
 403       break;
 404     case PROP_USE_CLIENT_SETTINGS:
 405       gst_rtsp_client_set_use_client_settings (client,
 406           g_value_get_boolean (value));
 407       break;
 408     default:
 409       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 410   }
 411 }
 412
 413 /**
 414  * gst_rtsp_client_new:
 415  *
 416  * Create a new #GstRTSPClient instance.
 417  *
 418  * Returns: a new #GstRTSPClient
 419  */
 420 GstRTSPClient *
 421 gst_rtsp_client_new (void)
 422 {
 423   GstRTSPClient *result;
 424
 425   result = g_object_new (GST_TYPE_RTSP_CLIENT, NULL);
 426
 427   return result;
 428 }
 429
 430 static void
 431 send_message (GstRTSPClient * client, GstRTSPSession * session,
 432     GstRTSPMessage * message, gboolean close)
 433 {
 434   GstRTSPClientPrivate *priv = client->priv;
 435
 436   gst_rtsp_message_add_header (message, GST_RTSP_HDR_SERVER,
 437       "GStreamer RTSP server");
 438
 439   /* remove any previous header */
 440   gst_rtsp_message_remove_header (message, GST_RTSP_HDR_SESSION, -1);
 441
 442   /* add the new session header for new session ids */
 443   if (session) {
 444     gst_rtsp_message_take_header (message, GST_RTSP_HDR_SESSION,
 445         gst_rtsp_session_get_header (session));
 446   }
 447
 448   if (gst_debug_category_get_threshold (rtsp_client_debug) >= GST_LEVEL_LOG) {
 449     gst_rtsp_message_dump (message);
 450   }
 451
 452   if (close)
 453     gst_rtsp_message_add_header (message, GST_RTSP_HDR_CONNECTION, "close");
 454
 455   g_mutex_lock (&priv->send_lock);
 456   if (priv->send_func)
 457     priv->send_func (client, message, close, priv->send_data);
 458   g_mutex_unlock (&priv->send_lock);
 459
 460   gst_rtsp_message_unset (message);
 461 }
 462
 463 static void
 464 send_generic_response (GstRTSPClient * client, GstRTSPStatusCode code,
 465     GstRTSPClientState * state)
 466 {
 467   gst_rtsp_message_init_response (state->response, code,
 468       gst_rtsp_status_as_text (code), state->request);
 469
 470   send_message (client, NULL, state->response, FALSE);
 471 }
 472
 473 static void
 474 handle_unauthorized_request (GstRTSPClient * client, GstRTSPAuth * auth,
 475     GstRTSPClientState * state)
 476 {
 477   gst_rtsp_message_init_response (state->response, GST_RTSP_STS_UNAUTHORIZED,
 478       gst_rtsp_status_as_text (GST_RTSP_STS_UNAUTHORIZED), state->request);
 479
 480   if (auth) {
 481     /* and let the authentication manager setup the auth tokens */
 482     gst_rtsp_auth_setup (auth, state);
 483   }
 484
 485   send_message (client, state->session, state->response, FALSE);
 486 }
 487
 488
 489 static gboolean
 490 paths_are_equal (const gchar * path1, const gchar * path2, gint len2)
 491 {
 492   if (path1 == NULL || path2 == NULL)
 493     return FALSE;
 494
 495   if (strlen (path1) != len2)
 496     return FALSE;
 497
 498   if (strncmp (path1, path2, len2))
 499     return FALSE;
 500
 501   return TRUE;
 502 }
 503
 504 /* this function is called to initially find the media for the DESCRIBE request
 505  * but is cached for when the same client (without breaking the connection) is
 506  * doing a setup for the exact same url. */
 507 static GstRTSPMedia *
 508 find_media (GstRTSPClient * client, GstRTSPClientState * state, gint * matched)
 509 {
 510   GstRTSPClientPrivate *priv = client->priv;
 511   GstRTSPMediaFactory *factory;
 512   GstRTSPMedia *media;
 513   gchar *path;
 514   gint path_len;
 515
 516   if (!priv->mount_points)
 517     goto no_mount_points;
 518
 519   path = state->uri->abspath;
 520
 521   /* find the longest matching factory for the uri first */
 522   if (!(factory = gst_rtsp_mount_points_match (priv->mount_points,
 523               path, matched)))
 524     goto no_factory;
 525
 526   state->factory = factory;
 527
 528   if (!gst_rtsp_auth_check (GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_ACCESS))
 529     goto no_factory_access;
 530
 531   if (!gst_rtsp_auth_check (GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_CONSTRUCT))
 532     goto not_authorized;
 533
 534   if (matched)
 535     path_len = *matched;
 536   else
 537     path_len = strlen (path);
 538
 539   if (!paths_are_equal (priv->path, path, path_len)) {
 540     GstRTSPThread *thread;
 541
 542     /* remove any previously cached values before we try to construct a new
 543      * media for uri */
 544     if (priv->path)
 545       g_free (priv->path);
 546     priv->path = NULL;
 547     if (priv->media) {
 548       gst_rtsp_media_unprepare (priv->media);
 549       g_object_unref (priv->media);
 550     }
 551     priv->media = NULL;
 552
 553     /* prepare the media and add it to the pipeline */
 554     if (!(media = gst_rtsp_media_factory_construct (factory, state->uri)))
 555       goto no_media;
 556
 557     state->media = media;
 558
 559     thread = gst_rtsp_thread_pool_get_thread (priv->thread_pool,
 560         GST_RTSP_THREAD_TYPE_MEDIA, state);
 561     if (thread == NULL)
 562       goto no_thread;
 563
 564     /* prepare the media */
 565     if (!(gst_rtsp_media_prepare (media, thread)))
 566       goto no_prepare;
 567
 568     /* now keep track of the uri and the media */
 569     priv->path = g_strndup (path, path_len);
 570     priv->media = media;
 571   } else {
 572     /* we have seen this path before, used cached media */
 573     media = priv->media;
 574     state->media = media;
 575     GST_INFO ("reusing cached media %p for path %s", media, priv->path);
 576   }
 577
 578   g_object_unref (factory);
 579   state->factory = NULL;
 580
 581   if (media)
 582     g_object_ref (media);
 583
 584   return media;
 585
 586   /* ERRORS */
 587 no_mount_points:
 588   {
 589     GST_ERROR ("client %p: no mount points configured", client);
 590     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
 591     return NULL;
 592   }
 593 no_factory:
 594   {
 595     GST_ERROR ("client %p: no factory for uri %s", client, path);
 596     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
 597     return NULL;
 598   }
 599 no_factory_access:
 600   {
 601     GST_ERROR ("client %p: not authorized to see factory uri %s", client, path);
 602     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
 603     return NULL;
 604   }
 605 not_authorized:
 606   {
 607     GST_ERROR ("client %p: not authorized for factory uri %s", client, path);
 608     handle_unauthorized_request (client, priv->auth, state);
 609     return NULL;
 610   }
 611 no_media:
 612   {
 613     GST_ERROR ("client %p: can't create media", client);
 614     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
 615     g_object_unref (factory);
 616     state->factory = NULL;
 617     return NULL;
 618   }
 619 no_thread:
 620   {
 621     GST_ERROR ("client %p: can't create thread", client);
 622     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
 623     g_object_unref (media);
 624     state->media = NULL;
 625     g_object_unref (factory);
 626     state->factory = NULL;
 627     return NULL;
 628   }
 629 no_prepare:
 630   {
 631     GST_ERROR ("client %p: can't prepare media", client);
 632     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
 633     g_object_unref (media);
 634     state->media = NULL;
 635     g_object_unref (factory);
 636     state->factory = NULL;
 637     return NULL;
 638   }
 639 }
 640
 641 static gboolean
 642 do_send_data (GstBuffer * buffer, guint8 channel, GstRTSPClient * client)
 643 {
 644   GstRTSPClientPrivate *priv = client->priv;
 645   GstRTSPMessage message = { 0 };
 646   GstMapInfo map_info;
 647   guint8 *data;
 648   guint usize;
 649
 650   gst_rtsp_message_init_data (&message, channel);
 651
 652   /* FIXME, need some sort of iovec RTSPMessage here */
 653   if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ))
 654     return FALSE;
 655
 656   gst_rtsp_message_take_body (&message, map_info.data, map_info.size);
 657
 658   g_mutex_lock (&priv->send_lock);
 659   if (priv->send_func)
 660     priv->send_func (client, &message, FALSE, priv->send_data);
 661   g_mutex_unlock (&priv->send_lock);
 662
 663   gst_rtsp_message_steal_body (&message, &data, &usize);
 664   gst_buffer_unmap (buffer, &map_info);
 665
 666   gst_rtsp_message_unset (&message);
 667
 668   return TRUE;
 669 }
 670
 671 static void
 672 link_transport (GstRTSPClient * client, GstRTSPSession * session,
 673     GstRTSPStreamTransport * trans)
 674 {
 675   GstRTSPClientPrivate *priv = client->priv;
 676
 677   GST_DEBUG ("client %p: linking transport %p", client, trans);
 678
 679   gst_rtsp_stream_transport_set_callbacks (trans,
 680       (GstRTSPSendFunc) do_send_data,
 681       (GstRTSPSendFunc) do_send_data, client, NULL);
 682
 683   priv->transports = g_list_prepend (priv->transports, trans);
 684
 685   /* make sure our session can't expire */
 686   gst_rtsp_session_prevent_expire (session);
 687 }
 688
 689 static void
 690 unlink_transport (GstRTSPClient * client, GstRTSPSession * session,
 691     GstRTSPStreamTransport * trans)
 692 {
 693   GstRTSPClientPrivate *priv = client->priv;
 694
 695   GST_DEBUG ("client %p: unlinking transport %p", client, trans);
 696
 697   gst_rtsp_stream_transport_set_callbacks (trans, NULL, NULL, NULL, NULL);
 698
 699   priv->transports = g_list_remove (priv->transports, trans);
 700
 701   /* our session can now expire */
 702   gst_rtsp_session_allow_expire (session);
 703 }
 704
 705 static void
 706 unlink_session_transports (GstRTSPClient * client, GstRTSPSession * session,
 707     GstRTSPSessionMedia * sessmedia)
 708 {
 709   guint n_streams, i;
 710
 711   n_streams =
 712       gst_rtsp_media_n_streams (gst_rtsp_session_media_get_media (sessmedia));
 713   for (i = 0; i < n_streams; i++) {
 714     GstRTSPStreamTransport *trans;
 715     const GstRTSPTransport *tr;
 716
 717     /* get the transport, if there is no transport configured, skip this stream */
 718     trans = gst_rtsp_session_media_get_transport (sessmedia, i);
 719     if (trans == NULL)
 720       continue;
 721
 722     tr = gst_rtsp_stream_transport_get_transport (trans);
 723
 724     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
 725       /* for TCP, unlink the stream from the TCP connection of the client */
 726       unlink_transport (client, session, trans);
 727     }
 728   }
 729 }
 730
 731 static void
 732 close_connection (GstRTSPClient * client)
 733 {
 734   GstRTSPClientPrivate *priv = client->priv;
 735   const gchar *tunnelid;
 736
 737   GST_DEBUG ("client %p: closing connection", client);
 738
 739   if ((tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection))) {
 740     g_mutex_lock (&tunnels_lock);
 741     /* remove from tunnelids */
 742     g_hash_table_remove (tunnels, tunnelid);
 743     g_mutex_unlock (&tunnels_lock);
 744   }
 745
 746   gst_rtsp_connection_close (priv->connection);
 747 }
 748
 749 static gboolean
 750 handle_teardown_request (GstRTSPClient * client, GstRTSPClientState * state)
 751 {
 752   GstRTSPClientPrivate *priv = client->priv;
 753   GstRTSPSession *session;
 754   GstRTSPSessionMedia *sessmedia;
 755   GstRTSPStatusCode code;
 756   const gchar *path;
 757   gint matched;
 758
 759   if (!state->session)
 760     goto no_session;
 761
 762   session = state->session;
 763
 764   if (!state->uri)
 765     goto no_uri;
 766
 767   path = state->uri->abspath;
 768
 769   /* get a handle to the configuration of the media in the session */
 770   sessmedia = gst_rtsp_session_get_media (session, path, &matched);
 771   if (!sessmedia)
 772     goto not_found;
 773
 774   /* only aggregate control for now.. */
 775   if (path[matched] != '\0')
 776     goto no_aggregate;
 777
 778   state->sessmedia = sessmedia;
 779
 780   /* we emit the signal before closing the connection */
 781   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_TEARDOWN_REQUEST],
 782       0, state);
 783
 784   /* unlink the all TCP callbacks */
 785   unlink_session_transports (client, session, sessmedia);
 786
 787   /* remove the session from the watched sessions */
 788   client_unwatch_session (client, session);
 789
 790   gst_rtsp_session_media_set_state (sessmedia, GST_STATE_NULL);
 791
 792   /* unmanage the media in the session, returns false if all media session
 793    * are torn down. */
 794   if (!gst_rtsp_session_release_media (session, sessmedia)) {
 795     /* remove the session */
 796     gst_rtsp_session_pool_remove (priv->session_pool, session);
 797   }
 798   /* construct the response now */
 799   code = GST_RTSP_STS_OK;
 800   gst_rtsp_message_init_response (state->response, code,
 801       gst_rtsp_status_as_text (code), state->request);
 802
 803   send_message (client, session, state->response, TRUE);
 804
 805   return TRUE;
 806
 807   /* ERRORS */
 808 no_session:
 809   {
 810     GST_ERROR ("client %p: no session", client);
 811     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
 812     return FALSE;
 813   }
 814 no_uri:
 815   {
 816     GST_ERROR ("client %p: no uri supplied", client);
 817     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
 818     return FALSE;
 819   }
 820 not_found:
 821   {
 822     GST_ERROR ("client %p: no media for uri", client);
 823     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
 824     return FALSE;
 825   }
 826 no_aggregate:
 827   {
 828     GST_ERROR ("client %p: no aggregate path %s", client, path);
 829     send_generic_response (client,
 830         GST_RTSP_STS_ONLY_AGGREGATE_OPERATION_ALLOWED, state);
 831     return FALSE;
 832   }
 833 }
 834
 835 static GstRTSPResult
 836 default_params_set (GstRTSPClient * client, GstRTSPClientState * state)
 837 {
 838   GstRTSPResult res;
 839
 840   res = gst_rtsp_params_set (client, state);
 841
 842   return res;
 843 }
 844
 845 static GstRTSPResult
 846 default_params_get (GstRTSPClient * client, GstRTSPClientState * state)
 847 {
 848   GstRTSPResult res;
 849
 850   res = gst_rtsp_params_get (client, state);
 851
 852   return res;
 853 }
 854
 855 static gboolean
 856 handle_get_param_request (GstRTSPClient * client, GstRTSPClientState * state)
 857 {
 858   GstRTSPResult res;
 859   guint8 *data;
 860   guint size;
 861
 862   res = gst_rtsp_message_get_body (state->request, &data, &size);
 863   if (res != GST_RTSP_OK)
 864     goto bad_request;
 865
 866   if (size == 0) {
 867     /* no body, keep-alive request */
 868     send_generic_response (client, GST_RTSP_STS_OK, state);
 869   } else {
 870     /* there is a body, handle the params */
 871     res = GST_RTSP_CLIENT_GET_CLASS (client)->params_get (client, state);
 872     if (res != GST_RTSP_OK)
 873       goto bad_request;
 874
 875     send_message (client, state->session, state->response, FALSE);
 876   }
 877
 878   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_GET_PARAMETER_REQUEST],
 879       0, state);
 880
 881   return TRUE;
 882
 883   /* ERRORS */
 884 bad_request:
 885   {
 886     GST_ERROR ("client %p: bad request", client);
 887     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
 888     return FALSE;
 889   }
 890 }
 891
 892 static gboolean
 893 handle_set_param_request (GstRTSPClient * client, GstRTSPClientState * state)
 894 {
 895   GstRTSPResult res;
 896   guint8 *data;
 897   guint size;
 898
 899   res = gst_rtsp_message_get_body (state->request, &data, &size);
 900   if (res != GST_RTSP_OK)
 901     goto bad_request;
 902
 903   if (size == 0) {
 904     /* no body, keep-alive request */
 905     send_generic_response (client, GST_RTSP_STS_OK, state);
 906   } else {
 907     /* there is a body, handle the params */
 908     res = GST_RTSP_CLIENT_GET_CLASS (client)->params_set (client, state);
 909     if (res != GST_RTSP_OK)
 910       goto bad_request;
 911
 912     send_message (client, state->session, state->response, FALSE);
 913   }
 914
 915   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SET_PARAMETER_REQUEST],
 916       0, state);
 917
 918   return TRUE;
 919
 920   /* ERRORS */
 921 bad_request:
 922   {
 923     GST_ERROR ("client %p: bad request", client);
 924     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
 925     return FALSE;
 926   }
 927 }
 928
 929 static gboolean
 930 handle_pause_request (GstRTSPClient * client, GstRTSPClientState * state)
 931 {
 932   GstRTSPSession *session;
 933   GstRTSPSessionMedia *sessmedia;
 934   GstRTSPStatusCode code;
 935   GstRTSPState rtspstate;
 936   const gchar *path;
 937   gint matched;
 938
 939   if (!(session = state->session))
 940     goto no_session;
 941
 942   if (!state->uri)
 943     goto no_uri;
 944
 945   path = state->uri->abspath;
 946
 947   /* get a handle to the configuration of the media in the session */
 948   sessmedia = gst_rtsp_session_get_media (session, path, &matched);
 949   if (!sessmedia)
 950     goto not_found;
 951
 952   if (path[matched] != '\0')
 953     goto no_aggregate;
 954
 955   state->sessmedia = sessmedia;
 956
 957   rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
 958   /* the session state must be playing or recording */
 959   if (rtspstate != GST_RTSP_STATE_PLAYING &&
 960       rtspstate != GST_RTSP_STATE_RECORDING)
 961     goto invalid_state;
 962
 963   /* unlink the all TCP callbacks */
 964   unlink_session_transports (client, session, sessmedia);
 965
 966   /* then pause sending */
 967   gst_rtsp_session_media_set_state (sessmedia, GST_STATE_PAUSED);
 968
 969   /* construct the response now */
 970   code = GST_RTSP_STS_OK;
 971   gst_rtsp_message_init_response (state->response, code,
 972       gst_rtsp_status_as_text (code), state->request);
 973
 974   send_message (client, session, state->response, FALSE);
 975
 976   /* the state is now READY */
 977   gst_rtsp_session_media_set_rtsp_state (sessmedia, GST_RTSP_STATE_READY);
 978
 979   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_PAUSE_REQUEST],
 980       0, state);
 981
 982   return TRUE;
 983
 984   /* ERRORS */
 985 no_session:
 986   {
 987     GST_ERROR ("client %p: no seesion", client);
 988     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
 989     return FALSE;
 990   }
 991 no_uri:
 992   {
 993     GST_ERROR ("client %p: no uri supplied", client);
 994     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
 995     return FALSE;
 996   }
 997 not_found:
 998   {
 999     GST_ERROR ("client %p: no media for uri", client);
1000     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
1001     return FALSE;
1002   }
1003 no_aggregate:
1004   {
1005     GST_ERROR ("client %p: no aggregate path %s", client, path);
1006     send_generic_response (client,
1007         GST_RTSP_STS_ONLY_AGGREGATE_OPERATION_ALLOWED, state);
1008     return FALSE;
1009   }
1010 invalid_state:
1011   {
1012     GST_ERROR ("client %p: not PLAYING or RECORDING", client);
1013     send_generic_response (client, GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE,
1014         state);
1015     return FALSE;
1016   }
1017 }
1018
1019 static gboolean
1020 handle_play_request (GstRTSPClient * client, GstRTSPClientState * state)
1021 {
1022   GstRTSPSession *session;
1023   GstRTSPSessionMedia *sessmedia;
1024   GstRTSPMedia *media;
1025   GstRTSPStatusCode code;
1026   GString *rtpinfo;
1027   guint n_streams, i, infocount;
1028   gchar *str;
1029   GstRTSPTimeRange *range;
1030   GstRTSPResult res;
1031   GstRTSPState rtspstate;
1032   GstRTSPRangeUnit unit = GST_RTSP_RANGE_NPT;
1033   const gchar *path;
1034   gint matched;
1035
1036   if (!(session = state->session))
1037     goto no_session;
1038
1039   if (!state->uri)
1040     goto no_uri;
1041
1042   path = state->uri->abspath;
1043
1044   /* get a handle to the configuration of the media in the session */
1045   sessmedia = gst_rtsp_session_get_media (session, path, &matched);
1046   if (!sessmedia)
1047     goto not_found;
1048
1049   if (path[matched] != '\0')
1050     goto no_aggregate;
1051
1052   state->sessmedia = sessmedia;
1053   state->media = media = gst_rtsp_session_media_get_media (sessmedia);
1054
1055   /* the session state must be playing or ready */
1056   rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
1057   if (rtspstate != GST_RTSP_STATE_PLAYING && rtspstate != GST_RTSP_STATE_READY)
1058     goto invalid_state;
1059
1060   /* parse the range header if we have one */
1061   res =
1062       gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_RANGE, &str, 0);
1063   if (res == GST_RTSP_OK) {
1064     if (gst_rtsp_range_parse (str, &range) == GST_RTSP_OK) {
1065       /* we have a range, seek to the position */
1066       unit = range->unit;
1067       gst_rtsp_media_seek (media, range);
1068       gst_rtsp_range_free (range);
1069     }
1070   }
1071
1072   /* grab RTPInfo from the payloaders now */
1073   rtpinfo = g_string_new ("");
1074
1075   n_streams = gst_rtsp_media_n_streams (media);
1076   for (i = 0, infocount = 0; i < n_streams; i++) {
1077     GstRTSPStreamTransport *trans;
1078     GstRTSPStream *stream;
1079     const GstRTSPTransport *tr;
1080     gchar *uristr;
1081     guint rtptime, seq;
1082
1083     /* get the transport, if there is no transport configured, skip this stream */
1084     trans = gst_rtsp_session_media_get_transport (sessmedia, i);
1085     if (trans == NULL) {
1086       GST_INFO ("stream %d is not configured", i);
1087       continue;
1088     }
1089     tr = gst_rtsp_stream_transport_get_transport (trans);
1090
1091     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
1092       /* for TCP, link the stream to the TCP connection of the client */
1093       link_transport (client, session, trans);
1094     }
1095
1096     stream = gst_rtsp_stream_transport_get_stream (trans);
1097     if (gst_rtsp_stream_get_rtpinfo (stream, &rtptime, &seq)) {
1098       if (infocount > 0)
1099         g_string_append (rtpinfo, ", ");
1100
1101       uristr = gst_rtsp_url_get_request_uri (state->uri);
1102       g_string_append_printf (rtpinfo, "url=%s/stream=%d;seq=%u;rtptime=%u",
1103           uristr, i, seq, rtptime);
1104       g_free (uristr);
1105
1106       infocount++;
1107     } else {
1108       GST_WARNING ("RTP-Info cannot be determined for stream %d", i);
1109     }
1110   }
1111
1112   /* construct the response now */
1113   code = GST_RTSP_STS_OK;
1114   gst_rtsp_message_init_response (state->response, code,
1115       gst_rtsp_status_as_text (code), state->request);
1116
1117   /* add the RTP-Info header */
1118   if (infocount > 0) {
1119     str = g_string_free (rtpinfo, FALSE);
1120     gst_rtsp_message_take_header (state->response, GST_RTSP_HDR_RTP_INFO, str);
1121   } else {
1122     g_string_free (rtpinfo, TRUE);
1123   }
1124
1125   /* add the range */
1126   str = gst_rtsp_media_get_range_string (media, TRUE, unit);
1127   gst_rtsp_message_take_header (state->response, GST_RTSP_HDR_RANGE, str);
1128
1129   send_message (client, session, state->response, FALSE);
1130
1131   /* start playing after sending the request */
1132   gst_rtsp_session_media_set_state (sessmedia, GST_STATE_PLAYING);
1133
1134   gst_rtsp_session_media_set_rtsp_state (sessmedia, GST_RTSP_STATE_PLAYING);
1135
1136   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_PLAY_REQUEST],
1137       0, state);
1138
1139   return TRUE;
1140
1141   /* ERRORS */
1142 no_session:
1143   {
1144     GST_ERROR ("client %p: no session", client);
1145     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
1146     return FALSE;
1147   }
1148 no_uri:
1149   {
1150     GST_ERROR ("client %p: no uri supplied", client);
1151     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
1152     return FALSE;
1153   }
1154 not_found:
1155   {
1156     GST_ERROR ("client %p: media not found", client);
1157     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
1158     return FALSE;
1159   }
1160 no_aggregate:
1161   {
1162     GST_ERROR ("client %p: no aggregate path %s", client, path);
1163     send_generic_response (client,
1164         GST_RTSP_STS_ONLY_AGGREGATE_OPERATION_ALLOWED, state);
1165     return FALSE;
1166   }
1167 invalid_state:
1168   {
1169     GST_ERROR ("client %p: not PLAYING or READY", client);
1170     send_generic_response (client, GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE,
1171         state);
1172     return FALSE;
1173   }
1174 }
1175
1176 static void
1177 do_keepalive (GstRTSPSession * session)
1178 {
1179   GST_INFO ("keep session %p alive", session);
1180   gst_rtsp_session_touch (session);
1181 }
1182
1183 /* parse @transport and return a valid transport in @tr. only transports
1184  * from @supported are returned. Returns FALSE if no valid transport
1185  * was found. */
1186 static gboolean
1187 parse_transport (const char *transport, GstRTSPLowerTrans supported,
1188     GstRTSPTransport * tr)
1189 {
1190   gint i;
1191   gboolean res;
1192   gchar **transports;
1193
1194   res = FALSE;
1195   gst_rtsp_transport_init (tr);
1196
1197   GST_DEBUG ("parsing transports %s", transport);
1198
1199   transports = g_strsplit (transport, ",", 0);
1200
1201   /* loop through the transports, try to parse */
1202   for (i = 0; transports[i]; i++) {
1203     res = gst_rtsp_transport_parse (transports[i], tr);
1204     if (res != GST_RTSP_OK) {
1205       /* no valid transport, search some more */
1206       GST_WARNING ("could not parse transport %s", transports[i]);
1207       goto next;
1208     }
1209
1210     /* we have a transport, see if it's RTP/AVP */
1211     if (tr->trans != GST_RTSP_TRANS_RTP || tr->profile != GST_RTSP_PROFILE_AVP) {
1212       GST_WARNING ("invalid transport %s", transports[i]);
1213       goto next;
1214     }
1215
1216     if (!(tr->lower_transport & supported)) {
1217       GST_WARNING ("unsupported transport %s", transports[i]);
1218       goto next;
1219     }
1220
1221     /* we have a valid transport */
1222     GST_INFO ("found valid transport %s", transports[i]);
1223     res = TRUE;
1224     break;
1225
1226   next:
1227     gst_rtsp_transport_init (tr);
1228   }
1229   g_strfreev (transports);
1230
1231   return res;
1232 }
1233
1234 static gboolean
1235 handle_blocksize (GstRTSPMedia * media, GstRTSPStream * stream,
1236     GstRTSPMessage * request)
1237 {
1238   gchar *blocksize_str;
1239   gboolean ret = TRUE;
1240
1241   if (gst_rtsp_message_get_header (request, GST_RTSP_HDR_BLOCKSIZE,
1242           &blocksize_str, 0) == GST_RTSP_OK) {
1243     guint64 blocksize;
1244     gchar *end;
1245
1246     blocksize = g_ascii_strtoull (blocksize_str, &end, 10);
1247     if (end == blocksize_str) {
1248       GST_ERROR ("failed to parse blocksize");
1249       ret = FALSE;
1250     } else {
1251       /* we don't want to change the mtu when this media
1252        * can be shared because it impacts other clients */
1253       if (gst_rtsp_media_is_shared (media))
1254         return TRUE;
1255
1256       if (blocksize > G_MAXUINT)
1257         blocksize = G_MAXUINT;
1258       gst_rtsp_stream_set_mtu (stream, blocksize);
1259     }
1260   }
1261   return ret;
1262 }
1263
1264 static gboolean
1265 default_configure_client_transport (GstRTSPClient * client,
1266     GstRTSPClientState * state, GstRTSPTransport * ct)
1267 {
1268   GstRTSPClientPrivate *priv = client->priv;
1269
1270   /* we have a valid transport now, set the destination of the client. */
1271   if (ct->lower_transport == GST_RTSP_LOWER_TRANS_UDP_MCAST) {
1272     if (ct->destination && priv->use_client_settings) {
1273       GstRTSPAddress *addr;
1274
1275       addr = gst_rtsp_stream_reserve_address (state->stream, ct->destination,
1276           ct->port.min, ct->port.max - ct->port.min + 1, ct->ttl);
1277
1278       if (addr == NULL)
1279         goto no_address;
1280
1281       gst_rtsp_address_free (addr);
1282     } else {
1283       GstRTSPAddress *addr;
1284       GSocketFamily family;
1285
1286       family = priv->is_ipv6 ? G_SOCKET_FAMILY_IPV6 : G_SOCKET_FAMILY_IPV4;
1287
1288       addr = gst_rtsp_stream_get_multicast_address (state->stream, family);
1289       if (addr == NULL)
1290         goto no_address;
1291
1292       g_free (ct->destination);
1293       ct->destination = g_strdup (addr->address);
1294       ct->port.min = addr->port;
1295       ct->port.max = addr->port + addr->n_ports - 1;
1296       ct->ttl = addr->ttl;
1297
1298       gst_rtsp_address_free (addr);
1299     }
1300   } else {
1301     GstRTSPUrl *url;
1302
1303     url = gst_rtsp_connection_get_url (priv->connection);
1304     g_free (ct->destination);
1305     ct->destination = g_strdup (url->host);
1306
1307     if (ct->lower_transport & GST_RTSP_LOWER_TRANS_TCP) {
1308       /* check if the client selected channels for TCP */
1309       if (ct->interleaved.min == -1 || ct->interleaved.max == -1) {
1310         gst_rtsp_session_media_alloc_channels (state->sessmedia,
1311             &ct->interleaved);
1312       }
1313     }
1314   }
1315   return TRUE;
1316
1317   /* ERRORS */
1318 no_address:
1319   {
1320     GST_ERROR_OBJECT (client, "failed to acquire address for stream");
1321     return FALSE;
1322   }
1323 }
1324
1325 static GstRTSPTransport *
1326 make_server_transport (GstRTSPClient * client, GstRTSPClientState * state,
1327     GstRTSPTransport * ct)
1328 {
1329   GstRTSPTransport *st;
1330   GInetAddress *addr;
1331   GSocketFamily family;
1332
1333   /* prepare the server transport */
1334   gst_rtsp_transport_new (&st);
1335
1336   st->trans = ct->trans;
1337   st->profile = ct->profile;
1338   st->lower_transport = ct->lower_transport;
1339
1340   addr = g_inet_address_new_from_string (ct->destination);
1341
1342   if (!addr) {
1343     GST_ERROR ("failed to get inet addr from client destination");
1344     family = G_SOCKET_FAMILY_IPV4;
1345   } else {
1346     family = g_inet_address_get_family (addr);
1347     g_object_unref (addr);
1348     addr = NULL;
1349   }
1350
1351   switch (st->lower_transport) {
1352     case GST_RTSP_LOWER_TRANS_UDP:
1353       st->client_port = ct->client_port;
1354       gst_rtsp_stream_get_server_port (state->stream, &st->server_port, family);
1355       break;
1356     case GST_RTSP_LOWER_TRANS_UDP_MCAST:
1357       st->port = ct->port;
1358       st->destination = g_strdup (ct->destination);
1359       st->ttl = ct->ttl;
1360       break;
1361     case GST_RTSP_LOWER_TRANS_TCP:
1362       st->interleaved = ct->interleaved;
1363     default:
1364       break;
1365   }
1366
1367   gst_rtsp_stream_get_ssrc (state->stream, &st->ssrc);
1368
1369   return st;
1370 }
1371
1372 static gboolean
1373 handle_setup_request (GstRTSPClient * client, GstRTSPClientState * state)
1374 {
1375   GstRTSPClientPrivate *priv = client->priv;
1376   GstRTSPResult res;
1377   GstRTSPUrl *uri;
1378   gchar *transport;
1379   GstRTSPTransport *ct, *st;
1380   GstRTSPLowerTrans supported;
1381   GstRTSPStatusCode code;
1382   GstRTSPSession *session;
1383   GstRTSPStreamTransport *trans;
1384   gchar *trans_str;
1385   GstRTSPSessionMedia *sessmedia;
1386   GstRTSPMedia *media;
1387   GstRTSPStream *stream;
1388   GstRTSPState rtspstate;
1389   GstRTSPClientClass *klass;
1390   gchar *path, *control;
1391   gint matched;
1392
1393   if (!state->uri)
1394     goto no_uri;
1395
1396   uri = state->uri;
1397   path = uri->abspath;
1398
1399   /* parse the transport */
1400   res =
1401       gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_TRANSPORT,
1402       &transport, 0);
1403   if (res != GST_RTSP_OK)
1404     goto no_transport;
1405
1406   /* we create the session after parsing stuff so that we don't make
1407    * a session for malformed requests */
1408   if (priv->session_pool == NULL)
1409     goto no_pool;
1410
1411   session = state->session;
1412
1413   if (session) {
1414     g_object_ref (session);
1415     /* get a handle to the configuration of the media in the session, this can
1416      * return NULL if this is a new url to manage in this session. */
1417     sessmedia = gst_rtsp_session_get_media (session, path, &matched);
1418   } else {
1419     /* we need a new media configuration in this session */
1420     sessmedia = NULL;
1421   }
1422
1423   /* we have no session media, find one and manage it */
1424   if (sessmedia == NULL) {
1425     /* get a handle to the configuration of the media in the session */
1426     media = find_media (client, state, &matched);
1427   } else {
1428     if ((media = gst_rtsp_session_media_get_media (sessmedia)))
1429       g_object_ref (media);
1430   }
1431   /* no media, not found then */
1432   if (media == NULL)
1433     goto media_not_found;
1434
1435   /* path is what matched. We can modify the parsed uri in place */
1436   path[matched] = '\0';
1437   /* control is remainder */
1438   control = &path[matched + 1];
1439
1440   /* find the stream now using the control part */
1441   stream = gst_rtsp_media_find_stream (media, control);
1442   if (stream == NULL)
1443     goto stream_not_found;
1444
1445   /* now we have a uri identifying a valid media and stream */
1446   state->stream = stream;
1447   state->media = media;
1448
1449   if (session == NULL) {
1450     /* create a session if this fails we probably reached our session limit or
1451      * something. */
1452     if (!(session = gst_rtsp_session_pool_create (priv->session_pool)))
1453       goto service_unavailable;
1454
1455     /* make sure this client is closed when the session is closed */
1456     client_watch_session (client, session);
1457
1458     /* signal new session */
1459     g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_NEW_SESSION], 0,
1460         session);
1461
1462     state->session = session;
1463   }
1464
1465   if (sessmedia == NULL) {
1466     /* manage the media in our session now, if not done already  */
1467     sessmedia = gst_rtsp_session_manage_media (session, path, media);
1468     /* if we stil have no media, error */
1469     if (sessmedia == NULL)
1470       goto sessmedia_unavailable;
1471   } else {
1472     g_object_unref (media);
1473   }
1474
1475   state->sessmedia = sessmedia;
1476
1477   /* set blocksize on this stream */
1478   if (!handle_blocksize (media, stream, state->request))
1479     goto invalid_blocksize;
1480
1481   gst_rtsp_transport_new (&ct);
1482
1483   /* our supported transports */
1484   supported = GST_RTSP_LOWER_TRANS_UDP |
1485       GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP;
1486
1487   /* parse and find a usable supported transport */
1488   if (!parse_transport (transport, supported, ct))
1489     goto unsupported_transports;
1490
1491   /* update the client transport */
1492   klass = GST_RTSP_CLIENT_GET_CLASS (client);
1493   if (!klass->configure_client_transport (client, state, ct))
1494     goto unsupported_client_transport;
1495
1496   /* set in the session media transport */
1497   trans = gst_rtsp_session_media_set_transport (sessmedia, stream, ct);
1498
1499   /* configure keepalive for this transport */
1500   gst_rtsp_stream_transport_set_keepalive (trans,
1501       (GstRTSPKeepAliveFunc) do_keepalive, session, NULL);
1502
1503   /* create and serialize the server transport */
1504   st = make_server_transport (client, state, ct);
1505   trans_str = gst_rtsp_transport_as_text (st);
1506   gst_rtsp_transport_free (st);
1507
1508   /* construct the response now */
1509   code = GST_RTSP_STS_OK;
1510   gst_rtsp_message_init_response (state->response, code,
1511       gst_rtsp_status_as_text (code), state->request);
1512
1513   gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_TRANSPORT,
1514       trans_str);
1515   g_free (trans_str);
1516
1517   send_message (client, session, state->response, FALSE);
1518
1519   /* update the state */
1520   rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
1521   switch (rtspstate) {
1522     case GST_RTSP_STATE_PLAYING:
1523     case GST_RTSP_STATE_RECORDING:
1524     case GST_RTSP_STATE_READY:
1525       /* no state change */
1526       break;
1527     default:
1528       gst_rtsp_session_media_set_rtsp_state (sessmedia, GST_RTSP_STATE_READY);
1529       break;
1530   }
1531   g_object_unref (session);
1532
1533   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SETUP_REQUEST],
1534       0, state);
1535
1536   return TRUE;
1537
1538   /* ERRORS */
1539 no_uri:
1540   {
1541     GST_ERROR ("client %p: no uri", client);
1542     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
1543     return FALSE;
1544   }
1545 no_transport:
1546   {
1547     GST_ERROR ("client %p: no transport", client);
1548     send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
1549     return FALSE;
1550   }
1551 no_pool:
1552   {
1553     GST_ERROR ("client %p: no session pool configured", client);
1554     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
1555     return FALSE;
1556   }
1557 media_not_found:
1558   {
1559     GST_ERROR ("client %p: media '%s' not found", client, path);
1560     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
1561     return FALSE;
1562   }
1563 stream_not_found:
1564   {
1565     GST_ERROR ("client %p: stream '%s' not found", client, control);
1566     send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
1567     g_object_unref (media);
1568     return FALSE;
1569   }
1570 service_unavailable:
1571   {
1572     GST_ERROR ("client %p: can't create session", client);
1573     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
1574     g_object_unref (media);
1575     return FALSE;
1576   }
1577 sessmedia_unavailable:
1578   {
1579     GST_ERROR ("client %p: can't create session media", client);
1580     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
1581     g_object_unref (media);
1582     g_object_unref (session);
1583     return FALSE;
1584   }
1585 invalid_blocksize:
1586   {
1587     GST_ERROR ("client %p: invalid blocksize", client);
1588     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
1589     g_object_unref (session);
1590     return FALSE;
1591   }
1592 unsupported_transports:
1593   {
1594     GST_ERROR ("client %p: unsupported transports", client);
1595     send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
1596     gst_rtsp_transport_free (ct);
1597     g_object_unref (session);
1598     return FALSE;
1599   }
1600 unsupported_client_transport:
1601   {
1602     GST_ERROR ("client %p: unsupported client transport", client);
1603     send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
1604     gst_rtsp_transport_free (ct);
1605     g_object_unref (session);
1606     return FALSE;
1607   }
1608 }
1609
1610 static GstSDPMessage *
1611 create_sdp (GstRTSPClient * client, GstRTSPMedia * media)
1612 {
1613   GstRTSPClientPrivate *priv = client->priv;
1614   GstSDPMessage *sdp;
1615   GstSDPInfo info;
1616   const gchar *proto;
1617
1618   gst_sdp_message_new (&sdp);
1619
1620   /* some standard things first */
1621   gst_sdp_message_set_version (sdp, "0");
1622
1623   if (priv->is_ipv6)
1624     proto = "IP6";
1625   else
1626     proto = "IP4";
1627
1628   gst_sdp_message_set_origin (sdp, "-", "1188340656180883", "1", "IN", proto,
1629       priv->server_ip);
1630
1631   gst_sdp_message_set_session_name (sdp, "Session streamed with GStreamer");
1632   gst_sdp_message_set_information (sdp, "rtsp-server");
1633   gst_sdp_message_add_time (sdp, "0", "0", NULL);
1634   gst_sdp_message_add_attribute (sdp, "tool", "GStreamer");
1635   gst_sdp_message_add_attribute (sdp, "type", "broadcast");
1636   gst_sdp_message_add_attribute (sdp, "control", "*");
1637
1638   info.is_ipv6 = priv->is_ipv6;
1639   info.server_ip = priv->server_ip;
1640
1641   /* create an SDP for the media object */
1642   if (!gst_rtsp_sdp_from_media (sdp, &info, media))
1643     goto no_sdp;
1644
1645   return sdp;
1646
1647   /* ERRORS */
1648 no_sdp:
1649   {
1650     GST_ERROR ("client %p: could not create SDP", client);
1651     gst_sdp_message_free (sdp);
1652     return NULL;
1653   }
1654 }
1655
1656 /* for the describe we must generate an SDP */
1657 static gboolean
1658 handle_describe_request (GstRTSPClient * client, GstRTSPClientState * state)
1659 {
1660   GstRTSPResult res;
1661   GstSDPMessage *sdp;
1662   guint i, str_len;
1663   gchar *str, *content_base;
1664   GstRTSPMedia *media;
1665   GstRTSPClientClass *klass;
1666
1667   klass = GST_RTSP_CLIENT_GET_CLASS (client);
1668
1669   if (!state->uri)
1670     goto no_uri;
1671
1672   /* check what kind of format is accepted, we don't really do anything with it
1673    * and always return SDP for now. */
1674   for (i = 0; i++;) {
1675     gchar *accept;
1676
1677     res =
1678         gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_ACCEPT,
1679         &accept, i);
1680     if (res == GST_RTSP_ENOTIMPL)
1681       break;
1682
1683     if (g_ascii_strcasecmp (accept, "application/sdp") == 0)
1684       break;
1685   }
1686
1687   /* find the media object for the uri */
1688   if (!(media = find_media (client, state, NULL)))
1689     goto no_media;
1690
1691   /* create an SDP for the media object on this client */
1692   if (!(sdp = klass->create_sdp (client, media)))
1693     goto no_sdp;
1694
1695   g_object_unref (media);
1696
1697   gst_rtsp_message_init_response (state->response, GST_RTSP_STS_OK,
1698       gst_rtsp_status_as_text (GST_RTSP_STS_OK), state->request);
1699
1700   gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_CONTENT_TYPE,
1701       "application/sdp");
1702
1703   /* content base for some clients that might screw up creating the setup uri */
1704   str = gst_rtsp_url_get_request_uri (state->uri);
1705   str_len = strlen (str);
1706
1707   /* check for trailing '/' and append one */
1708   if (str[str_len - 1] != '/') {
1709     content_base = g_malloc (str_len + 2);
1710     memcpy (content_base, str, str_len);
1711     content_base[str_len] = '/';
1712     content_base[str_len + 1] = '\0';
1713     g_free (str);
1714   } else {
1715     content_base = str;
1716   }
1717
1718   GST_INFO ("adding content-base: %s", content_base);
1719
1720   gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_CONTENT_BASE,
1721       content_base);
1722   g_free (content_base);
1723
1724   /* add SDP to the response body */
1725   str = gst_sdp_message_as_text (sdp);
1726   gst_rtsp_message_take_body (state->response, (guint8 *) str, strlen (str));
1727   gst_sdp_message_free (sdp);
1728
1729   send_message (client, state->session, state->response, FALSE);
1730
1731   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_DESCRIBE_REQUEST],
1732       0, state);
1733
1734   return TRUE;
1735
1736   /* ERRORS */
1737 no_uri:
1738   {
1739     GST_ERROR ("client %p: no uri", client);
1740     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
1741     return FALSE;
1742   }
1743 no_media:
1744   {
1745     GST_ERROR ("client %p: no media", client);
1746     /* error reply is already sent */
1747     return FALSE;
1748   }
1749 no_sdp:
1750   {
1751     GST_ERROR ("client %p: can't create SDP", client);
1752     send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
1753     g_object_unref (media);
1754     return FALSE;
1755   }
1756 }
1757
1758 static gboolean
1759 handle_options_request (GstRTSPClient * client, GstRTSPClientState * state)
1760 {
1761   GstRTSPMethod options;
1762   gchar *str;
1763
1764   options = GST_RTSP_DESCRIBE |
1765       GST_RTSP_OPTIONS |
1766       GST_RTSP_PAUSE |
1767       GST_RTSP_PLAY |
1768       GST_RTSP_SETUP |
1769       GST_RTSP_GET_PARAMETER | GST_RTSP_SET_PARAMETER | GST_RTSP_TEARDOWN;
1770
1771   str = gst_rtsp_options_as_text (options);
1772
1773   gst_rtsp_message_init_response (state->response, GST_RTSP_STS_OK,
1774       gst_rtsp_status_as_text (GST_RTSP_STS_OK), state->request);
1775
1776   gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_PUBLIC, str);
1777   g_free (str);
1778
1779   send_message (client, state->session, state->response, FALSE);
1780
1781   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST],
1782       0, state);
1783
1784   return TRUE;
1785 }
1786
1787 /* remove duplicate and trailing '/' */
1788 static void
1789 sanitize_uri (GstRTSPUrl * uri)
1790 {
1791   gint i, len;
1792   gchar *s, *d;
1793   gboolean have_slash, prev_slash;
1794
1795   s = d = uri->abspath;
1796   len = strlen (uri->abspath);
1797
1798   prev_slash = FALSE;
1799
1800   for (i = 0; i < len; i++) {
1801     have_slash = s[i] == '/';
1802     *d = s[i];
1803     if (!have_slash || !prev_slash)
1804       d++;
1805     prev_slash = have_slash;
1806   }
1807   len = d - uri->abspath;
1808   /* don't remove the first slash if that's the only thing left */
1809   if (len > 1 && *(d - 1) == '/')
1810     d--;
1811   *d = '\0';
1812 }
1813
1814 static void
1815 client_session_finalized (GstRTSPClient * client, GstRTSPSession * session)
1816 {
1817   GstRTSPClientPrivate *priv = client->priv;
1818
1819   GST_INFO ("client %p: session %p finished", client, session);
1820
1821   /* unlink all media managed in this session */
1822   client_unlink_session (client, session);
1823
1824   /* remove the session */
1825   if (!(priv->sessions = g_list_remove (priv->sessions, session))) {
1826     GST_INFO ("client %p: all sessions finalized, close the connection",
1827         client);
1828     close_connection (client);
1829   }
1830 }
1831
1832 static GPrivate state_key;
1833
1834 /**
1835  * gst_rtsp_client_state_get_current:
1836  *
1837  * Get the current #GstRTSPClientState. This object is retrieved from the
1838  * current thread that is handling the request for a client.
1839  *
1840  * Returns: a #GstRTSPClientState
1841  */
1842 GstRTSPClientState *
1843 gst_rtsp_client_state_get_current (void)
1844 {
1845   return g_private_get (&state_key);
1846 }
1847
1848 static void
1849 handle_request (GstRTSPClient * client, GstRTSPMessage * request)
1850 {
1851   GstRTSPClientPrivate *priv = client->priv;
1852   GstRTSPMethod method;
1853   const gchar *uristr;
1854   GstRTSPUrl *uri = NULL;
1855   GstRTSPVersion version;
1856   GstRTSPResult res;
1857   GstRTSPSession *session = NULL;
1858   GstRTSPClientState state = { NULL };
1859   GstRTSPMessage response = { 0 };
1860   gchar *sessid;
1861
1862   state.conn = priv->connection;
1863   state.client = client;
1864   state.request = request;
1865   state.response = &response;
1866   state.auth = priv->auth;
1867   g_private_set (&state_key, &state);
1868
1869   if (gst_debug_category_get_threshold (rtsp_client_debug) >= GST_LEVEL_LOG) {
1870     gst_rtsp_message_dump (request);
1871   }
1872
1873   GST_INFO ("client %p: received a request", client);
1874
1875   gst_rtsp_message_parse_request (request, &method, &uristr, &version);
1876
1877   /* we can only handle 1.0 requests */
1878   if (version != GST_RTSP_VERSION_1_0)
1879     goto not_supported;
1880
1881   state.method = method;
1882
1883   /* we always try to parse the url first */
1884   if (strcmp (uristr, "*") == 0) {
1885     /* special case where we have * as uri, keep uri = NULL */
1886   } else if (gst_rtsp_url_parse (uristr, &uri) != GST_RTSP_OK)
1887     goto bad_request;
1888
1889   /* get the session if there is any */
1890   res = gst_rtsp_message_get_header (request, GST_RTSP_HDR_SESSION, &sessid, 0);
1891   if (res == GST_RTSP_OK) {
1892     if (priv->session_pool == NULL)
1893       goto no_pool;
1894
1895     /* we had a session in the request, find it again */
1896     if (!(session = gst_rtsp_session_pool_find (priv->session_pool, sessid)))
1897       goto session_not_found;
1898
1899     /* we add the session to the client list of watched sessions. When a session
1900      * disappears because it times out, we will be notified. If all sessions are
1901      * gone, we will close the connection */
1902     client_watch_session (client, session);
1903   }
1904
1905   /* sanitize the uri */
1906   if (uri)
1907     sanitize_uri (uri);
1908   state.uri = uri;
1909   state.session = session;
1910
1911   if (!gst_rtsp_auth_check (GST_RTSP_AUTH_CHECK_URL))
1912     goto not_authorized;
1913
1914   /* now see what is asked and dispatch to a dedicated handler */
1915   switch (method) {
1916     case GST_RTSP_OPTIONS:
1917       handle_options_request (client, &state);
1918       break;
1919     case GST_RTSP_DESCRIBE:
1920       handle_describe_request (client, &state);
1921       break;
1922     case GST_RTSP_SETUP:
1923       handle_setup_request (client, &state);
1924       break;
1925     case GST_RTSP_PLAY:
1926       handle_play_request (client, &state);
1927       break;
1928     case GST_RTSP_PAUSE:
1929       handle_pause_request (client, &state);
1930       break;
1931     case GST_RTSP_TEARDOWN:
1932       handle_teardown_request (client, &state);
1933       break;
1934     case GST_RTSP_SET_PARAMETER:
1935       handle_set_param_request (client, &state);
1936       break;
1937     case GST_RTSP_GET_PARAMETER:
1938       handle_get_param_request (client, &state);
1939       break;
1940     case GST_RTSP_ANNOUNCE:
1941     case GST_RTSP_RECORD:
1942     case GST_RTSP_REDIRECT:
1943       goto not_implemented;
1944     case GST_RTSP_INVALID:
1945     default:
1946       goto bad_request;
1947   }
1948
1949 done:
1950   g_private_set (&state_key, NULL);
1951   if (session)
1952     g_object_unref (session);
1953   if (uri)
1954     gst_rtsp_url_free (uri);
1955   return;
1956
1957   /* ERRORS */
1958 not_supported:
1959   {
1960     GST_ERROR ("client %p: version %d not supported", client, version);
1961     send_generic_response (client, GST_RTSP_STS_RTSP_VERSION_NOT_SUPPORTED,
1962         &state);
1963     goto done;
1964   }
1965 bad_request:
1966   {
1967     GST_ERROR ("client %p: bad request", client);
1968     send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, &state);
1969     goto done;
1970   }
1971 no_pool:
1972   {
1973     GST_ERROR ("client %p: no pool configured", client);
1974     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, &state);
1975     goto done;
1976   }
1977 session_not_found:
1978   {
1979     GST_ERROR ("client %p: session not found", client);
1980     send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, &state);
1981     goto done;
1982   }
1983 not_authorized:
1984   {
1985     GST_ERROR ("client %p: not allowed", client);
1986     handle_unauthorized_request (client, priv->auth, &state);
1987     goto done;
1988   }
1989 not_implemented:
1990   {
1991     GST_ERROR ("client %p: method %d not implemented", client, method);
1992     send_generic_response (client, GST_RTSP_STS_NOT_IMPLEMENTED, &state);
1993     goto done;
1994   }
1995 }
1996
1997 static void
1998 handle_data (GstRTSPClient * client, GstRTSPMessage * message)
1999 {
2000   GstRTSPClientPrivate *priv = client->priv;
2001   GstRTSPResult res;
2002   guint8 channel;
2003   GList *walk;
2004   guint8 *data;
2005   guint size;
2006   GstBuffer *buffer;
2007   gboolean handled;
2008
2009   /* find the stream for this message */
2010   res = gst_rtsp_message_parse_data (message, &channel);
2011   if (res != GST_RTSP_OK)
2012     return;
2013
2014   gst_rtsp_message_steal_body (message, &data, &size);
2015
2016   buffer = gst_buffer_new_wrapped (data, size);
2017
2018   handled = FALSE;
2019   for (walk = priv->transports; walk; walk = g_list_next (walk)) {
2020     GstRTSPStreamTransport *trans;
2021     GstRTSPStream *stream;
2022     const GstRTSPTransport *tr;
2023
2024     trans = walk->data;
2025
2026     tr = gst_rtsp_stream_transport_get_transport (trans);
2027     stream = gst_rtsp_stream_transport_get_stream (trans);
2028
2029     /* check for TCP transport */
2030     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
2031       /* dispatch to the stream based on the channel number */
2032       if (tr->interleaved.min == channel) {
2033         gst_rtsp_stream_recv_rtp (stream, buffer);
2034         handled = TRUE;
2035         break;
2036       } else if (tr->interleaved.max == channel) {
2037         gst_rtsp_stream_recv_rtcp (stream, buffer);
2038         handled = TRUE;
2039         break;
2040       }
2041     }
2042   }
2043   if (!handled)
2044     gst_buffer_unref (buffer);
2045 }
2046
2047 /**
2048  * gst_rtsp_client_set_session_pool:
2049  * @client: a #GstRTSPClient
2050  * @pool: a #GstRTSPSessionPool
2051  *
2052  * Set @pool as the sessionpool for @client which it will use to find
2053  * or allocate sessions. the sessionpool is usually inherited from the server
2054  * that created the client but can be overridden later.
2055  */
2056 void
2057 gst_rtsp_client_set_session_pool (GstRTSPClient * client,
2058     GstRTSPSessionPool * pool)
2059 {
2060   GstRTSPSessionPool *old;
2061   GstRTSPClientPrivate *priv;
2062
2063   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2064
2065   priv = client->priv;
2066
2067   if (pool)
2068     g_object_ref (pool);
2069
2070   g_mutex_lock (&priv->lock);
2071   old = priv->session_pool;
2072   priv->session_pool = pool;
2073   g_mutex_unlock (&priv->lock);
2074
2075   if (old)
2076     g_object_unref (old);
2077 }
2078
2079 /**
2080  * gst_rtsp_client_get_session_pool:
2081  * @client: a #GstRTSPClient
2082  *
2083  * Get the #GstRTSPSessionPool object that @client uses to manage its sessions.
2084  *
2085  * Returns: (transfer full): a #GstRTSPSessionPool, unref after usage.
2086  */
2087 GstRTSPSessionPool *
2088 gst_rtsp_client_get_session_pool (GstRTSPClient * client)
2089 {
2090   GstRTSPClientPrivate *priv;
2091   GstRTSPSessionPool *result;
2092
2093   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2094
2095   priv = client->priv;
2096
2097   g_mutex_lock (&priv->lock);
2098   if ((result = priv->session_pool))
2099     g_object_ref (result);
2100   g_mutex_unlock (&priv->lock);
2101
2102   return result;
2103 }
2104
2105 /**
2106  * gst_rtsp_client_set_mount_points:
2107  * @client: a #GstRTSPClient
2108  * @mounts: a #GstRTSPMountPoints
2109  *
2110  * Set @mounts as the mount points for @client which it will use to map urls
2111  * to media streams. These mount points are usually inherited from the server that
2112  * created the client but can be overriden later.
2113  */
2114 void
2115 gst_rtsp_client_set_mount_points (GstRTSPClient * client,
2116     GstRTSPMountPoints * mounts)
2117 {
2118   GstRTSPClientPrivate *priv;
2119   GstRTSPMountPoints *old;
2120
2121   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2122
2123   priv = client->priv;
2124
2125   if (mounts)
2126     g_object_ref (mounts);
2127
2128   g_mutex_lock (&priv->lock);
2129   old = priv->mount_points;
2130   priv->mount_points = mounts;
2131   g_mutex_unlock (&priv->lock);
2132
2133   if (old)
2134     g_object_unref (old);
2135 }
2136
2137 /**
2138  * gst_rtsp_client_get_mount_points:
2139  * @client: a #GstRTSPClient
2140  *
2141  * Get the #GstRTSPMountPoints object that @client uses to manage its sessions.
2142  *
2143  * Returns: (transfer full): a #GstRTSPMountPoints, unref after usage.
2144  */
2145 GstRTSPMountPoints *
2146 gst_rtsp_client_get_mount_points (GstRTSPClient * client)
2147 {
2148   GstRTSPClientPrivate *priv;
2149   GstRTSPMountPoints *result;
2150
2151   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2152
2153   priv = client->priv;
2154
2155   g_mutex_lock (&priv->lock);
2156   if ((result = priv->mount_points))
2157     g_object_ref (result);
2158   g_mutex_unlock (&priv->lock);
2159
2160   return result;
2161 }
2162
2163 /**
2164  * gst_rtsp_client_set_use_client_settings:
2165  * @client: a #GstRTSPClient
2166  * @use_client_settings: whether to use client settings for multicast
2167  *
2168  * Use client transport settings (destination and ttl) for multicast.
2169  * When @use_client_settings is %FALSE, the server settings will be
2170  * used.
2171  */
2172 void
2173 gst_rtsp_client_set_use_client_settings (GstRTSPClient * client,
2174     gboolean use_client_settings)
2175 {
2176   GstRTSPClientPrivate *priv;
2177
2178   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2179
2180   priv = client->priv;
2181
2182   g_mutex_lock (&priv->lock);
2183   priv->use_client_settings = use_client_settings;
2184   g_mutex_unlock (&priv->lock);
2185 }
2186
2187 /**
2188  * gst_rtsp_client_get_use_client_settings:
2189  * @client: a #GstRTSPClient
2190  *
2191  * Check if client transport settings (destination and ttl) for multicast
2192  * will be used.
2193  */
2194 gboolean
2195 gst_rtsp_client_get_use_client_settings (GstRTSPClient * client)
2196 {
2197   GstRTSPClientPrivate *priv;
2198   gboolean res;
2199
2200   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), FALSE);
2201
2202   priv = client->priv;
2203
2204   g_mutex_lock (&priv->lock);
2205   res = priv->use_client_settings;
2206   g_mutex_unlock (&priv->lock);
2207
2208   return res;
2209 }
2210
2211 /**
2212  * gst_rtsp_client_set_auth:
2213  * @client: a #GstRTSPClient
2214  * @auth: a #GstRTSPAuth
2215  *
2216  * configure @auth to be used as the authentication manager of @client.
2217  */
2218 void
2219 gst_rtsp_client_set_auth (GstRTSPClient * client, GstRTSPAuth * auth)
2220 {
2221   GstRTSPClientPrivate *priv;
2222   GstRTSPAuth *old;
2223
2224   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2225
2226   priv = client->priv;
2227
2228   if (auth)
2229     g_object_ref (auth);
2230
2231   g_mutex_lock (&priv->lock);
2232   old = priv->auth;
2233   priv->auth = auth;
2234   g_mutex_unlock (&priv->lock);
2235
2236   if (old)
2237     g_object_unref (old);
2238 }
2239
2240
2241 /**
2242  * gst_rtsp_client_get_auth:
2243  * @client: a #GstRTSPClient
2244  *
2245  * Get the #GstRTSPAuth used as the authentication manager of @client.
2246  *
2247  * Returns: (transfer full): the #GstRTSPAuth of @client. g_object_unref() after
2248  * usage.
2249  */
2250 GstRTSPAuth *
2251 gst_rtsp_client_get_auth (GstRTSPClient * client)
2252 {
2253   GstRTSPClientPrivate *priv;
2254   GstRTSPAuth *result;
2255
2256   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2257
2258   priv = client->priv;
2259
2260   g_mutex_lock (&priv->lock);
2261   if ((result = priv->auth))
2262     g_object_ref (result);
2263   g_mutex_unlock (&priv->lock);
2264
2265   return result;
2266 }
2267
2268 /**
2269  * gst_rtsp_client_set_thread_pool:
2270  * @client: a #GstRTSPClient
2271  * @pool: a #GstRTSPThreadPool
2272  *
2273  * configure @pool to be used as the thread pool of @client.
2274  */
2275 void
2276 gst_rtsp_client_set_thread_pool (GstRTSPClient * client,
2277     GstRTSPThreadPool * pool)
2278 {
2279   GstRTSPClientPrivate *priv;
2280   GstRTSPThreadPool *old;
2281
2282   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2283
2284   priv = client->priv;
2285
2286   if (pool)
2287     g_object_ref (pool);
2288
2289   g_mutex_lock (&priv->lock);
2290   old = priv->thread_pool;
2291   priv->thread_pool = pool;
2292   g_mutex_unlock (&priv->lock);
2293
2294   if (old)
2295     g_object_unref (old);
2296 }
2297
2298 /**
2299  * gst_rtsp_client_get_thread_pool:
2300  * @client: a #GstRTSPClient
2301  *
2302  * Get the #GstRTSPThreadPool used as the thread pool of @client.
2303  *
2304  * Returns: (transfer full): the #GstRTSPThreadPool of @client. g_object_unref() after
2305  * usage.
2306  */
2307 GstRTSPThreadPool *
2308 gst_rtsp_client_get_thread_pool (GstRTSPClient * client)
2309 {
2310   GstRTSPClientPrivate *priv;
2311   GstRTSPThreadPool *result;
2312
2313   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2314
2315   priv = client->priv;
2316
2317   g_mutex_lock (&priv->lock);
2318   if ((result = priv->thread_pool))
2319     g_object_ref (result);
2320   g_mutex_unlock (&priv->lock);
2321
2322   return result;
2323 }
2324
2325 /**
2326  * gst_rtsp_client_set_connection:
2327  * @client: a #GstRTSPClient
2328  * @conn: (transfer full): a #GstRTSPConnection
2329  *
2330  * Set the #GstRTSPConnection of @client. This function takes ownership of
2331  * @conn.
2332  *
2333  * Returns: %TRUE on success.
2334  */
2335 gboolean
2336 gst_rtsp_client_set_connection (GstRTSPClient * client,
2337     GstRTSPConnection * conn)
2338 {
2339   GstRTSPClientPrivate *priv;
2340   GSocket *read_socket;
2341   GSocketAddress *address;
2342   GstRTSPUrl *url;
2343   GError *error = NULL;
2344
2345   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), FALSE);
2346   g_return_val_if_fail (conn != NULL, FALSE);
2347
2348   priv = client->priv;
2349
2350   read_socket = gst_rtsp_connection_get_read_socket (conn);
2351
2352   if (!(address = g_socket_get_local_address (read_socket, &error)))
2353     goto no_address;
2354
2355   g_free (priv->server_ip);
2356   /* keep the original ip that the client connected to */
2357   if (G_IS_INET_SOCKET_ADDRESS (address)) {
2358     GInetAddress *iaddr;
2359
2360     iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address));
2361
2362     /* socket might be ipv6 but adress still ipv4 */
2363     priv->is_ipv6 = g_inet_address_get_family (iaddr) == G_SOCKET_FAMILY_IPV6;
2364     priv->server_ip = g_inet_address_to_string (iaddr);
2365     g_object_unref (address);
2366   } else {
2367     priv->is_ipv6 = g_socket_get_family (read_socket) == G_SOCKET_FAMILY_IPV6;
2368     priv->server_ip = g_strdup ("unknown");
2369   }
2370
2371   GST_INFO ("client %p connected to server ip %s, ipv6 = %d", client,
2372       priv->server_ip, priv->is_ipv6);
2373
2374   url = gst_rtsp_connection_get_url (conn);
2375   GST_INFO ("added new client %p ip %s:%d", client, url->host, url->port);
2376
2377   priv->connection = conn;
2378
2379   return TRUE;
2380
2381   /* ERRORS */
2382 no_address:
2383   {
2384     GST_ERROR ("could not get local address %s", error->message);
2385     g_error_free (error);
2386     return FALSE;
2387   }
2388 }
2389
2390 /**
2391  * gst_rtsp_client_get_connection:
2392  * @client: a #GstRTSPClient
2393  *
2394  * Get the #GstRTSPConnection of @client.
2395  *
2396  * Returns: (transfer none): the #GstRTSPConnection of @client.
2397  * The connection object returned remains valid until the client is freed.
2398  */
2399 GstRTSPConnection *
2400 gst_rtsp_client_get_connection (GstRTSPClient * client)
2401 {
2402   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2403
2404   return client->priv->connection;
2405 }
2406
2407 /**
2408  * gst_rtsp_client_set_send_func:
2409  * @client: a #GstRTSPClient
2410  * @func: a #GstRTSPClientSendFunc
2411  * @user_data: user data passed to @func
2412  * @notify: called when @user_data is no longer in use
2413  *
2414  * Set @func as the callback that will be called when a new message needs to be
2415  * sent to the client. @user_data is passed to @func and @notify is called when
2416  * @user_data is no longer in use.
2417  *
2418  * By default, the client will send the messages on the #GstRTSPConnection that
2419  * was configured with gst_rtsp_client_attach() was called.
2420  */
2421 void
2422 gst_rtsp_client_set_send_func (GstRTSPClient * client,
2423     GstRTSPClientSendFunc func, gpointer user_data, GDestroyNotify notify)
2424 {
2425   GstRTSPClientPrivate *priv;
2426   GDestroyNotify old_notify;
2427   gpointer old_data;
2428
2429   g_return_if_fail (GST_IS_RTSP_CLIENT (client));
2430
2431   priv = client->priv;
2432
2433   g_mutex_lock (&priv->send_lock);
2434   priv->send_func = func;
2435   old_notify = priv->send_notify;
2436   old_data = priv->send_data;
2437   priv->send_notify = notify;
2438   priv->send_data = user_data;
2439   g_mutex_unlock (&priv->send_lock);
2440
2441   if (old_notify)
2442     old_notify (old_data);
2443 }
2444
2445 /**
2446  * gst_rtsp_client_handle_message:
2447  * @client: a #GstRTSPClient
2448  * @message: an #GstRTSPMessage
2449  *
2450  * Let the client handle @message.
2451  *
2452  * Returns: a #GstRTSPResult.
2453  */
2454 GstRTSPResult
2455 gst_rtsp_client_handle_message (GstRTSPClient * client,
2456     GstRTSPMessage * message)
2457 {
2458   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), GST_RTSP_EINVAL);
2459   g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
2460
2461   switch (message->type) {
2462     case GST_RTSP_MESSAGE_REQUEST:
2463       handle_request (client, message);
2464       break;
2465     case GST_RTSP_MESSAGE_RESPONSE:
2466       break;
2467     case GST_RTSP_MESSAGE_DATA:
2468       handle_data (client, message);
2469       break;
2470     default:
2471       break;
2472   }
2473   return GST_RTSP_OK;
2474 }
2475
2476 /**
2477  * gst_rtsp_client_send_request:
2478  * @client: a #GstRTSPClient
2479  * @session: a #GstRTSPSession to send the request to or %NULL
2480  * @request: The request #GstRTSPMessage to send
2481  *
2482  * Send a request message to the remote end. @request must be a
2483  * #GST_RTSP_MESSAGE_REQUEST.
2484  */
2485 GstRTSPResult
2486 gst_rtsp_client_send_request (GstRTSPClient * client, GstRTSPSession * session,
2487     GstRTSPMessage * request)
2488 {
2489   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), GST_RTSP_EINVAL);
2490   g_return_val_if_fail (request != NULL, GST_RTSP_EINVAL);
2491   g_return_val_if_fail (request->type == GST_RTSP_MESSAGE_REQUEST,
2492       GST_RTSP_EINVAL);
2493
2494   send_message (client, session, request, FALSE);
2495
2496   return GST_RTSP_OK;
2497 }
2498
2499 static GstRTSPResult
2500 do_send_message (GstRTSPClient * client, GstRTSPMessage * message,
2501     gboolean close, gpointer user_data)
2502 {
2503   GstRTSPClientPrivate *priv = client->priv;
2504
2505   /* send the response and store the seq number so we can wait until it's
2506    * written to the client to close the connection */
2507   return gst_rtsp_watch_send_message (priv->watch, message, close ?
2508       &priv->close_seq : NULL);
2509 }
2510
2511 static GstRTSPResult
2512 message_received (GstRTSPWatch * watch, GstRTSPMessage * message,
2513     gpointer user_data)
2514 {
2515   return gst_rtsp_client_handle_message (GST_RTSP_CLIENT (user_data), message);
2516 }
2517
2518 static GstRTSPResult
2519 message_sent (GstRTSPWatch * watch, guint cseq, gpointer user_data)
2520 {
2521   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2522   GstRTSPClientPrivate *priv = client->priv;
2523
2524   if (priv->close_seq && priv->close_seq == cseq) {
2525     priv->close_seq = 0;
2526     close_connection (client);
2527   }
2528
2529   return GST_RTSP_OK;
2530 }
2531
2532 static GstRTSPResult
2533 closed (GstRTSPWatch * watch, gpointer user_data)
2534 {
2535   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2536   GstRTSPClientPrivate *priv = client->priv;
2537   const gchar *tunnelid;
2538
2539   GST_INFO ("client %p: connection closed", client);
2540
2541   if ((tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection))) {
2542     g_mutex_lock (&tunnels_lock);
2543     /* remove from tunnelids */
2544     g_hash_table_remove (tunnels, tunnelid);
2545     g_mutex_unlock (&tunnels_lock);
2546   }
2547
2548   gst_rtsp_client_set_send_func (client, NULL, NULL, NULL);
2549
2550   return GST_RTSP_OK;
2551 }
2552
2553 static GstRTSPResult
2554 error (GstRTSPWatch * watch, GstRTSPResult result, gpointer user_data)
2555 {
2556   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2557   gchar *str;
2558
2559   str = gst_rtsp_strresult (result);
2560   GST_INFO ("client %p: received an error %s", client, str);
2561   g_free (str);
2562
2563   return GST_RTSP_OK;
2564 }
2565
2566 static GstRTSPResult
2567 error_full (GstRTSPWatch * watch, GstRTSPResult result,
2568     GstRTSPMessage * message, guint id, gpointer user_data)
2569 {
2570   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2571   gchar *str;
2572
2573   str = gst_rtsp_strresult (result);
2574   GST_INFO
2575       ("client %p: error when handling message %p with id %d: %s",
2576       client, message, id, str);
2577   g_free (str);
2578
2579   return GST_RTSP_OK;
2580 }
2581
2582 static gboolean
2583 remember_tunnel (GstRTSPClient * client)
2584 {
2585   GstRTSPClientPrivate *priv = client->priv;
2586   const gchar *tunnelid;
2587
2588   /* store client in the pending tunnels */
2589   tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection);
2590   if (tunnelid == NULL)
2591     goto no_tunnelid;
2592
2593   GST_INFO ("client %p: inserting tunnel session %s", client, tunnelid);
2594
2595   /* we can't have two clients connecting with the same tunnelid */
2596   g_mutex_lock (&tunnels_lock);
2597   if (g_hash_table_lookup (tunnels, tunnelid))
2598     goto tunnel_existed;
2599
2600   g_hash_table_insert (tunnels, g_strdup (tunnelid), g_object_ref (client));
2601   g_mutex_unlock (&tunnels_lock);
2602
2603   return TRUE;
2604
2605   /* ERRORS */
2606 no_tunnelid:
2607   {
2608     GST_ERROR ("client %p: no tunnelid provided", client);
2609     return FALSE;
2610   }
2611 tunnel_existed:
2612   {
2613     g_mutex_unlock (&tunnels_lock);
2614     GST_ERROR ("client %p: tunnel session %s already existed", client,
2615         tunnelid);
2616     return FALSE;
2617   }
2618 }
2619
2620 static GstRTSPStatusCode
2621 tunnel_start (GstRTSPWatch * watch, gpointer user_data)
2622 {
2623   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2624   GstRTSPClientPrivate *priv = client->priv;
2625
2626   GST_INFO ("client %p: tunnel start (connection %p)", client,
2627       priv->connection);
2628
2629   if (!remember_tunnel (client))
2630     goto tunnel_error;
2631
2632   return GST_RTSP_STS_OK;
2633
2634   /* ERRORS */
2635 tunnel_error:
2636   {
2637     GST_ERROR ("client %p: error starting tunnel", client);
2638     return GST_RTSP_STS_SERVICE_UNAVAILABLE;
2639   }
2640 }
2641
2642 static GstRTSPResult
2643 tunnel_lost (GstRTSPWatch * watch, gpointer user_data)
2644 {
2645   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2646   GstRTSPClientPrivate *priv = client->priv;
2647
2648   GST_WARNING ("client %p: tunnel lost (connection %p)", client,
2649       priv->connection);
2650
2651   /* ignore error, it'll only be a problem when the client does a POST again */
2652   remember_tunnel (client);
2653
2654   return GST_RTSP_OK;
2655 }
2656
2657 static GstRTSPResult
2658 tunnel_complete (GstRTSPWatch * watch, gpointer user_data)
2659 {
2660   const gchar *tunnelid;
2661   GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
2662   GstRTSPClientPrivate *priv = client->priv;
2663   GstRTSPClient *oclient;
2664   GstRTSPClientPrivate *opriv;
2665
2666   GST_INFO ("client %p: tunnel complete", client);
2667
2668   /* find previous tunnel */
2669   tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection);
2670   if (tunnelid == NULL)
2671     goto no_tunnelid;
2672
2673   g_mutex_lock (&tunnels_lock);
2674   if (!(oclient = g_hash_table_lookup (tunnels, tunnelid)))
2675     goto no_tunnel;
2676
2677   /* remove the old client from the table. ref before because removing it will
2678    * remove the ref to it. */
2679   g_object_ref (oclient);
2680   g_hash_table_remove (tunnels, tunnelid);
2681
2682   opriv = oclient->priv;
2683
2684   if (opriv->watch == NULL)
2685     goto tunnel_closed;
2686   g_mutex_unlock (&tunnels_lock);
2687
2688   GST_INFO ("client %p: found tunnel %p (old %p, new %p)", client, oclient,
2689       opriv->connection, priv->connection);
2690
2691   /* merge the tunnels into the first client */
2692   gst_rtsp_connection_do_tunnel (opriv->connection, priv->connection);
2693   gst_rtsp_watch_reset (opriv->watch);
2694   g_object_unref (oclient);
2695
2696   return GST_RTSP_OK;
2697
2698   /* ERRORS */
2699 no_tunnelid:
2700   {
2701     GST_ERROR ("client %p: no tunnelid provided", client);
2702     return GST_RTSP_ERROR;
2703   }
2704 no_tunnel:
2705   {
2706     g_mutex_unlock (&tunnels_lock);
2707     GST_ERROR ("client %p: tunnel session %s not found", client, tunnelid);
2708     return GST_RTSP_ERROR;
2709   }
2710 tunnel_closed:
2711   {
2712     g_mutex_unlock (&tunnels_lock);
2713     GST_ERROR ("client %p: tunnel session %s was closed", client, tunnelid);
2714     g_object_unref (oclient);
2715     return GST_RTSP_ERROR;
2716   }
2717 }
2718
2719 static GstRTSPWatchFuncs watch_funcs = {
2720   message_received,
2721   message_sent,
2722   closed,
2723   error,
2724   tunnel_start,
2725   tunnel_complete,
2726   error_full,
2727   tunnel_lost
2728 };
2729
2730 static void
2731 client_watch_notify (GstRTSPClient * client)
2732 {
2733   GstRTSPClientPrivate *priv = client->priv;
2734
2735   GST_INFO ("client %p: watch destroyed", client);
2736   priv->watch = NULL;
2737   g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_CLOSED], 0, NULL);
2738   g_object_unref (client);
2739 }
2740
2741 /**
2742  * gst_rtsp_client_attach:
2743  * @client: a #GstRTSPClient
2744  * @context: (allow-none): a #GMainContext
2745  *
2746  * Attaches @client to @context. When the mainloop for @context is run, the
2747  * client will be dispatched. When @context is NULL, the default context will be
2748  * used).
2749  *
2750  * This function should be called when the client properties and urls are fully
2751  * configured and the client is ready to start.
2752  *
2753  * Returns: the ID (greater than 0) for the source within the GMainContext.
2754  */
2755 guint
2756 gst_rtsp_client_attach (GstRTSPClient * client, GMainContext * context)
2757 {
2758   GstRTSPClientPrivate *priv;
2759   guint res;
2760
2761   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), 0);
2762   priv = client->priv;
2763   g_return_val_if_fail (priv->connection != NULL, 0);
2764   g_return_val_if_fail (priv->watch == NULL, 0);
2765
2766   /* create watch for the connection and attach */
2767   priv->watch = gst_rtsp_watch_new (priv->connection, &watch_funcs,
2768       g_object_ref (client), (GDestroyNotify) client_watch_notify);
2769   gst_rtsp_client_set_send_func (client, do_send_message, priv->watch,
2770       (GDestroyNotify) gst_rtsp_watch_unref);
2771
2772   /* FIXME make this configurable. We don't want to do this yet because it will
2773    * be superceeded by a cache object later */
2774   gst_rtsp_watch_set_send_backlog (priv->watch, 0, 100);
2775
2776   GST_INFO ("attaching to context %p", context);
2777   res = gst_rtsp_watch_attach (priv->watch, context);
2778
2779   return res;
2780 }
2781
2782 /**
2783  * gst_rtsp_client_session_filter:
2784  * @client: a #GstRTSPclient
2785  * @func: (scope call): a callback
2786  * @user_data: user data passed to @func
2787  *
2788  * Call @func for each session managed by @client. The result value of @func
2789  * determines what happens to the session. @func will be called with @client
2790  * locked so no further actions on @client can be performed from @func.
2791  *
2792  * If @func returns #GST_RTSP_FILTER_REMOVE, the session will be removed from
2793  * @client.
2794  *
2795  * If @func returns #GST_RTSP_FILTER_KEEP, the session will remain in @client.
2796  *
2797  * If @func returns #GST_RTSP_FILTER_REF, the session will remain in @client but
2798  * will also be added with an additional ref to the result #GList of this
2799  * function..
2800  *
2801  * Returns: (element-type GstRTSPSession) (transfer full): a #GList with all
2802  * sessions for which @func returned #GST_RTSP_FILTER_REF. After usage, each
2803  * element in the #GList should be unreffed before the list is freed.
2804  */
2805 GList *
2806 gst_rtsp_client_session_filter (GstRTSPClient * client,
2807     GstRTSPClientSessionFilterFunc func, gpointer user_data)
2808 {
2809   GstRTSPClientPrivate *priv;
2810   GList *result, *walk, *next;
2811
2812   g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
2813   g_return_val_if_fail (func != NULL, NULL);
2814
2815   priv = client->priv;
2816
2817   result = NULL;
2818
2819   g_mutex_lock (&priv->lock);
2820   for (walk = priv->sessions; walk; walk = next) {
2821     GstRTSPSession *sess = walk->data;
2822
2823     next = g_list_next (walk);
2824
2825     switch (func (client, sess, user_data)) {
2826       case GST_RTSP_FILTER_REMOVE:
2827         /* stop watching the session and pretent it went away */
2828         client_cleanup_session (client, sess);
2829         break;
2830       case GST_RTSP_FILTER_REF:
2831         result = g_list_prepend (result, g_object_ref (sess));
2832         break;
2833       case GST_RTSP_FILTER_KEEP:
2834       default:
2835         break;
2836     }
2837   }
2838   g_mutex_unlock (&priv->lock);
2839
2840   return result;
2841 }