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