X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Frtsp-server%2Frtsp-client.c;h=799b42e5121938c005fde453ef9dbe5eeb24c28e;hb=65042a9551a9cf4586d6e3fa49e6a10f25873553;hp=76450a20f1367c528ddf8382b351f6d9c6a506c2;hpb=b5a1719e89576098809aea59f1a8ddd3cc0a09e8;p=platform%2Fupstream%2Fgstreamer.git

diff --git a/gst/rtsp-server/rtsp-client.c b/gst/rtsp-server/rtsp-client.c
index 76450a2..799b42e 100644
--- a/gst/rtsp-server/rtsp-client.c
+++ b/gst/rtsp-server/rtsp-client.c
@@ -13,42 +13,63 @@
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
  */
 
-#include <sys/ioctl.h>
+#include <stdio.h>
+#include <string.h>
 
 #include "rtsp-client.h"
 #include "rtsp-sdp.h"
 #include "rtsp-params.h"
 
-/* temporary multicast address until it's configurable somewhere */
-#define MCAST_ADDRESS "224.2.0.1"
-
-static GMutex *tunnels_lock;
+static GMutex tunnels_lock;
 static GHashTable *tunnels;
 
+#define DEFAULT_SESSION_POOL            NULL
+#define DEFAULT_MEDIA_MAPPING           NULL
+#define DEFAULT_USE_CLIENT_SETTINGS     FALSE
+
 enum
 {
   PROP_0,
   PROP_SESSION_POOL,
   PROP_MEDIA_MAPPING,
+  PROP_USE_CLIENT_SETTINGS,
   PROP_LAST
 };
 
+enum
+{
+  SIGNAL_CLOSED,
+  SIGNAL_NEW_SESSION,
+  SIGNAL_OPTIONS_REQUEST,
+  SIGNAL_DESCRIBE_REQUEST,
+  SIGNAL_SETUP_REQUEST,
+  SIGNAL_PLAY_REQUEST,
+  SIGNAL_PAUSE_REQUEST,
+  SIGNAL_TEARDOWN_REQUEST,
+  SIGNAL_SET_PARAMETER_REQUEST,
+  SIGNAL_GET_PARAMETER_REQUEST,
+  SIGNAL_LAST
+};
+
 GST_DEBUG_CATEGORY_STATIC (rtsp_client_debug);
 #define GST_CAT_DEFAULT rtsp_client_debug
 
+static guint gst_rtsp_client_signals[SIGNAL_LAST] = { 0 };
+
 static void gst_rtsp_client_get_property (GObject * object, guint propid,
     GValue * value, GParamSpec * pspec);
 static void gst_rtsp_client_set_property (GObject * object, guint propid,
     const GValue * value, GParamSpec * pspec);
 static void gst_rtsp_client_finalize (GObject * obj);
 
+static GstSDPMessage *create_sdp (GstRTSPClient * client, GstRTSPMedia * media);
 static void client_session_finalized (GstRTSPClient * client,
     GstRTSPSession * session);
