path: root/src/ntl-uri-map.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */

/*
 *  Nautilus
 *
 *  Copyright (C) 1999, 2000 Red Hat, Inc.
 *  Copyright (C) 2000 Eazel, Inc.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU 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
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this library; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Author: Elliot Lee <sopwith@redhat.com>
 *
 */


/* #define DEBUG_MJS 1 */

/* ntl-uri-map.c: Implementation of routines for mapping a location
   change request to a set of views and actual URL to be loaded. */

#include <config.h>
#include "ntl-uri-map.h"

#include <libnautilus-extensions/nautilus-directory.h>
#include <libnautilus-extensions/nautilus-metadata.h>
#include <libnautilus-extensions/nautilus-global-preferences.h>
#include <libnautilus-extensions/nautilus-string.h>
#include <libnautilus-extensions/nautilus-file-attributes.h>
#include <libnautilus-extensions/nautilus-file.h>
#include <libnautilus-extensions/nautilus-view-identifier.h>
#include <libnautilus-extensions/nautilus-glib-extensions.h>

#include <libgnomevfs/gnome-vfs-file-info.h>
#include <libgnomevfs/gnome-vfs-async-ops.h>

#include <liboaf/liboaf.h>

#include <sys/types.h>
#include <dirent.h>
#include <limits.h>
#include <ctype.h>
#include <string.h>

/* forward declarations */
static void add_sidebar_panel_identifiers       (NautilusNavigationInfo            *navinfo);
static void async_get_file_info_text            (GnomeVFSAsyncHandle              **handle,
                                                 const char                        *text_uri,
                                                 GnomeVFSFileInfoOptions            options,
                                                 GnomeVFSAsyncGetFileInfoCallback   callback,
                                                 gpointer                           callback_data);

/* Nautilus View Identifiers associate a component name with a user displayable name */

static NautilusNavigationResult
get_nautilus_navigation_result_from_gnome_vfs_result (GnomeVFSResult gnome_vfs_result)
{
        switch (gnome_vfs_result) {
        case GNOME_VFS_OK:
                return NAUTILUS_NAVIGATION_RESULT_OK;
        case GNOME_VFS_ERROR_NOTFOUND:
        case GNOME_VFS_ERROR_HOSTNOTFOUND:
                return NAUTILUS_NAVIGATION_RESULT_NOT_FOUND;
        case GNOME_VFS_ERROR_INVALIDURI:
                return NAUTILUS_NAVIGATION_RESULT_INVALID_URI;
        case GNOME_VFS_ERROR_NOTSUPPORTED:
                return NAUTILUS_NAVIGATION_RESULT_UNSUPPORTED_SCHEME;
        case GNOME_VFS_ERROR_GENERIC:
                /* This one has occurred at least once in the web browser component */
                return NAUTILUS_NAVIGATION_RESULT_UNSPECIFIC_ERROR;
        default:
                /* Whenever this message fires, we should consider adding a specific case
                 * to make the error as comprehensible as possible to the user. Please
                 * bug me (sullivan@eazel.com) if you see this fire and don't have the
                 * inclination to immediately make a good message yourself (tell me
                 * what GnomeVFSResult code the message reported, and what caused it to
                 * fire).
                 */
                g_message ("in ntl-uri-map.c, got unhandled GnomeVFSResult %d", gnome_vfs_result);
                return NAUTILUS_NAVIGATION_RESULT_UNSPECIFIC_ERROR;
        }
}

/* GCompareFunc-style function for checking whether a given string matches
 * the iid of a NautilusViewIdentifier. Returns 0 if there is a match.
 */
static int
check_iid (gconstpointer a, gconstpointer b)
{
	NautilusViewIdentifier *identifier;
	char *string;
        
	identifier = (NautilusViewIdentifier *)a;
	string = (char *)b;
        
	return strcmp (identifier->iid, string) != 0;
}

/**
 * set_initial_content_iid:
 * 
 * Sets the iid that will determine which content view to use when
 * a URI is displayed.
 * 
 * @navinfo: The NautilusNavigationInfo representing the URI that's about
 * to be displayed.
 * @fallback_value: The iid to use for the content view if no better
 * one can be determined.
 */
