gst/gsturi.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  * Copyright (C) 2011 Tim-Philipp Müller <tim centricular net>
   5  * Copyright (C) 2014 David Waring, British Broadcasting Corporation
   6  *                        <david.waring@rd.bbc.co.uk>
   7  *
   8  * gsturi.c: register URI handlers and IETF RFC 3986 URI manipulations.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public
  21  * License along with this library; if not, write to the
  22  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  23  * Boston, MA 02110-1301, USA.
  24  */
  25
  26 /**
  27  * SECTION:gsturihandler
  28  * @title: GstUriHandler
  29  * @short_description: Interface to ease URI handling in plugins.
  30  *
  31  * The #GstURIHandler is an interface that is implemented by Source and Sink
  32  * #GstElement to unify handling of URI.
  33  *
  34  * An application can use the following functions to quickly get an element
  35  * that handles the given URI for reading or writing
  36  * (gst_element_make_from_uri()).
  37  *
  38  * Source and Sink plugins should implement this interface when possible.
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 #  include "config.h"
  43 #endif
  44
  45 #include "gst_private.h"
  46 #include "gst.h"
  47 #include "gsturi.h"
  48 #include "gstinfo.h"
  49 #include "gstregistry.h"
  50
  51 #include "gst-i18n-lib.h"
  52
  53 #include <string.h>
  54 #include <glib.h>
  55 #include <glib/gprintf.h>
  56
  57 GST_DEBUG_CATEGORY_STATIC (gst_uri_handler_debug);
  58 #define GST_CAT_DEFAULT gst_uri_handler_debug
  59
  60 #ifndef HAVE_STRCASESTR
  61 #define strcasestr _gst_ascii_strcasestr
  62
  63 /* From https://github.com/freebsd/freebsd/blob/master/contrib/file/src/strcasestr.c
  64  * Updated to use GLib types and GLib string functions
  65  *
  66  * Copyright (c) 1990, 1993
  67  *      The Regents of the University of California.  All rights reserved.
  68  *
  69  * This code is derived from software contributed to Berkeley by
  70  * Chris Torek.
  71  *
  72  * Redistribution and use in source and binary forms, with or without
  73  * modification, are permitted provided that the following conditions
  74  * are met:
  75  * 1. Redistributions of source code must retain the above copyright
  76  *    notice, this list of conditions and the following disclaimer.
  77  * 2. Redistributions in binary form must reproduce the above copyright
  78  *    notice, this list of conditions and the following disclaimer in the
  79  *    documentation and/or other materials provided with the distribution.
  80  * 3. Neither the name of the University nor the names of its contributors
  81  *    may be used to endorse or promote products derived from this software
  82  *    without specific prior written permission.
  83  *
  84  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  85  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  86  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  87  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  88  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  89  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  90  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  91  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  92  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  93  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  94  * SUCH DAMAGE.
  95  */
  96
  97 /*
  98  * Find the first occurrence of find in s, ignore case.
  99  */
 100
 101 static gchar *
 102 _gst_ascii_strcasestr (const gchar * s, const gchar * find)
 103 {
 104   gchar c, sc;
 105   gsize len;
 106
 107   if ((c = *find++) != 0) {
 108     c = g_ascii_tolower (c);
 109     len = strlen (find);
 110     do {
 111       do {
 112         if ((sc = *s++) == 0)
 113           return (NULL);
 114       } while (g_ascii_tolower (sc) != c);
 115     } while (g_ascii_strncasecmp (s, find, len) != 0);
 116     s--;
 117   }
 118   return (gchar *) (gintptr) (s);
 119 }
 120 #endif
 121
 122 GType
 123 gst_uri_handler_get_type (void)
 124 {
 125   static volatile gsize urihandler_type = 0;
 126
 127   if (g_once_init_enter (&urihandler_type)) {
 128     GType _type;
 129     static const GTypeInfo urihandler_info = {
 130       sizeof (GstURIHandlerInterface),
 131       NULL,
 132       NULL,
 133       NULL,
 134       NULL,
 135       NULL,
 136       0,
 137       0,
 138       NULL,
 139       NULL
 140     };
 141
 142     _type = g_type_register_static (G_TYPE_INTERFACE,
 143         "GstURIHandler", &urihandler_info, 0);
 144
 145     GST_DEBUG_CATEGORY_INIT (gst_uri_handler_debug, "GST_URI", GST_DEBUG_BOLD,
 146         "handling of URIs");
 147     g_once_init_leave (&urihandler_type, _type);
 148   }
 149   return urihandler_type;
 150 }
 151
 152 GQuark
 153 gst_uri_error_quark (void)
 154 {
 155   return g_quark_from_static_string ("gst-uri-error-quark");
 156 }
 157
 158 #define HEX_ESCAPE '%'
 159
 160 #ifndef GST_REMOVE_DEPRECATED
 161 static const guchar acceptable[96] = {  /* X0   X1   X2   X3   X4   X5   X6   X7   X8   X9   XA   XB   XC   XD   XE   XF */
 162   0x00, 0x3F, 0x20, 0x20, 0x20, 0x00, 0x2C, 0x3F, 0x3F, 0x3F, 0x3F, 0x22, 0x20, 0x3F, 0x3F, 0x1C,       /* 2X  !"#$%&'()*+,-./   */
 163   0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x38, 0x20, 0x20, 0x2C, 0x20, 0x2C,       /* 3X 0123456789:;<=>?   */
 164   0x30, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,       /* 4X @ABCDEFGHIJKLMNO   */
 165   0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x3F,       /* 5X PQRSTUVWXYZ[\]^_   */
 166   0x20, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,       /* 6X `abcdefghijklmno   */
 167   0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x3F, 0x20        /* 7X pqrstuvwxyz{|}~DEL */
 168 };
 169
 170 typedef enum
 171 {
 172   UNSAFE_ALL = 0x1,             /* Escape all unsafe characters   */
 173   UNSAFE_ALLOW_PLUS = 0x2,      /* Allows '+'  */
 174   UNSAFE_PATH = 0x4,            /* Allows '/' and '?' and '&' and '='  */
 175   UNSAFE_DOS_PATH = 0x8,        /* Allows '/' and '?' and '&' and '=' and ':' */
 176   UNSAFE_HOST = 0x10,           /* Allows '/' and ':' and '@' */
 177   UNSAFE_SLASHES = 0x20         /* Allows all characters except for '/' and '%' */
 178 } UnsafeCharacterSet;
 179
 180 /*  Escape undesirable characters using %
 181  *  -------------------------------------
 182  *
 183  * This function takes a pointer to a string in which
 184  * some characters may be unacceptable unescaped.
 185  * It returns a string which has these characters
 186  * represented by a '%' character followed by two hex digits.
 187  *
 188  * This routine returns a g_malloced string.
 189  */
 190
 191 static const gchar hex[16] = "0123456789ABCDEF";
 192
 193 static gchar *
 194 escape_string_internal (const gchar * string, UnsafeCharacterSet mask)
 195 {
 196 #define ACCEPTABLE_CHAR(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask))
 197
 198   const gchar *p;
 199   gchar *q;
 200   gchar *result;
 201   guchar c;
 202   gint unacceptable;
 203   UnsafeCharacterSet use_mask;
 204
 205   g_return_val_if_fail (mask == UNSAFE_ALL
 206       || mask == UNSAFE_ALLOW_PLUS
 207       || mask == UNSAFE_PATH
 208       || mask == UNSAFE_DOS_PATH
 209       || mask == UNSAFE_HOST || mask == UNSAFE_SLASHES, NULL);
 210
 211   if (string == NULL) {
 212     return NULL;
 213   }
 214
 215   unacceptable = 0;
 216   use_mask = mask;
 217   for (p = string; *p != '\0'; p++) {
 218     c = *p;
 219     if (!ACCEPTABLE_CHAR (c)) {
 220       unacceptable++;
 221     }
 222     if ((use_mask == UNSAFE_HOST) && (unacceptable || (c == '/'))) {
 223       /* when escaping a host, if we hit something that needs to be escaped, or we finally
 224        * hit a path separator, revert to path mode (the host segment of the url is over).
 225        */
 226       use_mask = UNSAFE_PATH;
 227     }
 228   }
 229
 230   result = g_malloc (p - string + unacceptable * 2 + 1);
 231
 232   use_mask = mask;
 233   for (q = result, p = string; *p != '\0'; p++) {
 234     c = *p;
 235
 236     if (!ACCEPTABLE_CHAR (c)) {
 237       *q++ = HEX_ESCAPE;        /* means hex coming */
 238       *q++ = hex[c >> 4];
 239       *q++ = hex[c & 15];
 240     } else {
 241       *q++ = c;
 242     }
 243     if ((use_mask == UNSAFE_HOST) && (!ACCEPTABLE_CHAR (c) || (c == '/'))) {
 244       use_mask = UNSAFE_PATH;
 245     }
 246   }
 247
 248   *q = '\0';
 249
 250   return result;
 251 }
 252 #endif
 253
 254 static int
 255 hex_to_int (gchar c)
 256 {
 257   return c >= '0' && c <= '9' ? c - '0'
 258       : c >= 'A' && c <= 'F' ? c - 'A' + 10
 259       : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1;
 260 }
 261
 262 static int
 263 unescape_character (const char *scanner)
 264 {
 265   int first_digit;
 266   int second_digit;
 267
 268   first_digit = hex_to_int (*scanner++);
 269   if (first_digit < 0) {
 270     return -1;
 271   }
 272
 273   second_digit = hex_to_int (*scanner);
 274   if (second_digit < 0) {
 275     return -1;
 276   }
 277
 278   return (first_digit << 4) | second_digit;
 279 }
 280
 281 /* unescape_string:
 282  * @escaped_string: an escaped URI, path, or other string
 283  * @illegal_characters: a string containing a sequence of characters
 284  * considered "illegal", '\0' is automatically in this list.
 285  *
 286  * Decodes escaped characters (i.e. PERCENTxx sequences) in @escaped_string.
 287  * Characters are encoded in PERCENTxy form, where xy is the ASCII hex code
 288  * for character 16x+y.
 289  *
 290  * Return value: (nullable): a newly allocated string with the
 291  * unescaped equivalents, or %NULL if @escaped_string contained one of
 292  * the characters in @illegal_characters.
 293  **/
 294 static char *
 295 unescape_string (const gchar * escaped_string, const gchar * illegal_characters)
 296 {
 297   const gchar *in;
 298   gchar *out, *result;
 299   gint character;
 300
 301   if (escaped_string == NULL) {
 302     return NULL;
 303   }
 304
 305   result = g_malloc (strlen (escaped_string) + 1);
 306
 307   out = result;
 308   for (in = escaped_string; *in != '\0'; in++) {
 309     character = *in;
 310     if (*in == HEX_ESCAPE) {
 311       character = unescape_character (in + 1);
 312
 313       /* Check for an illegal character. We consider '\0' illegal here. */
 314       if (character <= 0
 315           || (illegal_characters != NULL
 316               && strchr (illegal_characters, (char) character) != NULL)) {
 317         g_free (result);
 318         return NULL;
 319       }
 320       in += 2;
 321     }
 322     *out++ = (char) character;
 323   }
 324
 325   *out = '\0';
 326   g_assert ((gsize) (out - result) <= strlen (escaped_string));
 327   return result;
 328
 329 }
 330
 331
 332 static void
 333 gst_uri_protocol_check_internal (const gchar * uri, gchar ** endptr)
 334 {
 335   gchar *check = (gchar *) uri;
 336
 337   g_assert (uri != NULL);
 338   g_assert (endptr != NULL);
 339
 340   if (g_ascii_isalpha (*check)) {
 341     check++;
 342     while (g_ascii_isalnum (*check) || *check == '+'
 343         || *check == '-' || *check == '.')
 344       check++;
 345   }
 346
 347   *endptr = check;
 348 }
 349
 350 /**
 351  * gst_uri_protocol_is_valid:
 352  * @protocol: A string
 353  *
 354  * Tests if the given string is a valid protocol identifier. Protocols
 355  * must consist of alphanumeric characters, '+', '-' and '.' and must
 356  * start with a alphabetic character. See RFC 3986 Section 3.1.
 357  *
 358  * Returns: %TRUE if the string is a valid protocol identifier, %FALSE otherwise.
 359  */
 360 gboolean
 361 gst_uri_protocol_is_valid (const gchar * protocol)
 362 {
 363   gchar *endptr;
 364
 365   g_return_val_if_fail (protocol != NULL, FALSE);
 366
 367   gst_uri_protocol_check_internal (protocol, &endptr);
 368
 369   return *endptr == '\0' && ((gsize) (endptr - protocol)) >= 2;
 370 }
 371
 372 /**
 373  * gst_uri_is_valid:
 374  * @uri: A URI string
 375  *
 376  * Tests if the given string is a valid URI identifier. URIs start with a valid
 377  * scheme followed by ":" and maybe a string identifying the location.
 378  *
 379  * Returns: %TRUE if the string is a valid URI
 380  */
 381 gboolean
 382 gst_uri_is_valid (const gchar * uri)
 383 {
 384   gchar *endptr;
 385
 386   g_return_val_if_fail (uri != NULL, FALSE);
 387
 388   gst_uri_protocol_check_internal (uri, &endptr);
 389
 390   return *endptr == ':' && ((gsize) (endptr - uri)) >= 2;
 391 }
 392
 393 /**
 394  * gst_uri_get_protocol:
 395  * @uri: A URI string
 396  *
 397  * Extracts the protocol out of a given valid URI. The returned string must be
 398  * freed using g_free().
 399  *
 400  * Returns: (nullable): The protocol for this URI.
 401  */
 402 gchar *
 403 gst_uri_get_protocol (const gchar * uri)
 404 {
 405   gchar *colon;
 406
 407   g_return_val_if_fail (uri != NULL, NULL);
 408   g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
 409
 410   colon = strstr (uri, ":");
 411
 412   return g_ascii_strdown (uri, colon - uri);
 413 }
 414
 415 /**
 416  * gst_uri_has_protocol:
 417  * @uri: a URI string
 418  * @protocol: a protocol string (e.g. "http")
 419  *
 420  * Checks if the protocol of a given valid URI matches @protocol.
 421  *
 422  * Returns: %TRUE if the protocol matches.
 423  */
 424 gboolean
 425 gst_uri_has_protocol (const gchar * uri, const gchar * protocol)
 426 {
 427   gchar *colon;
 428
 429   g_return_val_if_fail (uri != NULL, FALSE);
 430   g_return_val_if_fail (protocol != NULL, FALSE);
 431   g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);
 432
 433   colon = strstr (uri, ":");
 434
 435   if (colon == NULL)
 436     return FALSE;
 437
 438   return (g_ascii_strncasecmp (uri, protocol, (gsize) (colon - uri)) == 0);
 439 }
 440
 441 /**
 442  * gst_uri_get_location:
 443  * @uri: A URI string
 444  *
 445  * Extracts the location out of a given valid URI, ie. the protocol and "://"
 446  * are stripped from the URI, which means that the location returned includes
 447  * the hostname if one is specified. The returned string must be freed using
 448  * g_free().
 449  *
 450  * Free-function: g_free
 451  *
 452  * Returns: (transfer full) (nullable): the location for this URI. Returns
 453  *     %NULL if the URI isn't valid. If the URI does not contain a location, an
 454  *     empty string is returned.
 455  */
 456 gchar *
 457 gst_uri_get_location (const gchar * uri)
 458 {
 459   const gchar *colon;
 460   gchar *unescaped = NULL;
 461
 462   g_return_val_if_fail (uri != NULL, NULL);
 463   g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
 464
 465   colon = strstr (uri, "://");
 466   if (!colon)
 467     return NULL;
 468
 469   unescaped = unescape_string (colon + 3, "/");
 470
 471   /* On Windows an URI might look like file:///c:/foo/bar.txt or
 472    * file:///c|/foo/bar.txt (some Netscape versions) and we want to
 473    * return c:/foo/bar.txt as location rather than /c:/foo/bar.txt.
 474    * Can't use g_filename_from_uri() here because it will only handle the
 475    * file:// protocol */
 476 #ifdef G_OS_WIN32
 477   if (unescaped != NULL && unescaped[0] == '/' &&
 478       g_ascii_isalpha (unescaped[1]) &&
 479       (unescaped[2] == ':' || unescaped[2] == '|')) {
 480     unescaped[2] = ':';
 481     memmove (unescaped, unescaped + 1, strlen (unescaped + 1) + 1);
 482   }
 483 #endif
 484
 485   GST_LOG ("extracted location '%s' from URI '%s'", GST_STR_NULL (unescaped),
 486       uri);
 487   return unescaped;
 488 }
 489
 490 /**
 491  * gst_uri_construct:
 492  * @protocol: Protocol for URI
 493  * @location: (transfer none): Location for URI
 494  *
 495  * Constructs a URI for a given valid protocol and location.
 496  *
 497  * Free-function: g_free
 498  *
 499  * Returns: (transfer full): a new string for this URI. Returns %NULL if the
 500  *     given URI protocol is not valid, or the given location is %NULL.
 501  */
 502 #ifndef GST_REMOVE_DEPRECATED
 503 gchar *
 504 gst_uri_construct (const gchar * protocol, const gchar * location)
 505 {
 506   char *escaped, *proto_lowercase;
 507   char *retval;
 508
 509   g_return_val_if_fail (gst_uri_protocol_is_valid (protocol), NULL);
 510   g_return_val_if_fail (location != NULL, NULL);
 511
 512   proto_lowercase = g_ascii_strdown (protocol, -1);
 513   escaped = escape_string_internal (location, UNSAFE_PATH);
 514   retval = g_strdup_printf ("%s://%s", proto_lowercase, escaped);
 515   g_free (escaped);
 516   g_free (proto_lowercase);
 517
 518   return retval;
 519 }
 520 #endif
 521
 522 typedef struct
 523 {
 524   GstURIType type;
 525   const gchar *protocol;
 526 }
 527 SearchEntry;
 528
 529 static gboolean
 530 search_by_entry (GstPluginFeature * feature, gpointer search_entry)
 531 {
 532   const gchar *const *protocols;
 533   GstElementFactory *factory;
 534   SearchEntry *entry = (SearchEntry *) search_entry;
 535
 536   if (!GST_IS_ELEMENT_FACTORY (feature))
 537     return FALSE;
 538   factory = GST_ELEMENT_FACTORY_CAST (feature);
 539
 540   if (factory->uri_type != entry->type)
 541     return FALSE;
 542
 543   protocols = gst_element_factory_get_uri_protocols (factory);
 544
 545   if (protocols == NULL) {
 546     g_warning ("Factory '%s' implements GstUriHandler interface but returned "
 547         "no supported protocols!", gst_plugin_feature_get_name (feature));
 548     return FALSE;
 549   }
 550
 551   while (*protocols != NULL) {
 552     if (g_ascii_strcasecmp (*protocols, entry->protocol) == 0)
 553       return TRUE;
 554     protocols++;
 555   }
 556   return FALSE;
 557 }
 558
 559 static gint
 560 sort_by_rank (GstPluginFeature * first, GstPluginFeature * second)
 561 {
 562   return gst_plugin_feature_get_rank (second) -
 563       gst_plugin_feature_get_rank (first);
 564 }
 565
 566 static GList *
 567 get_element_factories_from_uri_protocol (const GstURIType type,
 568     const gchar * protocol)
 569 {
 570   GList *possibilities;
 571   SearchEntry entry;
 572
 573   g_return_val_if_fail (protocol, NULL);
 574
 575   entry.type = type;
 576   entry.protocol = protocol;
 577   possibilities = gst_registry_feature_filter (gst_registry_get (),
 578       search_by_entry, FALSE, &entry);
 579
 580   return possibilities;
 581 }
 582
 583 /**
 584  * gst_uri_protocol_is_supported:
 585  * @type: Whether to check for a source or a sink
 586  * @protocol: Protocol that should be checked for (e.g. "http" or "smb")
 587  *
 588  * Checks if an element exists that supports the given URI protocol. Note
 589  * that a positive return value does not imply that a subsequent call to
 590  * gst_element_make_from_uri() is guaranteed to work.
 591  *
 592  * Returns: %TRUE
 593 */
 594 gboolean
 595 gst_uri_protocol_is_supported (const GstURIType type, const gchar * protocol)
 596 {
 597   GList *possibilities;
 598
 599   g_return_val_if_fail (protocol, FALSE);
 600
 601   possibilities = get_element_factories_from_uri_protocol (type, protocol);
 602
 603   if (possibilities) {
 604     g_list_free (possibilities);
 605     return TRUE;
 606   } else
 607     return FALSE;
 608 }
 609
 610 /**
 611  * gst_element_make_from_uri:
 612  * @type: Whether to create a source or a sink
 613  * @uri: URI to create an element for
 614  * @elementname: (allow-none): Name of created element, can be %NULL.
 615  * @error: (allow-none): address where to store error information, or %NULL.
 616  *
 617  * Creates an element for handling the given URI.
 618  *
 619  * Returns: (transfer floating) (nullable): a new element or %NULL if none
 620  * could be created
 621  */
 622 GstElement *
 623 gst_element_make_from_uri (const GstURIType type, const gchar * uri,
 624     const gchar * elementname, GError ** error)
 625 {
 626   GList *possibilities, *walk;
 627   gchar *protocol;
 628   GstElement *ret = NULL;
 629
 630   g_return_val_if_fail (gst_is_initialized (), NULL);
 631   g_return_val_if_fail (GST_URI_TYPE_IS_VALID (type), NULL);
 632   g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
 633   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 634
 635   GST_DEBUG ("type:%d, uri:%s, elementname:%s", type, uri, elementname);
 636
 637   protocol = gst_uri_get_protocol (uri);
 638   possibilities = get_element_factories_from_uri_protocol (type, protocol);
 639
 640   if (!possibilities) {
 641     GST_DEBUG ("No %s for URI '%s'", type == GST_URI_SINK ? "sink" : "source",
 642         uri);
 643     /* The error message isn't great, but we don't expect applications to
 644      * show that error to users, but call the missing plugins functions */
 645     g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
 646         _("No URI handler for the %s protocol found"), protocol);
 647     g_free (protocol);
 648     return NULL;
 649   }
 650   g_free (protocol);
 651
 652   possibilities = g_list_sort (possibilities, (GCompareFunc) sort_by_rank);
 653   walk = possibilities;
 654   while (walk) {
 655     GstElementFactory *factory = walk->data;
 656     GError *uri_err = NULL;
 657
 658     ret = gst_element_factory_create (factory, elementname);
 659     if (ret != NULL) {
 660       GstURIHandler *handler = GST_URI_HANDLER (ret);
 661
 662       if (gst_uri_handler_set_uri (handler, uri, &uri_err))
 663         break;
 664
 665       GST_WARNING ("%s didn't accept URI '%s': %s", GST_OBJECT_NAME (ret), uri,
 666           uri_err->message);
 667
 668       if (error != NULL && *error == NULL)
 669         g_propagate_error (error, uri_err);
 670       else
 671         g_error_free (uri_err);
 672
 673       gst_object_unref (ret);
 674       ret = NULL;
 675     }
 676     walk = walk->next;
 677   }
 678   gst_plugin_feature_list_free (possibilities);
 679
 680   GST_LOG_OBJECT (ret, "created %s for URL '%s'",
 681       type == GST_URI_SINK ? "sink" : "source", uri);
 682
 683   /* if the first handler didn't work, but we found another one that works */
 684   if (ret != NULL)
 685     g_clear_error (error);
 686
 687   return ret;
 688 }
 689
 690 /**
 691  * gst_uri_handler_get_uri_type:
 692  * @handler: A #GstURIHandler.
 693  *
 694  * Gets the type of the given URI handler
 695  *
 696  * Returns: the #GstURIType of the URI handler.
 697  * Returns #GST_URI_UNKNOWN if the @handler isn't implemented correctly.
 698  */
 699 GstURIType
 700 gst_uri_handler_get_uri_type (GstURIHandler * handler)
 701 {
 702   GstURIHandlerInterface *iface;
 703   GstURIType ret;
 704
 705   g_return_val_if_fail (GST_IS_URI_HANDLER (handler), GST_URI_UNKNOWN);
 706
 707   iface = GST_URI_HANDLER_GET_INTERFACE (handler);
 708   g_return_val_if_fail (iface != NULL, GST_URI_UNKNOWN);
 709   g_return_val_if_fail (iface->get_type != NULL, GST_URI_UNKNOWN);
 710
 711   ret = iface->get_type (G_OBJECT_TYPE (handler));
 712   g_return_val_if_fail (GST_URI_TYPE_IS_VALID (ret), GST_URI_UNKNOWN);
 713
 714   return ret;
 715 }
 716
 717 /**
 718  * gst_uri_handler_get_protocols:
 719  * @handler: A #GstURIHandler.
 720  *
 721  * Gets the list of protocols supported by @handler. This list may not be
 722  * modified.
 723  *
 724  * Returns: (transfer none) (element-type utf8) (nullable): the
 725  *     supported protocols.  Returns %NULL if the @handler isn't
 726  *     implemented properly, or the @handler doesn't support any
 727  *     protocols.
 728  */
 729 const gchar *const *
 730 gst_uri_handler_get_protocols (GstURIHandler * handler)
 731 {
 732   GstURIHandlerInterface *iface;
 733   const gchar *const *ret;
 734
 735   g_return_val_if_fail (GST_IS_URI_HANDLER (handler), NULL);
 736
 737   iface = GST_URI_HANDLER_GET_INTERFACE (handler);
 738   g_return_val_if_fail (iface != NULL, NULL);
 739   g_return_val_if_fail (iface->get_protocols != NULL, NULL);
 740
 741   ret = iface->get_protocols (G_OBJECT_TYPE (handler));
 742   g_return_val_if_fail (ret != NULL, NULL);
 743
 744   return ret;
 745 }
 746
 747 /**
 748  * gst_uri_handler_get_uri:
 749  * @handler: A #GstURIHandler
 750  *
 751  * Gets the currently handled URI.
 752  *
 753  * Returns: (transfer full) (nullable): the URI currently handled by
 754  *   the @handler.  Returns %NULL if there are no URI currently
 755  *   handled. The returned string must be freed with g_free() when no
 756  *   longer needed.
 757  */
 758 gchar *
 759 gst_uri_handler_get_uri (GstURIHandler * handler)
 760 {
 761   GstURIHandlerInterface *iface;
 762   gchar *ret;
 763
 764   g_return_val_if_fail (GST_IS_URI_HANDLER (handler), NULL);
 765
 766   iface = GST_URI_HANDLER_GET_INTERFACE (handler);
 767   g_return_val_if_fail (iface != NULL, NULL);
 768   g_return_val_if_fail (iface->get_uri != NULL, NULL);
 769   ret = iface->get_uri (handler);
 770   if (ret != NULL)
 771     g_return_val_if_fail (gst_uri_is_valid (ret), NULL);
 772
 773   return ret;
 774 }
 775
 776 /**
 777  * gst_uri_handler_set_uri:
 778  * @handler: A #GstURIHandler
 779  * @uri: URI to set
 780  * @error: (allow-none): address where to store a #GError in case of
 781  *    an error, or %NULL
 782  *
 783  * Tries to set the URI of the given handler.
 784  *
 785  * Returns: %TRUE if the URI was set successfully, else %FALSE.
 786  */
 787 gboolean
 788 gst_uri_handler_set_uri (GstURIHandler * handler, const gchar * uri,
 789     GError ** error)
 790 {
 791   GstURIHandlerInterface *iface;
 792   gboolean ret;
 793   gchar *protocol;
 794
 795   g_return_val_if_fail (GST_IS_URI_HANDLER (handler), FALSE);
 796   g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);
 797   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 798
 799   iface = GST_URI_HANDLER_GET_INTERFACE (handler);
 800   g_return_val_if_fail (iface != NULL, FALSE);
 801   g_return_val_if_fail (iface->set_uri != NULL, FALSE);
 802
 803   protocol = gst_uri_get_protocol (uri);
 804
 805   if (iface->get_protocols) {
 806     const gchar *const *protocols;
 807     const gchar *const *p;
 808     gboolean found_protocol = FALSE;
 809
 810     protocols = iface->get_protocols (G_OBJECT_TYPE (handler));
 811     if (protocols != NULL) {
 812       for (p = protocols; *p != NULL; ++p) {
 813         if (g_ascii_strcasecmp (protocol, *p) == 0) {
 814           found_protocol = TRUE;
 815           break;
 816         }
 817       }
 818
 819       if (!found_protocol) {
 820         g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
 821             _("URI scheme '%s' not supported"), protocol);
 822         g_free (protocol);
 823         return FALSE;
 824       }
 825     }
 826   }
 827
 828   ret = iface->set_uri (handler, uri, error);
 829
 830   g_free (protocol);
 831
 832   return ret;
 833 }
 834
 835 static gchar *
 836 gst_file_utils_canonicalise_path (const gchar * path)
 837 {
 838   gchar **parts, **p, *clean_path;
 839
 840 #ifdef G_OS_WIN32
 841   {
 842     GST_WARNING ("FIXME: canonicalise win32 path");
 843     return g_strdup (path);
 844   }
 845 #endif
 846
 847   parts = g_strsplit (path, "/", -1);
 848
 849   p = parts;
 850   while (*p != NULL) {
 851     if (strcmp (*p, ".") == 0) {
 852       /* just move all following parts on top of this, incl. NUL terminator */
 853       g_free (*p);
 854       memmove (p, p + 1, (g_strv_length (p + 1) + 1) * sizeof (gchar *));
 855       /* re-check the new current part again in the next iteration */
 856       continue;
 857     } else if (strcmp (*p, "..") == 0 && p > parts) {
 858       /* just move all following parts on top of the previous part, incl.
 859        * NUL terminator */
 860       g_free (*(p - 1));
 861       g_free (*p);
 862       memmove (p - 1, p + 1, (g_strv_length (p + 1) + 1) * sizeof (gchar *));
 863       /* re-check the new current part again in the next iteration */
 864       --p;
 865       continue;
 866     }
 867     ++p;
 868   }
 869   if (*path == '/') {
 870     guint num_parts;
 871
 872     num_parts = g_strv_length (parts) + 1;      /* incl. terminator */
 873     parts = g_renew (gchar *, parts, num_parts + 1);
 874     memmove (parts + 1, parts, num_parts * sizeof (gchar *));
 875     parts[0] = g_strdup ("/");
 876   }
 877
 878   clean_path = g_build_filenamev (parts);
 879   g_strfreev (parts);
 880   return clean_path;
 881 }
 882
 883 static gboolean
 884 file_path_contains_relatives (const gchar * path)
 885 {
 886   return (strstr (path, "/./") != NULL || strstr (path, "/../") != NULL ||
 887       strstr (path, G_DIR_SEPARATOR_S "." G_DIR_SEPARATOR_S) != NULL ||
 888       strstr (path, G_DIR_SEPARATOR_S ".." G_DIR_SEPARATOR_S) != NULL);
 889 }
 890
 891 /**
 892  * gst_filename_to_uri:
 893  * @filename: absolute or relative file name path
 894  * @error: pointer to error, or %NULL
 895  *
 896  * Similar to g_filename_to_uri(), but attempts to handle relative file paths
 897  * as well. Before converting @filename into an URI, it will be prefixed by
 898  * the current working directory if it is a relative path, and then the path
 899  * will be canonicalised so that it doesn't contain any './' or '../' segments.
 900  *
 901  * On Windows #filename should be in UTF-8 encoding.
 902  *
 903  * Returns: newly-allocated URI string, or NULL on error. The caller must
 904  *   free the URI string with g_free() when no longer needed.
 905  */
 906 gchar *
 907 gst_filename_to_uri (const gchar * filename, GError ** error)
 908 {
 909   gchar *abs_location = NULL;
 910   gchar *uri, *abs_clean;
 911
 912   g_return_val_if_fail (filename != NULL, NULL);
 913   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 914
 915   if (g_path_is_absolute (filename)) {
 916     if (!file_path_contains_relatives (filename)) {
 917       uri = g_filename_to_uri (filename, NULL, error);
 918       goto beach;
 919     }
 920
 921     abs_location = g_strdup (filename);
 922   } else {
 923     gchar *cwd;
 924
 925     cwd = g_get_current_dir ();
 926     abs_location = g_build_filename (cwd, filename, NULL);
 927     g_free (cwd);
 928
 929     if (!file_path_contains_relatives (abs_location)) {
 930       uri = g_filename_to_uri (abs_location, NULL, error);
 931       goto beach;
 932     }
 933   }
 934
 935   /* path is now absolute, but contains '.' or '..' */
 936   abs_clean = gst_file_utils_canonicalise_path (abs_location);
 937   GST_LOG ("'%s' -> '%s' -> '%s'", filename, abs_location, abs_clean);
 938   uri = g_filename_to_uri (abs_clean, NULL, error);
 939   g_free (abs_clean);
 940
 941 beach:
 942
 943   g_free (abs_location);
 944   GST_DEBUG ("'%s' -> '%s'", filename, uri);
 945   return uri;
 946 }
 947
 948 /****************************************************************************
 949  * GstUri - GstMiniObject to parse and merge URIs according to IETF RFC 3986
 950  ****************************************************************************/
 951
 952 /**
 953  * SECTION:gsturi
 954  * @title: GstUri
 955  * @short_description: URI parsing and manipulation.
 956  *
 957  * A #GstUri object can be used to parse and split a URI string into its
 958  * constituant parts. Two #GstUri objects can be joined to make a new #GstUri
 959  * using the algorithm described in RFC3986.
 960  */
 961
 962 /* Definition for GstUri object */
 963 struct _GstUri
 964 {
 965   /*< private > */
 966   GstMiniObject mini_object;
 967   gchar *scheme;
 968   gchar *userinfo;
 969   gchar *host;
 970   guint port;
 971   GList *path;
 972   GHashTable *query;
 973   gchar *fragment;
 974 };
 975
 976 GST_DEFINE_MINI_OBJECT_TYPE (GstUri, gst_uri);
 977
 978 static GstUri *_gst_uri_copy (const GstUri * uri);
 979 static void _gst_uri_free (GstUri * uri);
 980 static GstUri *_gst_uri_new (void);
 981 static GList *_remove_dot_segments (GList * path);
 982
 983 /* private GstUri functions */
 984
 985 static GstUri *
 986 _gst_uri_new (void)
 987 {
 988   GstUri *uri;
 989
 990   g_return_val_if_fail (gst_is_initialized (), NULL);
 991
 992   uri = GST_URI_CAST (g_slice_new0 (GstUri));
 993
 994   if (uri)
 995     gst_mini_object_init (GST_MINI_OBJECT_CAST (uri), 0, gst_uri_get_type (),
 996         (GstMiniObjectCopyFunction) _gst_uri_copy, NULL,
 997         (GstMiniObjectFreeFunction) _gst_uri_free);
 998
 999   return uri;
1000 }
1001
1002 static void
1003 _gst_uri_free (GstUri * uri)
1004 {
1005   g_return_if_fail (GST_IS_URI (uri));
1006
1007   g_free (uri->scheme);
1008   g_free (uri->userinfo);
1009   g_free (uri->host);
1010   g_list_free_full (uri->path, g_free);
1011   if (uri->query)
1012     g_hash_table_unref (uri->query);
1013   g_free (uri->fragment);
1014
1015   g_slice_free1 (sizeof (*uri), uri);
1016 }
1017
1018 static GHashTable *
1019 _gst_uri_copy_query_table (GHashTable * orig)
1020 {
1021   GHashTable *new = NULL;
1022
1023   if (orig != NULL) {
1024     GHashTableIter iter;
1025     gpointer key, value;
1026     new = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1027     g_hash_table_iter_init (&iter, orig);
1028     while (g_hash_table_iter_next (&iter, &key, &value)) {
1029       g_hash_table_insert (new, g_strdup (key), g_strdup (value));
1030     }
1031   }
1032
1033   return new;
1034 }
1035
1036 static GstUri *
1037 _gst_uri_copy (const GstUri * orig_uri)
1038 {
1039   GstUri *new_uri;
1040
1041   g_return_val_if_fail (GST_IS_URI (orig_uri), NULL);
1042
1043   new_uri = _gst_uri_new ();
1044
1045   if (new_uri) {
1046     new_uri->scheme = g_strdup (orig_uri->scheme);
1047     new_uri->userinfo = g_strdup (orig_uri->userinfo);
1048     new_uri->host = g_strdup (orig_uri->host);
1049     new_uri->port = orig_uri->port;
1050     new_uri->path = g_list_copy_deep (orig_uri->path, (GCopyFunc) g_strdup,
1051         NULL);
1052     new_uri->query = _gst_uri_copy_query_table (orig_uri->query);
1053     new_uri->fragment = g_strdup (orig_uri->fragment);
1054   }
1055
1056   return new_uri;
1057 }
1058
1059 /*
1060  * _gst_uri_compare_lists:
1061  *
1062  * Compare two lists for equality. This compares the two lists, item for item,
1063  * comparing items in the same position in the two lists. If @first is
1064  * considered less than @second the result will be negative. If @first is
1065  * considered to be more than @second then the result will be positive. If the
1066  * lists are considered to be equal then the result will be 0. If two lists
1067  * have the same items, but one list is shorter than the other, then the
1068  * shorter list is considered to be less than the longer list.
1069  */
1070 static gint
1071 _gst_uri_compare_lists (GList * first, GList * second, GCompareFunc cmp_fn)
1072 {
1073   GList *itr1, *itr2;
1074   gint result;
1075
1076   for (itr1 = first, itr2 = second;
1077       itr1 != NULL || itr2 != NULL; itr1 = itr1->next, itr2 = itr2->next) {
1078     if (itr1 == NULL)
1079       return -1;
1080     if (itr2 == NULL)
1081       return 1;
1082     result = cmp_fn (itr1->data, itr2->data);
1083     if (result != 0)
1084       return result;
1085   }
1086   return 0;
1087 }
1088
1089 typedef enum
1090 {
1091   _GST_URI_NORMALIZE_LOWERCASE = 1,
1092   _GST_URI_NORMALIZE_UPPERCASE = 2
1093 } _GstUriNormalizations;
1094
1095 /*
1096  * Find the first character that hasn't been normalized according to the @flags.
1097  */
1098 static gchar *
1099 _gst_uri_first_non_normalized_char (gchar * str, guint flags)
1100 {
1101   gchar *pos;
1102
1103   if (str == NULL)
1104     return NULL;
1105
1106   for (pos = str; *pos; pos++) {
1107     if ((flags & _GST_URI_NORMALIZE_UPPERCASE) && g_ascii_islower (*pos))
1108       return pos;
1109     if ((flags & _GST_URI_NORMALIZE_LOWERCASE) && g_ascii_isupper (*pos))
1110       return pos;
1111   }
1112   return NULL;
1113 }
1114
1115 static gboolean
1116 _gst_uri_normalize_lowercase (gchar * str)
1117 {
1118   gchar *pos;
1119   gboolean ret = FALSE;
1120
1121   for (pos = _gst_uri_first_non_normalized_char (str,
1122           _GST_URI_NORMALIZE_LOWERCASE);
1123       pos != NULL;
1124       pos = _gst_uri_first_non_normalized_char (pos + 1,
1125           _GST_URI_NORMALIZE_LOWERCASE)) {
1126     *pos = g_ascii_tolower (*pos);
1127     ret = TRUE;
1128   }
1129
1130   return ret;
1131 }
1132
1133 #define _gst_uri_normalize_scheme _gst_uri_normalize_lowercase
1134 #define _gst_uri_normalize_hostname _gst_uri_normalize_lowercase
1135
1136 static gboolean
1137 _gst_uri_normalize_path (GList ** path)
1138 {
1139   GList *new_path;
1140
1141   new_path = _remove_dot_segments (*path);
1142   if (_gst_uri_compare_lists (new_path, *path, (GCompareFunc) g_strcmp0) != 0) {
1143     g_list_free_full (*path, g_free);
1144     *path = new_path;
1145     return TRUE;
1146   }
1147   g_list_free_full (new_path, g_free);
1148
1149   return FALSE;
1150 }
1151
1152 static gboolean
1153 _gst_uri_normalize_str_noop (gchar * str)
1154 {
1155   return FALSE;
1156 }
1157
1158 static gboolean
1159 _gst_uri_normalize_table_noop (GHashTable * table)
1160 {
1161   return FALSE;
1162 }
1163
1164 #define _gst_uri_normalize_userinfo _gst_uri_normalize_str_noop
1165 #define _gst_uri_normalize_query _gst_uri_normalize_table_noop
1166 #define _gst_uri_normalize_fragment _gst_uri_normalize_str_noop
1167
1168 /* RFC 3986 functions */
1169
1170 static GList *
1171 _merge (GList * base, GList * path)
1172 {
1173   GList *ret, *path_copy, *last;
1174
1175   path_copy = g_list_copy_deep (path, (GCopyFunc) g_strdup, NULL);
1176   /* if base is NULL make path absolute */
1177   if (base == NULL) {
1178     if (path_copy != NULL && path_copy->data != NULL) {
1179       path_copy = g_list_prepend (path_copy, NULL);
1180     }
1181     return path_copy;
1182   }
1183
1184   ret = g_list_copy_deep (base, (GCopyFunc) g_strdup, NULL);
1185   last = g_list_last (ret);
1186   ret = g_list_remove_link (ret, last);
1187   g_list_free_full (last, g_free);
1188   ret = g_list_concat (ret, path_copy);
1189
1190   return ret;
1191 }
1192
1193 static GList *
1194 _remove_dot_segments (GList * path)
1195 {
1196   GList *out, *elem, *next;
1197
1198   if (path == NULL)
1199     return NULL;
1200
1201   out = g_list_copy_deep (path, (GCopyFunc) g_strdup, NULL);
1202
1203   for (elem = out; elem; elem = next) {
1204     next = elem->next;
1205     if (elem->data == NULL && elem != out && next != NULL) {
1206       out = g_list_delete_link (out, elem);
1207     } else if (g_strcmp0 (elem->data, ".") == 0) {
1208       g_free (elem->data);
1209       out = g_list_delete_link (out, elem);
1210     } else if (g_strcmp0 (elem->data, "..") == 0) {
1211       GList *prev = g_list_previous (elem);
1212       if (prev && (prev != out || prev->data != NULL)) {
1213         g_free (prev->data);
1214         out = g_list_delete_link (out, prev);
1215       }
1216       g_free (elem->data);
1217       if (next != NULL) {
1218         out = g_list_delete_link (out, elem);
1219       } else {
1220         /* path ends in '/..' We need to keep the last '/' */
1221         elem->data = NULL;
1222       }
1223     }
1224   }
1225
1226   return out;
1227 }
1228
1229 static gchar *
1230 _gst_uri_escape_userinfo (const gchar * userinfo)
1231 {
1232   return g_uri_escape_string (userinfo,
1233       G_URI_RESERVED_CHARS_ALLOWED_IN_USERINFO, FALSE);
1234 }
1235
1236 static gchar *
1237 _gst_uri_escape_host (const gchar * host)
1238 {
1239   return g_uri_escape_string (host,
1240       G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, FALSE);
1241 }
1242
1243 static gchar *
1244 _gst_uri_escape_host_colon (const gchar * host)
1245 {
1246   return g_uri_escape_string (host,
1247       G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS ":", FALSE);
1248 }
1249
1250 static gchar *
1251 _gst_uri_escape_path_segment (const gchar * segment)
1252 {
1253   return g_uri_escape_string (segment,
1254       G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT, FALSE);
1255 }
1256
1257 static gchar *
1258 _gst_uri_escape_http_query_element (const gchar * element)
1259 {
1260   gchar *ret, *c;
1261
1262   ret = g_uri_escape_string (element, "!$'()*,;:@/? ", FALSE);
1263   for (c = ret; *c; c++)
1264     if (*c == ' ')
1265       *c = '+';
1266   return ret;
1267 }
1268
1269 static gchar *
1270 _gst_uri_escape_fragment (const gchar * fragment)
1271 {
1272   return g_uri_escape_string (fragment,
1273       G_URI_RESERVED_CHARS_ALLOWED_IN_PATH "?", FALSE);
1274 }
1275
1276 static GList *
1277 _gst_uri_string_to_list (const gchar * str, const gchar * sep, gboolean convert,
1278     gboolean unescape)
1279 {
1280   GList *new_list = NULL;
1281
1282   if (str) {
1283     guint pct_sep_len = 0;
1284     gchar *pct_sep = NULL;
1285     gchar **split_str;
1286
1287     if (convert && !unescape) {
1288       pct_sep = g_strdup_printf ("%%%2.2X", (guint) (*sep));
1289       pct_sep_len = 3;
1290     }
1291
1292     split_str = g_strsplit (str, sep, -1);
1293     if (split_str) {
1294       gchar **next_elem;
1295       for (next_elem = split_str; *next_elem; next_elem += 1) {
1296         gchar *elem = *next_elem;
1297         if (*elem == '\0') {
1298           new_list = g_list_append (new_list, NULL);
1299         } else {
1300           if (convert && !unescape) {
1301             gchar *next_sep;
1302             for (next_sep = strcasestr (elem, pct_sep); next_sep;
1303                 next_sep = strcasestr (next_sep + 1, pct_sep)) {
1304               *next_sep = *sep;
1305               memmove (next_sep + 1, next_sep + pct_sep_len,
1306                   strlen (next_sep + pct_sep_len) + 1);
1307             }
1308           }
1309           if (unescape) {
1310             *next_elem = g_uri_unescape_string (elem, NULL);
1311             g_free (elem);
1312             elem = *next_elem;
1313           }
1314           new_list = g_list_append (new_list, g_strdup (elem));
1315         }
1316       }
1317     }
1318     g_strfreev (split_str);
1319     if (convert && !unescape)
1320       g_free (pct_sep);
1321   }
1322
1323   return new_list;
1324 }
1325
1326 static GHashTable *
1327 _gst_uri_string_to_table (const gchar * str, const gchar * part_sep,
1328     const gchar * kv_sep, gboolean convert, gboolean unescape)
1329 {
1330   GHashTable *new_table = NULL;
1331
1332   if (str) {
1333     gchar *pct_part_sep = NULL, *pct_kv_sep = NULL;
1334     gchar **split_parts;
1335
1336     new_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1337
1338     if (convert && !unescape) {
1339       pct_part_sep = g_strdup_printf ("%%%2.2X", (guint) (*part_sep));
1340       pct_kv_sep = g_strdup_printf ("%%%2.2X", (guint) (*kv_sep));
1341     }
1342
1343     split_parts = g_strsplit (str, part_sep, -1);
1344     if (split_parts) {
1345       gchar **next_part;
1346       for (next_part = split_parts; *next_part; next_part += 1) {
1347         gchar *part = *next_part;
1348         gchar *kv_sep_pos;
1349         gchar *key, *value;
1350         /* if we are converting percent encoded versions of separators then
1351          *  substitute the part separator now. */
1352         if (convert && !unescape) {
1353           gchar *next_sep;
1354           for (next_sep = strcasestr (part, pct_part_sep); next_sep;
1355               next_sep = strcasestr (next_sep + 1, pct_part_sep)) {
1356             *next_sep = *part_sep;
1357             memmove (next_sep + 1, next_sep + 3, strlen (next_sep + 3) + 1);
1358           }
1359         }
1360         /* find the key/value separator within the part */
1361         kv_sep_pos = g_strstr_len (part, -1, kv_sep);
1362         if (kv_sep_pos == NULL) {
1363           if (unescape) {
1364             key = g_uri_unescape_string (part, NULL);
1365           } else {
1366             key = g_strdup (part);
1367           }
1368           value = NULL;
1369         } else {
1370           if (unescape) {
1371             key = g_uri_unescape_segment (part, kv_sep_pos, NULL);
1372             value = g_uri_unescape_string (kv_sep_pos + 1, NULL);
1373           } else {
1374             key = g_strndup (part, kv_sep_pos - part);
1375             value = g_strdup (kv_sep_pos + 1);
1376           }
1377         }
1378         /* if we are converting percent encoded versions of separators then
1379          *  substitute the key/value separator in both key and value now. */
1380         if (convert && !unescape) {
1381           gchar *next_sep;
1382           for (next_sep = strcasestr (key, pct_kv_sep); next_sep;
1383               next_sep = strcasestr (next_sep + 1, pct_kv_sep)) {
1384             *next_sep = *kv_sep;
1385             memmove (next_sep + 1, next_sep + 3, strlen (next_sep + 3) + 1);
1386           }
1387           if (value) {
1388             for (next_sep = strcasestr (value, pct_kv_sep); next_sep;
1389                 next_sep = strcasestr (next_sep + 1, pct_kv_sep)) {
1390               *next_sep = *kv_sep;
1391               memmove (next_sep + 1, next_sep + 3, strlen (next_sep + 3) + 1);
1392             }
1393           }
1394         }
1395         /* add value to the table */
1396         g_hash_table_insert (new_table, key, value);
1397       }
1398     }
1399     /* tidy up */
1400     g_strfreev (split_parts);
1401     if (convert && !unescape) {
1402       g_free (pct_part_sep);
1403       g_free (pct_kv_sep);
1404     }
1405   }
1406
1407   return new_table;
1408 }
1409
1410
1411 /*
1412  * Method definitions.
1413  */
1414
1415 /**
1416  * gst_uri_new:
1417  * @scheme: (nullable): The scheme for the new URI.
1418  * @userinfo: (nullable): The user-info for the new URI.
1419  * @host: (nullable): The host name for the new URI.
1420  * @port: The port number for the new URI or %GST_URI_NO_PORT.
1421  * @path: (nullable): The path for the new URI with '/' separating path
1422  *                      elements.
1423  * @query: (nullable): The query string for the new URI with '&' separating
1424  *                       query elements. Elements containing '&' characters
1425  *                       should encode them as "&percnt;26".
1426  * @fragment: (nullable): The fragment name for the new URI.
1427  *
1428  * Creates a new #GstUri object with the given URI parts. The path and query
1429  * strings will be broken down into their elements. All strings should not be
1430  * escaped except where indicated.
1431  *
1432  * Returns: (transfer full): A new #GstUri object.
1433  *
1434  * Since: 1.6
1435  */
1436 GstUri *
1437 gst_uri_new (const gchar * scheme, const gchar * userinfo, const gchar * host,
1438     guint port, const gchar * path, const gchar * query, const gchar * fragment)
1439 {
1440   GstUri *new_uri;
1441
1442   new_uri = _gst_uri_new ();
1443   if (new_uri) {
1444     new_uri->scheme = g_strdup (scheme);
1445     new_uri->userinfo = g_strdup (userinfo);
1446     new_uri->host = g_strdup (host);
1447     new_uri->port = port;
1448     new_uri->path = _gst_uri_string_to_list (path, "/", FALSE, FALSE);
1449     new_uri->query = _gst_uri_string_to_table (query, "&", "=", TRUE, FALSE);
1450     new_uri->fragment = g_strdup (fragment);
1451   }
1452
1453   return new_uri;
1454 }
1455
1456 /**
1457  * gst_uri_new_with_base:
1458  * @base: (transfer none)(nullable): The base URI to join the new URI to.
1459  * @scheme: (nullable): The scheme for the new URI.
1460  * @userinfo: (nullable): The user-info for the new URI.
1461  * @host: (nullable): The host name for the new URI.
1462  * @port: The port number for the new URI or %GST_URI_NO_PORT.
1463  * @path: (nullable): The path for the new URI with '/' separating path
1464  *                      elements.
1465  * @query: (nullable): The query string for the new URI with '&' separating
1466  *                       query elements. Elements containing '&' characters
1467  *                       should encode them as "&percnt;26".
1468  * @fragment: (nullable): The fragment name for the new URI.
1469  *
1470  * Like gst_uri_new(), but joins the new URI onto a base URI.
1471  *
1472  * Returns: (transfer full): The new URI joined onto @base.
1473  *
1474  * Since: 1.6
1475  */
1476 GstUri *
1477 gst_uri_new_with_base (GstUri * base, const gchar * scheme,
1478     const gchar * userinfo, const gchar * host, guint port, const gchar * path,
1479     const gchar * query, const gchar * fragment)
1480 {
1481   GstUri *new_rel_uri;
1482   GstUri *new_uri;
1483
1484   g_return_val_if_fail (base == NULL || GST_IS_URI (base), NULL);
1485
1486   new_rel_uri = gst_uri_new (scheme, userinfo, host, port, path, query,
1487       fragment);
1488   new_uri = gst_uri_join (base, new_rel_uri);
1489   gst_uri_unref (new_rel_uri);
1490
1491   return new_uri;
1492 }
1493
1494 /**
1495  * gst_uri_from_string:
1496  * @uri: The URI string to parse.
1497  *
1498  * Parses a URI string into a new #GstUri object. Will return NULL if the URI
1499  * cannot be parsed.
1500  *
1501  * Returns: (transfer full) (nullable): A new #GstUri object, or NULL.
1502  *
1503  * Since: 1.6
1504  */
1505 GstUri *
1506 gst_uri_from_string (const gchar * uri)
1507 {
1508   const gchar *orig_uri = uri;
1509   GstUri *uri_obj;
1510
1511   uri_obj = _gst_uri_new ();
1512
1513   if (uri_obj && uri != NULL) {
1514     int i = 0;
1515
1516     /* be helpful and skip initial white space */
1517     while (*uri == '\v' || g_ascii_isspace (*uri))
1518       uri++;
1519
1520     if (g_ascii_isalpha (uri[i])) {
1521       /* find end of scheme name */
1522       i++;
1523       while (g_ascii_isalnum (uri[i]) || uri[i] == '+' || uri[i] == '-' ||
1524           uri[i] == '.')
1525         i++;
1526     }
1527     if (i > 0 && uri[i] == ':') {
1528       /* get scheme */
1529       uri_obj->scheme = g_strndup (uri, i);
1530       uri += i + 1;
1531     }
1532     if (uri[0] == '/' && uri[1] == '/') {
1533       const gchar *eoa, *eoui, *eoh, *reoh;
1534       /* get authority [userinfo@]host[:port] */
1535       uri += 2;
1536       /* find end of authority */
1537       eoa = uri + strcspn (uri, "/?#");
1538
1539       /* find end of userinfo */
1540       eoui = strchr (uri, '@');
1541       if (eoui != NULL && eoui < eoa) {
1542         uri_obj->userinfo = g_uri_unescape_segment (uri, eoui, NULL);
1543         uri = eoui + 1;
1544       }
1545       /* find end of host */
1546       if (uri[0] == '[') {
1547         eoh = strchr (uri, ']');
1548         if (eoh == NULL || eoh > eoa) {
1549           GST_DEBUG ("Unable to parse the host part of the URI '%s'.",
1550               orig_uri);
1551           gst_uri_unref (uri_obj);
1552           return NULL;
1553         }
1554         reoh = eoh + 1;
1555         uri++;
1556       } else {
1557         reoh = eoh = strchr (uri, ':');
1558         if (eoh == NULL || eoh > eoa)
1559           reoh = eoh = eoa;
1560       }
1561       /* don't capture empty host strings */
1562       if (eoh != uri)
1563         uri_obj->host = g_uri_unescape_segment (uri, eoh, NULL);
1564
1565       uri = reoh;
1566       if (uri < eoa) {
1567         /* if port number is malformed then we can't parse this */
1568         if (uri[0] != ':' || strspn (uri + 1, "0123456789") != eoa - uri - 1) {
1569           GST_DEBUG ("Unable to parse host/port part of the URI '%s'.",
1570               orig_uri);
1571           gst_uri_unref (uri_obj);
1572           return NULL;
1573         }
1574         /* otherwise treat port as unsigned decimal number */
1575         uri++;
1576         while (uri < eoa) {
1577           uri_obj->port = uri_obj->port * 10 + g_ascii_digit_value (*uri);
1578           uri++;
1579         }
1580       }
1581       uri = eoa;
1582     }
1583     if (uri != NULL && uri[0] != '\0') {
1584       /* get path */
1585       size_t len;
1586       len = strcspn (uri, "?#");
1587       if (uri[len] == '\0') {
1588         uri_obj->path = _gst_uri_string_to_list (uri, "/", FALSE, TRUE);
1589         uri = NULL;
1590       } else {
1591         if (len > 0) {
1592           gchar *path_str = g_strndup (uri, len);
1593           uri_obj->path = _gst_uri_string_to_list (path_str, "/", FALSE, TRUE);
1594           g_free (path_str);
1595         }
1596         uri += len;
1597       }
1598     }
1599     if (uri != NULL && uri[0] == '?') {
1600       /* get query */
1601       gchar *eoq;
1602       eoq = strchr (++uri, '#');
1603       if (eoq == NULL) {
1604         uri_obj->query = _gst_uri_string_to_table (uri, "&", "=", TRUE, TRUE);
1605         uri = NULL;
1606       } else {
1607         if (eoq != uri) {
1608           gchar *query_str = g_strndup (uri, eoq - uri);
1609           uri_obj->query = _gst_uri_string_to_table (query_str, "&", "=", TRUE,
1610               TRUE);
1611           g_free (query_str);
1612         }
1613         uri = eoq;
1614       }
1615     }
1616     if (uri != NULL && uri[0] == '#') {
1617       uri_obj->fragment = g_uri_unescape_string (uri + 1, NULL);
1618     }
1619   }
1620
1621   return uri_obj;
1622 }
1623
1624 /**
1625  * gst_uri_from_string_with_base:
1626  * @base: (transfer none)(nullable): The base URI to join the new URI with.
1627  * @uri: The URI string to parse.
1628  *
1629  * Like gst_uri_from_string() but also joins with a base URI.
1630  *
1631  * Returns: (transfer full): A new #GstUri object.
1632  *
1633  * Since: 1.6
1634  */
1635 GstUri *
1636 gst_uri_from_string_with_base (GstUri * base, const gchar * uri)
1637 {
1638   GstUri *new_rel_uri;
1639   GstUri *new_uri;
1640
1641   g_return_val_if_fail (base == NULL || GST_IS_URI (base), NULL);
1642
1643   new_rel_uri = gst_uri_from_string (uri);
1644   new_uri = gst_uri_join (base, new_rel_uri);
1645   gst_uri_unref (new_rel_uri);
1646
1647   return new_uri;
1648 }
1649
1650 /**
1651  * gst_uri_equal:
1652  * @first: First #GstUri to compare.
1653  * @second: Second #GstUri to compare.
1654  *
1655  * Compares two #GstUri objects to see if they represent the same normalized
1656  * URI.
1657  *
1658  * Returns: %TRUE if the normalized versions of the two URI's would be equal.
1659  *
1660  * Since: 1.6
1661  */
1662 gboolean
1663 gst_uri_equal (const GstUri * first, const GstUri * second)
1664 {
1665   gchar *first_norm = NULL, *second_norm = NULL;
1666   GList *first_norm_list = NULL, *second_norm_list = NULL;
1667   const gchar *first_cmp, *second_cmp;
1668   GHashTableIter table_iter;
1669   gpointer key, value;
1670   int result;
1671
1672   g_return_val_if_fail ((first == NULL || GST_IS_URI (first)) &&
1673       (second == NULL || GST_IS_URI (second)), FALSE);
1674
1675   if (first == second)
1676     return TRUE;
1677
1678   if (first == NULL || second == NULL)
1679     return FALSE;
1680
1681   if (first->port != second->port)
1682     return FALSE;
1683
1684 /* work out a version of field value (normalized or not) to compare.
1685  * first_cmp, second_cmp will be the values to compare later.
1686  * first_norm, second_norm will be non-NULL if normalized versions are used,
1687  *  and need to be freed later.
1688  */
1689 #define GST_URI_NORMALIZED_FIELD(pos, field, norm_fn, flags) \
1690   pos##_cmp = pos->field; \
1691   if (_gst_uri_first_non_normalized_char ((gchar*)pos##_cmp, flags) != NULL) { \
1692     pos##_norm = g_strdup (pos##_cmp); \
1693     norm_fn (pos##_norm); \
1694     pos##_cmp = pos##_norm; \
1695   }
1696
1697 /* compare two string values, normalizing if needed */
1698 #define GST_URI_NORMALIZED_CMP_STR(field, norm_fn, flags) \
1699   GST_URI_NORMALIZED_FIELD (first, field, norm_fn, flags) \
1700   GST_URI_NORMALIZED_FIELD (second, field, norm_fn, flags) \
1701   result = g_strcmp0 (first_cmp, second_cmp); \
1702   g_free (first_norm); \
1703   first_norm = NULL; \
1704   g_free (second_norm); \
1705   second_norm = NULL; \
1706   if (result != 0) return FALSE
1707
1708 /* compare two string values */
1709 #define GST_URI_CMP_STR(field) \
1710   if (g_strcmp0 (first->field, second->field) != 0) return FALSE
1711
1712 /* compare two GLists, normalize lists if needed before comparison */
1713 #define GST_URI_NORMALIZED_CMP_LIST(field, norm_fn, copy_fn, cmp_fn, free_fn) \
1714   first_norm_list = g_list_copy_deep (first->field, (GCopyFunc) copy_fn, NULL); \
1715   norm_fn (&first_norm_list); \
1716   second_norm_list = g_list_copy_deep (second->field, (GCopyFunc) copy_fn, NULL); \
1717   norm_fn (&second_norm_list); \
1718   result = _gst_uri_compare_lists (first_norm_list, second_norm_list, (GCompareFunc) cmp_fn); \
1719   g_list_free_full (first_norm_list, free_fn); \
1720   g_list_free_full (second_norm_list, free_fn); \
1721   if (result != 0) return FALSE
1722
1723   GST_URI_CMP_STR (userinfo);
1724
1725   GST_URI_CMP_STR (fragment);
1726
1727   GST_URI_NORMALIZED_CMP_STR (scheme, _gst_uri_normalize_scheme,
1728       _GST_URI_NORMALIZE_LOWERCASE);
1729
1730   GST_URI_NORMALIZED_CMP_STR (host, _gst_uri_normalize_hostname,
1731       _GST_URI_NORMALIZE_LOWERCASE);
1732
1733   GST_URI_NORMALIZED_CMP_LIST (path, _gst_uri_normalize_path, g_strdup,
1734       g_strcmp0, g_free);
1735
1736   if (first->query == NULL && second->query != NULL)
1737     return FALSE;
1738   if (first->query != NULL && second->query == NULL)
1739     return FALSE;
1740   if (first->query != NULL) {
1741     if (g_hash_table_size (first->query) != g_hash_table_size (second->query))
1742       return FALSE;
1743
1744     g_hash_table_iter_init (&table_iter, first->query);
1745     while (g_hash_table_iter_next (&table_iter, &key, &value)) {
1746       if (!g_hash_table_contains (second->query, key))
1747         return FALSE;
1748       result = g_strcmp0 (g_hash_table_lookup (second->query, key), value);
1749       if (result != 0)
1750         return FALSE;
1751     }
1752   }
1753 #undef GST_URI_NORMALIZED_CMP_STR
1754 #undef GST_URI_CMP_STR
1755 #undef GST_URI_NORMALIZED_CMP_LIST
1756 #undef GST_URI_NORMALIZED_FIELD
1757
1758   return TRUE;
1759 }
1760
1761 /**
1762  * gst_uri_join:
1763  * @base_uri: (transfer none) (nullable): The base URI to join another to.
1764  * @ref_uri: (transfer none) (nullable): The reference URI to join onto the
1765  *                                       base URI.
1766  *
1767  * Join a reference URI onto a base URI using the method from RFC 3986.
1768  * If either URI is %NULL then the other URI will be returned with the ref count
1769  * increased.
1770  *
1771  * Returns: (transfer full) (nullable): A #GstUri which represents the base
1772  *                                      with the reference URI joined on.
1773  *
1774  * Since: 1.6
1775  */
1776 GstUri *
1777 gst_uri_join (GstUri * base_uri, GstUri * ref_uri)
1778 {
1779   const gchar *r_scheme;
1780   GstUri *t;
1781
1782   g_return_val_if_fail ((base_uri == NULL || GST_IS_URI (base_uri)) &&
1783       (ref_uri == NULL || GST_IS_URI (ref_uri)), NULL);
1784
1785   if (base_uri == NULL && ref_uri == NULL)
1786     return NULL;
1787   if (base_uri == NULL) {
1788     g_return_val_if_fail (GST_IS_URI (ref_uri), NULL);
1789     return gst_uri_ref (ref_uri);
1790   }
1791   if (ref_uri == NULL) {
1792     g_return_val_if_fail (GST_IS_URI (base_uri), NULL);
1793     return gst_uri_ref (base_uri);
1794   }
1795
1796   g_return_val_if_fail (GST_IS_URI (base_uri) && GST_IS_URI (ref_uri), NULL);
1797
1798   t = _gst_uri_new ();
1799
1800   if (t == NULL)
1801     return t;
1802
1803   /* process according to RFC3986 */
1804   r_scheme = ref_uri->scheme;
1805   if (r_scheme != NULL && g_strcmp0 (base_uri->scheme, r_scheme) == 0) {
1806     r_scheme = NULL;
1807   }
1808   if (r_scheme != NULL) {
1809     t->scheme = g_strdup (r_scheme);
1810     t->userinfo = g_strdup (ref_uri->userinfo);
1811     t->host = g_strdup (ref_uri->host);
1812     t->port = ref_uri->port;
1813     t->path = _remove_dot_segments (ref_uri->path);
1814     t->query = _gst_uri_copy_query_table (ref_uri->query);
1815   } else {
1816     if (ref_uri->host != NULL) {
1817       t->userinfo = g_strdup (ref_uri->userinfo);
1818       t->host = g_strdup (ref_uri->host);
1819       t->port = ref_uri->port;
1820       t->path = _remove_dot_segments (ref_uri->path);
1821       t->query = _gst_uri_copy_query_table (ref_uri->query);
1822     } else {
1823       if (ref_uri->path == NULL) {
1824         t->path = g_list_copy_deep (base_uri->path, (GCopyFunc) g_strdup, NULL);
1825         if (ref_uri->query != NULL)
1826           t->query = _gst_uri_copy_query_table (ref_uri->query);
1827         else
1828           t->query = _gst_uri_copy_query_table (base_uri->query);
1829       } else {
1830         if (ref_uri->path->data == NULL)
1831           t->path = _remove_dot_segments (ref_uri->path);
1832         else {
1833           GList *mrgd = _merge (base_uri->path, ref_uri->path);
1834           t->path = _remove_dot_segments (mrgd);
1835           g_list_free_full (mrgd, g_free);
1836         }
1837         t->query = _gst_uri_copy_query_table (ref_uri->query);
1838       }
1839       t->userinfo = g_strdup (base_uri->userinfo);
1840       t->host = g_strdup (base_uri->host);
1841       t->port = base_uri->port;
1842     }
1843     t->scheme = g_strdup (base_uri->scheme);
1844   }
1845   t->fragment = g_strdup (ref_uri->fragment);
1846
1847   return t;
1848 }
1849
1850 /**
1851  * gst_uri_join_strings:
1852  * @base_uri: The percent-encoded base URI.
1853  * @ref_uri: The percent-encoded reference URI to join to the @base_uri.
1854  *
1855  * This is a convenience function to join two URI strings and return the result.
1856  * The returned string should be g_free()'d after use.
1857  *
1858  * Returns: (transfer full): A string representing the percent-encoded join of
1859  *          the two URIs.
1860  *
1861  * Since: 1.6
1862  */
1863 gchar *
1864 gst_uri_join_strings (const gchar * base_uri, const gchar * ref_uri)
1865 {
1866   GstUri *base, *result;
1867   gchar *result_uri;
1868
1869   base = gst_uri_from_string (base_uri);
1870   result = gst_uri_from_string_with_base (base, ref_uri);
1871   result_uri = gst_uri_to_string (result);
1872   gst_uri_unref (base);
1873   gst_uri_unref (result);
1874
1875   return result_uri;
1876 }
1877
1878 /**
1879  * gst_uri_is_writable:
1880  * @uri: The #GstUri object to test.
1881  *
1882  * Check if it is safe to write to this #GstUri.
1883  *
1884  * Check if the refcount of @uri is exactly 1, meaning that no other
1885  * reference exists to the #GstUri and that the #GstUri is therefore writable.
1886  *
1887  * Modification of a #GstUri should only be done after verifying that it is
1888  * writable.
1889  *
1890  * Returns: %TRUE if it is safe to write to the object.
1891  *
1892  * Since: 1.6
1893  */
1894 gboolean
1895 gst_uri_is_writable (const GstUri * uri)
1896 {
1897   g_return_val_if_fail (GST_IS_URI (uri), FALSE);
1898   return gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (uri));
1899 }
1900
1901 /**
1902  * gst_uri_make_writable:
1903  * @uri: (transfer full): The #GstUri object to make writable.
1904  *
1905  * Make the #GstUri writable.
1906  *
1907  * Checks if @uri is writable, and if so the original object is returned. If
1908  * not, then a writable copy is made and returned. This gives away the
1909  * reference to @uri and returns a reference to the new #GstUri.
1910  * If @uri is %NULL then %NULL is returned.
1911  *
1912  * Returns: (transfer full): A writable version of @uri.
1913  *
1914  * Since: 1.6
1915  */
1916 GstUri *
1917 gst_uri_make_writable (GstUri * uri)
1918 {
1919   g_return_val_if_fail (GST_IS_URI (uri), NULL);
1920   return
1921       GST_URI_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (uri)));
1922 }
1923
1924 /**
1925  * gst_uri_to_string:
1926  * @uri: This #GstUri to convert to a string.
1927  *
1928  * Convert the URI to a string.
1929  *
1930  * Returns the URI as held in this object as a #gchar* nul-terminated string.
1931  * The caller should g_free() the string once they are finished with it.
1932  * The string is put together as described in RFC 3986.
1933  *
1934  * Returns: (transfer full): The string version of the URI.
1935  *
1936  * Since: 1.6
1937  */
1938 gchar *
1939 gst_uri_to_string (const GstUri * uri)
1940 {
1941   GString *uri_str;
1942   gchar *escaped;
1943
1944   g_return_val_if_fail (GST_IS_URI (uri), NULL);
1945
1946   uri_str = g_string_new (NULL);
1947
1948   if (uri->scheme != NULL)
1949     g_string_append_printf (uri_str, "%s:", uri->scheme);
1950
1951   if (uri->userinfo != NULL || uri->host != NULL ||
1952       uri->port != GST_URI_NO_PORT)
1953     g_string_append (uri_str, "//");
1954
1955   if (uri->userinfo != NULL) {
1956     escaped = _gst_uri_escape_userinfo (uri->userinfo);
1957     g_string_append_printf (uri_str, "%s@", escaped);
1958     g_free (escaped);
1959   }
1960
1961   if (uri->host != NULL) {
1962     if (strchr (uri->host, ':') != NULL) {
1963       escaped = _gst_uri_escape_host_colon (uri->host);
1964       g_string_append_printf (uri_str, "[%s]", escaped);
1965       g_free (escaped);
1966     } else {
1967       escaped = _gst_uri_escape_host (uri->host);
1968       g_string_append (uri_str, escaped);
1969       g_free (escaped);
1970     }
1971   }
1972
1973   if (uri->port != GST_URI_NO_PORT)
1974     g_string_append_printf (uri_str, ":%u", uri->port);
1975
1976   if (uri->path != NULL) {
1977     escaped = gst_uri_get_path_string (uri);
1978     g_string_append (uri_str, escaped);
1979     g_free (escaped);
1980   }
1981
1982   if (uri->query) {
1983     g_string_append (uri_str, "?");
1984     escaped = gst_uri_get_query_string (uri);
1985     g_string_append (uri_str, escaped);
1986     g_free (escaped);
1987   }
1988
1989   if (uri->fragment != NULL) {
1990     escaped = _gst_uri_escape_fragment (uri->fragment);
1991     g_string_append_printf (uri_str, "#%s", escaped);
1992     g_free (escaped);
1993   }
1994
1995   return g_string_free (uri_str, FALSE);
1996 }
1997
1998 /**
1999  * gst_uri_is_normalized:
2000  * @uri: The #GstUri to test to see if it is normalized.
2001  *
2002  * Tests the @uri to see if it is normalized. A %NULL @uri is considered to be
2003  * normalized.
2004  *
2005  * Returns: TRUE if the URI is normalized or is %NULL.
2006  *
2007  * Since: 1.6
2008  */
2009 gboolean
2010 gst_uri_is_normalized (const GstUri * uri)
2011 {
2012   GList *new_path;
2013   gboolean ret;
2014
2015   if (uri == NULL)
2016     return TRUE;
2017
2018   g_return_val_if_fail (GST_IS_URI (uri), FALSE);
2019
2020   /* check for non-normalized characters in uri parts */
2021   if (_gst_uri_first_non_normalized_char (uri->scheme,
2022           _GST_URI_NORMALIZE_LOWERCASE) != NULL ||
2023       /*_gst_uri_first_non_normalized_char (uri->userinfo,
2024           _GST_URI_NORMALIZE_PERCENTAGES) != NULL || */
2025       _gst_uri_first_non_normalized_char (uri->host,
2026           _GST_URI_NORMALIZE_LOWERCASE /*| _GST_URI_NORMALIZE_PERCENTAGES */ )
2027       != NULL
2028       /*|| _gst_uri_first_non_normalized_char (uri->path,
2029          _GST_URI_NORMALIZE_PERCENTAGES) != NULL
2030          || _gst_uri_first_non_normalized_char (uri->query,
2031          _GST_URI_NORMALIZE_PERCENTAGES) != NULL
2032          || _gst_uri_first_non_normalized_char (uri->fragment,
2033          _GST_URI_NORMALIZE_PERCENTAGES) != NULL */ )
2034     return FALSE;
2035
2036   /* also check path has had dot segments removed */
2037   new_path = _remove_dot_segments (uri->path);
2038   ret =
2039       (_gst_uri_compare_lists (new_path, uri->path,
2040           (GCompareFunc) g_strcmp0) == 0);
2041   g_list_free_full (new_path, g_free);
2042   return ret;
2043 }
2044
2045 /**
2046  * gst_uri_normalize:
2047  * @uri: (transfer none): The #GstUri to normalize.
2048  *
2049  * Normalization will remove extra path segments ("." and "..") from the URI. It
2050  * will also convert the scheme and host name to lower case and any
2051  * percent-encoded values to uppercase.
2052  *
2053  * The #GstUri object must be writable. Check with gst_uri_is_writable() or use
2054  * gst_uri_make_writable() first.
2055  *
2056  * Returns: TRUE if the URI was modified.
2057  *
2058  * Since: 1.6
2059  */
2060 gboolean
2061 gst_uri_normalize (GstUri * uri)
2062 {
2063   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2064
2065   return _gst_uri_normalize_scheme (uri->scheme) |
2066       _gst_uri_normalize_userinfo (uri->userinfo) |
2067       _gst_uri_normalize_hostname (uri->host) |
2068       _gst_uri_normalize_path (&uri->path) |
2069       _gst_uri_normalize_query (uri->query) |
2070       _gst_uri_normalize_fragment (uri->fragment);
2071 }
2072
2073 /**
2074  * gst_uri_get_scheme:
2075  * @uri: (nullable): This #GstUri object.
2076  *
2077  * Get the scheme name from the URI or %NULL if it doesn't exist.
2078  * If @uri is %NULL then returns %NULL.
2079  *
2080  * Returns: (nullable): The scheme from the #GstUri object or %NULL.
2081  */
2082 const gchar *
2083 gst_uri_get_scheme (const GstUri * uri)
2084 {
2085   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2086   return (uri ? uri->scheme : NULL);
2087 }
2088
2089 /**
2090  * gst_uri_set_scheme:
2091  * @uri: (transfer none)(nullable): The #GstUri to modify.
2092  * @scheme: The new scheme to set or %NULL to unset the scheme.
2093  *
2094  * Set or unset the scheme for the URI.
2095  *
2096  * Returns: %TRUE if the scheme was set/unset successfully.
2097  *
2098  * Since: 1.6
2099  */
2100 gboolean
2101 gst_uri_set_scheme (GstUri * uri, const gchar * scheme)
2102 {
2103   if (!uri)
2104     return scheme == NULL;
2105   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2106
2107   g_free (uri->scheme);
2108   uri->scheme = g_strdup (scheme);
2109
2110   return TRUE;
2111 }
2112
2113 /**
2114  * gst_uri_get_userinfo:
2115  * @uri: (nullable): This #GstUri object.
2116  *
2117  * Get the userinfo (usually in the form "username:password") from the URI
2118  * or %NULL if it doesn't exist. If @uri is %NULL then returns %NULL.
2119  *
2120  * Returns: (nullable): The userinfo from the #GstUri object or %NULL.
2121  *
2122  * Since: 1.6
2123  */
2124 const gchar *
2125 gst_uri_get_userinfo (const GstUri * uri)
2126 {
2127   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2128   return (uri ? uri->userinfo : NULL);
2129 }
2130
2131 /**
2132  * gst_uri_set_userinfo:
2133  * @uri: (transfer none)(nullable): The #GstUri to modify.
2134  * @userinfo: The new user-information string to set or %NULL to unset.
2135  *
2136  * Set or unset the user information for the URI.
2137  *
2138  * Returns: %TRUE if the user information was set/unset successfully.
2139  *
2140  * Since: 1.6
2141  */
2142 gboolean
2143 gst_uri_set_userinfo (GstUri * uri, const gchar * userinfo)
2144 {
2145   if (!uri)
2146     return userinfo == NULL;
2147   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2148
2149   g_free (uri->userinfo);
2150   uri->userinfo = g_strdup (userinfo);
2151
2152   return TRUE;
2153 }
2154
2155 /**
2156  * gst_uri_get_host:
2157  * @uri: (nullable): This #GstUri object.
2158  *
2159  * Get the host name from the URI or %NULL if it doesn't exist.
2160  * If @uri is %NULL then returns %NULL.
2161  *
2162  * Returns: (nullable): The host name from the #GstUri object or %NULL.
2163  *
2164  * Since: 1.6
2165  */
2166 const gchar *
2167 gst_uri_get_host (const GstUri * uri)
2168 {
2169   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2170   return (uri ? uri->host : NULL);
2171 }
2172
2173 /**
2174  * gst_uri_set_host:
2175  * @uri: (transfer none)(nullable): The #GstUri to modify.
2176  * @host: The new host string to set or %NULL to unset.
2177  *
2178  * Set or unset the host for the URI.
2179  *
2180  * Returns: %TRUE if the host was set/unset successfully.
2181  *
2182  * Since: 1.6
2183  */
2184 gboolean
2185 gst_uri_set_host (GstUri * uri, const gchar * host)
2186 {
2187   if (!uri)
2188     return host == NULL;
2189   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2190
2191   g_free (uri->host);
2192   uri->host = g_strdup (host);
2193
2194   return TRUE;
2195 }
2196
2197 /**
2198  * gst_uri_get_port:
2199  * @uri: (nullable): This #GstUri object.
2200  *
2201  * Get the port number from the URI or %GST_URI_NO_PORT if it doesn't exist.
2202  * If @uri is %NULL then returns %GST_URI_NO_PORT.
2203  *
2204  * Returns: The port number from the #GstUri object or %GST_URI_NO_PORT.
2205  *
2206  * Since: 1.6
2207  */
2208 guint
2209 gst_uri_get_port (const GstUri * uri)
2210 {
2211   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), GST_URI_NO_PORT);
2212   return (uri ? uri->port : GST_URI_NO_PORT);
2213 }
2214
2215 /**
2216  * gst_uri_set_port:
2217  * @uri: (transfer none)(nullable): The #GstUri to modify.
2218  * @port: The new port number to set or %GST_URI_NO_PORT to unset.
2219  *
2220  * Set or unset the port number for the URI.
2221  *
2222  * Returns: %TRUE if the port number was set/unset successfully.
2223  *
2224  * Since: 1.6
2225  */
2226 gboolean
2227 gst_uri_set_port (GstUri * uri, guint port)
2228 {
2229   if (!uri)
2230     return port == GST_URI_NO_PORT;
2231   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2232
2233   uri->port = port;
2234
2235   return TRUE;
2236 }
2237
2238 /**
2239  * gst_uri_get_path:
2240  * @uri: The #GstUri to get the path from.
2241  *
2242  * Extract the path string from the URI object.
2243  *
2244  * Returns: (transfer full): (nullable): The path from the URI. Once finished
2245  *                                       with the string should be g_free()'d.
2246  *
2247  * Since: 1.6
2248  */
2249 gchar *
2250 gst_uri_get_path (const GstUri * uri)
2251 {
2252   GList *path_segment;
2253   const gchar *sep = "";
2254   GString *ret;
2255
2256   if (!uri)
2257     return NULL;
2258   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2259   if (!uri->path)
2260     return NULL;
2261
2262   ret = g_string_new (NULL);
2263
2264   for (path_segment = uri->path; path_segment;
2265       path_segment = path_segment->next) {
2266     g_string_append (ret, sep);
2267     if (path_segment->data) {
2268       g_string_append (ret, path_segment->data);
2269     }
2270     sep = "/";
2271   }
2272
2273   return g_string_free (ret, FALSE);
2274 }
2275
2276 /**
2277  * gst_uri_set_path:
2278  * @uri: (transfer none) (nullable): The #GstUri to modify.
2279  * @path: The new path to set with path segments separated by '/', or use %NULL
2280  *        to unset the path.
2281  *
2282  * Sets or unsets the path in the URI.
2283  *
2284  * Returns: %TRUE if the path was set successfully.
2285  *
2286  * Since: 1.6
2287  */
2288 gboolean
2289 gst_uri_set_path (GstUri * uri, const gchar * path)
2290 {
2291   if (!uri)
2292     return path == NULL;
2293   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2294
2295   g_list_free_full (uri->path, g_free);
2296   uri->path = _gst_uri_string_to_list (path, "/", FALSE, FALSE);
2297
2298   return TRUE;
2299 }
2300
2301 /**
2302  * gst_uri_get_path_string:
2303  * @uri: The #GstUri to get the path from.
2304  *
2305  * Extract the path string from the URI object as a percent encoded URI path.
2306  *
2307  * Returns: (transfer full) (nullable): The path from the URI. Once finished
2308  *                                      with the string should be g_free()'d.
2309  *
2310  * Since: 1.6
2311  */
2312 gchar *
2313 gst_uri_get_path_string (const GstUri * uri)
2314 {
2315   GList *path_segment;
2316   const gchar *sep = "";
2317   GString *ret;
2318   gchar *escaped;
2319
2320   if (!uri)
2321     return NULL;
2322   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2323   if (!uri->path)
2324     return NULL;
2325
2326   ret = g_string_new (NULL);
2327
2328   for (path_segment = uri->path; path_segment;
2329       path_segment = path_segment->next) {
2330     g_string_append (ret, sep);
2331     if (path_segment->data) {
2332       escaped = _gst_uri_escape_path_segment (path_segment->data);
2333       g_string_append (ret, escaped);
2334       g_free (escaped);
2335     }
2336     sep = "/";
2337   }
2338
2339   return g_string_free (ret, FALSE);
2340 }
2341
2342 /**
2343  * gst_uri_set_path_string:
2344  * @uri: (transfer none)(nullable): The #GstUri to modify.
2345  * @path: The new percent encoded path to set with path segments separated by
2346  * '/', or use %NULL to unset the path.
2347  *
2348  * Sets or unsets the path in the URI.
2349  *
2350  * Returns: %TRUE if the path was set successfully.
2351  *
2352  * Since: 1.6
2353  */
2354 gboolean
2355 gst_uri_set_path_string (GstUri * uri, const gchar * path)
2356 {
2357   if (!uri)
2358     return path == NULL;
2359   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2360
2361   g_list_free_full (uri->path, g_free);
2362   uri->path = _gst_uri_string_to_list (path, "/", FALSE, TRUE);
2363   return TRUE;
2364 }
2365
2366 /**
2367  * gst_uri_get_path_segments:
2368  * @uri: (nullable): The #GstUri to get the path from.
2369  *
2370  * Get a list of path segments from the URI.
2371  *
2372  * Returns: (transfer full) (element-type gchar*): A #GList of path segment
2373  *          strings or %NULL if no path segments are available. Free the list
2374  *          when no longer needed with g_list_free_full(list, g_free).
2375  *
2376  * Since: 1.6
2377  */
2378 GList *
2379 gst_uri_get_path_segments (const GstUri * uri)
2380 {
2381   GList *ret = NULL;
2382
2383   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2384
2385   if (uri) {
2386     ret = g_list_copy_deep (uri->path, (GCopyFunc) g_strdup, NULL);
2387   }
2388
2389   return ret;
2390 }
2391
2392 /**
2393  * gst_uri_set_path_segments:
2394  * @uri: (transfer none)(nullable): The #GstUri to modify.
2395  * @path_segments: (transfer full)(nullable)(element-type gchar*): The new
2396  *                 path list to set.
2397  *
2398  * Replace the path segments list in the URI.
2399  *
2400  * Returns: %TRUE if the path segments were set successfully.
2401  *
2402  * Since: 1.6
2403  */
2404 gboolean
2405 gst_uri_set_path_segments (GstUri * uri, GList * path_segments)
2406 {
2407   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), FALSE);
2408
2409   if (!uri) {
2410     if (path_segments)
2411       g_list_free_full (path_segments, g_free);
2412     return path_segments == NULL;
2413   }
2414
2415   g_return_val_if_fail (gst_uri_is_writable (uri), FALSE);
2416
2417   g_list_free_full (uri->path, g_free);
2418   uri->path = path_segments;
2419   return TRUE;
2420 }
2421
2422 /**
2423  * gst_uri_append_path:
2424  * @uri: (transfer none)(nullable): The #GstUri to modify.
2425  * @relative_path: Relative path to append to the end of the current path.
2426  *
2427  * Append a path onto the end of the path in the URI. The path is not
2428  * normalized, call #gst_uri_normalize() to normalize the path.
2429  *
2430  * Returns: %TRUE if the path was appended successfully.
2431  *
2432  * Since: 1.6
2433  */
2434 gboolean
2435 gst_uri_append_path (GstUri * uri, const gchar * relative_path)
2436 {
2437   GList *rel_path_list;
2438
2439   if (!uri)
2440     return relative_path == NULL;
2441   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2442   if (!relative_path)
2443     return TRUE;
2444
2445   if (uri->path) {
2446     GList *last_elem = g_list_last (uri->path);
2447     if (last_elem->data == NULL) {
2448       uri->path = g_list_delete_link (uri->path, last_elem);
2449     }
2450   }
2451   rel_path_list = _gst_uri_string_to_list (relative_path, "/", FALSE, FALSE);
2452   /* if path was absolute, make it relative by removing initial NULL element */
2453   if (rel_path_list && rel_path_list->data == NULL) {
2454     rel_path_list = g_list_delete_link (rel_path_list, rel_path_list);
2455   }
2456   uri->path = g_list_concat (uri->path, rel_path_list);
2457   return TRUE;
2458 }
2459
2460 /**
2461  * gst_uri_append_path_segment:
2462  * @uri: (transfer none)(nullable): The #GstUri to modify.
2463  * @path_segment: The path segment string to append to the URI path.
2464  *
2465  * Append a single path segment onto the end of the URI path.
2466  *
2467  * Returns: %TRUE if the path was appended successfully.
2468  *
2469  * Since: 1.6
2470  */
2471 gboolean
2472 gst_uri_append_path_segment (GstUri * uri, const gchar * path_segment)
2473 {
2474   if (!uri)
2475     return path_segment == NULL;
2476   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2477   if (!path_segment)
2478     return TRUE;
2479
2480   /* if base path ends in a directory (i.e. last element is NULL), remove it */
2481   if (uri->path && g_list_last (uri->path)->data == NULL) {
2482     uri->path = g_list_delete_link (uri->path, g_list_last (uri->path));
2483   }
2484   uri->path = g_list_append (uri->path, g_strdup (path_segment));
2485   return TRUE;
2486 }
2487
2488 /**
2489  * gst_uri_get_query_string:
2490  * @uri: (nullable): The #GstUri to get the query string from.
2491  *
2492  * Get a percent encoded URI query string from the @uri.
2493  *
2494  * Returns: (transfer full) (nullable): A percent encoded query string. Use
2495  *                                      g_free() when no longer needed.
2496  *
2497  * Since: 1.6
2498  */
2499 gchar *
2500 gst_uri_get_query_string (const GstUri * uri)
2501 {
2502   GHashTableIter iter;
2503   gpointer key, value;
2504   const gchar *sep = "";
2505   gchar *escaped;
2506   GString *ret;
2507
2508   if (!uri)
2509     return NULL;
2510   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2511   if (!uri->query)
2512     return NULL;
2513
2514   ret = g_string_new (NULL);
2515   g_hash_table_iter_init (&iter, uri->query);
2516   while (g_hash_table_iter_next (&iter, &key, &value)) {
2517     g_string_append (ret, sep);
2518     escaped = _gst_uri_escape_http_query_element (key);
2519     g_string_append (ret, escaped);
2520     g_free (escaped);
2521     if (value) {
2522       escaped = _gst_uri_escape_http_query_element (value);
2523       g_string_append_printf (ret, "=%s", escaped);
2524       g_free (escaped);
2525     }
2526     sep = "&";
2527   }
2528
2529   return g_string_free (ret, FALSE);
2530 }
2531
2532 /**
2533  * gst_uri_set_query_string:
2534  * @uri: (transfer none)(nullable): The #GstUri to modify.
2535  * @query: The new percent encoded query string to use to populate the query
2536  *        table, or use %NULL to unset the query table.
2537  *
2538  * Sets or unsets the query table in the URI.
2539  *
2540  * Returns: %TRUE if the query table was set successfully.
2541  *
2542  * Since: 1.6
2543  */
2544 gboolean
2545 gst_uri_set_query_string (GstUri * uri, const gchar * query)
2546 {
2547   if (!uri)
2548     return query == NULL;
2549
2550   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2551
2552   if (uri->query)
2553     g_hash_table_unref (uri->query);
2554   uri->query = _gst_uri_string_to_table (query, "&", "=", TRUE, TRUE);
2555
2556   return TRUE;
2557 }
2558
2559 /**
2560  * gst_uri_get_query_table:
2561  * @uri: (nullable): The #GstUri to get the query table from.
2562  *
2563  * Get the query table from the URI. Keys and values in the table are freed
2564  * with g_free when they are deleted. A value may be %NULL to indicate that
2565  * the key should appear in the query string in the URI, but does not have a
2566  * value. Free the returned #GHashTable with #g_hash_table_unref() when it is
2567  * no longer required. Modifying this hash table will modify the query in the
2568  * URI.
2569  *
2570  * Returns: (transfer full) (element-type gchar* gchar*) (nullable): The query
2571  *          hash table from the URI.
2572  *
2573  * Since: 1.6
2574  */
2575 GHashTable *
2576 gst_uri_get_query_table (const GstUri * uri)
2577 {
2578   if (!uri)
2579     return NULL;
2580   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2581   if (!uri->query)
2582     return NULL;
2583
2584   return g_hash_table_ref (uri->query);
2585 }
2586
2587 /**
2588  * gst_uri_set_query_table:
2589  * @uri: (transfer none)(nullable): The #GstUri to modify.
2590  * @query_table: (transfer none)(nullable)(element-type gchar* gchar*): The new
2591  *               query table to use.
2592  *
2593  * Set the query table to use in the URI. The old table is unreferenced and a
2594  * reference to the new one is used instead. A value if %NULL for @query_table
2595  * will remove the query string from the URI.
2596  *
2597  * Returns: %TRUE if the new table was sucessfully used for the query table.
2598  *
2599  * Since: 1.6
2600  */
2601 gboolean
2602 gst_uri_set_query_table (GstUri * uri, GHashTable * query_table)
2603 {
2604   GHashTable *old_table = NULL;
2605
2606   if (!uri)
2607     return query_table == NULL;
2608   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2609
2610   old_table = uri->query;
2611   if (query_table)
2612     uri->query = g_hash_table_ref (query_table);
2613   else
2614     uri->query = NULL;
2615   if (old_table)
2616     g_hash_table_unref (old_table);
2617
2618   return TRUE;
2619 }
2620
2621 /**
2622  * gst_uri_set_query_value:
2623  * @uri: (transfer none)(nullable): The #GstUri to modify.
2624  * @query_key: (transfer none): The key for the query entry.
2625  * @query_value: (transfer none)(nullable): The value for the key.
2626  *
2627  * This inserts or replaces a key in the query table. A @query_value of %NULL
2628  * indicates that the key has no associated value, but will still be present in
2629  * the query string.
2630  *
2631  * Returns: %TRUE if the query table was sucessfully updated.
2632  *
2633  * Since: 1.6
2634  */
2635 gboolean
2636 gst_uri_set_query_value (GstUri * uri, const gchar * query_key,
2637     const gchar * query_value)
2638 {
2639   if (!uri)
2640     return FALSE;
2641   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2642
2643   if (!uri->query) {
2644     uri->query = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
2645         g_free);
2646   }
2647   g_hash_table_insert (uri->query, g_strdup (query_key),
2648       g_strdup (query_value));
2649
2650   return TRUE;
2651 }
2652
2653 /**
2654  * gst_uri_remove_query_key:
2655  * @uri: (transfer none)(nullable): The #GstUri to modify.
2656  * @query_key: The key to remove.
2657  *
2658  * Remove an entry from the query table by key.
2659  *
2660  * Returns: %TRUE if the key existed in the table and was removed.
2661  *
2662  * Since: 1.6
2663  */
2664 gboolean
2665 gst_uri_remove_query_key (GstUri * uri, const gchar * query_key)
2666 {
2667   gboolean result;
2668
2669   if (!uri)
2670     return FALSE;
2671   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2672   if (!uri->query)
2673     return FALSE;
2674
2675   result = g_hash_table_remove (uri->query, query_key);
2676   /* if this was the last query entry, remove the query string completely */
2677   if (result && g_hash_table_size (uri->query) == 0) {
2678     g_hash_table_unref (uri->query);
2679     uri->query = NULL;
2680   }
2681   return result;
2682 }
2683
2684 /**
2685  * gst_uri_query_has_key:
2686  * @uri: (nullable): The #GstUri to examine.
2687  * @query_key: The key to lookup.
2688  *
2689  * Check if there is a query table entry for the @query_key key.
2690  *
2691  * Returns: %TRUE if @query_key exists in the URI query table.
2692  *
2693  * Since: 1.6
2694  */
2695 gboolean
2696 gst_uri_query_has_key (const GstUri * uri, const gchar * query_key)
2697 {
2698   if (!uri)
2699     return FALSE;
2700   g_return_val_if_fail (GST_IS_URI (uri), FALSE);
2701   if (!uri->query)
2702     return FALSE;
2703
2704   return g_hash_table_contains (uri->query, query_key);
2705 }
2706
2707 /**
2708  * gst_uri_get_query_value:
2709  * @uri: (nullable): The #GstUri to examine.
2710  * @query_key: The key to lookup.
2711  *
2712  * Get the value associated with the @query_key key. Will return %NULL if the
2713  * key has no value or if the key does not exist in the URI query table. Because
2714  * %NULL is returned for both missing keys and keys with no value, you should
2715  * use gst_uri_query_has_key() to determine if a key is present in the URI
2716  * query.
2717  *
2718  * Returns: (nullable): The value for the given key, or %NULL if not found.
2719  *
2720  * Since: 1.6
2721  */
2722 const gchar *
2723 gst_uri_get_query_value (const GstUri * uri, const gchar * query_key)
2724 {
2725   if (!uri)
2726     return NULL;
2727   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2728   if (!uri->query)
2729     return NULL;
2730
2731   return g_hash_table_lookup (uri->query, query_key);
2732 }
2733
2734 /**
2735  * gst_uri_get_query_keys:
2736  * @uri: (nullable): The #GstUri to examine.
2737  *
2738  * Get a list of the query keys from the URI.
2739  *
2740  * Returns: (transfer container) (element-type gchar*): A list of keys from
2741  *          the URI query. Free the list with g_list_free().
2742  *
2743  * Since: 1.6
2744  */
2745 GList *
2746 gst_uri_get_query_keys (const GstUri * uri)
2747 {
2748   if (!uri)
2749     return NULL;
2750   g_return_val_if_fail (GST_IS_URI (uri), NULL);
2751   if (!uri->query)
2752     return NULL;
2753
2754   return g_hash_table_get_keys (uri->query);
2755 }
2756
2757 /**
2758  * gst_uri_get_fragment:
2759  * @uri: (nullable): This #GstUri object.
2760  *
2761  * Get the fragment name from the URI or %NULL if it doesn't exist.
2762  * If @uri is %NULL then returns %NULL.
2763  *
2764  * Returns: (nullable): The host name from the #GstUri object or %NULL.
2765  *
2766  * Since: 1.6
2767  */
2768 const gchar *
2769 gst_uri_get_fragment (const GstUri * uri)
2770 {
2771   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2772   return (uri ? uri->fragment : NULL);
2773 }
2774
2775 /**
2776  * gst_uri_set_fragment:
2777  * @uri: (transfer none)(nullable): The #GstUri to modify.
2778  * @fragment: (nullable): The fragment string to set.
2779  *
2780  * Sets the fragment string in the URI. Use a value of %NULL in @fragment to
2781  * unset the fragment string.
2782  *
2783  * Returns: %TRUE if the fragment was set/unset successfully.
2784  *
2785  * Since: 1.6
2786  */
2787 gboolean
2788 gst_uri_set_fragment (GstUri * uri, const gchar * fragment)
2789 {
2790   if (!uri)
2791     return fragment == NULL;
2792   g_return_val_if_fail (GST_IS_URI (uri) && gst_uri_is_writable (uri), FALSE);
2793
2794   g_free (uri->fragment);
2795   uri->fragment = g_strdup (fragment);
2796   return TRUE;
2797 }
2798
2799 /**
2800  * gst_uri_get_media_fragment_table:
2801  * @uri: (nullable): The #GstUri to get the fragment table from.
2802  *
2803  * Get the media fragment table from the URI, as defined by "Media Fragments URI 1.0".
2804  * Hash table returned by this API is a list of "key-value" pairs, and the each
2805  * pair is generated by splitting "URI fragment" per "&" sub-delims, then "key"
2806  * and "value" are splitted by "=" sub-delims. The "key" returned by this API may
2807  * be undefined keyword by standard.
2808  * A value may be %NULL to indicate that the key should appear in the fragment
2809  * string in the URI, but does not have a value. Free the returned #GHashTable
2810  * with #g_hash_table_unref() when it is no longer required.
2811  * Modifying this hash table does not affect the fragment in the URI.
2812  *
2813  * See more about Media Fragments URI 1.0 (W3C) at https://www.w3.org/TR/media-frags/
2814  *
2815  * Returns: (transfer full) (element-type gchar* gchar*) (nullable): The
2816  *          fragment hash table from the URI.
2817  *
2818  * Since: 1.12
2819  */
2820 GHashTable *
2821 gst_uri_get_media_fragment_table (const GstUri * uri)
2822 {
2823   g_return_val_if_fail (uri == NULL || GST_IS_URI (uri), NULL);
2824
2825   if (!uri->fragment)
2826     return NULL;
2827   return _gst_uri_string_to_table (uri->fragment, "&", "=", TRUE, TRUE);
2828 }