/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *

 * gsturi.c: register URI handlers

 *

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

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

 * License as published by the Free Software Foundation; either

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

 *

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

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

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

 * Library General Public License for more details.

 *

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

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

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

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gsturihandler

 * @short_description: Interface to ease URI handling in plugins.

 *

 * The URIHandler is an interface that is implemented by Source and Sink 

 * #GstElement to simplify then handling of URI.

 *

 * An application can use the following functions to quickly get an element

 * that handles the given URI for reading or writing

 * (gst_element_make_from_uri()).

 *

 * Source and Sink plugins should implement this interface when possible.

 *

 * Last reviewed on 2005-11-09 (0.9.4)

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "gst_private.h"

#include "gsturi.h"

#include "gstinfo.h"

#include "gstmarshal.h"

#include "gstregistry.h"

#include <string.h>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

GST_DEBUG_CATEGORY_STATIC (gst_uri_handler_debug);

#define GST_CAT_DEFAULT gst_uri_handler_debug

static void gst_uri_handler_base_init (gpointer g_class);

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_uri_handler_get_type (void)

{

  static volatile gsize urihandler_type = 0;

  if (g_once_init_enter (&urihandler_type)) {

    GType _type;

    static const GTypeInfo urihandler_info = {

      sizeof (GstURIHandlerInterface),

      gst_uri_handler_base_init,

      NULL,

      NULL,

      NULL,

      NULL,

      0,

      0,

      NULL,

      NULL

    };

    _type = g_type_register_static (G_TYPE_INTERFACE,

        "GstURIHandler", &urihandler_info, 0);

    GST_DEBUG_CATEGORY_INIT (gst_uri_handler_debug, "GST_URI", GST_DEBUG_BOLD,

        "handling of URIs");

    g_once_init_leave (&urihandler_type, _type);

  }

  return urihandler_type;

}

static void

gst_uri_handler_base_init (gpointer g_class)

{

  static gboolean initialized = FALSE;

  if (G_UNLIKELY (!initialized)) {

    /**

     * GstURIHandler::new-uri:

     * @handler: The #GstURIHandler which emitted the signal

     * @uri: The new URI, or NULL if the URI was removed

     *

     * The URI of the given @handler has changed.

     */

    g_signal_new ("new-uri", GST_TYPE_URI_HANDLER, G_SIGNAL_RUN_LAST,

        G_STRUCT_OFFSET (GstURIHandlerInterface, new_uri), NULL, NULL,

        gst_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);

    initialized = TRUE;

  }

}

static const guchar acceptable[96] = {  /* X0   X1   X2   X3   X4   X5   X6   X7   X8   X9   XA   XB   XC   XD   XE   XF */

  0x00, 0x3F, 0x20, 0x20, 0x20, 0x00, 0x2C, 0x3F, 0x3F, 0x3F, 0x3F, 0x22, 0x20, 0x3F, 0x3F, 0x1C,       /* 2X  !"#$%&'()*+,-./   */

  0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x38, 0x20, 0x20, 0x2C, 0x20, 0x2C,       /* 3X 0123456789:;<=>?   */

  0x30, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,       /* 4X @ABCDEFGHIJKLMNO   */

  0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x3F,       /* 5X PQRSTUVWXYZ[\]^_   */

  0x20, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,       /* 6X `abcdefghijklmno   */

  0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x3F, 0x20        /* 7X pqrstuvwxyz{|}~DEL */

};

typedef enum

{

  UNSAFE_ALL = 0x1,             /* Escape all unsafe characters   */

  UNSAFE_ALLOW_PLUS = 0x2,      /* Allows '+'  */

  UNSAFE_PATH = 0x4,            /* Allows '/' and '?' and '&' and '='  */

  UNSAFE_DOS_PATH = 0x8,        /* Allows '/' and '?' and '&' and '=' and ':' */

  UNSAFE_HOST = 0x10,           /* Allows '/' and ':' and '@' */

  UNSAFE_SLASHES = 0x20         /* Allows all characters except for '/' and '%' */

} UnsafeCharacterSet;

#define HEX_ESCAPE '%'

/*  Escape undesirable characters using %

 *  -------------------------------------

 *

 * This function takes a pointer to a string in which

 * some characters may be unacceptable unescaped.

 * It returns a string which has these characters

 * represented by a '%' character followed by two hex digits.

 *

 * This routine returns a g_malloced string.

 */

static const gchar hex[16] = "0123456789ABCDEF";

static gchar *

escape_string_internal (const gchar * string, UnsafeCharacterSet mask)

