/* 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
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 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,
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_SEND_MESSAGE] =
g_signal_new ("send-message", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
+ 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 (&tunnels_lock);
g_mutex_init (&priv->watch_lock);
priv->close_seq = 0;
priv->drop_backlog = DEFAULT_DROP_BACKLOG;
- priv->transports = g_hash_table_new (g_direct_hash, g_direct_equal);
+ priv->transports =
+ g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
+ g_object_unref);
}
static GstRTSPFilterResult
return GST_RTSP_FILTER_REMOVE;
}
+static void
+clean_cached_media (GstRTSPClient * client, gboolean unprepare)
+{
+ GstRTSPClientPrivate *priv = client->priv;
+
+ 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;
+ }
+}
+
/* A client is finalized when the connection is broken */
static void
gst_rtsp_client_finalize (GObject * obj)
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);
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;
- /* prepare the media */
- if (!(gst_rtsp_media_prepare (media, thread)))
- goto no_prepare;
+ 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;
+ }
/* now keep track of the uri and the media */
priv->path = g_strndup (path, path_len);
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 */
- if (priv->watch != NULL)
- gst_rtsp_watch_set_flushing (priv->watch, TRUE);
-
gst_rtsp_session_media_set_state (sessmedia, GST_STATE_NULL);
- /* allow messages again so that we can send the reply */
- if (priv->watch != NULL)
- gst_rtsp_watch_set_flushing (priv->watch, FALSE);
-
/* unmanage the media in the session, returns false if all media session
* are torn down. */
keep_session = gst_rtsp_session_release_media (session, sessmedia);
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;
}
}
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
}
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;
}
- 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;
}
gst_caps_unref (caps);
}
gst_mikey_message_unref (msg);
+ gst_buffer_unref (key);
return TRUE;
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 (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;
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,
/* 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);
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);
}
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);
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;
/* 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_sdp (GstRTSPClient * client, GstRTSPContext * ctx, GstRTSPMedia * media,
+ GstSDPMessage * sdp)
+{
+ GstRTSPClientPrivate *priv = client->priv;
+ GstRTSPThread *thread;
+
+ /* create an SDP for the media object */
+ if (!gst_rtsp_media_handle_sdp (media, sdp))
+ goto unhandled_sdp;
+
+ 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;
+
+ return TRUE;
+
+ /* 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;
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);
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);
+ /* Strip trailing \0 (which GstRTSPConnection adds) */
+ --size;
+
buffer = gst_buffer_new_wrapped (data, size);
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);
}
+
+ return;
+
+/* ERRORS */
+invalid_length:
+ {
+ GST_DEBUG ("client %p: Short message received, ignoring", client);
+ return;
+ }
}
/**