static void
set_initial_content_iid (NautilusNavigationInfo *navinfo,
			 const char *fallback_value)
{
	char *remembered_value = NULL;
	const char *value = NULL;

	g_assert (fallback_value != NULL);
	g_assert (g_list_length (navinfo->content_identifiers) > 0);

	/* NOTE: Darin doesn't like the unpredictability of this three-choice system.
	 * He'd prefer a global setting and perhaps an explicit location-specific
	 * setting that doesn't affect any other locations. Maybe we should change
	 * this to work that way.
	 */
        remembered_value = nautilus_directory_get_metadata
                (navinfo->directory, NAUTILUS_METADATA_KEY_INITIAL_VIEW, NULL);
        
        /* Use the remembered value if it's non-NULL and in the list of choices. */
        if (remembered_value != NULL) {
                if (g_list_find_custom (navinfo->content_identifiers,
                                        remembered_value, check_iid)) {
                        value = remembered_value;
                } else {
                        g_message ("Unknown iid \"%s\" stored for %s",
                                   remembered_value,
                                   navinfo->navinfo.requested_uri);
                }
        }
        
	if (value == NULL) {
		/* Can't use remembered value, use referring value if 
		 * it's non-NULL and in the list of choices. 
		 */
		if (navinfo->referring_iid != NULL) {
			if (g_list_find_custom (navinfo->content_identifiers,
                                                navinfo->referring_iid, check_iid)) {
				value = navinfo->referring_iid;
			}
		}

		/* Can't use remembered or referring value, use fallback value. */
		if (value == NULL) {
			value = fallback_value;
		}		
	}

	navinfo->initial_content_iid = g_strdup (value);

        g_free (remembered_value);
}


static char * const nautilus_sort_criteria[] = {
        /* Prefer the html view most */
        "iid == 'OAFIID:ntl_web_browser:0ce1a736-c939-4ac7-b12c-19d72bf1510b'",
        /* Prefer the icon view next */
        "iid == 'OAFIID:ntl_file_manager_icon_view:42681b21-d5ca-4837-87d2-394d88ecc058'",
        /* Prefer anything else over the loser view. */
        "iid != 'OAFIID:nautilus_content_loser:95901458-c68b-43aa-aaca-870ced11062d'",
        /* Prefer anything else over the sample view. */
        "iid != 'OAFIID:nautilus_sample_content_view:45c746bc-7d64-4346-90d5-6410463b43ae'",
        NULL};

/* It might be worth moving this to nautilus-string.h at some point. */
static char *
extract_prefix_add_suffix (const char *string, const char *separator, const char *suffix)
{
        const char *separator_position;
        int prefix_length;
        char *result;

        separator_position = strstr (string, separator);
        prefix_length = separator_position == NULL
                ? strlen (string)
                : separator_position - string;

        result = g_malloc (prefix_length + strlen(suffix) + 1);
        
        strncpy (result, string, prefix_length);
        result[prefix_length] = '\0';

        strcat (result, suffix);

        return result;
}

static char *
mime_type_get_supertype (const char *mime_type)
{
        return extract_prefix_add_suffix (mime_type, "/", "/*");
}

static char *
uri_string_get_scheme (const char *uri_string)
{
        return extract_prefix_add_suffix (uri_string, ":", "");
}

/*
 * The following routine uses metadata associated with the current url
 * to add content view components specified in the metadata. The
 * content views are specified in the string as <EXPLICIT_CONTENT_VIEW
 * IID="iid"/> elements inside the appropriate <DIRECTORY> or <FILE> element.  
 */

static void
get_explicit_content_view_iids_from_metafile (NautilusNavigationInfo *navinfo)
{
        if (navinfo->directory != NULL) {
                navinfo->explicit_iids = nautilus_directory_get_metadata_list 
                        (navinfo->directory, "EXPLICIT_CONTENT_VIEW", "IID");
        } 
}

static char *
make_oaf_query_for_explicit_content_view_iids (GList *view_iids)
{
        GList *p;
        char  *iid;
        char  *query;
        char  *old_query;

        query = NULL;

        for (p = view_iids; p != NULL; p = p->next) {
                iid = (char *) p->data;
                if (query != NULL) {
                        old_query = query;
                        query = g_strconcat (query, " OR ", NULL);
                        g_free (old_query);
                } else {
                        query = g_strdup ("(");
                }

                old_query = query;
                query = g_strdup_printf ("%s iid=='%s'", old_query, iid);
                g_free (old_query);
        }


        if (query != NULL) {
                old_query = query;
                query = g_strconcat (old_query, ")", NULL);
                g_free (old_query);
        } else {
                query = g_strdup ("false");
        }

        return query;
}

