/* GStreamer

 * Copyright (C) <2005,2006> Wim Taymans <wim@fluendo.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Unless otherwise indicated, Source Code is licensed under MIT license.

 * See further explanation attached in License Statement (distributed in the file

 * LICENSE).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy of

 * this software and associated documentation files (the "Software"), to deal in

 * the Software without restriction, including without limitation the rights to

 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do

 * so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

/**

 * SECTION:gstsdpmessage

 * @short_description: Helper methods for dealing with SDP messages

 *

 * <refsect2>

 * <para>

 * The GstSDPMessage helper functions makes it easy to parse and create SDP

 * messages.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2007-07-24 (0.10.14)

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#include <glib.h>               /* for G_OS_WIN32 */

#include <gst/gstinfo.h>        /* For GST_STR_NULL */

#ifdef G_OS_WIN32

#ifdef _MSC_VER

#include <Winsock2.h>

#endif

#include <ws2tcpip.h>

#else

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#endif

#include "gstsdpmessage.h"

/* FIXME, is currently allocated on the stack */

#define MAX_LINE_LEN    1024 * 16

#define FREE_STRING(field)              g_free (field); (field) = NULL

#define REPLACE_STRING(field, val)      FREE_STRING(field); (field) = g_strdup (val)

#define INIT_ARRAY(field, type, init_func)              \

G_STMT_START {                                          \

  if (field) {                                          \

    guint i;                                            \

    for(i = 0; i < (field)->len; i++)                   \

      init_func (&g_array_index ((field), type, i));    \

    g_array_set_size ((field), 0);                      \

  }                                                     \

  else                                                  \

    (field) = g_array_new (FALSE, TRUE, sizeof (type)); \

} G_STMT_END

#define FREE_ARRAY(field)         \

G_STMT_START {                    \

  if (field)                      \

    g_array_free ((field), TRUE); \

  (field) = NULL;                 \

} G_STMT_END

#define INIT_PTR_ARRAY(field, type, init_func)          \

G_STMT_START {                                          \

  if (field) {                                          \

    guint i;                                            \

    for(i = 0; i < (field)->len; i++)                   \

      init_func (g_array_index ((field), type, i));     \

    g_array_set_size ((field), 0);                      \

  }                                                     \

  else                                                  \

    (field) = g_array_new (FALSE, TRUE, sizeof (type)); \

} G_STMT_END

#define FREE_PTR_ARRAY(field) FREE_ARRAY(field)

#define DEFINE_STRING_SETTER(field)                                     \

GstSDPResult gst_sdp_message_set_##field (GstSDPMessage *msg, const gchar *val) { \

  g_free (msg->field);                                                  \

  msg->field = g_strdup (val);                                          \

  return GST_SDP_OK;                                                    \

}

#define DEFINE_STRING_GETTER(field)                                     \

const gchar* gst_sdp_message_get_##field (const GstSDPMessage *msg) {   \

  return msg->field;                                                    \

}

#define DEFINE_ARRAY_LEN(field)                                         \

guint gst_sdp_message_##field##_len (const GstSDPMessage *msg) {        \

  return msg->field->len;                                               \

}

#define DEFINE_ARRAY_GETTER(method, field, type)                        \

type * gst_sdp_message_get_##method (const GstSDPMessage *msg, guint idx) {  \

  return &g_array_index (msg->field, type, idx);                        \

}

#define DEFINE_PTR_ARRAY_LEN(field) DEFINE_ARRAY_LEN(field)

#define DEFINE_PTR_ARRAY_GETTER(method, field, type)                    \

type gst_sdp_message_get_##method (const GstSDPMessage *msg, guint idx) {    \

  return g_array_index (msg->field, type, idx);                         \

}

#define DEFINE_PTR_ARRAY_ADDER(method, field, type, dup_method)         \

GstSDPResult gst_sdp_message_add_##method (GstSDPMessage *msg, type val) {   \

  type v = dup_method (val);                                            \

  g_array_append_val (msg->field, v);                                   \

  return GST_SDP_OK;                                                    \

}