-static void unlink_session_streams (GstRTSPClient * client,
+static void unlink_session_transports (GstRTSPClient * client,
     GstRTSPSession * session, GstRTSPSessionMedia * media);
 
 G_DEFINE_TYPE (GstRTSPClient, gst_rtsp_client, G_TYPE_OBJECT);
@@ -64,6 +85,8 @@ gst_rtsp_client_class_init (GstRTSPClientClass * klass)
   gobject_class->set_property = gst_rtsp_client_set_property;
   gobject_class->finalize = gst_rtsp_client_finalize;
 
+  klass->create_sdp = create_sdp;
+
   g_object_class_install_property (gobject_class, PROP_SESSION_POOL,
       g_param_spec_object ("session-pool", "Session Pool",
           "The session pool to use for client session",
@@ -76,9 +99,73 @@ gst_rtsp_client_class_init (GstRTSPClientClass * klass)
           GST_TYPE_RTSP_MEDIA_MAPPING,
           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
+  g_object_class_install_property (gobject_class, PROP_USE_CLIENT_SETTINGS,
+      g_param_spec_boolean ("use-client-settings", "Use Client Settings",
+          "Use client settings for ttl and destination in multicast",
+          DEFAULT_USE_CLIENT_SETTINGS,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  gst_rtsp_client_signals[SIGNAL_CLOSED] =
+      g_signal_new ("closed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+      G_STRUCT_OFFSET (GstRTSPClientClass, closed), NULL, NULL,
+      g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
+
+  gst_rtsp_client_signals[SIGNAL_NEW_SESSION] =
+      g_signal_new ("new-session", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+      G_STRUCT_OFFSET (GstRTSPClientClass, new_session), NULL, NULL,
+      g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_RTSP_SESSION);
+
+  gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST] =
+      g_signal_new ("options-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, options_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_DESCRIBE_REQUEST] =
+      g_signal_new ("describe-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, describe_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_SETUP_REQUEST] =
+      g_signal_new ("setup-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, setup_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_PLAY_REQUEST] =
+      g_signal_new ("play-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, play_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_PAUSE_REQUEST] =
+      g_signal_new ("pause-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, pause_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_TEARDOWN_REQUEST] =
+      g_signal_new ("teardown-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, teardown_request),
+      NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
+      G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_SET_PARAMETER_REQUEST] =
+      g_signal_new ("set-parameter-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
+          set_parameter_request), NULL, NULL, g_cclosure_marshal_VOID__POINTER,
+      G_TYPE_NONE, 1, G_TYPE_POINTER);
+
+  gst_rtsp_client_signals[SIGNAL_GET_PARAMETER_REQUEST] =
+      g_signal_new ("get-parameter-request", G_TYPE_FROM_CLASS (klass),
+      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
+          get_parameter_request), NULL, NULL, g_cclosure_marshal_VOID__POINTER,
+      G_TYPE_NONE, 1, G_TYPE_POINTER);
+
   tunnels =
       g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
-  tunnels_lock = g_mutex_new ();
+  g_mutex_init (&tunnels_lock);
 
   GST_DEBUG_CATEGORY_INIT (rtsp_client_debug, "rtspclient", 0, "GstRTSPClient");
 }
@@ -86,17 +173,21 @@ gst_rtsp_client_class_init (GstRTSPClientClass * klass)
 static void
 gst_rtsp_client_init (GstRTSPClient * client)
 {
+  client->use_client_settings = DEFAULT_USE_CLIENT_SETTINGS;
+  client->teardown_response_seq = 0;
 }
 
 static void
 client_unlink_session (GstRTSPClient * client, GstRTSPSession * session)
 {
-  GList *medias;
-
   /* unlink all media managed in this session */
-  for (medias = session->medias; medias; medias = g_list_next (medias)) {
-    unlink_session_streams (client, session,
-        (GstRTSPSessionMedia *) medias->data);
+  while (session->medias) {
+    GstRTSPSessionMedia *media = session->medias->data;
+
+    gst_rtsp_session_media_set_state (media, GST_STATE_NULL);
+    unlink_session_transports (client, session, media);
+    /* unmanage the media in the session. this will modify session->medias */
+    gst_rtsp_session_release_media (session, media);
   }
 }
 
@@ -124,6 +215,9 @@ gst_rtsp_client_finalize (GObject * obj)
 
   GST_INFO ("finalize client %p", client);
 
+  if (client->watch)
+    g_source_destroy ((GSource *) client->watch);
+
   client_cleanup_sessions (client);
 
   gst_rtsp_connection_free (client->connection);
@@ -131,6 +225,8 @@ gst_rtsp_client_finalize (GObject * obj)
     g_object_unref (client->session_pool);
   if (client->media_mapping)
     g_object_unref (client->media_mapping);
+  if (client->auth)
+    g_object_unref (client->auth);
 
   if (client->uri)
     gst_rtsp_url_free (client->uri);
@@ -155,6 +251,10 @@ gst_rtsp_client_get_property (GObject * object, guint propid,
     case PROP_MEDIA_MAPPING:
       g_value_take_object (value, gst_rtsp_client_get_media_mapping (client));
       break;
+    case PROP_USE_CLIENT_SETTINGS:
+      g_value_set_boolean (value,
+          gst_rtsp_client_get_use_client_settings (client));
+      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
   }
@@ -173,6 +273,10 @@ gst_rtsp_client_set_property (GObject * object, guint propid,
     case PROP_MEDIA_MAPPING:
       gst_rtsp_client_set_media_mapping (client, g_value_get_object (value));
       break;
+    case PROP_USE_CLIENT_SETTINGS:
+      gst_rtsp_client_set_use_client_settings (client,
+          g_value_get_boolean (value));
+      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
   }
@@ -197,7 +301,7 @@ gst_rtsp_client_new (void)
 
 static void
 send_response (GstRTSPClient * client, GstRTSPSession * session,
-    GstRTSPMessage * response)
+    GstRTSPMessage * response, guint * id)
 {
   gst_rtsp_message_add_header (response, GST_RTSP_HDR_SERVER,
       "GStreamer RTSP server");
@@ -207,38 +311,44 @@ send_response (GstRTSPClient * client, GstRTSPSession * session,
 
   /* add the new session header for new session ids */
   if (session) {
-    gchar *str;
-
-    if (session->timeout != 60)
-      str =
-          g_strdup_printf ("%s; timeout=%d", session->sessionid,
-          session->timeout);
-    else
-      str = g_strdup (session->sessionid);
-
-    gst_rtsp_message_take_header (response, GST_RTSP_HDR_SESSION, str);
+    gst_rtsp_message_take_header (response, GST_RTSP_HDR_SESSION,
+        gst_rtsp_session_get_header (session));
   }
 
   if (gst_debug_category_get_threshold (rtsp_client_debug) >= GST_LEVEL_LOG) {
     gst_rtsp_message_dump (response);
   }
 
-  gst_rtsp_watch_send_message (client->watch, response, NULL);
+  gst_rtsp_watch_send_message (client->watch, response, id);
   gst_rtsp_message_unset (response);
 }
 
 static void
 send_generic_response (GstRTSPClient * client, GstRTSPStatusCode code,
-    GstRTSPMessage * request)
+    GstRTSPClientState * state)
 {
-  GstRTSPMessage response = { 0 };
+  gst_rtsp_message_init_response (state->response, code,
+      gst_rtsp_status_as_text (code), state->request);
+
+  send_response (client, NULL, state->response, NULL);
+}
 
-  gst_rtsp_message_init_response (&response, code,
-      gst_rtsp_status_as_text (code), request);
+static void
+handle_unauthorized_request (GstRTSPClient * client, GstRTSPAuth * auth,
+    GstRTSPClientState * state)
+{
+  gst_rtsp_message_init_response (state->response, GST_RTSP_STS_UNAUTHORIZED,
+      gst_rtsp_status_as_text (GST_RTSP_STS_UNAUTHORIZED), state->request);
 
-  send_response (client, NULL, &response);
+  if (auth) {
+    /* and let the authentication manager setup the auth tokens */
+    gst_rtsp_auth_setup_auth (auth, client, 0, state);
+  }
+
+  send_response (client, state->session, state->response, NULL);
 }
 
+
 static gboolean
 compare_uri (const GstRTSPUrl * uri1, const GstRTSPUrl * uri2)
 {
@@ -255,12 +365,13 @@ compare_uri (const GstRTSPUrl * uri1, const GstRTSPUrl * uri2)
  * but is cached for when the same client (without breaking the connection) is
  * doing a setup for the exact same url. */
 static GstRTSPMedia *
-find_media (GstRTSPClient * client, GstRTSPUrl * uri, GstRTSPMessage * request)
+find_media (GstRTSPClient * client, GstRTSPClientState * state)
 {
   GstRTSPMediaFactory *factory;
   GstRTSPMedia *media;
+  GstRTSPAuth *auth;
 
-  if (!compare_uri (client->uri, uri)) {
+  if (!compare_uri (client->uri, state->uri)) {
     /* remove any previously cached values before we try to construct a new
      * media for uri */
     if (client->uri)
@@ -275,26 +386,43 @@ find_media (GstRTSPClient * client, GstRTSPUrl * uri, GstRTSPMessage * request)
 
     /* find the factory for the uri first */
     if (!(factory =
-            gst_rtsp_media_mapping_find_factory (client->media_mapping, uri)))
+            gst_rtsp_media_mapping_find_factory (client->media_mapping,
+                state->uri)))
       goto no_factory;
 
+    state->factory = factory;
+
+    /* check if we have access to the factory */
+    if ((auth = gst_rtsp_media_factory_get_auth (factory))) {
+      if (!gst_rtsp_auth_check (auth, client, 0, state))
+        goto not_allowed;
+
+      g_object_unref (auth);
+    }
+
     /* prepare the media and add it to the pipeline */
-    if (!(media = gst_rtsp_media_factory_construct (factory, uri)))
+    if (!(media = gst_rtsp_media_factory_construct (factory, state->uri)))
       goto no_media;
 
+    g_object_unref (factory);
+    factory = NULL;
+    state->factory = NULL;
+
     /* set ipv6 on the media before preparing */
     media->is_ipv6 = client->is_ipv6;
+    state->media = media;
 
     /* prepare the media */
     if (!(gst_rtsp_media_prepare (media)))
       goto no_prepare;
 
     /* now keep track of the uri and the media */
-    client->uri = gst_rtsp_url_copy (uri);
+    client->uri = gst_rtsp_url_copy (state->uri);
     client->media = media;
   } else {
     /* we have seen this uri before, used cached media */
     media = client->media;
+    state->media = media;
     GST_INFO ("reusing cached media %p", media);
   }
 
@@ -306,25 +434,31 @@ find_media (GstRTSPClient * client, GstRTSPUrl * uri, GstRTSPMessage * request)
   /* ERRORS */
 no_mapping:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
     return NULL;
   }
 no_factory:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
+    return NULL;
+  }
+not_allowed:
+  {
+    handle_unauthorized_request (client, auth, state);
+    g_object_unref (factory);
+    g_object_unref (auth);
     return NULL;
   }
 no_media:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
     g_object_unref (factory);
     return NULL;
   }
 no_prepare:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
     g_object_unref (media);
-    g_object_unref (factory);
     return NULL;
   }
 }
@@ -333,90 +467,79 @@ static gboolean
 do_send_data (GstBuffer * buffer, guint8 channel, GstRTSPClient * client)
 {
   GstRTSPMessage message = { 0 };
+  GstMapInfo map_info;
   guint8 *data;
-  guint size;
+  guint usize;
 
   gst_rtsp_message_init_data (&message, channel);
 
-  data = GST_BUFFER_DATA (buffer);
-  size = GST_BUFFER_SIZE (buffer);
-  gst_rtsp_message_take_body (&message, data, size);
+  /* FIXME, need some sort of iovec RTSPMessage here */
+  if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ))
+    return FALSE;
+
+  gst_rtsp_message_take_body (&message, map_info.data, map_info.size);
 
   /* FIXME, client->watch could have been finalized here, we need to keep an
    * extra refcount to the watch.  */
   gst_rtsp_watch_send_message (client->watch, &message, NULL);
 
-  gst_rtsp_message_steal_body (&message, &data, &size);
+  gst_rtsp_message_steal_body (&message, &data, &usize);
+  gst_buffer_unmap (buffer, &map_info);
+
   gst_rtsp_message_unset (&message);
 
   return TRUE;
 }
 
-static gboolean
-do_send_data_list (GstBufferList * blist, guint8 channel,
-    GstRTSPClient * client)
+static void
+link_transport (GstRTSPClient * client, GstRTSPSession * session,
+    GstRTSPStreamTransport * trans)
 {
-  GstBufferListIterator *it;
+  GST_DEBUG ("client %p: linking transport %p", client, trans);
+  gst_rtsp_stream_transport_set_callbacks (trans,
+      (GstRTSPSendFunc) do_send_data,
+      (GstRTSPSendFunc) do_send_data, client, NULL);
 
-  it = gst_buffer_list_iterate (blist);
-  while (gst_buffer_list_iterator_next_group (it)) {
-    GstBuffer *group = gst_buffer_list_iterator_merge_group (it);
-
-    if (group == NULL)
-      continue;
-
-    do_send_data (group, channel, client);
-  }
-  gst_buffer_list_iterator_free (it);
-
-  return TRUE;
-}
+  client->transports = g_list_prepend (client->transports, trans);
 
-static void
-link_stream (GstRTSPClient * client, GstRTSPSession * session,
-    GstRTSPSessionStream * stream)
-{
-  GST_DEBUG ("client %p: linking stream %p", client, stream);
-  gst_rtsp_session_stream_set_callbacks (stream, (GstRTSPSendFunc) do_send_data,
-      (GstRTSPSendFunc) do_send_data, (GstRTSPSendListFunc) do_send_data_list,
-      (GstRTSPSendListFunc) do_send_data_list, client, NULL);
-  client->streams = g_list_prepend (client->streams, stream);
   /* make sure our session can't expire */
   gst_rtsp_session_prevent_expire (session);
 }
 
 static void
-unlink_stream (GstRTSPClient * client, GstRTSPSession * session,
-    GstRTSPSessionStream * stream)
+unlink_transport (GstRTSPClient * client, GstRTSPSession * session,
+    GstRTSPStreamTransport * trans)
 {
-  GST_DEBUG ("client %p: unlinking stream %p", client, stream);
-  gst_rtsp_session_stream_set_callbacks (stream, NULL, NULL, NULL, NULL, NULL,
-      NULL);
-  client->streams = g_list_remove (client->streams, stream);
+  GST_DEBUG ("client %p: unlinking transport %p", client, trans);
+  gst_rtsp_stream_transport_set_callbacks (trans, NULL, NULL, NULL, NULL);
+
+  client->transports = g_list_remove (client->transports, trans);
+
   /* our session can now expire */
   gst_rtsp_session_allow_expire (session);
 }
 
 static void
-unlink_session_streams (GstRTSPClient * client, GstRTSPSession * session,
+unlink_session_transports (GstRTSPClient * client, GstRTSPSession * session,
     GstRTSPSessionMedia * media)
 {
   guint n_streams, i;
 
   n_streams = gst_rtsp_media_n_streams (media->media);
   for (i = 0; i < n_streams; i++) {
-    GstRTSPSessionStream *sstream;
+    GstRTSPStreamTransport *trans;
     GstRTSPTransport *tr;
 
-    /* get the stream as configured in the session */
-    sstream = gst_rtsp_session_media_get_stream (media, i);
     /* get the transport, if there is no transport configured, skip this stream */
-    if (!(tr = sstream->trans.transport))
+    trans = gst_rtsp_session_media_get_transport (media, i);
+    if (trans == NULL)
       continue;
 
+    tr = trans->transport;
+
     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
       /* for TCP, unlink the stream from the TCP connection of the client */
-      unlink_stream (client, session, sstream);
+      unlink_transport (client, session, trans);
     }
   }
 }
@@ -429,38 +552,36 @@ close_connection (GstRTSPClient * client)
   GST_DEBUG ("client %p: closing connection", client);
 
   if ((tunnelid = gst_rtsp_connection_get_tunnelid (client->connection))) {
-    g_mutex_lock (tunnels_lock);
+    g_mutex_lock (&tunnels_lock);
     /* remove from tunnelids */
     g_hash_table_remove (tunnels, tunnelid);
-    g_mutex_unlock (tunnels_lock);
+    g_mutex_unlock (&tunnels_lock);
   }
 
   gst_rtsp_connection_close (client->connection);
-  if (client->watchid) {
-    g_source_destroy ((GSource *) client->watch);
-    client->watchid = 0;
-    client->watch = NULL;
-  }
 }
 
 static gboolean
