* Copyright (C) <2005-2009> Wim Taymans <wim.taymans@gmail.com>

/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.

 * minwg32 headers check WINVER before allowing the use of these */

#ifndef WINVER

#define WINVER 0x0501

#endif

#include <ws2tcpip.h>

#include <fcntl.h>

#include "md5.h"

union gst_sockaddr

{

  struct sockaddr sa;

  struct sockaddr_in sa_in;

  struct sockaddr_in6 sa_in6;

  struct sockaddr_storage sa_stor;

};

typedef struct

{

  gint state;

  guint save;

  guchar out[3];                /* the size must be evenly divisible by 3 */

  guint cout;

  guint coutl;

} DecodeCtx;

static GstRTSPResult read_line (gint fd, guint8 * buffer, guint * idx,

    guint size, DecodeCtx * ctxp);

static GstRTSPResult parse_key_value (guint8 * buffer, gchar * key,

    guint keysize, gchar ** value);

static void parse_string (gchar * dest, gint size, gchar ** src);

#define READ_SOCKET(fd, buf, len) recv (fd, (char *)buf, len, 0)

#define WRITE_SOCKET(fd, buf, len) send (fd, (const char *)buf, len, 0)

#define SETSOCKOPT(sock, level, name, val, len) setsockopt (sock, level, name, (const char *)val, len)

#define ERRNO_IS_EAGAIN (WSAGetLastError () == WSAEWOULDBLOCK)

#define ERRNO_IS_EINTR (WSAGetLastError () == WSAEINTR)

#define ERRNO_IS_EINPROGRESS (WSAGetLastError () == WSAEWOULDBLOCK)

#define SETSOCKOPT(sock, level, name, val, len) setsockopt (sock, level, name, val, len)

#define ERRNO_IS_EAGAIN (errno == EAGAIN)

#define ERRNO_IS_EINTR (errno == EINTR)

#define ERRNO_IS_EINPROGRESS (errno == EINPROGRESS)

#define ADD_POLLFD(fdset, pfd, fd)        \

G_STMT_START {                            \

  (pfd)->fd = fd;                         \

  gst_poll_add_fd (fdset, pfd);           \

} G_STMT_END

#define REMOVE_POLLFD(fdset, pfd)          \

G_STMT_START {                             \

  if ((pfd)->fd != -1) {                   \

    GST_DEBUG ("remove fd %d", (pfd)->fd); \

    gst_poll_remove_fd (fdset, pfd);       \

    CLOSE_SOCKET ((pfd)->fd);              \

    (pfd)->fd = -1;                        \

  }                                        \

} G_STMT_END

typedef enum

{

  TUNNEL_STATE_NONE,

  TUNNEL_STATE_GET,

  TUNNEL_STATE_POST,

  TUNNEL_STATE_COMPLETE

} GstRTSPTunnelState;

#define TUNNELID_LEN   24

struct _GstRTSPConnection

  /*< private > */

  /* URL for the connection */

  GstRTSPUrl *url;

  /* connection state */

  GstPollFD fd0;

  GstPollFD fd1;

  GstPollFD *readfd;

  GstPollFD *writefd;

  gchar tunnelid[TUNNELID_LEN];

  gboolean tunneled;

  GstRTSPTunnelState tstate;

  GstPoll *fdset;

  gchar *ip;

  /* Session state */

  gint cseq;                    /* sequence number */

  gchar session_id[512];        /* session id */

  gint timeout;                 /* session timeout in seconds */

  GTimer *timer;                /* timeout timer */

  /* Authentication */

  GstRTSPAuthMethod auth_method;

  gchar *username;

  gchar *passwd;

  GHashTable *auth_params;

  DecodeCtx ctx;

  DecodeCtx *ctxp;

  gchar *proxy_host;

  guint proxy_port;

};

enum

{

  STATE_START = 0,

  STATE_DATA_HEADER,

  STATE_DATA_BODY,

  STATE_READ_LINES,

  STATE_END,

  STATE_LAST

};

/* a structure for constructing RTSPMessages */

typedef struct

{

  gint state;

  guint8 buffer[4096];

  guint offset;

  guint line;

  guint8 *body_data;

  glong body_len;

} GstRTSPBuilder;

static void

build_reset (GstRTSPBuilder * builder)

{

  g_free (builder->body_data);

  memset (builder, 0, sizeof (GstRTSPBuilder));

 * @conn: storage for a #GstRTSPConnection

 * A copy of @url will be made.

 *

gst_rtsp_connection_create (const GstRTSPUrl * url, GstRTSPConnection ** conn)

#ifdef G_OS_WIN32

  WSADATA w;

  int error;

#endif

#ifdef G_OS_WIN32

  error = WSAStartup (0x0202, &w);

  if (error)

    goto startup_error;

  if (w.wVersion != 0x0202)

    goto version_error;

#endif

  newconn->url = gst_rtsp_url_copy (url);

  newconn->fd0.fd = -1;

  newconn->fd1.fd = -1;

  newconn->timeout = 60;

  newconn->cseq = 1;

  newconn->auth_params = NULL;

  *conn = newconn;

  return GST_RTSP_OK;

  /* ERRORS */

#ifdef G_OS_WIN32

startup_error:

  {

    g_warning ("Error %d on WSAStartup", error);

    return GST_RTSP_EWSASTART;

  }

version_error:

  {

    g_warning ("Windows sockets are not version 0x202 (current 0x%x)",

        w.wVersion);

    WSACleanup ();

    return GST_RTSP_EWSAVERSION;

  }

#endif

no_fdset:

  {

    g_free (newconn);

#ifdef G_OS_WIN32

    WSACleanup ();

#endif

    return GST_RTSP_ESYS;

  }

}