static void

gst_sdp_origin_init (GstSDPOrigin * origin)

{

  FREE_STRING (origin->username);

  FREE_STRING (origin->sess_id);

  FREE_STRING (origin->sess_version);

  FREE_STRING (origin->nettype);

  FREE_STRING (origin->addrtype);

  FREE_STRING (origin->addr);

}

static void

gst_sdp_connection_init (GstSDPConnection * connection)

{

  FREE_STRING (connection->nettype);

  FREE_STRING (connection->addrtype);

  FREE_STRING (connection->address);

  connection->ttl = 0;

  connection->addr_number = 0;

}

static void

gst_sdp_bandwidth_init (GstSDPBandwidth * bandwidth)

{

  FREE_STRING (bandwidth->bwtype);

  bandwidth->bandwidth = 0;

}

static void

gst_sdp_time_init (GstSDPTime * t)

{

  FREE_STRING (t->start);

  FREE_STRING (t->stop);

  INIT_PTR_ARRAY (t->repeat, gchar *, g_free);

  FREE_PTR_ARRAY (t->repeat);

}

static void

gst_sdp_zone_init (GstSDPZone * zone)

{

  FREE_STRING (zone->time);

  FREE_STRING (zone->typed_time);

}

static void

gst_sdp_key_init (GstSDPKey * key)

{

  FREE_STRING (key->type);

  FREE_STRING (key->data);

}

static void

gst_sdp_attribute_init (GstSDPAttribute * attr)

{

  FREE_STRING (attr->key);

  FREE_STRING (attr->value);

}

/**

 * gst_sdp_message_new:

 * @msg: pointer to new #GstSDPMessage

 *

 * Allocate a new GstSDPMessage and store the result in @msg.

 *

 * Returns: a #GstSDPResult.

 */

GstSDPResult

gst_sdp_message_new (GstSDPMessage ** msg)

{

  GstSDPMessage *newmsg;

  g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

  newmsg = g_new0 (GstSDPMessage, 1);

  *msg = newmsg;

  return gst_sdp_message_init (newmsg);

}

/**

 * gst_sdp_message_init:

 * @msg: a #GstSDPMessage

 *

 * Initialize @msg so that its contents are as if it was freshly allocated

 * with gst_sdp_message_new(). This function is mostly used to initialize a message

 * allocated on the stack. gst_sdp_message_uninit() undoes this operation.

 *

 * When this function is invoked on newly allocated data (with malloc or on the

 * stack), its contents should be set to 0 before calling this function.

 *

 * Returns: a #GstSDPResult.

 */

GstSDPResult

gst_sdp_message_init (GstSDPMessage * msg)

{

  g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

  FREE_STRING (msg->version);

  gst_sdp_origin_init (&msg->origin);

  FREE_STRING (msg->session_name);

  FREE_STRING (msg->information);

  FREE_STRING (msg->uri);

  INIT_PTR_ARRAY (msg->emails, gchar *, g_free);

  INIT_PTR_ARRAY (msg->phones, gchar *, g_free);

  gst_sdp_connection_init (&msg->connection);

  INIT_ARRAY (msg->bandwidths, GstSDPBandwidth, gst_sdp_bandwidth_init);

  INIT_ARRAY (msg->times, GstSDPTime, gst_sdp_time_init);

  INIT_ARRAY (msg->zones, GstSDPZone, gst_sdp_zone_init);

  gst_sdp_key_init (&msg->key);

  INIT_ARRAY (msg->attributes, GstSDPAttribute, gst_sdp_attribute_init);

  INIT_ARRAY (msg->medias, GstSDPMedia, gst_sdp_media_uninit);

  return GST_SDP_OK;

}

/**

 * gst_sdp_message_uninit:

 * @msg: a #GstSDPMessage

 *

 * Free all resources allocated in @msg. @msg should not be used anymore after

 * this function. This function should be used when @msg was allocated on the

 * stack and initialized with gst_sdp_message_init().

 *

 * Returns: a #GstSDPResult.

 */

GstSDPResult

