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>
6 * gsturi.c: register URI handlers
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
25 * SECTION:gsturihandler
26 * @short_description: Interface to ease URI handling in plugins.
28 * The URIHandler is an interface that is implemented by Source and Sink
29 * #GstElement to simplify then handling of URI.
31 * An application can use the following functions to quickly get an element
32 * that handles the given URI for reading or writing
33 * (gst_element_make_from_uri()).
35 * Source and Sink plugins should implement this interface when possible.
42 #include "gst_private.h"
46 #include "gstregistry.h"
48 #include "gst-i18n-lib.h"
52 GST_DEBUG_CATEGORY_STATIC (gst_uri_handler_debug);
53 #define GST_CAT_DEFAULT gst_uri_handler_debug
56 gst_uri_handler_get_type (void)
58 static volatile gsize urihandler_type = 0;
60 if (g_once_init_enter (&urihandler_type)) {
62 static const GTypeInfo urihandler_info = {
63 sizeof (GstURIHandlerInterface),
75 _type = g_type_register_static (G_TYPE_INTERFACE,
76 "GstURIHandler", &urihandler_info, 0);
78 GST_DEBUG_CATEGORY_INIT (gst_uri_handler_debug, "GST_URI", GST_DEBUG_BOLD,
80 g_once_init_leave (&urihandler_type, _type);
82 return urihandler_type;
86 gst_uri_error_quark (void)
88 return g_quark_from_static_string ("gst-uri-error-quark");
91 static const guchar acceptable[96] = { /* X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF */
92 0x00, 0x3F, 0x20, 0x20, 0x20, 0x00, 0x2C, 0x3F, 0x3F, 0x3F, 0x3F, 0x22, 0x20, 0x3F, 0x3F, 0x1C, /* 2X !"#$%&'()*+,-./ */
93 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x38, 0x20, 0x20, 0x2C, 0x20, 0x2C, /* 3X 0123456789:;<=>? */
94 0x30, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, /* 4X @ABCDEFGHIJKLMNO */
95 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x3F, /* 5X PQRSTUVWXYZ[\]^_ */
96 0x20, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, /* 6X `abcdefghijklmno */
97 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x20, 0x3F, 0x20 /* 7X pqrstuvwxyz{|}~DEL */
102 UNSAFE_ALL = 0x1, /* Escape all unsafe characters */
103 UNSAFE_ALLOW_PLUS = 0x2, /* Allows '+' */
104 UNSAFE_PATH = 0x4, /* Allows '/' and '?' and '&' and '=' */
105 UNSAFE_DOS_PATH = 0x8, /* Allows '/' and '?' and '&' and '=' and ':' */
106 UNSAFE_HOST = 0x10, /* Allows '/' and ':' and '@' */
107 UNSAFE_SLASHES = 0x20 /* Allows all characters except for '/' and '%' */
108 } UnsafeCharacterSet;
110 #define HEX_ESCAPE '%'
112 /* Escape undesirable characters using %
113 * -------------------------------------
115 * This function takes a pointer to a string in which
116 * some characters may be unacceptable unescaped.
117 * It returns a string which has these characters
118 * represented by a '%' character followed by two hex digits.
120 * This routine returns a g_malloced string.
123 static const gchar hex[16] = "0123456789ABCDEF";
126 escape_string_internal (const gchar * string, UnsafeCharacterSet mask)
128 #define ACCEPTABLE_CHAR(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask))
135 UnsafeCharacterSet use_mask;
137 g_return_val_if_fail (mask == UNSAFE_ALL
138 || mask == UNSAFE_ALLOW_PLUS
139 || mask == UNSAFE_PATH
140 || mask == UNSAFE_DOS_PATH
141 || mask == UNSAFE_HOST || mask == UNSAFE_SLASHES, NULL);
143 if (string == NULL) {
149 for (p = string; *p != '\0'; p++) {
151 if (!ACCEPTABLE_CHAR (c)) {
154 if ((use_mask == UNSAFE_HOST) && (unacceptable || (c == '/'))) {
155 /* when escaping a host, if we hit something that needs to be escaped, or we finally
156 * hit a path separator, revert to path mode (the host segment of the url is over).
158 use_mask = UNSAFE_PATH;
162 result = g_malloc (p - string + unacceptable * 2 + 1);
165 for (q = result, p = string; *p != '\0'; p++) {
168 if (!ACCEPTABLE_CHAR (c)) {
169 *q++ = HEX_ESCAPE; /* means hex coming */
175 if ((use_mask == UNSAFE_HOST) && (!ACCEPTABLE_CHAR (c) || (c == '/'))) {
176 use_mask = UNSAFE_PATH;
186 * @string: string to be escaped
188 * Escapes @string, replacing any and all special characters
189 * with equivalent escape sequences.
191 * Return value: a newly allocated string equivalent to @string
192 * but with all special characters escaped
195 escape_string (const gchar * string)
197 return escape_string_internal (string, UNSAFE_ALL);
203 return c >= '0' && c <= '9' ? c - '0'
204 : c >= 'A' && c <= 'F' ? c - 'A' + 10
205 : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1;
209 unescape_character (const char *scanner)
214 first_digit = hex_to_int (*scanner++);
215 if (first_digit < 0) {
219 second_digit = hex_to_int (*scanner);
220 if (second_digit < 0) {
224 return (first_digit << 4) | second_digit;
228 * @escaped_string: an escaped URI, path, or other string
229 * @illegal_characters: a string containing a sequence of characters
230 * considered "illegal", '\0' is automatically in this list.
232 * Decodes escaped characters (i.e. PERCENTxx sequences) in @escaped_string.
233 * Characters are encoded in PERCENTxy form, where xy is the ASCII hex code
234 * for character 16x+y.
236 * Return value: (nullable): a newly allocated string with the
237 * unescaped equivalents, or %NULL if @escaped_string contained one of
238 * the characters in @illegal_characters.
241 unescape_string (const gchar * escaped_string, const gchar * illegal_characters)
247 if (escaped_string == NULL) {
251 result = g_malloc (strlen (escaped_string) + 1);
254 for (in = escaped_string; *in != '\0'; in++) {
256 if (*in == HEX_ESCAPE) {
257 character = unescape_character (in + 1);
259 /* Check for an illegal character. We consider '\0' illegal here. */
261 || (illegal_characters != NULL
262 && strchr (illegal_characters, (char) character) != NULL)) {
268 *out++ = (char) character;
272 g_assert ((gsize) (out - result) <= strlen (escaped_string));
279 gst_uri_protocol_check_internal (const gchar * uri, gchar ** endptr)
281 gchar *check = (gchar *) uri;
283 g_assert (uri != NULL);
284 g_assert (endptr != NULL);
286 if (g_ascii_isalpha (*check)) {
288 while (g_ascii_isalnum (*check) || *check == '+'
289 || *check == '-' || *check == '.')
297 * gst_uri_protocol_is_valid:
298 * @protocol: A string
300 * Tests if the given string is a valid protocol identifier. Protocols
301 * must consist of alphanumeric characters, '+', '-' and '.' and must
302 * start with a alphabetic character. See RFC 3986 Section 3.1.
304 * Returns: %TRUE if the string is a valid protocol identifier, %FALSE otherwise.
307 gst_uri_protocol_is_valid (const gchar * protocol)
311 g_return_val_if_fail (protocol != NULL, FALSE);
313 gst_uri_protocol_check_internal (protocol, &endptr);
315 return *endptr == '\0' && ((gsize) (endptr - protocol)) >= 2;
322 * Tests if the given string is a valid URI identifier. URIs start with a valid
323 * scheme followed by ":" and maybe a string identifying the location.
325 * Returns: %TRUE if the string is a valid URI
328 gst_uri_is_valid (const gchar * uri)
332 g_return_val_if_fail (uri != NULL, FALSE);
334 gst_uri_protocol_check_internal (uri, &endptr);
336 return *endptr == ':' && ((gsize) (endptr - uri)) >= 2;
340 * gst_uri_get_protocol:
343 * Extracts the protocol out of a given valid URI. The returned string must be
344 * freed using g_free().
346 * Returns: The protocol for this URI.
349 gst_uri_get_protocol (const gchar * uri)
353 g_return_val_if_fail (uri != NULL, NULL);
354 g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
356 colon = strstr (uri, ":");
358 return g_ascii_strdown (uri, colon - uri);
362 * gst_uri_has_protocol:
364 * @protocol: a protocol string (e.g. "http")
366 * Checks if the protocol of a given valid URI matches @protocol.
368 * Returns: %TRUE if the protocol matches.
371 gst_uri_has_protocol (const gchar * uri, const gchar * protocol)
375 g_return_val_if_fail (uri != NULL, FALSE);
376 g_return_val_if_fail (protocol != NULL, FALSE);
377 g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);
379 colon = strstr (uri, ":");
384 return (g_ascii_strncasecmp (uri, protocol, (gsize) (colon - uri)) == 0);
388 * gst_uri_get_location:
391 * Extracts the location out of a given valid URI, ie. the protocol and "://"
392 * are stripped from the URI, which means that the location returned includes
393 * the hostname if one is specified. The returned string must be freed using
396 * Free-function: g_free
398 * Returns: (transfer full): the location for this URI. Returns %NULL if the
399 * URI isn't valid. If the URI does not contain a location, an empty
400 * string is returned.
403 gst_uri_get_location (const gchar * uri)
406 gchar *unescaped = NULL;
408 g_return_val_if_fail (uri != NULL, NULL);
409 g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
411 colon = strstr (uri, "://");
415 unescaped = unescape_string (colon + 3, "/");
417 /* On Windows an URI might look like file:///c:/foo/bar.txt or
418 * file:///c|/foo/bar.txt (some Netscape versions) and we want to
419 * return c:/foo/bar.txt as location rather than /c:/foo/bar.txt.
420 * Can't use g_filename_from_uri() here because it will only handle the
421 * file:// protocol */
423 if (unescaped != NULL && unescaped[0] == '/' &&
424 g_ascii_isalpha (unescaped[1]) &&
425 (unescaped[2] == ':' || unescaped[2] == '|')) {
427 memmove (unescaped, unescaped + 1, strlen (unescaped + 1) + 1);
431 GST_LOG ("extracted location '%s' from URI '%s'", GST_STR_NULL (unescaped),
438 * @protocol: Protocol for URI
439 * @location: (transfer none): Location for URI
441 * Constructs a URI for a given valid protocol and location.
443 * Free-function: g_free
445 * Returns: (transfer full): a new string for this URI. Returns %NULL if the
446 * given URI protocol is not valid, or the given location is %NULL.
449 gst_uri_construct (const gchar * protocol, const gchar * location)
451 char *escaped, *proto_lowercase;
454 g_return_val_if_fail (gst_uri_protocol_is_valid (protocol), NULL);
455 g_return_val_if_fail (location != NULL, NULL);
457 proto_lowercase = g_ascii_strdown (protocol, -1);
458 escaped = escape_string (location);
459 retval = g_strdup_printf ("%s://%s", proto_lowercase, escaped);
461 g_free (proto_lowercase);
469 const gchar *protocol;
474 search_by_entry (GstPluginFeature * feature, gpointer search_entry)
476 const gchar *const *protocols;
477 GstElementFactory *factory;
478 SearchEntry *entry = (SearchEntry *) search_entry;
480 if (!GST_IS_ELEMENT_FACTORY (feature))
482 factory = GST_ELEMENT_FACTORY_CAST (feature);
484 if (factory->uri_type != entry->type)
487 protocols = gst_element_factory_get_uri_protocols (factory);
489 if (protocols == NULL) {
490 g_warning ("Factory '%s' implements GstUriHandler interface but returned "
491 "no supported protocols!", gst_plugin_feature_get_name (feature));
495 while (*protocols != NULL) {
496 if (g_ascii_strcasecmp (*protocols, entry->protocol) == 0)
504 sort_by_rank (GstPluginFeature * first, GstPluginFeature * second)
506 return gst_plugin_feature_get_rank (second) -
507 gst_plugin_feature_get_rank (first);
511 get_element_factories_from_uri_protocol (const GstURIType type,
512 const gchar * protocol)
514 GList *possibilities;
517 g_return_val_if_fail (protocol, NULL);
520 entry.protocol = protocol;
521 possibilities = gst_registry_feature_filter (gst_registry_get (),
522 search_by_entry, FALSE, &entry);
524 return possibilities;
528 * gst_uri_protocol_is_supported:
529 * @type: Whether to check for a source or a sink
530 * @protocol: Protocol that should be checked for (e.g. "http" or "smb")
532 * Checks if an element exists that supports the given URI protocol. Note
533 * that a positive return value does not imply that a subsequent call to
534 * gst_element_make_from_uri() is guaranteed to work.
539 gst_uri_protocol_is_supported (const GstURIType type, const gchar * protocol)
541 GList *possibilities;
543 g_return_val_if_fail (protocol, FALSE);
545 possibilities = get_element_factories_from_uri_protocol (type, protocol);
548 g_list_free (possibilities);
555 * gst_element_make_from_uri:
556 * @type: Whether to create a source or a sink
557 * @uri: URI to create an element for
558 * @elementname: (allow-none): Name of created element, can be %NULL.
559 * @error: (allow-none): address where to store error information, or %NULL.
561 * Creates an element for handling the given URI.
563 * Returns: (transfer floating): a new element or %NULL if none could be created
566 gst_element_make_from_uri (const GstURIType type, const gchar * uri,
567 const gchar * elementname, GError ** error)
569 GList *possibilities, *walk;
571 GstElement *ret = NULL;
573 g_return_val_if_fail (gst_is_initialized (), NULL);
574 g_return_val_if_fail (GST_URI_TYPE_IS_VALID (type), NULL);
575 g_return_val_if_fail (gst_uri_is_valid (uri), NULL);
576 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
578 GST_DEBUG ("type:%d, uri:%s, elementname:%s", type, uri, elementname);
580 protocol = gst_uri_get_protocol (uri);
581 possibilities = get_element_factories_from_uri_protocol (type, protocol);
583 if (!possibilities) {
584 GST_DEBUG ("No %s for URI '%s'", type == GST_URI_SINK ? "sink" : "source",
586 /* The error message isn't great, but we don't expect applications to
587 * show that error to users, but call the missing plugins functions */
588 g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
589 _("No URI handler for the %s protocol found"), protocol);
595 possibilities = g_list_sort (possibilities, (GCompareFunc) sort_by_rank);
596 walk = possibilities;
598 GstElementFactory *factory = walk->data;
599 GError *uri_err = NULL;
601 ret = gst_element_factory_create (factory, elementname);
603 GstURIHandler *handler = GST_URI_HANDLER (ret);
605 if (gst_uri_handler_set_uri (handler, uri, &uri_err))
608 GST_WARNING ("%s didn't accept URI '%s': %s", GST_OBJECT_NAME (ret), uri,
611 if (error != NULL && *error == NULL)
612 g_propagate_error (error, uri_err);
614 g_error_free (uri_err);
616 gst_object_unref (ret);
621 gst_plugin_feature_list_free (possibilities);
623 GST_LOG_OBJECT (ret, "created %s for URL '%s'",
624 type == GST_URI_SINK ? "sink" : "source", uri);
626 /* if the first handler didn't work, but we found another one that works */
628 g_clear_error (error);
634 * gst_uri_handler_get_uri_type:
635 * @handler: A #GstURIHandler.
637 * Gets the type of the given URI handler
639 * Returns: the #GstURIType of the URI handler.
640 * Returns #GST_URI_UNKNOWN if the @handler isn't implemented correctly.
643 gst_uri_handler_get_uri_type (GstURIHandler * handler)
645 GstURIHandlerInterface *iface;
648 g_return_val_if_fail (GST_IS_URI_HANDLER (handler), GST_URI_UNKNOWN);
650 iface = GST_URI_HANDLER_GET_INTERFACE (handler);
651 g_return_val_if_fail (iface != NULL, GST_URI_UNKNOWN);
652 g_return_val_if_fail (iface->get_type != NULL, GST_URI_UNKNOWN);
654 ret = iface->get_type (G_OBJECT_TYPE (handler));
655 g_return_val_if_fail (GST_URI_TYPE_IS_VALID (ret), GST_URI_UNKNOWN);
661 * gst_uri_handler_get_protocols:
662 * @handler: A #GstURIHandler.
664 * Gets the list of protocols supported by @handler. This list may not be
667 * Returns: (transfer none) (element-type utf8) (nullable): the
668 * supported protocols. Returns %NULL if the @handler isn't
669 * implemented properly, or the @handler doesn't support any
673 gst_uri_handler_get_protocols (GstURIHandler * handler)
675 GstURIHandlerInterface *iface;
676 const gchar *const *ret;
678 g_return_val_if_fail (GST_IS_URI_HANDLER (handler), NULL);
680 iface = GST_URI_HANDLER_GET_INTERFACE (handler);
681 g_return_val_if_fail (iface != NULL, NULL);
682 g_return_val_if_fail (iface->get_protocols != NULL, NULL);
684 ret = iface->get_protocols (G_OBJECT_TYPE (handler));
685 g_return_val_if_fail (ret != NULL, NULL);
691 * gst_uri_handler_get_uri:
692 * @handler: A #GstURIHandler
694 * Gets the currently handled URI.
696 * Returns: (transfer full) (nullable): the URI currently handled by
697 * the @handler. Returns %NULL if there are no URI currently
698 * handled. The returned string must be freed with g_free() when no
702 gst_uri_handler_get_uri (GstURIHandler * handler)
704 GstURIHandlerInterface *iface;
707 g_return_val_if_fail (GST_IS_URI_HANDLER (handler), NULL);
709 iface = GST_URI_HANDLER_GET_INTERFACE (handler);
710 g_return_val_if_fail (iface != NULL, NULL);
711 g_return_val_if_fail (iface->get_uri != NULL, NULL);
712 ret = iface->get_uri (handler);
714 g_return_val_if_fail (gst_uri_is_valid (ret), NULL);
720 * gst_uri_handler_set_uri:
721 * @handler: A #GstURIHandler
723 * @error: (allow-none): address where to store a #GError in case of
726 * Tries to set the URI of the given handler.
728 * Returns: %TRUE if the URI was set successfully, else %FALSE.
731 gst_uri_handler_set_uri (GstURIHandler * handler, const gchar * uri,
734 GstURIHandlerInterface *iface;
738 g_return_val_if_fail (GST_IS_URI_HANDLER (handler), FALSE);
739 g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);
740 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
742 iface = GST_URI_HANDLER_GET_INTERFACE (handler);
743 g_return_val_if_fail (iface != NULL, FALSE);
744 g_return_val_if_fail (iface->set_uri != NULL, FALSE);
746 protocol = gst_uri_get_protocol (uri);
748 if (iface->get_protocols) {
749 const gchar *const *protocols;
750 const gchar *const *p;
751 gboolean found_protocol = FALSE;
753 protocols = iface->get_protocols (G_OBJECT_TYPE (handler));
754 if (protocols != NULL) {
755 for (p = protocols; *p != NULL; ++p) {
756 if (g_ascii_strcasecmp (protocol, *p) == 0) {
757 found_protocol = TRUE;
762 if (!found_protocol) {
763 g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
764 _("URI scheme '%s' not supported"), protocol);
771 ret = iface->set_uri (handler, uri, error);
779 gst_file_utils_canonicalise_path (const gchar * path)
781 gchar **parts, **p, *clean_path;
785 GST_WARNING ("FIXME: canonicalise win32 path");
786 return g_strdup (path);
790 parts = g_strsplit (path, "/", -1);
794 if (strcmp (*p, ".") == 0) {
795 /* just move all following parts on top of this, incl. NUL terminator */
797 memmove (p, p + 1, (g_strv_length (p + 1) + 1) * sizeof (gchar *));
798 /* re-check the new current part again in the next iteration */
800 } else if (strcmp (*p, "..") == 0 && p > parts) {
801 /* just move all following parts on top of the previous part, incl.
805 memmove (p - 1, p + 1, (g_strv_length (p + 1) + 1) * sizeof (gchar *));
806 /* re-check the new current part again in the next iteration */
815 num_parts = g_strv_length (parts) + 1; /* incl. terminator */
816 parts = g_renew (gchar *, parts, num_parts + 1);
817 memmove (parts + 1, parts, num_parts * sizeof (gchar *));
818 parts[0] = g_strdup ("/");
821 clean_path = g_build_filenamev (parts);
827 file_path_contains_relatives (const gchar * path)
829 return (strstr (path, "/./") != NULL || strstr (path, "/../") != NULL ||
830 strstr (path, G_DIR_SEPARATOR_S "." G_DIR_SEPARATOR_S) != NULL ||
831 strstr (path, G_DIR_SEPARATOR_S ".." G_DIR_SEPARATOR_S) != NULL);
835 * gst_filename_to_uri:
836 * @filename: absolute or relative file name path
837 * @error: pointer to error, or %NULL
839 * Similar to g_filename_to_uri(), but attempts to handle relative file paths
840 * as well. Before converting @filename into an URI, it will be prefixed by
841 * the current working directory if it is a relative path, and then the path
842 * will be canonicalised so that it doesn't contain any './' or '../' segments.
844 * On Windows #filename should be in UTF-8 encoding.
847 gst_filename_to_uri (const gchar * filename, GError ** error)
849 gchar *abs_location = NULL;
850 gchar *uri, *abs_clean;
852 g_return_val_if_fail (filename != NULL, NULL);
853 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
855 if (g_path_is_absolute (filename)) {
856 if (!file_path_contains_relatives (filename)) {
857 uri = g_filename_to_uri (filename, NULL, error);
861 abs_location = g_strdup (filename);
865 cwd = g_get_current_dir ();
866 abs_location = g_build_filename (cwd, filename, NULL);
869 if (!file_path_contains_relatives (abs_location)) {
870 uri = g_filename_to_uri (abs_location, NULL, error);
875 /* path is now absolute, but contains '.' or '..' */
876 abs_clean = gst_file_utils_canonicalise_path (abs_location);
877 GST_LOG ("'%s' -> '%s' -> '%s'", filename, abs_location, abs_clean);
878 uri = g_filename_to_uri (abs_clean, NULL, error);
883 g_free (abs_location);
884 GST_DEBUG ("'%s' -> '%s'", filename, uri);