{

#define ACCEPTABLE_CHAR(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask))

  const gchar *p;

  gchar *q;

  gchar *result;

  guchar c;

  gint unacceptable;

  UnsafeCharacterSet use_mask;

  g_return_val_if_fail (mask == UNSAFE_ALL

      || mask == UNSAFE_ALLOW_PLUS

      || mask == UNSAFE_PATH

      || mask == UNSAFE_DOS_PATH

      || mask == UNSAFE_HOST || mask == UNSAFE_SLASHES, NULL);

  if (string == NULL) {

    return NULL;

  }

  unacceptable = 0;

  use_mask = mask;

  for (p = string; *p != '\0'; p++) {

    c = *p;

    if (!ACCEPTABLE_CHAR (c)) {

      unacceptable++;

    }

    if ((use_mask == UNSAFE_HOST) && (unacceptable || (c == '/'))) {

      /* when escaping a host, if we hit something that needs to be escaped, or we finally

       * hit a path separator, revert to path mode (the host segment of the url is over).

       */

      use_mask = UNSAFE_PATH;

    }

  }

  result = g_malloc (p - string + unacceptable * 2 + 1);

  use_mask = mask;

  for (q = result, p = string; *p != '\0'; p++) {

    c = *p;

    if (!ACCEPTABLE_CHAR (c)) {

      *q++ = HEX_ESCAPE;        /* means hex coming */

      *q++ = hex[c >> 4];

      *q++ = hex[c & 15];

    } else {

      *q++ = c;

    }

    if ((use_mask == UNSAFE_HOST) && (!ACCEPTABLE_CHAR (c) || (c == '/'))) {

      use_mask = UNSAFE_PATH;

    }

  }

  *q = '\0';

  return result;

}

/**

 * escape_string:

 * @string: string to be escaped

 *

 * Escapes @string, replacing any and all special characters

 * with equivalent escape sequences.

 *

 * Return value: a newly allocated string equivalent to @string

 * but with all special characters escaped

 **/

static gchar *

escape_string (const gchar * string)

{

  return escape_string_internal (string, UNSAFE_ALL);

}

static int

hex_to_int (gchar c)

{

  return c >= '0' && c <= '9' ? c - '0'

      : c >= 'A' && c <= 'F' ? c - 'A' + 10

      : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1;

}

static int

unescape_character (const char *scanner)

{

  int first_digit;

  int second_digit;

  first_digit = hex_to_int (*scanner++);

  if (first_digit < 0) {

    return -1;

  }

  second_digit = hex_to_int (*scanner);

  if (second_digit < 0) {

    return -1;

  }

  return (first_digit << 4) | second_digit;

}

/**

 * unescape_string:

 * @escaped_string: an escaped URI, path, or other string

 * @illegal_characters: a string containing a sequence of characters

 * considered "illegal", '\0' is automatically in this list.

 *

 * Decodes escaped characters (i.e. PERCENTxx sequences) in @escaped_string.

 * Characters are encoded in PERCENTxy form, where xy is the ASCII hex code

 * for character 16x+y.

 *

 * Return value: a newly allocated string with the unescaped equivalents,

 * or %NULL if @escaped_string contained one of the characters

 * in @illegal_characters.

 **/

static char *

unescape_string (const gchar * escaped_string, const gchar * illegal_characters)

{

  const gchar *in;

  gchar *out, *result;

  gint character;

  if (escaped_string == NULL) {

    return NULL;

  }

  result = g_malloc (strlen (escaped_string) + 1);

  out = result;

  for (in = escaped_string; *in != '\0'; in++) {

    character = *in;

    if (*in == HEX_ESCAPE) {

      character = unescape_character (in + 1);

      /* Check for an illegal character. We consider '\0' illegal here. */

      if (character <= 0

          || (illegal_characters != NULL

              && strchr (illegal_characters, (char) character) != NULL)) {

        g_free (result);

        return NULL;

      }

      in += 2;

    }

    *out++ = (char) character;

  }

  *out = '\0';

  g_assert ((gsize) (out - result) <= strlen (escaped_string));

  return result;

}

static void

gst_uri_protocol_check_internal (const gchar * uri, gchar ** endptr)

{

  gchar *check = (gchar *) uri;

  g_assert (uri != NULL);

  g_assert (endptr != NULL);

  if (g_ascii_isalpha (*check)) {

    check++;

    while (g_ascii_isalnum (*check) || *check == '+'

        || *check == '-' || *check == '.')

      check++;

  }

  *endptr = check;

}

