/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright © 2011 Red Hat, Inc

 *

 * 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/>.

 *

 * Authors: Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include <string.h>

#include "gresource.h"

#include <gvdb/gvdb-reader.h>

#include <gi18n-lib.h>

#include <gstdio.h>

#include <gio/gfile.h>

#include <gio/gioerror.h>

#include <gio/gmemoryinputstream.h>

#include <gio/gzlibdecompressor.h>

#include <gio/gconverterinputstream.h>

#include "glib-private.h"

struct _GResource

{

  int ref_count;

  GvdbTable *table;

};

static void register_lazy_static_resources (void);

G_DEFINE_BOXED_TYPE (GResource, g_resource, g_resource_ref, g_resource_unref)

/**

 * SECTION:gresource

 * @short_description: Resource framework

 * @include: gio/gio.h

 *

 * Applications and libraries often contain binary or textual data that is

 * really part of the application, rather than user data. For instance

 * #GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files,

 * icons, etc. These are often shipped as files in `$datadir/appname`, or

 * manually included as literal strings in the code.

 *

 * The #GResource API and the [glib-compile-resources][glib-compile-resources] program

 * provide a convenient and efficient alternative to this which has some nice properties. You

 * maintain the files as normal files, so its easy to edit them, but during the build the files

 * are combined into a binary bundle that is linked into the executable. This means that loading

 * the resource files are efficient (as they are already in memory, shared with other instances) and

 * simple (no need to check for things like I/O errors or locate the files in the filesystem). It

 * also makes it easier to create relocatable applications.

 *

 * Resource files can also be marked as compressed. Such files will be included in the resource bundle

 * in a compressed form, but will be automatically uncompressed when the resource is used. This

 * is very useful e.g. for larger text files that are parsed once (or rarely) and then thrown away.

 *

 * Resource files can also be marked to be preprocessed, by setting the value of the

 * `preprocess` attribute to a comma-separated list of preprocessing options.

 * The only options currently supported are:

 *

 * `xml-stripblanks` which will use the xmllint command

 * to strip ignorable whitespace from the XML file. For this to work,

 * the `XMLLINT` environment variable must be set to the full path to

 * the xmllint executable, or xmllint must be in the `PATH`; otherwise

 * the preprocessing step is skipped.

 *

 * `to-pixdata` (deprecated since gdk-pixbuf 2.32) which will use the

 * `gdk-pixbuf-pixdata` command to convert images to the #GdkPixdata format,

 * which allows you to create pixbufs directly using the data inside the

 * resource file, rather than an (uncompressed) copy of it. For this, the

 * `gdk-pixbuf-pixdata` program must be in the `PATH`, or the

 * `GDK_PIXBUF_PIXDATA` environment variable must be set to the full path to the

 * `gdk-pixbuf-pixdata` executable; otherwise the resource compiler will abort.

 * `to-pixdata` has been deprecated since gdk-pixbuf 2.32, as #GResource

 * supports embedding modern image formats just as well. Instead of using it,

 * embed a PNG or SVG file in your #GResource.

 *

 * `json-stripblanks` which will use the `json-glib-format` command to strip

 * ignorable whitespace from the JSON file. For this to work, the

 * `JSON_GLIB_FORMAT` environment variable must be set to the full path to the

 * `json-glib-format` executable, or it must be in the `PATH`;

 * otherwise the preprocessing step is skipped. In addition, at least version

 * 1.6 of `json-glib-format` is required.

 *

 * Resource files will be exported in the GResource namespace using the

 * combination of the given `prefix` and the filename from the `file` element.

 * The `alias` attribute can be used to alter the filename to expose them at a

 * different location in the resource namespace. Typically, this is used to

 * include files from a different source directory without exposing the source

 * directory in the resource namespace, as in the example below.

 *

 * Resource bundles are created by the [glib-compile-resources][glib-compile-resources] program

 * which takes an XML file that describes the bundle, and a set of files that the XML references. These

 * are combined into a binary resource bundle.

 *

 * An example resource description:

 * |[

 * <?xml version="1.0" encoding="UTF-8"?>

 * <gresources>

 *   <gresource prefix="/org/gtk/Example">

 *     <file>data/splashscreen.png</file>

 *     <file compressed="true">dialog.ui</file>

 *     <file preprocess="xml-stripblanks">menumarkup.xml</file>

 *     <file alias="example.css">data/example.css</file>

 *   </gresource>

 * </gresources>

 * ]|

 *

 * This will create a resource bundle with the following files:

 * |[

 * /org/gtk/Example/data/splashscreen.png

 * /org/gtk/Example/dialog.ui

 * /org/gtk/Example/menumarkup.xml

 * /org/gtk/Example/example.css

 * ]|

 *

 * Note that all resources in the process share the same namespace, so use Java-style

 * path prefixes (like in the above example) to avoid conflicts.

 *

 * You can then use [glib-compile-resources][glib-compile-resources] to compile the XML to a

 * binary bundle that you can load with g_resource_load(). However, its more common to use the --generate-source and

 * --generate-header arguments to create a source file and header to link directly into your application.

 * This will generate `get_resource()`, `register_resource()` and

 * `unregister_resource()` functions, prefixed by the `--c-name` argument passed

 * to [glib-compile-resources][glib-compile-resources]. `get_resource()` returns

 * the generated #GResource object. The register and unregister functions

 * register the resource so its files can be accessed using

 * g_resources_lookup_data().

 *

 * Once a #GResource has been created and registered all the data in it can be accessed globally in the process by

 * using API calls like g_resources_open_stream() to stream the data or g_resources_lookup_data() to get a direct pointer

 * to the data. You can also use URIs like "resource:///org/gtk/Example/data/splashscreen.png" with #GFile to access

 * the resource data.

 *

 * Some higher-level APIs, such as #GtkApplication, will automatically load

 * resources from certain well-known paths in the resource namespace as a

 * convenience. See the documentation for those APIs for details.

 *

 * There are two forms of the generated source, the default version uses the compiler support for constructor

 * and destructor functions (where available) to automatically create and register the #GResource on startup

 * or library load time. If you pass `--manual-register`, two functions to register/unregister the resource are created

 * instead. This requires an explicit initialization call in your application/library, but it works on all platforms,

 * even on the minor ones where constructors are not supported. (Constructor support is available for at least Win32, Mac OS and Linux.)

 *

 * Note that resource data can point directly into the data segment of e.g. a library, so if you are unloading libraries

 * during runtime you need to be very careful with keeping around pointers to data from a resource, as this goes away

 * when the library is unloaded. However, in practice this is not generally a problem, since most resource accesses

 * are for your own resources, and resource data is often used once, during parsing, and then released.

 *

 * When debugging a program or testing a change to an installed version, it is often useful to be able to

 * replace resources in the program or library, without recompiling, for debugging or quick hacking and testing

 * purposes. Since GLib 2.50, it is possible to use the `G_RESOURCE_OVERLAYS` environment variable to selectively overlay

 * resources with replacements from the filesystem.  It is a %G_SEARCHPATH_SEPARATOR-separated list of substitutions to perform

 * during resource lookups. It is ignored when running in a setuid process.

 *

 * A substitution has the form

 *

 * |[

 *    /org/gtk/libgtk=/home/desrt/gtk-overlay

 * ]|

 *

 * The part before the `=` is the resource subpath for which the overlay applies.  The part after is a

 * filesystem path which contains files and subdirectories as you would like to be loaded as resources with the

 * equivalent names.

 *

 * In the example above, if an application tried to load a resource with the resource path

 * `/org/gtk/libgtk/ui/gtkdialog.ui` then GResource would check the filesystem path

 * `/home/desrt/gtk-overlay/ui/gtkdialog.ui`.  If a file was found there, it would be used instead.  This is an

 * overlay, not an outright replacement, which means that if a file is not found at that path, the built-in

 * version will be used instead.  Whiteouts are not currently supported.

 *

 * Substitutions must start with a slash, and must not contain a trailing slash before the '='.  The path after

 * the slash should ideally be absolute, but this is not strictly required.  It is possible to overlay the

 * location of a single resource with an individual file.

 *

 * Since: 2.32

 */