-handle_teardown_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_teardown_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
+  GstRTSPSession *session;
   GstRTSPSessionMedia *media;
-  GstRTSPMessage response = { 0 };
   GstRTSPStatusCode code;
 
-  if (!session)
+  if (!state->session)
     goto no_session;
 
+  session = state->session;
+
   /* get a handle to the configuration of the media in the session */
-  media = gst_rtsp_session_get_media (session, uri);
+  media = gst_rtsp_session_get_media (session, state->uri);
   if (!media)
     goto not_found;
 
+  state->sessmedia = media;
+
   /* unlink the all TCP callbacks */
-  unlink_session_streams (client, session, media);
+  unlink_session_transports (client, session, media);
 
   /* remove the session from the watched sessions */
   g_object_weak_unref (G_OBJECT (session),
@@ -477,188 +598,200 @@ handle_teardown_request (GstRTSPClient * client, GstRTSPUrl * uri,
   }
   /* construct the response now */
   code = GST_RTSP_STS_OK;
-  gst_rtsp_message_init_response (&response, code,
-      gst_rtsp_status_as_text (code), request);
+  gst_rtsp_message_init_response (state->response, code,
+      gst_rtsp_status_as_text (code), state->request);
 
-  gst_rtsp_message_add_header (&response, GST_RTSP_HDR_CONNECTION, "close");
+  gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_CONNECTION,
+      "close");
 
-  send_response (client, session, &response);
+  /* send the response and store the seq number so we can wait until it's
+   * written to the client to close the connection */
+  send_response (client, session, state->response,
+      &client->teardown_response_seq);
 
-  close_connection (client);
+  /* we emit the signal before closing the connection */
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_TEARDOWN_REQUEST],
+      0, state);
 
   return TRUE;
 
   /* ERRORS */
 no_session:
   {
-    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
     return FALSE;
   }
 not_found:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
     return FALSE;
   }
 }
 
 static gboolean
-handle_get_param_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_get_param_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
   GstRTSPResult res;
   guint8 *data;
   guint size;
 
-  res = gst_rtsp_message_get_body (request, &data, &size);
+  res = gst_rtsp_message_get_body (state->request, &data, &size);
   if (res != GST_RTSP_OK)
     goto bad_request;
 
   if (size == 0) {
     /* no body, keep-alive request */
-    send_generic_response (client, GST_RTSP_STS_OK, request);
+    send_generic_response (client, GST_RTSP_STS_OK, state);
   } else {
-    /* there is a body */
-    GstRTSPMessage response = { 0 };
-
     /* there is a body, handle the params */
-    res = gst_rtsp_params_get (client, uri, session, request, &response);
+    res = gst_rtsp_params_get (client, state);
     if (res != GST_RTSP_OK)
       goto bad_request;
 
-    send_response (client, session, &response);
+    send_response (client, state->session, state->response, NULL);
   }
+
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_GET_PARAMETER_REQUEST],
+      0, state);
+
   return TRUE;
 
   /* ERRORS */
 bad_request:
   {
-    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, request);
+    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
     return FALSE;
   }
 }
 
 static gboolean
-handle_set_param_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_set_param_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
   GstRTSPResult res;
   guint8 *data;
   guint size;
 
-  res = gst_rtsp_message_get_body (request, &data, &size);
+  res = gst_rtsp_message_get_body (state->request, &data, &size);
   if (res != GST_RTSP_OK)
     goto bad_request;
 
   if (size == 0) {
     /* no body, keep-alive request */
-    send_generic_response (client, GST_RTSP_STS_OK, request);
+    send_generic_response (client, GST_RTSP_STS_OK, state);
   } else {
-    GstRTSPMessage response = { 0 };
-
     /* there is a body, handle the params */
-    res = gst_rtsp_params_set (client, uri, session, request, &response);
+    res = gst_rtsp_params_set (client, state);
     if (res != GST_RTSP_OK)
       goto bad_request;
 
-    send_response (client, session, &response);
+    send_response (client, state->session, state->response, NULL);
   }
+
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SET_PARAMETER_REQUEST],
+      0, state);
+
   return TRUE;
 
   /* ERRORS */
 bad_request:
   {
-    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, request);
+    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
     return FALSE;
   }
 }
 
 static gboolean
-handle_pause_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_pause_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
+  GstRTSPSession *session;
   GstRTSPSessionMedia *media;
-  GstRTSPMessage response = { 0 };
   GstRTSPStatusCode code;
 
-  if (!session)
+  if (!(session = state->session))
     goto no_session;
 
   /* get a handle to the configuration of the media in the session */
-  media = gst_rtsp_session_get_media (session, uri);
+  media = gst_rtsp_session_get_media (session, state->uri);
   if (!media)
     goto not_found;
 
+  state->sessmedia = media;
+
   /* the session state must be playing or recording */
   if (media->state != GST_RTSP_STATE_PLAYING &&
       media->state != GST_RTSP_STATE_RECORDING)
     goto invalid_state;
 
   /* unlink the all TCP callbacks */
-  unlink_session_streams (client, session, media);
+  unlink_session_transports (client, session, media);
 
   /* then pause sending */
   gst_rtsp_session_media_set_state (media, GST_STATE_PAUSED);
 
   /* construct the response now */
   code = GST_RTSP_STS_OK;
-  gst_rtsp_message_init_response (&response, code,
-      gst_rtsp_status_as_text (code), request);
+  gst_rtsp_message_init_response (state->response, code,
+      gst_rtsp_status_as_text (code), state->request);
 
-  send_response (client, session, &response);
+  send_response (client, session, state->response, NULL);
 
   /* the state is now READY */
   media->state = GST_RTSP_STATE_READY;
 
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_PAUSE_REQUEST],
+      0, state);
+
   return TRUE;
 
   /* ERRORS */
 no_session:
   {
-    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
     return FALSE;
   }
 not_found:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
     return FALSE;
   }
 invalid_state:
   {
     send_generic_response (client, GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE,
-        request);
+        state);
     return FALSE;
   }
 }
 
 static gboolean
-handle_play_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_play_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
+  GstRTSPSession *session;
   GstRTSPSessionMedia *media;
-  GstRTSPMessage response = { 0 };
   GstRTSPStatusCode code;
   GString *rtpinfo;
   guint n_streams, i, infocount;
-  guint timestamp, seqnum;
   gchar *str;
   GstRTSPTimeRange *range;
   GstRTSPResult res;
 
-  if (!session)
+  if (!(session = state->session))
     goto no_session;
 
   /* get a handle to the configuration of the media in the session */
-  media = gst_rtsp_session_get_media (session, uri);
+  media = gst_rtsp_session_get_media (session, state->uri);
   if (!media)
     goto not_found;
 
+  state->sessmedia = media;
+
   /* the session state must be playing or ready */
   if (media->state != GST_RTSP_STATE_PLAYING &&
       media->state != GST_RTSP_STATE_READY)
     goto invalid_state;
 
   /* parse the range header if we have one */