/**

 * gst_uri_protocol_is_valid:

 * @protocol: A string

 *

 * Tests if the given string is a valid protocol identifier. Protocols

 * must consist of alphanumeric characters, '+', '-' and '.' and must

 * start with a alphabetic character. See RFC 3986 Section 3.1.

 *

 * Returns: TRUE if the string is a valid protocol identifier, FALSE otherwise.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_uri_protocol_is_valid (const gchar * protocol)

{

  gchar *endptr;

  g_return_val_if_fail (protocol != NULL, FALSE);

  gst_uri_protocol_check_internal (protocol, &endptr);

  return *endptr == '\0' && endptr != protocol;

}

/**

 * gst_uri_is_valid:

 * @uri: A URI string

 *

 * Tests if the given string is a valid URI identifier. URIs start with a valid

 * scheme followed by ":" and maybe a string identifying the location.

 *

 * Returns: TRUE if the string is a valid URI

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_uri_is_valid (const gchar * uri)

{

  gchar *endptr;

  g_return_val_if_fail (uri != NULL, FALSE);

  gst_uri_protocol_check_internal (uri, &endptr);

  return *endptr == ':';

}

/**

 * gst_uri_get_protocol:

 * @uri: A URI string

 *

 * Extracts the protocol out of a given valid URI. The returned string must be

 * freed using g_free().

 *

 * Returns: The protocol for this URI.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gchar *

gst_uri_get_protocol (const gchar * uri)

{

  gchar *colon;

  g_return_val_if_fail (uri != NULL, NULL);

  g_return_val_if_fail (gst_uri_is_valid (uri), NULL);

  colon = strstr (uri, ":");

  return g_ascii_strdown (uri, colon - uri);

}

/**

 * gst_uri_has_protocol:

 * @uri: an URI string

 * @protocol: a protocol string (e.g. "http")

 *

 * Checks if the protocol of a given valid URI matches @protocol.

 *

 * Returns: %TRUE if the protocol matches.

 *

 * Since: 0.10.4

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_uri_has_protocol (const gchar * uri, const gchar * protocol)

{

  gchar *colon;

  g_return_val_if_fail (uri != NULL, FALSE);

  g_return_val_if_fail (protocol != NULL, FALSE);

  g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);

  colon = strstr (uri, ":");

  if (colon == NULL)

    return FALSE;

  return (g_ascii_strncasecmp (uri, protocol, (gsize) (colon - uri)) == 0);

}

/**

 * gst_uri_get_location:

 * @uri: A URI string

 *

 * Extracts the location out of a given valid URI, ie. the protocol and "://"

 * are stripped from the URI, which means that the location returned includes

 * the hostname if one is specified. The returned string must be freed using

 * g_free().

 *

 * Returns: The location for this URI. Returns NULL if the URI isn't valid. If

 * the URI does not contain a location, an empty string is returned.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gchar *

gst_uri_get_location (const gchar * uri)

{

  const gchar *colon;

  gchar *unescaped = NULL;

  g_return_val_if_fail (uri != NULL, NULL);

  g_return_val_if_fail (gst_uri_is_valid (uri), NULL);

  colon = strstr (uri, "://");

  if (!colon)

    return NULL;

  unescaped = unescape_string (colon + 3, "/");

  /* On Windows an URI might look like file:///c:/foo/bar.txt or

   * file:///c|/foo/bar.txt (some Netscape versions) and we want to

   * return c:/foo/bar.txt as location rather than /c:/foo/bar.txt.

   * Can't use g_filename_from_uri() here because it will only handle the

   * file:// protocol */

#ifdef G_OS_WIN32

  if (unescaped != NULL && unescaped[0] == '/' &&

      g_ascii_isalpha (unescaped[1]) &&

      (unescaped[2] == ':' || unescaped[2] == '|')) {

    unescaped[2] = ':';

    g_memmove (unescaped, unescaped + 1, strlen (unescaped + 1) + 1);

  }

#endif

  GST_LOG ("extracted location '%s' from URI '%s'", GST_STR_NULL (unescaped),

      uri);

  return unescaped;

}

/**

 * gst_uri_construct:

 * @protocol: Protocol for URI

 * @location: Location for URI

 *

 * Constructs a URI for a given valid protocol and location.

 *

 * Returns: a new string for this URI. Returns NULL if the given URI protocol

 * is not valid, or the given location is NULL.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gchar *

gst_uri_construct (const gchar * protocol, const gchar * location)

{

  char *escaped, *proto_lowercase;

  char *retval;

  g_return_val_if_fail (gst_uri_protocol_is_valid (protocol), NULL);

  g_return_val_if_fail (location != NULL, NULL);

  proto_lowercase = g_ascii_strdown (protocol, -1);

  escaped = escape_string (location);

  retval = g_strdup_printf ("%s://%s", proto_lowercase, escaped);

  g_free (escaped);

  g_free (proto_lowercase);

  return retval;

}

typedef struct

{

  GstURIType type;

  const gchar *protocol;

}

SearchEntry;

static gboolean

search_by_entry (GstPluginFeature * feature, gpointer search_entry)

{

  gchar **protocols;