/**

 * gst_rtsp_connection_accept:

 * @sock: a socket

 * @conn: storage for a #GstRTSPConnection

 *

 * Accept a new connection on @sock and create a new #GstRTSPConnection for

 * handling communication on new socket.

 *

 * Returns: #GST_RTSP_OK when @conn contains a valid connection.

 *

 * Since: 0.10.23

 */

GstRTSPResult

gst_rtsp_connection_accept (gint sock, GstRTSPConnection ** conn)

{

  int fd;

  GstRTSPConnection *newconn = NULL;

  union gst_sockaddr sa;

  socklen_t slen = sizeof (sa);

  gchar ip[INET6_ADDRSTRLEN];

  GstRTSPUrl *url;

#ifdef G_OS_WIN32

  gulong flags = 1;

#endif

  memset (&sa, 0, slen);

#ifndef G_OS_WIN32

  fd = accept (sock, &sa.sa, &slen);

#else

  fd = accept (sock, &sa.sa, (gint *) & slen);

#endif /* G_OS_WIN32 */

  if (fd == -1)

    goto accept_failed;

  if (getnameinfo (&sa.sa, slen, ip, sizeof (ip), NULL, 0, NI_NUMERICHOST) != 0)

    goto getnameinfo_failed;

  if (sa.sa.sa_family != AF_INET && sa.sa.sa_family != AF_INET6)

    goto wrong_family;

  /* set to non-blocking mode so that we can cancel the communication */

#ifndef G_OS_WIN32

  fcntl (fd, F_SETFL, O_NONBLOCK);

#else

  ioctlsocket (fd, FIONBIO, &flags);

#endif /* G_OS_WIN32 */

  /* create a url for the client address */

  url = g_new0 (GstRTSPUrl, 1);

  url->host = g_strdup (ip);

  if (sa.sa.sa_family == AF_INET)

    url->port = sa.sa_in.sin_port;

  else

    url->port = sa.sa_in6.sin6_port;

  /* now create the connection object */

  gst_rtsp_connection_create (url, &newconn);

  gst_rtsp_url_free (url);

  ADD_POLLFD (newconn->fdset, &newconn->fd0, fd);

  /* both read and write initially */

  newconn->readfd = &newconn->fd0;

  newconn->writefd = &newconn->fd0;

accept_failed:

  {

    return GST_RTSP_ESYS;

  }

getnameinfo_failed:

wrong_family:

  {

    close (fd);

    return GST_RTSP_ERROR;

  }

}

static gchar *

do_resolve (const gchar * host)

{

  static gchar ip[INET6_ADDRSTRLEN];

  struct addrinfo *aires;

  struct addrinfo *ai;

  gint aierr;

  aierr = getaddrinfo (host, NULL, NULL, &aires);

  if (aierr != 0)

    goto no_addrinfo;

  for (ai = aires; ai; ai = ai->ai_next) {

    if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {

      break;

    }

  }

  if (ai == NULL)

    goto no_family;

  aierr = getnameinfo (ai->ai_addr, ai->ai_addrlen, ip, sizeof (ip), NULL, 0,

      NI_NUMERICHOST | NI_NUMERICSERV);

  if (aierr != 0)

    goto no_address;

  freeaddrinfo (aires);

  return g_strdup (ip);

  /* ERRORS */

no_addrinfo:

  {

    GST_ERROR ("no addrinfo found for %s: %s", host, gai_strerror (aierr));

    return NULL;

  }

no_family:

  {

    GST_ERROR ("no family found for %s", host);

    freeaddrinfo (aires);

    return NULL;

  }

no_address:

  {

    GST_ERROR ("no address found for %s: %s", host, gai_strerror (aierr));

    freeaddrinfo (aires);

    return NULL;

  }

}

static GstRTSPResult

do_connect (const gchar * ip, guint16 port, GstPollFD * fdout,

    GstPoll * fdset, GTimeVal * timeout)

{

  gint fd;

  struct addrinfo hints;

  struct addrinfo *aires;

  struct addrinfo *ai;

  gint aierr;

  gchar service[NI_MAXSERV];

  gint ret;

#ifdef G_OS_WIN32

  unsigned long flags = 1;

#endif /* G_OS_WIN32 */

  GstClockTime to;

  gint retval;

  memset (&hints, 0, sizeof hints);

  hints.ai_flags = AI_NUMERICHOST;

  hints.ai_family = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;

  g_snprintf (service, sizeof (service) - 1, "%hu", port);

  service[sizeof (service) - 1] = '\0';

  aierr = getaddrinfo (ip, service, &hints, &aires);

  if (aierr != 0)

    goto no_addrinfo;

  for (ai = aires; ai; ai = ai->ai_next) {

    if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {

      break;

    }

  }

  if (ai == NULL)

    goto no_family;

  fd = socket (ai->ai_family, SOCK_STREAM, 0);

  if (fd == -1)

    goto no_socket;

  /* set to non-blocking mode so that we can cancel the connect */

#ifndef G_OS_WIN32

  fcntl (fd, F_SETFL, O_NONBLOCK);

#else

  ioctlsocket (fd, FIONBIO, &flags);

#endif /* G_OS_WIN32 */

  /* add the socket to our fdset */

  ADD_POLLFD (fdset, fdout, fd);

  /* we are going to connect ASYNC now */

  ret = connect (fd, ai->ai_addr, ai->ai_addrlen);

  if (ret == 0)