-  res = gst_rtsp_message_get_header (request, GST_RTSP_HDR_RANGE, &str, 0);
+  res =
+      gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_RANGE, &str, 0);
   if (res == GST_RTSP_OK) {
     if (gst_rtsp_range_parse (str, &range) == GST_RTSP_OK) {
       /* we have a range, seek to the position */
@@ -672,44 +805,31 @@ handle_play_request (GstRTSPClient * client, GstRTSPUrl * uri,
 
   n_streams = gst_rtsp_media_n_streams (media->media);
   for (i = 0, infocount = 0; i < n_streams; i++) {
-    GstRTSPSessionStream *sstream;
-    GstRTSPMediaStream *stream;
+    GstRTSPStreamTransport *trans;
     GstRTSPTransport *tr;
-    GObjectClass *payobjclass;
     gchar *uristr;
+    guint rtptime, seq;
 
-    /* get the stream as configured in the session */
-    sstream = gst_rtsp_session_media_get_stream (media, i);
     /* get the transport, if there is no transport configured, skip this stream */
-    if (!(tr = sstream->trans.transport)) {
+    trans = gst_rtsp_session_media_get_transport (media, i);
+    if (trans == NULL) {
       GST_INFO ("stream %d is not configured", i);
       continue;
     }
+    tr = trans->transport;
 
     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
       /* for TCP, link the stream to the TCP connection of the client */
-      link_stream (client, session, sstream);
+      link_transport (client, session, trans);
     }
 
-    stream = sstream->media_stream;
-
-    payobjclass = G_OBJECT_GET_CLASS (stream->payloader);
-
-    if (g_object_class_find_property (payobjclass, "seqnum") &&
-        g_object_class_find_property (payobjclass, "timestamp")) {
-      GObject *payobj;
-
-      payobj = G_OBJECT (stream->payloader);
-
-      /* only add RTP-Info for streams with seqnum and timestamp */
-      g_object_get (payobj, "seqnum", &seqnum, "timestamp", &timestamp, NULL);
-
+    if (gst_rtsp_stream_get_rtpinfo (trans->stream, &rtptime, &seq)) {
       if (infocount > 0)
         g_string_append (rtpinfo, ", ");
 
-      uristr = gst_rtsp_url_get_request_uri (uri);
+      uristr = gst_rtsp_url_get_request_uri (state->uri);
       g_string_append_printf (rtpinfo, "url=%s/stream=%d;seq=%u;rtptime=%u",
-          uristr, i, seqnum, timestamp);
+          uristr, i, seq, rtptime);
       g_free (uristr);
 
       infocount++;
@@ -720,45 +840,48 @@ handle_play_request (GstRTSPClient * client, GstRTSPUrl * uri,
 
   /* construct the response now */
   code = GST_RTSP_STS_OK;
-  gst_rtsp_message_init_response (&response, code,
-      gst_rtsp_status_as_text (code), request);
+  gst_rtsp_message_init_response (state->response, code,
+      gst_rtsp_status_as_text (code), state->request);
 
   /* add the RTP-Info header */
   if (infocount > 0) {
     str = g_string_free (rtpinfo, FALSE);
-    gst_rtsp_message_take_header (&response, GST_RTSP_HDR_RTP_INFO, str);
+    gst_rtsp_message_take_header (state->response, GST_RTSP_HDR_RTP_INFO, str);
   } else {
     g_string_free (rtpinfo, TRUE);
   }
 
   /* add the range */
   str = gst_rtsp_media_get_range_string (media->media, TRUE);
-  gst_rtsp_message_take_header (&response, GST_RTSP_HDR_RANGE, str);
+  gst_rtsp_message_take_header (state->response, GST_RTSP_HDR_RANGE, str);
 
-  send_response (client, session, &response);
+  send_response (client, session, state->response, NULL);
 
   /* start playing after sending the request */
   gst_rtsp_session_media_set_state (media, GST_STATE_PLAYING);
 
   media->state = GST_RTSP_STATE_PLAYING;
 
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_PLAY_REQUEST],
+      0, state);
+
   return TRUE;
 
   /* ERRORS */
 no_session:
   {
-    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, state);
     return FALSE;
   }
 not_found:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
     return FALSE;
   }
 invalid_state:
   {
     send_generic_response (client, GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE,
-        request);
+        state);
     return FALSE;
   }
 }
@@ -770,62 +893,27 @@ do_keepalive (GstRTSPSession * session)
   gst_rtsp_session_touch (session);
 }
 
+/* parse @transport and return a valid transport in @tr. only transports
+ * from @supported are returned. Returns FALSE if no valid transport
+ * was found. */
 static gboolean