/**

 * GStaticResource:

 *

 * #GStaticResource is an opaque data structure and can only be accessed

 * using the following functions.

 **/

typedef gboolean (* CheckCandidate) (const gchar *candidate, gpointer user_data);

static gboolean

open_overlay_stream (const gchar *candidate,

                     gpointer     user_data)

{

  GInputStream **res = (GInputStream **) user_data;

  GError *error = NULL;

  GFile *file;

  file = g_file_new_for_path (candidate);

  *res = (GInputStream *) g_file_read (file, NULL, &error);

  if (*res)

    {

      g_message ("Opened file '%s' as a resource overlay", candidate);

    }

  else

    {

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))

        g_warning ("Can't open overlay file '%s': %s", candidate, error->message);

      g_error_free (error);

    }

  g_object_unref (file);

  return *res != NULL;

}

static gboolean

get_overlay_bytes (const gchar *candidate,

                   gpointer     user_data)

{

  GBytes **res = (GBytes **) user_data;

  GMappedFile *mapped_file;

  GError *error = NULL;

  mapped_file = g_mapped_file_new (candidate, FALSE, &error);

  if (mapped_file)

    {

      g_message ("Mapped file '%s' as a resource overlay", candidate);

      *res = g_mapped_file_get_bytes (mapped_file);

      g_mapped_file_unref (mapped_file);

    }

  else

    {

      if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))

        g_warning ("Can't mmap overlay file '%s': %s", candidate, error->message);

      g_error_free (error);

    }

  return *res != NULL;

}