static char *
make_oaf_query_with_known_mime_type (NautilusNavigationInfo *navinfo)
{
        const char *mime_type;
        char *mime_supertype;
        char *uri_scheme;
        char *result;
        char *explicit_iid_query;

        mime_type = navinfo->navinfo.content_type;
        mime_supertype = mime_type_get_supertype (mime_type);
        uri_scheme = uri_string_get_scheme (navinfo->navinfo.requested_uri);

        explicit_iid_query = make_oaf_query_for_explicit_content_view_iids (navinfo->explicit_iids);

        result = g_strdup_printf 
                (
                 /* Check if the component has the interfaces we need.
                  * We can work with either a Nautilus ContentView, or
                  * with a Bonobo Control or Embeddable that supports
                  * one of the three persistence interfaces:
                  * PersistStream, ProgressiveDataSink, or
                  * PersistFile.
                  */
                 "((repo_ids.has_all(['IDL:Bonobo/Control:1.0',"
                                    "'IDL:Nautilus/ContentView:1.0'])"
                  "OR (repo_ids.has_one(['IDL:Bonobo/Control:1.0',"
                                        "'IDL:Bonobo/Embeddable:1.0'])"
                      "AND repo_ids.has_one(['IDL:Bonobo/PersistStream:1.0',"
                                            "'IDL:Bonobo/ProgressiveDataSink:1.0',"
                                            "'IDL:Bonobo/PersistFile:1.0'])))"
                 
                 /* Check that the component either has a specific
                  * MIME type or URI scheme. If neither is specified,
                  * then we don't trust that to mean "all MIME types
                  * and all schemes". For that, you have to do a
                  * wildcard for the MIME type or for the scheme.
                  */
                 "AND (bonobo:supported_mime_types.defined()"
                      "OR bonobo:supported_uri_schemes.defined ())"

                 /* Check that the supported MIME types include the
                  * URI's MIME type or its supertype.
                  */
                 "AND (NOT bonobo:supported_mime_types.defined()"
                      "OR bonobo:supported_mime_types.has('%s')"
                      "OR bonobo:supported_mime_types.has('%s')"
                      "OR bonobo:supported_mime_types.has('*/*'))"

                 /* Check that the supported URI schemes include the
                  * URI's scheme.
                  */
                 "AND (NOT bonobo:supported_uri_schemes.defined()"
                      "OR bonobo:supported_uri_schemes.has('%s')"
                      "OR bonobo:supported_uri_schemes.has('*'))"

                  /* Check that the component makes it clear that it's
                   * intended for Nautilus by providing a "view_as"
                   * name. We could instead support a default, but
                   * that would make components that are untested with
                   * Nautilus appear.
                   */
                 "AND nautilus:view_as_name.defined())"

                  /* Also select iids that were specifically requested
                     for this location, even if they do not otherwise
                     meet the requirements. */
                  "OR %s"

                 /* The MIME type, MIME supertype, and URI scheme for
                  * the %s above.
                  */
                 , mime_type, mime_supertype, uri_scheme

                 /* The explicit metafile iid query for the %s above. */
                 , explicit_iid_query
);

        g_free (mime_supertype);
        g_free (uri_scheme);
        g_free (explicit_iid_query);
        return result;
}