-handle_setup_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+parse_transport (const char *transport, GstRTSPLowerTrans supported,
+    GstRTSPTransport * tr)
 {
-  GstRTSPResult res;
-  gchar *transport;
-  gchar **transports;
-  gboolean have_transport;
-  GstRTSPTransport *ct, *st;
   gint i;
-  GstRTSPLowerTrans supported;
-  GstRTSPMessage response = { 0 };
-  GstRTSPStatusCode code;
-  GstRTSPSessionStream *stream;
-  gchar *trans_str, *pos;
-  guint streamid;
-  GstRTSPSessionMedia *media;
-  GstRTSPUrl *url;
-
-  /* the uri contains the stream number we added in the SDP config, which is
-   * always /stream=%d so we need to strip that off 
-   * parse the stream we need to configure, look for the stream in the abspath
-   * first and then in the query. */
-  if (uri->abspath == NULL || !(pos = strstr (uri->abspath, "/stream="))) {
-    if (uri->query == NULL || !(pos = strstr (uri->query, "/stream=")))
-      goto bad_request;
-  }
+  gboolean res;
+  gchar **transports;
 
-  /* we can mofify the parse uri in place */
-  *pos = '\0';
+  res = FALSE;
+  gst_rtsp_transport_init (tr);
 
-  pos += strlen ("/stream=");
-  if (sscanf (pos, "%u", &streamid) != 1)
-    goto bad_request;
-
-  /* parse the transport */
-  res =
-      gst_rtsp_message_get_header (request, GST_RTSP_HDR_TRANSPORT, &transport,
-      0);
-  if (res != GST_RTSP_OK)
-    goto no_transport;
+  GST_DEBUG ("parsing transports %s", transport);
 
   transports = g_strsplit (transport, ",", 0);
-  gst_rtsp_transport_new (&ct);
-
-  /* init transports */
-  have_transport = FALSE;
-  gst_rtsp_transport_init (ct);
-
-  /* our supported transports */
-  supported = GST_RTSP_LOWER_TRANS_UDP |
-      GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP;
 
   /* loop through the transports, try to parse */
   for (i = 0; transports[i]; i++) {
-    res = gst_rtsp_transport_parse (transports[i], ct);
+    res = gst_rtsp_transport_parse (transports[i], tr);
     if (res != GST_RTSP_OK) {
       /* no valid transport, search some more */
       GST_WARNING ("could not parse transport %s", transports[i]);
@@ -833,157 +921,334 @@ handle_setup_request (GstRTSPClient * client, GstRTSPUrl * uri,
     }
 
     /* we have a transport, see if it's RTP/AVP */
-    if (ct->trans != GST_RTSP_TRANS_RTP || ct->profile != GST_RTSP_PROFILE_AVP) {
+    if (tr->trans != GST_RTSP_TRANS_RTP || tr->profile != GST_RTSP_PROFILE_AVP) {
       GST_WARNING ("invalid transport %s", transports[i]);
       goto next;
     }
 
-    if (!(ct->lower_transport & supported)) {
+    if (!(tr->lower_transport & supported)) {
       GST_WARNING ("unsupported transport %s", transports[i]);
       goto next;
     }
 
     /* we have a valid transport */
     GST_INFO ("found valid transport %s", transports[i]);
-    have_transport = TRUE;
+    res = TRUE;
     break;
 
   next:
-    gst_rtsp_transport_init (ct);
+    gst_rtsp_transport_init (tr);
   }
   g_strfreev (transports);
 
-  /* we have not found anything usable, error out */
-  if (!have_transport)
-    goto unsupported_transports;
+  return res;
+}
 
-  if (client->session_pool == NULL)
-    goto no_pool;
+static gboolean
+handle_blocksize (GstRTSPMedia * media, GstRTSPStream * stream,
+    GstRTSPMessage * request)
+{
+  gchar *blocksize_str;
+  gboolean ret = TRUE;
+
+  if (gst_rtsp_message_get_header (request, GST_RTSP_HDR_BLOCKSIZE,
+          &blocksize_str, 0) == GST_RTSP_OK) {
+    guint64 blocksize;
+    gchar *end;
+
+    blocksize = g_ascii_strtoull (blocksize_str, &end, 10);
+    if (end == blocksize_str) {
+      GST_ERROR ("failed to parse blocksize");
+      ret = FALSE;
+    } else {
+      /* we don't want to change the mtu when this media
+       * can be shared because it impacts other clients */
+      if (gst_rtsp_media_is_shared (media))
+        return TRUE;
+
+      if (blocksize > G_MAXUINT)
+        blocksize = G_MAXUINT;
+      gst_rtsp_stream_set_mtu (stream, blocksize);
+    }
+  }
+  return ret;
+}
 
+static gboolean
+configure_client_transport (GstRTSPClient * client, GstRTSPClientState * state,
+    GstRTSPTransport * ct)
+{
   /* we have a valid transport now, set the destination of the client. */
-  g_free (ct->destination);
   if (ct->lower_transport == GST_RTSP_LOWER_TRANS_UDP_MCAST) {
-    ct->destination = g_strdup (MCAST_ADDRESS);
+    if (ct->destination == NULL || !client->use_client_settings) {
+      GstRTSPAddress *addr;
+
+      addr = gst_rtsp_stream_get_address (state->stream);
+      if (addr == NULL)
+        goto no_address;
+
+      g_free (ct->destination);
+      ct->destination = g_strdup (addr->address);
+      ct->port.min = addr->port;
+      ct->port.max = addr->port + addr->n_ports - 1;
+      ct->ttl = addr->ttl;
+    }
   } else {
+    GstRTSPUrl *url;
+
     url = gst_rtsp_connection_get_url (client->connection);
+    g_free (ct->destination);
     ct->destination = g_strdup (url->host);
+
+    if (ct->lower_transport & GST_RTSP_LOWER_TRANS_TCP) {
+      /* check if the client selected channels for TCP */
+      if (ct->interleaved.min == -1 || ct->interleaved.max == -1) {
+        gst_rtsp_session_media_alloc_channels (state->sessmedia,
+            &ct->interleaved);
+      }
+    }
+  }
+  return TRUE;
+
+  /* ERRORS */
+no_address:
+  {
+    GST_ERROR_OBJECT (client, "failed to acquire address for stream");
+    return FALSE;
+  }
+}
+
+static GstRTSPTransport *
+make_server_transport (GstRTSPClient * client, GstRTSPClientState * state,
+    GstRTSPTransport * ct)
+{
+  GstRTSPTransport *st;
+
+  /* prepare the server transport */
+  gst_rtsp_transport_new (&st);
+
+  st->trans = ct->trans;
+  st->profile = ct->profile;
+  st->lower_transport = ct->lower_transport;
+
+  switch (st->lower_transport) {
+    case GST_RTSP_LOWER_TRANS_UDP:
+      st->client_port = ct->client_port;
+      st->server_port = state->stream->server_port;
+      break;
+    case GST_RTSP_LOWER_TRANS_UDP_MCAST:
+      st->port = ct->port;
+      st->destination = g_strdup (ct->destination);
+      st->ttl = ct->ttl;
+      break;
+    case GST_RTSP_LOWER_TRANS_TCP:
+      st->interleaved = ct->interleaved;
+    default:
+      break;
   }
 
+  if (state->stream->session)
+    g_object_get (state->stream->session, "internal-ssrc", &st->ssrc, NULL);
+
+  return st;
+}
+
+static gboolean
+handle_setup_request (GstRTSPClient * client, GstRTSPClientState * state)
+{
+  GstRTSPResult res;
+  GstRTSPUrl *uri;
+  gchar *transport;
+  GstRTSPTransport *ct, *st;
+  GstRTSPLowerTrans supported;
+  GstRTSPStatusCode code;
+  GstRTSPSession *session;
+  GstRTSPStreamTransport *trans;
+  gchar *trans_str, *pos;
+  guint streamid;
+  GstRTSPSessionMedia *sessmedia;
+  GstRTSPMedia *media;
+  GstRTSPStream *stream;
+
+  uri = state->uri;
+
+  /* the uri contains the stream number we added in the SDP config, which is
+   * always /stream=%d so we need to strip that off
+   * parse the stream we need to configure, look for the stream in the abspath
+   * first and then in the query. */
+  if (uri->abspath == NULL || !(pos = strstr (uri->abspath, "/stream="))) {
+    if (uri->query == NULL || !(pos = strstr (uri->query, "/stream=")))
+      goto bad_request;
+  }
+
+  /* we can mofify the parsed uri in place */
+  *pos = '\0';
+
+  pos += strlen ("/stream=");
+  if (sscanf (pos, "%u", &streamid) != 1)
+    goto bad_request;
+
+  /* parse the transport */
+  res =
+      gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_TRANSPORT,
+      &transport, 0);
+  if (res != GST_RTSP_OK)
+    goto no_transport;
+
+  gst_rtsp_transport_new (&ct);
+
+  /* our supported transports */
+  supported = GST_RTSP_LOWER_TRANS_UDP |
+      GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP;
+
+  /* parse and find a usable supported transport */
+  if (!parse_transport (transport, supported, ct))
+    goto unsupported_transports;
+
+  /* we create the session after parsing stuff so that we don't make
+   * a session for malformed requests */
+  if (client->session_pool == NULL)
+    goto no_pool;
+
+  session = state->session;
+
   if (session) {
     g_object_ref (session);
     /* get a handle to the configuration of the media in the session, this can
      * return NULL if this is a new url to manage in this session. */
-    media = gst_rtsp_session_get_media (session, uri);
+    sessmedia = gst_rtsp_session_get_media (session, uri);
   } else {
     /* create a session if this fails we probably reached our session limit or
      * something. */
     if (!(session = gst_rtsp_session_pool_create (client->session_pool)))
       goto service_unavailable;
 
+    state->session = session;
+
     /* we need a new media configuration in this session */
-    media = NULL;
+    sessmedia = NULL;
   }
 
   /* we have no media, find one and manage it */
-  if (media == NULL) {
-    GstRTSPMedia *m;
-
+  if (sessmedia == NULL) {
     /* get a handle to the configuration of the media in the session */
-    if ((m = find_media (client, uri, request))) {
+    if ((media = find_media (client, state))) {
       /* manage the media in our session now */
-      media = gst_rtsp_session_manage_media (session, uri, m);
+      sessmedia = gst_rtsp_session_manage_media (session, uri, media);
     }
   }
 
   /* if we stil have no media, error */
-  if (media == NULL)
+  if (sessmedia == NULL)
     goto not_found;
 
-  /* fix the transports */
-  if (ct->lower_transport & GST_RTSP_LOWER_TRANS_TCP) {
-    /* check if the client selected channels for TCP */
-    if (ct->interleaved.min == -1 || ct->interleaved.max == -1) {
-      gst_rtsp_session_media_alloc_channels (media, &ct->interleaved);
-    }
-  }
+  state->sessmedia = sessmedia;
+  state->media = media = sessmedia->media;
+
+  /* now get the stream */
+  stream = gst_rtsp_media_get_stream (media, streamid);
+  if (stream == NULL)
+    goto not_found;
 
-  /* get a handle to the stream in the media */
-  if (!(stream = gst_rtsp_session_media_get_stream (media, streamid)))
-    goto no_stream;
+  state->stream = stream;
 
-  st = gst_rtsp_session_stream_set_transport (stream, ct);
+  /* set blocksize on this stream */
+  if (!handle_blocksize (media, stream, state->request))
+    goto invalid_blocksize;
+
+  /* update the client transport */
+  if (!configure_client_transport (client, state, ct))
+    goto unsupported_client_transport;
+
+  /* set in the session media transport */
+  trans = gst_rtsp_session_media_set_transport (sessmedia, stream, ct);
 
   /* configure keepalive for this transport */
-  gst_rtsp_session_stream_set_keepalive (stream,
+  gst_rtsp_stream_transport_set_keepalive (trans,
       (GstRTSPKeepAliveFunc) do_keepalive, session, NULL);
 
-  /* serialize the server transport */
+  /* create and serialize the server transport */
+  st = make_server_transport (client, state, ct);
   trans_str = gst_rtsp_transport_as_text (st);
   gst_rtsp_transport_free (st);
 
   /* construct the response now */
   code = GST_RTSP_STS_OK;
-  gst_rtsp_message_init_response (&response, code,
-      gst_rtsp_status_as_text (code), request);
+  gst_rtsp_message_init_response (state->response, code,
+      gst_rtsp_status_as_text (code), state->request);
 
-  gst_rtsp_message_add_header (&response, GST_RTSP_HDR_TRANSPORT, trans_str);
+  gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_TRANSPORT,
+      trans_str);
   g_free (trans_str);
 
-  send_response (client, session, &response);
+  send_response (client, session, state->response, NULL);
 
   /* update the state */
-  switch (media->state) {
+  switch (sessmedia->state) {
     case GST_RTSP_STATE_PLAYING:
     case GST_RTSP_STATE_RECORDING:
     case GST_RTSP_STATE_READY:
       /* no state change */
       break;
     default:
-      media->state = GST_RTSP_STATE_READY;
+      sessmedia->state = GST_RTSP_STATE_READY;
       break;
   }
   g_object_unref (session);
 
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SETUP_REQUEST],
+      0, state);
+
   return TRUE;
 
   /* ERRORS */
 bad_request:
   {
-    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, request);
+    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
     return FALSE;
   }
 not_found:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, state);
     g_object_unref (session);
+    gst_rtsp_transport_free (ct);
     return FALSE;
   }
-no_stream:
+invalid_blocksize:
   {
-    send_generic_response (client, GST_RTSP_STS_NOT_FOUND, request);
-    g_object_unref (media);
+    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, state);
+    g_object_unref (session);
+    gst_rtsp_transport_free (ct);
+    return FALSE;
+  }
+unsupported_client_transport:
+  {
+    send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
     g_object_unref (session);
+    gst_rtsp_transport_free (ct);
     return FALSE;
   }
 no_transport:
   {
-    send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, request);
+    send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
     return FALSE;
   }
 unsupported_transports:
   {
-    send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, request);
+    send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, state);
     gst_rtsp_transport_free (ct);
     return FALSE;
   }
 no_pool:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
+    gst_rtsp_transport_free (ct);
     return FALSE;
   }
 service_unavailable:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
+    gst_rtsp_transport_free (ct);
     return FALSE;
   }
 }
@@ -1016,20 +1281,20 @@ create_sdp (GstRTSPClient * client, GstRTSPMedia * media)
   gst_sdp_message_add_attribute (sdp, "control", "*");
 
   info.server_proto = proto;
