/* GStreamer
* Copyright (C) 2008 Wim Taymans <wim.taymans at gmail.com>
+ * Copyright (C) 2015 Centricular Ltd
+ * Author: Sebastian Dröge <sebastian@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
{
GMutex lock; /* protects everything else */
GMutex send_lock;
+ GMutex watch_lock;
GstRTSPConnection *connection;
GstRTSPWatch *watch;
+ GMainContext *watch_context;
guint close_seq;
gchar *server_ip;
gboolean is_ipv6;
GDestroyNotify send_notify; /* protected by send_lock */
GstRTSPSessionPool *session_pool;
+ gulong session_removed_id;
GstRTSPMountPoints *mount_points;
GstRTSPAuth *auth;
GstRTSPThreadPool *thread_pool;
gchar *path;
GstRTSPMedia *media;
- GList *transports;
+ GHashTable *transports;
GList *sessions;
+ guint sessions_cookie;
gboolean drop_backlog;
};
static GMutex tunnels_lock;
static GHashTable *tunnels; /* protected by tunnels_lock */
+/* FIXME make this configurable. We don't want to do this yet because it will
+ * be superceeded by a cache object later */
+#define WATCH_BACKLOG_SIZE 100
+
#define DEFAULT_SESSION_POOL NULL
#define DEFAULT_MOUNT_POINTS NULL
#define DEFAULT_DROP_BACKLOG TRUE
SIGNAL_SET_PARAMETER_REQUEST,
SIGNAL_GET_PARAMETER_REQUEST,
SIGNAL_HANDLE_RESPONSE,
+ SIGNAL_SEND_MESSAGE,
+ SIGNAL_ANNOUNCE_REQUEST,
+ SIGNAL_RECORD_REQUEST,
SIGNAL_LAST
};
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_transports (GstRTSPClient * client,
- GstRTSPSession * session, GstRTSPSessionMedia * sessmedia);
+static gboolean handle_sdp (GstRTSPClient * client, GstRTSPContext * ctx,
+ GstRTSPMedia * media, GstSDPMessage * sdp);
static gboolean default_configure_client_media (GstRTSPClient * client,
GstRTSPMedia * media, GstRTSPStream * stream, GstRTSPContext * ctx);
static gboolean default_configure_client_transport (GstRTSPClient * client,
GstRTSPContext * ctx);
static gchar *default_make_path_from_uri (GstRTSPClient * client,
const GstRTSPUrl * uri);
+static void client_session_removed (GstRTSPSessionPool * pool,
+ GstRTSPSession * session, GstRTSPClient * client);
G_DEFINE_TYPE (GstRTSPClient, gst_rtsp_client, G_TYPE_OBJECT);
gobject_class->finalize = gst_rtsp_client_finalize;
klass->create_sdp = create_sdp;
+ klass->handle_sdp = handle_sdp;
klass->configure_client_media = default_configure_client_media;
klass->configure_client_transport = default_configure_client_transport;
klass->params_set = default_params_set;
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);
+ g_cclosure_marshal_generic, 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);
+ g_cclosure_marshal_generic, 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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
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);
+ set_parameter_request), NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 1, GST_TYPE_RTSP_CONTEXT);
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);
+ get_parameter_request), NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 1, GST_TYPE_RTSP_CONTEXT);
gst_rtsp_client_signals[SIGNAL_HANDLE_RESPONSE] =
g_signal_new ("handle-response", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
- handle_response), NULL, NULL, g_cclosure_marshal_VOID__POINTER,
- G_TYPE_NONE, 1, G_TYPE_POINTER);
+ handle_response), NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 1, GST_TYPE_RTSP_CONTEXT);
+
+ /**
+ * GstRTSPClient::send-message:
+ * @client: The RTSP client
+ * @session: (type GstRtspServer.RTSPSession): The session
+ * @message: (type GstRtsp.RTSPMessage): The message
+ */
+ gst_rtsp_client_signals[SIGNAL_SEND_MESSAGE] =
+ g_signal_new ("send-message", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass,
+ send_message), NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 2, GST_TYPE_RTSP_CONTEXT, G_TYPE_POINTER);
+
+ gst_rtsp_client_signals[SIGNAL_ANNOUNCE_REQUEST] =
+ g_signal_new ("announce-request", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, announce_request),
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
+
+ gst_rtsp_client_signals[SIGNAL_RECORD_REQUEST] =
+ g_signal_new ("record-request", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPClientClass, record_request),
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_CONTEXT);
tunnels =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
g_mutex_init (&priv->lock);
g_mutex_init (&priv->send_lock);
+ g_mutex_init (&priv->watch_lock);
priv->close_seq = 0;
priv->drop_backlog = DEFAULT_DROP_BACKLOG;
+ priv->transports =
+ g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
+ g_object_unref);
}
static GstRTSPFilterResult
-filter_session (GstRTSPSession * sess, GstRTSPSessionMedia * sessmedia,
+filter_session_media (GstRTSPSession * sess, GstRTSPSessionMedia * sessmedia,
gpointer user_data)
{
- GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
-
gst_rtsp_session_media_set_state (sessmedia, GST_STATE_NULL);
- unlink_session_transports (client, sess, sessmedia);
- /* unmanage the media in the session */
return GST_RTSP_FILTER_REMOVE;
}
static void
-client_unlink_session (GstRTSPClient * client, GstRTSPSession * session)
-{
- /* unlink all media managed in this session */
- gst_rtsp_session_filter (session, filter_session, client);
-}
-
-static void
client_watch_session (GstRTSPClient * client, GstRTSPSession * session)
{
GstRTSPClientPrivate *priv = client->priv;
- GList *walk;
- for (walk = priv->sessions; walk; walk = g_list_next (walk)) {
- GstRTSPSession *msession = (GstRTSPSession *) walk->data;
+ g_mutex_lock (&priv->lock);
+ /* check if we already know about this session */
+ if (g_list_find (priv->sessions, session) == NULL) {
+ GST_INFO ("watching session %p", session);
- /* we already know about this session */
- if (msession == session)
- return;
- }
+ priv->sessions = g_list_prepend (priv->sessions, g_object_ref (session));
+ priv->sessions_cookie++;
- GST_INFO ("watching session %p", session);
+ /* connect removed session handler, it will be disconnected when the last
+ * session gets removed */
+ if (priv->session_removed_id == 0)
+ priv->session_removed_id = g_signal_connect_data (priv->session_pool,
+ "session-removed", G_CALLBACK (client_session_removed),
+ g_object_ref (client), (GClosureNotify) g_object_unref, 0);
+ }
+ g_mutex_unlock (&priv->lock);
- g_object_weak_ref (G_OBJECT (session), (GWeakNotify) client_session_finalized,
- client);
- priv->sessions = g_list_prepend (priv->sessions, session);
+ return;
}
+/* should be called with lock */
static void
-client_unwatch_session (GstRTSPClient * client, GstRTSPSession * session)
+client_unwatch_session (GstRTSPClient * client, GstRTSPSession * session,
+ GList * link)
{
GstRTSPClientPrivate *priv = client->priv;
- GST_INFO ("unwatching session %p", session);
+ GST_INFO ("client %p: unwatch session %p", client, session);
- g_object_weak_unref (G_OBJECT (session),
- (GWeakNotify) client_session_finalized, client);
- priv->sessions = g_list_remove (priv->sessions, session);
+ if (link == NULL) {
+ link = g_list_find (priv->sessions, session);
+ if (link == NULL)
+ return;
+ }
+
+ priv->sessions = g_list_delete_link (priv->sessions, link);
+ priv->sessions_cookie++;
+
+ /* if this was the last session, disconnect the handler.
+ * This will also drop the extra client ref */
+ if (!priv->sessions) {
+ g_signal_handler_disconnect (priv->session_pool, priv->session_removed_id);
+ priv->session_removed_id = 0;
+ }
+
+ /* remove the session */
+ g_object_unref (session);
}
-static void
-client_cleanup_session (GstRTSPClient * client, GstRTSPSession * session)
+static GstRTSPFilterResult
+cleanup_session (GstRTSPClient * client, GstRTSPSession * sess,
+ gpointer user_data)
{
- g_object_weak_unref (G_OBJECT (session),
- (GWeakNotify) client_session_finalized, client);
- client_unlink_session (client, session);
+ /* unlink all media managed in this session. This needs to happen
+ * without the client lock, so we really want to do it here. */
+ gst_rtsp_session_filter (sess, filter_session_media, client);
+
+ return GST_RTSP_FILTER_REMOVE;
}
static void
-client_cleanup_sessions (GstRTSPClient * client)
+clean_cached_media (GstRTSPClient * client, gboolean unprepare)
{
GstRTSPClientPrivate *priv = client->priv;
- GList *sessions;
- /* remove weak-ref from sessions */
- for (sessions = priv->sessions; sessions; sessions = g_list_next (sessions)) {
- client_cleanup_session (client, (GstRTSPSession *) sessions->data);
+ if (priv->path) {
+ g_free (priv->path);
+ priv->path = NULL;
+ }
+ if (priv->media) {
+ if (unprepare)
+ gst_rtsp_media_unprepare (priv->media);
+ g_object_unref (priv->media);
+ priv->media = NULL;
}
- g_list_free (priv->sessions);
- priv->sessions = NULL;
}
/* A client is finalized when the connection is broken */
if (priv->watch)
g_source_destroy ((GSource *) priv->watch);
- client_cleanup_sessions (client);
+ if (priv->watch_context)
+ g_main_context_unref (priv->watch_context);
+
+ /* all sessions should have been removed by now. We keep a ref to
+ * the client object for the session removed handler. The ref is
+ * dropped when the last session is removed from the list. */
+ g_assert (priv->sessions == NULL);
+ g_assert (priv->session_removed_id == 0);
+
+ g_hash_table_unref (priv->transports);
if (priv->connection)
gst_rtsp_connection_free (priv->connection);
- if (priv->session_pool)
+ if (priv->session_pool) {
g_object_unref (priv->session_pool);
+ }
if (priv->mount_points)
g_object_unref (priv->mount_points);
if (priv->auth)
if (priv->thread_pool)
g_object_unref (priv->thread_pool);
- if (priv->path)
- g_free (priv->path);
- if (priv->media) {
- gst_rtsp_media_unprepare (priv->media);
- g_object_unref (priv->media);
- }
+ clean_cached_media (client, TRUE);
g_free (priv->server_ip);
g_mutex_clear (&priv->lock);
g_mutex_clear (&priv->send_lock);
+ g_mutex_clear (&priv->watch_lock);
G_OBJECT_CLASS (gst_rtsp_client_parent_class)->finalize (obj);
}
}
static void
-send_message (GstRTSPClient * client, GstRTSPSession * session,
+send_message (GstRTSPClient * client, GstRTSPContext * ctx,
GstRTSPMessage * message, gboolean close)
{
GstRTSPClientPrivate *priv = client->priv;
gst_rtsp_message_remove_header (message, GST_RTSP_HDR_SESSION, -1);
/* add the new session header for new session ids */
- if (session) {
+ if (ctx->session) {
gst_rtsp_message_take_header (message, GST_RTSP_HDR_SESSION,
- gst_rtsp_session_get_header (session));
+ gst_rtsp_session_get_header (ctx->session));
}
if (gst_debug_category_get_threshold (rtsp_client_debug) >= GST_LEVEL_LOG) {
if (close)
gst_rtsp_message_add_header (message, GST_RTSP_HDR_CONNECTION, "close");
+ g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SEND_MESSAGE],
+ 0, ctx, message);
+
g_mutex_lock (&priv->send_lock);
if (priv->send_func)
priv->send_func (client, message, close, priv->send_data);
gst_rtsp_message_init_response (ctx->response, code,
gst_rtsp_status_as_text (code), ctx->request);
- send_message (client, NULL, ctx->response, FALSE);
+ ctx->session = NULL;
+
+ send_message (client, ctx, ctx->response, FALSE);
+}
+
+static void
+send_option_not_supported_response (GstRTSPClient * client,
+ GstRTSPContext * ctx, const gchar * unsupported_options)
+{
+ GstRTSPStatusCode code = GST_RTSP_STS_OPTION_NOT_SUPPORTED;
+
+ gst_rtsp_message_init_response (ctx->response, code,
+ gst_rtsp_status_as_text (code), ctx->request);
+
+ if (unsupported_options != NULL) {
+ gst_rtsp_message_add_header (ctx->response, GST_RTSP_HDR_UNSUPPORTED,
+ unsupported_options);
+ }
+
+ ctx->session = NULL;
+
+ send_message (client, ctx, ctx->response, FALSE);
}
static gboolean
path_len = strlen (path);
if (!paths_are_equal (priv->path, path, path_len)) {
- GstRTSPThread *thread;
-
/* remove any previously cached values before we try to construct a new
* media for uri */
- if (priv->path)
- g_free (priv->path);
- priv->path = NULL;
- if (priv->media) {
- gst_rtsp_media_unprepare (priv->media);
- g_object_unref (priv->media);
- }
- priv->media = NULL;
+ clean_cached_media (client, TRUE);
/* prepare the media and add it to the pipeline */
if (!(media = gst_rtsp_media_factory_construct (factory, ctx->uri)))
ctx->media = media;
- thread = gst_rtsp_thread_pool_get_thread (priv->thread_pool,
- GST_RTSP_THREAD_TYPE_MEDIA, ctx);
- if (thread == NULL)
- goto no_thread;
+ if (!(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_RECORD)) {
+ GstRTSPThread *thread;
+
+ thread = gst_rtsp_thread_pool_get_thread (priv->thread_pool,
+ GST_RTSP_THREAD_TYPE_MEDIA, ctx);
+ if (thread == NULL)
+ goto no_thread;
- /* prepare the media */
- if (!(gst_rtsp_media_prepare (media, thread)))
- goto no_prepare;
+ /* prepare the media */
+ if (!gst_rtsp_media_prepare (media, thread))
+ goto no_prepare;
+ }
/* now keep track of the uri and the media */
priv->path = g_strndup (path, path_len);
{
GstRTSPClientPrivate *priv = client->priv;
GstRTSPMessage message = { 0 };
+ GstRTSPResult res = GST_RTSP_OK;
GstMapInfo map_info;
guint8 *data;
guint usize;
g_mutex_lock (&priv->send_lock);
if (priv->send_func)
- priv->send_func (client, &message, FALSE, priv->send_data);
+ res = priv->send_func (client, &message, FALSE, priv->send_data);
g_mutex_unlock (&priv->send_lock);
gst_rtsp_message_steal_body (&message, &data, &usize);
gst_rtsp_message_unset (&message);
- return TRUE;
-}
-
-static void
-link_transport (GstRTSPClient * client, GstRTSPSession * session,
- GstRTSPStreamTransport * trans)
-{
- GstRTSPClientPrivate *priv = client->priv;
-
- 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);
-
- priv->transports = g_list_prepend (priv->transports, trans);
-
- /* make sure our session can't expire */
- gst_rtsp_session_prevent_expire (session);
-}
-
-static void
-link_session_transports (GstRTSPClient * client, GstRTSPSession * session,
- GstRTSPSessionMedia * sessmedia)
-{
- guint n_streams, i;
-
- n_streams =
- gst_rtsp_media_n_streams (gst_rtsp_session_media_get_media (sessmedia));
- for (i = 0; i < n_streams; i++) {
- GstRTSPStreamTransport *trans;
- const GstRTSPTransport *tr;
-
- /* get the transport, if there is no transport configured, skip this stream */
- trans = gst_rtsp_session_media_get_transport (sessmedia, i);
- if (trans == NULL)
- continue;
-
- tr = gst_rtsp_stream_transport_get_transport (trans);
-
- if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
- /* for TCP, link the stream to the TCP connection of the client */
- link_transport (client, session, trans);
- }
- }
-}
-
-static void
-unlink_transport (GstRTSPClient * client, GstRTSPSession * session,
- GstRTSPStreamTransport * trans)
-{
- GstRTSPClientPrivate *priv = client->priv;
-
- GST_DEBUG ("client %p: unlinking transport %p", client, trans);
-
- gst_rtsp_stream_transport_set_callbacks (trans, NULL, NULL, NULL, NULL);
-
- priv->transports = g_list_remove (priv->transports, trans);
-
- /* our session can now expire */
- gst_rtsp_session_allow_expire (session);
-}
-
-static void
-unlink_session_transports (GstRTSPClient * client, GstRTSPSession * session,
- GstRTSPSessionMedia * sessmedia)
-{
- guint n_streams, i;
-
- n_streams =
- gst_rtsp_media_n_streams (gst_rtsp_session_media_get_media (sessmedia));
- for (i = 0; i < n_streams; i++) {
- GstRTSPStreamTransport *trans;
- const GstRTSPTransport *tr;
-
- /* get the transport, if there is no transport configured, skip this stream */
- trans = gst_rtsp_session_media_get_transport (sessmedia, i);
- if (trans == NULL)
- continue;
-
- tr = gst_rtsp_stream_transport_get_transport (trans);
-
- if (tr->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
- /* for TCP, unlink the stream from the TCP connection of the client */
- unlink_transport (client, session, trans);
- }
- }
+ return res == GST_RTSP_OK;
}
-static void
-close_connection (GstRTSPClient * client)
+/**
+ * gst_rtsp_client_close:
+ * @client: a #GstRTSPClient
+ *
+ * Close the connection of @client and remove all media it was managing.
+ *
+ * Since: 1.4
+ */
+void
+gst_rtsp_client_close (GstRTSPClient * client)
{
GstRTSPClientPrivate *priv = client->priv;
const gchar *tunnelid;
GST_DEBUG ("client %p: closing connection", client);
- if ((tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection))) {
- g_mutex_lock (&tunnels_lock);
- /* remove from tunnelids */
- g_hash_table_remove (tunnels, tunnelid);
- g_mutex_unlock (&tunnels_lock);
+ if (priv->connection) {
+ if ((tunnelid = gst_rtsp_connection_get_tunnelid (priv->connection))) {
+ g_mutex_lock (&tunnels_lock);
+ /* remove from tunnelids */
+ g_hash_table_remove (tunnels, tunnelid);
+ g_mutex_unlock (&tunnels_lock);
+ }
+ gst_rtsp_connection_close (priv->connection);
}
- gst_rtsp_connection_close (priv->connection);
+ /* connection is now closed, destroy the watch which will also cause the
+ * closed signal to be emitted */
+ if (priv->watch) {
+ GST_DEBUG ("client %p: destroying watch", client);
+ g_source_destroy ((GSource *) priv->watch);
+ priv->watch = NULL;
+ gst_rtsp_client_set_send_func (client, NULL, NULL, NULL);
+ g_main_context_unref (priv->watch_context);
+ priv->watch_context = NULL;
+ }
}
static gchar *
GstRTSPStatusCode code;
gchar *path;
gint matched;
+ gboolean keep_session;
if (!ctx->session)
goto no_session;
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_TEARDOWN_REQUEST],
0, ctx);
- /* make sure we unblock the backlog and don't accept new messages
- * on the watch */
- gst_rtsp_watch_set_flushing (priv->watch, TRUE);
-
- /* unlink the all TCP callbacks */
- unlink_session_transports (client, session, sessmedia);
-
- /* remove the session from the watched sessions */
- client_unwatch_session (client, session);
-
gst_rtsp_session_media_set_state (sessmedia, GST_STATE_NULL);
- /* allow messages again so that we can send the reply */
- gst_rtsp_watch_set_flushing (priv->watch, FALSE);
-
/* unmanage the media in the session, returns false if all media session
* are torn down. */
- if (!gst_rtsp_session_release_media (session, sessmedia)) {
- /* remove the session */
- gst_rtsp_session_pool_remove (priv->session_pool, session);
- }
+ keep_session = gst_rtsp_session_release_media (session, sessmedia);
+
/* construct the response now */
code = GST_RTSP_STS_OK;
gst_rtsp_message_init_response (ctx->response, code,
gst_rtsp_status_as_text (code), ctx->request);
- send_message (client, session, ctx->response, TRUE);
+ send_message (client, ctx, ctx->response, TRUE);
+
+ if (!keep_session) {
+ /* remove the session */
+ gst_rtsp_session_pool_remove (priv->session_pool, session);
+ }
return TRUE;
if (res != GST_RTSP_OK)
goto bad_request;
- send_message (client, ctx->session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
}
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_GET_PARAMETER_REQUEST],
if (res != GST_RTSP_OK)
goto bad_request;
- send_message (client, ctx->session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
}
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_SET_PARAMETER_REQUEST],
rtspstate != GST_RTSP_STATE_RECORDING)
goto invalid_state;
- /* unlink the all TCP callbacks */
- unlink_session_transports (client, session, sessmedia);
-
/* then pause sending */
gst_rtsp_session_media_set_state (sessmedia, GST_STATE_PAUSED);
gst_rtsp_message_init_response (ctx->response, code,
gst_rtsp_status_as_text (code), ctx->request);
- send_message (client, session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
/* the state is now READY */
gst_rtsp_session_media_set_rtsp_state (sessmedia, GST_RTSP_STATE_READY);
ctx->sessmedia = sessmedia;
ctx->media = media = gst_rtsp_session_media_get_media (sessmedia);
+ if (!(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_PLAY))
+ goto unsupported_mode;
+
/* the session state must be playing or ready */
rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
if (rtspstate != GST_RTSP_STATE_PLAYING && rtspstate != GST_RTSP_STATE_READY)
res = gst_rtsp_message_get_header (ctx->request, GST_RTSP_HDR_RANGE, &str, 0);
if (res == GST_RTSP_OK) {
if (gst_rtsp_range_parse (str, &range) == GST_RTSP_OK) {
+ GstRTSPMediaStatus media_status;
+
/* we have a range, seek to the position */
unit = range->unit;
gst_rtsp_media_seek (media, range);
gst_rtsp_range_free (range);
+
+ media_status = gst_rtsp_media_get_status (media);
+ if (media_status == GST_RTSP_MEDIA_STATUS_ERROR)
+ goto seek_failed;
}
}
- /* link the all TCP callbacks */
- link_session_transports (client, session, sessmedia);
-
/* grab RTPInfo from the media now */
rtpinfo = gst_rtsp_session_media_get_rtpinfo (sessmedia);
if (str)
gst_rtsp_message_take_header (ctx->response, GST_RTSP_HDR_RANGE, str);
- send_message (client, session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
/* start playing after sending the response */
gst_rtsp_session_media_set_state (sessmedia, GST_STATE_PLAYING);
send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, ctx);
return FALSE;
}
+seek_failed:
+ {
+ GST_ERROR ("client %p: seek failed", client);
+ send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, ctx);
+ return FALSE;
+ }
+unsupported_mode:
+ {
+ GST_ERROR ("client %p: media does not support PLAY", client);
+ send_generic_response (client, GST_RTSP_STS_METHOD_NOT_ALLOWED, ctx);
+ return FALSE;
+ }
}
static void
ct->destination = g_strdup (url->host);
if (ct->lower_transport & GST_RTSP_LOWER_TRANS_TCP) {
+ GSocket *sock;
+ GSocketAddress *addr;
+
+ sock = gst_rtsp_connection_get_read_socket (priv->connection);
+ if ((addr = g_socket_get_remote_address (sock, NULL))) {
+ /* our read port is the sender port of client */
+ ct->client_port.min =
+ g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
+ g_object_unref (addr);
+ }
+ if ((addr = g_socket_get_local_address (sock, NULL))) {
+ ct->server_port.max =
+ g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
+ g_object_unref (addr);
+ }
+ sock = gst_rtsp_connection_get_write_socket (priv->connection);
+ if ((addr = g_socket_get_remote_address (sock, NULL))) {
+ /* our write port is the receiver port of client */
+ ct->client_port.max =
+ g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
+ g_object_unref (addr);
+ }
+ if ((addr = g_socket_get_local_address (sock, NULL))) {
+ ct->server_port.min =
+ g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
+ g_object_unref (addr);
+ }
/* check if the client selected channels for TCP */
if (ct->interleaved.min == -1 || ct->interleaved.max == -1) {
gst_rtsp_session_media_alloc_channels (ctx->sessmedia,
}
static GstRTSPTransport *
-make_server_transport (GstRTSPClient * client, GstRTSPContext * ctx,
- GstRTSPTransport * ct)
+make_server_transport (GstRTSPClient * client, GstRTSPMedia * media,
+ GstRTSPContext * ctx, GstRTSPTransport * ct)
{
GstRTSPTransport *st;
GInetAddress *addr;
st->trans = ct->trans;
st->profile = ct->profile;
st->lower_transport = ct->lower_transport;
+ st->mode_play = ct->mode_play;
+ st->mode_record = ct->mode_record;
addr = g_inet_address_new_from_string (ct->destination);
break;
case GST_RTSP_LOWER_TRANS_TCP:
st->interleaved = ct->interleaved;
+ st->client_port = ct->client_port;
+ st->server_port = ct->server_port;
default:
break;
}
- gst_rtsp_stream_get_ssrc (ctx->stream, &st->ssrc);
+ if ((gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_PLAY))
+ gst_rtsp_stream_get_ssrc (ctx->stream, &st->ssrc);
return st;
}
+#define AES_128_KEY_LEN 16
+#define AES_256_KEY_LEN 32
+
+#define HMAC_32_KEY_LEN 4
+#define HMAC_80_KEY_LEN 10
+
static gboolean
mikey_apply_policy (GstCaps * caps, GstMIKEYMessage * msg, guint8 policy)
{
break;
}
break;
+ case GST_MIKEY_SP_SRTP_ENC_KEY_LEN:
+ switch (param->val[0]) {
+ case AES_128_KEY_LEN:
+ srtp_cipher = "aes-128-icm";
+ break;
+ case AES_256_KEY_LEN:
+ srtp_cipher = "aes-256-icm";
+ break;
+ default:
+ break;
+ }
+ break;
case GST_MIKEY_SP_SRTP_AUTH_ALG:
switch (param->val[0]) {
case 0:
break;
}
break;
+ case GST_MIKEY_SP_SRTP_AUTH_KEY_LEN:
+ switch (param->val[0]) {
+ case HMAC_32_KEY_LEN:
+ srtp_auth = "hmac-sha1-32";
+ break;
+ case HMAC_80_KEY_LEN:
+ srtp_auth = "hmac-sha1-80";
+ break;
+ default:
+ break;
+ }
+ break;
case GST_MIKEY_SP_SRTP_SRTP_ENC:
break;
case GST_MIKEY_SP_SRTP_SRTCP_ENC:
gst_rtsp_stream_update_crypto (ctx->stream, map->ssrc, caps);
gst_caps_unref (caps);
}
- gst_mikey_message_free (msg);
+ gst_mikey_message_unref (msg);
+ gst_buffer_unref (key);
return TRUE;
}
cleanup_message:
{
- gst_mikey_message_free (msg);
+ gst_mikey_message_unref (msg);
return FALSE;
}
}
memmove (str, s, len + 1);
}
-/**
- * KeyMgmt = "KeyMgmt" ":" key-mgmt-spec 0*("," key-mgmt-spec)
+/* KeyMgmt = "KeyMgmt" ":" key-mgmt-spec 0*("," key-mgmt-spec)
* key-mgmt-spec = "prot" "=" KMPID ";" ["uri" "=" %x22 URI %x22 ";"]
*/
static gboolean
handle_mikey_data (client, ctx, data, size);
}
}
+ g_strfreev (split);
}
+ g_strfreev (specs);
return TRUE;
}
GstRTSPStream *stream;
GstRTSPState rtspstate;
GstRTSPClientClass *klass;
- gchar *path, *control;
+ gchar *path, *control = NULL;
gint matched;
+ gboolean new_session = FALSE;
if (!ctx->uri)
goto no_uri;
if (media == NULL)
goto media_not_found_no_reply;
- if (path[matched] == '\0')
- goto control_not_found;
+ if (path[matched] == '\0') {
+ if (gst_rtsp_media_n_streams (media) == 1) {
+ stream = gst_rtsp_media_get_stream (media, 0);
+ } else {
+ goto control_not_found;
+ }
+ } else {
+ /* path is what matched. */
+ path[matched] = '\0';
+ /* control is remainder */
+ control = &path[matched + 1];
- /* path is what matched. */
- path[matched] = '\0';
- /* control is remainder */
- control = &path[matched + 1];
+ /* find the stream now using the control part */
+ stream = gst_rtsp_media_find_stream (media, control);
+ }
- /* find the stream now using the control part */
- stream = gst_rtsp_media_find_stream (media, control);
if (stream == NULL)
goto stream_not_found;
/* make sure this client is closed when the session is closed */
client_watch_session (client, session);
+ new_session = TRUE;
/* signal new session */
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_NEW_SESSION], 0,
session);
ctx->session = session;
}
- if (sessmedia == NULL) {
- /* manage the media in our session now, if not done already */
- sessmedia = gst_rtsp_session_manage_media (session, path, media);
- /* if we stil have no media, error */
- if (sessmedia == NULL)
- goto sessmedia_unavailable;
- } else {
- g_object_unref (media);
- }
-
- ctx->sessmedia = sessmedia;
-
if (!klass->configure_client_media (client, media, stream, ctx))
goto configure_media_failed_no_reply;
if (!parse_transport (transport, stream, ct))
goto unsupported_transports;
- /* update the client transport */
- if (!klass->configure_client_transport (client, ctx, ct))
- goto unsupported_client_transport;
+ if ((ct->mode_play
+ && !(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_PLAY)) || (ct->mode_record
+ && !(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_RECORD)))
+ goto unsupported_mode;
/* parse the keymgmt */
if (gst_rtsp_message_get_header (ctx->request, GST_RTSP_HDR_KEYMGMT,
goto keymgmt_error;
}
+ if (sessmedia == NULL) {
+ /* manage the media in our session now, if not done already */
+ sessmedia = gst_rtsp_session_manage_media (session, path, media);
+ /* if we stil have no media, error */
+ if (sessmedia == NULL)
+ goto sessmedia_unavailable;
+
+ /* don't cache media anymore */
+ clean_cached_media (client, FALSE);
+ } else {
+ g_object_unref (media);
+ }
+
+ ctx->sessmedia = sessmedia;
+
+ /* update the client transport */
+ if (!klass->configure_client_transport (client, ctx, ct))
+ goto unsupported_client_transport;
+
/* set in the session media transport */
trans = gst_rtsp_session_media_set_transport (sessmedia, stream, ct);
+ ctx->trans = trans;
+
/* configure the url used to set this transport, this we will use when
* generating the response for the PLAY request */
gst_rtsp_stream_transport_set_url (trans, uri);
-
/* configure keepalive for this transport */
gst_rtsp_stream_transport_set_keepalive (trans,
(GstRTSPKeepAliveFunc) do_keepalive, session, NULL);
+ if (ct->lower_transport == GST_RTSP_LOWER_TRANS_TCP) {
+ /* our callbacks to send data on this TCP connection */
+ gst_rtsp_stream_transport_set_callbacks (trans,
+ (GstRTSPSendFunc) do_send_data,
+ (GstRTSPSendFunc) do_send_data, client, NULL);
+
+ g_hash_table_insert (priv->transports,
+ GINT_TO_POINTER (ct->interleaved.min), trans);
+ g_object_ref (trans);
+ g_hash_table_insert (priv->transports,
+ GINT_TO_POINTER (ct->interleaved.max), trans);
+ g_object_ref (trans);
+ }
+
/* create and serialize the server transport */
- st = make_server_transport (client, ctx, ct);
+ st = make_server_transport (client, media, ctx, ct);
trans_str = gst_rtsp_transport_as_text (st);
gst_rtsp_transport_free (st);
trans_str);
g_free (trans_str);
- send_message (client, session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
/* update the state */
rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
}
stream_not_found:
{
- GST_ERROR ("client %p: stream '%s' not found", client, control);
+ GST_ERROR ("client %p: stream '%s' not found", client,
+ GST_STR_NULL (control));
send_generic_response (client, GST_RTSP_STS_NOT_FOUND, ctx);
g_object_unref (media);
goto cleanup_path;
send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, ctx);
goto cleanup_transport;
}
+unsupported_mode:
+ {
+ GST_ERROR ("client %p: unsupported mode (media play: %d, media record: %d, "
+ "mode play: %d, mode record: %d)", client,
+ ! !(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_PLAY),
+ ! !(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_RECORD), ct->mode_play, ct->mode_record);
+ send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_TRANSPORT, ctx);
+ goto cleanup_transport;
+ }
keymgmt_error:
{
GST_ERROR ("client %p: keymgmt error", client);
cleanup_transport:
gst_rtsp_transport_free (ct);
cleanup_session:
+ if (new_session)
+ gst_rtsp_session_pool_remove (priv->session_pool, session);
g_object_unref (session);
cleanup_path:
g_free (path);
GstSDPMessage *sdp;
GstSDPInfo info;
const gchar *proto;
+ guint64 session_id_tmp;
+ gchar session_id[21];
gst_sdp_message_new (&sdp);
else
proto = "IP4";
- gst_sdp_message_set_origin (sdp, "-", "1188340656180883", "1", "IN", proto,
+ session_id_tmp = (((guint64) g_random_int ()) << 32) | g_random_int ();
+ g_snprintf (session_id, sizeof (session_id), "%" G_GUINT64_FORMAT,
+ session_id_tmp);
+
+ gst_sdp_message_set_origin (sdp, "-", session_id, "1", "IN", proto,
priv->server_ip);
gst_sdp_message_set_session_name (sdp, "Session streamed with GStreamer");
if (!(media = find_media (client, ctx, path, NULL)))
goto no_media;
+ if (!(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_PLAY))
+ goto unsupported_mode;
+
/* create an SDP for the media object on this client */
if (!(sdp = klass->create_sdp (client, media)))
goto no_sdp;
gst_rtsp_message_take_body (ctx->response, (guint8 *) str, strlen (str));
gst_sdp_message_free (sdp);
- send_message (client, ctx->session, ctx->response, FALSE);
+ send_message (client, ctx, ctx->response, FALSE);
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_DESCRIBE_REQUEST],
0, ctx);
/* error reply is already sent */
return FALSE;
}
+unsupported_mode:
+ {
+ GST_ERROR ("client %p: media does not support DESCRIBE", client);
+ send_generic_response (client, GST_RTSP_STS_METHOD_NOT_ALLOWED, ctx);
+ g_free (path);
+ g_object_unref (media);
+ return FALSE;
+ }
no_sdp:
{
GST_ERROR ("client %p: can't create SDP", client);
}
static gboolean
-handle_options_request (GstRTSPClient * client, GstRTSPContext * ctx)
+handle_sdp (GstRTSPClient * client, GstRTSPContext * ctx, GstRTSPMedia * media,
+ GstSDPMessage * sdp)
{
- GstRTSPMethod options;
- gchar *str;
-
- options = GST_RTSP_DESCRIBE |
- GST_RTSP_OPTIONS |
- GST_RTSP_PAUSE |
- GST_RTSP_PLAY |
- GST_RTSP_SETUP |
- GST_RTSP_GET_PARAMETER | GST_RTSP_SET_PARAMETER | GST_RTSP_TEARDOWN;
-
- str = gst_rtsp_options_as_text (options);
-
- gst_rtsp_message_init_response (ctx->response, GST_RTSP_STS_OK,
- gst_rtsp_status_as_text (GST_RTSP_STS_OK), ctx->request);
+ GstRTSPClientPrivate *priv = client->priv;
+ GstRTSPThread *thread;
- gst_rtsp_message_add_header (ctx->response, GST_RTSP_HDR_PUBLIC, str);
- g_free (str);
+ /* create an SDP for the media object */
+ if (!gst_rtsp_media_handle_sdp (media, sdp))
+ goto unhandled_sdp;
- send_message (client, ctx->session, ctx->response, FALSE);
+ thread = gst_rtsp_thread_pool_get_thread (priv->thread_pool,
+ GST_RTSP_THREAD_TYPE_MEDIA, ctx);
+ if (thread == NULL)
+ goto no_thread;
- g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST],
- 0, ctx);
+ /* prepare the media */
+ if (!gst_rtsp_media_prepare (media, thread))
+ goto no_prepare;
return TRUE;
-}
-
-/* remove duplicate and trailing '/' */
-static void
-sanitize_uri (GstRTSPUrl * uri)
-{
- gint i, len;
- gchar *s, *d;
- gboolean have_slash, prev_slash;
- s = d = uri->abspath;
- len = strlen (uri->abspath);
-
- prev_slash = FALSE;
+ /* ERRORS */
+unhandled_sdp:
+ {
+ GST_ERROR ("client %p: could not handle SDP", client);
+ return FALSE;
+ }
+no_thread:
+ {
+ GST_ERROR ("client %p: can't create thread", client);
+ return FALSE;
+ }
+no_prepare:
+ {
+ GST_ERROR ("client %p: can't prepare media", client);
+ return FALSE;
+ }
+}
+
+static gboolean
+handle_announce_request (GstRTSPClient * client, GstRTSPContext * ctx)
+{
+ GstRTSPClientPrivate *priv = client->priv;
+ GstRTSPClientClass *klass;
+ GstSDPResult sres;
+ GstSDPMessage *sdp;
+ GstRTSPMedia *media;
+ gchar *path, *cont = NULL;
+ guint8 *data;
+ guint size;
+
+ klass = GST_RTSP_CLIENT_GET_CLASS (client);
+
+ if (!ctx->uri)
+ goto no_uri;
+
+ if (!priv->mount_points)
+ goto no_mount_points;
+
+ /* check if reply is SDP */
+ gst_rtsp_message_get_header (ctx->request, GST_RTSP_HDR_CONTENT_TYPE, &cont,
+ 0);
+ /* could not be set but since the request returned OK, we assume it
+ * was SDP, else check it. */
+ if (cont) {
+ if (g_ascii_strcasecmp (cont, "application/sdp") != 0)
+ goto wrong_content_type;
+ }
+
+ /* get message body and parse as SDP */
+ gst_rtsp_message_get_body (ctx->request, &data, &size);
+ if (data == NULL || size == 0)
+ goto no_message;
+
+ GST_DEBUG ("client %p: parse SDP...", client);
+ gst_sdp_message_new (&sdp);
+ sres = gst_sdp_message_parse_buffer (data, size, sdp);
+ if (sres != GST_SDP_OK)
+ goto sdp_parse_failed;
+
+ if (!(path = gst_rtsp_mount_points_make_path (priv->mount_points, ctx->uri)))
+ goto no_path;
+
+ /* find the media object for the uri */
+ if (!(media = find_media (client, ctx, path, NULL)))
+ goto no_media;
+
+ if (!(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_RECORD))
+ goto unsupported_mode;
+
+ /* Tell client subclass about the media */
+ if (!klass->handle_sdp (client, ctx, media, sdp))
+ goto unhandled_sdp;
+
+ /* we suspend after the announce */
+ gst_rtsp_media_suspend (media);
+ g_object_unref (media);
+
+ gst_rtsp_message_init_response (ctx->response, GST_RTSP_STS_OK,
+ gst_rtsp_status_as_text (GST_RTSP_STS_OK), ctx->request);
+
+ send_message (client, ctx, ctx->response, FALSE);
+
+ g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_ANNOUNCE_REQUEST],
+ 0, ctx);
+
+ gst_sdp_message_free (sdp);
+ g_free (path);
+ return TRUE;
+
+no_uri:
+ {
+ GST_ERROR ("client %p: no uri", client);
+ send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, ctx);
+ return FALSE;
+ }
+no_mount_points:
+ {
+ GST_ERROR ("client %p: no mount points configured", client);
+ send_generic_response (client, GST_RTSP_STS_NOT_FOUND, ctx);
+ return FALSE;
+ }
+no_path:
+ {
+ GST_ERROR ("client %p: can't find path for url", client);
+ send_generic_response (client, GST_RTSP_STS_NOT_FOUND, ctx);
+ gst_sdp_message_free (sdp);
+ return FALSE;
+ }
+wrong_content_type:
+ {
+ GST_ERROR ("client %p: unknown content type", client);
+ send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, ctx);
+ return FALSE;
+ }
+no_message:
+ {
+ GST_ERROR ("client %p: can't find SDP message", client);
+ send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, ctx);
+ return FALSE;
+ }
+sdp_parse_failed:
+ {
+ GST_ERROR ("client %p: failed to parse SDP message", client);
+ send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, ctx);
+ gst_sdp_message_free (sdp);
+ return FALSE;
+ }
+no_media:
+ {
+ GST_ERROR ("client %p: no media", client);
+ g_free (path);
+ /* error reply is already sent */
+ gst_sdp_message_free (sdp);
+ return FALSE;
+ }
+unsupported_mode:
+ {
+ GST_ERROR ("client %p: media does not support ANNOUNCE", client);
+ send_generic_response (client, GST_RTSP_STS_METHOD_NOT_ALLOWED, ctx);
+ g_free (path);
+ g_object_unref (media);
+ gst_sdp_message_free (sdp);
+ return FALSE;
+ }
+unhandled_sdp:
+ {
+ GST_ERROR ("client %p: can't handle SDP", client);
+ send_generic_response (client, GST_RTSP_STS_UNSUPPORTED_MEDIA_TYPE, ctx);
+ g_free (path);
+ g_object_unref (media);
+ gst_sdp_message_free (sdp);
+ return FALSE;
+ }
+}
+
+static gboolean
+handle_record_request (GstRTSPClient * client, GstRTSPContext * ctx)
+{
+ GstRTSPSession *session;
+ GstRTSPClientClass *klass;
+ GstRTSPSessionMedia *sessmedia;
+ GstRTSPMedia *media;
+ GstRTSPUrl *uri;
+ GstRTSPState rtspstate;
+ gchar *path;
+ gint matched;
+
+ if (!(session = ctx->session))
+ goto no_session;
+
+ if (!(uri = ctx->uri))
+ goto no_uri;
+
+ klass = GST_RTSP_CLIENT_GET_CLASS (client);
+ path = klass->make_path_from_uri (client, uri);
+
+ /* get a handle to the configuration of the media in the session */
+ sessmedia = gst_rtsp_session_get_media (session, path, &matched);
+ if (!sessmedia)
+ goto not_found;
+
+ if (path[matched] != '\0')
+ goto no_aggregate;
+
+ g_free (path);
+
+ ctx->sessmedia = sessmedia;
+ ctx->media = media = gst_rtsp_session_media_get_media (sessmedia);
+
+ if (!(gst_rtsp_media_get_transport_mode (media) &
+ GST_RTSP_TRANSPORT_MODE_RECORD))
+ goto unsupported_mode;
+
+ /* the session state must be playing or ready */
+ rtspstate = gst_rtsp_session_media_get_rtsp_state (sessmedia);
+ if (rtspstate != GST_RTSP_STATE_PLAYING && rtspstate != GST_RTSP_STATE_READY)
+ goto invalid_state;
+
+ /* in play we first unsuspend, media could be suspended from SDP or PAUSED */
+ if (!gst_rtsp_media_unsuspend (media))
+ goto unsuspend_failed;
+
+ gst_rtsp_message_init_response (ctx->response, GST_RTSP_STS_OK,
+ gst_rtsp_status_as_text (GST_RTSP_STS_OK), ctx->request);
+
+ send_message (client, ctx, ctx->response, FALSE);
+
+ /* start playing after sending the response */
+ gst_rtsp_session_media_set_state (sessmedia, GST_STATE_PLAYING);
+
+ gst_rtsp_session_media_set_rtsp_state (sessmedia, GST_RTSP_STATE_PLAYING);
+
+ g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_RECORD_REQUEST], 0,
+ ctx);
+
+ return TRUE;
+
+ /* ERRORS */
+no_session:
+ {
+ GST_ERROR ("client %p: no session", client);
+ send_generic_response (client, GST_RTSP_STS_SESSION_NOT_FOUND, ctx);
+ return FALSE;
+ }
+no_uri:
+ {
+ GST_ERROR ("client %p: no uri supplied", client);
+ send_generic_response (client, GST_RTSP_STS_BAD_REQUEST, ctx);
+ return FALSE;
+ }
+not_found:
+ {
+ GST_ERROR ("client %p: media not found", client);
+ send_generic_response (client, GST_RTSP_STS_NOT_FOUND, ctx);
+ return FALSE;
+ }
+no_aggregate:
+ {
+ GST_ERROR ("client %p: no aggregate path %s", client, path);
+ send_generic_response (client,
+ GST_RTSP_STS_ONLY_AGGREGATE_OPERATION_ALLOWED, ctx);
+ g_free (path);
+ return FALSE;
+ }
+unsupported_mode:
+ {
+ GST_ERROR ("client %p: media does not support RECORD", client);
+ send_generic_response (client, GST_RTSP_STS_METHOD_NOT_ALLOWED, ctx);
+ return FALSE;
+ }
+invalid_state:
+ {
+ GST_ERROR ("client %p: not PLAYING or READY", client);
+ send_generic_response (client, GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE,
+ ctx);
+ return FALSE;
+ }
+unsuspend_failed:
+ {
+ GST_ERROR ("client %p: unsuspend failed", client);
+ send_generic_response (client, GST_RTSP_STS_SERVICE_UNAVAILABLE, ctx);
+ return FALSE;
+ }
+}
+
+static gboolean
+handle_options_request (GstRTSPClient * client, GstRTSPContext * ctx)
+{
+ GstRTSPMethod options;
+ gchar *str;
+
+ options = GST_RTSP_DESCRIBE |
+ GST_RTSP_OPTIONS |
+ GST_RTSP_PAUSE |
+ GST_RTSP_PLAY |
+ GST_RTSP_SETUP |
+ GST_RTSP_GET_PARAMETER | GST_RTSP_SET_PARAMETER | GST_RTSP_TEARDOWN;
+
+ str = gst_rtsp_options_as_text (options);
+
+ gst_rtsp_message_init_response (ctx->response, GST_RTSP_STS_OK,
+ gst_rtsp_status_as_text (GST_RTSP_STS_OK), ctx->request);
+
+ gst_rtsp_message_add_header (ctx->response, GST_RTSP_HDR_PUBLIC, str);
+ g_free (str);
+
+ send_message (client, ctx, ctx->response, FALSE);
+
+ g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_OPTIONS_REQUEST],
+ 0, ctx);
+
+ return TRUE;
+}
+
+/* remove duplicate and trailing '/' */
+static void
+sanitize_uri (GstRTSPUrl * uri)
+{
+ gint i, len;
+ gchar *s, *d;
+ gboolean have_slash, prev_slash;
+
+ s = d = uri->abspath;
+ len = strlen (uri->abspath);
+
+ prev_slash = FALSE;
for (i = 0; i < len; i++) {
have_slash = s[i] == '/';
*d = '\0';
}
+/* is called when the session is removed from its session pool. */
static void
-client_session_finalized (GstRTSPClient * client, GstRTSPSession * session)
+client_session_removed (GstRTSPSessionPool * pool, GstRTSPSession * session,
+ GstRTSPClient * client)
{
GstRTSPClientPrivate *priv = client->priv;
- GST_INFO ("client %p: session %p finished", client, session);
+ GST_INFO ("client %p: session %p removed", client, session);
- /* unlink all media managed in this session */
- client_unlink_session (client, session);
+ g_mutex_lock (&priv->lock);
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, 0);
+ client_unwatch_session (client, session, NULL);
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, WATCH_BACKLOG_SIZE);
+ g_mutex_unlock (&priv->lock);
+}
- /* remove the session */
- if (!(priv->sessions = g_list_remove (priv->sessions, session))) {
- GST_INFO ("client %p: all sessions finalized, close the connection",
- client);
- close_connection (client);
+/* Returns TRUE if there are no Require headers, otherwise returns FALSE
+ * and also returns a newly-allocated string of (comma-separated) unsupported
+ * options in the unsupported_reqs variable .
+ *
+ * There may be multiple Require headers, but we must send one single
+ * Unsupported header with all the unsupported options as response. If
+ * an incoming Require header contained a comma-separated list of options
+ * GstRtspConnection will already have split that list up into multiple
+ * headers.
+ *
+ * TODO: allow the application to decide what features are supported
+ */
+static gboolean
+check_request_requirements (GstRTSPMessage * msg, gchar ** unsupported_reqs)
+{
+ GstRTSPResult res;
+ GPtrArray *arr = NULL;
+ gchar *reqs = NULL;
+ gint i;
+
+ i = 0;
+ do {
+ res = gst_rtsp_message_get_header (msg, GST_RTSP_HDR_REQUIRE, &reqs, i++);
+
+ if (res == GST_RTSP_ENOTIMPL)
+ break;
+
+ if (arr == NULL)
+ arr = g_ptr_array_new_with_free_func ((GDestroyNotify) g_free);
+
+ g_ptr_array_add (arr, g_strdup (reqs));
}
+ while (TRUE);
+
+ /* if we don't have any Require headers at all, all is fine */
+ if (i == 1)
+ return TRUE;
+
+ /* otherwise we've now processed at all the Require headers */
+ g_ptr_array_add (arr, NULL);
+
+ /* for now we don't commit to supporting anything, so will just report
+ * all of the required options as unsupported */
+ *unsupported_reqs = g_strjoinv (", ", (gchar **) arr->pdata);
+
+ g_ptr_array_unref (arr);
+ return FALSE;
}
static void
GstRTSPSession *session = NULL;
GstRTSPContext sctx = { NULL }, *ctx;
GstRTSPMessage response = { 0 };
+ gchar *unsupported_reqs = NULL;
gchar *sessid;
if (!(ctx = gst_rtsp_context_get_current ())) {
if (!gst_rtsp_auth_check (GST_RTSP_AUTH_CHECK_URL))
goto not_authorized;
+ /* handle any 'Require' headers */
+ if (!check_request_requirements (ctx->request, &unsupported_reqs))
+ goto unsupported_requirement;
+
+ /* the backlog must be unlimited while processing requests.
+ * the causes of this are two cases of deadlocks while streaming over TCP:
+ *
+ * 1. consider the scenario where the media pipeline's streaming thread
+ * is blocking in the appsink (taking the appsink's preroll lock) because
+ * the backlog is full. when a PAUSE request is received by the RTSP
+ * client thread then the the state of the session media ought to change
+ * to PAUSED. while most elements in the pipeline can change state this
+ * can never happen for the appsink since its preroll lock is taken by
+ * another thread.
+ *
+ * 2. consider the scenario where the media pipeline's streaming thread
+ * is blocking in the appsink new_sample callback (taking the send lock
+ * in RTSP client) because the backlog is full. when e.g. a GET request
+ * is received by the RTSP client thread then a response ought to be sent
+ * but this can never happen since it requires taking the send lock
+ * already taken by another thread.
+ *
+ * the reason that the backlog is never emptied is that the source used
+ * for dequeing messages from the backlog is never dispatched because it
+ * is attached to the same mainloop as the source receving RTSP requests and
+ * therefore run by the RTSP client thread which is alreayd blocking.
+ *
+ * without significant changes the easiest way to cope with this is to
+ * not block indefinitely when the backlog is full, but rather let the
+ * backlog grow in size. this in effect means that there can not be any
+ * upper boundary on its size.
+ */
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, 0);
+
/* now see what is asked and dispatch to a dedicated handler */
switch (method) {
case GST_RTSP_OPTIONS:
handle_get_param_request (client, ctx);
break;
case GST_RTSP_ANNOUNCE:
+ handle_announce_request (client, ctx);
+ break;
case GST_RTSP_RECORD:
+ handle_record_request (client, ctx);
+ break;
case GST_RTSP_REDIRECT:
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, WATCH_BACKLOG_SIZE);
goto not_implemented;
case GST_RTSP_INVALID:
default:
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, WATCH_BACKLOG_SIZE);
goto bad_request;
}
+ if (priv->watch != NULL)
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, WATCH_BACKLOG_SIZE);
+
done:
if (ctx == &sctx)
gst_rtsp_context_pop_current (ctx);
/* error reply is already sent */
goto done;
}
+unsupported_requirement:
+ {
+ GST_ERROR ("client %p: Required option is not supported (%s)", client,
+ unsupported_reqs);
+ send_option_not_supported_response (client, ctx, unsupported_reqs);
+ g_free (unsupported_reqs);
+ goto done;
+ }
not_implemented:
{
GST_ERROR ("client %p: method %d not implemented", client, method);
GstRTSPClientPrivate *priv = client->priv;
GstRTSPResult res;
guint8 channel;
- GList *walk;
guint8 *data;
guint size;
GstBuffer *buffer;
- gboolean handled;
+ GstRTSPStreamTransport *trans;
/* find the stream for this message */
res = gst_rtsp_message_parse_data (message, &channel);
if (res != GST_RTSP_OK)
return;
+ gst_rtsp_message_get_body (message, &data, &size);
+ if (size < 2)
+ goto invalid_length;
+
gst_rtsp_message_steal_body (message, &data, &size);
- buffer = gst_buffer_new_wrapped (data, size);
+ /* Strip trailing \0 (which GstRTSPConnection adds) */
+ --size;
- handled = FALSE;
- for (walk = priv->transports; walk; walk = g_list_next (walk)) {
- GstRTSPStreamTransport *trans;
- GstRTSPStream *stream;
- const GstRTSPTransport *tr;
+ buffer = gst_buffer_new_wrapped (data, size);
- trans = walk->data;
+ trans =
+ g_hash_table_lookup (priv->transports, GINT_TO_POINTER ((gint) channel));
+ if (trans) {
+ /* dispatch to the stream based on the channel number */
+ GST_LOG_OBJECT (client, "%u bytes of data on channel %u", size, channel);
+ gst_rtsp_stream_transport_recv_data (trans, channel, buffer);
+ } else {
+ GST_DEBUG_OBJECT (client, "received %u bytes of data for "
+ "unknown channel %u", size, channel);
+ gst_buffer_unref (buffer);
+ }
- tr = gst_rtsp_stream_transport_get_transport (trans);
- stream = gst_rtsp_stream_transport_get_stream (trans);
+ return;
- /* 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_stream_recv_rtp (stream, buffer);
- handled = TRUE;
- break;
- } else if (tr->interleaved.max == channel) {
- gst_rtsp_stream_recv_rtcp (stream, buffer);
- handled = TRUE;
- break;
- }
- }
+/* ERRORS */
+invalid_length:
+ {
+ GST_DEBUG ("client %p: Short message received, ignoring", client);
+ return;
}
- if (!handled)
- gst_buffer_unref (buffer);
}
/**
g_mutex_lock (&priv->lock);
old = priv->session_pool;
priv->session_pool = pool;
+
+ if (priv->session_removed_id) {
+ g_signal_handler_disconnect (old, priv->session_removed_id);
+ priv->session_removed_id = 0;
+ }
g_mutex_unlock (&priv->lock);
+ /* FIXME, should remove all sessions from the old pool for this client */
if (old)
g_object_unref (old);
}
/**
* gst_rtsp_client_send_message:
* @client: a #GstRTSPClient
- * @session: (transfer none): a #GstRTSPSession to send the message to or %NULL
+ * @session: (allow-none) (transfer none): a #GstRTSPSession to send
+ * the message to or %NULL
* @message: (transfer none): The #GstRTSPMessage to send
*
* Send a message message to the remote end. @message must be a
gst_rtsp_client_send_message (GstRTSPClient * client, GstRTSPSession * session,
GstRTSPMessage * message)
{
+ GstRTSPContext sctx = { NULL }
+ , *ctx;
+ GstRTSPClientPrivate *priv;
+
g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), GST_RTSP_EINVAL);
g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
g_return_val_if_fail (message->type == GST_RTSP_MESSAGE_REQUEST ||
message->type == GST_RTSP_MESSAGE_RESPONSE, GST_RTSP_EINVAL);
- send_message (client, session, message, FALSE);
+ priv = client->priv;
+
+ if (!(ctx = gst_rtsp_context_get_current ())) {
+ ctx = &sctx;
+ ctx->auth = priv->auth;
+ gst_rtsp_context_push_current (ctx);
+ }
+
+ ctx->conn = priv->connection;
+ ctx->client = client;
+ ctx->session = session;
+
+ send_message (client, ctx, message, FALSE);
+
+ if (ctx == &sctx)
+ gst_rtsp_context_pop_current (ctx);
return GST_RTSP_OK;
}
GstRTSPClientPrivate *priv = client->priv;
if (priv->close_seq && priv->close_seq == cseq) {
+ GST_INFO ("client %p: send close message", client);
priv->close_seq = 0;
- close_connection (client);
+ gst_rtsp_client_close (client);
}
return GST_RTSP_OK;
}
gst_rtsp_watch_set_flushing (watch, TRUE);
+ g_mutex_lock (&priv->watch_lock);
gst_rtsp_client_set_send_func (client, NULL, NULL, NULL);
+ g_mutex_unlock (&priv->watch_lock);
return GST_RTSP_OK;
}
opriv = oclient->priv;
+ g_mutex_lock (&opriv->watch_lock);
if (opriv->watch == NULL)
goto tunnel_closed;
gst_rtsp_connection_do_tunnel (opriv->connection, priv->connection);
gst_rtsp_watch_reset (priv->watch);
gst_rtsp_watch_reset (opriv->watch);
+ g_mutex_unlock (&opriv->watch_lock);
g_object_unref (oclient);
/* the old client owns the tunnel now, the new one will be freed */
tunnel_closed:
{
GST_ERROR ("client %p: tunnel session %s was closed", client, tunnelid);
+ g_mutex_unlock (&opriv->watch_lock);
g_object_unref (oclient);
return FALSE;
}
GST_INFO ("client %p: watch destroyed", client);
priv->watch = NULL;
+ /* remove all sessions and so drop the extra client ref */
+ gst_rtsp_client_session_filter (client, cleanup_session, NULL);
g_signal_emit (client, gst_rtsp_client_signals[SIGNAL_CLOSED], 0, NULL);
g_object_unref (client);
}
g_return_val_if_fail (priv->connection != NULL, 0);
g_return_val_if_fail (priv->watch == NULL, 0);
+ /* make sure noone will free the context before the watch is destroyed */
+ priv->watch_context = g_main_context_ref (context);
+
/* create watch for the connection and attach */
priv->watch = gst_rtsp_watch_new (priv->connection, &watch_funcs,
g_object_ref (client), (GDestroyNotify) client_watch_notify);
gst_rtsp_client_set_send_func (client, do_send_message, priv->watch,
(GDestroyNotify) gst_rtsp_watch_unref);
- /* FIXME make this configurable. We don't want to do this yet because it will
- * be superceeded by a cache object later */
- gst_rtsp_watch_set_send_backlog (priv->watch, 0, 100);
+ gst_rtsp_watch_set_send_backlog (priv->watch, 0, WATCH_BACKLOG_SIZE);
- GST_INFO ("attaching to context %p", context);
+ GST_INFO ("client %p: attaching to context %p", client, context);
res = gst_rtsp_watch_attach (priv->watch, context);
return res;
{
GstRTSPClientPrivate *priv;
GList *result, *walk, *next;
+ GHashTable *visited;
+ guint cookie;
g_return_val_if_fail (GST_IS_RTSP_CLIENT (client), NULL);
priv = client->priv;
result = NULL;
+ if (func)
+ visited = g_hash_table_new_full (NULL, NULL, g_object_unref, NULL);
g_mutex_lock (&priv->lock);
+restart:
+ cookie = priv->sessions_cookie;
for (walk = priv->sessions; walk; walk = next) {
GstRTSPSession *sess = walk->data;
GstRTSPFilterResult res;
+ gboolean changed;
next = g_list_next (walk);
- if (func)
+ if (func) {
+ /* only visit each session once */
+ if (g_hash_table_contains (visited, sess))
+ continue;
+
+ g_hash_table_add (visited, g_object_ref (sess));
+ g_mutex_unlock (&priv->lock);
+
res = func (client, sess, user_data);
- else
+
+ g_mutex_lock (&priv->lock);
+ } else
res = GST_RTSP_FILTER_REF;
+ changed = (cookie != priv->sessions_cookie);
+
switch (res) {
case GST_RTSP_FILTER_REMOVE:
- /* stop watching the session and pretent it went away */
- client_cleanup_session (client, sess);
+ /* stop watching the session and pretend it went away, if the list was
+ * changed, we can't use the current list position, try to see if we
+ * still have the session */
+ client_unwatch_session (client, sess, changed ? NULL : walk);
+ cookie = priv->sessions_cookie;
break;
case GST_RTSP_FILTER_REF:
result = g_list_prepend (result, g_object_ref (sess));
default:
break;
}
+ if (changed)
+ goto restart;
}
g_mutex_unlock (&priv->lock);
+ if (func)
+ g_hash_table_unref (visited);
+
return result;
}
projects / platform / upstream / gstreamer.git / blobdiff