static char *
make_oaf_query_with_uri_scheme_only (NautilusNavigationInfo *navinfo)
{
        char *uri_scheme;
        char *result;
        char *explicit_iid_query;
        
        uri_scheme = uri_string_get_scheme (navinfo->navinfo.requested_uri);

        explicit_iid_query = make_oaf_query_for_explicit_content_view_iids (navinfo->explicit_iids);

        result = g_strdup_printf 
                (
                 /* Check if the component has the interfaces we need.
                  * We can work with either a Nautilus ContentView, or
                  * with a Bonobo Control or Embeddable that works on
                  * a file, which is indicated by Bonobo PersistFile.
                  */
                  "((repo_ids.has_all(['IDL:Bonobo/Control:1.0',"
                                     "'IDL:Nautilus/ContentView:1.0'])"
                   "OR (repo_ids.has_one(['IDL:Bonobo/Control:1.0',"
                                         "'IDL:Bonobo/Embeddable:1.0'])"
                       "AND repo_ids.has('IDL:Bonobo/PersistFile:1.0')))"

                  /* Check if the component supports this particular
                   * URI scheme.
                   */
                  "AND (bonobo:supported_uri_schemes.has('%s')"
                       "OR bonobo:supported_uri_schemes.has('*'))"

                  /* Check that the component doesn't require
                   * particular MIME types. Note that even saying you support "all"
                   */
                  "AND (NOT bonobo:supported_mime_types.defined())"

                  /* Check that the component makes it clear that it's
                   * intended for Nautilus by providing a "view_as"
                   * name. We could instead support a default, but
                   * that would make components that are untested with
                   * Nautilus appear.
                   */
                  "AND nautilus:view_as_name.defined())"

                 /* Also select iids that were specifically requested
                     for this location, even if they do not otherwise
                     meet the requirements. */

                  "OR %s"

                  /* The URI scheme for the %s above. */
                  , uri_scheme

                  /* The explicit metafile iid query for the %s above. */
                  , explicit_iid_query);
           

        g_free (uri_scheme);
        g_free (explicit_iid_query);

        return result;
}




static GHashTable *
file_list_to_mime_type_hash_table (GList *files)
{
        GHashTable *result;
        GList *p;
        char *mime_type;

        result = g_hash_table_new (g_str_hash, g_str_equal);

        for (p = files; p != NULL; p = p->next) {
                if (p->data != NULL) {
                        mime_type = nautilus_file_get_mime_type ((NautilusFile *) p->data);
                        
                        if (NULL != mime_type) {
                                if (g_hash_table_lookup (result, mime_type) == NULL) {
#ifdef DEBUG_MJS
                                        printf ("XXX content mime type: %s\n", mime_type);
#endif
                                        g_hash_table_insert (result, mime_type, mime_type);
                                } else {
                                        g_free (mime_type);
                                }
                        }
                }
        }

        return result;
}

static void
free_key (gpointer key, gpointer value, gpointer user_data)
{
        g_free (key);
}

static void
mime_type_hash_table_destroy (GHashTable *table)
{
        g_hash_table_foreach (table, free_key, NULL);
        g_hash_table_destroy (table);
}

static gboolean
server_matches_content_requirements (OAF_ServerInfo *server, GHashTable *type_table, GList *explicit_iids)
{
        OAF_Attribute *attr;
        GNOME_stringlist types;
        int i;

        /* Components explicitly requested in the metafile are not capability tested. */
        if (g_list_find_custom (explicit_iids, (gpointer) server->iid, (GCompareFunc) strcmp) != NULL) {
                return TRUE;
        }

        attr = oaf_server_info_attr_find (server, "nautilus:required_directory_content_mime_types");

        if (attr == NULL || attr->v._d != OAF_A_STRINGV) {
                return TRUE;
        } else {
                types = attr->v._u.value_stringv;

                for (i = 0; i < types._length; i++) {
                        if (g_hash_table_lookup (type_table, types._buffer[i]) != NULL) {
                                return TRUE;
                        }
                }
        }

        return FALSE;
}