-  if (media->protocols & GST_RTSP_LOWER_TRANS_UDP_MCAST)
-    info.server_ip = MCAST_ADDRESS;
-  else
-    info.server_ip = client->server_ip;
+  info.server_ip = g_strdup (client->server_ip);
 
   /* create an SDP for the media object */
   if (!gst_rtsp_sdp_from_media (sdp, &info, media))
     goto no_sdp;
 
+  g_free (info.server_ip);
+
   return sdp;
 
   /* ERRORS */
 no_sdp:
   {
+    g_free (info.server_ip);
     gst_sdp_message_free (sdp);
     return NULL;
   }
@@ -1037,15 +1302,16 @@ no_sdp:
 
 /* for the describe we must generate an SDP */
 static gboolean
-handle_describe_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_describe_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
-  GstRTSPMessage response = { 0 };
   GstRTSPResult res;
   GstSDPMessage *sdp;
   guint i, str_len;
   gchar *str, *content_base;
   GstRTSPMedia *media;
+  GstRTSPClientClass *klass;
+
+  klass = GST_RTSP_CLIENT_GET_CLASS (client);
 
   /* check what kind of format is accepted, we don't really do anything with it
    * and always return SDP for now. */
@@ -1053,7 +1319,8 @@ handle_describe_request (GstRTSPClient * client, GstRTSPUrl * uri,
     gchar *accept;
 
     res =
-        gst_rtsp_message_get_header (request, GST_RTSP_HDR_ACCEPT, &accept, i);
+        gst_rtsp_message_get_header (state->request, GST_RTSP_HDR_ACCEPT,
+        &accept, i);
     if (res == GST_RTSP_ENOTIMPL)
       break;
 
@@ -1062,23 +1329,23 @@ handle_describe_request (GstRTSPClient * client, GstRTSPUrl * uri,
   }
 
   /* find the media object for the uri */
-  if (!(media = find_media (client, uri, request)))
+  if (!(media = find_media (client, state)))
     goto no_media;
 
   /* create an SDP for the media object on this client */
-  if (!(sdp = create_sdp (client, media)))
+  if (!(sdp = klass->create_sdp (client, media)))
     goto no_sdp;
 
   g_object_unref (media);
 
-  gst_rtsp_message_init_response (&response, GST_RTSP_STS_OK,
-      gst_rtsp_status_as_text (GST_RTSP_STS_OK), request);
+  gst_rtsp_message_init_response (state->response, GST_RTSP_STS_OK,
+      gst_rtsp_status_as_text (GST_RTSP_STS_OK), state->request);
 
-  gst_rtsp_message_add_header (&response, GST_RTSP_HDR_CONTENT_TYPE,
+  gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_CONTENT_TYPE,
       "application/sdp");
 
   /* content base for some clients that might screw up creating the setup uri */
-  str = gst_rtsp_url_get_request_uri (uri);
+  str = gst_rtsp_url_get_request_uri (state->uri);
   str_len = strlen (str);
 
   /* check for trailing '/' and append one */
@@ -1094,16 +1361,19 @@ handle_describe_request (GstRTSPClient * client, GstRTSPUrl * uri,
 
   GST_INFO ("adding content-base: %s", content_base);
 
-  gst_rtsp_message_add_header (&response, GST_RTSP_HDR_CONTENT_BASE,
+  gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_CONTENT_BASE,
       content_base);
   g_free (content_base);
 
   /* add SDP to the response body */
   str = gst_sdp_message_as_text (sdp);
-  gst_rtsp_message_take_body (&response, (guint8 *) str, strlen (str));
+  gst_rtsp_message_take_body (state->response, (guint8 *) str, strlen (str));
   gst_sdp_message_free (sdp);
 
-  send_response (client, session, &response);
+  send_response (client, state->session, state->response, NULL);
+
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_DESCRIBE_REQUEST],
+      0, state);
 
   return TRUE;
 
@@ -1115,17 +1385,15 @@ no_media:
   }
 no_sdp:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, state);
     g_object_unref (media);
     return FALSE;
   }
 }
 
 static gboolean
-handle_options_request (GstRTSPClient * client, GstRTSPUrl * uri,
-    GstRTSPSession * session, GstRTSPMessage * request)
+handle_options_request (GstRTSPClient * client, GstRTSPClientState * state)
 {
-  GstRTSPMessage response = { 0 };
   GstRTSPMethod options;
   gchar *str;
 
@@ -1138,13 +1406,16 @@ handle_options_request (GstRTSPClient * client, GstRTSPUrl * uri,
 
   str = gst_rtsp_options_as_text (options);
 
-  gst_rtsp_message_init_response (&response, GST_RTSP_STS_OK,
-      gst_rtsp_status_as_text (GST_RTSP_STS_OK), request);
+  gst_rtsp_message_init_response (state->response, GST_RTSP_STS_OK,
+      gst_rtsp_status_as_text (GST_RTSP_STS_OK), state->request);
 
-  gst_rtsp_message_add_header (&response, GST_RTSP_HDR_PUBLIC, str);
+  gst_rtsp_message_add_header (state->response, GST_RTSP_HDR_PUBLIC, str);
   g_free (str);
 
-  send_response (client, session, &response);
+  send_response (client, state->session, state->response, NULL);
+
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST],
+      0, state);
 
   return TRUE;
 }
@@ -1210,6 +1481,9 @@ client_watch_session (GstRTSPClient * client, GstRTSPSession * session)
   g_object_weak_ref (G_OBJECT (session), (GWeakNotify) client_session_finalized,
       client);
   client->sessions = g_list_prepend (client->sessions, session);
+
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_NEW_SESSION], 0,
+      session);
 }
 
 static void
@@ -1221,8 +1495,13 @@ handle_request (GstRTSPClient * client, GstRTSPMessage * request)
   GstRTSPVersion version;
   GstRTSPResult res;
   GstRTSPSession *session;
+  GstRTSPClientState state = { NULL };
+  GstRTSPMessage response = { 0 };
   gchar *sessid;
 
+  state.request = request;
+  state.response = &response;
+
   if (gst_debug_category_get_threshold (rtsp_client_debug) >= GST_LEVEL_LOG) {
     gst_rtsp_message_dump (request);
   }
@@ -1234,18 +1513,20 @@ handle_request (GstRTSPClient * client, GstRTSPMessage * request)
   if (version != GST_RTSP_VERSION_1_0) {
     /* we can only handle 1.0 requests */
     send_generic_response (client, GST_RTSP_STS_RTSP_VERSION_NOT_SUPPORTED,
-        request);
+        &state);
     return;
   }
+  state.method = method;
 
   /* we always try to parse the url first */
   if (gst_rtsp_url_parse (uristr, &uri) != GST_RTSP_OK) {
-    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, request);
+    send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, &state);
     return;
   }
 
   /* sanitize the uri */
   sanitize_uri (uri);
+  state.uri = uri;
 
   /* get the session if there is any */
   res = gst_rtsp_message_get_header (request, GST_RTSP_HDR_SESSION, &sessid, 0);
@@ -1264,40 +1545,47 @@ handle_request (GstRTSPClient * client, GstRTSPMessage * request)
   } else
     session = NULL;
 
+  state.session = session;
+
+  if (client->auth) {
+    if (!gst_rtsp_auth_check (client->auth, client, 0, &state))
+      goto not_authorized;
+  }
+
   /* now see what is asked and dispatch to a dedicated handler */
   switch (method) {
     case GST_RTSP_OPTIONS:
-      handle_options_request (client, uri, session, request);
+      handle_options_request (client, &state);
       break;
     case GST_RTSP_DESCRIBE:
-      handle_describe_request (client, uri, session, request);
+      handle_describe_request (client, &state);
       break;
     case GST_RTSP_SETUP:
-      handle_setup_request (client, uri, session, request);
+      handle_setup_request (client, &state);
       break;
     case GST_RTSP_PLAY:
-      handle_play_request (client, uri, session, request);
+      handle_play_request (client, &state);
       break;
     case GST_RTSP_PAUSE:
-      handle_pause_request (client, uri, session, request);
+      handle_pause_request (client, &state);
       break;
     case GST_RTSP_TEARDOWN:
-      handle_teardown_request (client, uri, session, request);
+      handle_teardown_request (client, &state);
       break;
     case GST_RTSP_SET_PARAMETER:
-      handle_set_param_request (client, uri, session, request);
+      handle_set_param_request (client, &state);
       break;
     case GST_RTSP_GET_PARAMETER:
-      handle_get_param_request (client, uri, session, request);
+      handle_get_param_request (client, &state);
       break;
     case GST_RTSP_ANNOUNCE:
     case GST_RTSP_RECORD:
     case GST_RTSP_REDIRECT:
-      send_generic_response (client, GST_RTSP_STS_NOT_IMPLEMENTED, request);
+      send_generic_response (client, GST_RTSP_STS_NOT_IMPLEMENTED, &state);
       break;
     case GST_RTSP_INVALID:
     default:
-      send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, request);
+      send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, &state);
       break;
   }
   if (session)
@@ -1309,12 +1597,17 @@ handle_request (GstRTSPClient * client, GstRTSPMessage * request)
   /* ERRORS */
 no_pool:
   {
-    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, request);
+    send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, &state);
     return;
   }
 session_not_found:
   {
-    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, request);
+    send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, &state);
+    return;
+  }
+not_authorized:
+  {
+    handle_unauthorized_request (client, client->auth, &state);
     return;
   }
 }