static gboolean

enumerate_overlay_dir (const gchar *candidate,

                       gpointer     user_data)

{

  GHashTable **hash = (GHashTable **) user_data;

  GError *error = NULL;

  GDir *dir;

  const gchar *name;

  dir = g_dir_open (candidate, 0, &error);

  if (dir)

    {

      if (*hash == NULL)

        /* note: keep in sync with same line below */

        *hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

      g_message ("Enumerating directory '%s' as resource overlay", candidate);

      while ((name = g_dir_read_name (dir)))

        {

          gchar *fullname = g_build_filename (candidate, name, NULL);

          /* match gvdb behaviour by suffixing "/" on dirs */

          if (g_file_test (fullname, G_FILE_TEST_IS_DIR))

            g_hash_table_add (*hash, g_strconcat (name, "/", NULL));

          else

            g_hash_table_add (*hash, g_strdup (name));

          g_free (fullname);

        }

      g_dir_close (dir);

    }

  else

    {

      if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))

        g_warning ("Can't enumerate overlay directory '%s': %s", candidate, error->message);

      g_error_free (error);

      return FALSE;

    }

  /* We may want to enumerate results from more than one overlay

   * directory.

   */

  return FALSE;

}

typedef struct {

  gsize size;

  guint32 flags;

} InfoData;

static gboolean

get_overlay_info (const gchar *candidate,

                  gpointer     user_data)

{

  InfoData *info = user_data;

  GStatBuf buf;

  if (g_stat (candidate, &buf) < 0)

    return FALSE;

  info->size = buf.st_size;

  info->flags = G_RESOURCE_FLAGS_NONE;

  return TRUE;

}

static gboolean

g_resource_find_overlay (const gchar    *path,

                         CheckCandidate  check,

                         gpointer        user_data)

