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