gst_sdp_message_uninit (GstSDPMessage * msg)

{

  g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

  gst_sdp_message_init (msg);

  FREE_PTR_ARRAY (msg->emails);

  FREE_PTR_ARRAY (msg->phones);

  FREE_ARRAY (msg->bandwidths);

  FREE_ARRAY (msg->times);

  FREE_ARRAY (msg->zones);

  FREE_ARRAY (msg->attributes);

  FREE_ARRAY (msg->medias);

  return GST_SDP_OK;

}

/**

 * gst_sdp_message_free:

 * @msg: a #GstSDPMessage

 *

 * Free all resources allocated by @msg. @msg should not be used anymore after

 * this function. This function should be used when @msg was dynamically

 * allocated with gst_sdp_message_new().

 *

 * Returns: a #GstSDPResult.

 */

GstSDPResult

gst_sdp_message_free (GstSDPMessage * msg)

{

  g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

  gst_sdp_message_uninit (msg);

  g_free (msg);

  return GST_SDP_OK;

}

static gboolean

is_multicast_address (const gchar * host_name, guint * family)

{

  struct addrinfo hints;

  struct addrinfo *ai;

  struct addrinfo *res;

  gboolean ret = FALSE;

  memset (&hints, 0, sizeof (hints));

  hints.ai_socktype = SOCK_DGRAM;

  g_return_val_if_fail (host_name, FALSE);

    return FALSE;

  for (ai = res; !ret && ai; ai = ai->ai_next) {

    if (ai->ai_family == AF_INET)

      ret =

          IN_MULTICAST (ntohl (((struct sockaddr_in *) ai->ai_addr)->sin_addr.

              s_addr));

    else

      ret =

          IN6_IS_ADDR_MULTICAST (&((struct sockaddr_in6 *) ai->ai_addr)->

          sin6_addr);

    if (ret && family)

      *family = ai->ai_family;

  }

  freeaddrinfo (res);

  return ret;

}

/**

 * gst_sdp_message_as_text:

 * @msg: a #GstSDPMessage

 *

 * Convert the contents of @msg to a text string.

 *

 * Returns: A dynamically allocated string representing the SDP description.

 */

gchar *

gst_sdp_message_as_text (const GstSDPMessage * msg)