static void
got_file_info_callback (GnomeVFSAsyncHandle *ah,
                        GList *result_list,
                        gpointer data)
{
        GnomeVFSGetFileInfoResult *file_result;
        GnomeVFSResult vfs_result_code;
        NautilusNavigationInfo *navinfo;
        NautilusNavigationCallback notify_ready;
        gpointer notify_ready_data;
        NautilusNavigationResult result_code;
        const char *fallback_iid;
        const char *query;
        OAF_ServerInfoList *oaf_result;
        CORBA_Environment ev;

        g_assert (result_list != NULL);
        g_assert (result_list->data != NULL);
        g_assert (result_list->next == NULL);

        navinfo = data;

        navinfo->ah = NULL;
        
        notify_ready = navinfo->callback;
        notify_ready_data = navinfo->callback_data;

        /* Get the content type. */
        file_result = result_list->data;
        vfs_result_code = file_result->result;

        oaf_result = NULL;
        query = NULL;

        get_explicit_content_view_iids_from_metafile (navinfo);

        if (vfs_result_code == GNOME_VFS_OK) {
                /* FIXME bugzilla.eazel.com 697: disgusting hack to make rpm view work. Why
                   is the mime type not being detected properly in the
                   first place? */

                if (nautilus_str_has_suffix (navinfo->navinfo.requested_uri, ".rpm")) {
                        navinfo->navinfo.content_type = g_strdup ("application/x-rpm");
                } else {
                        navinfo->navinfo.content_type = g_strdup
                                (gnome_vfs_file_info_get_mime_type (file_result->file_info));
                }

                /* FIXME bugzilla.eazel.com 699: 
                   hack for lack of good type descriptions. Can
                   we remove this now? */

                if (navinfo->navinfo.content_type == NULL) {
                        navinfo->navinfo.content_type = g_strdup ("text/plain");
                }

                /* activate by scheme and mime type */

                query = make_oaf_query_with_known_mime_type (navinfo);
        } else if (vfs_result_code == GNOME_VFS_ERROR_NOTSUPPORTED
                   || vfs_result_code == GNOME_VFS_ERROR_INVALIDURI) {
                /* Activate by scheme only */

                query = make_oaf_query_with_uri_scheme_only (navinfo);
        } else {
                goto out;
        }

        CORBA_exception_init (&ev);

#ifdef DEBUG_MJS
        printf ("query: \"%s\"\n", query);
#endif

        oaf_result = oaf_query (query, nautilus_sort_criteria, &ev);
        
        if (ev._major == CORBA_NO_EXCEPTION && oaf_result != NULL && oaf_result->_length > 0) {
                GHashTable *content_types;
                int i;
                
                content_types = file_list_to_mime_type_hash_table (navinfo->files);
                
                CORBA_exception_free (&ev);
                
                vfs_result_code = GNOME_VFS_OK;
                
                for (i = 0; i < oaf_result->_length; i++) {
                        OAF_ServerInfo *server;

                        server = &oaf_result->_buffer[i];

                        if (server_matches_content_requirements (server, content_types, navinfo->explicit_iids)) {
                                navinfo->content_identifiers = g_list_append
                                        (navinfo->content_identifiers, 
                                         nautilus_view_identifier_new_from_content_view (server));
                        }
                }

                mime_type_hash_table_destroy (content_types);
        } else {
                CORBA_exception_free (&ev);
                result_code = NAUTILUS_NAVIGATION_RESULT_NO_HANDLER_FOR_TYPE;
                goto out;
        }


        /* Map GnomeVFSResult to one of the types that Nautilus knows how to handle. */
        result_code = get_nautilus_navigation_result_from_gnome_vfs_result (vfs_result_code);

        if (vfs_result_code != GNOME_VFS_OK) {
                /* Leave navinfo intact so notify_ready function can access the uri.
                 * (notify_ready function is responsible for freeing navinfo).
                 */
                goto out;
        }
               
        if (navinfo->content_identifiers) {
                fallback_iid = ((NautilusViewIdentifier *)
                                (navinfo->content_identifiers->data))->iid;
#ifdef DEBUG_MJS
                printf ("XXX - fallback_iid: %s\n", fallback_iid);
#endif
        }
  
        add_sidebar_panel_identifiers (navinfo);
        
        /* Now that all the content_identifiers are in place, we're ready to choose
         * the initial one.
         */
        g_assert (fallback_iid != NULL);
        set_initial_content_iid (navinfo, fallback_iid);
        
 out:
        (* notify_ready) (result_code, navinfo, notify_ready_data);
}

/* The following routine uses metadata associated with the current url to add content view components specified in the metadata */


static gboolean
sidebar_panel_preference_is_on (NautilusViewIdentifier *identifier,
                                gpointer ignore)
{
        gchar *pref_name;
        gboolean enabled;

        pref_name = g_strconcat ("/nautilus/metaviews/", identifier->iid, NULL);
        enabled = nautilus_preferences_get_boolean (pref_name, FALSE);
        g_free (pref_name);

        return enabled;
}


static void
add_sidebar_panel_identifiers (NautilusNavigationInfo *navinfo)
{
	GList *view_identifiers;
	GList *disabled_view_identifiers;
        
	g_assert (navinfo != NULL);
	
	view_identifiers = nautilus_global_preferences_get_sidebar_panel_view_identifiers ();
        
        view_identifiers = nautilus_g_list_partition (view_identifiers,
                                                      (NautilusGPredicateFunc) sidebar_panel_preference_is_on,
                                                      NULL,
                                                      &disabled_view_identifiers);

        navinfo->sidebar_panel_identifiers = view_identifiers;

        nautilus_view_identifier_free_list (disabled_view_identifiers);
}

