gio/gcontenttype-win32.c - third_party/glib - Git at Google

 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

 /* GIO - GLib Input, Output and Streaming Library
  *
  * Copyright (C) 2006-2007 Red Hat, Inc.
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General
  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  *
  * Author: Alexander Larsson <alexl@redhat.com>
  */

 #include "config.h"
 #include <sys/types.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include "gcontenttype.h"
 #include "gthemedicon.h"
 #include "gicon.h"
 #include "glibintl.h"

 #include <windows.h>

 static char *
 get_registry_classes_key (const char    *subdir,
                           const wchar_t *key_name)
 {
   wchar_t *wc_key;
   HKEY reg_key = NULL;
   DWORD key_type;
   DWORD nbytes;
   char *value_utf8;

   value_utf8 = NULL;

   nbytes = 0;
   wc_key = g_utf8_to_utf16 (subdir, -1, NULL, NULL, NULL);
   if (RegOpenKeyExW (HKEY_CLASSES_ROOT, wc_key, 0,
                      KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS &&
       RegQueryValueExW (reg_key, key_name, 0,
                         &key_type, NULL, &nbytes) == ERROR_SUCCESS &&
       (key_type == REG_SZ || key_type == REG_EXPAND_SZ))
     {
       wchar_t *wc_temp = g_new (wchar_t, (nbytes+1)/2 + 1);
       RegQueryValueExW (reg_key, key_name, 0,
                         &key_type, (LPBYTE) wc_temp, &nbytes);
       wc_temp[nbytes/2] = '\0';
       if (key_type == REG_EXPAND_SZ)
         {
           wchar_t dummy[1];
           DWORD len = ExpandEnvironmentStringsW (wc_temp, dummy, 1);
           if (len > 0)
             {
               wchar_t *wc_temp_expanded = g_new (wchar_t, len);
               if (ExpandEnvironmentStringsW (wc_temp, wc_temp_expanded, len) == len)
                 value_utf8 = g_utf16_to_utf8 (wc_temp_expanded, -1, NULL, NULL, NULL);
               g_free (wc_temp_expanded);
             }
         }
       else
         {
           value_utf8 = g_utf16_to_utf8 (wc_temp, -1, NULL, NULL, NULL);
         }
       g_free (wc_temp);

     }
   g_free (wc_key);

   if (reg_key != NULL)
     RegCloseKey (reg_key);

   return value_utf8;
 }

 /*< private >*/
 void
 g_content_type_set_mime_dirs (const gchar * const *dirs)
 {
   /* noop on Windows */
 }

 /*< private >*/
 const gchar * const *
 g_content_type_get_mime_dirs (void)
 {
   const gchar * const *mime_dirs = { NULL };
   return mime_dirs;
 }

 gboolean
 g_content_type_equals (const gchar *type1,
                        const gchar *type2)
 {
   char *progid1, *progid2;
   gboolean res;

   g_return_val_if_fail (type1 != NULL, FALSE);
   g_return_val_if_fail (type2 != NULL, FALSE);

   if (g_ascii_strcasecmp (type1, type2) == 0)
     return TRUE;

   res = FALSE;
   progid1 = get_registry_classes_key (type1, NULL);
   progid2 = get_registry_classes_key (type2, NULL);
   if (progid1 != NULL && progid2 != NULL &&
       strcmp (progid1, progid2) == 0)
     res = TRUE;
   g_free (progid1);
   g_free (progid2);

   return res;
 }

 gboolean
 g_content_type_is_a (const gchar *type,
                      const gchar *supertype)
 {
   gboolean res;
   char *perceived_type;
   char *perceived_supertype;

   g_return_val_if_fail (type != NULL, FALSE);
   g_return_val_if_fail (supertype != NULL, FALSE);

   if (g_content_type_equals (type, supertype))
     return TRUE;

   perceived_type = get_registry_classes_key (type, L"PerceivedType");
   perceived_supertype = get_registry_classes_key (supertype, L"PerceivedType");

   res = perceived_type && perceived_supertype &&
     strcmp (perceived_type, perceived_supertype) == 0;

   g_free (perceived_type);
   g_free (perceived_supertype);

   return res;
 }

 gboolean
 g_content_type_is_mime_type (const gchar *type,
                              const gchar *mime_type)
 {
   gchar *content_type;
   gboolean ret;

   g_return_val_if_fail (type != NULL, FALSE);
   g_return_val_if_fail (mime_type != NULL, FALSE);

   content_type = g_content_type_from_mime_type (mime_type);
   ret = g_content_type_is_a (type, content_type);
   g_free (content_type);

   return ret;
 }

 gboolean
 g_content_type_is_unknown (const gchar *type)
 {
   g_return_val_if_fail (type != NULL, FALSE);

   return strcmp ("*", type) == 0;
 }

 gchar *
 g_content_type_get_description (const gchar *type)
 {
   char *progid;
   char *description;

   g_return_val_if_fail (type != NULL, NULL);

   progid = get_registry_classes_key (type, NULL);
   if (progid)
     {
       description = get_registry_classes_key (progid, NULL);
       g_free (progid);

       if (description)
         return description;
     }

   if (g_content_type_is_unknown (type))
     return g_strdup (_("Unknown type"));

   return g_strdup_printf (_("%s filetype"), type);
 }

 gchar *
 g_content_type_get_mime_type (const gchar *type)
 {
   char *mime;

   g_return_val_if_fail (type != NULL, NULL);

   mime = get_registry_classes_key (type, L"Content Type");
   if (mime)
     return mime;
   else if (g_content_type_is_unknown (type))
     return g_strdup ("application/octet-stream");
   else if (*type == '.')
     return g_strdup_printf ("application/x-ext-%s", type+1);
   else if (strcmp ("inode/directory", type) == 0)
     return g_strdup (type);
   /* TODO: Map "image" to "image/ *", etc? */

   return g_strdup ("application/octet-stream");
 }

 G_LOCK_DEFINE_STATIC (_type_icons);
 static GHashTable *_type_icons = NULL;

 GIcon *
 g_content_type_get_icon (const gchar *type)
 {
   GIcon *themed_icon;
   char *name = NULL;

   g_return_val_if_fail (type != NULL, NULL);

   /* In the Registry icons are the default value of
      HKEY_CLASSES_ROOT\<progid>\DefaultIcon with typical values like:
      <type>: <value>
      REG_EXPAND_SZ: %SystemRoot%\System32\Wscript.exe,3
      REG_SZ: shimgvw.dll,3
   */
   G_LOCK (_type_icons);
   if (!_type_icons)
     _type_icons = g_hash_table_new (g_str_hash, g_str_equal);
   name = g_hash_table_lookup (_type_icons, type);
   if (!name && type[0] == '.')
     {
       /* double lookup by extension */
       gchar *key = get_registry_classes_key (type, NULL);
       if (!key)
         key = g_strconcat (type+1, "file\\DefaultIcon", NULL);
       else
         {
           gchar *key2 = g_strconcat (key, "\\DefaultIcon", NULL);
           g_free (key);
           key = key2;
         }
       name = get_registry_classes_key (key, NULL);
       if (name && strcmp (name, "%1") == 0)
         {
           g_free (name);
           name = NULL;
         }
       if (name)
         g_hash_table_insert (_type_icons, g_strdup (type), g_strdup (name));
       g_free (key);
     }

   if (!name)
     {
       /* if no icon found, fall back to standard generic names */
       if (strcmp (type, "inode/directory") == 0)
         name = "folder";
       else if (g_content_type_can_be_executable (type))
         name = "system-run";
       else
         name = "text-x-generic";
       g_hash_table_insert (_type_icons, g_strdup (type), g_strdup (name));
     }
   themed_icon = g_themed_icon_new (name);
   G_UNLOCK (_type_icons);

   return G_ICON (themed_icon);
 }

 GIcon *
 g_content_type_get_symbolic_icon (const gchar *type)
 {
   return g_content_type_get_icon (type);
 }

 gchar *
 g_content_type_get_generic_icon_name (const gchar *type)
 {
   return NULL;
 }

 gboolean
 g_content_type_can_be_executable (const gchar *type)
 {
   g_return_val_if_fail (type != NULL, FALSE);

   if (strcmp (type, ".exe") == 0 ||
       strcmp (type, ".com") == 0 ||
       strcmp (type, ".bat") == 0)
     return TRUE;

   /* TODO: Also look at PATHEXT, which lists the extensions for
    * "scripts" in addition to those for true binary executables.
    *
    * (PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH for me
    * right now, for instance). And in a sense, all associated file
    * types are "executable" on Windows... You can just type foo.jpg as
    * a command name in cmd.exe, and it will run the application
    * associated with .jpg. Hard to say what this API actually means
    * with "executable".
    */

   return FALSE;
 }

 static gboolean
 looks_like_text (const guchar *data,
                  gsize         data_size)
 {
   gsize i;
   guchar c;
   for (i = 0; i < data_size; i++)
     {
       c = data[i];
       if (g_ascii_iscntrl (c) && !g_ascii_isspace (c) && c != '\b')
         return FALSE;
     }
   return TRUE;
 }

 gchar *
 g_content_type_from_mime_type (const gchar *mime_type)
 {
   char *key, *content_type;

   g_return_val_if_fail (mime_type != NULL, NULL);

   /* This is a hack to allow directories to have icons in filechooser */
   if (strcmp ("inode/directory", mime_type) == 0)
     return g_strdup (mime_type);

   key = g_strconcat ("MIME\\DataBase\\Content Type\\", mime_type, NULL);
   content_type = get_registry_classes_key (key, L"Extension");
   g_free (key);


   return content_type ? g_steal_pointer (&content_type) : g_strdup ("*");
 }

 gchar *
 g_content_type_guess (const gchar  *filename,
                       const guchar *data,
                       gsize         data_size,
                       gboolean     *result_uncertain)
 {
   char *basename;
   char *type;
   char *dot;
   size_t i;

   type = NULL;

   if (result_uncertain)
     *result_uncertain = FALSE;

   /* our test suite and potentially other code used -1 in the past, which is
    * not documented and not allowed; guard against that */
   g_return_val_if_fail (data_size != (gsize) -1, g_strdup ("*"));

   if (filename)
     {
       i = strlen (filename);
       if (i > 0 && filename[i - 1] == G_DIR_SEPARATOR)
         {
           type = g_strdup ("inode/directory");
           if (result_uncertain)
             *result_uncertain = TRUE;
         }
       else
         {
           basename = g_path_get_basename (filename);
           dot = strrchr (basename, '.');
           if (dot)
             type = g_strdup (dot);
           g_free (basename);
         }
     }

   if (type)
     return type;

   if (data && looks_like_text (data, data_size))
     return g_strdup (".txt");

   return g_strdup ("*");
 }

 GList *
 g_content_types_get_registered (void)
 {
   DWORD index;
   wchar_t keyname[256];
   DWORD key_len;
   char *key_utf8;
   GList *types;

   types = NULL;
   index = 0;
   key_len = 256;
   while (RegEnumKeyExW(HKEY_CLASSES_ROOT,
                        index,
                        keyname,
                        &key_len,
                        NULL,
                        NULL,
                        NULL,
                        NULL) == ERROR_SUCCESS)
     {
       key_utf8 = g_utf16_to_utf8 (keyname, -1, NULL, NULL, NULL);
       if (key_utf8)
         {
           if (*key_utf8 == '.')
             types = g_list_prepend (types, key_utf8);
           else
             g_free (key_utf8);
         }
       index++;
       key_len = 256;
     }

   return g_list_reverse (types);
 }

 gchar **
 g_content_type_guess_for_tree (GFile *root)
 {
   /* FIXME: implement */
   return NULL;
 }
	/* -- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -- */

	/* GIO - GLib Input, Output and Streaming Library
	*
	* Copyright (C) 2006-2007 Red Hat, Inc.
	*
	* SPDX-License-Identifier: LGPL-2.1-or-later
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 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
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General
	* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
	*
	* Author: Alexander Larsson <alexl@redhat.com>
	*/

	#include "config.h"
	#include <sys/types.h>
	#include <stdlib.h>
	#include <string.h>
	#include <stdio.h>
	#include "gcontenttype.h"
	#include "gthemedicon.h"
	#include "gicon.h"
	#include "glibintl.h"

	#include <windows.h>

	static char *
	get_registry_classes_key (const char *subdir,
	const wchar_t *key_name)
	{
	wchar_t *wc_key;
	HKEY reg_key = NULL;
	DWORD key_type;
	DWORD nbytes;
	char *value_utf8;

	value_utf8 = NULL;

	nbytes = 0;
	wc_key = g_utf8_to_utf16 (subdir, -1, NULL, NULL, NULL);
	if (RegOpenKeyExW (HKEY_CLASSES_ROOT, wc_key, 0,
	KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS &&
	RegQueryValueExW (reg_key, key_name, 0,
	&key_type, NULL, &nbytes) == ERROR_SUCCESS &&
	(key_type == REG_SZ \|\| key_type == REG_EXPAND_SZ))
	{
	wchar_t *wc_temp = g_new (wchar_t, (nbytes+1)/2 + 1);
	RegQueryValueExW (reg_key, key_name, 0,
	&key_type, (LPBYTE) wc_temp, &nbytes);
	wc_temp[nbytes/2] = '\0';
	if (key_type == REG_EXPAND_SZ)
	{
	wchar_t dummy[1];
	DWORD len = ExpandEnvironmentStringsW (wc_temp, dummy, 1);
	if (len > 0)
	{
	wchar_t *wc_temp_expanded = g_new (wchar_t, len);
	if (ExpandEnvironmentStringsW (wc_temp, wc_temp_expanded, len) == len)
	value_utf8 = g_utf16_to_utf8 (wc_temp_expanded, -1, NULL, NULL, NULL);
	g_free (wc_temp_expanded);
	}
	}
	else
	{
	value_utf8 = g_utf16_to_utf8 (wc_temp, -1, NULL, NULL, NULL);
	}
	g_free (wc_temp);

	}
	g_free (wc_key);

	if (reg_key != NULL)
	RegCloseKey (reg_key);

	return value_utf8;
	}

	/< private >/
	void
	g_content_type_set_mime_dirs (const gchar * const *dirs)
	{
	/* noop on Windows */
	}

	/< private >/
	const gchar * const *
	g_content_type_get_mime_dirs (void)
	{
	const gchar * const *mime_dirs = { NULL };
	return mime_dirs;
	}

	gboolean
	g_content_type_equals (const gchar *type1,
	const gchar *type2)
	{
	char progid1, progid2;
	gboolean res;

	g_return_val_if_fail (type1 != NULL, FALSE);
	g_return_val_if_fail (type2 != NULL, FALSE);

	if (g_ascii_strcasecmp (type1, type2) == 0)
	return TRUE;

	res = FALSE;
	progid1 = get_registry_classes_key (type1, NULL);
	progid2 = get_registry_classes_key (type2, NULL);
	if (progid1 != NULL && progid2 != NULL &&
	strcmp (progid1, progid2) == 0)
	res = TRUE;
	g_free (progid1);
	g_free (progid2);

	return res;
	}

	gboolean
	g_content_type_is_a (const gchar *type,
	const gchar *supertype)
	{
	gboolean res;
	char *perceived_type;
	char *perceived_supertype;

	g_return_val_if_fail (type != NULL, FALSE);
	g_return_val_if_fail (supertype != NULL, FALSE);

	if (g_content_type_equals (type, supertype))
	return TRUE;

	perceived_type = get_registry_classes_key (type, L"PerceivedType");
	perceived_supertype = get_registry_classes_key (supertype, L"PerceivedType");

	res = perceived_type && perceived_supertype &&
	strcmp (perceived_type, perceived_supertype) == 0;

	g_free (perceived_type);
	g_free (perceived_supertype);

	return res;
	}

	gboolean
	g_content_type_is_mime_type (const gchar *type,
	const gchar *mime_type)
	{
	gchar *content_type;
	gboolean ret;

	g_return_val_if_fail (type != NULL, FALSE);
	g_return_val_if_fail (mime_type != NULL, FALSE);

	content_type = g_content_type_from_mime_type (mime_type);
	ret = g_content_type_is_a (type, content_type);
	g_free (content_type);

	return ret;
	}

	gboolean
	g_content_type_is_unknown (const gchar *type)
	{
	g_return_val_if_fail (type != NULL, FALSE);

	return strcmp ("*", type) == 0;
	}

	gchar *
	g_content_type_get_description (const gchar *type)
	{
	char *progid;
	char *description;

	g_return_val_if_fail (type != NULL, NULL);

	progid = get_registry_classes_key (type, NULL);
	if (progid)
	{
	description = get_registry_classes_key (progid, NULL);
	g_free (progid);

	if (description)
	return description;
	}

	if (g_content_type_is_unknown (type))
	return g_strdup (_("Unknown type"));

	return g_strdup_printf (_("%s filetype"), type);
	}

	gchar *
	g_content_type_get_mime_type (const gchar *type)
	{
	char *mime;

	g_return_val_if_fail (type != NULL, NULL);

	mime = get_registry_classes_key (type, L"Content Type");
	if (mime)
	return mime;
	else if (g_content_type_is_unknown (type))
	return g_strdup ("application/octet-stream");
	else if (*type == '.')
	return g_strdup_printf ("application/x-ext-%s", type+1);
	else if (strcmp ("inode/directory", type) == 0)
	return g_strdup (type);
	/* TODO: Map "image" to "image/ ", etc? /

	return g_strdup ("application/octet-stream");
	}

	G_LOCK_DEFINE_STATIC (_type_icons);
	static GHashTable *_type_icons = NULL;

	GIcon *
	g_content_type_get_icon (const gchar *type)
	{
	GIcon *themed_icon;
	char *name = NULL;

	g_return_val_if_fail (type != NULL, NULL);

	/* In the Registry icons are the default value of
	HKEY_CLASSES_ROOT\<progid>\DefaultIcon with typical values like:
	<type>: <value>
	REG_EXPAND_SZ: %SystemRoot%\System32\Wscript.exe,3
	REG_SZ: shimgvw.dll,3
	*/
	G_LOCK (_type_icons);
	if (!_type_icons)
	_type_icons = g_hash_table_new (g_str_hash, g_str_equal);
	name = g_hash_table_lookup (_type_icons, type);
	if (!name && type[0] == '.')
	{
	/* double lookup by extension */
	gchar *key = get_registry_classes_key (type, NULL);
	if (!key)
	key = g_strconcat (type+1, "file\\DefaultIcon", NULL);
	else
	{
	gchar *key2 = g_strconcat (key, "\\DefaultIcon", NULL);
	g_free (key);
	key = key2;
	}
	name = get_registry_classes_key (key, NULL);
	if (name && strcmp (name, "%1") == 0)
	{
	g_free (name);
	name = NULL;
	}
	if (name)
	g_hash_table_insert (_type_icons, g_strdup (type), g_strdup (name));
	g_free (key);
	}

	if (!name)
	{
	/* if no icon found, fall back to standard generic names */
	if (strcmp (type, "inode/directory") == 0)
	name = "folder";
	else if (g_content_type_can_be_executable (type))
	name = "system-run";
	else
	name = "text-x-generic";
	g_hash_table_insert (_type_icons, g_strdup (type), g_strdup (name));
	}
	themed_icon = g_themed_icon_new (name);
	G_UNLOCK (_type_icons);

	return G_ICON (themed_icon);
	}

	GIcon *
	g_content_type_get_symbolic_icon (const gchar *type)
	{
	return g_content_type_get_icon (type);
	}

	gchar *
	g_content_type_get_generic_icon_name (const gchar *type)
	{
	return NULL;
	}

	gboolean
	g_content_type_can_be_executable (const gchar *type)
	{
	g_return_val_if_fail (type != NULL, FALSE);

	if (strcmp (type, ".exe") == 0 \|\|
	strcmp (type, ".com") == 0 \|\|
	strcmp (type, ".bat") == 0)
	return TRUE;

	/* TODO: Also look at PATHEXT, which lists the extensions for
	* "scripts" in addition to those for true binary executables.
	*
	* (PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH for me
	* right now, for instance). And in a sense, all associated file
	* types are "executable" on Windows... You can just type foo.jpg as
	* a command name in cmd.exe, and it will run the application
	* associated with .jpg. Hard to say what this API actually means
	* with "executable".
	*/

	return FALSE;
	}

	static gboolean
	looks_like_text (const guchar *data,
	gsize data_size)
	{
	gsize i;
	guchar c;
	for (i = 0; i < data_size; i++)
	{
	c = data[i];
	if (g_ascii_iscntrl (c) && !g_ascii_isspace (c) && c != '\b')
	return FALSE;
	}
	return TRUE;
	}

	gchar *
	g_content_type_from_mime_type (const gchar *mime_type)
	{
	char key, content_type;

	g_return_val_if_fail (mime_type != NULL, NULL);

	/* This is a hack to allow directories to have icons in filechooser */
	if (strcmp ("inode/directory", mime_type) == 0)
	return g_strdup (mime_type);

	key = g_strconcat ("MIME\\DataBase\\Content Type\\", mime_type, NULL);
	content_type = get_registry_classes_key (key, L"Extension");
	g_free (key);


	return content_type ? g_steal_pointer (&content_type) : g_strdup ("*");
	}

	gchar *
	g_content_type_guess (const gchar *filename,
	const guchar *data,
	gsize data_size,
	gboolean *result_uncertain)
	{
	char *basename;
	char *type;
	char *dot;
	size_t i;

	type = NULL;

	if (result_uncertain)
	*result_uncertain = FALSE;

	/* our test suite and potentially other code used -1 in the past, which is
	* not documented and not allowed; guard against that */
	g_return_val_if_fail (data_size != (gsize) -1, g_strdup ("*"));

	if (filename)
	{
	i = strlen (filename);
	if (i > 0 && filename[i - 1] == G_DIR_SEPARATOR)
	{
	type = g_strdup ("inode/directory");
	if (result_uncertain)
	*result_uncertain = TRUE;
	}
	else
	{
	basename = g_path_get_basename (filename);
	dot = strrchr (basename, '.');
	if (dot)
	type = g_strdup (dot);
	g_free (basename);
	}
	}

	if (type)
	return type;

	if (data && looks_like_text (data, data_size))
	return g_strdup (".txt");

	return g_strdup ("*");
	}

	GList *
	g_content_types_get_registered (void)
	{
	DWORD index;
	wchar_t keyname[256];
	DWORD key_len;
	char *key_utf8;
	GList *types;

	types = NULL;
	index = 0;
	key_len = 256;
	while (RegEnumKeyExW(HKEY_CLASSES_ROOT,
	index,
	keyname,
	&key_len,
	NULL,
	NULL,
	NULL,
	NULL) == ERROR_SUCCESS)
	{
	key_utf8 = g_utf16_to_utf8 (keyname, -1, NULL, NULL, NULL);
	if (key_utf8)
	{
	if (*key_utf8 == '.')
	types = g_list_prepend (types, key_utf8);
	else
	g_free (key_utf8);
	}
	index++;
	key_len = 256;
	}

	return g_list_reverse (types);
	}

	gchar **
	g_content_type_guess_for_tree (GFile *root)
	{
	/* FIXME: implement */
	return NULL;
	}