@@ -1337,34 +1630,29 @@ handle_data (GstRTSPClient * client, GstRTSPMessage * message)
 
   gst_rtsp_message_steal_body (message, &data, &size);
 
-  buffer = gst_buffer_new ();
-  GST_BUFFER_DATA (buffer) = data;
-  GST_BUFFER_MALLOCDATA (buffer) = data;
-  GST_BUFFER_SIZE (buffer) = size;
+  buffer = gst_buffer_new_wrapped (data, size);
 
   handled = FALSE;
-  for (walk = client->streams; walk; walk = g_list_next (walk)) {
-    GstRTSPSessionStream *stream = (GstRTSPSessionStream *) walk->data;
-    GstRTSPMediaStream *mstream;
+  for (walk = client->transports; walk; walk = g_list_next (walk)) {
+    GstRTSPStreamTransport *trans;
+    GstRTSPStream *stream;
     GstRTSPTransport *tr;
 
-    /* get the transport, if there is no transport configured, skip this stream */
-    if (!(tr = stream->trans.transport))
-      continue;
+    trans = walk->data;
 
-    /* we also need a media stream */
-    if (!(mstream = stream->media_stream))
-      continue;
+    /* we only add clients with a transport to the list */
+    tr = trans->transport;
+    stream = trans->stream;
 
     /* check for TCP transport */
     if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
       /* dispatch to the stream based on the channel number */
       if (tr->interleaved.min == channel) {
-        gst_rtsp_media_stream_rtp (mstream, buffer);
+        gst_rtsp_stream_recv_rtp (stream, buffer);
         handled = TRUE;
         break;
       } else if (tr->interleaved.max == channel) {
-        gst_rtsp_media_stream_rtcp (mstream, buffer);
+        gst_rtsp_stream_recv_rtcp (stream, buffer);
         handled = TRUE;
         break;
       }
@@ -1405,7 +1693,7 @@ gst_rtsp_client_set_session_pool (GstRTSPClient * client,
  *
  * Get the #GstRTSPSessionPool object that @client uses to manage its sessions.
  *
- * Returns: a #GstRTSPSessionPool, unref after usage.
+ * Returns: (transfer full): a #GstRTSPSessionPool, unref after usage.
  */
 GstRTSPSessionPool *
 gst_rtsp_client_get_session_pool (GstRTSPClient * client)
@@ -1419,6 +1707,47 @@ gst_rtsp_client_get_session_pool (GstRTSPClient * client)
 }
 
 /**
+ * gst_rtsp_client_set_server:
+ * @client: a #GstRTSPClient
+ * @server: a #GstRTSPServer
+ *
+ * Set @server as the server that created @client.
+ */
+void
+gst_rtsp_client_set_server (GstRTSPClient * client, GstRTSPServer * server)
+{
+  GstRTSPServer *old;
+
+  old = client->server;
+  if (old != server) {
+    if (server)
+      g_object_ref (server);
+    client->server = server;
+    if (old)
+      g_object_unref (old);
+  }
+}
+
+/**
+ * gst_rtsp_client_get_server:
+ * @client: a #GstRTSPClient
+ *
+ * Get the #GstRTSPServer object that @client was created from.
+ *
+ * Returns: (transfer full): a #GstRTSPServer, unref after usage.
+ */
+GstRTSPServer *
+gst_rtsp_client_get_server (GstRTSPClient * client)
+{
+  GstRTSPServer *result;
+
+  if ((result = client->server))
+    g_object_ref (result);
+
+  return result;
+}
+
+/**
  * gst_rtsp_client_set_media_mapping:
  * @client: a #GstRTSPClient
  * @mapping: a #GstRTSPMediaMapping
@@ -1450,7 +1779,7 @@ gst_rtsp_client_set_media_mapping (GstRTSPClient * client,
  *
  * Get the #GstRTSPMediaMapping object that @client uses to manage its sessions.
  *
- * Returns: a #GstRTSPMediaMapping, unref after usage.
+ * Returns: (transfer full): a #GstRTSPMediaMapping, unref after usage.
  */
 GstRTSPMediaMapping *
 gst_rtsp_client_get_media_mapping (GstRTSPClient * client)
@@ -1463,6 +1792,83 @@ gst_rtsp_client_get_media_mapping (GstRTSPClient * client)
   return result;
 }
 
+/**
+ * gst_rtsp_client_set_use_client_settings:
+ * @client: a #GstRTSPClient
+ * @use_client_settings: whether to use client settings for multicast
+ *
+ * Use client transport settings (destination and ttl) for multicast.
+ * When @use_client_settings is %FALSE, the server settings will be
+ * used.
+ */
+void
+gst_rtsp_client_set_use_client_settings (GstRTSPClient * client,
+    gboolean use_client_settings)
+{
+  client->use_client_settings = use_client_settings;
+}
+
+/**
+ * gst_rtsp_client_get_use_client_settings:
+ * @client: a #GstRTSPClient
+ *
+ * Check if client transport settings (destination and ttl) for multicast
+ * will be used.
+ */
+gboolean
+gst_rtsp_client_get_use_client_settings (GstRTSPClient * client)
+{
+  return client->use_client_settings;
+}
+
+/**
+ * gst_rtsp_client_set_auth:
+ * @client: a #GstRTSPClient
+ * @auth: a #GstRTSPAuth
+ *
+ * configure @auth to be used as the authentication manager of @client.
+ */
+void
+gst_rtsp_client_set_auth (GstRTSPClient * client, GstRTSPAuth * auth)
+{
+  GstRTSPAuth *old;
+
+  g_return_if_fail (GST_IS_RTSP_CLIENT (client));
+
+  old = client->auth;
+
+  if (old != auth) {
+    if (auth)
+      g_object_ref (auth);
+    client->auth = auth;
+    if (old)
+      g_object_unref (old);
+  }
+}
+
+
+/**
+ * gst_rtsp_client_get_auth:
+ * @client: a #GstRTSPClient
+ *
+ * Get the #GstRTSPAuth used as the authentication manager of @client.
+ *
+ * Returns: (transfer full): the #GstRTSPAuth of @client. g_object_unref() after
+ * usage.
+ */
+GstRTSPAuth *
+gst_rtsp_client_get_auth (GstRTSPClient * client)
+{
+  GstRTSPAuth *result;
+
+  g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
+
+  if ((result = client->auth))
+    g_object_ref (result);
+
+  return result;
+}
+
 static GstRTSPResult
 message_received (GstRTSPWatch * watch, GstRTSPMessage * message,
     gpointer user_data)
@@ -1490,8 +1896,10 @@ message_sent (GstRTSPWatch * watch, guint cseq, gpointer user_data)
   GstRTSPClient *client;
 
   client = GST_RTSP_CLIENT (user_data);
-
-  /* GST_INFO ("client %p: sent a message with cseq %d", client, cseq); */
+  if (client->teardown_response_seq && client->teardown_response_seq == cseq) {
+    client->teardown_response_seq = 0;
+    close_connection (client);
+  }
 
   return GST_RTSP_OK;
 }
@@ -1505,10 +1913,10 @@ closed (GstRTSPWatch * watch, gpointer user_data)
   GST_INFO ("client %p: connection closed", client);
 
   if ((tunnelid = gst_rtsp_connection_get_tunnelid (client->connection))) {
-    g_mutex_lock (tunnels_lock);
+    g_mutex_lock (&tunnels_lock);
     /* remove from tunnelids */
     g_hash_table_remove (tunnels, tunnelid);
-    g_mutex_unlock (tunnels_lock);
+    g_mutex_unlock (&tunnels_lock);
   }
 
   return GST_RTSP_OK;
@@ -1556,12 +1964,12 @@ remember_tunnel (GstRTSPClient * client)
   GST_INFO ("client %p: inserting tunnel session %s", client, tunnelid);
 
   /* we can't have two clients connecting with the same tunnelid */
-  g_mutex_lock (tunnels_lock);
+  g_mutex_lock (&tunnels_lock);
   if (g_hash_table_lookup (tunnels, tunnelid))
     goto tunnel_existed;
 
   g_hash_table_insert (tunnels, g_strdup (tunnelid), g_object_ref (client));
-  g_mutex_unlock (tunnels_lock);
+  g_mutex_unlock (&tunnels_lock);
 
   return TRUE;
 