{

  /* change all vars so they match rfc? */

  GString *lines;

  guint i;

  g_return_val_if_fail (msg != NULL, NULL);

  lines = g_string_new ("");

  if (msg->version)

    g_string_append_printf (lines, "v=%s\r\n", msg->version);

  if (msg->origin.sess_id && msg->origin.sess_version && msg->origin.nettype &&

      msg->origin.addrtype && msg->origin.addr)

    g_string_append_printf (lines, "o=%s %s %s %s %s %s\r\n",

        msg->origin.username ? msg->origin.username : "-", msg->origin.sess_id,

        msg->origin.sess_version, msg->origin.nettype, msg->origin.addrtype,

        msg->origin.addr);

  if (msg->session_name)

    g_string_append_printf (lines, "s=%s\r\n", msg->session_name);

  if (msg->information)

    g_string_append_printf (lines, "i=%s\r\n", msg->information);

  if (msg->uri)

    g_string_append_printf (lines, "u=%s\r\n", msg->uri);

  for (i = 0; i < gst_sdp_message_emails_len (msg); i++)

    g_string_append_printf (lines, "e=%s\r\n",

        gst_sdp_message_get_email (msg, i));

  for (i = 0; i < gst_sdp_message_phones_len (msg); i++)

    g_string_append_printf (lines, "p=%s\r\n",

        gst_sdp_message_get_phone (msg, i));

  if (gst_sdp_message_emails_len (msg) == 0 &&

      gst_sdp_message_phones_len (msg) == 0)

    g_string_append_printf (lines, "e=NONE\r\n");

  if (msg->connection.nettype && msg->connection.addrtype &&

      msg->connection.address) {

    guint family;

    g_string_append_printf (lines, "c=%s %s %s", msg->connection.nettype,

        msg->connection.addrtype, msg->connection.address);

    if (is_multicast_address (msg->connection.address, &family)) {

      if (family == AF_INET)

        g_string_append_printf (lines, "/%u", msg->connection.ttl);

      if (msg->connection.addr_number > 1)

        g_string_append_printf (lines, "/%u", msg->connection.addr_number);

    }

    g_string_append_printf (lines, "\r\n");

  }

  for (i = 0; i < gst_sdp_message_bandwidths_len (msg); i++) {

    const GstSDPBandwidth *bandwidth = gst_sdp_message_get_bandwidth (msg, i);

    g_string_append_printf (lines, "b=%s:%u\r\n", bandwidth->bwtype,

        bandwidth->bandwidth);

  }

  for (i = 0; i < gst_sdp_message_times_len (msg); i++) {

    const GstSDPTime *times = gst_sdp_message_get_time (msg, i);

    g_string_append_printf (lines, "t=%s %s\r\n", times->start, times->stop);

    if (times->repeat != NULL) {

      guint j;

      g_string_append_printf (lines, "r=%s",

          g_array_index (times->repeat, gchar *, 0));

      for (j = 1; j < times->repeat->len; j++)

        g_string_append_printf (lines, " %s",

            g_array_index (times->repeat, gchar *, j));

      g_string_append_printf (lines, "\r\n");

    }

  }

  if (gst_sdp_message_zones_len (msg) > 0) {

    const GstSDPZone *zone = gst_sdp_message_get_zone (msg, 0);

    g_string_append_printf (lines, "z=%s %s", zone->time, zone->typed_time);

    for (i = 1; i < gst_sdp_message_zones_len (msg); i++) {

      zone = gst_sdp_message_get_zone (msg, i);

      g_string_append_printf (lines, " %s %s", zone->time, zone->typed_time);

    }

    g_string_append_printf (lines, "\r\n");

  }

  if (msg->key.type) {

    g_string_append_printf (lines, "k=%s", msg->key.type);

    if (msg->key.data)

      g_string_append_printf (lines, ":%s", msg->key.data);

    g_string_append_printf (lines, "\r\n");

  }

  for (i = 0; i < gst_sdp_message_attributes_len (msg); i++) {

    const GstSDPAttribute *attr = gst_sdp_message_get_attribute (msg, i);

    if (attr->key) {

      g_string_append_printf (lines, "a=%s", attr->key);

      if (attr->value)

        g_string_append_printf (lines, ":%s", attr->value);

      g_string_append_printf (lines, "\r\n");

    }

  }

  for (i = 0; i < gst_sdp_message_medias_len (msg); i++) {

    const GstSDPMedia *media = gst_sdp_message_get_media (msg, i);

    gchar *sdp_media_str;

    sdp_media_str = gst_sdp_media_as_text (media);

    g_string_append_printf (lines, "%s", sdp_media_str);

    g_free (sdp_media_str);

  }

  return g_string_free (lines, FALSE);

}

/**

 * gst_sdp_message_set_version:

 * @msg: a #GstSDPMessage

 * @version: the version

 *

 * Set the version in @msg.

 *

 * Returns: a #GstSDPResult.

 */

DEFINE_STRING_SETTER (version);

/**

 * gst_sdp_message_get_version:

 * @msg: a #GstSDPMessage

 *

 * Get the version in @msg.

 *

 * Returns: a #GstSDPResult.

 */

DEFINE_STRING_GETTER (version);

/**

 * gst_sdp_message_set_origin:

 * @msg: a #GstSDPMessage

 * @username: the user name

 * @sess_id: a session id

 * @sess_version: a session version

 * @nettype: a network type

 * @addrtype: an address type

 * @addr: an address

 *

 * Configure the SDP origin in @msg with the given parameters.

 *

 * Returns: #GST_SDP_OK.

 */

GstSDPResult

gst_sdp_message_set_origin (GstSDPMessage * msg, const gchar * username,

    const gchar * sess_id, const gchar * sess_version, const gchar * nettype,

    const gchar * addrtype, const gchar * addr)

{