{

  /* This is a null-terminated array of replacement strings (with '=' inside) */

  static const gchar * const *overlay_dirs;

  gboolean res = FALSE;

  gint path_len = -1;

  gint i;

  /* We try to be very fast in case there are no overlays.  Otherwise,

   * we can take a bit more time...

   */

  if (g_once_init_enter (&overlay_dirs))

    {

      gboolean is_setuid = GLIB_PRIVATE_CALL (g_check_setuid) ();

      const gchar * const *result;

      const gchar *envvar;

      /* Don’t load overlays if setuid, as they could allow reading privileged

       * files. */

      envvar = !is_setuid ? g_getenv ("G_RESOURCE_OVERLAYS") : NULL;

      if (envvar != NULL)

        {

          gchar **parts;

          gint i, j;

          parts = g_strsplit (envvar, G_SEARCHPATH_SEPARATOR_S, 0);

          /* Sanity check the parts, dropping those that are invalid.

           * 'i' may grow faster than 'j'.

           */

          for (i = j = 0; parts[i]; i++)

            {

              gchar *part = parts[i];

              gchar *eq;

              eq = strchr (part, '=');

              if (eq == NULL)

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' lacks '='.  Ignoring.", part);

                  g_free (part);

                  continue;

                }

              if (eq == part)

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' lacks path before '='.  Ignoring.", part);

                  g_free (part);

                  continue;

                }

              if (eq[1] == '\0')

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' lacks path after '='.  Ignoring", part);

                  g_free (part);

                  continue;

                }

              if (part[0] != '/')

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' lacks leading '/'.  Ignoring.", part);

                  g_free (part);

                  continue;

                }

              if (eq[-1] == '/')

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' has trailing '/' before '='.  Ignoring", part);

                  g_free (part);

                  continue;

                }

              if (!g_path_is_absolute (eq + 1))

                {

                  g_critical ("G_RESOURCE_OVERLAYS segment '%s' does not have an absolute path after '='.  Ignoring", part);

                  g_free (part);

                  continue;

                }

              g_message ("Adding GResources overlay '%s'", part);

              parts[j++] = part;

            }

          parts[j] = NULL;

          result = (const gchar **) parts;

        }

      else

        {

          /* We go out of the way to avoid malloc() in the normal case

           * where the environment variable is not set.

           */

          static const gchar * const empty_strv[0 + 1];

          result = empty_strv;

        }

      g_once_init_leave (&overlay_dirs, result);

    }

  for (i = 0; overlay_dirs[i]; i++)

    {

      const gchar *src;

      gint src_len;

      const gchar *dst;

      gint dst_len;

      gchar *candidate;

      {

        gchar *eq;

        /* split the overlay into src/dst */

        src = overlay_dirs[i];

        eq = strchr (src, '=');

        g_assert (eq); /* we checked this already */

        src_len = eq - src;

        dst = eq + 1;

        /* hold off on dst_len because we will probably fail the checks below */

      }

      if (path_len == -1)

        path_len = strlen (path);

      /* The entire path is too short to match the source */

      if (path_len < src_len)

        continue;

      /* It doesn't match the source */

      if (memcmp (path, src, src_len) != 0)

        continue;

      /* The prefix matches, but it's not a complete path component */

      if (path[src_len] && path[src_len] != '/')

        continue;

      /* OK.  Now we need this. */

      dst_len = strlen (dst);

      /* The candidate will be composed of:

       *

       *    dst + remaining_path + nul

       */

      candidate = g_malloc (dst_len + (path_len - src_len) + 1);

      memcpy (candidate, dst, dst_len);

      memcpy (candidate + dst_len, path + src_len, path_len - src_len);

      candidate[dst_len + (path_len - src_len)] = '\0';

      /* No matter what, 'r' is what we need, including the case where

       * we are trying to enumerate a directory.

       */

      res = (* check) (candidate, user_data);

      g_free (candidate);

      if (res)

        break;

    }

  return res;

}

/**

 * g_resource_error_quark:

 *

 * Gets the #GResource Error Quark.

 *

 * Returns: a #GQuark

 *

 * Since: 2.32

 */

G_DEFINE_QUARK (g-resource-error-quark, g_resource_error)

/**

 * g_resource_ref:

 * @resource: A #GResource

 *

 * Atomically increments the reference count of @resource by one. This

 * function is MT-safe and may be called from any thread.

 *

 * Returns: The passed in #GResource

 *

 * Since: 2.32

 **/

GResource *

g_resource_ref (GResource *resource)

{

  g_atomic_int_inc (&resource->ref_count);

  return resource;

}

/**

 * g_resource_unref:

 * @resource: A #GResource

 *

 * Atomically decrements the reference count of @resource by one. If the

 * reference count drops to 0, all memory allocated by the resource is

 * released. This function is MT-safe and may be called from any

 * thread.

 *

 * Since: 2.32

 **/

void

g_resource_unref (GResource *resource)

{

  if (g_atomic_int_dec_and_test (&resource->ref_count))

    {

      gvdb_table_free (resource->table);

      g_free (resource);

    }

}

/*< internal >

 * g_resource_new_from_table:

 * @table: (transfer full): a GvdbTable

 *

 * Returns: (transfer full): a new #GResource for @table

 */

