1 /* GStreamer

     2  * Copyright (C) <2005,2006> Wim Taymans <wim@fluendo.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:gstsdpmessage

    45  * @short_description: Helper methods for dealing with SDP messages

    46  *

    47  * <refsect2>

    48  * <para>

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

    50  * messages.

    51  * </para>

    52  * </refsect2>

    53  *

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

    55  */

    56 

    57 #ifdef HAVE_CONFIG_H

    58 #include "config.h"

    59 #endif

    60 

    61 #include <stdlib.h>

    62 #include <string.h>

    63 

    64 #ifdef HAVE_SYS_TYPES_H

    65 #include <sys/types.h>

    66 #endif

    67 

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

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

    70 

    71 #ifdef G_OS_WIN32

    72 #ifdef _MSC_VER

    73 #include <Winsock2.h>

    74 #endif

    75 #include <ws2tcpip.h>

    76 #else

    77 #include <sys/socket.h>

    78 #include <netdb.h>

    79 #include <netinet/in.h>

    80 #endif

    81 

    82 #include "gstsdpmessage.h"

    83 

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

    85 #define MAX_LINE_LEN    1024 * 16

    86 

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

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

    89 

    90 #define INIT_ARRAY(field, type, init_func)              \

    91 G_STMT_START {                                          \

    92   if (field) {                                          \

    93     guint i;                                            \

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

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

    96     g_array_set_size ((field), 0);                      \

    97   }                                                     \

    98   else                                                  \

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

   100 } G_STMT_END

   101 

   102 #define FREE_ARRAY(field)         \

   103 G_STMT_START {                    \

   104   if (field)                      \

   105     g_array_free ((field), TRUE); \

   106   (field) = NULL;                 \

   107 } G_STMT_END

   108 

   109 #define INIT_PTR_ARRAY(field, type, init_func)          \

   110 G_STMT_START {                                          \

   111   if (field) {                                          \

   112     guint i;                                            \

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

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

   115     g_array_set_size ((field), 0);                      \

   116   }                                                     \

   117   else                                                  \

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

   119 } G_STMT_END

   120 

   121 #define FREE_PTR_ARRAY(field) FREE_ARRAY(field)

   122 

   123 #define DEFINE_STRING_SETTER(field)                                     \

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

   125   g_free (msg->field);                                                  \

   126   msg->field = g_strdup (val);                                          \

   127   return GST_SDP_OK;                                                    \

   128 }

   129 #define DEFINE_STRING_GETTER(field)                                     \

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

   131   return msg->field;                                                    \

   132 }

   133 

   134 #define DEFINE_ARRAY_LEN(field)                                         \

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

   136   return msg->field->len;                                               \

   137 }

   138 #define DEFINE_ARRAY_GETTER(method, field, type)                        \

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

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

   141 }

   142 

   143 #define DEFINE_PTR_ARRAY_LEN(field) DEFINE_ARRAY_LEN(field)

   144 #define DEFINE_PTR_ARRAY_GETTER(method, field, type)                    \

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

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

   147 }

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

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

   150   type v = dup_method (val);                                            \

   151   g_array_append_val (msg->field, v);                                   \

   152   return GST_SDP_OK;                                                    \

   153 }

   154 #ifdef __SYMBIAN32__

   155 EXPORT_C

   156 #endif

   157 

   158 

   159 static void

   160 gst_sdp_origin_init (GstSDPOrigin * origin)

   161 {

   162   FREE_STRING (origin->username);

   163   FREE_STRING (origin->sess_id);

   164   FREE_STRING (origin->sess_version);

   165   FREE_STRING (origin->nettype);

   166   FREE_STRING (origin->addrtype);

   167   FREE_STRING (origin->addr);

   168 }

   169 

   170 static void

   171 gst_sdp_connection_init (GstSDPConnection * connection)

   172 {

   173   FREE_STRING (connection->nettype);

   174   FREE_STRING (connection->addrtype);

   175   FREE_STRING (connection->address);

   176   connection->ttl = 0;

   177   connection->addr_number = 0;

   178 }

   179 

   180 static void

   181 gst_sdp_bandwidth_init (GstSDPBandwidth * bandwidth)

   182 {

   183   FREE_STRING (bandwidth->bwtype);

   184   bandwidth->bandwidth = 0;

   185 }

   186 

   187 static void

   188 gst_sdp_time_init (GstSDPTime * t)

   189 {

   190   FREE_STRING (t->start);

   191   FREE_STRING (t->stop);

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

   193   FREE_PTR_ARRAY (t->repeat);

   194 }

   195 

   196 static void

   197 gst_sdp_zone_init (GstSDPZone * zone)

   198 {

   199   FREE_STRING (zone->time);

   200   FREE_STRING (zone->typed_time);

   201 }

   202 

   203 static void

   204 gst_sdp_key_init (GstSDPKey * key)

   205 {

   206   FREE_STRING (key->type);

   207   FREE_STRING (key->data);

   208 }

   209 

   210 static void

   211 gst_sdp_attribute_init (GstSDPAttribute * attr)

   212 {

   213   FREE_STRING (attr->key);

   214   FREE_STRING (attr->value);

   215 }

   216 

   217 /**

   218  * gst_sdp_message_new:

   219  * @msg: pointer to new #GstSDPMessage

   220  *

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

   222  *

   223  * Returns: a #GstSDPResult.

   224  */

   225 GstSDPResult

   226 gst_sdp_message_new (GstSDPMessage ** msg)

   227 {

   228   GstSDPMessage *newmsg;

   229 

   230   g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

   231 

   232   newmsg = g_new0 (GstSDPMessage, 1);

   233 

   234   *msg = newmsg;

   235 

   236   return gst_sdp_message_init (newmsg);

   237 }

   238 

   239 /**

   240  * gst_sdp_message_init:

   241  * @msg: a #GstSDPMessage

   242  *

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

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

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

   246  *

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

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

   249  *

   250  * Returns: a #GstSDPResult.

   251  */

   252 GstSDPResult

   253 gst_sdp_message_init (GstSDPMessage * msg)

   254 {

   255   g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

   256 

   257   FREE_STRING (msg->version);

   258   gst_sdp_origin_init (&msg->origin);

   259   FREE_STRING (msg->session_name);

   260   FREE_STRING (msg->information);

   261   FREE_STRING (msg->uri);

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

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

   264   gst_sdp_connection_init (&msg->connection);

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

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

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

   268   gst_sdp_key_init (&msg->key);

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

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

   271 

   272   return GST_SDP_OK;

   273 }

   274 

   275 /**

   276  * gst_sdp_message_uninit:

   277  * @msg: a #GstSDPMessage

   278  *

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

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

   281  * stack and initialized with gst_sdp_message_init().

   282  *

   283  * Returns: a #GstSDPResult.

   284  */

   285 GstSDPResult

   286 gst_sdp_message_uninit (GstSDPMessage * msg)

   287 {

   288   g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

   289 

   290   gst_sdp_message_init (msg);

   291 

   292   FREE_PTR_ARRAY (msg->emails);

   293   FREE_PTR_ARRAY (msg->phones);

   294   FREE_ARRAY (msg->bandwidths);

   295   FREE_ARRAY (msg->times);

   296   FREE_ARRAY (msg->zones);

   297   FREE_ARRAY (msg->attributes);

   298   FREE_ARRAY (msg->medias);

   299 

   300   return GST_SDP_OK;

   301 }

   302 

   303 /**

   304  * gst_sdp_message_free:

   305  * @msg: a #GstSDPMessage

   306  *

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

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

   309  * allocated with gst_sdp_message_new().

   310  *

   311  * Returns: a #GstSDPResult.

   312  */

   313 GstSDPResult

   314 gst_sdp_message_free (GstSDPMessage * msg)

   315 {

   316   g_return_val_if_fail (msg != NULL, GST_SDP_EINVAL);

   317 

   318   gst_sdp_message_uninit (msg);

   319   g_free (msg);

   320 

   321   return GST_SDP_OK;

   322 }

   323 

   324 static gboolean

   325 is_multicast_address (const gchar * host_name, guint * family)

   326 {

   327   struct addrinfo hints;

   328   struct addrinfo *ai;

   329   struct addrinfo *res;

   330   gboolean ret = FALSE;

   331   int err;

   332 

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

   334   hints.ai_socktype = SOCK_DGRAM;

   335 

   336   g_return_val_if_fail (host_name, FALSE);

   337 

   338   if ((err = getaddrinfo (host_name, NULL, &hints, &res)) < 0)

   339     return FALSE;

   340 

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

   342     if (ai->ai_family == AF_INET)

   343       ret =

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

   345               s_addr));

   346     else

   347       ret =

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

   349           sin6_addr);

   350     if (ret && family)

   351       *family = ai->ai_family;

   352   }

   353 

   354   freeaddrinfo (res);

   355 

   356   return ret;

   357 }

   358 

   359 /**

   360  * gst_sdp_message_as_text:

   361  * @msg: a #GstSDPMessage

   362  *

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

   364  *

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

   366  */

   367 gchar *

   368 gst_sdp_message_as_text (const GstSDPMessage * msg)

   369 {

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

   371   GString *lines;

   372   guint i;

   373 

   374   g_return_val_if_fail (msg != NULL, NULL);

   375 

   376   lines = g_string_new ("");

   377 

   378   if (msg->version)

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

   380 

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

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

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

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

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

   386         msg->origin.addr);

   387 

   388   if (msg->session_name)

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

   390 

   391   if (msg->information)

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

   393 

   394   if (msg->uri)

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

   396 

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

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

   399         gst_sdp_message_get_email (msg, i));

   400 

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

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

   403         gst_sdp_message_get_phone (msg, i));

   404 

   405   if (gst_sdp_message_emails_len (msg) == 0 &&

   406       gst_sdp_message_phones_len (msg) == 0)

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

   408 

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

   410       msg->connection.address) {

   411     guint family;

   412 

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

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

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

   416       if (family == AF_INET)

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

   418       if (msg->connection.addr_number > 1)

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

   420     }

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

   422   }

   423 

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

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

   426 

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

   428         bandwidth->bandwidth);

   429   }

   430 

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

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

   433 

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

   435 

   436     if (times->repeat != NULL) {

   437       guint j;

   438 

   439       g_string_append_printf (lines, "r=%s",

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

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

   442         g_string_append_printf (lines, " %s",

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

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

   445     }

   446   }

   447 

   448   if (gst_sdp_message_zones_len (msg) > 0) {

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

   450 

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

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

   453       zone = gst_sdp_message_get_zone (msg, i);

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

   455     }

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

   457   }

   458 

   459   if (msg->key.type) {

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

   461     if (msg->key.data)

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

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

   464   }

   465 

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

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

   468 

   469     if (attr->key) {

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

   471       if (attr->value)

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

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

   474     }

   475   }

   476 

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

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

   479     gchar *sdp_media_str;

   480 

   481     sdp_media_str = gst_sdp_media_as_text (media);

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

   483     g_free (sdp_media_str);

   484   }

   485 

   486   return g_string_free (lines, FALSE);

   487 }

   488 

   489 /**

   490  * gst_sdp_message_set_version:

   491  * @msg: a #GstSDPMessage

   492  * @version: the version

   493  *

   494  * Set the version in @msg.

   495  *

   496  * Returns: a #GstSDPResult.

   497  */

   498 DEFINE_STRING_SETTER (version);

   499 /**

   500  * gst_sdp_message_get_version:

   501  * @msg: a #GstSDPMessage

   502  *

   503  * Get the version in @msg.

   504  *

   505  * Returns: a #GstSDPResult.

   506  */

   507 DEFINE_STRING_GETTER (version);

   508 

   509 /**

   510  * gst_sdp_message_set_origin:

   511  * @msg: a #GstSDPMessage

   512  * @username: the user name

   513  * @sess_id: a session id

   514  * @sess_version: a session version

   515  * @nettype: a network type

   516  * @addrtype: an address type

   517  * @addr: an address

   518  *

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

   520  *

   521  * Returns: #GST_SDP_OK.

   522  */

   523 GstSDPResult

   524 gst_sdp_message_set_origin (GstSDPMessage * msg, const gchar * username,

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

   526     const gchar * addrtype, const gchar * addr)

   527 {

   528   REPLACE_STRING (msg->origin.username, username);

   529   REPLACE_STRING (msg->origin.sess_id, sess_id);

   530   REPLACE_STRING (msg->origin.sess_version, sess_version);

   531   REPLACE_STRING (msg->origin.nettype, nettype);

   532   REPLACE_STRING (msg->origin.addrtype, addrtype);

   533   REPLACE_STRING (msg->origin.addr, addr);

   534 

   535   return GST_SDP_OK;

   536 }

   537 

   538 /**

   539  * gst_sdp_message_get_origin:

   540  * @msg: a #GstSDPMessage

   541  *

   542  * Get the origin of @msg.

   543  *

   544  * Returns: a #GstSDPOrigin. The result remains valid as long as @msg is valid.

   545  */

   546 const GstSDPOrigin *

   547 gst_sdp_message_get_origin (const GstSDPMessage * msg)

   548 {

   549   return &msg->origin;

   550 }

   551 

   552 /**

   553  * gst_sdp_message_set_session_name:

   554  * @msg: a #GstSDPMessage

   555  * @session_name: the session name

   556  *

   557  * Set the session name in @msg.

   558  *

   559  * Returns: a #GstSDPResult.

   560  */

   561 DEFINE_STRING_SETTER (session_name);

   562 /**

   563  * gst_sdp_message_get_session_name:

   564  * @msg: a #GstSDPMessage

   565  *

   566  * Get the session name in @msg.

   567  *

   568  * Returns: a #GstSDPResult.

   569  */

   570 DEFINE_STRING_GETTER (session_name);

   571 /**

   572  * gst_sdp_message_set_information:

   573  * @msg: a #GstSDPMessage

   574  * @information: the information

   575  *

   576  * Set the information in @msg.

   577  *

   578  * Returns: a #GstSDPResult.

   579  */

   580 DEFINE_STRING_SETTER (information);

   581 /**

   582  * gst_sdp_message_get_information:

   583  * @msg: a #GstSDPMessage

   584  *

   585  * Get the information in @msg.

   586  *

   587  * Returns: a #GstSDPResult.

   588  */

   589 DEFINE_STRING_GETTER (information);

   590 /**

   591  * gst_sdp_message_set_uri:

   592  * @msg: a #GstSDPMessage

   593  * @uri: the URI

   594  *

   595  * Set the URI in @msg.

   596  *

   597  * Returns: a #GstSDPResult.

   598  */

   599 DEFINE_STRING_SETTER (uri);

   600 /**

   601  * gst_sdp_message_get_uri:

   602  * @msg: a #GstSDPMessage

   603  *

   604  * Get the URI in @msg.

   605  *

   606  * Returns: a #GstSDPResult.

   607  */

   608 DEFINE_STRING_GETTER (uri);

   609 

   610 /**

   611  * gst_sdp_message_emails_len:

   612  * @msg: a #GstSDPMessage

   613  *

   614  * Get the number of emails in @msg.

   615  *

   616  * Returns: the number of emails in @msg.

   617  */

   618 DEFINE_ARRAY_LEN (emails);

   619 /**

   620  * gst_sdp_message_get_email:

   621  * @msg: a #GstSDPMessage

   622  * @idx: an email index

   623  *

   624  * Get the email with number @idx from @msg.

   625  *

   626  * Returns: the email at position @idx.

   627  */

   628 DEFINE_PTR_ARRAY_GETTER (email, emails, const gchar *);

   629 

   630 /**

   631  * gst_sdp_message_add_email:

   632  * @msg: a #GstSDPMessage

   633  * @email: an email

   634  *

   635  * Add @email to the list of emails in @msg.

   636  *

   637  * Returns: a #GstSDPResult.

   638  */

   639 DEFINE_PTR_ARRAY_ADDER (email, emails, const gchar *, g_strdup);

   640 

   641 /**

   642  * gst_sdp_message_phones_len:

   643  * @msg: a #GstSDPMessage

   644  *

   645  * Get the number of phones in @msg.

   646  *

   647  * Returns: the number of phones in @msg.

   648  */

   649 DEFINE_ARRAY_LEN (phones);

   650 /**

   651  * gst_sdp_message_get_phone:

   652  * @msg: a #GstSDPMessage

   653  * @idx: a phone index

   654  *

   655  * Get the phone with number @idx from @msg.

   656  *

   657  * Returns: the phone at position @idx.

   658  */

   659 DEFINE_PTR_ARRAY_GETTER (phone, phones, const gchar *);

   660 

   661 /**

   662  * gst_sdp_message_add_phone:

   663  * @msg: a #GstSDPMessage

   664  * @phone: a phone

   665  *

   666  * Add @phone to the list of phones in @msg.

   667  *

   668  * Returns: a #GstSDPResult.

   669  */

   670 DEFINE_PTR_ARRAY_ADDER (phone, phones, const gchar *, g_strdup);

   671 

   672 /**

   673  * gst_sdp_message_set_connection:

   674  * @msg: a #GstSDPMessage

   675  * @nettype: the type of network. "IN" is defined to have the meaning

   676  * "Internet".

   677  * @addrtype: the type of address.

   678  * @address: the address

   679  * @ttl: the time to live of the address

   680  * @addr_number: the number of layers

   681  *

   682  * Configure the SDP connection in @msg with the given parameters.

   683  *

   684  * Returns: a #GstSDPResult.

   685  */

   686 GstSDPResult

   687 gst_sdp_message_set_connection (GstSDPMessage * msg, const gchar * nettype,

   688     const gchar * addrtype, const gchar * address, guint ttl, guint addr_number)

   689 {

   690   REPLACE_STRING (msg->connection.nettype, nettype);

   691   REPLACE_STRING (msg->connection.addrtype, addrtype);

   692   REPLACE_STRING (msg->connection.address, address);

   693   msg->connection.ttl = ttl;

   694   msg->connection.addr_number = addr_number;

   695 

   696   return GST_SDP_OK;

   697 }

   698 

   699 /**

   700  * gst_sdp_message_get_connection:

   701  * @msg: a #GstSDPMessage

   702  *

   703  * Get the connection of @msg.

   704  *

   705  * Returns: a #GstSDPConnection. The result remains valid as long as @msg is valid.

   706  */

   707 const GstSDPConnection *

   708 gst_sdp_message_get_connection (const GstSDPMessage * msg)

   709 {

   710   return &msg->connection;

   711 }

   712 

   713 /**

   714  * gst_sdp_message_bandwidths_len:

   715  * @msg: a #GstSDPMessage

   716  *

   717  * Get the number of bandwidth information in @msg.

   718  *

   719  * Returns: the number of bandwidth information in @msg.

   720  */

   721 DEFINE_ARRAY_LEN (bandwidths);

   722 /**

   723  * gst_sdp_message_get_bandwidth:

   724  * @msg: a #GstSDPMessage

   725  * @idx: the bandwidth index

   726  *

   727  * Get the bandwidth at index @idx from @msg.

   728  *

   729  * Returns: a #GstSDPBandwidth.

   730  */

   731 DEFINE_ARRAY_GETTER (bandwidth, bandwidths, const GstSDPBandwidth);

   732 

   733 /**

   734  * gst_sdp_message_add_bandwidth:

   735  * @msg: a #GstSDPMessage

   736  * @bwtype: the bandwidth modifier type

   737  * @bandwidth: the bandwidth in kilobits per second

   738  *

   739  * Add the specified bandwidth information to @msg.

   740  *

   741  * Returns: a #GstSDPResult.

   742  */

   743 

   744 GstSDPResult

   745 gst_sdp_message_add_bandwidth (GstSDPMessage * msg, const gchar * bwtype,

   746     guint bandwidth)

   747 {

   748   GstSDPBandwidth bw;

   749 

   750   bw.bwtype = g_strdup (bwtype);

   751   bw.bandwidth = bandwidth;

   752 

   753   g_array_append_val (msg->bandwidths, bw);

   754 

   755   return GST_SDP_OK;

   756 }

   757 

   758 /**

   759  * gst_sdp_message_times_len:

   760  * @msg: a #GstSDPMessage

   761  *

   762  * Get the number of time information entries in @msg.

   763  *

   764  * Returns: the number of time information entries in @msg.

   765  */

   766 DEFINE_ARRAY_LEN (times);

   767 

   768 /**

   769  * gst_sdp_message_get_time:

   770  * @msg: a #GstSDPMessage

   771  * @idx: the time index

   772  *

   773  * Get time information with index @idx from @msg.

   774  *

   775  * Returns: a #GstSDPTime.

   776  */

   777 DEFINE_ARRAY_GETTER (time, times, const GstSDPTime);

   778 

   779 /**

   780  * gst_sdp_message_add_time:

   781  * @msg: a #GstSDPMessage

   782  * @start: the start time

   783  * @stop: the stop time

   784  * @repeat: the repeat times

   785  *

   786  * Add time information @start and @stop to @msg.

   787  *

   788  * Returns: a #GstSDPResult.

   789  */

   790 GstSDPResult

   791 gst_sdp_message_add_time (GstSDPMessage * msg, const gchar * start,

   792     const gchar * stop, const gchar ** repeat)

   793 {

   794   GstSDPTime times;

   795 

   796   times.start = g_strdup (start);

   797   times.stop = g_strdup (stop);

   798   if (repeat) {

   799     times.repeat = g_array_new (FALSE, TRUE, sizeof (gchar *));

   800     for (; *repeat; repeat++) {

   801       gchar *r = g_strdup (*repeat);

   802 

   803       g_array_append_val (times.repeat, r);

   804     }

   805   } else

   806     times.repeat = NULL;

   807   g_array_append_val (msg->times, times);

   808 

   809   return GST_SDP_OK;

   810 }

   811 

   812 /**

   813  * gst_sdp_message_zones_len:

   814  * @msg: a #GstSDPMessage

   815  *

   816  * Get the number of time zone information entries in @msg.

   817  *

   818  * Returns: the number of time zone information entries in @msg.

   819  */

   820 DEFINE_ARRAY_LEN (zones);

   821 /**

   822  * gst_sdp_message_get_zone:

   823  * @msg: a #GstSDPMessage

   824  * @idx: the zone index

   825  *

   826  * Get time zone information with index @idx from @msg.

   827  *

   828  * Returns: a #GstSDPZone.

   829  */

   830 DEFINE_ARRAY_GETTER (zone, zones, const GstSDPZone);

   831 

   832 /**

   833  * gst_sdp_message_add_zone:

   834  * @msg: a #GstSDPMessage

   835  * @adj_time: the NTP time that a time zone adjustment happens

   836  * @typed_time: the offset from the time when the session was first scheduled

   837  *

   838  * Add time zone information to @msg.

   839  *

   840  * Returns: a #GstSDPResult.

   841  */

   842 GstSDPResult

   843 gst_sdp_message_add_zone (GstSDPMessage * msg, const gchar * adj_time,

   844     const gchar * typed_time)

   845 {

   846   GstSDPZone zone;

   847 

   848   zone.time = g_strdup (adj_time);

   849   zone.typed_time = g_strdup (typed_time);

   850 

   851   g_array_append_val (msg->zones, zone);

   852 

   853   return GST_SDP_OK;

   854 }

   855 

   856 /**

   857  * gst_sdp_message_set_key:

   858  * @msg: a #GstSDPMessage

   859  * @type: the encryption type

   860  * @data: the encryption data

   861  *

   862  * Adds the encryption information to @msg.

   863  *

   864  * Returns: a #GstSDPResult.

   865  */

   866 GstSDPResult

   867 gst_sdp_message_set_key (GstSDPMessage * msg, const gchar * type,

   868     const gchar * data)

   869 {

   870   REPLACE_STRING (msg->key.type, type);

   871   REPLACE_STRING (msg->key.data, data);

   872 

   873   return GST_SDP_OK;

   874 }

   875 

   876 /**

   877  * gst_sdp_message_get_key:

   878  * @msg: a #GstSDPMessage

   879  *

   880  * Get the encryption information from @msg.

   881  *

   882  * Returns: a #GstSDPKey.

   883  */

   884 const GstSDPKey *

   885 gst_sdp_message_get_key (const GstSDPMessage * msg)

   886 {

   887   return &msg->key;

   888 }

   889 

   890 /**

   891  * gst_sdp_message_attributes_len:

   892  * @msg: a #GstSDPMessage

   893  *

   894  * Get the number of attributes in @msg.

   895  *

   896  * Returns: the number of attributes in @msg.

   897  */

   898 DEFINE_ARRAY_LEN (attributes);

   899 

   900 /**

   901  * gst_sdp_message_get_attribute:

   902  * @msg: a #GstSDPMessage

   903  * @idx: the index

   904  *

   905  * Get the attribute at position @idx in @msg.

   906  *

   907  * Returns: the #GstSDPAttribute at position @idx.

   908  */

   909 DEFINE_ARRAY_GETTER (attribute, attributes, const GstSDPAttribute);

   910 

   911 /**

   912  * gst_sdp_message_get_attribute_val_n:

   913  * @msg: a #GstSDPMessage

   914  * @key: the key

   915  * @nth: the index

   916  *

   917  * Get the @nth attribute with key @key in @msg.

   918  *

   919  * Returns: the attribute value of the @nth attribute with @key.

   920  */

   921 const gchar *

   922 gst_sdp_message_get_attribute_val_n (const GstSDPMessage * msg,

   923     const gchar * key, guint nth)

   924 {

   925   guint i;

   926 

   927   for (i = 0; i < msg->attributes->len; i++) {

   928     GstSDPAttribute *attr;

   929 

   930     attr = &g_array_index (msg->attributes, GstSDPAttribute, i);

   931     if (!strcmp (attr->key, key)) {

   932       if (nth == 0)

   933         return attr->value;

   934       else

   935         nth--;

   936     }

   937   }

   938   return NULL;

   939 }

   940 

   941 /**

   942  * gst_sdp_message_get_attribute_val:

   943  * @msg: a #GstSDPMessage

   944  * @key: the key

   945  *

   946  * Get the first attribute with key @key in @msg.

   947  *

   948  * Returns: the attribute value of the first attribute with @key.

   949  */

   950 const gchar *

   951 gst_sdp_message_get_attribute_val (const GstSDPMessage * msg, const gchar * key)

   952 {

   953   return gst_sdp_message_get_attribute_val_n (msg, key, 0);

   954 }

   955 

   956 /**

   957  * gst_sdp_message_add_attribute:

   958  * @msg: a #GstSDPMessage

   959  * @key: the key

   960  * @value: the value

   961  *

   962  * Add the attribute with @key and @value to @msg.

   963  *

   964  * Returns: @GST_SDP_OK.

   965  */

   966 GstSDPResult

   967 gst_sdp_message_add_attribute (GstSDPMessage * msg, const gchar * key,

   968     const gchar * value)

   969 {

   970   GstSDPAttribute attr;

   971 

   972   attr.key = g_strdup (key);

   973   attr.value = g_strdup (value);

   974 

   975   g_array_append_val (msg->attributes, attr);

   976 

   977   return GST_SDP_OK;

   978 }

   979 

   980 /**

   981  * gst_sdp_message_medias_len:

   982  * @msg: a #GstSDPMessage

   983  *

   984  * Get the number of media descriptions in @msg.

   985  *

   986  * Returns: the number of media descriptions in @msg.

   987  */

   988 DEFINE_ARRAY_LEN (medias);

   989 /**

   990  * gst_sdp_message_get_media:

   991  * @msg: a #GstSDPMessage

   992  * @idx: the index

   993  *

   994  * Get the media description at index @idx in @msg.

   995  *

   996  * Returns: a #GstSDPMedia.

   997  */

   998 DEFINE_ARRAY_GETTER (media, medias, const GstSDPMedia);

   999 

  1000 /**

  1001  * gst_sdp_message_add_media:

  1002  * @msg: a #GstSDPMessage

  1003  * @media: a #GstSDPMedia to add

  1004  *

  1005  * Adds @media to the array of medias in @msg. This function takes ownership of

  1006  * the contents of @media so that @media will have to be reinitialized with

  1007  * gst_media_init() before it can be used again.

  1008  *

  1009  * Returns: a #GstSDPResult.

  1010  */

  1011 GstSDPResult

  1012 gst_sdp_message_add_media (GstSDPMessage * msg, GstSDPMedia * media)

  1013 {

  1014   guint len;

  1015   GstSDPMedia *nmedia;

  1016 

  1017   len = msg->medias->len;

  1018   g_array_set_size (msg->medias, len + 1);

  1019   nmedia = &g_array_index (msg->medias, GstSDPMedia, len);

  1020 

  1021   memcpy (nmedia, media, sizeof (GstSDPMedia));

  1022   memset (media, 0, sizeof (GstSDPMedia));

  1023 

  1024   return GST_SDP_OK;

  1025 }

  1026 

  1027 /* media access */

  1028 

  1029 /**

  1030  * gst_sdp_media_new:

  1031  * @media: pointer to new #GstSDPMedia

  1032  *

  1033  * Allocate a new GstSDPMedia and store the result in @media.

  1034  *

  1035  * Returns: a #GstSDPResult.

  1036  */

  1037 GstSDPResult

  1038 gst_sdp_media_new (GstSDPMedia ** media)

  1039 {

  1040   GstSDPMedia *newmedia;

  1041 

  1042   g_return_val_if_fail (media != NULL, GST_SDP_EINVAL);

  1043 

  1044   newmedia = g_new0 (GstSDPMedia, 1);

  1045 

  1046   *media = newmedia;

  1047 

  1048   return gst_sdp_media_init (newmedia);

  1049 }

  1050 

  1051 /**

  1052  * gst_sdp_media_init:

  1053  * @media: a #GstSDPMedia

  1054  *

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

  1056  * with gst_sdp_media_new(). This function is mostly used to initialize a media

  1057  * allocated on the stack. gst_sdp_media_uninit() undoes this operation.

  1058  *

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

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

  1061  *

  1062  * Returns: a #GstSDPResult.

  1063  */

  1064 GstSDPResult

  1065 gst_sdp_media_init (GstSDPMedia * media)

  1066 {

  1067   g_return_val_if_fail (media != NULL, GST_SDP_EINVAL);

  1068 

  1069   FREE_STRING (media->media);

  1070   media->port = 0;

  1071   media->num_ports = 0;

  1072   FREE_STRING (media->proto);

  1073   INIT_PTR_ARRAY (media->fmts, gchar *, g_free);

  1074   FREE_STRING (media->information);

  1075   INIT_ARRAY (media->connections, GstSDPConnection, gst_sdp_connection_init);

  1076   INIT_ARRAY (media->bandwidths, GstSDPBandwidth, gst_sdp_bandwidth_init);

  1077   gst_sdp_key_init (&media->key);

  1078   INIT_ARRAY (media->attributes, GstSDPAttribute, gst_sdp_attribute_init);

  1079 

  1080   return GST_SDP_OK;

  1081 }

  1082 

  1083 /**

  1084  * gst_sdp_media_uninit:

  1085  * @media: a #GstSDPMedia

  1086  *

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

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

  1089  * stack and initialized with gst_sdp_media_init().

  1090  *

  1091  * Returns: a #GstSDPResult.

  1092  */

  1093 GstSDPResult

  1094 gst_sdp_media_uninit (GstSDPMedia * media)

  1095 {

  1096   g_return_val_if_fail (media != NULL, GST_SDP_EINVAL);

  1097 

  1098   gst_sdp_media_init (media);

  1099   FREE_PTR_ARRAY (media->fmts);

  1100   FREE_ARRAY (media->connections);

  1101   FREE_ARRAY (media->bandwidths);

  1102   FREE_ARRAY (media->attributes);

  1103 

  1104   return GST_SDP_OK;

  1105 }

  1106 

  1107 /**

  1108  * gst_sdp_media_free:

  1109  * @media: a #GstSDPMedia

  1110  *

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

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

  1113  * allocated with gst_sdp_media_new().

  1114  *

  1115  * Returns: a #GstSDPResult.

  1116  */

  1117 GstSDPResult

  1118 gst_sdp_media_free (GstSDPMedia * media)

  1119 {

  1120   g_return_val_if_fail (media != NULL, GST_SDP_EINVAL);

  1121 

  1122   gst_sdp_media_uninit (media);

  1123   g_free (media);

  1124 

  1125   return GST_SDP_OK;

  1126 }

  1127 

  1128 /**

  1129  * gst_sdp_media_as_text:

  1130  * @media: a #GstSDPMedia

  1131  *

  1132  * Convert the contents of @media to a text string.

  1133  *

  1134  * Returns: A dynamically allocated string representing the media.