gst-libs/gst/rtsp/gstrtspconnection.c

   1 /* GStreamer
   2  * Copyright (C) <2005-2009> Wim Taymans <wim.taymans@gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 /*
  20  * Unless otherwise indicated, Source Code is licensed under MIT license.
  21  * See further explanation attached in License Statement (distributed in the file
  22  * LICENSE).
  23  *
  24  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  25  * this software and associated documentation files (the "Software"), to deal in
  26  * the Software without restriction, including without limitation the rights to
  27  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  28  * of the Software, and to permit persons to whom the Software is furnished to do
  29  * so, subject to the following conditions:
  30  *
  31  * The above copyright notice and this permission notice shall be included in all
  32  * copies or substantial portions of the Software.
  33  *
  34  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  35  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  36  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  37  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  38  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  39  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  40  * SOFTWARE.
  41  */
  42
  43 /**
  44  * SECTION:gstrtspconnection
  45  * @short_description: manage RTSP connections
  46  * @see_also: gstrtspurl
  47  *
  48  * <refsect2>
  49  * <para>
  50  * This object manages the RTSP connection to the server. It provides function
  51  * to receive and send bytes and messages.
  52  * </para>
  53  * </refsect2>
  54  *
  55  * Last reviewed on 2007-07-24 (0.10.14)
  56  */
  57
  58 #ifdef HAVE_CONFIG_H
  59 #  include <config.h>
  60 #endif
  61
  62 #include <stdio.h>
  63 #include <errno.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66 #include <time.h>
  67
  68 #ifdef HAVE_UNISTD_H
  69 #include <unistd.h>
  70 #endif
  71
  72 /* we include this here to get the G_OS_* defines */
  73 #include <glib.h>
  74 #include <gst/gst.h>
  75
  76 #ifdef G_OS_WIN32
  77 /* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.
  78  * minwg32 headers check WINVER before allowing the use of these */
  79 #ifndef WINVER
  80 #define WINVER 0x0501
  81 #endif
  82 #include <winsock2.h>
  83 #include <ws2tcpip.h>
  84 #define EINPROGRESS WSAEINPROGRESS
  85 #else
  86 #include <sys/ioctl.h>
  87 #include <netdb.h>
  88 #include <sys/socket.h>
  89 #include <fcntl.h>
  90 #include <netinet/in.h>
  91 #endif
  92
  93 #ifdef HAVE_FIONREAD_IN_SYS_FILIO
  94 #include <sys/filio.h>
  95 #endif
  96
  97 #include "gstrtspconnection.h"
  98 #include "gstrtspbase64.h"
  99
 100 union gst_sockaddr
 101 {
 102   struct sockaddr sa;
 103   struct sockaddr_in sa_in;
 104   struct sockaddr_in6 sa_in6;
 105   struct sockaddr_storage sa_stor;
 106 };
 107
 108 typedef struct
 109 {
 110   gint state;
 111   guint save;
 112   guchar out[3];                /* the size must be evenly divisible by 3 */
 113   guint cout;
 114   guint coutl;
 115 } DecodeCtx;
 116
 117 #ifdef MSG_NOSIGNAL
 118 #define SEND_FLAGS MSG_NOSIGNAL
 119 #else
 120 #define SEND_FLAGS 0
 121 #endif
 122
 123 #ifdef G_OS_WIN32
 124 #define READ_SOCKET(fd, buf, len) recv (fd, (char *)buf, len, 0)
 125 #define WRITE_SOCKET(fd, buf, len) send (fd, (const char *)buf, len, SEND_FLAGS)
 126 #define SETSOCKOPT(sock, level, name, val, len) setsockopt (sock, level, name, (const char *)val, len)
 127 #define CLOSE_SOCKET(sock) closesocket (sock)
 128 #define ERRNO_IS_EAGAIN (WSAGetLastError () == WSAEWOULDBLOCK)
 129 #define ERRNO_IS_EINTR (WSAGetLastError () == WSAEINTR)
 130 /* According to Microsoft's connect() documentation this one returns
 131  * WSAEWOULDBLOCK and not WSAEINPROGRESS. */
 132 #define ERRNO_IS_EINPROGRESS (WSAGetLastError () == WSAEWOULDBLOCK)
 133 #else
 134 #define READ_SOCKET(fd, buf, len) read (fd, buf, len)
 135 #define WRITE_SOCKET(fd, buf, len) send (fd, buf, len, SEND_FLAGS)
 136 #define SETSOCKOPT(sock, level, name, val, len) setsockopt (sock, level, name, val, len)
 137 #define CLOSE_SOCKET(sock) close (sock)
 138 #define ERRNO_IS_EAGAIN (errno == EAGAIN)
 139 #define ERRNO_IS_EINTR (errno == EINTR)
 140 #define ERRNO_IS_EINPROGRESS (errno == EINPROGRESS)
 141 #endif
 142
 143 #define ADD_POLLFD(fdset, pfd, fd)        \
 144 G_STMT_START {                            \
 145   (pfd)->fd = fd;                         \
 146   gst_poll_add_fd (fdset, pfd);           \
 147 } G_STMT_END
 148
 149 #define REMOVE_POLLFD(fdset, pfd)          \
 150 G_STMT_START {                             \
 151   if ((pfd)->fd != -1) {                   \
 152     GST_DEBUG ("remove fd %d", (pfd)->fd); \
 153     gst_poll_remove_fd (fdset, pfd);       \
 154     CLOSE_SOCKET ((pfd)->fd);              \
 155     (pfd)->fd = -1;                        \
 156   }                                        \
 157 } G_STMT_END
 158
 159 typedef enum
 160 {
 161   TUNNEL_STATE_NONE,
 162   TUNNEL_STATE_GET,
 163   TUNNEL_STATE_POST,
 164   TUNNEL_STATE_COMPLETE
 165 } GstRTSPTunnelState;
 166
 167 #define TUNNELID_LEN   24
 168
 169 struct _GstRTSPConnection
 170 {
 171   /*< private > */
 172   /* URL for the connection */
 173   GstRTSPUrl *url;
 174
 175   /* connection state */
 176   GstPollFD fd0;
 177   GstPollFD fd1;
 178
 179   GstPollFD *readfd;
 180   GstPollFD *writefd;
 181
 182   gboolean manual_http;
 183
 184   gchar tunnelid[TUNNELID_LEN];
 185   gboolean tunneled;
 186   GstRTSPTunnelState tstate;
 187
 188   GstPoll *fdset;
 189   gchar *ip;
 190
 191   gint read_ahead;
 192
 193   gchar *initial_buffer;
 194   gsize initial_buffer_offset;
 195
 196   /* Session state */
 197   gint cseq;                    /* sequence number */
 198   gchar session_id[512];        /* session id */
 199   gint timeout;                 /* session timeout in seconds */
 200   GTimer *timer;                /* timeout timer */
 201
 202   /* Authentication */
 203   GstRTSPAuthMethod auth_method;
 204   gchar *username;
 205   gchar *passwd;
 206   GHashTable *auth_params;
 207
 208   DecodeCtx ctx;
 209   DecodeCtx *ctxp;
 210
 211   gchar *proxy_host;
 212   guint proxy_port;
 213 };
 214
 215 enum
 216 {
 217   STATE_START = 0,
 218   STATE_DATA_HEADER,
 219   STATE_DATA_BODY,
 220   STATE_READ_LINES,
 221   STATE_END,
 222   STATE_LAST
 223 };
 224
 225 enum
 226 {
 227   READ_AHEAD_EOH = -1,          /* end of headers */
 228   READ_AHEAD_CRLF = -2,
 229   READ_AHEAD_CRLFCR = -3
 230 };
 231
 232 /* a structure for constructing RTSPMessages */
 233 typedef struct
 234 {
 235   gint state;
 236   GstRTSPResult status;
 237   guint8 buffer[4096];
 238   guint offset;
 239
 240   guint line;
 241   guint8 *body_data;
 242   glong body_len;
 243 } GstRTSPBuilder;
 244
 245 static void
 246 build_reset (GstRTSPBuilder * builder)
 247 {
 248   g_free (builder->body_data);
 249   memset (builder, 0, sizeof (GstRTSPBuilder));
 250 }
 251
 252 /**
 253  * gst_rtsp_connection_create:
 254  * @url: a #GstRTSPUrl
 255  * @conn: storage for a #GstRTSPConnection
 256  *
 257  * Create a newly allocated #GstRTSPConnection from @url and store it in @conn.
 258  * The connection will not yet attempt to connect to @url, use
 259  * gst_rtsp_connection_connect().
 260  *
 261  * A copy of @url will be made.
 262  *
 263  * Returns: #GST_RTSP_OK when @conn contains a valid connection.
 264  */
 265 GstRTSPResult
 266 gst_rtsp_connection_create (const GstRTSPUrl * url, GstRTSPConnection ** conn)
 267 {
 268   GstRTSPConnection *newconn;
 269 #ifdef G_OS_WIN32
 270   WSADATA w;
 271   int error;
 272 #endif
 273
 274   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
 275
 276 #ifdef G_OS_WIN32
 277   error = WSAStartup (0x0202, &w);
 278
 279   if (error)
 280     goto startup_error;
 281
 282   if (w.wVersion != 0x0202)
 283     goto version_error;
 284 #endif
 285
 286   newconn = g_new0 (GstRTSPConnection, 1);
 287
 288   if ((newconn->fdset = gst_poll_new (TRUE)) == NULL)
 289     goto no_fdset;
 290
 291   newconn->url = gst_rtsp_url_copy (url);
 292   newconn->fd0.fd = -1;
 293   newconn->fd1.fd = -1;
 294   newconn->timer = g_timer_new ();
 295   newconn->timeout = 60;
 296   newconn->cseq = 1;
 297
 298   newconn->auth_method = GST_RTSP_AUTH_NONE;
 299   newconn->username = NULL;
 300   newconn->passwd = NULL;
 301   newconn->auth_params = NULL;
 302
 303   *conn = newconn;
 304
 305   return GST_RTSP_OK;
 306
 307   /* ERRORS */
 308 #ifdef G_OS_WIN32
 309 startup_error:
 310   {
 311     g_warning ("Error %d on WSAStartup", error);
 312     return GST_RTSP_EWSASTART;
 313   }
 314 version_error:
 315   {
 316     g_warning ("Windows sockets are not version 0x202 (current 0x%x)",
 317         w.wVersion);
 318     WSACleanup ();
 319     return GST_RTSP_EWSAVERSION;
 320   }
 321 #endif
 322 no_fdset:
 323   {
 324     g_free (newconn);
 325 #ifdef G_OS_WIN32
 326     WSACleanup ();
 327 #endif
 328     return GST_RTSP_ESYS;
 329   }
 330 }
 331
 332 /**
 333  * gst_rtsp_connection_create_from_fd:
 334  * @fd: a file descriptor
 335  * @ip: the IP address of the other end
 336  * @port: the port used by the other end
 337  * @initial_buffer: data already read from @fd
 338  * @conn: storage for a #GstRTSPConnection
 339  *
 340  * Create a new #GstRTSPConnection for handling communication on the existing
 341  * file descriptor @fd. The @initial_buffer contains any data already read from
 342  * @fd which should be used before starting to read new data.
 343  *
 344  * Returns: #GST_RTSP_OK when @conn contains a valid connection.
 345  *
 346  * Since: 0.10.25
 347  */
 348 GstRTSPResult
 349 gst_rtsp_connection_create_from_fd (gint fd, const gchar * ip, guint16 port,
 350     const gchar * initial_buffer, GstRTSPConnection ** conn)
 351 {
 352   GstRTSPConnection *newconn = NULL;
 353   GstRTSPUrl *url;
 354 #ifdef G_OS_WIN32
 355   gulong flags = 1;
 356 #endif
 357   GstRTSPResult res;
 358
 359   g_return_val_if_fail (fd >= 0, GST_RTSP_EINVAL);
 360   g_return_val_if_fail (ip != NULL, GST_RTSP_EINVAL);
 361   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
 362
 363   /* set to non-blocking mode so that we can cancel the communication */
 364 #ifndef G_OS_WIN32
 365   fcntl (fd, F_SETFL, O_NONBLOCK);
 366 #else
 367   ioctlsocket (fd, FIONBIO, &flags);
 368 #endif /* G_OS_WIN32 */
 369
 370   /* create a url for the client address */
 371   url = g_new0 (GstRTSPUrl, 1);
 372   url->host = g_strdup (ip);
 373   url->port = port;
 374
 375   /* now create the connection object */
 376   GST_RTSP_CHECK (gst_rtsp_connection_create (url, &newconn), newconn_failed);
 377   gst_rtsp_url_free (url);
 378
 379   ADD_POLLFD (newconn->fdset, &newconn->fd0, fd);
 380
 381   /* both read and write initially */
 382   newconn->readfd = &newconn->fd0;
 383   newconn->writefd = &newconn->fd0;
 384
 385   newconn->ip = g_strdup (ip);
 386
 387   newconn->initial_buffer = g_strdup (initial_buffer);
 388
 389   *conn = newconn;
 390
 391   return GST_RTSP_OK;
 392
 393   /* ERRORS */
 394 newconn_failed:
 395   {
 396     gst_rtsp_url_free (url);
 397     return res;
 398   }
 399 }
 400
 401 /**
 402  * gst_rtsp_connection_accept:
 403  * @sock: a socket
 404  * @conn: storage for a #GstRTSPConnection
 405  *
 406  * Accept a new connection on @sock and create a new #GstRTSPConnection for
 407  * handling communication on new socket.
 408  *
 409  * Returns: #GST_RTSP_OK when @conn contains a valid connection.
 410  *
 411  * Since: 0.10.23
 412  */
 413 GstRTSPResult
 414 gst_rtsp_connection_accept (gint sock, GstRTSPConnection ** conn)
 415 {
 416   int fd;
 417   union gst_sockaddr sa;
 418   socklen_t slen = sizeof (sa);
 419   gchar ip[INET6_ADDRSTRLEN];
 420   guint16 port;
 421
 422   g_return_val_if_fail (sock >= 0, GST_RTSP_EINVAL);
 423   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
 424
 425   memset (&sa, 0, slen);
 426
 427 #ifndef G_OS_WIN32
 428   fd = accept (sock, &sa.sa, &slen);
 429 #else
 430   fd = accept (sock, &sa.sa, (gint *) & slen);
 431 #endif /* G_OS_WIN32 */
 432   if (fd == -1)
 433     goto accept_failed;
 434
 435   if (getnameinfo (&sa.sa, slen, ip, sizeof (ip), NULL, 0, NI_NUMERICHOST) != 0)
 436     goto getnameinfo_failed;
 437
 438   if (sa.sa.sa_family == AF_INET)
 439     port = sa.sa_in.sin_port;
 440   else if (sa.sa.sa_family == AF_INET6)
 441     port = sa.sa_in6.sin6_port;
 442   else
 443     goto wrong_family;
 444
 445   return gst_rtsp_connection_create_from_fd (fd, ip, port, NULL, conn);
 446
 447   /* ERRORS */
 448 accept_failed:
 449   {
 450     return GST_RTSP_ESYS;
 451   }
 452 getnameinfo_failed:
 453 wrong_family:
 454   {
 455     CLOSE_SOCKET (fd);
 456     return GST_RTSP_ERROR;
 457   }
 458 }
 459
 460 static gchar *
 461 do_resolve (const gchar * host)
 462 {
 463   static gchar ip[INET6_ADDRSTRLEN];
 464   struct addrinfo *aires;
 465   struct addrinfo *ai;
 466   gint aierr;
 467
 468   aierr = getaddrinfo (host, NULL, NULL, &aires);
 469   if (aierr != 0)
 470     goto no_addrinfo;
 471
 472   for (ai = aires; ai; ai = ai->ai_next) {
 473     if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {
 474       break;
 475     }
 476   }
 477   if (ai == NULL)
 478     goto no_family;
 479
 480   aierr = getnameinfo (ai->ai_addr, ai->ai_addrlen, ip, sizeof (ip), NULL, 0,
 481       NI_NUMERICHOST | NI_NUMERICSERV);
 482   if (aierr != 0)
 483     goto no_address;
 484
 485   freeaddrinfo (aires);
 486
 487   return g_strdup (ip);
 488
 489   /* ERRORS */
 490 no_addrinfo:
 491   {
 492     GST_ERROR ("no addrinfo found for %s: %s", host, gai_strerror (aierr));
 493     return NULL;
 494   }
 495 no_family:
 496   {
 497     GST_ERROR ("no family found for %s", host);
 498     freeaddrinfo (aires);
 499     return NULL;
 500   }
 501 no_address:
 502   {
 503     GST_ERROR ("no address found for %s: %s", host, gai_strerror (aierr));
 504     freeaddrinfo (aires);
 505     return NULL;
 506   }
 507 }
 508
 509 static GstRTSPResult
 510 do_connect (const gchar * ip, guint16 port, GstPollFD * fdout,
 511     GstPoll * fdset, GTimeVal * timeout)
 512 {
 513   gint fd;
 514   struct addrinfo hints;
 515   struct addrinfo *aires;
 516   struct addrinfo *ai;
 517   gint aierr;
 518   gchar service[NI_MAXSERV];
 519   gint ret;
 520 #ifdef G_OS_WIN32
 521   unsigned long flags = 1;
 522 #endif /* G_OS_WIN32 */
 523   GstClockTime to;
 524   gint retval;
 525
 526   memset (&hints, 0, sizeof hints);
 527   hints.ai_flags = AI_NUMERICHOST;
 528   hints.ai_family = AF_UNSPEC;
 529   hints.ai_socktype = SOCK_STREAM;
 530   g_snprintf (service, sizeof (service) - 1, "%hu", port);
 531   service[sizeof (service) - 1] = '\0';
 532
 533   aierr = getaddrinfo (ip, service, &hints, &aires);
 534   if (aierr != 0)
 535     goto no_addrinfo;
 536
 537   for (ai = aires; ai; ai = ai->ai_next) {
 538     if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {
 539       break;
 540     }
 541   }
 542   if (ai == NULL)
 543     goto no_family;
 544
 545   fd = socket (ai->ai_family, SOCK_STREAM, 0);
 546   if (fd == -1)
 547     goto no_socket;
 548
 549   /* set to non-blocking mode so that we can cancel the connect */
 550 #ifndef G_OS_WIN32
 551   fcntl (fd, F_SETFL, O_NONBLOCK);
 552 #else
 553   ioctlsocket (fd, FIONBIO, &flags);
 554 #endif /* G_OS_WIN32 */
 555
 556   /* add the socket to our fdset */
 557   ADD_POLLFD (fdset, fdout, fd);
 558
 559   /* we are going to connect ASYNC now */
 560   ret = connect (fd, ai->ai_addr, ai->ai_addrlen);
 561   if (ret == 0)
 562     goto done;
 563   if (!ERRNO_IS_EINPROGRESS)
 564     goto sys_error;
 565
 566   /* wait for connect to complete up to the specified timeout or until we got
 567    * interrupted. */
 568   gst_poll_fd_ctl_write (fdset, fdout, TRUE);
 569
 570   to = timeout ? GST_TIMEVAL_TO_TIME (*timeout) : GST_CLOCK_TIME_NONE;
 571
 572   do {
 573     retval = gst_poll_wait (fdset, to);
 574   } while (retval == -1 && (errno == EINTR || errno == EAGAIN));
 575
 576   if (retval == 0)
 577     goto timeout;
 578   else if (retval == -1)
 579     goto sys_error;
 580
 581   /* we can still have an error connecting on windows */
 582   if (gst_poll_fd_has_error (fdset, fdout)) {
 583     socklen_t len = sizeof (errno);
 584 #ifndef G_OS_WIN32
 585     getsockopt (fd, SOL_SOCKET, SO_ERROR, &errno, &len);
 586 #else
 587     getsockopt (fd, SOL_SOCKET, SO_ERROR, (char *) &errno, &len);
 588 #endif
 589     goto sys_error;
 590   }
 591
 592   gst_poll_fd_ignored (fdset, fdout);
 593
 594 done:
 595   freeaddrinfo (aires);
 596
 597   return GST_RTSP_OK;
 598
 599   /* ERRORS */
 600 no_addrinfo:
 601   {
 602     GST_ERROR ("no addrinfo found for %s: %s", ip, gai_strerror (aierr));
 603     return GST_RTSP_ERROR;
 604   }
 605 no_family:
 606   {
 607     GST_ERROR ("no family found for %s", ip);
 608     freeaddrinfo (aires);
 609     return GST_RTSP_ERROR;
 610   }
 611 no_socket:
 612   {
 613     GST_ERROR ("no socket %d (%s)", errno, g_strerror (errno));
 614     freeaddrinfo (aires);
 615     return GST_RTSP_ESYS;
 616   }
 617 sys_error:
 618   {
 619     GST_ERROR ("system error %d (%s)", errno, g_strerror (errno));
 620     REMOVE_POLLFD (fdset, fdout);
 621     freeaddrinfo (aires);
 622     return GST_RTSP_ESYS;
 623   }
 624 timeout:
 625   {
 626     GST_ERROR ("timeout");
 627     REMOVE_POLLFD (fdset, fdout);
 628     freeaddrinfo (aires);
 629     return GST_RTSP_ETIMEOUT;
 630   }
 631 }
 632
 633 static GstRTSPResult
 634 setup_tunneling (GstRTSPConnection * conn, GTimeVal * timeout)
 635 {
 636   gint i;
 637   GstRTSPResult res;
 638   gchar *ip;
 639   gchar *uri;
 640   gchar *value;
 641   guint16 port, url_port;
 642   GstRTSPUrl *url;
 643   gchar *hostparam;
 644   GstRTSPMessage *msg;
 645   GstRTSPMessage response;
 646   gboolean old_http;
 647
 648   memset (&response, 0, sizeof (response));
 649   gst_rtsp_message_init (&response);
 650
 651   /* create a random sessionid */
 652   for (i = 0; i < TUNNELID_LEN; i++)
 653     conn->tunnelid[i] = g_random_int_range ('a', 'z');
 654   conn->tunnelid[TUNNELID_LEN - 1] = '\0';
 655
 656   url = conn->url;
 657   /* get the port from the url */
 658   gst_rtsp_url_get_port (url, &url_port);
 659
 660   if (conn->proxy_host) {
 661     uri = g_strdup_printf ("http://%s:%d%s%s%s", url->host, url_port,
 662         url->abspath, url->query ? "?" : "", url->query ? url->query : "");
 663     hostparam = g_strdup_printf ("%s:%d", url->host, url_port);
 664     ip = conn->proxy_host;
 665     port = conn->proxy_port;
 666   } else {
 667     uri = g_strdup_printf ("%s%s%s", url->abspath, url->query ? "?" : "",
 668         url->query ? url->query : "");
 669     hostparam = NULL;
 670     ip = conn->ip;
 671     port = url_port;
 672   }
 673
 674   /* create the GET request for the read connection */
 675   GST_RTSP_CHECK (gst_rtsp_message_new_request (&msg, GST_RTSP_GET, uri),
 676       no_message);
 677   msg->type = GST_RTSP_MESSAGE_HTTP_REQUEST;
 678
 679   if (hostparam != NULL)
 680     gst_rtsp_message_add_header (msg, GST_RTSP_HDR_HOST, hostparam);
 681   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_X_SESSIONCOOKIE,
 682       conn->tunnelid);
 683   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_ACCEPT,
 684       "application/x-rtsp-tunnelled");
 685   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CACHE_CONTROL, "no-cache");
 686   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_PRAGMA, "no-cache");
 687
 688   /* we start by writing to this fd */
 689   conn->writefd = &conn->fd0;
 690
 691   /* we need to temporarily set conn->tunneled to FALSE to prevent the HTTP
 692    * request from being base64 encoded */
 693   conn->tunneled = FALSE;
 694   GST_RTSP_CHECK (gst_rtsp_connection_send (conn, msg, timeout), write_failed);
 695   gst_rtsp_message_free (msg);
 696   conn->tunneled = TRUE;
 697
 698   /* receive the response to the GET request */
 699   /* we need to temporarily set manual_http to TRUE since
 700    * gst_rtsp_connection_receive() will treat the HTTP response as a parsing
 701    * failure otherwise */
 702   old_http = conn->manual_http;
 703   conn->manual_http = TRUE;
 704   GST_RTSP_CHECK (gst_rtsp_connection_receive (conn, &response, timeout),
 705       read_failed);
 706   conn->manual_http = old_http;
 707
 708   if (response.type != GST_RTSP_MESSAGE_HTTP_RESPONSE ||
 709       response.type_data.response.code != GST_RTSP_STS_OK)
 710     goto wrong_result;
 711
 712   if (gst_rtsp_message_get_header (&response, GST_RTSP_HDR_X_SERVER_IP_ADDRESS,
 713           &value, 0) != GST_RTSP_OK) {
 714     if (conn->proxy_host) {
 715       /* if we use a proxy we need to change the destination url */
 716       g_free (url->host);
 717       url->host = g_strdup (value);
 718       g_free (hostparam);
 719       hostparam = g_strdup_printf ("%s:%d", url->host, url_port);
 720     } else {
 721       /* and resolve the new ip address */
 722       if (!(ip = do_resolve (conn->ip)))
 723         goto not_resolved;
 724       g_free (conn->ip);
 725       conn->ip = ip;
 726     }
 727   }
 728
 729   /* connect to the host/port */
 730   res = do_connect (ip, port, &conn->fd1, conn->fdset, timeout);
 731   if (res != GST_RTSP_OK)
 732     goto connect_failed;
 733
 734   /* this is now our writing socket */
 735   conn->writefd = &conn->fd1;
 736
 737   /* create the POST request for the write connection */
 738   GST_RTSP_CHECK (gst_rtsp_message_new_request (&msg, GST_RTSP_POST, uri),
 739       no_message);
 740   msg->type = GST_RTSP_MESSAGE_HTTP_REQUEST;
 741
 742   if (hostparam != NULL)
 743     gst_rtsp_message_add_header (msg, GST_RTSP_HDR_HOST, hostparam);
 744   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_X_SESSIONCOOKIE,
 745       conn->tunnelid);
 746   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_ACCEPT,
 747       "application/x-rtsp-tunnelled");
 748   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CACHE_CONTROL, "no-cache");
 749   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_PRAGMA, "no-cache");
 750   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_EXPIRES,
 751       "Sun, 9 Jan 1972 00:00:00 GMT");
 752   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CONTENT_LENGTH, "32767");
 753
 754   /* we need to temporarily set conn->tunneled to FALSE to prevent the HTTP
 755    * request from being base64 encoded */
 756   conn->tunneled = FALSE;
 757   GST_RTSP_CHECK (gst_rtsp_connection_send (conn, msg, timeout), write_failed);
 758   gst_rtsp_message_free (msg);
 759   conn->tunneled = TRUE;
 760
 761 exit:
 762   gst_rtsp_message_unset (&response);
 763   g_free (hostparam);
 764   g_free (uri);
 765
 766   return res;
 767
 768   /* ERRORS */
 769 no_message:
 770   {
 771     GST_ERROR ("failed to create request (%d)", res);
 772     goto exit;
 773   }
 774 write_failed:
 775   {
 776     GST_ERROR ("write failed (%d)", res);
 777     gst_rtsp_message_free (msg);
 778     conn->tunneled = TRUE;
 779     goto exit;
 780   }
 781 read_failed:
 782   {
 783     GST_ERROR ("read failed (%d)", res);
 784     conn->manual_http = FALSE;
 785     goto exit;
 786   }
 787 wrong_result:
 788   {
 789     GST_ERROR ("got failure response %d %s", response.type_data.response.code,
 790         response.type_data.response.reason);
 791     res = GST_RTSP_ERROR;
 792     goto exit;
 793   }
 794 not_resolved:
 795   {
 796     GST_ERROR ("could not resolve %s", conn->ip);
 797     res = GST_RTSP_ENET;
 798     goto exit;
 799   }
 800 connect_failed:
 801   {
 802     GST_ERROR ("failed to connect");
 803     goto exit;
 804   }
 805 }
 806
 807 /**
 808  * gst_rtsp_connection_connect:
 809  * @conn: a #GstRTSPConnection
 810  * @timeout: a #GTimeVal timeout
 811  *
 812  * Attempt to connect to the url of @conn made with
 813  * gst_rtsp_connection_create(). If @timeout is #NULL this function can block
 814  * forever. If @timeout contains a valid timeout, this function will return
 815  * #GST_RTSP_ETIMEOUT after the timeout expired.
 816  *
 817  * This function can be cancelled with gst_rtsp_connection_flush().
 818  *
 819  * Returns: #GST_RTSP_OK when a connection could be made.
 820  */
 821 GstRTSPResult
 822 gst_rtsp_connection_connect (GstRTSPConnection * conn, GTimeVal * timeout)
 823 {
 824   GstRTSPResult res;
 825   gchar *ip;
 826   guint16 port;
 827   GstRTSPUrl *url;
 828
 829   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
 830   g_return_val_if_fail (conn->url != NULL, GST_RTSP_EINVAL);
 831   g_return_val_if_fail (conn->fd0.fd < 0, GST_RTSP_EINVAL);
 832
 833   url = conn->url;
 834
 835   if (conn->proxy_host && conn->tunneled) {
 836     if (!(ip = do_resolve (conn->proxy_host))) {
 837       GST_ERROR ("could not resolve %s", conn->proxy_host);
 838       goto not_resolved;
 839     }
 840     port = conn->proxy_port;
 841     g_free (conn->proxy_host);
 842     conn->proxy_host = ip;
 843   } else {
 844     if (!(ip = do_resolve (url->host))) {
 845       GST_ERROR ("could not resolve %s", url->host);
 846       goto not_resolved;
 847     }
 848     /* get the port from the url */
 849     gst_rtsp_url_get_port (url, &port);
 850
 851     g_free (conn->ip);
 852     conn->ip = ip;
 853   }
 854
 855   /* connect to the host/port */
 856   res = do_connect (ip, port, &conn->fd0, conn->fdset, timeout);
 857   if (res != GST_RTSP_OK)
 858     goto connect_failed;
 859
 860   /* this is our read URL */
 861   conn->readfd = &conn->fd0;
 862
 863   if (conn->tunneled) {
 864     res = setup_tunneling (conn, timeout);
 865     if (res != GST_RTSP_OK)
 866       goto tunneling_failed;
 867   } else {
 868     conn->writefd = &conn->fd0;
 869   }
 870
 871   return GST_RTSP_OK;
 872
 873 not_resolved:
 874   {
 875     return GST_RTSP_ENET;
 876   }
 877 connect_failed:
 878   {
 879     GST_ERROR ("failed to connect");
 880     return res;
 881   }
 882 tunneling_failed:
 883   {
 884     GST_ERROR ("failed to setup tunneling");
 885     return res;
 886   }
 887 }
 888
 889 static void
 890 auth_digest_compute_hex_urp (const gchar * username,
 891     const gchar * realm, const gchar * password, gchar hex_urp[33])
 892 {
 893   GChecksum *md5_context = g_checksum_new (G_CHECKSUM_MD5);
 894   const gchar *digest_string;
 895
 896   g_checksum_update (md5_context, (const guchar *) username, strlen (username));
 897   g_checksum_update (md5_context, (const guchar *) ":", 1);
 898   g_checksum_update (md5_context, (const guchar *) realm, strlen (realm));
 899   g_checksum_update (md5_context, (const guchar *) ":", 1);
 900   g_checksum_update (md5_context, (const guchar *) password, strlen (password));
 901   digest_string = g_checksum_get_string (md5_context);
 902
 903   memset (hex_urp, 0, 33);
 904   memcpy (hex_urp, digest_string, strlen (digest_string));
 905
 906   g_checksum_free (md5_context);
 907 }
 908
 909 static void
 910 auth_digest_compute_response (const gchar * method,
 911     const gchar * uri, const gchar * hex_a1, const gchar * nonce,
 912     gchar response[33])
 913 {
 914   char hex_a2[33] = { 0, };
 915   GChecksum *md5_context = g_checksum_new (G_CHECKSUM_MD5);
 916   const gchar *digest_string;
 917
 918   /* compute A2 */
 919   g_checksum_update (md5_context, (const guchar *) method, strlen (method));
 920   g_checksum_update (md5_context, (const guchar *) ":", 1);
 921   g_checksum_update (md5_context, (const guchar *) uri, strlen (uri));
 922   digest_string = g_checksum_get_string (md5_context);
 923   memcpy (hex_a2, digest_string, strlen (digest_string));
 924
 925   /* compute KD */
 926   g_checksum_reset (md5_context);
 927   g_checksum_update (md5_context, (const guchar *) hex_a1, strlen (hex_a1));
 928   g_checksum_update (md5_context, (const guchar *) ":", 1);
 929   g_checksum_update (md5_context, (const guchar *) nonce, strlen (nonce));
 930   g_checksum_update (md5_context, (const guchar *) ":", 1);
 931
 932   g_checksum_update (md5_context, (const guchar *) hex_a2, 32);
 933   digest_string = g_checksum_get_string (md5_context);
 934   memset (response, 0, 33);
 935   memcpy (response, digest_string, strlen (digest_string));
 936
 937   g_checksum_free (md5_context);
 938 }
 939
 940 static void
 941 add_auth_header (GstRTSPConnection * conn, GstRTSPMessage * message)
 942 {
 943   switch (conn->auth_method) {
 944     case GST_RTSP_AUTH_BASIC:{
 945       gchar *user_pass;
 946       gchar *user_pass64;
 947       gchar *auth_string;
 948
 949       user_pass = g_strdup_printf ("%s:%s", conn->username, conn->passwd);
 950       user_pass64 = g_base64_encode ((guchar *) user_pass, strlen (user_pass));
 951       auth_string = g_strdup_printf ("Basic %s", user_pass64);
 952
 953       gst_rtsp_message_take_header (message, GST_RTSP_HDR_AUTHORIZATION,
 954           auth_string);
 955
 956       g_free (user_pass);
 957       g_free (user_pass64);
 958       break;
 959     }
 960     case GST_RTSP_AUTH_DIGEST:{
 961       gchar response[33], hex_urp[33];
 962       gchar *auth_string, *auth_string2;
 963       gchar *realm;
 964       gchar *nonce;
 965       gchar *opaque;
 966       const gchar *uri;
 967       const gchar *method;
 968
 969       /* we need to have some params set */
 970       if (conn->auth_params == NULL)
 971         break;
 972
 973       /* we need the realm and nonce */
 974       realm = (gchar *) g_hash_table_lookup (conn->auth_params, "realm");
 975       nonce = (gchar *) g_hash_table_lookup (conn->auth_params, "nonce");
 976       if (realm == NULL || nonce == NULL)
 977         break;
 978
 979       auth_digest_compute_hex_urp (conn->username, realm, conn->passwd,
 980           hex_urp);
 981
 982       method = gst_rtsp_method_as_text (message->type_data.request.method);
 983       uri = message->type_data.request.uri;
 984
 985       /* Assume no qop, algorithm=md5, stale=false */
 986       /* For algorithm MD5, a1 = urp. */
 987       auth_digest_compute_response (method, uri, hex_urp, nonce, response);
 988       auth_string = g_strdup_printf ("Digest username=\"%s\", "
 989           "realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
 990           conn->username, realm, nonce, uri, response);
 991
 992       opaque = (gchar *) g_hash_table_lookup (conn->auth_params, "opaque");
 993       if (opaque) {
 994         auth_string2 = g_strdup_printf ("%s, opaque=\"%s\"", auth_string,
 995             opaque);
 996         g_free (auth_string);
 997         auth_string = auth_string2;
 998       }
 999       gst_rtsp_message_take_header (message, GST_RTSP_HDR_AUTHORIZATION,
1000           auth_string);
1001       break;
1002     }
1003     default:
1004       /* Nothing to do */
1005       break;
1006   }
1007 }
1008
1009 static void
1010 gen_date_string (gchar * date_string, guint len)
1011 {
1012   GTimeVal tv;
1013   time_t t;
1014 #ifdef HAVE_GMTIME_R
1015   struct tm tm_;
1016 #endif
1017
1018   g_get_current_time (&tv);
1019   t = (time_t) tv.tv_sec;
1020
1021 #ifdef HAVE_GMTIME_R
1022   strftime (date_string, len, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r (&t, &tm_));
1023 #else
1024   strftime (date_string, len, "%a, %d %b %Y %H:%M:%S GMT", gmtime (&t));
1025 #endif
1026 }
1027
1028 static GstRTSPResult
1029 write_bytes (gint fd, const guint8 * buffer, guint * idx, guint size)
1030 {
1031   guint left;
1032
1033   if (G_UNLIKELY (*idx > size))
1034     return GST_RTSP_ERROR;
1035
1036   left = size - *idx;
1037
1038   while (left) {
1039     gint r;
1040
1041     r = WRITE_SOCKET (fd, &buffer[*idx], left);
1042     if (G_UNLIKELY (r == 0)) {
1043       return GST_RTSP_EINTR;
1044     } else if (G_UNLIKELY (r < 0)) {
1045       if (ERRNO_IS_EAGAIN)
1046         return GST_RTSP_EINTR;
1047       if (!ERRNO_IS_EINTR)
1048         return GST_RTSP_ESYS;
1049     } else {
1050       left -= r;
1051       *idx += r;
1052     }
1053   }
1054   return GST_RTSP_OK;
1055 }
1056
1057 static gint
1058 fill_raw_bytes (GstRTSPConnection * conn, guint8 * buffer, guint size)
1059 {
1060   gint out = 0;
1061
1062   if (G_UNLIKELY (conn->initial_buffer != NULL)) {
1063     gsize left = strlen (&conn->initial_buffer[conn->initial_buffer_offset]);
1064
1065     out = MIN (left, size);
1066     memcpy (buffer, &conn->initial_buffer[conn->initial_buffer_offset], out);
1067
1068     if (left == (gsize) out) {
1069       g_free (conn->initial_buffer);
1070       conn->initial_buffer = NULL;
1071       conn->initial_buffer_offset = 0;
1072     } else
1073       conn->initial_buffer_offset += out;
1074   }
1075
1076   if (G_LIKELY (size > (guint) out)) {
1077     gint r;
1078
1079     r = READ_SOCKET (conn->readfd->fd, &buffer[out], size - out);
1080     if (r <= 0) {
1081       if (out == 0)
1082         out = r;
1083     } else
1084       out += r;
1085   }
1086
1087   return out;
1088 }
1089
1090 static gint
1091 fill_bytes (GstRTSPConnection * conn, guint8 * buffer, guint size)
1092 {
1093   DecodeCtx *ctx = conn->ctxp;
1094   gint out = 0;
1095
1096   if (ctx) {
1097     while (size > 0) {
1098       guint8 in[sizeof (ctx->out) * 4 / 3];
1099       gint r;
1100
1101       while (size > 0 && ctx->cout < ctx->coutl) {
1102         /* we have some leftover bytes */
1103         *buffer++ = ctx->out[ctx->cout++];
1104         size--;
1105         out++;
1106       }
1107
1108       /* got what we needed? */
1109       if (size == 0)
1110         break;
1111
1112       /* try to read more bytes */
1113       r = fill_raw_bytes (conn, in, sizeof (in));
1114       if (r <= 0) {
1115         if (out == 0)
1116           out = r;
1117         break;
1118       }
1119
1120       ctx->cout = 0;
1121       ctx->coutl =
1122           g_base64_decode_step ((gchar *) in, r, ctx->out, &ctx->state,
1123           &ctx->save);
1124     }
1125   } else {
1126     out = fill_raw_bytes (conn, buffer, size);
1127   }
1128
1129   return out;
1130 }
1131
1132 static GstRTSPResult
1133 read_bytes (GstRTSPConnection * conn, guint8 * buffer, guint * idx, guint size)
1134 {
1135   guint left;
1136
1137   if (G_UNLIKELY (*idx > size))
1138     return GST_RTSP_ERROR;
1139
1140   left = size - *idx;
1141
1142   while (left) {
1143     gint r;
1144
1145     r = fill_bytes (conn, &buffer[*idx], left);
1146     if (G_UNLIKELY (r == 0)) {
1147       return GST_RTSP_EEOF;
1148     } else if (G_UNLIKELY (r < 0)) {
1149       if (ERRNO_IS_EAGAIN)
1150         return GST_RTSP_EINTR;
1151       if (!ERRNO_IS_EINTR)
1152         return GST_RTSP_ESYS;
1153     } else {
1154       left -= r;
1155       *idx += r;
1156     }
1157   }
1158   return GST_RTSP_OK;
1159 }
1160
1161 /* The code below tries to handle clients using \r, \n or \r\n to indicate the
1162  * end of a line. It even does its best to handle clients which mix them (even
1163  * though this is a really stupid idea (tm).) It also handles Line White Space
1164  * (LWS), where a line end followed by whitespace is considered LWS. This is
1165  * the method used in RTSP (and HTTP) to break long lines.
1166  */
1167 static GstRTSPResult
1168 read_line (GstRTSPConnection * conn, guint8 * buffer, guint * idx, guint size)
1169 {
1170   while (TRUE) {
1171     guint8 c;
1172     gint r;
1173
1174     if (conn->read_ahead == READ_AHEAD_EOH) {
1175       /* the last call to read_line() already determined that we have reached
1176        * the end of the headers, so convey that information now */
1177       conn->read_ahead = 0;
1178       break;
1179     } else if (conn->read_ahead == READ_AHEAD_CRLF) {
1180       /* the last call to read_line() left off after having read \r\n */
1181       c = '\n';
1182     } else if (conn->read_ahead == READ_AHEAD_CRLFCR) {
1183       /* the last call to read_line() left off after having read \r\n\r */
1184       c = '\r';
1185     } else if (conn->read_ahead != 0) {
1186       /* the last call to read_line() left us with a character to start with */
1187       c = (guint8) conn->read_ahead;
1188       conn->read_ahead = 0;
1189     } else {
1190       /* read the next character */
1191       r = fill_bytes (conn, &c, 1);
1192       if (G_UNLIKELY (r == 0)) {
1193         return GST_RTSP_EEOF;
1194       } else if (G_UNLIKELY (r < 0)) {
1195         if (ERRNO_IS_EAGAIN)
1196           return GST_RTSP_EINTR;
1197         if (!ERRNO_IS_EINTR)
1198           return GST_RTSP_ESYS;
1199         continue;
1200       }
1201     }
1202
1203     /* special treatment of line endings */
1204     if (c == '\r' || c == '\n') {
1205       guint8 read_ahead;
1206
1207     retry:
1208       /* need to read ahead one more character to know what to do... */
1209       r = fill_bytes (conn, &read_ahead, 1);
1210       if (G_UNLIKELY (r == 0)) {
1211         return GST_RTSP_EEOF;
1212       } else if (G_UNLIKELY (r < 0)) {
1213         if (ERRNO_IS_EAGAIN) {
1214           /* remember the original character we read and try again next time */
1215           if (conn->read_ahead == 0)
1216             conn->read_ahead = c;
1217           return GST_RTSP_EINTR;
1218         }
1219         if (!ERRNO_IS_EINTR)
1220           return GST_RTSP_ESYS;
1221         goto retry;
1222       }
1223
1224       if (read_ahead == ' ' || read_ahead == '\t') {
1225         if (conn->read_ahead == READ_AHEAD_CRLFCR) {
1226           /* got \r\n\r followed by whitespace, treat it as a normal line
1227            * followed by one starting with LWS */
1228           conn->read_ahead = read_ahead;
1229           break;
1230         } else {
1231           /* got LWS, change the line ending to a space and continue */
1232           c = ' ';
1233           conn->read_ahead = read_ahead;
1234         }
1235       } else if (conn->read_ahead == READ_AHEAD_CRLFCR) {
1236         if (read_ahead == '\r' || read_ahead == '\n') {
1237           /* got \r\n\r\r or \r\n\r\n, treat it as the end of the headers */
1238           conn->read_ahead = READ_AHEAD_EOH;
1239           break;
1240         } else {
1241           /* got \r\n\r followed by something else, this is not really
1242            * supported since we have probably just eaten the first character
1243            * of the body or the next message, so just ignore the second \r
1244            * and live with it... */
1245           conn->read_ahead = read_ahead;
1246           break;
1247         }
1248       } else if (conn->read_ahead == READ_AHEAD_CRLF) {
1249         if (read_ahead == '\r') {
1250           /* got \r\n\r so far, need one more character... */
1251           conn->read_ahead = READ_AHEAD_CRLFCR;
1252           goto retry;
1253         } else if (read_ahead == '\n') {
1254           /* got \r\n\n, treat it as the end of the headers */
1255           conn->read_ahead = READ_AHEAD_EOH;
1256           break;
1257         } else {
1258           /* found the end of a line, keep read_ahead for the next line */
1259           conn->read_ahead = read_ahead;
1260           break;
1261         }
1262       } else if (c == read_ahead) {
1263         /* got double \r or \n, treat it as the end of the headers */
1264         conn->read_ahead = READ_AHEAD_EOH;
1265         break;
1266       } else if (c == '\r' && read_ahead == '\n') {
1267         /* got \r\n so far, still need more to know what to do... */
1268         conn->read_ahead = READ_AHEAD_CRLF;
1269         goto retry;
1270       } else {
1271         /* found the end of a line, keep read_ahead for the next line */
1272         conn->read_ahead = read_ahead;
1273         break;
1274       }
1275     }
1276
1277     if (G_LIKELY (*idx < size - 1))
1278       buffer[(*idx)++] = c;
1279   }
1280   buffer[*idx] = '\0';
1281
1282   return GST_RTSP_OK;
1283 }
1284
1285 /**
1286  * gst_rtsp_connection_write:
1287  * @conn: a #GstRTSPConnection
1288  * @data: the data to write
1289  * @size: the size of @data
1290  * @timeout: a timeout value or #NULL
1291  *
1292  * Attempt to write @size bytes of @data to the connected @conn, blocking up to
1293  * the specified @timeout. @timeout can be #NULL, in which case this function
1294  * might block forever.
1295  *
1296  * This function can be cancelled with gst_rtsp_connection_flush().
1297  *
1298  * Returns: #GST_RTSP_OK on success.
1299  */
1300 GstRTSPResult
1301 gst_rtsp_connection_write (GstRTSPConnection * conn, const guint8 * data,
1302     guint size, GTimeVal * timeout)
1303 {
1304   guint offset;
1305   gint retval;
1306   GstClockTime to;
1307   GstRTSPResult res;
1308
1309   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
1310   g_return_val_if_fail (data != NULL || size == 0, GST_RTSP_EINVAL);
1311   g_return_val_if_fail (conn->writefd != NULL, GST_RTSP_EINVAL);
1312
1313   gst_poll_set_controllable (conn->fdset, TRUE);
1314   gst_poll_fd_ctl_write (conn->fdset, conn->writefd, TRUE);
1315   gst_poll_fd_ctl_read (conn->fdset, conn->readfd, FALSE);
1316   /* clear all previous poll results */
1317   gst_poll_fd_ignored (conn->fdset, conn->writefd);
1318   gst_poll_fd_ignored (conn->fdset, conn->readfd);
1319
1320   to = timeout ? GST_TIMEVAL_TO_TIME (*timeout) : GST_CLOCK_TIME_NONE;
1321
1322   offset = 0;
1323
1324   while (TRUE) {
1325     /* try to write */
1326     res = write_bytes (conn->writefd->fd, data, &offset, size);
1327     if (G_LIKELY (res == GST_RTSP_OK))
1328       break;
1329     if (G_UNLIKELY (res != GST_RTSP_EINTR))
1330       goto write_error;
1331
1332     /* not all is written, wait until we can write more */
1333     do {
1334       retval = gst_poll_wait (conn->fdset, to);
1335     } while (retval == -1 && (errno == EINTR || errno == EAGAIN));
1336
1337     if (G_UNLIKELY (retval == 0))
1338       goto timeout;
1339
1340     if (G_UNLIKELY (retval == -1)) {
1341       if (errno == EBUSY)
1342         goto stopped;
1343       else
1344         goto select_error;
1345     }
1346
1347     /* could also be an error with read socket */
1348     if (gst_poll_fd_has_error (conn->fdset, conn->readfd))
1349       goto socket_error;
1350   }
1351   return GST_RTSP_OK;
1352
1353   /* ERRORS */
1354 timeout:
1355   {
1356     return GST_RTSP_ETIMEOUT;
1357   }
1358 select_error:
1359   {
1360     return GST_RTSP_ESYS;
1361   }
1362 stopped:
1363   {
1364     return GST_RTSP_EINTR;
1365   }
1366 socket_error:
1367   {
1368     return GST_RTSP_ENET;
1369   }
1370 write_error:
1371   {
1372     return res;
1373   }
1374 }
1375
1376 static GString *
1377 message_to_string (GstRTSPConnection * conn, GstRTSPMessage * message)
1378 {
1379   GString *str = NULL;
1380
1381   str = g_string_new ("");
1382
1383   switch (message->type) {
1384     case GST_RTSP_MESSAGE_REQUEST:
1385       /* create request string, add CSeq */
1386       g_string_append_printf (str, "%s %s RTSP/1.0\r\n"
1387           "CSeq: %d\r\n",
1388           gst_rtsp_method_as_text (message->type_data.request.method),
1389           message->type_data.request.uri, conn->cseq++);
1390       /* add session id if we have one */
1391       if (conn->session_id[0] != '\0') {
1392         gst_rtsp_message_remove_header (message, GST_RTSP_HDR_SESSION, -1);
1393         gst_rtsp_message_add_header (message, GST_RTSP_HDR_SESSION,
1394             conn->session_id);
1395       }
1396       /* add any authentication headers */
1397       add_auth_header (conn, message);
1398       break;
1399     case GST_RTSP_MESSAGE_RESPONSE:
1400       /* create response string */
1401       g_string_append_printf (str, "RTSP/1.0 %d %s\r\n",
1402           message->type_data.response.code, message->type_data.response.reason);
1403       break;
1404     case GST_RTSP_MESSAGE_HTTP_REQUEST:
1405       /* create request string */
1406       g_string_append_printf (str, "%s %s HTTP/%s\r\n",
1407           gst_rtsp_method_as_text (message->type_data.request.method),
1408           message->type_data.request.uri,
1409           gst_rtsp_version_as_text (message->type_data.request.version));
1410       /* add any authentication headers */
1411       add_auth_header (conn, message);
1412       break;
1413     case GST_RTSP_MESSAGE_HTTP_RESPONSE:
1414       /* create response string */
1415       g_string_append_printf (str, "HTTP/%s %d %s\r\n",
1416           gst_rtsp_version_as_text (message->type_data.request.version),
1417           message->type_data.response.code, message->type_data.response.reason);
1418       break;
1419     case GST_RTSP_MESSAGE_DATA:
1420     {
1421       guint8 data_header[4];
1422
1423       /* prepare data header */
1424       data_header[0] = '$';
1425       data_header[1] = message->type_data.data.channel;
1426       data_header[2] = (message->body_size >> 8) & 0xff;
1427       data_header[3] = message->body_size & 0xff;
1428
1429       /* create string with header and data */
1430       str = g_string_append_len (str, (gchar *) data_header, 4);
1431       str =
1432           g_string_append_len (str, (gchar *) message->body,
1433           message->body_size);
1434       break;
1435     }
1436     default:
1437       g_string_free (str, TRUE);
1438       g_return_val_if_reached (NULL);
1439       break;
1440   }
1441
1442   /* append headers and body */
1443   if (message->type != GST_RTSP_MESSAGE_DATA) {
1444     gchar date_string[100];
1445
1446     gen_date_string (date_string, sizeof (date_string));
1447
1448     /* add date header */
1449     gst_rtsp_message_remove_header (message, GST_RTSP_HDR_DATE, -1);
1450     gst_rtsp_message_add_header (message, GST_RTSP_HDR_DATE, date_string);
1451
1452     /* append headers */
1453     gst_rtsp_message_append_headers (message, str);
1454
1455     /* append Content-Length and body if needed */
1456     if (message->body != NULL && message->body_size > 0) {
1457       gchar *len;
1458
1459       len = g_strdup_printf ("%d", message->body_size);
1460       g_string_append_printf (str, "%s: %s\r\n",
1461           gst_rtsp_header_as_text (GST_RTSP_HDR_CONTENT_LENGTH), len);
1462       g_free (len);
1463       /* header ends here */
1464       g_string_append (str, "\r\n");
1465       str =
1466           g_string_append_len (str, (gchar *) message->body,
1467           message->body_size);
1468     } else {
1469       /* just end headers */
1470       g_string_append (str, "\r\n");
1471     }
1472   }
1473
1474   return str;
1475 }
1476
1477 /**
1478  * gst_rtsp_connection_send:
1479  * @conn: a #GstRTSPConnection
1480  * @message: the message to send
1481  * @timeout: a timeout value or #NULL
1482  *
1483  * Attempt to send @message to the connected @conn, blocking up to
1484  * the specified @timeout. @timeout can be #NULL, in which case this function
1485  * might block forever.
1486  *
1487  * This function can be cancelled with gst_rtsp_connection_flush().
1488  *
1489  * Returns: #GST_RTSP_OK on success.
1490  */
1491 GstRTSPResult
1492 gst_rtsp_connection_send (GstRTSPConnection * conn, GstRTSPMessage * message,
1493     GTimeVal * timeout)
1494 {
1495   GString *string = NULL;
1496   GstRTSPResult res;
1497   gchar *str;
1498   gsize len;
1499
1500   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
1501   g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
1502
1503   if (G_UNLIKELY (!(string = message_to_string (conn, message))))
1504     goto no_message;
1505
1506   if (conn->tunneled) {
1507     str = g_base64_encode ((const guchar *) string->str, string->len);
1508     g_string_free (string, TRUE);
1509     len = strlen (str);
1510   } else {
1511     str = string->str;
1512     len = string->len;
1513     g_string_free (string, FALSE);
1514   }
1515
1516   /* write request */
1517   res = gst_rtsp_connection_write (conn, (guint8 *) str, len, timeout);
1518
1519   g_free (str);
1520
1521   return res;
1522
1523 no_message:
1524   {
1525     g_warning ("Wrong message");
1526     return GST_RTSP_EINVAL;
1527   }
1528 }
1529
1530 static GstRTSPResult
1531 parse_string (gchar * dest, gint size, gchar ** src)
1532 {
1533   GstRTSPResult res = GST_RTSP_OK;
1534   gint idx;
1535
1536   idx = 0;
1537   /* skip spaces */
1538   while (g_ascii_isspace (**src))
1539     (*src)++;
1540
1541   while (!g_ascii_isspace (**src) && **src != '\0') {
1542     if (idx < size - 1)
1543       dest[idx++] = **src;
1544     else
1545       res = GST_RTSP_EPARSE;
1546     (*src)++;
1547   }
1548   if (size > 0)
1549     dest[idx] = '\0';
1550
1551   return res;
1552 }
1553
1554 static GstRTSPResult
1555 parse_protocol_version (gchar * protocol, GstRTSPMsgType * type,
1556     GstRTSPVersion * version)
1557 {
1558   GstRTSPResult res = GST_RTSP_OK;
1559   gchar *ver;
1560
1561   if (G_LIKELY ((ver = strchr (protocol, '/')) != NULL)) {
1562     guint major;
1563     guint minor;
1564     gchar dummychar;
1565
1566     *ver++ = '\0';
1567
1568     /* the version number must be formatted as X.Y with nothing following */
1569     if (sscanf (ver, "%u.%u%c", &major, &minor, &dummychar) != 2)
1570       res = GST_RTSP_EPARSE;
1571
1572     if (g_ascii_strcasecmp (protocol, "RTSP") == 0) {
1573       if (major != 1 || minor != 0) {
1574         *version = GST_RTSP_VERSION_INVALID;
1575         res = GST_RTSP_ERROR;
1576       }
1577     } else if (g_ascii_strcasecmp (protocol, "HTTP") == 0) {
1578       if (*type == GST_RTSP_MESSAGE_REQUEST)
1579         *type = GST_RTSP_MESSAGE_HTTP_REQUEST;
1580       else if (*type == GST_RTSP_MESSAGE_RESPONSE)
1581         *type = GST_RTSP_MESSAGE_HTTP_RESPONSE;
1582
1583       if (major == 1 && minor == 1) {
1584         *version = GST_RTSP_VERSION_1_1;
1585       } else if (major != 1 || minor != 0) {
1586         *version = GST_RTSP_VERSION_INVALID;
1587         res = GST_RTSP_ERROR;
1588       }
1589     } else
1590       res = GST_RTSP_EPARSE;
1591   } else
1592     res = GST_RTSP_EPARSE;
1593
1594   return res;
1595 }
1596
1597 static GstRTSPResult
1598 parse_response_status (guint8 * buffer, GstRTSPMessage * msg)
1599 {
1600   GstRTSPResult res = GST_RTSP_OK;
1601   GstRTSPResult res2;
1602   gchar versionstr[20];
1603   gchar codestr[4];
1604   gint code;
1605   gchar *bptr;
1606
1607   bptr = (gchar *) buffer;
1608
1609   if (parse_string (versionstr, sizeof (versionstr), &bptr) != GST_RTSP_OK)
1610     res = GST_RTSP_EPARSE;
1611
1612   if (parse_string (codestr, sizeof (codestr), &bptr) != GST_RTSP_OK)
1613     res = GST_RTSP_EPARSE;
1614   code = atoi (codestr);
1615   if (G_UNLIKELY (*codestr == '\0' || code < 0 || code >= 600))
1616     res = GST_RTSP_EPARSE;
1617
1618   while (g_ascii_isspace (*bptr))
1619     bptr++;
1620
1621   if (G_UNLIKELY (gst_rtsp_message_init_response (msg, code, bptr,
1622               NULL) != GST_RTSP_OK))
1623     res = GST_RTSP_EPARSE;
1624
1625   res2 = parse_protocol_version (versionstr, &msg->type,
1626       &msg->type_data.response.version);
1627   if (G_LIKELY (res == GST_RTSP_OK))
1628     res = res2;
1629
1630   return res;
1631 }
1632
1633 static GstRTSPResult
1634 parse_request_line (guint8 * buffer, GstRTSPMessage * msg)
1635 {
1636   GstRTSPResult res = GST_RTSP_OK;
1637   GstRTSPResult res2;
1638   gchar versionstr[20];
1639   gchar methodstr[20];
1640   gchar urlstr[4096];
1641   gchar *bptr;
1642   GstRTSPMethod method;
1643
1644   bptr = (gchar *) buffer;
1645
1646   if (parse_string (methodstr, sizeof (methodstr), &bptr) != GST_RTSP_OK)
1647     res = GST_RTSP_EPARSE;
1648   method = gst_rtsp_find_method (methodstr);
1649
1650   if (parse_string (urlstr, sizeof (urlstr), &bptr) != GST_RTSP_OK)
1651     res = GST_RTSP_EPARSE;
1652   if (G_UNLIKELY (*urlstr == '\0'))
1653     res = GST_RTSP_EPARSE;
1654
1655   if (parse_string (versionstr, sizeof (versionstr), &bptr) != GST_RTSP_OK)
1656     res = GST_RTSP_EPARSE;
1657
1658   if (G_UNLIKELY (*bptr != '\0'))
1659     res = GST_RTSP_EPARSE;
1660
1661   if (G_UNLIKELY (gst_rtsp_message_init_request (msg, method,
1662               urlstr) != GST_RTSP_OK))
1663     res = GST_RTSP_EPARSE;
1664
1665   res2 = parse_protocol_version (versionstr, &msg->type,
1666       &msg->type_data.request.version);
1667   if (G_LIKELY (res == GST_RTSP_OK))
1668     res = res2;
1669
1670   if (G_LIKELY (msg->type == GST_RTSP_MESSAGE_REQUEST)) {
1671     /* GET and POST are not allowed as RTSP methods */
1672     if (msg->type_data.request.method == GST_RTSP_GET ||
1673         msg->type_data.request.method == GST_RTSP_POST) {
1674       msg->type_data.request.method = GST_RTSP_INVALID;
1675       if (res == GST_RTSP_OK)
1676         res = GST_RTSP_ERROR;
1677     }
1678   } else if (msg->type == GST_RTSP_MESSAGE_HTTP_REQUEST) {
1679     /* only GET and POST are allowed as HTTP methods */
1680     if (msg->type_data.request.method != GST_RTSP_GET &&
1681         msg->type_data.request.method != GST_RTSP_POST) {
1682       msg->type_data.request.method = GST_RTSP_INVALID;
1683       if (res == GST_RTSP_OK)
1684         res = GST_RTSP_ERROR;
1685     }
1686   }
1687
1688   return res;
1689 }
1690
1691 /* parsing lines means reading a Key: Value pair */
1692 static GstRTSPResult
1693 parse_line (guint8 * buffer, GstRTSPMessage * msg)
1694 {
1695   GstRTSPHeaderField field;
1696   gchar *line = (gchar *) buffer;
1697   gchar *value;
1698
1699   if ((value = strchr (line, ':')) == NULL || value == line)
1700     goto parse_error;
1701
1702   /* trim space before the colon */
1703   if (value[-1] == ' ')
1704     value[-1] = '\0';
1705
1706   /* replace the colon with a NUL */
1707   *value++ = '\0';
1708
1709   /* find the header */
1710   field = gst_rtsp_find_header_field (line);
1711   if (field == GST_RTSP_HDR_INVALID)
1712     goto done;
1713
1714   /* split up the value in multiple key:value pairs if it contains comma(s) */
1715   while (*value != '\0') {
1716     gchar *next_value;
1717     gchar *comma = NULL;
1718     gboolean quoted = FALSE;
1719     guint comment = 0;
1720
1721     /* trim leading space */
1722     if (*value == ' ')
1723       value++;
1724
1725     /* for headers which may not appear multiple times, and thus may not
1726      * contain multiple values on the same line, we can short-circuit the loop
1727      * below and the entire value results in just one key:value pair*/
1728     if (!gst_rtsp_header_allow_multiple (field))
1729       next_value = value + strlen (value);
1730     else
1731       next_value = value;
1732
1733     /* find the next value, taking special care of quotes and comments */
1734     while (*next_value != '\0') {
1735       if ((quoted || comment != 0) && *next_value == '\\' &&
1736           next_value[1] != '\0')
1737         next_value++;
1738       else if (comment == 0 && *next_value == '"')
1739         quoted = !quoted;
1740       else if (!quoted && *next_value == '(')
1741         comment++;
1742       else if (comment != 0 && *next_value == ')')
1743         comment--;
1744       else if (!quoted && comment == 0) {
1745         /* To quote RFC 2068: "User agents MUST take special care in parsing
1746          * the WWW-Authenticate field value if it contains more than one
1747          * challenge, or if more than one WWW-Authenticate header field is
1748          * provided, since the contents of a challenge may itself contain a
1749          * comma-separated list of authentication parameters."
1750          *
1751          * What this means is that we cannot just look for an unquoted comma
1752          * when looking for multiple values in Proxy-Authenticate and
1753          * WWW-Authenticate headers. Instead we need to look for the sequence
1754          * "comma [space] token space token" before we can split after the
1755          * comma...
1756          */
1757         if (field == GST_RTSP_HDR_PROXY_AUTHENTICATE ||
1758             field == GST_RTSP_HDR_WWW_AUTHENTICATE) {
1759           if (*next_value == ',') {
1760             if (next_value[1] == ' ') {
1761               /* skip any space following the comma so we do not mistake it for
1762                * separating between two tokens */
1763               next_value++;
1764             }
1765             comma = next_value;
1766           } else if (*next_value == ' ' && next_value[1] != ',' &&
1767               next_value[1] != '=' && comma != NULL) {
1768             next_value = comma;
1769             comma = NULL;
1770             break;
1771           }
1772         } else if (*next_value == ',')
1773           break;
1774       }
1775
1776       next_value++;
1777     }
1778
1779     /* trim space */
1780     if (value != next_value && next_value[-1] == ' ')
1781       next_value[-1] = '\0';
1782
1783     if (*next_value != '\0')
1784       *next_value++ = '\0';
1785
1786     /* add the key:value pair */
1787     if (*value != '\0')
1788       gst_rtsp_message_add_header (msg, field, value);
1789
1790     value = next_value;
1791   }
1792
1793 done:
1794   return GST_RTSP_OK;
1795
1796   /* ERRORS */
1797 parse_error:
1798   {
1799     return GST_RTSP_EPARSE;
1800   }
1801 }
1802
1803 /* convert all consecutive whitespace to a single space */
1804 static void
1805 normalize_line (guint8 * buffer)
1806 {
1807   while (*buffer) {
1808     if (g_ascii_isspace (*buffer)) {
1809       guint8 *tmp;
1810
1811       *buffer++ = ' ';
1812       for (tmp = buffer; g_ascii_isspace (*tmp); tmp++) {
1813       }
1814       if (buffer != tmp)
1815         memmove (buffer, tmp, strlen ((gchar *) tmp) + 1);
1816     } else {
1817       buffer++;
1818     }
1819   }
1820 }
1821
1822 /* returns:
1823  *  GST_RTSP_OK when a complete message was read.
1824  *  GST_RTSP_EEOF: when the socket is closed
1825  *  GST_RTSP_EINTR: when more data is needed.
1826  *  GST_RTSP_..: some other error occured.
1827  */
1828 static GstRTSPResult
1829 build_next (GstRTSPBuilder * builder, GstRTSPMessage * message,
1830     GstRTSPConnection * conn)
1831 {
1832   GstRTSPResult res;
1833
1834   while (TRUE) {
1835     switch (builder->state) {
1836       case STATE_START:
1837         builder->offset = 0;
1838         res =
1839             read_bytes (conn, (guint8 *) builder->buffer, &builder->offset, 1);
1840         if (res != GST_RTSP_OK)
1841           goto done;
1842
1843         /* we have 1 bytes now and we can see if this is a data message or
1844          * not */
1845         if (builder->buffer[0] == '$') {
1846           /* data message, prepare for the header */
1847           builder->state = STATE_DATA_HEADER;
1848         } else {
1849           builder->line = 0;
1850           builder->state = STATE_READ_LINES;
1851         }
1852         break;
1853       case STATE_DATA_HEADER:
1854       {
1855         res =
1856             read_bytes (conn, (guint8 *) builder->buffer, &builder->offset, 4);
1857         if (res != GST_RTSP_OK)
1858           goto done;
1859
1860         gst_rtsp_message_init_data (message, builder->buffer[1]);
1861
1862         builder->body_len = (builder->buffer[2] << 8) | builder->buffer[3];
1863         builder->body_data = g_malloc (builder->body_len + 1);
1864         builder->body_data[builder->body_len] = '\0';
1865         builder->offset = 0;
1866         builder->state = STATE_DATA_BODY;
1867         break;
1868       }
1869       case STATE_DATA_BODY:
1870       {
1871         res =
1872             read_bytes (conn, builder->body_data, &builder->offset,
1873             builder->body_len);
1874         if (res != GST_RTSP_OK)
1875           goto done;
1876
1877         /* we have the complete body now, store in the message adjusting the
1878          * length to include the traling '\0' */
1879         gst_rtsp_message_take_body (message,
1880             (guint8 *) builder->body_data, builder->body_len + 1);
1881         builder->body_data = NULL;
1882         builder->body_len = 0;
1883
1884         builder->state = STATE_END;
1885         break;
1886       }
1887       case STATE_READ_LINES:
1888       {
1889         res = read_line (conn, builder->buffer, &builder->offset,
1890             sizeof (builder->buffer));
1891         if (res != GST_RTSP_OK)
1892           goto done;
1893
1894         /* we have a regular response */
1895         if (builder->buffer[0] == '\0') {
1896           gchar *hdrval;
1897
1898           /* empty line, end of message header */
1899           /* see if there is a Content-Length header, but ignore it if this
1900            * is a POST request with an x-sessioncookie header */
1901           if (gst_rtsp_message_get_header (message,
1902                   GST_RTSP_HDR_CONTENT_LENGTH, &hdrval, 0) == GST_RTSP_OK &&
1903               (message->type != GST_RTSP_MESSAGE_HTTP_REQUEST ||
1904                   message->type_data.request.method != GST_RTSP_POST ||
1905                   gst_rtsp_message_get_header (message,
1906                       GST_RTSP_HDR_X_SESSIONCOOKIE, NULL, 0) != GST_RTSP_OK)) {
1907             /* there is, prepare to read the body */
1908             builder->body_len = atol (hdrval);
1909             builder->body_data = g_malloc (builder->body_len + 1);
1910             builder->body_data[builder->body_len] = '\0';
1911             builder->offset = 0;
1912             builder->state = STATE_DATA_BODY;
1913           } else {
1914             builder->state = STATE_END;
1915           }
1916           break;
1917         }
1918
1919         /* we have a line */
1920         normalize_line (builder->buffer);
1921         if (builder->line == 0) {
1922           /* first line, check for response status */
1923           if (memcmp (builder->buffer, "RTSP", 4) == 0 ||
1924               memcmp (builder->buffer, "HTTP", 4) == 0) {
1925             builder->status = parse_response_status (builder->buffer, message);
1926           } else {
1927             builder->status = parse_request_line (builder->buffer, message);
1928           }
1929         } else {
1930           /* else just parse the line */
1931           res = parse_line (builder->buffer, message);
1932           if (res != GST_RTSP_OK)
1933             builder->status = res;
1934         }
1935         builder->line++;
1936         builder->offset = 0;
1937         break;
1938       }
1939       case STATE_END:
1940       {
1941         gchar *session_cookie;
1942         gchar *session_id;
1943
1944         if (message->type == GST_RTSP_MESSAGE_DATA) {
1945           /* data messages don't have headers */
1946           res = GST_RTSP_OK;
1947           goto done;
1948         }
1949
1950         /* save the tunnel session in the connection */
1951         if (message->type == GST_RTSP_MESSAGE_HTTP_REQUEST &&
1952             !conn->manual_http &&
1953             conn->tstate == TUNNEL_STATE_NONE &&
1954             gst_rtsp_message_get_header (message, GST_RTSP_HDR_X_SESSIONCOOKIE,
1955                 &session_cookie, 0) == GST_RTSP_OK) {
1956           strncpy (conn->tunnelid, session_cookie, TUNNELID_LEN);
1957           conn->tunnelid[TUNNELID_LEN - 1] = '\0';
1958           conn->tunneled = TRUE;
1959         }
1960
1961         /* save session id in the connection for further use */
1962         if (message->type == GST_RTSP_MESSAGE_RESPONSE &&
1963             gst_rtsp_message_get_header (message, GST_RTSP_HDR_SESSION,
1964                 &session_id, 0) == GST_RTSP_OK) {
1965           gint maxlen, i;
1966
1967           maxlen = sizeof (conn->session_id) - 1;
1968           /* the sessionid can have attributes marked with ;
1969            * Make sure we strip them */
1970           for (i = 0; session_id[i] != '\0'; i++) {
1971             if (session_id[i] == ';') {
1972               maxlen = i;
1973               /* parse timeout */
1974               do {
1975                 i++;
1976               } while (g_ascii_isspace (session_id[i]));
1977               if (g_str_has_prefix (&session_id[i], "timeout=")) {
1978                 gint to;
1979
1980                 /* if we parsed something valid, configure */
1981                 if ((to = atoi (&session_id[i + 8])) > 0)
1982                   conn->timeout = to;
1983               }
1984               break;
1985             }
1986           }
1987
1988           /* make sure to not overflow */
1989           strncpy (conn->session_id, session_id, maxlen);
1990           conn->session_id[maxlen] = '\0';
1991         }
1992         res = builder->status;
1993         goto done;
1994       }
1995       default:
1996         res = GST_RTSP_ERROR;
1997         break;
1998     }
1999   }
2000 done:
2001   return res;
2002 }
2003
2004 /**
2005  * gst_rtsp_connection_read:
2006  * @conn: a #GstRTSPConnection
2007  * @data: the data to read
2008  * @size: the size of @data
2009  * @timeout: a timeout value or #NULL
2010  *
2011  * Attempt to read @size bytes into @data from the connected @conn, blocking up to
2012  * the specified @timeout. @timeout can be #NULL, in which case this function
2013  * might block forever.
2014  *
2015  * This function can be cancelled with gst_rtsp_connection_flush().
2016  *
2017  * Returns: #GST_RTSP_OK on success.
2018  */
2019 GstRTSPResult
2020 gst_rtsp_connection_read (GstRTSPConnection * conn, guint8 * data, guint size,
2021     GTimeVal * timeout)
2022 {
2023   guint offset;
2024   gint retval;
2025   GstClockTime to;
2026   GstRTSPResult res;
2027
2028   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2029   g_return_val_if_fail (data != NULL, GST_RTSP_EINVAL);
2030   g_return_val_if_fail (conn->readfd != NULL, GST_RTSP_EINVAL);
2031
2032   if (G_UNLIKELY (size == 0))
2033     return GST_RTSP_OK;
2034
2035   offset = 0;
2036
2037   /* configure timeout if any */
2038   to = timeout ? GST_TIMEVAL_TO_TIME (*timeout) : GST_CLOCK_TIME_NONE;
2039
2040   gst_poll_set_controllable (conn->fdset, TRUE);
2041   gst_poll_fd_ctl_write (conn->fdset, conn->writefd, FALSE);
2042   gst_poll_fd_ctl_read (conn->fdset, conn->readfd, TRUE);
2043
2044   while (TRUE) {
2045     res = read_bytes (conn, data, &offset, size);
2046     if (G_UNLIKELY (res == GST_RTSP_EEOF))
2047       goto eof;
2048     if (G_LIKELY (res == GST_RTSP_OK))
2049       break;
2050     if (G_UNLIKELY (res != GST_RTSP_EINTR))
2051       goto read_error;
2052
2053     do {
2054       retval = gst_poll_wait (conn->fdset, to);
2055     } while (retval == -1 && (errno == EINTR || errno == EAGAIN));
2056
2057     /* check for timeout */
2058     if (G_UNLIKELY (retval == 0))
2059       goto select_timeout;
2060
2061     if (G_UNLIKELY (retval == -1)) {
2062       if (errno == EBUSY)
2063         goto stopped;
2064       else
2065         goto select_error;
2066     }
2067
2068     /* could also be an error with write socket */
2069     if (gst_poll_fd_has_error (conn->fdset, conn->writefd))
2070       goto socket_error;
2071
2072     gst_poll_set_controllable (conn->fdset, FALSE);
2073   }
2074   return GST_RTSP_OK;
2075
2076   /* ERRORS */
2077 select_error:
2078   {
2079     return GST_RTSP_ESYS;
2080   }
2081 select_timeout:
2082   {
2083     return GST_RTSP_ETIMEOUT;
2084   }
2085 stopped:
2086   {
2087     return GST_RTSP_EINTR;
2088   }
2089 eof:
2090   {
2091     return GST_RTSP_EEOF;
2092   }
2093 socket_error:
2094   {
2095     res = GST_RTSP_ENET;
2096   }
2097 read_error:
2098   {
2099     return res;
2100   }
2101 }
2102
2103 static GstRTSPMessage *
2104 gen_tunnel_reply (GstRTSPConnection * conn, GstRTSPStatusCode code,
2105     const GstRTSPMessage * request)
2106 {
2107   GstRTSPMessage *msg;
2108   GstRTSPResult res;
2109
2110   if (gst_rtsp_status_as_text (code) == NULL)
2111     code = GST_RTSP_STS_INTERNAL_SERVER_ERROR;
2112
2113   GST_RTSP_CHECK (gst_rtsp_message_new_response (&msg, code, NULL, request),
2114       no_message);
2115
2116   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_SERVER,
2117       "GStreamer RTSP Server");
2118   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CONNECTION, "close");
2119   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CACHE_CONTROL, "no-store");
2120   gst_rtsp_message_add_header (msg, GST_RTSP_HDR_PRAGMA, "no-cache");
2121
2122   if (code == GST_RTSP_STS_OK) {
2123     if (conn->ip)
2124       gst_rtsp_message_add_header (msg, GST_RTSP_HDR_X_SERVER_IP_ADDRESS,
2125           conn->ip);
2126     gst_rtsp_message_add_header (msg, GST_RTSP_HDR_CONTENT_TYPE,
2127         "application/x-rtsp-tunnelled");
2128   }
2129
2130   return msg;
2131
2132   /* ERRORS */
2133 no_message:
2134   {
2135     return NULL;
2136   }
2137 }
2138
2139 /**
2140  * gst_rtsp_connection_receive:
2141  * @conn: a #GstRTSPConnection
2142  * @message: the message to read
2143  * @timeout: a timeout value or #NULL
2144  *
2145  * Attempt to read into @message from the connected @conn, blocking up to
2146  * the specified @timeout. @timeout can be #NULL, in which case this function
2147  * might block forever.
2148  *
2149  * This function can be cancelled with gst_rtsp_connection_flush().
2150  *
2151  * Returns: #GST_RTSP_OK on success.
2152  */
2153 GstRTSPResult
2154 gst_rtsp_connection_receive (GstRTSPConnection * conn, GstRTSPMessage * message,
2155     GTimeVal * timeout)
2156 {
2157   GstRTSPResult res;
2158   GstRTSPBuilder builder;
2159   gint retval;
2160   GstClockTime to;
2161
2162   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2163   g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
2164   g_return_val_if_fail (conn->readfd != NULL, GST_RTSP_EINVAL);
2165
2166   /* configure timeout if any */
2167   to = timeout ? GST_TIMEVAL_TO_TIME (*timeout) : GST_CLOCK_TIME_NONE;
2168
2169   gst_poll_set_controllable (conn->fdset, TRUE);
2170   gst_poll_fd_ctl_write (conn->fdset, conn->writefd, FALSE);
2171   gst_poll_fd_ctl_read (conn->fdset, conn->readfd, TRUE);
2172
2173   memset (&builder, 0, sizeof (GstRTSPBuilder));
2174   while (TRUE) {
2175     res = build_next (&builder, message, conn);
2176     if (G_UNLIKELY (res == GST_RTSP_EEOF))
2177       goto eof;
2178     else if (G_LIKELY (res == GST_RTSP_OK)) {
2179       if (!conn->manual_http) {
2180         if (message->type == GST_RTSP_MESSAGE_HTTP_REQUEST) {
2181           if (conn->tstate == TUNNEL_STATE_NONE &&
2182               message->type_data.request.method == GST_RTSP_GET) {
2183             GstRTSPMessage *response;
2184
2185             conn->tstate = TUNNEL_STATE_GET;
2186
2187             /* tunnel GET request, we can reply now */
2188             response = gen_tunnel_reply (conn, GST_RTSP_STS_OK, message);
2189             res = gst_rtsp_connection_send (conn, response, timeout);
2190             gst_rtsp_message_free (response);
2191             if (res == GST_RTSP_OK)
2192               res = GST_RTSP_ETGET;
2193             goto cleanup;
2194           } else if (conn->tstate == TUNNEL_STATE_NONE &&
2195               message->type_data.request.method == GST_RTSP_POST) {
2196             conn->tstate = TUNNEL_STATE_POST;
2197
2198             /* tunnel POST request, the caller now has to link the two
2199              * connections. */
2200             res = GST_RTSP_ETPOST;
2201             goto cleanup;
2202           } else {
2203             res = GST_RTSP_EPARSE;
2204             goto cleanup;
2205           }
2206         } else if (message->type == GST_RTSP_MESSAGE_HTTP_RESPONSE) {
2207           res = GST_RTSP_EPARSE;
2208           goto cleanup;
2209         }
2210       }
2211
2212       break;
2213     } else if (G_UNLIKELY (res != GST_RTSP_EINTR))
2214       goto read_error;
2215
2216     do {
2217       retval = gst_poll_wait (conn->fdset, to);
2218     } while (retval == -1 && (errno == EINTR || errno == EAGAIN));
2219
2220     /* check for timeout */
2221     if (G_UNLIKELY (retval == 0))
2222       goto select_timeout;
2223
2224     if (G_UNLIKELY (retval == -1)) {
2225       if (errno == EBUSY)
2226         goto stopped;
2227       else
2228         goto select_error;
2229     }
2230
2231     /* could also be an error with write socket */
2232     if (gst_poll_fd_has_error (conn->fdset, conn->writefd))
2233       goto socket_error;
2234
2235     gst_poll_set_controllable (conn->fdset, FALSE);
2236   }
2237
2238   /* we have a message here */
2239   build_reset (&builder);
2240
2241   return GST_RTSP_OK;
2242
2243   /* ERRORS */
2244 select_error:
2245   {
2246     res = GST_RTSP_ESYS;
2247     goto cleanup;
2248   }
2249 select_timeout:
2250   {
2251     res = GST_RTSP_ETIMEOUT;
2252     goto cleanup;
2253   }
2254 stopped:
2255   {
2256     res = GST_RTSP_EINTR;
2257     goto cleanup;
2258   }
2259 eof:
2260   {
2261     res = GST_RTSP_EEOF;
2262     goto cleanup;
2263   }
2264 socket_error:
2265   {
2266     res = GST_RTSP_ENET;
2267     goto cleanup;
2268   }
2269 read_error:
2270 cleanup:
2271   {
2272     build_reset (&builder);
2273     gst_rtsp_message_unset (message);
2274     return res;
2275   }
2276 }
2277
2278 /**
2279  * gst_rtsp_connection_close:
2280  * @conn: a #GstRTSPConnection
2281  *
2282  * Close the connected @conn. After this call, the connection is in the same
2283  * state as when it was first created.
2284  *
2285  * Returns: #GST_RTSP_OK on success.
2286  */
2287 GstRTSPResult
2288 gst_rtsp_connection_close (GstRTSPConnection * conn)
2289 {
2290   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2291
2292   g_free (conn->ip);
2293   conn->ip = NULL;
2294
2295   conn->read_ahead = 0;
2296
2297   g_free (conn->initial_buffer);
2298   conn->initial_buffer = NULL;
2299   conn->initial_buffer_offset = 0;
2300
2301   REMOVE_POLLFD (conn->fdset, &conn->fd0);
2302   REMOVE_POLLFD (conn->fdset, &conn->fd1);
2303   conn->writefd = NULL;
2304   conn->readfd = NULL;
2305   conn->tunneled = FALSE;
2306   conn->tstate = TUNNEL_STATE_NONE;
2307   conn->ctxp = NULL;
2308   g_free (conn->username);
2309   conn->username = NULL;
2310   g_free (conn->passwd);
2311   conn->passwd = NULL;
2312   gst_rtsp_connection_clear_auth_params (conn);
2313   conn->timeout = 60;
2314   conn->cseq = 0;
2315   conn->session_id[0] = '\0';
2316
2317   return GST_RTSP_OK;
2318 }
2319
2320 /**
2321  * gst_rtsp_connection_free:
2322  * @conn: a #GstRTSPConnection
2323  *
2324  * Close and free @conn.
2325  *
2326  * Returns: #GST_RTSP_OK on success.
2327  */
2328 GstRTSPResult
2329 gst_rtsp_connection_free (GstRTSPConnection * conn)
2330 {
2331   GstRTSPResult res;
2332
2333   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2334
2335   res = gst_rtsp_connection_close (conn);
2336   gst_poll_free (conn->fdset);
2337   g_timer_destroy (conn->timer);
2338   gst_rtsp_url_free (conn->url);
2339   g_free (conn->proxy_host);
2340   g_free (conn);
2341 #ifdef G_OS_WIN32
2342   WSACleanup ();
2343 #endif
2344
2345   return res;
2346 }
2347
2348 /**
2349  * gst_rtsp_connection_poll:
2350  * @conn: a #GstRTSPConnection
2351  * @events: a bitmask of #GstRTSPEvent flags to check
2352  * @revents: location for result flags
2353  * @timeout: a timeout
2354  *
2355  * Wait up to the specified @timeout for the connection to become available for
2356  * at least one of the operations specified in @events. When the function returns
2357  * with #GST_RTSP_OK, @revents will contain a bitmask of available operations on
2358  * @conn.
2359  *
2360  * @timeout can be #NULL, in which case this function might block forever.
2361  *
2362  * This function can be cancelled with gst_rtsp_connection_flush().
2363  *
2364  * Returns: #GST_RTSP_OK on success.
2365  *
2366  * Since: 0.10.15
2367  */
2368 GstRTSPResult
2369 gst_rtsp_connection_poll (GstRTSPConnection * conn, GstRTSPEvent events,
2370     GstRTSPEvent * revents, GTimeVal * timeout)
2371 {
2372   GstClockTime to;
2373   gint retval;
2374
2375   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2376   g_return_val_if_fail (events != 0, GST_RTSP_EINVAL);
2377   g_return_val_if_fail (revents != NULL, GST_RTSP_EINVAL);
2378   g_return_val_if_fail (conn->readfd != NULL, GST_RTSP_EINVAL);
2379   g_return_val_if_fail (conn->writefd != NULL, GST_RTSP_EINVAL);
2380
2381   gst_poll_set_controllable (conn->fdset, TRUE);
2382
2383   /* add fd to writer set when asked to */
2384   gst_poll_fd_ctl_write (conn->fdset, conn->writefd,
2385       events & GST_RTSP_EV_WRITE);
2386
2387   /* add fd to reader set when asked to */
2388   gst_poll_fd_ctl_read (conn->fdset, conn->readfd, events & GST_RTSP_EV_READ);
2389
2390   /* configure timeout if any */
2391   to = timeout ? GST_TIMEVAL_TO_TIME (*timeout) : GST_CLOCK_TIME_NONE;
2392
2393   do {
2394     retval = gst_poll_wait (conn->fdset, to);
2395   } while (retval == -1 && (errno == EINTR || errno == EAGAIN));
2396
2397   if (G_UNLIKELY (retval == 0))
2398     goto select_timeout;
2399
2400   if (G_UNLIKELY (retval == -1)) {
2401     if (errno == EBUSY)
2402       goto stopped;
2403     else
2404       goto select_error;
2405   }
2406
2407   *revents = 0;
2408   if (events & GST_RTSP_EV_READ) {
2409     if (gst_poll_fd_can_read (conn->fdset, conn->readfd))
2410       *revents |= GST_RTSP_EV_READ;
2411   }
2412   if (events & GST_RTSP_EV_WRITE) {
2413     if (gst_poll_fd_can_write (conn->fdset, conn->writefd))
2414       *revents |= GST_RTSP_EV_WRITE;
2415   }
2416   return GST_RTSP_OK;
2417
2418   /* ERRORS */
2419 select_timeout:
2420   {
2421     return GST_RTSP_ETIMEOUT;
2422   }
2423 select_error:
2424   {
2425     return GST_RTSP_ESYS;
2426   }
2427 stopped:
2428   {
2429     return GST_RTSP_EINTR;
2430   }
2431 }
2432
2433 /**
2434  * gst_rtsp_connection_next_timeout:
2435  * @conn: a #GstRTSPConnection
2436  * @timeout: a timeout
2437  *
2438  * Calculate the next timeout for @conn, storing the result in @timeout.
2439  *
2440  * Returns: #GST_RTSP_OK.
2441  */
2442 GstRTSPResult
2443 gst_rtsp_connection_next_timeout (GstRTSPConnection * conn, GTimeVal * timeout)
2444 {
2445   gdouble elapsed;
2446   glong sec;
2447   gulong usec;
2448
2449   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2450   g_return_val_if_fail (timeout != NULL, GST_RTSP_EINVAL);
2451
2452   elapsed = g_timer_elapsed (conn->timer, &usec);
2453   if (elapsed >= conn->timeout) {
2454     sec = 0;
2455     usec = 0;
2456   } else {
2457     sec = conn->timeout - elapsed;
2458   }
2459
2460   timeout->tv_sec = sec;
2461   timeout->tv_usec = usec;
2462
2463   return GST_RTSP_OK;
2464 }
2465
2466 /**
2467  * gst_rtsp_connection_reset_timeout:
2468  * @conn: a #GstRTSPConnection
2469  *
2470  * Reset the timeout of @conn.
2471  *
2472  * Returns: #GST_RTSP_OK.
2473  */
2474 GstRTSPResult
2475 gst_rtsp_connection_reset_timeout (GstRTSPConnection * conn)
2476 {
2477   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2478
2479   g_timer_start (conn->timer);
2480
2481   return GST_RTSP_OK;
2482 }
2483
2484 /**
2485  * gst_rtsp_connection_flush:
2486  * @conn: a #GstRTSPConnection
2487  * @flush: start or stop the flush
2488  *
2489  * Start or stop the flushing action on @conn. When flushing, all current
2490  * and future actions on @conn will return #GST_RTSP_EINTR until the connection
2491  * is set to non-flushing mode again.
2492  *
2493  * Returns: #GST_RTSP_OK.
2494  */
2495 GstRTSPResult
2496 gst_rtsp_connection_flush (GstRTSPConnection * conn, gboolean flush)
2497 {
2498   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2499
2500   gst_poll_set_flushing (conn->fdset, flush);
2501
2502   return GST_RTSP_OK;
2503 }
2504
2505 /**
2506  * gst_rtsp_connection_set_proxy:
2507  * @conn: a #GstRTSPConnection
2508  * @host: the proxy host
2509  * @port: the proxy port
2510  *
2511  * Set the proxy host and port.
2512  *
2513  * Returns: #GST_RTSP_OK.
2514  *
2515  * Since: 0.10.23
2516  */
2517 GstRTSPResult
2518 gst_rtsp_connection_set_proxy (GstRTSPConnection * conn,
2519     const gchar * host, guint port)
2520 {
2521   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2522
2523   g_free (conn->proxy_host);
2524   conn->proxy_host = g_strdup (host);
2525   conn->proxy_port = port;
2526
2527   return GST_RTSP_OK;
2528 }
2529
2530 /**
2531  * gst_rtsp_connection_set_auth:
2532  * @conn: a #GstRTSPConnection
2533  * @method: authentication method
2534  * @user: the user
2535  * @pass: the password
2536  *
2537  * Configure @conn for authentication mode @method with @user and @pass as the
2538  * user and password respectively.
2539  *
2540  * Returns: #GST_RTSP_OK.
2541  */
2542 GstRTSPResult
2543 gst_rtsp_connection_set_auth (GstRTSPConnection * conn,
2544     GstRTSPAuthMethod method, const gchar * user, const gchar * pass)
2545 {
2546   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2547
2548   if (method == GST_RTSP_AUTH_DIGEST && ((user == NULL || pass == NULL)
2549           || g_strrstr (user, ":") != NULL))
2550     return GST_RTSP_EINVAL;
2551
2552   /* Make sure the username and passwd are being set for authentication */
2553   if (method == GST_RTSP_AUTH_NONE && (user == NULL || pass == NULL))
2554     return GST_RTSP_EINVAL;
2555
2556   /* ":" chars are not allowed in usernames for basic auth */
2557   if (method == GST_RTSP_AUTH_BASIC && g_strrstr (user, ":") != NULL)
2558     return GST_RTSP_EINVAL;
2559
2560   g_free (conn->username);
2561   g_free (conn->passwd);
2562
2563   conn->auth_method = method;
2564   conn->username = g_strdup (user);
2565   conn->passwd = g_strdup (pass);
2566
2567   return GST_RTSP_OK;
2568 }
2569
2570 /**
2571  * str_case_hash:
2572  * @key: ASCII string to hash
2573  *
2574  * Hashes @key in a case-insensitive manner.
2575  *
2576  * Returns: the hash code.
2577  **/
2578 static guint
2579 str_case_hash (gconstpointer key)
2580 {
2581   const char *p = key;
2582   guint h = g_ascii_toupper (*p);
2583
2584   if (h)
2585     for (p += 1; *p != '\0'; p++)
2586       h = (h << 5) - h + g_ascii_toupper (*p);
2587
2588   return h;
2589 }
2590
2591 /**
2592  * str_case_equal:
2593  * @v1: an ASCII string
2594  * @v2: another ASCII string
2595  *
2596  * Compares @v1 and @v2 in a case-insensitive manner
2597  *
2598  * Returns: %TRUE if they are equal (modulo case)
2599  **/
2600 static gboolean
2601 str_case_equal (gconstpointer v1, gconstpointer v2)
2602 {
2603   const char *string1 = v1;
2604   const char *string2 = v2;
2605
2606   return g_ascii_strcasecmp (string1, string2) == 0;
2607 }
2608
2609 /**
2610  * gst_rtsp_connection_set_auth_param:
2611  * @conn: a #GstRTSPConnection
2612  * @param: authentication directive
2613  * @value: value
2614  *
2615  * Setup @conn with authentication directives. This is not necesary for
2616  * methods #GST_RTSP_AUTH_NONE and #GST_RTSP_AUTH_BASIC. For
2617  * #GST_RTSP_AUTH_DIGEST, directives should be taken from the digest challenge
2618  * in the WWW-Authenticate response header and can include realm, domain,
2619  * nonce, opaque, stale, algorithm, qop as per RFC2617.
2620  *
2621  * Since: 0.10.20
2622  */
2623 void
2624 gst_rtsp_connection_set_auth_param (GstRTSPConnection * conn,
2625     const gchar * param, const gchar * value)
2626 {
2627   g_return_if_fail (conn != NULL);
2628   g_return_if_fail (param != NULL);
2629
2630   if (conn->auth_params == NULL) {
2631     conn->auth_params =
2632         g_hash_table_new_full (str_case_hash, str_case_equal, g_free, g_free);
2633   }
2634   g_hash_table_insert (conn->auth_params, g_strdup (param), g_strdup (value));
2635 }
2636
2637 /**
2638  * gst_rtsp_connection_clear_auth_params:
2639  * @conn: a #GstRTSPConnection
2640  *
2641  * Clear the list of authentication directives stored in @conn.
2642  *
2643  * Since: 0.10.20
2644  */
2645 void
2646 gst_rtsp_connection_clear_auth_params (GstRTSPConnection * conn)
2647 {
2648   g_return_if_fail (conn != NULL);
2649
2650   if (conn->auth_params != NULL) {
2651     g_hash_table_destroy (conn->auth_params);
2652     conn->auth_params = NULL;
2653   }
2654 }
2655
2656 static GstRTSPResult
2657 set_qos_dscp (gint fd, guint qos_dscp)
2658 {
2659   union gst_sockaddr sa;
2660   socklen_t slen = sizeof (sa);
2661   gint af;
2662   gint tos;
2663
2664   if (fd == -1)
2665     return GST_RTSP_OK;
2666
2667   if (getsockname (fd, &sa.sa, &slen) < 0)
2668     goto no_getsockname;
2669
2670   af = sa.sa.sa_family;
2671
2672   /* if this is an IPv4-mapped address then do IPv4 QoS */
2673   if (af == AF_INET6) {
2674     if (IN6_IS_ADDR_V4MAPPED (&sa.sa_in6.sin6_addr))
2675       af = AF_INET;
2676   }
2677
2678   /* extract and shift 6 bits of the DSCP */
2679   tos = (qos_dscp & 0x3f) << 2;
2680
2681   switch (af) {
2682     case AF_INET:
2683       if (SETSOCKOPT (fd, IPPROTO_IP, IP_TOS, &tos, sizeof (tos)) < 0)
2684         goto no_setsockopt;
2685       break;
2686     case AF_INET6:
2687 #ifdef IPV6_TCLASS
2688       if (SETSOCKOPT (fd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof (tos)) < 0)
2689         goto no_setsockopt;
2690       break;
2691 #endif
2692     default:
2693       goto wrong_family;
2694   }
2695
2696   return GST_RTSP_OK;
2697
2698   /* ERRORS */
2699 no_getsockname:
2700 no_setsockopt:
2701   {
2702     return GST_RTSP_ESYS;
2703   }
2704
2705 wrong_family:
2706   {
2707     return GST_RTSP_ERROR;
2708   }
2709 }
2710
2711 /**
2712  * gst_rtsp_connection_set_qos_dscp:
2713  * @conn: a #GstRTSPConnection
2714  * @qos_dscp: DSCP value
2715  *
2716  * Configure @conn to use the specified DSCP value.
2717  *
2718  * Returns: #GST_RTSP_OK on success.
2719  *
2720  * Since: 0.10.20
2721  */
2722 GstRTSPResult
2723 gst_rtsp_connection_set_qos_dscp (GstRTSPConnection * conn, guint qos_dscp)
2724 {
2725   GstRTSPResult res;
2726
2727   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2728   g_return_val_if_fail (conn->readfd != NULL, GST_RTSP_EINVAL);
2729   g_return_val_if_fail (conn->writefd != NULL, GST_RTSP_EINVAL);
2730
2731   res = set_qos_dscp (conn->fd0.fd, qos_dscp);
2732   if (res == GST_RTSP_OK)
2733     res = set_qos_dscp (conn->fd1.fd, qos_dscp);
2734
2735   return res;
2736 }
2737
2738
2739 /**
2740  * gst_rtsp_connection_get_url:
2741  * @conn: a #GstRTSPConnection
2742  *
2743  * Retrieve the URL of the other end of @conn.
2744  *
2745  * Returns: The URL. This value remains valid until the
2746  * connection is freed.
2747  *
2748  * Since: 0.10.23
2749  */
2750 GstRTSPUrl *
2751 gst_rtsp_connection_get_url (const GstRTSPConnection * conn)
2752 {
2753   g_return_val_if_fail (conn != NULL, NULL);
2754
2755   return conn->url;
2756 }
2757
2758 /**
2759  * gst_rtsp_connection_get_ip:
2760  * @conn: a #GstRTSPConnection
2761  *
2762  * Retrieve the IP address of the other end of @conn.
2763  *
2764  * Returns: The IP address as a string. this value remains valid until the
2765  * connection is closed.
2766  *
2767  * Since: 0.10.20
2768  */
2769 const gchar *
2770 gst_rtsp_connection_get_ip (const GstRTSPConnection * conn)
2771 {
2772   g_return_val_if_fail (conn != NULL, NULL);
2773
2774   return conn->ip;
2775 }
2776
2777 /**
2778  * gst_rtsp_connection_set_ip:
2779  * @conn: a #GstRTSPConnection
2780  * @ip: an ip address
2781  *
2782  * Set the IP address of the server.
2783  *
2784  * Since: 0.10.23
2785  */
2786 void
2787 gst_rtsp_connection_set_ip (GstRTSPConnection * conn, const gchar * ip)
2788 {
2789   g_return_if_fail (conn != NULL);
2790
2791   g_free (conn->ip);
2792   conn->ip = g_strdup (ip);
2793 }
2794
2795 /**
2796  * gst_rtsp_connection_get_readfd:
2797  * @conn: a #GstRTSPConnection
2798  *
2799  * Get the file descriptor for reading.
2800  *
2801  * Returns: the file descriptor used for reading or -1 on error. The file
2802  * descriptor remains valid until the connection is closed.
2803  *
2804  * Since: 0.10.23
2805  */
2806 gint
2807 gst_rtsp_connection_get_readfd (const GstRTSPConnection * conn)
2808 {
2809   g_return_val_if_fail (conn != NULL, -1);
2810   g_return_val_if_fail (conn->readfd != NULL, -1);
2811
2812   return conn->readfd->fd;
2813 }
2814
2815 /**
2816  * gst_rtsp_connection_get_writefd:
2817  * @conn: a #GstRTSPConnection
2818  *
2819  * Get the file descriptor for writing.
2820  *
2821  * Returns: the file descriptor used for writing or -1 on error. The file
2822  * descriptor remains valid until the connection is closed.
2823  *
2824  * Since: 0.10.23
2825  */
2826 gint
2827 gst_rtsp_connection_get_writefd (const GstRTSPConnection * conn)
2828 {
2829   g_return_val_if_fail (conn != NULL, -1);
2830   g_return_val_if_fail (conn->writefd != NULL, -1);
2831
2832   return conn->writefd->fd;
2833 }
2834
2835 /**
2836  * gst_rtsp_connection_set_http_mode:
2837  * @conn: a #GstRTSPConnection
2838  * @enable: %TRUE to enable manual HTTP mode
2839  *
2840  * By setting the HTTP mode to %TRUE the message parsing will support HTTP
2841  * messages in addition to the RTSP messages. It will also disable the
2842  * automatic handling of setting up an HTTP tunnel.
2843  *
2844  * Since: 0.10.25
2845  */
2846 void
2847 gst_rtsp_connection_set_http_mode (GstRTSPConnection * conn, gboolean enable)
2848 {
2849   g_return_if_fail (conn != NULL);
2850
2851   conn->manual_http = enable;
2852 }
2853
2854 /**
2855  * gst_rtsp_connection_set_tunneled:
2856  * @conn: a #GstRTSPConnection
2857  * @tunneled: the new state
2858  *
2859  * Set the HTTP tunneling state of the connection. This must be configured before
2860  * the @conn is connected.
2861  *
2862  * Since: 0.10.23
2863  */
2864 void
2865 gst_rtsp_connection_set_tunneled (GstRTSPConnection * conn, gboolean tunneled)
2866 {
2867   g_return_if_fail (conn != NULL);
2868   g_return_if_fail (conn->readfd == NULL);
2869   g_return_if_fail (conn->writefd == NULL);
2870
2871   conn->tunneled = tunneled;
2872 }
2873
2874 /**
2875  * gst_rtsp_connection_is_tunneled:
2876  * @conn: a #GstRTSPConnection
2877  *
2878  * Get the tunneling state of the connection.
2879  *
2880  * Returns: if @conn is using HTTP tunneling.
2881  *
2882  * Since: 0.10.23
2883  */
2884 gboolean
2885 gst_rtsp_connection_is_tunneled (const GstRTSPConnection * conn)
2886 {
2887   g_return_val_if_fail (conn != NULL, FALSE);
2888
2889   return conn->tunneled;
2890 }
2891
2892 /**
2893  * gst_rtsp_connection_get_tunnelid:
2894  * @conn: a #GstRTSPConnection
2895  *
2896  * Get the tunnel session id the connection.
2897  *
2898  * Returns: returns a non-empty string if @conn is being tunneled over HTTP.
2899  *
2900  * Since: 0.10.23
2901  */
2902 const gchar *
2903 gst_rtsp_connection_get_tunnelid (const GstRTSPConnection * conn)
2904 {
2905   g_return_val_if_fail (conn != NULL, NULL);
2906
2907   if (!conn->tunneled)
2908     return NULL;
2909
2910   return conn->tunnelid;
2911 }
2912
2913 /**
2914  * gst_rtsp_connection_do_tunnel:
2915  * @conn: a #GstRTSPConnection
2916  * @conn2: a #GstRTSPConnection or %NULL
2917  *
2918  * If @conn received the first tunnel connection and @conn2 received
2919  * the second tunnel connection, link the two connections together so that
2920  * @conn manages the tunneled connection.
2921  *
2922  * After this call, @conn2 cannot be used anymore and must be freed with
2923  * gst_rtsp_connection_free().
2924  *
2925  * If @conn2 is %NULL then only the base64 decoding context will be setup for
2926  * @conn.
2927  *
2928  * Returns: return GST_RTSP_OK on success.
2929  *
2930  * Since: 0.10.23
2931  */
2932 GstRTSPResult
2933 gst_rtsp_connection_do_tunnel (GstRTSPConnection * conn,
2934     GstRTSPConnection * conn2)
2935 {
2936   g_return_val_if_fail (conn != NULL, GST_RTSP_EINVAL);
2937
2938   if (conn2 != NULL) {
2939     g_return_val_if_fail (conn->tstate == TUNNEL_STATE_GET, GST_RTSP_EINVAL);
2940     g_return_val_if_fail (conn2->tstate == TUNNEL_STATE_POST, GST_RTSP_EINVAL);
2941     g_return_val_if_fail (!memcmp (conn2->tunnelid, conn->tunnelid,
2942             TUNNELID_LEN), GST_RTSP_EINVAL);
2943
2944     /* both connections have fd0 as the read/write socket. start by taking the
2945      * socket from conn2 and set it as the socket in conn */
2946     conn->fd1 = conn2->fd0;
2947
2948     /* clean up some of the state of conn2 */
2949     gst_poll_remove_fd (conn2->fdset, &conn2->fd0);
2950     conn2->fd0.fd = -1;
2951     conn2->readfd = conn2->writefd = NULL;
2952
2953     /* We make fd0 the write socket and fd1 the read socket. */
2954     conn->writefd = &conn->fd0;
2955     conn->readfd = &conn->fd1;
2956
2957     conn->tstate = TUNNEL_STATE_COMPLETE;
2958   }
2959
2960   /* we need base64 decoding for the readfd */
2961   conn->ctx.state = 0;
2962   conn->ctx.save = 0;
2963   conn->ctx.cout = 0;
2964   conn->ctx.coutl = 0;
2965   conn->ctxp = &conn->ctx;
2966
2967   return GST_RTSP_OK;
2968 }
2969
2970 #define READ_COND   (G_IO_IN | G_IO_HUP | G_IO_ERR)
2971 #define WRITE_COND  (G_IO_OUT | G_IO_ERR)
2972
2973 typedef struct
2974 {
2975   guint8 *data;
2976   guint size;
2977   guint id;
2978 } GstRTSPRec;
2979
2980 /* async functions */
2981 struct _GstRTSPWatch
2982 {
2983   GSource source;
2984
2985   GstRTSPConnection *conn;
2986
2987   GstRTSPBuilder builder;
2988   GstRTSPMessage message;
2989
2990   GPollFD readfd;
2991   GPollFD writefd;
2992   gboolean write_added;
2993
2994   /* queued message for transmission */
2995   guint id;
2996   GMutex *mutex;
2997   GQueue *messages;
2998   guint8 *write_data;
2999   guint write_off;
3000   guint write_size;
3001   guint write_id;
3002
3003   GstRTSPWatchFuncs funcs;
3004
3005   gpointer user_data;
3006   GDestroyNotify notify;
3007 };
3008
3009 static gboolean
3010 gst_rtsp_source_prepare (GSource * source, gint * timeout)
3011 {
3012   GstRTSPWatch *watch = (GstRTSPWatch *) source;
3013
3014   if (watch->conn->initial_buffer != NULL)
3015     return TRUE;
3016
3017   *timeout = (watch->conn->timeout * 1000);
3018
3019   return FALSE;
3020 }
3021
3022 static gboolean
3023 gst_rtsp_source_check (GSource * source)
3024 {
3025   GstRTSPWatch *watch = (GstRTSPWatch *) source;
3026
3027   if (watch->readfd.revents & READ_COND)
3028     return TRUE;
3029
3030   if (watch->writefd.revents & WRITE_COND)
3031     return TRUE;
3032
3033   return FALSE;
3034 }
3035
3036 static gboolean
3037 gst_rtsp_source_dispatch (GSource * source, GSourceFunc callback G_GNUC_UNUSED,
3038     gpointer user_data G_GNUC_UNUSED)
3039 {
3040   GstRTSPWatch *watch = (GstRTSPWatch *) source;
3041   GstRTSPResult res;
3042
3043   /* first read as much as we can */
3044   if (watch->readfd.revents & READ_COND || watch->conn->initial_buffer != NULL) {
3045     do {
3046       res = build_next (&watch->builder, &watch->message, watch->conn);
3047       if (res == GST_RTSP_EINTR)
3048         break;
3049       else if (G_UNLIKELY (res == GST_RTSP_EEOF))
3050         goto eof;
3051       else if (G_LIKELY (res == GST_RTSP_OK)) {
3052         if (!watch->conn->manual_http &&
3053             watch->message.type == GST_RTSP_MESSAGE_HTTP_REQUEST) {
3054           if (watch->conn->tstate == TUNNEL_STATE_NONE &&
3055               watch->message.type_data.request.method == GST_RTSP_GET) {
3056             GstRTSPMessage *response;
3057             GstRTSPStatusCode code;
3058
3059             watch->conn->tstate = TUNNEL_STATE_GET;
3060
3061             if (watch->funcs.tunnel_start)
3062               code = watch->funcs.tunnel_start (watch, watch->user_data);
3063             else
3064               code = GST_RTSP_STS_OK;
3065
3066             /* queue the response */
3067             response = gen_tunnel_reply (watch->conn, code, &watch->message);
3068             gst_rtsp_watch_send_message (watch, response, NULL);
3069             gst_rtsp_message_free (response);
3070             goto read_done;
3071           } else if (watch->conn->tstate == TUNNEL_STATE_NONE &&
3072               watch->message.type_data.request.method == GST_RTSP_POST) {
3073             watch->conn->tstate = TUNNEL_STATE_POST;
3074
3075             /* in the callback the connection should be tunneled with the
3076              * GET connection */
3077             if (watch->funcs.tunnel_complete)
3078               watch->funcs.tunnel_complete (watch, watch->user_data);
3079             goto read_done;
3080           }
3081         }
3082       }
3083
3084       if (!watch->conn->manual_http) {
3085         /* if manual HTTP support is not enabled, then restore the message to
3086          * what it would have looked like without the support for parsing HTTP
3087          * messages being present */
3088         if (watch->message.type == GST_RTSP_MESSAGE_HTTP_REQUEST) {
3089           watch->message.type = GST_RTSP_MESSAGE_REQUEST;
3090           watch->message.type_data.request.method = GST_RTSP_INVALID;
3091           if (watch->message.type_data.request.version != GST_RTSP_VERSION_1_0)
3092             watch->message.type_data.request.version = GST_RTSP_VERSION_INVALID;
3093           res = GST_RTSP_EPARSE;
3094         } else if (watch->message.type == GST_RTSP_MESSAGE_HTTP_RESPONSE) {
3095           watch->message.type = GST_RTSP_MESSAGE_RESPONSE;
3096           if (watch->message.type_data.response.version != GST_RTSP_VERSION_1_0)
3097             watch->message.type_data.response.version =
3098                 GST_RTSP_VERSION_INVALID;
3099           res = GST_RTSP_EPARSE;
3100         }
3101       }
3102
3103       if (G_LIKELY (res == GST_RTSP_OK)) {
3104         if (watch->funcs.message_received)
3105           watch->funcs.message_received (watch, &watch->message,
3106               watch->user_data);
3107       } else {
3108         if (watch->funcs.error_full)
3109           GST_RTSP_CHECK (watch->funcs.error_full (watch, res, &watch->message,
3110                   0, watch->user_data), error);
3111         else
3112           goto error;
3113       }
3114
3115     read_done:
3116       gst_rtsp_message_unset (&watch->message);
3117       build_reset (&watch->builder);
3118     } while (FALSE);
3119   }
3120
3121   if (watch->writefd.revents & WRITE_COND) {
3122     g_mutex_lock (watch->mutex);
3123     do {
3124       if (watch->write_data == NULL) {
3125         GstRTSPRec *rec;
3126
3127         /* get a new message from the queue */
3128         rec = g_queue_pop_tail (watch->messages);
3129         if (rec == NULL)
3130           goto done;
3131
3132         watch->write_off = 0;
3133         watch->write_data = rec->data;
3134         watch->write_size = rec->size;
3135         watch->write_id = rec->id;
3136
3137         g_slice_free (GstRTSPRec, rec);
3138       }
3139
3140       res = write_bytes (watch->writefd.fd, watch->write_data,
3141           &watch->write_off, watch->write_size);
3142       g_mutex_unlock (watch->mutex);
3143       if (res == GST_RTSP_EINTR)
3144         goto write_blocked;
3145       else if (G_LIKELY (res == GST_RTSP_OK)) {
3146         if (watch->funcs.message_sent)
3147           watch->funcs.message_sent (watch, watch->write_id, watch->user_data);
3148       } else {
3149         if (watch->funcs.error_full)
3150           GST_RTSP_CHECK (watch->funcs.error_full (watch, res, NULL,
3151                   watch->write_id, watch->user_data), error);
3152         else
3153           goto error;
3154       }
3155       g_mutex_lock (watch->mutex);
3156
3157       g_free (watch->write_data);
3158       watch->write_data = NULL;
3159     } while (TRUE);
3160
3161   done:
3162     if (watch->write_added) {
3163       g_source_remove_poll ((GSource *) watch, &watch->writefd);
3164       watch->write_added = FALSE;
3165       watch->writefd.revents = 0;
3166     }
3167
3168     g_mutex_unlock (watch->mutex);
3169   }
3170
3171 write_blocked:
3172   return TRUE;
3173
3174   /* ERRORS */
3175 eof:
3176   {
3177     if (watch->funcs.closed)
3178       watch->funcs.closed (watch, watch->user_data);
3179     return FALSE;
3180   }
3181 error:
3182   {
3183     if (watch->funcs.error)
3184       watch->funcs.error (watch, res, watch->user_data);
3185     return FALSE;
3186   }
3187 }
3188
3189 static void
3190 gst_rtsp_rec_free (gpointer data)
3191 {
3192   GstRTSPRec *rec = data;
3193
3194   g_free (rec->data);
3195   g_slice_free (GstRTSPRec, rec);
3196 }
3197
3198 static void
3199 gst_rtsp_source_finalize (GSource * source)
3200 {
3201   GstRTSPWatch *watch = (GstRTSPWatch *) source;
3202
3203   build_reset (&watch->builder);
3204   gst_rtsp_message_unset (&watch->message);
3205
3206   g_queue_foreach (watch->messages, (GFunc) gst_rtsp_rec_free, NULL);
3207   g_queue_free (watch->messages);
3208   watch->messages = NULL;
3209
3210   g_mutex_free (watch->mutex);
3211
3212   g_free (watch->write_data);
3213
3214   if (watch->notify)
3215     watch->notify (watch->user_data);
3216 }
3217
3218 static GSourceFuncs gst_rtsp_source_funcs = {
3219   gst_rtsp_source_prepare,
3220   gst_rtsp_source_check,
3221   gst_rtsp_source_dispatch,
3222   gst_rtsp_source_finalize,
3223   NULL,
3224   NULL
3225 };
3226
3227 /**
3228  * gst_rtsp_watch_new:
3229  * @conn: a #GstRTSPConnection
3230  * @funcs: watch functions
3231  * @user_data: user data to pass to @funcs
3232  * @notify: notify when @user_data is not referenced anymore
3233  *
3234  * Create a watch object for @conn. The functions provided in @funcs will be
3235  * called with @user_data when activity happened on the watch.
3236  *
3237  * The new watch is usually created so that it can be attached to a
3238  * maincontext with gst_rtsp_watch_attach().
3239  *
3240  * @conn must exist for the entire lifetime of the watch.
3241  *
3242  * Returns: a #GstRTSPWatch that can be used for asynchronous RTSP
3243  * communication. Free with gst_rtsp_watch_unref () after usage.
3244  *
3245  * Since: 0.10.23
3246  */
3247 GstRTSPWatch *
3248 gst_rtsp_watch_new (GstRTSPConnection * conn,
3249     GstRTSPWatchFuncs * funcs, gpointer user_data, GDestroyNotify notify)
3250 {
3251   GstRTSPWatch *result;
3252
3253   g_return_val_if_fail (conn != NULL, NULL);
3254   g_return_val_if_fail (funcs != NULL, NULL);
3255   g_return_val_if_fail (conn->readfd != NULL, NULL);
3256   g_return_val_if_fail (conn->writefd != NULL, NULL);
3257
3258   result = (GstRTSPWatch *) g_source_new (&gst_rtsp_source_funcs,
3259       sizeof (GstRTSPWatch));
3260
3261   result->conn = conn;
3262   result->builder.state = STATE_START;
3263
3264   result->mutex = g_mutex_new ();
3265   result->messages = g_queue_new ();
3266
3267   result->readfd.fd = -1;
3268   result->writefd.fd = -1;
3269
3270   gst_rtsp_watch_reset (result);
3271
3272   result->funcs = *funcs;
3273   result->user_data = user_data;
3274   result->notify = notify;
3275
3276   /* only add the read fd, the write fd is only added when we have data
3277    * to send. */
3278   g_source_add_poll ((GSource *) result, &result->readfd);
3279
3280   return result;
3281 }
3282
3283 /**
3284  * gst_rtsp_watch_reset:
3285  * @watch: a #GstRTSPWatch
3286  *
3287  * Reset @watch, this is usually called after gst_rtsp_connection_do_tunnel()
3288  * when the file descriptors of the connection might have changed.
3289  *
3290  * Since: 0.10.23
3291  */
3292 void
3293 gst_rtsp_watch_reset (GstRTSPWatch * watch)
3294 {
3295   if (watch->readfd.fd != -1)
3296     g_source_remove_poll ((GSource *) watch, &watch->readfd);
3297   if (watch->writefd.fd != -1)
3298     g_source_remove_poll ((GSource *) watch, &watch->writefd);
3299
3300   watch->readfd.fd = watch->conn->readfd->fd;
3301   watch->readfd.events = READ_COND;
3302   watch->readfd.revents = 0;
3303
3304   watch->writefd.fd = watch->conn->writefd->fd;
3305   watch->writefd.events = WRITE_COND;
3306   watch->writefd.revents = 0;
3307   watch->write_added = FALSE;
3308
3309   g_source_add_poll ((GSource *) watch, &watch->readfd);
3310 }
3311
3312 /**
3313  * gst_rtsp_watch_attach:
3314  * @watch: a #GstRTSPWatch
3315  * @context: a GMainContext (if NULL, the default context will be used)
3316  *
3317  * Adds a #GstRTSPWatch to a context so that it will be executed within that context.
3318  *
3319  * Returns: the ID (greater than 0) for the watch within the GMainContext.
3320  *
3321  * Since: 0.10.23
3322  */
3323 guint
3324 gst_rtsp_watch_attach (GstRTSPWatch * watch, GMainContext * context)
3325 {
3326   g_return_val_if_fail (watch != NULL, 0);
3327
3328   return g_source_attach ((GSource *) watch, context);
3329 }
3330
3331 /**
3332  * gst_rtsp_watch_unref:
3333  * @watch: a #GstRTSPWatch
3334  *
3335  * Decreases the reference count of @watch by one. If the resulting reference
3336  * count is zero the watch and associated memory will be destroyed.
3337  *
3338  * Since: 0.10.23
3339  */
3340 void
3341 gst_rtsp_watch_unref (GstRTSPWatch * watch)
3342 {
3343   g_return_if_fail (watch != NULL);
3344
3345   g_source_unref ((GSource *) watch);
3346 }
3347
3348 /**
3349  * gst_rtsp_watch_write_data:
3350  * @watch: a #GstRTSPWatch
3351  * @data: the data to queue
3352  * @size: the size of @data
3353  * @id: location for a message ID or %NULL
3354  *
3355  * Write @data using the connection of the @watch. If it cannot be sent
3356  * immediately, it will be queued for transmission in @watch. The contents of
3357  * @message will then be serialized and transmitted when the connection of the
3358  * @watch becomes writable. In case the @message is queued, the ID returned in
3359  * @id will be non-zero and used as the ID argument in the message_sent
3360  * callback.
3361  *
3362  * This function will take ownership of @data and g_free() it after use.
3363  *
3364  * Returns: #GST_RTSP_OK on success.
3365  *
3366  * Since: 0.10.25
3367  */
3368 GstRTSPResult
3369 gst_rtsp_watch_write_data (GstRTSPWatch * watch, const guint8 * data,
3370     guint size, guint * id)
3371 {
3372   GstRTSPResult res;
3373   GstRTSPRec *rec;
3374   guint off = 0;
3375
3376   g_return_val_if_fail (watch != NULL, GST_RTSP_EINVAL);
3377   g_return_val_if_fail (data != NULL, GST_RTSP_EINVAL);
3378   g_return_val_if_fail (size != 0, GST_RTSP_EINVAL);
3379
3380   g_mutex_lock (watch->mutex);
3381
3382   if (watch->messages->length == 0) {
3383     res = write_bytes (watch->writefd.fd, data, &off, size);
3384     if (res != GST_RTSP_EINTR) {
3385       if (id != NULL)
3386         *id = 0;
3387       g_free ((gpointer) data);
3388       goto done;
3389     }
3390   }
3391
3392   /* make a record with the data and id */
3393   rec = g_slice_new (GstRTSPRec);
3394   if (off == 0) {
3395     rec->data = (guint8 *) data;
3396     rec->size = size;
3397   } else {
3398     rec->data = g_memdup (data + off, size - off);
3399     rec->size = size - off;
3400     g_free ((gpointer) data);
3401   }
3402
3403   do {
3404     /* make sure rec->id is never 0 */
3405     rec->id = ++watch->id;
3406   } while (G_UNLIKELY (rec->id == 0));
3407
3408   /* add the record to a queue. FIXME we would like to have an upper limit here */
3409   g_queue_push_head (watch->messages, rec);
3410
3411   /* make sure the main context will now also check for writability on the
3412    * socket */
3413   if (!watch->write_added) {
3414     g_source_add_poll ((GSource *) watch, &watch->writefd);
3415     watch->write_added = TRUE;
3416   }
3417
3418   if (id != NULL)
3419     *id = rec->id;
3420   res = GST_RTSP_OK;
3421
3422 done:
3423   g_mutex_unlock (watch->mutex);
3424   return res;
3425 }
3426
3427 /**
3428  * gst_rtsp_watch_send_message:
3429  * @watch: a #GstRTSPWatch
3430  * @message: a #GstRTSPMessage
3431  * @id: location for a message ID or %NULL
3432  *
3433  * Send a @message using the connection of the @watch. If it cannot be sent
3434  * immediately, it will be queued for transmission in @watch. The contents of
3435  * @message will then be serialized and transmitted when the connection of the
3436  * @watch becomes writable. In case the @message is queued, the ID returned in
3437  * @id will be non-zero and used as the ID argument in the message_sent
3438  * callback.
3439  *
3440  * Returns: #GST_RTSP_OK on success.
3441  *
3442  * Since: 0.10.25
3443  */
3444 GstRTSPResult
3445 gst_rtsp_watch_send_message (GstRTSPWatch * watch, GstRTSPMessage * message,
3446     guint * id)
3447 {
3448   GString *str;
3449   guint size;
3450
3451   g_return_val_if_fail (watch != NULL, GST_RTSP_EINVAL);
3452   g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
3453
3454   /* make a record with the message as a string and id */
3455   str = message_to_string (watch->conn, message);
3456   size = str->len;
3457   return gst_rtsp_watch_write_data (watch,
3458       (guint8 *) g_string_free (str, FALSE), size, id);
3459 }
3460
3461 /**
3462  * gst_rtsp_watch_queue_data:
3463  * @watch: a #GstRTSPWatch
3464  * @data: the data to queue
3465  * @size: the size of @data
3466  *
3467  * Queue @data for transmission in @watch. It will be transmitted when the
3468  * connection of the @watch becomes writable.
3469  *
3470  * This function will take ownership of @data and g_free() it after use.
3471  *
3472  * The return value of this function will be used as the id argument in the
3473  * message_sent callback.
3474  *
3475  * Deprecated: Use gst_rtsp_watch_write_data()
3476  *
3477  * Returns: an id.
3478  *
3479  * Since: 0.10.24
3480  */
3481 #ifndef GST_REMOVE_DEPRECATED
3482 guint
3483 gst_rtsp_watch_queue_data (GstRTSPWatch * watch, const guint8 * data,
3484     guint size)
3485 {
3486   GstRTSPRec *rec;
3487
3488   g_return_val_if_fail (watch != NULL, GST_RTSP_EINVAL);
3489   g_return_val_if_fail (data != NULL, GST_RTSP_EINVAL);
3490   g_return_val_if_fail (size != 0, GST_RTSP_EINVAL);
3491
3492   g_mutex_lock (watch->mutex);
3493
3494   /* make a record with the data and id */
3495   rec = g_slice_new (GstRTSPRec);
3496   rec->data = (guint8 *) data;
3497   rec->size = size;
3498   do {
3499     /* make sure rec->id is never 0 */
3500     rec->id = ++watch->id;
3501   } while (G_UNLIKELY (rec->id == 0));
3502
3503   /* add the record to a queue. FIXME we would like to have an upper limit here */
3504   g_queue_push_head (watch->messages, rec);
3505
3506   /* make sure the main context will now also check for writability on the
3507    * socket */
3508   if (!watch->write_added) {
3509     g_source_add_poll ((GSource *) watch, &watch->writefd);
3510     watch->write_added = TRUE;
3511   }
3512
3513   g_mutex_unlock (watch->mutex);
3514   return rec->id;
3515 }
3516 #endif /* GST_REMOVE_DEPRECATED */
3517
3518 /**
3519  * gst_rtsp_watch_queue_message:
3520  * @watch: a #GstRTSPWatch
3521  * @message: a #GstRTSPMessage
3522  *
3523  * Queue a @message for transmission in @watch. The contents of this
3524  * message will be serialized and transmitted when the connection of the
3525  * @watch becomes writable.
3526  *
3527  * The return value of this function will be used as the id argument in the
3528  * message_sent callback.
3529  *
3530  * Deprecated: Use gst_rtsp_watch_send_message()
3531  *
3532  * Returns: an id.
3533  *
3534  * Since: 0.10.23
3535  */
3536 #ifndef GST_REMOVE_DEPRECATED
3537 guint
3538 gst_rtsp_watch_queue_message (GstRTSPWatch * watch, GstRTSPMessage * message)
3539 {
3540   GString *str;
3541   guint size;
3542
3543   g_return_val_if_fail (watch != NULL, GST_RTSP_EINVAL);
3544   g_return_val_if_fail (message != NULL, GST_RTSP_EINVAL);
3545
3546   /* make a record with the message as a string and id */
3547   str = message_to_string (watch->conn, message);
3548   size = str->len;
3549   return gst_rtsp_watch_queue_data (watch,
3550       (guint8 *) g_string_free (str, FALSE), size);
3551 }
3552 #endif /* GST_REMOVE_DEPRECATED */