static GResource *

g_resource_new_from_table (GvdbTable *table)

{

  GResource *resource;

  resource = g_new (GResource, 1);

  resource->ref_count = 1;

  resource->table = table;

  return resource;

}

static void

g_resource_error_from_gvdb_table_error (GError **g_resource_error,

                                        GError  *gvdb_table_error  /* (transfer full) */)

{

  if (g_error_matches (gvdb_table_error, G_FILE_ERROR, G_FILE_ERROR_INVAL))

    g_set_error_literal (g_resource_error,

                         G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL,

                         gvdb_table_error->message);

  else

    g_propagate_error (g_resource_error, g_steal_pointer (&gvdb_table_error));

  g_clear_error (&gvdb_table_error);

}

/**

 * g_resource_new_from_data:

 * @data: A #GBytes

 * @error: return location for a #GError, or %NULL

 *

 * Creates a GResource from a reference to the binary resource bundle.

 * This will keep a reference to @data while the resource lives, so

 * the data should not be modified or freed.

 *

 * If you want to use this resource in the global resource namespace you need

 * to register it with g_resources_register().

 *

 * Note: @data must be backed by memory that is at least pointer aligned.

 * Otherwise this function will internally create a copy of the memory since

 * GLib 2.56, or in older versions fail and exit the process.

 *

 * If @data is empty or corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned.

 *

 * Returns: (transfer full): a new #GResource, or %NULL on error

 *

 * Since: 2.32

 **/

GResource *

g_resource_new_from_data (GBytes  *data,

                          GError **error)

{

  GvdbTable *table;

  gboolean unref_data = FALSE;

  GError *local_error = NULL;

  if (((guintptr) g_bytes_get_data (data, NULL)) % sizeof (gpointer) != 0)

    {

      data = g_bytes_new (g_bytes_get_data (data, NULL),

                          g_bytes_get_size (data));

      unref_data = TRUE;

    }

  table = gvdb_table_new_from_bytes (data, TRUE, &local_error);

  if (unref_data)

    g_bytes_unref (data);

  if (table == NULL)

    {

      g_resource_error_from_gvdb_table_error (error, g_steal_pointer (&local_error));

      return NULL;

    }

  return g_resource_new_from_table (table);

}

/**

 * g_resource_load:

 * @filename: (type filename): the path of a filename to load, in the GLib filename encoding

 * @error: return location for a #GError, or %NULL

 *

 * Loads a binary resource bundle and creates a #GResource representation of it, allowing

 * you to query it for data.

 *

 * If you want to use this resource in the global resource namespace you need

 * to register it with g_resources_register().

 *

 * If @filename is empty or the data in it is corrupt,

 * %G_RESOURCE_ERROR_INTERNAL will be returned. If @filename doesn’t exist, or

 * there is an error in reading it, an error from g_mapped_file_new() will be

 * returned.

 *

 * Returns: (transfer full): a new #GResource, or %NULL on error

 *

 * Since: 2.32

 **/

GResource *

g_resource_load (const gchar  *filename,

                 GError      **error)

{

  GvdbTable *table;

  GError *local_error = NULL;

  table = gvdb_table_new (filename, FALSE, &local_error);

  if (table == NULL)

    {

      g_resource_error_from_gvdb_table_error (error, g_steal_pointer (&local_error));

      return NULL;

    }

  return g_resource_new_from_table (table);

}

static gboolean

do_lookup (GResource             *resource,

           const gchar           *path,

           GResourceLookupFlags   lookup_flags,

           gsize                 *size,

           guint32               *flags,

           const void           **data,

           gsize                 *data_size,

           GError               **error)