static void
got_metadata_callback (NautilusDirectory *directory,
                       GList *files,
                       gpointer callback_data)
{
        NautilusNavigationInfo *info;

        info = callback_data;
        g_assert (info->directory == directory);
        
        info->files = nautilus_file_list_copy (files);
        async_get_file_info_text (&info->ah,
                                  info->navinfo.requested_uri,
                                  (GNOME_VFS_FILE_INFO_GETMIMETYPE
                                   | GNOME_VFS_FILE_INFO_FOLLOWLINKS),
                                  got_file_info_callback,
                                  info);
}

/* NautilusNavigationInfo */

NautilusNavigationInfo *
nautilus_navigation_info_new (Nautilus_NavigationRequestInfo *nri,
                              Nautilus_NavigationInfo *old_info,
                              NautilusNavigationCallback notify_when_ready,
                              gpointer notify_data,
                              const char *referring_iid)
{
        NautilusNavigationInfo *info;
        GList *attributes;

        info = g_new0 (NautilusNavigationInfo, 1);
        
        info->callback = notify_when_ready;
        info->callback_data = notify_data;
        
        if (old_info != NULL) {
                info->navinfo.referring_uri = old_info->requested_uri;
                info->navinfo.actual_referring_uri = old_info->actual_uri;
                info->navinfo.referring_content_type = old_info->content_type;
        }

        info->referring_iid = g_strdup (referring_iid);
        info->navinfo.requested_uri = g_strdup (nri->requested_uri);

        info->directory = nautilus_directory_get (nri->requested_uri);

        /* Arrange for all the file attributes we will need. */
        attributes = NULL;
        attributes = g_list_prepend (attributes, NAUTILUS_FILE_ATTRIBUTE_FAST_MIME_TYPE);
        
        nautilus_directory_call_when_ready
                (info->directory,
                 attributes, TRUE,
                 got_metadata_callback, info);
        
        g_list_free (attributes);
        
        return info;
}

void
nautilus_navigation_info_cancel (NautilusNavigationInfo *info)
{
        g_return_if_fail (info != NULL);

        if (info->ah != NULL) {
                gnome_vfs_async_cancel (info->ah);
                info->ah = NULL;
        }

        nautilus_directory_cancel_callback
                (info->directory,
                 got_metadata_callback,
                 info);
}

void
nautilus_navigation_info_free (NautilusNavigationInfo *info)
{
        g_return_if_fail (info != NULL);
        
        nautilus_navigation_info_cancel (info);

        nautilus_view_identifier_free_list (info->sidebar_panel_identifiers);
        nautilus_view_identifier_free_list (info->content_identifiers);
        nautilus_g_list_free_deep (info->explicit_iids);

        g_free (info->referring_iid);
        g_free (info->initial_content_iid);
        g_free (info->navinfo.requested_uri);
        g_free (info->navinfo.actual_uri);
        g_free (info->navinfo.content_type);

        nautilus_directory_unref (info->directory);
        nautilus_file_list_free (info->files);

        g_free (info);
}

/* Cover for getting file info for one file. */
static void
async_get_file_info_text (GnomeVFSAsyncHandle **handle,
                          const char *text_uri,
                          GnomeVFSFileInfoOptions options,
                          GnomeVFSAsyncGetFileInfoCallback callback,
                          gpointer callback_data)
{
        GnomeVFSURI *vfs_uri;
        GList uri_list;
        GList result_list;
        GnomeVFSGetFileInfoResult result_item;
        
        vfs_uri = gnome_vfs_uri_new (text_uri);
        if (vfs_uri == NULL) {
                /* Report the error. */

                *handle = NULL;
                
                result_item.uri = NULL;
                result_item.result = GNOME_VFS_ERROR_INVALIDURI;
                result_item.file_info = NULL;
                
                result_list.data = &result_item;
                result_list.next = NULL;
                
                (* callback) (NULL, &result_list, callback_data);
                
                return;
        }

        /* Construct a simple URI list. */
        uri_list.data = vfs_uri;
        uri_list.next = NULL;

        gnome_vfs_async_get_file_info (handle,
                                       &uri_list,
                                       options,
                                       NULL,
                                       callback,
                                       callback_data);
        
        gnome_vfs_uri_unref (vfs_uri);
}