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