{

  char *free_path = NULL;

  gsize path_len;

  gboolean res = FALSE;

  GVariant *value;

  /* Drop any trailing slash. */

  path_len = strlen (path);

  if (path_len >= 1 && path[path_len-1] == '/')

    {

      path = free_path = g_strdup (path);

      free_path[path_len-1] = 0;

    }

  value = gvdb_table_get_raw_value (resource->table, path);

  if (value == NULL)

    {

      g_set_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND,

                   _("The resource at “%s” does not exist"),

                   path);

    }

  else

    {

      guint32 _size, _flags;

      GVariant *array;

      g_variant_get (value, "(uu@ay)",

                     &_size,

                     &_flags,

                     &array);

      _size = GUINT32_FROM_LE (_size);

      _flags = GUINT32_FROM_LE (_flags);

      if (size)

        *size = _size;

      if (flags)

        *flags = _flags;

      if (data)

        *data = g_variant_get_data (array);

      if (data_size)

        {

          /* Don't report trailing newline that non-compressed files has */

          if (_flags & G_RESOURCE_FLAGS_COMPRESSED)

            *data_size = g_variant_get_size (array);

          else

            *data_size = g_variant_get_size (array) - 1;

        }

      g_variant_unref (array);

      g_variant_unref (value);

      res = TRUE;

    }

  g_free (free_path);

  return res;

}

/**

 * g_resource_open_stream:

 * @resource: A #GResource

 * @path: A pathname inside the resource

 * @lookup_flags: A #GResourceLookupFlags

 * @error: return location for a #GError, or %NULL

 *

 * Looks for a file at the specified @path in the resource and

 * returns a #GInputStream that lets you read the data.

 *

 * @lookup_flags controls the behaviour of the lookup.

 *

 * Returns: (transfer full): #GInputStream or %NULL on error.

 *     Free the returned object with g_object_unref()

 *

 * Since: 2.32

 **/

GInputStream *

g_resource_open_stream (GResource             *resource,

                        const gchar           *path,

                        GResourceLookupFlags   lookup_flags,

                        GError               **error)

{

  const void *data;

  gsize data_size;

  guint32 flags;

  GInputStream *stream, *stream2;

  if (!do_lookup (resource, path, lookup_flags, NULL, &flags, &data, &data_size, error))

    return NULL;

  stream = g_memory_input_stream_new_from_data (data, data_size, NULL);

  g_object_set_data_full (G_OBJECT (stream), "g-resource",

                          g_resource_ref (resource),

                          (GDestroyNotify)g_resource_unref);

  if (flags & G_RESOURCE_FLAGS_COMPRESSED)

    {

      GZlibDecompressor *decompressor =

        g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);

      stream2 = g_converter_input_stream_new (stream, G_CONVERTER (decompressor));

      g_object_unref (decompressor);

      g_object_unref (stream);

      stream = stream2;

    }

  return stream;

}

/**

 * g_resource_lookup_data:

 * @resource: A #GResource

 * @path: A pathname inside the resource

 * @lookup_flags: A #GResourceLookupFlags

 * @error: return location for a #GError, or %NULL

 *

 * Looks for a file at the specified @path in the resource and

 * returns a #GBytes that lets you directly access the data in

 * memory.

 *

 * The data is always followed by a zero byte, so you

 * can safely use the data as a C string. However, that byte

 * is not included in the size of the GBytes.

 *

 * For uncompressed resource files this is a pointer directly into

 * the resource bundle, which is typically in some readonly data section

 * in the program binary. For compressed files we allocate memory on

 * the heap and automatically uncompress the data.

 *

 * @lookup_flags controls the behaviour of the lookup.

 *

 * Returns: (transfer full): #GBytes or %NULL on error.

 *     Free the returned object with g_bytes_unref()

 *

 * Since: 2.32

 **/

GBytes *

g_resource_lookup_data (GResource             *resource,

                        const gchar           *path,

                        GResourceLookupFlags   lookup_flags,

                        GError               **error)