@@ -1573,7 +1981,7 @@ no_tunnelid:
   }
 tunnel_existed:
   {
-    g_mutex_unlock (tunnels_lock);
+    g_mutex_unlock (&tunnels_lock);
     GST_ERROR ("client %p: tunnel session %s already existed", client,
         tunnelid);
     return FALSE;
@@ -1633,7 +2041,7 @@ tunnel_complete (GstRTSPWatch * watch, gpointer user_data)
   if (tunnelid == NULL)
     goto no_tunnelid;
 
-  g_mutex_lock (tunnels_lock);
+  g_mutex_lock (&tunnels_lock);
   if (!(oclient = g_hash_table_lookup (tunnels, tunnelid)))
     goto no_tunnel;
 
@@ -1644,7 +2052,7 @@ tunnel_complete (GstRTSPWatch * watch, gpointer user_data)
 
   if (oclient->watch == NULL)
     goto tunnel_closed;
-  g_mutex_unlock (tunnels_lock);
+  g_mutex_unlock (&tunnels_lock);
 
   GST_INFO ("client %p: found tunnel %p (old %p, new %p)", client, oclient,
       oclient->connection, client->connection);
@@ -1654,31 +2062,26 @@ tunnel_complete (GstRTSPWatch * watch, gpointer user_data)
   gst_rtsp_watch_reset (oclient->watch);
   g_object_unref (oclient);
 
-  /* we don't need this watch anymore */
-  g_source_destroy ((GSource *) client->watch);
-  client->watchid = 0;
-  client->watch = NULL;
-
   return GST_RTSP_OK;
 
   /* ERRORS */
 no_tunnelid:
   {
     GST_INFO ("client %p: no tunnelid provided", client);
-    return GST_RTSP_STS_SERVICE_UNAVAILABLE;
+    return GST_RTSP_ERROR;
   }
 no_tunnel:
   {
-    g_mutex_unlock (tunnels_lock);
+    g_mutex_unlock (&tunnels_lock);
     GST_INFO ("client %p: tunnel session %s not found", client, tunnelid);
-    return GST_RTSP_STS_SERVICE_UNAVAILABLE;
+    return GST_RTSP_ERROR;
   }
 tunnel_closed:
   {
-    g_mutex_unlock (tunnels_lock);
+    g_mutex_unlock (&tunnels_lock);
     GST_INFO ("client %p: tunnel session %s was closed", client, tunnelid);
     g_object_unref (oclient);
-    return GST_RTSP_STS_SERVICE_UNAVAILABLE;
+    return GST_RTSP_ERROR;
   }
 }
 
@@ -1697,56 +2100,37 @@ static void
 client_watch_notify (GstRTSPClient * client)
 {
   GST_INFO ("client %p: watch destroyed", client);
-  client->watchid = 0;
   client->watch = NULL;
+  g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_CLOSED], 0, NULL);
   g_object_unref (client);
 }
 
-/**
- * gst_rtsp_client_attach:
- * @client: a #GstRTSPClient
- * @channel: a #GIOChannel
- *
- * Accept a new connection for @client on the socket in @channel. 
- *
- * This function should be called when the client properties and urls are fully
- * configured and the client is ready to start.
- *
- * Returns: %TRUE if the client could be accepted.
- */
-gboolean
-gst_rtsp_client_accept (GstRTSPClient * client, GIOChannel * channel)
+static gboolean
+setup_client (GstRTSPClient * client, GSocket * socket,
+    GstRTSPConnection * conn, GError ** error)
 {
-  int sock, fd;
-  GstRTSPConnection *conn;
-  GstRTSPResult res;
-  GSource *source;
-  GMainContext *context;
+  GSocket *read_socket;
+  GSocketAddress *address;
   GstRTSPUrl *url;
-  struct sockaddr_storage addr;
-  socklen_t addrlen;
-  gchar ip[INET6_ADDRSTRLEN];
-
-  /* a new client connected. */
-  sock = g_io_channel_unix_get_fd (channel);
 
-  GST_RTSP_CHECK (gst_rtsp_connection_accept (sock, &conn), accept_failed);
+  read_socket = gst_rtsp_connection_get_read_socket (conn);
+  client->is_ipv6 = g_socket_get_family (socket) == G_SOCKET_FAMILY_IPV6;
 
-  fd = gst_rtsp_connection_get_readfd (conn);
+  if (!(address = g_socket_get_remote_address (read_socket, error)))
+    goto no_address;
 
-  addrlen = sizeof (addr);
-  if (getsockname (fd, (struct sockaddr *) &addr, &addrlen) < 0)
-    goto getpeername_failed;
-
-  client->is_ipv6 = addr.ss_family == AF_INET6;
+  g_free (client->server_ip);
+  /* keep the original ip that the client connected to */
+  if (G_IS_INET_SOCKET_ADDRESS (address)) {
+    GInetAddress *iaddr;
 
-  if (getnameinfo ((struct sockaddr *) &addr, addrlen, ip, sizeof (ip), NULL, 0,
-          NI_NUMERICHOST) != 0)
-    goto getnameinfo_failed;
+    iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address));
 
-  /* keep the original ip that the client connected to */
-  g_free (client->server_ip);
-  client->server_ip = g_strndup (ip, sizeof (ip));
+    client->server_ip = g_inet_address_to_string (iaddr);
+    g_object_unref (address);
+  } else {
+    client->server_ip = g_strdup ("unknown");
+  }
 
   GST_INFO ("client %p connected to server ip %s, ipv6 = %d", client,
       client->server_ip, client->is_ipv6);
@@ -1756,40 +2140,118 @@ gst_rtsp_client_accept (GstRTSPClient * client, GIOChannel * channel)
 
   client->connection = conn;
 
-  /* create watch for the connection and attach */
-  client->watch = gst_rtsp_watch_new (client->connection, &watch_funcs,
-      g_object_ref (client), (GDestroyNotify) client_watch_notify);
+  return TRUE;
 
-  /* find the context to add the watch */
-  if ((source = g_main_current_source ()))
-    context = g_source_get_context (source);
-  else
-    context = NULL;
+  /* ERRORS */
+no_address:
+  {
+    GST_ERROR ("could not get remote address %s", (*error)->message);
+    return FALSE;
+  }
+}
 
-  GST_INFO ("attaching to context %p", context);
+/**
+ * gst_rtsp_client_use_socket:
+ * @client: a #GstRTSPClient
+ * @socket: a #GSocket
+ * @ip: the IP address of the remote client
+ * @port: the port used by the other end
+ * @initial_buffer: any zero terminated initial data that was already read from
+ *     the socket
+ * @error: a #GError
+ *
+ * Take an existing network socket and use it for an RTSP connection.
+ *
+ * Returns: %TRUE on success.
+ */
+gboolean
+gst_rtsp_client_use_socket (GstRTSPClient * client, GSocket * socket,
+    const gchar * ip, gint port, const gchar * initial_buffer, GError ** error)
+{
+  GstRTSPConnection *conn;
+  GstRTSPResult res;
 
-  client->watchid = gst_rtsp_watch_attach (client->watch, context);
-  gst_rtsp_watch_unref (client->watch);
+  GST_RTSP_CHECK (gst_rtsp_connection_create_from_socket (socket, ip, port,
+          initial_buffer, &conn), no_connection);
 
-  return TRUE;
+  return setup_client (client, socket, conn, error);
 
   /* ERRORS */
-accept_failed:
+no_connection:
   {
     gchar *str = gst_rtsp_strresult (res);
 
-    GST_ERROR ("Could not accept client on server socket %d: %s", sock, str);
+    GST_ERROR ("could not create connection from socket %p: %s", socket, str);
     g_free (str);
     return FALSE;
   }
-getpeername_failed:
-  {
-    GST_ERROR ("getpeername failed: %s", g_strerror (errno));
-    return FALSE;
-  }
-getnameinfo_failed:
+}
+
+/**
+ * gst_rtsp_client_accept:
+ * @client: a #GstRTSPClient
+ * @socket: a #GSocket
+ * @context: the context to run in
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Accept a new connection for @client on @socket.
+ *
+ * Returns: %TRUE if the client could be accepted.
+ */
+gboolean
+gst_rtsp_client_accept (GstRTSPClient * client, GSocket * socket,
+    GCancellable * cancellable, GError ** error)
+{
+  GstRTSPConnection *conn;
+  GstRTSPResult res;
+
+  /* a new client connected. */
+  GST_RTSP_CHECK (gst_rtsp_connection_accept (socket, &conn, cancellable),
+      accept_failed);
+
+  return setup_client (client, socket, conn, error);
+
+  /* ERRORS */
+accept_failed:
   {
-    GST_ERROR ("getnameinfo failed: %s", g_strerror (errno));
+    gchar *str = gst_rtsp_strresult (res);
+
+    GST_ERROR ("Could not accept client on server socket %p: %s", socket, str);
+    g_free (str);
     return FALSE;
   }
 }
+
+/**
+ * gst_rtsp_client_attach:
+ * @client: a #GstRTSPClient
+ * @context: (allow-none): a #GMainContext
+ *
+ * Attaches @client to @context. When the mainloop for @context is run, the
+ * client will be dispatched. When @context is NULL, the default context will be
+ * used).
+ *
+ * This function should be called when the client properties and urls are fully
+ * configured and the client is ready to start.
+ *
+ * Returns: the ID (greater than 0) for the source within the GMainContext.
+ */
+guint
+gst_rtsp_client_attach (GstRTSPClient * client, GMainContext * context)
+{
+  guint res;
+
+  g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), 0);
+  g_return_val_if_fail (client->watch == NULL, 0);
+
+  /* create watch for the connection and attach */
+  client->watch = gst_rtsp_watch_new (client->connection, &watch_funcs,
+      g_object_ref (client), (GDestroyNotify) client_watch_notify);
+
+  GST_INFO ("attaching to context %p", context);
+  res = gst_rtsp_watch_attach (client->watch, context);
+  gst_rtsp_watch_unref (client->watch);
+
+  return res;
+}