tests/check/gst/rtspserver.c

   1 /* GStreamer unit test for GstRTSPServer
   2  * Copyright (C) 2012 Axis Communications <dev-gstreamer at axis dot com>
   3  *   @author David Svensson Fors <davidsf at axis dot com>
   4  * Copyright (C) 2015 Centricular Ltd
   5  *   @author Tim-Philipp Müller <tim@centricular.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include <gst/check/gstcheck.h>
  24 #include <gst/sdp/gstsdpmessage.h>
  25 #include <gst/rtp/gstrtpbuffer.h>
  26 #include <gst/rtp/gstrtcpbuffer.h>
  27
  28 #include <stdio.h>
  29 #include <netinet/in.h>
  30
  31 #include "rtsp-server.h"
  32
  33 #define ERRORIGNORE "errorignore ignore-error=false ignore-notlinked=true " \
  34   "ignore-notnegotiated=false convert-to=ok"
  35 #define VIDEO_PIPELINE "videotestsrc ! " \
  36   ERRORIGNORE " ! " \
  37   "video/x-raw,width=352,height=288 ! " \
  38   "rtpgstpay name=pay0 pt=96"
  39 #define AUDIO_PIPELINE "audiotestsrc ! " \
  40   ERRORIGNORE " ! " \
  41   "audio/x-raw,rate=8000 ! " \
  42   "rtpgstpay name=pay1 pt=97"
  43
  44 #define TEST_MOUNT_POINT  "/test"
  45 #define TEST_PROTO        "RTP/AVP"
  46 #define TEST_ENCODING     "X-GST"
  47 #define TEST_CLOCK_RATE   "90000"
  48
  49 /* tested rtsp server */
  50 static GstRTSPServer *server = NULL;
  51
  52 /* tcp port that the test server listens for rtsp requests on */
  53 static gint test_port = 0;
  54
  55 /* id of the server's source within the GMainContext */
  56 static guint source_id;
  57
  58 /* iterate the default main loop until there are no events to dispatch */
  59 static void
  60 iterate (void)
  61 {
  62   while (g_main_context_iteration (NULL, FALSE)) {
  63     GST_DEBUG ("iteration");
  64   }
  65 }
  66
  67 static void
  68 get_client_ports_full (GstRTSPRange * range, GSocket ** rtp_socket,
  69     GSocket ** rtcp_socket)
  70 {
  71   GSocket *rtp = NULL;
  72   GSocket *rtcp = NULL;
  73   gint rtp_port = 0;
  74   gint rtcp_port;
  75   GInetAddress *anyaddr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
  76   GSocketAddress *sockaddr;
  77   gboolean bound;
  78
  79   for (;;) {
  80     if (rtp_port != 0)
  81       rtp_port += 2;
  82
  83     rtp = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
  84         G_SOCKET_PROTOCOL_UDP, NULL);
  85     fail_unless (rtp != NULL);
  86
  87     sockaddr = g_inet_socket_address_new (anyaddr, rtp_port);
  88     fail_unless (sockaddr != NULL);
  89     bound = g_socket_bind (rtp, sockaddr, FALSE, NULL);
  90     g_object_unref (sockaddr);
  91     if (!bound) {
  92       g_object_unref (rtp);
  93       continue;
  94     }
  95
  96     sockaddr = g_socket_get_local_address (rtp, NULL);
  97     fail_unless (sockaddr != NULL && G_IS_INET_SOCKET_ADDRESS (sockaddr));
  98     rtp_port =
  99         g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (sockaddr));
 100     g_object_unref (sockaddr);
 101
 102     if (rtp_port % 2 != 0) {
 103       rtp_port += 1;
 104       g_object_unref (rtp);
 105       continue;
 106     }
 107
 108     rtcp_port = rtp_port + 1;
 109
 110     rtcp = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
 111         G_SOCKET_PROTOCOL_UDP, NULL);
 112     fail_unless (rtcp != NULL);
 113
 114     sockaddr = g_inet_socket_address_new (anyaddr, rtcp_port);
 115     fail_unless (sockaddr != NULL);
 116     bound = g_socket_bind (rtcp, sockaddr, FALSE, NULL);
 117     g_object_unref (sockaddr);
 118     if (!bound) {
 119       g_object_unref (rtp);
 120       g_object_unref (rtcp);
 121       continue;
 122     }
 123
 124     sockaddr = g_socket_get_local_address (rtcp, NULL);
 125     fail_unless (sockaddr != NULL && G_IS_INET_SOCKET_ADDRESS (sockaddr));
 126     fail_unless (rtcp_port ==
 127         g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (sockaddr)));
 128     g_object_unref (sockaddr);
 129
 130     break;
 131   }
 132
 133   range->min = rtp_port;
 134   range->max = rtcp_port;
 135   if (rtp_socket)
 136     *rtp_socket = rtp;
 137   else
 138     g_object_unref (rtp);
 139   if (rtcp_socket)
 140     *rtcp_socket = rtcp;
 141   else
 142     g_object_unref (rtcp);
 143   GST_DEBUG ("client_port=%d-%d", range->min, range->max);
 144   g_object_unref (anyaddr);
 145 }
 146
 147 /* get a free rtp/rtcp client port pair */
 148 static void
 149 get_client_ports (GstRTSPRange * range)
 150 {
 151   get_client_ports_full (range, NULL, NULL);
 152 }
 153
 154 /* start the tested rtsp server */
 155 static void
 156 start_server (gboolean set_shared_factory)
 157 {
 158   GstRTSPMountPoints *mounts;
 159   gchar *service;
 160   GstRTSPMediaFactory *factory;
 161   GstRTSPAddressPool *pool;
 162
 163   mounts = gst_rtsp_server_get_mount_points (server);
 164
 165   factory = gst_rtsp_media_factory_new ();
 166
 167   gst_rtsp_media_factory_set_launch (factory,
 168       "( " VIDEO_PIPELINE "  " AUDIO_PIPELINE " )");
 169   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
 170   g_object_unref (mounts);
 171
 172   /* use an address pool for multicast */
 173   pool = gst_rtsp_address_pool_new ();
 174   gst_rtsp_address_pool_add_range (pool,
 175       "224.3.0.0", "224.3.0.10", 5500, 5510, 16);
 176   gst_rtsp_address_pool_add_range (pool, GST_RTSP_ADDRESS_POOL_ANY_IPV4,
 177       GST_RTSP_ADDRESS_POOL_ANY_IPV4, 6000, 6010, 0);
 178   gst_rtsp_media_factory_set_address_pool (factory, pool);
 179   gst_rtsp_media_factory_set_shared (factory, set_shared_factory);
 180   gst_object_unref (pool);
 181
 182   /* set port to any */
 183   gst_rtsp_server_set_service (server, "0");
 184
 185   /* attach to default main context */
 186   source_id = gst_rtsp_server_attach (server, NULL);
 187   fail_if (source_id == 0);
 188
 189   /* get port */
 190   service = gst_rtsp_server_get_service (server);
 191   test_port = atoi (service);
 192   fail_unless (test_port != 0);
 193   g_free (service);
 194
 195   GST_DEBUG ("rtsp server listening on port %d", test_port);
 196 }
 197
 198 static void
 199 start_tcp_server (gboolean set_shared_factory)
 200 {
 201   GstRTSPMountPoints *mounts;
 202   gchar *service;
 203   GstRTSPMediaFactory *factory;
 204
 205   mounts = gst_rtsp_server_get_mount_points (server);
 206
 207   factory = gst_rtsp_media_factory_new ();
 208
 209   gst_rtsp_media_factory_set_protocols (factory, GST_RTSP_LOWER_TRANS_TCP);
 210   gst_rtsp_media_factory_set_launch (factory,
 211       "( " VIDEO_PIPELINE "  " AUDIO_PIPELINE " )");
 212   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
 213   gst_rtsp_media_factory_set_shared (factory, set_shared_factory);
 214   g_object_unref (mounts);
 215
 216   /* set port to any */
 217   gst_rtsp_server_set_service (server, "0");
 218
 219   /* attach to default main context */
 220   source_id = gst_rtsp_server_attach (server, NULL);
 221   fail_if (source_id == 0);
 222
 223   /* get port */
 224   service = gst_rtsp_server_get_service (server);
 225   test_port = atoi (service);
 226   fail_unless (test_port != 0);
 227   g_free (service);
 228
 229   GST_DEBUG ("rtsp server listening on port %d", test_port);
 230
 231 }
 232
 233 /* start the testing rtsp server for RECORD mode */
 234 static GstRTSPMediaFactory *
 235 start_record_server (const gchar * launch_line)
 236 {
 237   GstRTSPMediaFactory *factory;
 238   GstRTSPMountPoints *mounts;
 239   gchar *service;
 240
 241   mounts = gst_rtsp_server_get_mount_points (server);
 242
 243   factory = gst_rtsp_media_factory_new ();
 244
 245   gst_rtsp_media_factory_set_transport_mode (factory,
 246       GST_RTSP_TRANSPORT_MODE_RECORD);
 247   gst_rtsp_media_factory_set_launch (factory, launch_line);
 248   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
 249   g_object_unref (mounts);
 250
 251   /* set port to any */
 252   gst_rtsp_server_set_service (server, "0");
 253
 254   /* attach to default main context */
 255   source_id = gst_rtsp_server_attach (server, NULL);
 256   fail_if (source_id == 0);
 257
 258   /* get port */
 259   service = gst_rtsp_server_get_service (server);
 260   test_port = atoi (service);
 261   fail_unless (test_port != 0);
 262   g_free (service);
 263
 264   GST_DEBUG ("rtsp server listening on port %d", test_port);
 265   return factory;
 266 }
 267
 268 /* stop the tested rtsp server */
 269 static void
 270 stop_server (void)
 271 {
 272   g_source_remove (source_id);
 273   source_id = 0;
 274
 275   GST_DEBUG ("rtsp server stopped");
 276 }
 277
 278 /* create an rtsp connection to the server on test_port */
 279 static GstRTSPConnection *
 280 connect_to_server (gint port, const gchar * mount_point)
 281 {
 282   GstRTSPConnection *conn = NULL;
 283   gchar *address;
 284   gchar *uri_string;
 285   GstRTSPUrl *url = NULL;
 286
 287   address = gst_rtsp_server_get_address (server);
 288   uri_string = g_strdup_printf ("rtsp://%s:%d%s", address, port, mount_point);
 289   g_free (address);
 290   fail_unless (gst_rtsp_url_parse (uri_string, &url) == GST_RTSP_OK);
 291   g_free (uri_string);
 292
 293   fail_unless (gst_rtsp_connection_create (url, &conn) == GST_RTSP_OK);
 294   gst_rtsp_url_free (url);
 295
 296   fail_unless (gst_rtsp_connection_connect (conn, NULL) == GST_RTSP_OK);
 297
 298   return conn;
 299 }
 300
 301 /* create an rtsp request */
 302 static GstRTSPMessage *
 303 create_request (GstRTSPConnection * conn, GstRTSPMethod method,
 304     const gchar * control)
 305 {
 306   GstRTSPMessage *request = NULL;
 307   gchar *base_uri;
 308   gchar *full_uri;
 309
 310   base_uri = gst_rtsp_url_get_request_uri (gst_rtsp_connection_get_url (conn));
 311   full_uri = g_strdup_printf ("%s/%s", base_uri, control ? control : "");
 312   g_free (base_uri);
 313   if (gst_rtsp_message_new_request (&request, method, full_uri) != GST_RTSP_OK) {
 314     GST_DEBUG ("failed to create request object");
 315     g_free (full_uri);
 316     return NULL;
 317   }
 318   g_free (full_uri);
 319   return request;
 320 }
 321
 322 /* send an rtsp request */
 323 static gboolean
 324 send_request (GstRTSPConnection * conn, GstRTSPMessage * request)
 325 {
 326   if (gst_rtsp_connection_send (conn, request, NULL) != GST_RTSP_OK) {
 327     GST_DEBUG ("failed to send request");
 328     return FALSE;
 329   }
 330   return TRUE;
 331 }
 332
 333 /* read rtsp response. response must be freed by the caller */
 334 static GstRTSPMessage *
 335 read_response (GstRTSPConnection * conn)
 336 {
 337   GstRTSPMessage *response = NULL;
 338   GstRTSPMsgType type;
 339
 340   if (gst_rtsp_message_new (&response) != GST_RTSP_OK) {
 341     GST_DEBUG ("failed to create response object");
 342     return NULL;
 343   }
 344   if (gst_rtsp_connection_receive (conn, response, NULL) != GST_RTSP_OK) {
 345     GST_DEBUG ("failed to read response");
 346     gst_rtsp_message_free (response);
 347     return NULL;
 348   }
 349   type = gst_rtsp_message_get_type (response);
 350   fail_unless (type == GST_RTSP_MESSAGE_RESPONSE
 351       || type == GST_RTSP_MESSAGE_DATA);
 352   return response;
 353 }
 354
 355 /* send an rtsp request and receive response. gchar** parameters are out
 356  * parameters that have to be freed by the caller */
 357 static GstRTSPStatusCode
 358 do_request_full (GstRTSPConnection * conn, GstRTSPMethod method,
 359     const gchar * control, const gchar * session_in, const gchar * transport_in,
 360     const gchar * range_in, const gchar * require_in,
 361     gchar ** content_type, gchar ** content_base, gchar ** body,
 362     gchar ** session_out, gchar ** transport_out, gchar ** range_out,
 363     gchar ** unsupported_out)
 364 {
 365   GstRTSPMessage *request;
 366   GstRTSPMessage *response;
 367   GstRTSPStatusCode code;
 368   gchar *value;
 369   GstRTSPMsgType msg_type;
 370
 371   /* create request */
 372   request = create_request (conn, method, control);
 373
 374   /* add headers */
 375   if (session_in) {
 376     gst_rtsp_message_add_header (request, GST_RTSP_HDR_SESSION, session_in);
 377   }
 378   if (transport_in) {
 379     gst_rtsp_message_add_header (request, GST_RTSP_HDR_TRANSPORT, transport_in);
 380   }
 381   if (range_in) {
 382     gst_rtsp_message_add_header (request, GST_RTSP_HDR_RANGE, range_in);
 383   }
 384   if (require_in) {
 385     gst_rtsp_message_add_header (request, GST_RTSP_HDR_REQUIRE, require_in);
 386   }
 387
 388   /* send request */
 389   fail_unless (send_request (conn, request));
 390   gst_rtsp_message_free (request);
 391
 392   iterate ();
 393
 394   /* read response */
 395   response = read_response (conn);
 396   fail_unless (response != NULL);
 397
 398   msg_type = gst_rtsp_message_get_type (response);
 399
 400   if (msg_type == GST_RTSP_MESSAGE_DATA) {
 401     do {
 402       gst_rtsp_message_free (response);
 403       response = read_response (conn);
 404       msg_type = gst_rtsp_message_get_type (response);
 405     } while (msg_type == GST_RTSP_MESSAGE_DATA);
 406   }
 407
 408   fail_unless (msg_type == GST_RTSP_MESSAGE_RESPONSE);
 409
 410   /* check status line */
 411   gst_rtsp_message_parse_response (response, &code, NULL, NULL);
 412   if (code != GST_RTSP_STS_OK) {
 413     if (unsupported_out != NULL && code == GST_RTSP_STS_OPTION_NOT_SUPPORTED) {
 414       gst_rtsp_message_get_header (response, GST_RTSP_HDR_UNSUPPORTED,
 415           &value, 0);
 416       *unsupported_out = g_strdup (value);
 417     }
 418     gst_rtsp_message_free (response);
 419     return code;
 420   }
 421
 422   /* get information from response */
 423   if (content_type) {
 424     gst_rtsp_message_get_header (response, GST_RTSP_HDR_CONTENT_TYPE,
 425         &value, 0);
 426     *content_type = g_strdup (value);
 427   }
 428   if (content_base) {
 429     gst_rtsp_message_get_header (response, GST_RTSP_HDR_CONTENT_BASE,
 430         &value, 0);
 431     *content_base = g_strdup (value);
 432   }
 433   if (body) {
 434     *body = g_malloc (response->body_size + 1);
 435     strncpy (*body, (gchar *) response->body, response->body_size);
 436   }
 437   if (session_out) {
 438     gst_rtsp_message_get_header (response, GST_RTSP_HDR_SESSION, &value, 0);
 439
 440     value = g_strdup (value);
 441
 442     /* Remove the timeout */
 443     if (value) {
 444       char *pos = strchr (value, ';');
 445       if (pos)
 446         *pos = 0;
 447     }
 448     if (session_in) {
 449       /* check that we got the same session back */
 450       fail_unless (!g_strcmp0 (value, session_in));
 451     }
 452     *session_out = value;
 453   }
 454   if (transport_out) {
 455     gst_rtsp_message_get_header (response, GST_RTSP_HDR_TRANSPORT, &value, 0);
 456     *transport_out = g_strdup (value);
 457   }
 458   if (range_out) {
 459     gst_rtsp_message_get_header (response, GST_RTSP_HDR_RANGE, &value, 0);
 460     *range_out = g_strdup (value);
 461   }
 462
 463   gst_rtsp_message_free (response);
 464   return code;
 465 }
 466
 467 /* send an rtsp request and receive response. gchar** parameters are out
 468  * parameters that have to be freed by the caller */
 469 static GstRTSPStatusCode
 470 do_request (GstRTSPConnection * conn, GstRTSPMethod method,
 471     const gchar * control, const gchar * session_in,
 472     const gchar * transport_in, const gchar * range_in,
 473     gchar ** content_type, gchar ** content_base, gchar ** body,
 474     gchar ** session_out, gchar ** transport_out, gchar ** range_out)
 475 {
 476   return do_request_full (conn, method, control, session_in, transport_in,
 477       range_in, NULL, content_type, content_base, body, session_out,
 478       transport_out, range_out, NULL);
 479 }
 480
 481 /* send an rtsp request with a method and a session, and receive response */
 482 static GstRTSPStatusCode
 483 do_simple_request (GstRTSPConnection * conn, GstRTSPMethod method,
 484     const gchar * session)
 485 {
 486   return do_request (conn, method, NULL, session, NULL, NULL, NULL,
 487       NULL, NULL, NULL, NULL, NULL);
 488 }
 489
 490 /* send an rtsp request with a method,session and range in,
 491  * and receive response. range_in is the Range in req header */
 492 static GstRTSPStatusCode
 493 do_simple_request_rangein (GstRTSPConnection * conn, GstRTSPMethod method,
 494     const gchar * session, const gchar * rangein)
 495 {
 496   return do_request (conn, method, NULL, session, NULL, rangein, NULL,
 497       NULL, NULL, NULL, NULL, NULL);
 498 }
 499
 500 /* send a DESCRIBE request and receive response. returns a received
 501  * GstSDPMessage that must be freed by the caller */
 502 static GstSDPMessage *
 503 do_describe (GstRTSPConnection * conn, const gchar * mount_point)
 504 {
 505   GstSDPMessage *sdp_message;
 506   gchar *content_type = NULL;
 507   gchar *content_base = NULL;
 508   gchar *body = NULL;
 509   gchar *address;
 510   gchar *expected_content_base;
 511
 512   /* send DESCRIBE request */
 513   fail_unless (do_request (conn, GST_RTSP_DESCRIBE, NULL, NULL, NULL, NULL,
 514           &content_type, &content_base, &body, NULL, NULL, NULL) ==
 515       GST_RTSP_STS_OK);
 516
 517   /* check response values */
 518   fail_unless (!g_strcmp0 (content_type, "application/sdp"));
 519   address = gst_rtsp_server_get_address (server);
 520   expected_content_base =
 521       g_strdup_printf ("rtsp://%s:%d%s/", address, test_port, mount_point);
 522   fail_unless (!g_strcmp0 (content_base, expected_content_base));
 523
 524   /* create sdp message */
 525   fail_unless (gst_sdp_message_new (&sdp_message) == GST_SDP_OK);
 526   fail_unless (gst_sdp_message_parse_buffer ((guint8 *) body,
 527           strlen (body), sdp_message) == GST_SDP_OK);
 528
 529   /* clean up */
 530   g_free (content_type);
 531   g_free (content_base);
 532   g_free (body);
 533   g_free (address);
 534   g_free (expected_content_base);
 535
 536   return sdp_message;
 537 }
 538
 539 /* send a SETUP request and receive response. if *session is not NULL,
 540  * it is used in the request. otherwise, *session is set to a returned
 541  * session string that must be freed by the caller. the returned
 542  * transport must be freed by the caller. */
 543 static GstRTSPStatusCode
 544 do_setup_full (GstRTSPConnection * conn, const gchar * control,
 545     GstRTSPLowerTrans lower_transport, const GstRTSPRange * client_ports,
 546     const gchar * require, gchar ** session, GstRTSPTransport ** transport,
 547     gchar ** unsupported)
 548 {
 549   GstRTSPStatusCode code;
 550   gchar *session_in = NULL;
 551   GString *transport_string_in = NULL;
 552   gchar **session_out = NULL;
 553   gchar *transport_string_out = NULL;
 554
 555   /* prepare and send SETUP request */
 556   if (session) {
 557     if (*session) {
 558       session_in = *session;
 559     } else {
 560       session_out = session;
 561     }
 562   }
 563
 564   transport_string_in = g_string_new (TEST_PROTO);
 565   switch (lower_transport) {
 566     case GST_RTSP_LOWER_TRANS_UDP:
 567       transport_string_in =
 568           g_string_append (transport_string_in, "/UDP;unicast");
 569       break;
 570     case GST_RTSP_LOWER_TRANS_UDP_MCAST:
 571       transport_string_in =
 572           g_string_append (transport_string_in, "/UDP;multicast");
 573       break;
 574     case GST_RTSP_LOWER_TRANS_TCP:
 575       transport_string_in =
 576           g_string_append (transport_string_in, "/TCP;unicast");
 577       break;
 578     default:
 579       g_assert_not_reached ();
 580       break;
 581   }
 582
 583   if (client_ports) {
 584     g_string_append_printf (transport_string_in, ";client_port=%d-%d",
 585         client_ports->min, client_ports->max);
 586   }
 587
 588   code =
 589       do_request_full (conn, GST_RTSP_SETUP, control, session_in,
 590       transport_string_in->str, NULL, require, NULL, NULL, NULL, session_out,
 591       &transport_string_out, NULL, unsupported);
 592   g_string_free (transport_string_in, TRUE);
 593
 594   if (transport_string_out) {
 595     /* create transport */
 596     fail_unless (gst_rtsp_transport_new (transport) == GST_RTSP_OK);
 597     fail_unless (gst_rtsp_transport_parse (transport_string_out,
 598             *transport) == GST_RTSP_OK);
 599     g_free (transport_string_out);
 600   }
 601   GST_INFO ("code=%d", code);
 602   return code;
 603 }
 604
 605 /* send a SETUP request and receive response. if *session is not NULL,
 606  * it is used in the request. otherwise, *session is set to a returned
 607  * session string that must be freed by the caller. the returned
 608  * transport must be freed by the caller. */
 609 static GstRTSPStatusCode
 610 do_setup (GstRTSPConnection * conn, const gchar * control,
 611     const GstRTSPRange * client_ports, gchar ** session,
 612     GstRTSPTransport ** transport)
 613 {
 614   return do_setup_full (conn, control, GST_RTSP_LOWER_TRANS_UDP, client_ports,
 615       NULL, session, transport, NULL);
 616 }
 617
 618 /* fixture setup function */
 619 static void
 620 setup (void)
 621 {
 622   server = gst_rtsp_server_new ();
 623 }
 624
 625 /* fixture clean-up function */
 626 static void
 627 teardown (void)
 628 {
 629   if (server) {
 630     g_object_unref (server);
 631     server = NULL;
 632   }
 633   test_port = 0;
 634 }
 635
 636 GST_START_TEST (test_connect)
 637 {
 638   GstRTSPConnection *conn;
 639
 640   start_server (FALSE);
 641
 642   /* connect to server */
 643   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 644
 645   /* clean up */
 646   gst_rtsp_connection_free (conn);
 647   stop_server ();
 648
 649   /* iterate so the clean-up can finish */
 650   iterate ();
 651 }
 652
 653 GST_END_TEST;
 654
 655 GST_START_TEST (test_describe)
 656 {
 657   GstRTSPConnection *conn;
 658   GstSDPMessage *sdp_message = NULL;
 659   const GstSDPMedia *sdp_media;
 660   gint32 format;
 661   gchar *expected_rtpmap;
 662   const gchar *rtpmap;
 663   const gchar *control_video;
 664   const gchar *control_audio;
 665
 666   start_server (FALSE);
 667
 668   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 669
 670   /* send DESCRIBE request */
 671   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
 672
 673   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
 674
 675   /* check video sdp */
 676   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
 677   fail_unless (!g_strcmp0 (gst_sdp_media_get_proto (sdp_media), TEST_PROTO));
 678   fail_unless (gst_sdp_media_formats_len (sdp_media) == 1);
 679   sscanf (gst_sdp_media_get_format (sdp_media, 0), "%" G_GINT32_FORMAT,
 680       &format);
 681   expected_rtpmap =
 682       g_strdup_printf ("%d " TEST_ENCODING "/" TEST_CLOCK_RATE, format);
 683   rtpmap = gst_sdp_media_get_attribute_val (sdp_media, "rtpmap");
 684   fail_unless (!g_strcmp0 (rtpmap, expected_rtpmap));
 685   g_free (expected_rtpmap);
 686   control_video = gst_sdp_media_get_attribute_val (sdp_media, "control");
 687   fail_unless (!g_strcmp0 (control_video, "stream=0"));
 688
 689   /* check audio sdp */
 690   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
 691   fail_unless (!g_strcmp0 (gst_sdp_media_get_proto (sdp_media), TEST_PROTO));
 692   fail_unless (gst_sdp_media_formats_len (sdp_media) == 1);
 693   sscanf (gst_sdp_media_get_format (sdp_media, 0), "%" G_GINT32_FORMAT,
 694       &format);
 695   expected_rtpmap =
 696       g_strdup_printf ("%d " TEST_ENCODING "/" TEST_CLOCK_RATE, format);
 697   rtpmap = gst_sdp_media_get_attribute_val (sdp_media, "rtpmap");
 698   fail_unless (!g_strcmp0 (rtpmap, expected_rtpmap));
 699   g_free (expected_rtpmap);
 700   control_audio = gst_sdp_media_get_attribute_val (sdp_media, "control");
 701   fail_unless (!g_strcmp0 (control_audio, "stream=1"));
 702
 703   /* clean up and iterate so the clean-up can finish */
 704   gst_sdp_message_free (sdp_message);
 705   gst_rtsp_connection_free (conn);
 706   stop_server ();
 707   iterate ();
 708 }
 709
 710 GST_END_TEST;
 711
 712 GST_START_TEST (test_describe_record_media)
 713 {
 714   GstRTSPConnection *conn;
 715
 716   start_record_server ("( fakesink name=depay0 )");
 717
 718   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 719
 720   /* send DESCRIBE request */
 721   fail_unless_equals_int (do_request (conn, GST_RTSP_DESCRIBE, NULL, NULL, NULL,
 722           NULL, NULL, NULL, NULL, NULL, NULL, NULL),
 723       GST_RTSP_STS_METHOD_NOT_ALLOWED);
 724
 725   /* clean up and iterate so the clean-up can finish */
 726   gst_rtsp_connection_free (conn);
 727   stop_server ();
 728   iterate ();
 729 }
 730
 731 GST_END_TEST;
 732
 733 GST_START_TEST (test_describe_non_existing_mount_point)
 734 {
 735   GstRTSPConnection *conn;
 736
 737   start_server (FALSE);
 738
 739   /* send DESCRIBE request for a non-existing mount point
 740    * and check that we get a 404 Not Found */
 741   conn = connect_to_server (test_port, "/non-existing");
 742   fail_unless (do_simple_request (conn, GST_RTSP_DESCRIBE, NULL)
 743       == GST_RTSP_STS_NOT_FOUND);
 744
 745   /* clean up and iterate so the clean-up can finish */
 746   gst_rtsp_connection_free (conn);
 747   stop_server ();
 748   iterate ();
 749 }
 750
 751 GST_END_TEST;
 752
 753 static void
 754 do_test_setup (GstRTSPLowerTrans lower_transport)
 755 {
 756   GstRTSPConnection *conn;
 757   GstSDPMessage *sdp_message = NULL;
 758   const GstSDPMedia *sdp_media;
 759   const gchar *video_control;
 760   const gchar *audio_control;
 761   GstRTSPRange client_ports = { 0 };
 762   gchar *session = NULL;
 763   GstRTSPTransport *video_transport = NULL;
 764   GstRTSPTransport *audio_transport = NULL;
 765
 766   start_server (FALSE);
 767
 768   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 769
 770   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
 771
 772   /* get control strings from DESCRIBE response */
 773   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
 774   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
 775   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
 776   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
 777   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
 778
 779   get_client_ports (&client_ports);
 780
 781   /* send SETUP request for video */
 782   fail_unless (do_setup_full (conn, video_control, lower_transport,
 783           &client_ports, NULL, &session, &video_transport,
 784           NULL) == GST_RTSP_STS_OK);
 785   GST_DEBUG ("set up video %s, got session '%s'", video_control, session);
 786
 787   /* check response from SETUP */
 788   fail_unless (video_transport->trans == GST_RTSP_TRANS_RTP);
 789   fail_unless (video_transport->profile == GST_RTSP_PROFILE_AVP);
 790   fail_unless (video_transport->lower_transport == lower_transport);
 791   fail_unless (video_transport->mode_play);
 792   gst_rtsp_transport_free (video_transport);
 793
 794   /* send SETUP request for audio */
 795   fail_unless (do_setup_full (conn, audio_control, lower_transport,
 796           &client_ports, NULL, &session, &audio_transport,
 797           NULL) == GST_RTSP_STS_OK);
 798   GST_DEBUG ("set up audio %s with session '%s'", audio_control, session);
 799
 800   /* check response from SETUP */
 801   fail_unless (audio_transport->trans == GST_RTSP_TRANS_RTP);
 802   fail_unless (audio_transport->profile == GST_RTSP_PROFILE_AVP);
 803   fail_unless (audio_transport->lower_transport == lower_transport);
 804   fail_unless (audio_transport->mode_play);
 805   gst_rtsp_transport_free (audio_transport);
 806
 807   /* send TEARDOWN request and check that we get 200 OK */
 808   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
 809           session) == GST_RTSP_STS_OK);
 810
 811   /* clean up and iterate so the clean-up can finish */
 812   g_free (session);
 813   gst_sdp_message_free (sdp_message);
 814   gst_rtsp_connection_free (conn);
 815   stop_server ();
 816   iterate ();
 817 }
 818
 819 GST_START_TEST (test_setup_udp)
 820 {
 821   do_test_setup (GST_RTSP_LOWER_TRANS_UDP);
 822 }
 823
 824 GST_END_TEST;
 825
 826 GST_START_TEST (test_setup_tcp)
 827 {
 828   do_test_setup (GST_RTSP_LOWER_TRANS_TCP);
 829 }
 830
 831 GST_END_TEST;
 832
 833 GST_START_TEST (test_setup_udp_mcast)
 834 {
 835   do_test_setup (GST_RTSP_LOWER_TRANS_UDP_MCAST);
 836 }
 837
 838 GST_END_TEST;
 839
 840 GST_START_TEST (test_setup_twice)
 841 {
 842   GstRTSPConnection *conn;
 843   GstSDPMessage *sdp_message;
 844   const GstSDPMedia *sdp_media;
 845   const gchar *video_control;
 846   GstRTSPRange client_ports;
 847   GstRTSPTransport *video_transport = NULL;
 848   gchar *session1 = NULL;
 849   gchar *session2 = NULL;
 850
 851   start_server (FALSE);
 852
 853   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 854
 855   /* we wan't more than one session for this connection */
 856   gst_rtsp_connection_set_remember_session_id (conn, FALSE);
 857
 858   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
 859
 860   /* get the control url */
 861   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
 862   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
 863   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
 864
 865   get_client_ports (&client_ports);
 866
 867   /* send SETUP request for one session */
 868   fail_unless (do_setup (conn, video_control, &client_ports, &session1,
 869           &video_transport) == GST_RTSP_STS_OK);
 870   GST_DEBUG ("set up video %s, got session '%s'", video_control, session1);
 871
 872   /* check response from SETUP */
 873   fail_unless (video_transport->trans == GST_RTSP_TRANS_RTP);
 874   fail_unless (video_transport->profile == GST_RTSP_PROFILE_AVP);
 875   fail_unless (video_transport->lower_transport == GST_RTSP_LOWER_TRANS_UDP);
 876   fail_unless (video_transport->mode_play);
 877   gst_rtsp_transport_free (video_transport);
 878
 879   /* send SETUP request for another session */
 880   fail_unless (do_setup (conn, video_control, &client_ports, &session2,
 881           &video_transport) == GST_RTSP_STS_OK);
 882   GST_DEBUG ("set up video %s, got session '%s'", video_control, session2);
 883
 884   /* check response from SETUP */
 885   fail_unless (video_transport->trans == GST_RTSP_TRANS_RTP);
 886   fail_unless (video_transport->profile == GST_RTSP_PROFILE_AVP);
 887   fail_unless (video_transport->lower_transport == GST_RTSP_LOWER_TRANS_UDP);
 888   fail_unless (video_transport->mode_play);
 889   gst_rtsp_transport_free (video_transport);
 890
 891   /* session can not be the same */
 892   fail_unless (strcmp (session1, session2));
 893
 894   /* send TEARDOWN request for the first session */
 895   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
 896           session1) == GST_RTSP_STS_OK);
 897
 898   /* send TEARDOWN request for the second session */
 899   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
 900           session2) == GST_RTSP_STS_OK);
 901
 902   g_free (session1);
 903   g_free (session2);
 904   gst_sdp_message_free (sdp_message);
 905   gst_rtsp_connection_free (conn);
 906   stop_server ();
 907   iterate ();
 908 }
 909
 910 GST_END_TEST;
 911
 912 GST_START_TEST (test_setup_with_require_header)
 913 {
 914   GstRTSPConnection *conn;
 915   GstSDPMessage *sdp_message = NULL;
 916   const GstSDPMedia *sdp_media;
 917   const gchar *video_control;
 918   GstRTSPRange client_ports;
 919   gchar *session = NULL;
 920   gchar *unsupported = NULL;
 921   GstRTSPTransport *video_transport = NULL;
 922
 923   start_server (FALSE);
 924
 925   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 926
 927   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
 928
 929   /* get control strings from DESCRIBE response */
 930   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
 931   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
 932   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
 933
 934   get_client_ports (&client_ports);
 935
 936   /* send SETUP request for video, with single Require header */
 937   fail_unless_equals_int (do_setup_full (conn, video_control,
 938           GST_RTSP_LOWER_TRANS_UDP, &client_ports, "funky-feature", &session,
 939           &video_transport, &unsupported), GST_RTSP_STS_OPTION_NOT_SUPPORTED);
 940   fail_unless_equals_string (unsupported, "funky-feature");
 941   g_free (unsupported);
 942   unsupported = NULL;
 943
 944   /* send SETUP request for video, with multiple Require headers */
 945   fail_unless_equals_int (do_setup_full (conn, video_control,
 946           GST_RTSP_LOWER_TRANS_UDP, &client_ports,
 947           "funky-feature, foo-bar, superburst", &session, &video_transport,
 948           &unsupported), GST_RTSP_STS_OPTION_NOT_SUPPORTED);
 949   fail_unless_equals_string (unsupported, "funky-feature, foo-bar, superburst");
 950   g_free (unsupported);
 951   unsupported = NULL;
 952
 953   /* ok, just do a normal setup then (make sure that still works) */
 954   fail_unless_equals_int (do_setup (conn, video_control, &client_ports,
 955           &session, &video_transport), GST_RTSP_STS_OK);
 956
 957   GST_DEBUG ("set up video %s, got session '%s'", video_control, session);
 958
 959   /* check response from SETUP */
 960   fail_unless (video_transport->trans == GST_RTSP_TRANS_RTP);
 961   fail_unless (video_transport->profile == GST_RTSP_PROFILE_AVP);
 962   fail_unless (video_transport->lower_transport == GST_RTSP_LOWER_TRANS_UDP);
 963   fail_unless (video_transport->mode_play);
 964   gst_rtsp_transport_free (video_transport);
 965
 966   /* send TEARDOWN request and check that we get 200 OK */
 967   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
 968           session) == GST_RTSP_STS_OK);
 969
 970   /* clean up and iterate so the clean-up can finish */
 971   g_free (session);
 972   gst_sdp_message_free (sdp_message);
 973   gst_rtsp_connection_free (conn);
 974   stop_server ();
 975   iterate ();
 976 }
 977
 978 GST_END_TEST;
 979
 980 GST_START_TEST (test_setup_non_existing_stream)
 981 {
 982   GstRTSPConnection *conn;
 983   GstRTSPRange client_ports;
 984
 985   start_server (FALSE);
 986
 987   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
 988
 989   get_client_ports (&client_ports);
 990
 991   /* send SETUP request with a non-existing stream and check that we get a
 992    * 404 Not Found */
 993   fail_unless (do_setup (conn, "stream=7", &client_ports, NULL,
 994           NULL) == GST_RTSP_STS_NOT_FOUND);
 995
 996   /* clean up and iterate so the clean-up can finish */
 997   gst_rtsp_connection_free (conn);
 998   stop_server ();
 999   iterate ();
1000 }
1001
1002 GST_END_TEST;
1003
1004 static void
1005 receive_rtp (GSocket * socket, GSocketAddress ** addr)
1006 {
1007   GstBuffer *buffer = gst_buffer_new_allocate (NULL, 65536, NULL);
1008
1009   for (;;) {
1010     gssize bytes;
1011     GstMapInfo map = GST_MAP_INFO_INIT;
1012     GstRTPBuffer rtpbuffer = GST_RTP_BUFFER_INIT;
1013
1014     gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1015     bytes = g_socket_receive_from (socket, addr, (gchar *) map.data,
1016         map.maxsize, NULL, NULL);
1017     fail_unless (bytes > 0);
1018     gst_buffer_unmap (buffer, &map);
1019     gst_buffer_set_size (buffer, bytes);
1020
1021     if (gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtpbuffer)) {
1022       gst_rtp_buffer_unmap (&rtpbuffer);
1023       break;
1024     }
1025
1026     if (addr)
1027       g_clear_object (addr);
1028   }
1029
1030   gst_buffer_unref (buffer);
1031 }
1032
1033 static void
1034 receive_rtcp (GSocket * socket, GSocketAddress ** addr, GstRTCPType type)
1035 {
1036   GstBuffer *buffer = gst_buffer_new_allocate (NULL, 65536, NULL);
1037
1038   for (;;) {
1039     gssize bytes;
1040     GstMapInfo map = GST_MAP_INFO_INIT;
1041
1042     gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1043     bytes = g_socket_receive_from (socket, addr, (gchar *) map.data,
1044         map.maxsize, NULL, NULL);
1045     fail_unless (bytes > 0);
1046     gst_buffer_unmap (buffer, &map);
1047     gst_buffer_set_size (buffer, bytes);
1048
1049     if (gst_rtcp_buffer_validate (buffer)) {
1050       GstRTCPBuffer rtcpbuffer = GST_RTCP_BUFFER_INIT;
1051       GstRTCPPacket packet;
1052
1053       if (type) {
1054         fail_unless (gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcpbuffer));
1055         fail_unless (gst_rtcp_buffer_get_first_packet (&rtcpbuffer, &packet));
1056         do {
1057           if (gst_rtcp_packet_get_type (&packet) == type) {
1058             gst_rtcp_buffer_unmap (&rtcpbuffer);
1059             goto done;
1060           }
1061         } while (gst_rtcp_packet_move_to_next (&packet));
1062         gst_rtcp_buffer_unmap (&rtcpbuffer);
1063       } else {
1064         break;
1065       }
1066     }
1067
1068     if (addr)
1069       g_clear_object (addr);
1070   }
1071
1072 done:
1073
1074   gst_buffer_unref (buffer);
1075 }
1076
1077 static void
1078 do_test_play_tcp_full (const gchar * range)
1079 {
1080   GstRTSPConnection *conn;
1081   GstSDPMessage *sdp_message = NULL;
1082   const GstSDPMedia *sdp_media;
1083   const gchar *video_control;
1084   const gchar *audio_control;
1085   GstRTSPRange client_port;
1086   gchar *session = NULL;
1087   GstRTSPTransport *video_transport = NULL;
1088   GstRTSPTransport *audio_transport = NULL;
1089   gchar *range_out = NULL;
1090   GstRTSPLowerTrans lower_transport = GST_RTSP_LOWER_TRANS_TCP;
1091
1092   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1093
1094   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1095   get_client_ports (&client_port);
1096
1097   /* get control strings from DESCRIBE response */
1098   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1099   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1100   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1101   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1102   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1103
1104   /* do SETUP for video and audio */
1105   fail_unless (do_setup_full (conn, video_control, lower_transport,
1106           &client_port, NULL, &session, &video_transport,
1107           NULL) == GST_RTSP_STS_OK);
1108   fail_unless (do_setup_full (conn, audio_control, lower_transport,
1109           &client_port, NULL, &session, &audio_transport,
1110           NULL) == GST_RTSP_STS_OK);
1111
1112   /* send PLAY request and check that we get 200 OK */
1113   fail_unless (do_request (conn, GST_RTSP_PLAY, NULL, session, NULL, range,
1114           NULL, NULL, NULL, NULL, NULL, &range_out) == GST_RTSP_STS_OK);
1115
1116   if (range)
1117     fail_unless_equals_string (range, range_out);
1118   g_free (range_out);
1119
1120   {
1121     GstRTSPMessage *message;
1122     fail_unless (gst_rtsp_message_new (&message) == GST_RTSP_OK);
1123     fail_unless (gst_rtsp_connection_receive (conn, message,
1124             NULL) == GST_RTSP_OK);
1125     fail_unless (gst_rtsp_message_get_type (message) == GST_RTSP_MESSAGE_DATA);
1126     gst_rtsp_message_free (message);
1127   }
1128
1129   /* send TEARDOWN request and check that we get 200 OK */
1130   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1131           session) == GST_RTSP_STS_OK);
1132
1133   /* FIXME: The rtsp-server always disconnects the transport before
1134    * sending the RTCP BYE
1135    * receive_rtcp (rtcp_socket, NULL, GST_RTCP_TYPE_BYE);
1136    */
1137
1138   /* clean up and iterate so the clean-up can finish */
1139   g_free (session);
1140   gst_rtsp_transport_free (video_transport);
1141   gst_rtsp_transport_free (audio_transport);
1142   gst_sdp_message_free (sdp_message);
1143   gst_rtsp_connection_free (conn);
1144 }
1145
1146 static void
1147 do_test_play_full (const gchar * range, GstRTSPLowerTrans lower_transport,
1148     GMutex * lock)
1149 {
1150   GstRTSPConnection *conn;
1151   GstSDPMessage *sdp_message = NULL;
1152   const GstSDPMedia *sdp_media;
1153   const gchar *video_control;
1154   const gchar *audio_control;
1155   GstRTSPRange client_port;
1156   gchar *session = NULL;
1157   GstRTSPTransport *video_transport = NULL;
1158   GstRTSPTransport *audio_transport = NULL;
1159   GSocket *rtp_socket, *rtcp_socket;
1160   gchar *range_out = NULL;
1161
1162   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1163
1164   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1165
1166   /* get control strings from DESCRIBE response */
1167   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1168   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1169   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1170   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1171   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1172
1173   get_client_ports_full (&client_port, &rtp_socket, &rtcp_socket);
1174
1175   /* do SETUP for video and audio */
1176   fail_unless (do_setup_full (conn, video_control, lower_transport,
1177           &client_port, NULL, &session, &video_transport,
1178           NULL) == GST_RTSP_STS_OK);
1179   fail_unless (do_setup_full (conn, audio_control, lower_transport,
1180           &client_port, NULL, &session, &audio_transport,
1181           NULL) == GST_RTSP_STS_OK);
1182
1183   /* send PLAY request and check that we get 200 OK */
1184   fail_unless (do_request (conn, GST_RTSP_PLAY, NULL, session, NULL, range,
1185           NULL, NULL, NULL, NULL, NULL, &range_out) == GST_RTSP_STS_OK);
1186   if (range)
1187     fail_unless_equals_string (range, range_out);
1188   g_free (range_out);
1189
1190   for (;;) {
1191     receive_rtp (rtp_socket, NULL);
1192     receive_rtcp (rtcp_socket, NULL, 0);
1193
1194     if (lock != NULL) {
1195       if (g_mutex_trylock (lock) == TRUE) {
1196         g_mutex_unlock (lock);
1197         break;
1198       }
1199     } else {
1200       break;
1201     }
1202
1203   }
1204
1205   /* send TEARDOWN request and check that we get 200 OK */
1206   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1207           session) == GST_RTSP_STS_OK);
1208
1209   /* FIXME: The rtsp-server always disconnects the transport before
1210    * sending the RTCP BYE
1211    * receive_rtcp (rtcp_socket, NULL, GST_RTCP_TYPE_BYE);
1212    */
1213
1214   /* clean up and iterate so the clean-up can finish */
1215   g_object_unref (rtp_socket);
1216   g_object_unref (rtcp_socket);
1217   g_free (session);
1218   gst_rtsp_transport_free (video_transport);
1219   gst_rtsp_transport_free (audio_transport);
1220   gst_sdp_message_free (sdp_message);
1221   gst_rtsp_connection_free (conn);
1222 }
1223
1224 static void
1225 do_test_play (const gchar * range)
1226 {
1227   do_test_play_full (range, GST_RTSP_LOWER_TRANS_UDP, NULL);
1228 }
1229
1230 GST_START_TEST (test_play)
1231 {
1232   start_server (FALSE);
1233
1234   do_test_play (NULL);
1235
1236   stop_server ();
1237   iterate ();
1238 }
1239
1240 GST_END_TEST;
1241
1242 GST_START_TEST (test_play_tcp)
1243 {
1244   GstRTSPConnection *conn;
1245   GstSDPMessage *sdp_message = NULL;
1246   const GstSDPMedia *sdp_media;
1247   const gchar *video_control;
1248   const gchar *audio_control;
1249   GstRTSPRange client_ports = { 0 };
1250   gchar *session = NULL;
1251   GstRTSPTransport *video_transport = NULL;
1252   GstRTSPTransport *audio_transport = NULL;
1253
1254   start_tcp_server (FALSE);
1255
1256   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1257
1258   /* send DESCRIBE request */
1259   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1260
1261   /* get control strings from DESCRIBE response */
1262   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1263   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1264   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1265   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1266   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1267
1268   get_client_ports (&client_ports);
1269
1270   /* send SETUP request for the first media */
1271   fail_unless (do_setup_full (conn, video_control, GST_RTSP_LOWER_TRANS_TCP,
1272           &client_ports, NULL, &session, &video_transport,
1273           NULL) == GST_RTSP_STS_OK);
1274
1275   /* check response from SETUP */
1276   fail_unless (video_transport->trans == GST_RTSP_TRANS_RTP);
1277   fail_unless (video_transport->profile == GST_RTSP_PROFILE_AVP);
1278   fail_unless (video_transport->lower_transport == GST_RTSP_LOWER_TRANS_TCP);
1279   fail_unless (video_transport->mode_play);
1280   gst_rtsp_transport_free (video_transport);
1281
1282   /* send SETUP request for the second media */
1283   fail_unless (do_setup_full (conn, audio_control, GST_RTSP_LOWER_TRANS_TCP,
1284           &client_ports, NULL, &session, &audio_transport,
1285           NULL) == GST_RTSP_STS_OK);
1286
1287   /* check response from SETUP */
1288   fail_unless (audio_transport->trans == GST_RTSP_TRANS_RTP);
1289   fail_unless (audio_transport->profile == GST_RTSP_PROFILE_AVP);
1290   fail_unless (audio_transport->lower_transport == GST_RTSP_LOWER_TRANS_TCP);
1291   fail_unless (audio_transport->mode_play);
1292   gst_rtsp_transport_free (audio_transport);
1293
1294   /* send PLAY request and check that we get 200 OK */
1295   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1296           session) == GST_RTSP_STS_OK);
1297
1298   /* send TEARDOWN request and check that we get 200 OK */
1299   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1300           session) == GST_RTSP_STS_OK);
1301
1302   /* clean up and iterate so the clean-up can finish */
1303   g_free (session);
1304   gst_sdp_message_free (sdp_message);
1305   gst_rtsp_connection_free (conn);
1306   stop_server ();
1307   iterate ();
1308 }
1309
1310 GST_END_TEST;
1311
1312 GST_START_TEST (test_play_without_session)
1313 {
1314   GstRTSPConnection *conn;
1315
1316   start_server (FALSE);
1317
1318   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1319
1320   /* send PLAY request without a session and check that we get a
1321    * 454 Session Not Found */
1322   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1323           NULL) == GST_RTSP_STS_SESSION_NOT_FOUND);
1324
1325   /* clean up and iterate so the clean-up can finish */
1326   gst_rtsp_connection_free (conn);
1327   stop_server ();
1328   iterate ();
1329 }
1330
1331 GST_END_TEST;
1332
1333 GST_START_TEST (test_bind_already_in_use)
1334 {
1335   GstRTSPServer *serv;
1336   GSocketService *service;
1337   GError *error = NULL;
1338   guint16 port;
1339   gchar *port_str;
1340
1341   serv = gst_rtsp_server_new ();
1342   service = g_socket_service_new ();
1343
1344   /* bind service to port */
1345   port =
1346       g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL,
1347       &error);
1348   g_assert_no_error (error);
1349
1350   port_str = g_strdup_printf ("%d\n", port);
1351
1352   /* try to bind server to the same port */
1353   g_object_set (serv, "service", port_str, NULL);
1354   g_free (port_str);
1355
1356   /* attach to default main context */
1357   fail_unless (gst_rtsp_server_attach (serv, NULL) == 0);
1358
1359   /* cleanup */
1360   g_object_unref (serv);
1361   g_socket_service_stop (service);
1362   g_object_unref (service);
1363 }
1364
1365 GST_END_TEST;
1366
1367
1368 GST_START_TEST (test_play_multithreaded)
1369 {
1370   GstRTSPThreadPool *pool;
1371
1372   pool = gst_rtsp_server_get_thread_pool (server);
1373   gst_rtsp_thread_pool_set_max_threads (pool, 2);
1374   g_object_unref (pool);
1375
1376   start_server (FALSE);
1377
1378   do_test_play (NULL);
1379
1380   stop_server ();
1381   iterate ();
1382 }
1383
1384 GST_END_TEST;
1385
1386 enum
1387 {
1388   BLOCK_ME,
1389   BLOCKED,
1390   UNBLOCK
1391 };
1392
1393
1394 static void
1395 media_constructed_block (GstRTSPMediaFactory * factory,
1396     GstRTSPMedia * media, gpointer user_data)
1397 {
1398   gint *block_state = user_data;
1399
1400   g_mutex_lock (&check_mutex);
1401
1402   *block_state = BLOCKED;
1403   g_cond_broadcast (&check_cond);
1404
1405   while (*block_state != UNBLOCK)
1406     g_cond_wait (&check_cond, &check_mutex);
1407   g_mutex_unlock (&check_mutex);
1408 }
1409
1410
1411 GST_START_TEST (test_play_multithreaded_block_in_describe)
1412 {
1413   GstRTSPConnection *conn;
1414   GstRTSPMountPoints *mounts;
1415   GstRTSPMediaFactory *factory;
1416   gint block_state = BLOCK_ME;
1417   GstRTSPMessage *request;
1418   GstRTSPMessage *response;
1419   GstRTSPStatusCode code;
1420   GstRTSPThreadPool *pool;
1421
1422   pool = gst_rtsp_server_get_thread_pool (server);
1423   gst_rtsp_thread_pool_set_max_threads (pool, 2);
1424   g_object_unref (pool);
1425
1426   mounts = gst_rtsp_server_get_mount_points (server);
1427   fail_unless (mounts != NULL);
1428   factory = gst_rtsp_media_factory_new ();
1429   gst_rtsp_media_factory_set_launch (factory,
1430       "( " VIDEO_PIPELINE "  " AUDIO_PIPELINE " )");
1431   g_signal_connect (factory, "media-constructed",
1432       G_CALLBACK (media_constructed_block), &block_state);
1433   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT "2", factory);
1434   g_object_unref (mounts);
1435
1436   start_server (FALSE);
1437
1438   conn = connect_to_server (test_port, TEST_MOUNT_POINT "2");
1439   iterate ();
1440
1441   /* do describe, it will not return now as we've blocked it */
1442   request = create_request (conn, GST_RTSP_DESCRIBE, NULL);
1443   fail_unless (send_request (conn, request));
1444   gst_rtsp_message_free (request);
1445
1446   g_mutex_lock (&check_mutex);
1447   while (block_state != BLOCKED)
1448     g_cond_wait (&check_cond, &check_mutex);
1449   g_mutex_unlock (&check_mutex);
1450
1451   /* Do a second connection while the first one is blocked */
1452   do_test_play (NULL);
1453
1454   /* Now unblock the describe */
1455   g_mutex_lock (&check_mutex);
1456   block_state = UNBLOCK;
1457   g_cond_broadcast (&check_cond);
1458   g_mutex_unlock (&check_mutex);
1459
1460   response = read_response (conn);
1461   gst_rtsp_message_parse_response (response, &code, NULL, NULL);
1462   fail_unless (code == GST_RTSP_STS_OK);
1463   gst_rtsp_message_free (response);
1464
1465
1466   gst_rtsp_connection_free (conn);
1467   stop_server ();
1468   iterate ();
1469
1470 }
1471
1472 GST_END_TEST;
1473
1474
1475 static void
1476 new_session_timeout_one (GstRTSPClient * client,
1477     GstRTSPSession * session, gpointer user_data)
1478 {
1479   gst_rtsp_session_set_timeout (session, 1);
1480
1481   g_signal_handlers_disconnect_by_func (client, new_session_timeout_one,
1482       user_data);
1483 }
1484
1485 static void
1486 session_connected_new_session_cb (GstRTSPServer * server,
1487     GstRTSPClient * client, gpointer user_data)
1488 {
1489
1490   g_signal_connect (client, "new-session", user_data, NULL);
1491 }
1492
1493 GST_START_TEST (test_play_multithreaded_timeout_client)
1494 {
1495   GstRTSPConnection *conn;
1496   GstSDPMessage *sdp_message = NULL;
1497   const GstSDPMedia *sdp_media;
1498   const gchar *video_control;
1499   const gchar *audio_control;
1500   GstRTSPRange client_port;
1501   gchar *session = NULL;
1502   GstRTSPTransport *video_transport = NULL;
1503   GstRTSPTransport *audio_transport = NULL;
1504   GstRTSPSessionPool *pool;
1505   GstRTSPThreadPool *thread_pool;
1506
1507   thread_pool = gst_rtsp_server_get_thread_pool (server);
1508   gst_rtsp_thread_pool_set_max_threads (thread_pool, 2);
1509   g_object_unref (thread_pool);
1510
1511   pool = gst_rtsp_server_get_session_pool (server);
1512   g_signal_connect (server, "client-connected",
1513       G_CALLBACK (session_connected_new_session_cb), new_session_timeout_one);
1514
1515   start_server (FALSE);
1516
1517
1518   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1519
1520   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1521
1522   /* get control strings from DESCRIBE response */
1523   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1524   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1525   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1526   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1527   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1528
1529   get_client_ports (&client_port);
1530
1531   /* do SETUP for video and audio */
1532   fail_unless (do_setup_full (conn, video_control, GST_RTSP_LOWER_TRANS_UDP,
1533           &client_port, NULL, &session, &video_transport,
1534           NULL) == GST_RTSP_STS_OK);
1535   fail_unless (do_setup_full (conn, audio_control, GST_RTSP_LOWER_TRANS_UDP,
1536           &client_port, NULL, &session, &audio_transport,
1537           NULL) == GST_RTSP_STS_OK);
1538
1539   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 1);
1540
1541   /* send PLAY request and check that we get 200 OK */
1542   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1543           session) == GST_RTSP_STS_OK);
1544
1545   sleep (7);
1546
1547   fail_unless (gst_rtsp_session_pool_cleanup (pool) == 1);
1548   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 0);
1549
1550   /* clean up and iterate so the clean-up can finish */
1551   g_object_unref (pool);
1552   g_free (session);
1553   gst_rtsp_transport_free (video_transport);
1554   gst_rtsp_transport_free (audio_transport);
1555   gst_sdp_message_free (sdp_message);
1556   gst_rtsp_connection_free (conn);
1557
1558   stop_server ();
1559   iterate ();
1560 }
1561
1562 GST_END_TEST;
1563
1564
1565 GST_START_TEST (test_play_multithreaded_timeout_session)
1566 {
1567   GstRTSPConnection *conn;
1568   GstSDPMessage *sdp_message = NULL;
1569   const GstSDPMedia *sdp_media;
1570   const gchar *video_control;
1571   const gchar *audio_control;
1572   GstRTSPRange client_port;
1573   gchar *session1 = NULL;
1574   gchar *session2 = NULL;
1575   GstRTSPTransport *video_transport = NULL;
1576   GstRTSPTransport *audio_transport = NULL;
1577   GstRTSPSessionPool *pool;
1578   GstRTSPThreadPool *thread_pool;
1579
1580   thread_pool = gst_rtsp_server_get_thread_pool (server);
1581   gst_rtsp_thread_pool_set_max_threads (thread_pool, 2);
1582   g_object_unref (thread_pool);
1583
1584   pool = gst_rtsp_server_get_session_pool (server);
1585   g_signal_connect (server, "client-connected",
1586       G_CALLBACK (session_connected_new_session_cb), new_session_timeout_one);
1587
1588   start_server (FALSE);
1589
1590
1591   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1592
1593   gst_rtsp_connection_set_remember_session_id (conn, FALSE);
1594
1595   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1596
1597   /* get control strings from DESCRIBE response */
1598   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1599   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1600   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1601   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1602   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1603
1604   get_client_ports (&client_port);
1605
1606   /* do SETUP for video and audio */
1607   fail_unless (do_setup (conn, video_control, &client_port, &session1,
1608           &video_transport) == GST_RTSP_STS_OK);
1609   fail_unless (do_setup (conn, audio_control, &client_port, &session2,
1610           &audio_transport) == GST_RTSP_STS_OK);
1611
1612   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 2);
1613
1614   /* send PLAY request and check that we get 200 OK */
1615   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1616           session1) == GST_RTSP_STS_OK);
1617   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1618           session2) == GST_RTSP_STS_OK);
1619
1620   sleep (7);
1621
1622   fail_unless (gst_rtsp_session_pool_cleanup (pool) == 1);
1623
1624   /* send TEARDOWN request and check that we get 454 Session Not found */
1625   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1626           session1) == GST_RTSP_STS_SESSION_NOT_FOUND);
1627
1628   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1629           session2) == GST_RTSP_STS_OK);
1630
1631   /* clean up and iterate so the clean-up can finish */
1632   g_object_unref (pool);
1633   g_free (session1);
1634   g_free (session2);
1635   gst_rtsp_transport_free (video_transport);
1636   gst_rtsp_transport_free (audio_transport);
1637   gst_sdp_message_free (sdp_message);
1638   gst_rtsp_connection_free (conn);
1639
1640   stop_server ();
1641   iterate ();
1642 }
1643
1644 GST_END_TEST;
1645
1646
1647 GST_START_TEST (test_no_session_timeout)
1648 {
1649   GstRTSPSession *session;
1650   gint64 now;
1651   gboolean is_expired;
1652
1653   session = gst_rtsp_session_new ("test-session");
1654   gst_rtsp_session_set_timeout (session, 0);
1655
1656   now = g_get_monotonic_time ();
1657   /* add more than the extra 5 seconds that are usually added in
1658    * gst_rtsp_session_next_timeout_usec */
1659   now += 7000000;
1660
1661   is_expired = gst_rtsp_session_is_expired_usec (session, now);
1662   fail_unless (is_expired == FALSE);
1663
1664   g_object_unref (session);
1665 }
1666
1667 GST_END_TEST;
1668
1669 /* media contains two streams: video and audio but only one
1670  * stream is requested */
1671 GST_START_TEST (test_play_one_active_stream)
1672 {
1673   GstRTSPConnection *conn;
1674   GstSDPMessage *sdp_message = NULL;
1675   const GstSDPMedia *sdp_media;
1676   const gchar *video_control;
1677   GstRTSPRange client_port;
1678   gchar *session = NULL;
1679   GstRTSPTransport *video_transport = NULL;
1680   GstRTSPSessionPool *pool;
1681   GstRTSPThreadPool *thread_pool;
1682
1683   thread_pool = gst_rtsp_server_get_thread_pool (server);
1684   gst_rtsp_thread_pool_set_max_threads (thread_pool, 2);
1685   g_object_unref (thread_pool);
1686
1687   pool = gst_rtsp_server_get_session_pool (server);
1688   g_signal_connect (server, "client-connected",
1689       G_CALLBACK (session_connected_new_session_cb), new_session_timeout_one);
1690
1691   start_server (FALSE);
1692
1693   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1694
1695   gst_rtsp_connection_set_remember_session_id (conn, FALSE);
1696
1697   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1698
1699   /* get control strings from DESCRIBE response */
1700   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1701   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1702   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1703
1704   get_client_ports (&client_port);
1705
1706   /* do SETUP for video only */
1707   fail_unless (do_setup (conn, video_control, &client_port, &session,
1708           &video_transport) == GST_RTSP_STS_OK);
1709
1710   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 1);
1711
1712   /* send PLAY request and check that we get 200 OK */
1713   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1714           session) == GST_RTSP_STS_OK);
1715
1716
1717   /* send TEARDOWN request */
1718   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1719           session) == GST_RTSP_STS_OK);
1720
1721   /* clean up and iterate so the clean-up can finish */
1722   g_object_unref (pool);
1723   g_free (session);
1724   gst_rtsp_transport_free (video_transport);
1725   gst_sdp_message_free (sdp_message);
1726   gst_rtsp_connection_free (conn);
1727
1728   stop_server ();
1729   iterate ();
1730 }
1731
1732 GST_END_TEST;
1733
1734 GST_START_TEST (test_play_disconnect)
1735 {
1736   GstRTSPConnection *conn;
1737   GstSDPMessage *sdp_message = NULL;
1738   const GstSDPMedia *sdp_media;
1739   const gchar *video_control;
1740   const gchar *audio_control;
1741   GstRTSPRange client_port;
1742   gchar *session = NULL;
1743   GstRTSPTransport *video_transport = NULL;
1744   GstRTSPTransport *audio_transport = NULL;
1745   GstRTSPSessionPool *pool;
1746
1747   pool = gst_rtsp_server_get_session_pool (server);
1748   g_signal_connect (server, "client-connected",
1749       G_CALLBACK (session_connected_new_session_cb), new_session_timeout_one);
1750
1751   start_server (FALSE);
1752
1753   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1754
1755   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1756
1757   /* get control strings from DESCRIBE response */
1758   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
1759   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1760   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1761   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
1762   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1763
1764   get_client_ports (&client_port);
1765
1766   /* do SETUP for video and audio */
1767   fail_unless (do_setup (conn, video_control, &client_port, &session,
1768           &video_transport) == GST_RTSP_STS_OK);
1769   fail_unless (do_setup (conn, audio_control, &client_port, &session,
1770           &audio_transport) == GST_RTSP_STS_OK);
1771
1772   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 1);
1773
1774   /* send PLAY request and check that we get 200 OK */
1775   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1776           session) == GST_RTSP_STS_OK);
1777
1778   gst_rtsp_connection_free (conn);
1779
1780   sleep (7);
1781
1782   fail_unless (gst_rtsp_session_pool_get_n_sessions (pool) == 1);
1783   fail_unless (gst_rtsp_session_pool_cleanup (pool) == 1);
1784
1785
1786   /* clean up and iterate so the clean-up can finish */
1787   g_object_unref (pool);
1788   g_free (session);
1789   gst_rtsp_transport_free (video_transport);
1790   gst_rtsp_transport_free (audio_transport);
1791   gst_sdp_message_free (sdp_message);
1792
1793   stop_server ();
1794   iterate ();
1795 }
1796
1797 GST_END_TEST;
1798
1799 /* Only different with test_play is the specific ports selected */
1800
1801 GST_START_TEST (test_play_specific_server_port)
1802 {
1803   GstRTSPMountPoints *mounts;
1804   gchar *service;
1805   GstRTSPMediaFactory *factory;
1806   GstRTSPAddressPool *pool;
1807   GstRTSPConnection *conn;
1808   GstSDPMessage *sdp_message = NULL;
1809   const GstSDPMedia *sdp_media;
1810   const gchar *video_control;
1811   GstRTSPRange client_port;
1812   gchar *session = NULL;
1813   GstRTSPTransport *video_transport = NULL;
1814   GSocket *rtp_socket, *rtcp_socket;
1815   GSocketAddress *rtp_address, *rtcp_address;
1816   guint16 rtp_port, rtcp_port;
1817
1818   mounts = gst_rtsp_server_get_mount_points (server);
1819
1820   factory = gst_rtsp_media_factory_new ();
1821   /* we have to suspend media after SDP in order to make sure that
1822    * we can reconfigure UDP sink with new UDP ports */
1823   gst_rtsp_media_factory_set_suspend_mode (factory,
1824       GST_RTSP_SUSPEND_MODE_RESET);
1825   pool = gst_rtsp_address_pool_new ();
1826   gst_rtsp_address_pool_add_range (pool, GST_RTSP_ADDRESS_POOL_ANY_IPV4,
1827       GST_RTSP_ADDRESS_POOL_ANY_IPV4, 7770, 7780, 0);
1828   gst_rtsp_media_factory_set_address_pool (factory, pool);
1829   g_object_unref (pool);
1830   gst_rtsp_media_factory_set_launch (factory, "( " VIDEO_PIPELINE " )");
1831   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
1832   g_object_unref (mounts);
1833
1834   /* set port to any */
1835   gst_rtsp_server_set_service (server, "0");
1836
1837   /* attach to default main context */
1838   source_id = gst_rtsp_server_attach (server, NULL);
1839   fail_if (source_id == 0);
1840
1841   /* get port */
1842   service = gst_rtsp_server_get_service (server);
1843   test_port = atoi (service);
1844   fail_unless (test_port != 0);
1845   g_free (service);
1846
1847   GST_DEBUG ("rtsp server listening on port %d", test_port);
1848
1849
1850   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
1851
1852   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
1853
1854   /* get control strings from DESCRIBE response */
1855   fail_unless (gst_sdp_message_medias_len (sdp_message) == 1);
1856   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
1857   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
1858
1859   get_client_ports_full (&client_port, &rtp_socket, &rtcp_socket);
1860
1861   /* do SETUP for video */
1862   fail_unless (do_setup (conn, video_control, &client_port, &session,
1863           &video_transport) == GST_RTSP_STS_OK);
1864
1865   /* send PLAY request and check that we get 200 OK */
1866   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
1867           session) == GST_RTSP_STS_OK);
1868
1869   receive_rtp (rtp_socket, &rtp_address);
1870   receive_rtcp (rtcp_socket, &rtcp_address, 0);
1871
1872   fail_unless (G_IS_INET_SOCKET_ADDRESS (rtp_address));
1873   fail_unless (G_IS_INET_SOCKET_ADDRESS (rtcp_address));
1874   rtp_port =
1875       g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (rtp_address));
1876   rtcp_port =
1877       g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (rtcp_address));
1878   fail_unless (rtp_port >= 7770 && rtp_port <= 7780 && rtp_port % 2 == 0);
1879   fail_unless (rtcp_port >= 7770 && rtcp_port <= 7780 && rtcp_port % 2 == 1);
1880   fail_unless (rtp_port + 1 == rtcp_port);
1881
1882   g_object_unref (rtp_address);
1883   g_object_unref (rtcp_address);
1884
1885   /* send TEARDOWN request and check that we get 200 OK */
1886   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
1887           session) == GST_RTSP_STS_OK);
1888
1889   /* FIXME: The rtsp-server always disconnects the transport before
1890    * sending the RTCP BYE
1891    * receive_rtcp (rtcp_socket, NULL, GST_RTCP_TYPE_BYE);
1892    */
1893
1894   /* clean up and iterate so the clean-up can finish */
1895   g_object_unref (rtp_socket);
1896   g_object_unref (rtcp_socket);
1897   g_free (session);
1898   gst_rtsp_transport_free (video_transport);
1899   gst_sdp_message_free (sdp_message);
1900   gst_rtsp_connection_free (conn);
1901
1902
1903   stop_server ();
1904   iterate ();
1905 }
1906
1907 GST_END_TEST;
1908
1909
1910 GST_START_TEST (test_play_smpte_range)
1911 {
1912   start_server (FALSE);
1913
1914   do_test_play ("npt=5-");
1915   do_test_play ("smpte=0:00:00-");
1916   do_test_play ("smpte=1:00:00-");
1917   do_test_play ("smpte=1:00:03-");
1918   do_test_play ("clock=20120321T152256Z-");
1919
1920   stop_server ();
1921   iterate ();
1922 }
1923
1924 GST_END_TEST;
1925
1926 GST_START_TEST (test_play_smpte_range_tcp)
1927 {
1928   start_tcp_server (FALSE);
1929
1930   do_test_play_tcp_full ("npt=5-");
1931   do_test_play_tcp_full ("smpte=0:00:00-");
1932   do_test_play_tcp_full ("smpte=1:00:00-");
1933   do_test_play_tcp_full ("smpte=1:00:03-");
1934   do_test_play_tcp_full ("clock=20120321T152256Z-");
1935
1936   stop_server ();
1937   iterate ();
1938 }
1939
1940 GST_END_TEST;
1941
1942 static gpointer
1943 thread_func_udp (gpointer data)
1944 {
1945   do_test_play_full (NULL, GST_RTSP_LOWER_TRANS_UDP, (GMutex *) data);
1946   return NULL;
1947 }
1948
1949 static gpointer
1950 thread_func_tcp (gpointer data)
1951 {
1952   do_test_play_tcp_full (NULL);
1953   return NULL;
1954 }
1955
1956 static void
1957 test_shared (gpointer (thread_func) (gpointer data))
1958 {
1959   GMutex lock1, lock2, lock3, lock4;
1960   GThread *thread1, *thread2, *thread3, *thread4;
1961
1962   /* Locks for each thread. Each thread will keep reading data as long as the
1963    * thread is locked. */
1964   g_mutex_init (&lock1);
1965   g_mutex_init (&lock2);
1966   g_mutex_init (&lock3);
1967   g_mutex_init (&lock4);
1968
1969   if (thread_func == thread_func_tcp)
1970     start_tcp_server (TRUE);
1971   else
1972     start_server (TRUE);
1973
1974   /* Start the first receiver thread. */
1975   g_mutex_lock (&lock1);
1976   thread1 = g_thread_new ("thread1", thread_func, &lock1);
1977
1978   /* Connect and disconnect another client. */
1979   g_mutex_lock (&lock2);
1980   thread2 = g_thread_new ("thread2", thread_func, &lock2);
1981   g_mutex_unlock (&lock2);
1982   g_mutex_clear (&lock2);
1983   g_thread_join (thread2);
1984
1985   /* Do it again. */
1986   g_mutex_lock (&lock3);
1987   thread3 = g_thread_new ("thread3", thread_func, &lock3);
1988   g_mutex_unlock (&lock3);
1989   g_mutex_clear (&lock3);
1990   g_thread_join (thread3);
1991
1992   /* Disconnect the last client. This will clean up the media. */
1993   g_mutex_unlock (&lock1);
1994   g_mutex_clear (&lock1);
1995   g_thread_join (thread1);
1996
1997   /* Connect and disconnect another client. This will create and clean up the
1998    * media. */
1999   g_mutex_lock (&lock4);
2000   thread4 = g_thread_new ("thread4", thread_func, &lock4);
2001   g_mutex_unlock (&lock4);
2002   g_mutex_clear (&lock4);
2003   g_thread_join (thread4);
2004
2005   stop_server ();
2006   iterate ();
2007 }
2008
2009 /* Test adding and removing clients to a 'Shared' media.
2010  * CASE: unicast UDP */
2011 GST_START_TEST (test_shared_udp)
2012 {
2013   test_shared (thread_func_udp);
2014 }
2015
2016 GST_END_TEST;
2017
2018 /* Test adding and removing clients to a 'Shared' media.
2019  * CASE: unicast TCP */
2020 GST_START_TEST (test_shared_tcp)
2021 {
2022   test_shared (thread_func_tcp);
2023 }
2024
2025 GST_END_TEST;
2026
2027 GST_START_TEST (test_announce_without_sdp)
2028 {
2029   GstRTSPConnection *conn;
2030   GstRTSPStatusCode status;
2031   GstRTSPMessage *request;
2032   GstRTSPMessage *response;
2033
2034   start_record_server ("( fakesink name=depay0 )");
2035
2036   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
2037
2038   /* create and send ANNOUNCE request */
2039   request = create_request (conn, GST_RTSP_ANNOUNCE, NULL);
2040
2041   fail_unless (send_request (conn, request));
2042
2043   iterate ();
2044
2045   response = read_response (conn);
2046
2047   /* check response */
2048   gst_rtsp_message_parse_response (response, &status, NULL, NULL);
2049   fail_unless_equals_int (status, GST_RTSP_STS_BAD_REQUEST);
2050   gst_rtsp_message_free (response);
2051
2052   /* try again, this type with content-type, but still no SDP */
2053   gst_rtsp_message_add_header (request, GST_RTSP_HDR_CONTENT_TYPE,
2054       "application/sdp");
2055
2056   fail_unless (send_request (conn, request));
2057
2058   iterate ();
2059
2060   response = read_response (conn);
2061
2062   /* check response */
2063   gst_rtsp_message_parse_response (response, &status, NULL, NULL);
2064   fail_unless_equals_int (status, GST_RTSP_STS_BAD_REQUEST);
2065   gst_rtsp_message_free (response);
2066
2067   /* try again, this type with an unknown content-type */
2068   gst_rtsp_message_remove_header (request, GST_RTSP_HDR_CONTENT_TYPE, -1);
2069   gst_rtsp_message_add_header (request, GST_RTSP_HDR_CONTENT_TYPE,
2070       "application/x-something");
2071
2072   fail_unless (send_request (conn, request));
2073
2074   iterate ();
2075
2076   response = read_response (conn);
2077
2078   /* check response */
2079   gst_rtsp_message_parse_response (response, &status, NULL, NULL);
2080   fail_unless_equals_int (status, GST_RTSP_STS_BAD_REQUEST);
2081   gst_rtsp_message_free (response);
2082
2083   /* clean up and iterate so the clean-up can finish */
2084   gst_rtsp_message_free (request);
2085   gst_rtsp_connection_free (conn);
2086   stop_server ();
2087   iterate ();
2088 }
2089
2090 GST_END_TEST;
2091
2092 static GstRTSPStatusCode
2093 do_announce (GstRTSPConnection * conn, GstSDPMessage * sdp)
2094 {
2095   GstRTSPMessage *request;
2096   GstRTSPMessage *response;
2097   GstRTSPStatusCode code;
2098   gchar *str;
2099
2100   /* create request */
2101   request = create_request (conn, GST_RTSP_ANNOUNCE, NULL);
2102
2103   gst_rtsp_message_add_header (request, GST_RTSP_HDR_CONTENT_TYPE,
2104       "application/sdp");
2105
2106   /* add SDP to the response body */
2107   str = gst_sdp_message_as_text (sdp);
2108   gst_rtsp_message_take_body (request, (guint8 *) str, strlen (str));
2109   gst_sdp_message_free (sdp);
2110
2111   /* send request */
2112   fail_unless (send_request (conn, request));
2113   gst_rtsp_message_free (request);
2114
2115   iterate ();
2116
2117   /* read response */
2118   response = read_response (conn);
2119
2120   /* check status line */
2121   gst_rtsp_message_parse_response (response, &code, NULL, NULL);
2122
2123   gst_rtsp_message_free (response);
2124   return code;
2125 }
2126
2127 static void
2128 media_constructed_cb (GstRTSPMediaFactory * mfactory, GstRTSPMedia * media,
2129     gpointer user_data)
2130 {
2131   GstElement **p_sink = user_data;
2132   GstElement *bin;
2133
2134   bin = gst_rtsp_media_get_element (media);
2135   *p_sink = gst_bin_get_by_name (GST_BIN (bin), "sink");
2136   GST_INFO ("media constructed!: %" GST_PTR_FORMAT, *p_sink);
2137   gst_object_unref (bin);
2138 }
2139
2140 #define RECORD_N_BUFS 10
2141
2142 GST_START_TEST (test_record_tcp)
2143 {
2144   GstRTSPMediaFactory *mfactory;
2145   GstRTSPConnection *conn;
2146   GstRTSPStatusCode status;
2147   GstRTSPMessage *response;
2148   GstRTSPMessage *request;
2149   GstSDPMessage *sdp;
2150   GstRTSPResult rres;
2151   GSocketAddress *sa;
2152   GInetAddress *ia;
2153   GstElement *server_sink = NULL;
2154   GSocket *conn_socket;
2155   const gchar *proto;
2156   gchar *client_ip, *sess_id, *session = NULL;
2157   gint i;
2158
2159   mfactory =
2160       start_record_server
2161       ("( rtppcmadepay name=depay0 ! appsink name=sink async=false )");
2162
2163   g_signal_connect (mfactory, "media-constructed",
2164       G_CALLBACK (media_constructed_cb), &server_sink);
2165
2166   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
2167
2168   conn_socket = gst_rtsp_connection_get_read_socket (conn);
2169
2170   sa = g_socket_get_local_address (conn_socket, NULL);
2171   ia = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (sa));
2172   client_ip = g_inet_address_to_string (ia);
2173   if (g_socket_address_get_family (sa) == G_SOCKET_FAMILY_IPV6)
2174     proto = "IP6";
2175   else if (g_socket_address_get_family (sa) == G_SOCKET_FAMILY_IPV4)
2176     proto = "IP4";
2177   else
2178     g_assert_not_reached ();
2179   g_object_unref (sa);
2180
2181   gst_sdp_message_new (&sdp);
2182
2183   /* some standard things first */
2184   gst_sdp_message_set_version (sdp, "0");
2185
2186   /* session ID doesn't have to be super-unique in this case */
2187   sess_id = g_strdup_printf ("%u", g_random_int ());
2188   gst_sdp_message_set_origin (sdp, "-", sess_id, "1", "IN", proto, client_ip);
2189   g_free (sess_id);
2190   g_free (client_ip);
2191
2192   gst_sdp_message_set_session_name (sdp, "Session streamed with GStreamer");
2193   gst_sdp_message_set_information (sdp, "rtsp-server-test");
2194   gst_sdp_message_add_time (sdp, "0", "0", NULL);
2195   gst_sdp_message_add_attribute (sdp, "tool", "GStreamer");
2196
2197   /* add stream 0 */
2198   {
2199     GstSDPMedia *smedia;
2200
2201     gst_sdp_media_new (&smedia);
2202     gst_sdp_media_set_media (smedia, "audio");
2203     gst_sdp_media_add_format (smedia, "8");     /* pcma/alaw */
2204     gst_sdp_media_set_port_info (smedia, 0, 1);
2205     gst_sdp_media_set_proto (smedia, "RTP/AVP");
2206     gst_sdp_media_add_attribute (smedia, "rtpmap", "8 PCMA/8000");
2207     gst_sdp_message_add_media (sdp, smedia);
2208     gst_sdp_media_free (smedia);
2209   }
2210
2211   /* send ANNOUNCE request */
2212   status = do_announce (conn, sdp);
2213   fail_unless_equals_int (status, GST_RTSP_STS_OK);
2214
2215   /* create and send SETUP request */
2216   request = create_request (conn, GST_RTSP_SETUP, NULL);
2217   gst_rtsp_message_add_header (request, GST_RTSP_HDR_TRANSPORT,
2218       "RTP/AVP/TCP;interleaved=0;mode=record");
2219   fail_unless (send_request (conn, request));
2220   gst_rtsp_message_free (request);
2221   iterate ();
2222   response = read_response (conn);
2223   gst_rtsp_message_parse_response (response, &status, NULL, NULL);
2224   fail_unless_equals_int (status, GST_RTSP_STS_OK);
2225
2226   rres =
2227       gst_rtsp_message_get_header (response, GST_RTSP_HDR_SESSION, &session, 0);
2228   session = g_strdup (session);
2229   fail_unless_equals_int (rres, GST_RTSP_OK);
2230   gst_rtsp_message_free (response);
2231
2232   /* send RECORD */
2233   request = create_request (conn, GST_RTSP_RECORD, NULL);
2234   gst_rtsp_message_add_header (request, GST_RTSP_HDR_SESSION, session);
2235   fail_unless (send_request (conn, request));
2236   gst_rtsp_message_free (request);
2237   iterate ();
2238   response = read_response (conn);
2239   gst_rtsp_message_parse_response (response, &status, NULL, NULL);
2240   fail_unless_equals_int (status, GST_RTSP_STS_OK);
2241   gst_rtsp_message_free (response);
2242
2243   /* send some data */
2244   {
2245     GstElement *pipeline, *src, *enc, *pay, *sink;
2246
2247     pipeline = gst_pipeline_new ("send-pipeline");
2248     src = gst_element_factory_make ("audiotestsrc", NULL);
2249     g_object_set (src, "num-buffers", RECORD_N_BUFS,
2250         "samplesperbuffer", 1000, NULL);
2251     enc = gst_element_factory_make ("alawenc", NULL);
2252     pay = gst_element_factory_make ("rtppcmapay", NULL);
2253     sink = gst_element_factory_make ("appsink", NULL);
2254     fail_unless (pipeline && src && enc && pay && sink);
2255     gst_bin_add_many (GST_BIN (pipeline), src, enc, pay, sink, NULL);
2256     gst_element_link_many (src, enc, pay, sink, NULL);
2257     gst_element_set_state (pipeline, GST_STATE_PLAYING);
2258
2259     do {
2260       GstRTSPMessage *data_msg;
2261       GstMapInfo map = GST_MAP_INFO_INIT;
2262       GstRTSPResult rres;
2263       GstSample *sample = NULL;
2264       GstBuffer *buf;
2265
2266       g_signal_emit_by_name (G_OBJECT (sink), "pull-sample", &sample);
2267       if (sample == NULL)
2268         break;
2269       buf = gst_sample_get_buffer (sample);
2270       rres = gst_rtsp_message_new_data (&data_msg, 0);
2271       fail_unless_equals_int (rres, GST_RTSP_OK);
2272       gst_buffer_map (buf, &map, GST_MAP_READ);
2273       GST_INFO ("sending %u bytes of data on channel 0", (guint) map.size);
2274       GST_MEMDUMP ("data on channel 0", map.data, map.size);
2275       rres = gst_rtsp_message_set_body (data_msg, map.data, map.size);
2276       fail_unless_equals_int (rres, GST_RTSP_OK);
2277       gst_buffer_unmap (buf, &map);
2278       rres = gst_rtsp_connection_send (conn, data_msg, NULL);
2279       fail_unless_equals_int (rres, GST_RTSP_OK);
2280       gst_rtsp_message_free (data_msg);
2281       gst_sample_unref (sample);
2282     } while (TRUE);
2283
2284     gst_element_set_state (pipeline, GST_STATE_NULL);
2285     gst_object_unref (pipeline);
2286   }
2287
2288   /* check received data (we assume every buffer created by audiotestsrc and
2289    * subsequently encoded by mulawenc results in exactly one RTP packet) */
2290   for (i = 0; i < RECORD_N_BUFS; ++i) {
2291     GstSample *sample = NULL;
2292
2293     g_signal_emit_by_name (G_OBJECT (server_sink), "pull-sample", &sample);
2294     GST_INFO ("%2d recv sample: %p", i, sample);
2295     gst_sample_unref (sample);
2296   }
2297
2298   fail_unless_equals_int (GST_STATE (server_sink), GST_STATE_PLAYING);
2299
2300   /* clean up and iterate so the clean-up can finish */
2301   gst_rtsp_connection_free (conn);
2302   stop_server ();
2303   iterate ();
2304   g_free (session);
2305 }
2306
2307 GST_END_TEST;
2308
2309 static void
2310 do_test_multiple_transports (GstRTSPLowerTrans trans1, GstRTSPLowerTrans trans2)
2311 {
2312   GstRTSPConnection *conn1;
2313   GstRTSPConnection *conn2;
2314   GstSDPMessage *sdp_message1 = NULL;
2315   GstSDPMessage *sdp_message2 = NULL;
2316   const GstSDPMedia *sdp_media;
2317   const gchar *video_control;
2318   const gchar *audio_control;
2319   GstRTSPRange client_port1, client_port2;
2320   gchar *session1 = NULL;
2321   gchar *session2 = NULL;
2322   GstRTSPTransport *video_transport = NULL;
2323   GstRTSPTransport *audio_transport = NULL;
2324   GSocket *rtp_socket, *rtcp_socket;
2325
2326   conn1 = connect_to_server (test_port, TEST_MOUNT_POINT);
2327   conn2 = connect_to_server (test_port, TEST_MOUNT_POINT);
2328
2329   sdp_message1 = do_describe (conn1, TEST_MOUNT_POINT);
2330
2331   get_client_ports_full (&client_port1, &rtp_socket, &rtcp_socket);
2332   /* get control strings from DESCRIBE response */
2333   sdp_media = gst_sdp_message_get_media (sdp_message1, 0);
2334   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2335   sdp_media = gst_sdp_message_get_media (sdp_message1, 1);
2336   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2337
2338   /* do SETUP for video and audio */
2339   fail_unless (do_setup_full (conn1, video_control, trans1,
2340           &client_port1, NULL, &session1, &video_transport,
2341           NULL) == GST_RTSP_STS_OK);
2342   fail_unless (do_setup_full (conn1, audio_control, trans1,
2343           &client_port1, NULL, &session1, &audio_transport,
2344           NULL) == GST_RTSP_STS_OK);
2345
2346   gst_rtsp_transport_free (video_transport);
2347   gst_rtsp_transport_free (audio_transport);
2348
2349   sdp_message2 = do_describe (conn2, TEST_MOUNT_POINT);
2350
2351   /* get control strings from DESCRIBE response */
2352   sdp_media = gst_sdp_message_get_media (sdp_message2, 0);
2353   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2354   sdp_media = gst_sdp_message_get_media (sdp_message2, 1);
2355   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2356
2357   get_client_ports_full (&client_port2, NULL, NULL);
2358   /* do SETUP for video and audio */
2359   fail_unless (do_setup_full (conn2, video_control, trans2,
2360           &client_port2, NULL, &session2, &video_transport,
2361           NULL) == GST_RTSP_STS_OK);
2362   fail_unless (do_setup_full (conn2, audio_control, trans2,
2363           &client_port2, NULL, &session2, &audio_transport,
2364           NULL) == GST_RTSP_STS_OK);
2365
2366   /* send PLAY request and check that we get 200 OK */
2367   fail_unless (do_request (conn1, GST_RTSP_PLAY, NULL, session1, NULL, NULL,
2368           NULL, NULL, NULL, NULL, NULL, NULL) == GST_RTSP_STS_OK);
2369   /* send PLAY request and check that we get 200 OK */
2370   fail_unless (do_request (conn2, GST_RTSP_PLAY, NULL, session2, NULL, NULL,
2371           NULL, NULL, NULL, NULL, NULL, NULL) == GST_RTSP_STS_OK);
2372
2373
2374   /* receive UDP data */
2375   receive_rtp (rtp_socket, NULL);
2376   receive_rtcp (rtcp_socket, NULL, 0);
2377
2378   /* receive TCP data */
2379   {
2380     GstRTSPMessage *message;
2381     fail_unless (gst_rtsp_message_new (&message) == GST_RTSP_OK);
2382     fail_unless (gst_rtsp_connection_receive (conn2, message,
2383             NULL) == GST_RTSP_OK);
2384     fail_unless (gst_rtsp_message_get_type (message) == GST_RTSP_MESSAGE_DATA);
2385     gst_rtsp_message_free (message);
2386   }
2387
2388   /* send TEARDOWN request and check that we get 200 OK */
2389   fail_unless (do_simple_request (conn1, GST_RTSP_TEARDOWN,
2390           session1) == GST_RTSP_STS_OK);
2391   /* send TEARDOWN request and check that we get 200 OK */
2392   fail_unless (do_simple_request (conn2, GST_RTSP_TEARDOWN,
2393           session2) == GST_RTSP_STS_OK);
2394
2395   /* clean up and iterate so the clean-up can finish */
2396   g_object_unref (rtp_socket);
2397   g_object_unref (rtcp_socket);
2398   g_free (session1);
2399   g_free (session2);
2400   gst_rtsp_transport_free (video_transport);
2401   gst_rtsp_transport_free (audio_transport);
2402   gst_sdp_message_free (sdp_message1);
2403   gst_sdp_message_free (sdp_message2);
2404   gst_rtsp_connection_free (conn1);
2405   gst_rtsp_connection_free (conn2);
2406 }
2407
2408 GST_START_TEST (test_multiple_transports)
2409 {
2410   start_server (TRUE);
2411   do_test_multiple_transports (GST_RTSP_LOWER_TRANS_UDP,
2412       GST_RTSP_LOWER_TRANS_TCP);
2413   stop_server ();
2414 }
2415
2416 GST_END_TEST;
2417
2418 GST_START_TEST (test_suspend_mode_reset_only_audio)
2419 {
2420   GstRTSPMountPoints *mounts;
2421   gchar *service;
2422   GstRTSPMediaFactory *factory;
2423   GstRTSPConnection *conn;
2424   GstSDPMessage *sdp_message = NULL;
2425   const GstSDPMedia *sdp_media;
2426   const gchar *audio_control;
2427   GstRTSPRange client_port;
2428   gchar *session = NULL;
2429   GstRTSPTransport *audio_transport = NULL;
2430   GSocket *rtp_socket, *rtcp_socket;
2431
2432   mounts = gst_rtsp_server_get_mount_points (server);
2433
2434   factory = gst_rtsp_media_factory_new ();
2435   gst_rtsp_media_factory_set_suspend_mode (factory,
2436       GST_RTSP_SUSPEND_MODE_RESET);
2437   gst_rtsp_media_factory_set_launch (factory,
2438       "( " VIDEO_PIPELINE "  " AUDIO_PIPELINE " )");
2439   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
2440   g_object_unref (mounts);
2441
2442   /* set port to any */
2443   gst_rtsp_server_set_service (server, "0");
2444
2445   /* attach to default main context */
2446   source_id = gst_rtsp_server_attach (server, NULL);
2447   fail_if (source_id == 0);
2448
2449   /* get port */
2450   service = gst_rtsp_server_get_service (server);
2451   test_port = atoi (service);
2452   fail_unless (test_port != 0);
2453   g_free (service);
2454
2455   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
2456
2457   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
2458
2459   /* get control strings from DESCRIBE response */
2460   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
2461   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
2462   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2463
2464   get_client_ports_full (&client_port, &rtp_socket, &rtcp_socket);
2465
2466   /* do SETUP for audio */
2467   fail_unless (do_setup (conn, audio_control, &client_port, &session,
2468           &audio_transport) == GST_RTSP_STS_OK);
2469
2470   /* send PLAY request and check that we get 200 OK */
2471   fail_unless (do_simple_request (conn, GST_RTSP_PLAY,
2472           session) == GST_RTSP_STS_OK);
2473
2474   /* send TEARDOWN request and check that we get 200 OK */
2475   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
2476           session) == GST_RTSP_STS_OK);
2477
2478   /* clean up and iterate so the clean-up can finish */
2479   g_free (session);
2480   gst_rtsp_transport_free (audio_transport);
2481   gst_sdp_message_free (sdp_message);
2482   gst_rtsp_connection_free (conn);
2483
2484   stop_server ();
2485   iterate ();
2486 }
2487
2488 GST_END_TEST;
2489
2490
2491 static GstRTSPStatusCode
2492 adjust_play_mode (GstRTSPClient * client, GstRTSPContext * ctx,
2493     GstRTSPTimeRange ** range, GstSeekFlags * flags, gdouble * rate,
2494     GstClockTime * trickmode_interval, gboolean * enable_rate_control)
2495 {
2496   GstRTSPState rtspstate;
2497
2498   rtspstate = gst_rtsp_session_media_get_rtsp_state (ctx->sessmedia);
2499   if (rtspstate == GST_RTSP_STATE_PLAYING) {
2500     if (!gst_rtsp_session_media_set_state (ctx->sessmedia, GST_STATE_PAUSED))
2501       return GST_RTSP_STS_INTERNAL_SERVER_ERROR;
2502
2503     if (!gst_rtsp_media_unsuspend (ctx->media))
2504       return GST_RTSP_STS_INTERNAL_SERVER_ERROR;
2505   }
2506
2507   return GST_RTSP_STS_OK;
2508 }
2509
2510 GST_START_TEST (test_double_play)
2511 {
2512   GstRTSPMountPoints *mounts;
2513   gchar *service;
2514   GstRTSPMediaFactory *factory;
2515   GstRTSPConnection *conn;
2516   GstSDPMessage *sdp_message = NULL;
2517   const GstSDPMedia *sdp_media;
2518   const gchar *video_control;
2519   const gchar *audio_control;
2520   GstRTSPRange client_port;
2521   gchar *session = NULL;
2522   GstRTSPTransport *audio_transport = NULL;
2523   GstRTSPTransport *video_transport = NULL;
2524   GSocket *rtp_socket, *rtcp_socket;
2525   GstRTSPClient *client;
2526   GstRTSPClientClass *klass;
2527
2528   client = gst_rtsp_client_new ();
2529   klass = GST_RTSP_CLIENT_GET_CLASS (client);
2530   klass->adjust_play_mode = adjust_play_mode;
2531
2532   mounts = gst_rtsp_server_get_mount_points (server);
2533
2534   factory = gst_rtsp_media_factory_new ();
2535   gst_rtsp_media_factory_set_launch (factory,
2536       "( " VIDEO_PIPELINE "  " AUDIO_PIPELINE " )");
2537   gst_rtsp_mount_points_add_factory (mounts, TEST_MOUNT_POINT, factory);
2538   g_object_unref (mounts);
2539
2540
2541   /* set port to any */
2542   gst_rtsp_server_set_service (server, "0");
2543
2544   /* attach to default main context */
2545   source_id = gst_rtsp_server_attach (server, NULL);
2546   fail_if (source_id == 0);
2547
2548   /* get port */
2549   service = gst_rtsp_server_get_service (server);
2550   test_port = atoi (service);
2551   fail_unless (test_port != 0);
2552   g_free (service);
2553
2554   conn = connect_to_server (test_port, TEST_MOUNT_POINT);
2555
2556   sdp_message = do_describe (conn, TEST_MOUNT_POINT);
2557
2558   /* get control strings from DESCRIBE response */
2559   fail_unless (gst_sdp_message_medias_len (sdp_message) == 2);
2560   sdp_media = gst_sdp_message_get_media (sdp_message, 0);
2561   video_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2562   sdp_media = gst_sdp_message_get_media (sdp_message, 1);
2563   audio_control = gst_sdp_media_get_attribute_val (sdp_media, "control");
2564
2565   get_client_ports_full (&client_port, &rtp_socket, &rtcp_socket);
2566
2567   /* do SETUP for video */
2568   fail_unless (do_setup (conn, video_control, &client_port, &session,
2569           &video_transport) == GST_RTSP_STS_OK);
2570
2571   /* do SETUP for audio */
2572   fail_unless (do_setup (conn, audio_control, &client_port, &session,
2573           &audio_transport) == GST_RTSP_STS_OK);
2574
2575   /* send PLAY request and check that we get 200 OK */
2576   fail_unless (do_simple_request_rangein (conn, GST_RTSP_PLAY,
2577           session, "npt=0-") == GST_RTSP_STS_OK);
2578
2579   /* let it play for a while, so it needs to seek
2580    * for next play (npt=0-) */
2581   g_usleep (30000);
2582
2583   /* send PLAY request and check that we get 200 OK */
2584   fail_unless (do_simple_request_rangein (conn, GST_RTSP_PLAY,
2585           session, "npt=0-") == GST_RTSP_STS_OK);
2586
2587   /* send TEARDOWN request and check that we get 200 OK */
2588   fail_unless (do_simple_request (conn, GST_RTSP_TEARDOWN,
2589           session) == GST_RTSP_STS_OK);
2590
2591   /* clean up and iterate so the clean-up can finish */
2592   g_free (session);
2593   gst_rtsp_transport_free (video_transport);
2594   gst_rtsp_transport_free (audio_transport);
2595   gst_sdp_message_free (sdp_message);
2596   gst_rtsp_connection_free (conn);
2597
2598   stop_server ();
2599   iterate ();
2600 }
2601
2602 GST_END_TEST;
2603
2604
2605 static Suite *
2606 rtspserver_suite (void)
2607 {
2608   Suite *s = suite_create ("rtspserver");
2609   TCase *tc = tcase_create ("general");
2610
2611   suite_add_tcase (s, tc);
2612   tcase_add_checked_fixture (tc, setup, teardown);
2613   tcase_set_timeout (tc, 120);
2614   tcase_add_test (tc, test_connect);
2615   tcase_add_test (tc, test_describe);
2616   tcase_add_test (tc, test_describe_non_existing_mount_point);
2617   tcase_add_test (tc, test_describe_record_media);
2618   tcase_add_test (tc, test_setup_udp);
2619   tcase_add_test (tc, test_setup_tcp);
2620   tcase_add_test (tc, test_setup_udp_mcast);
2621   tcase_add_test (tc, test_setup_twice);
2622   tcase_add_test (tc, test_setup_with_require_header);
2623   tcase_add_test (tc, test_setup_non_existing_stream);
2624   tcase_add_test (tc, test_play);
2625   tcase_add_test (tc, test_play_tcp);
2626   tcase_add_test (tc, test_play_without_session);
2627   tcase_add_test (tc, test_bind_already_in_use);
2628   tcase_add_test (tc, test_play_multithreaded);
2629   tcase_add_test (tc, test_play_multithreaded_block_in_describe);
2630   tcase_add_test (tc, test_play_multithreaded_timeout_client);
2631   tcase_add_test (tc, test_play_multithreaded_timeout_session);
2632   tcase_add_test (tc, test_no_session_timeout);
2633   tcase_add_test (tc, test_play_one_active_stream);
2634   tcase_add_test (tc, test_play_disconnect);
2635   tcase_add_test (tc, test_play_specific_server_port);
2636   tcase_add_test (tc, test_play_smpte_range);
2637   tcase_add_test (tc, test_play_smpte_range_tcp);
2638   tcase_add_test (tc, test_shared_udp);
2639   tcase_add_test (tc, test_shared_tcp);
2640   tcase_add_test (tc, test_announce_without_sdp);
2641   tcase_add_test (tc, test_record_tcp);
2642   tcase_add_test (tc, test_multiple_transports);
2643   tcase_add_test (tc, test_suspend_mode_reset_only_audio);
2644   tcase_add_test (tc, test_double_play);
2645
2646   return s;
2647 }
2648
2649 GST_CHECK_MAIN (rtspserver);