{

  const void *data;

  guint32 flags;

  gsize data_size;

  gsize size;

  if (!do_lookup (resource, path, lookup_flags, &size, &flags, &data, &data_size, error))

    return NULL;

  if (size == 0)

    return g_bytes_new_with_free_func ("", 0, (GDestroyNotify) g_resource_unref, g_resource_ref (resource));

  else if (flags & G_RESOURCE_FLAGS_COMPRESSED)

    {

      char *uncompressed, *d;

      const char *s;

      GConverterResult res;

      gsize d_size, s_size;

      gsize bytes_read, bytes_written;

      GZlibDecompressor *decompressor =

        g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);

      uncompressed = g_malloc (size + 1);

      s = data;

      s_size = data_size;

      d = uncompressed;

      d_size = size;

      do

        {

          res = g_converter_convert (G_CONVERTER (decompressor),

                                     s, s_size,

                                     d, d_size,

                                     G_CONVERTER_INPUT_AT_END,

                                     &bytes_read,

                                     &bytes_written,

                                     NULL);

          if (res == G_CONVERTER_ERROR)

            {

              g_free (uncompressed);

              g_object_unref (decompressor);

              g_set_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL,

                           _("The resource at “%s” failed to decompress"),

                           path);

              return NULL;

            }

          s += bytes_read;

          s_size -= bytes_read;

          d += bytes_written;

          d_size -= bytes_written;

        }

      while (res != G_CONVERTER_FINISHED);

      uncompressed[size] = 0; /* Zero terminate */

      g_object_unref (decompressor);

      return g_bytes_new_take (uncompressed, size);

    }

  else

    return g_bytes_new_with_free_func (data, data_size, (GDestroyNotify)g_resource_unref, g_resource_ref (resource));

}

/**

 * g_resource_get_info:

 * @resource: A #GResource

 * @path: A pathname inside the resource

 * @lookup_flags: A #GResourceLookupFlags

 * @size:  (out) (optional): a location to place the length of the contents of the file,

 *    or %NULL if the length is not needed

 * @flags:  (out) (optional): a location to place the flags about the file,

 *    or %NULL if the length is not needed

 * @error: return location for a #GError, or %NULL

 *

 * Looks for a file at the specified @path in the resource and

 * if found returns information about it.

 *

 * @lookup_flags controls the behaviour of the lookup.

 *

 * Returns: %TRUE if the file was found. %FALSE if there were errors

 *

 * Since: 2.32

 **/

gboolean

g_resource_get_info (GResource             *resource,

                     const gchar           *path,

                     GResourceLookupFlags   lookup_flags,

                     gsize                 *size,

                     guint32               *flags,

                     GError               **error)

{

  return do_lookup (resource, path, lookup_flags, size, flags, NULL, NULL, error);

}

/**

 * g_resource_enumerate_children:

 * @resource: A #GResource

 * @path: A pathname inside the resource

 * @lookup_flags: A #GResourceLookupFlags

 * @error: return location for a #GError, or %NULL

 *

 * Returns all the names of children at the specified @path in the resource.

 * The return result is a %NULL terminated list of strings which should

 * be released with g_strfreev().

 *

 * If @path is invalid or does not exist in the #GResource,

 * %G_RESOURCE_ERROR_NOT_FOUND will be returned.

 *

 * @lookup_flags controls the behaviour of the lookup.

 *

 * Returns: (array zero-terminated=1) (transfer full): an array of constant strings

 *

 * Since: 2.32

 **/

gchar **

g_resource_enumerate_children (GResource             *resource,

                               const gchar           *path,

                               GResourceLookupFlags   lookup_flags,

                               GError               **error)

{

  gchar local_str[256];

  const gchar *path_with_slash;

  gchar **children;

  gchar *free_path = NULL;

  gsize path_len;

  /*

   * Size of 256 is arbitrarily chosen based on being large enough

   * for pretty much everything we come across, but not cumbersome

   * on the stack. It also matches common cacheline sizes.

   */

  if (*path == 0)

    {

      if (error)

        g_set_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND,

                     _("The resource at “%s” does not exist"),

                     path);

      return NULL;

    }

  path_len = strlen (path);

  if G_UNLIKELY (path[path_len-1] != '/')

    {

      if (path_len < sizeof (local_str) - 2)

        {

          /*

           * We got a path that does not have a trailing /. It is not the

           * ideal use of this API as we require trailing / for our lookup

           * into gvdb. Some degenerate application configurations can hit

           * this code path quite a bit, so we try to avoid using the

           * g_strconcat()/g_free().

           */

          memcpy (local_str, path, path_len);

          local_str[path_len] = '/';

          local_str[path_len+1] = 0;

          path_with_slash = local_str;

        }

      else

        {

          path_with_slash = free_path = g_strconcat (path, "/", NULL);

        }

    }

  else

    {

      path_with_slash = path;

    }