gio/gresourcefile.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Alexander Larsson <alexl@redhat.com>
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24
  25 #include "gresource.h"
  26 #include "gresourcefile.h"
  27 #include "gfileattribute.h"
  28 #include <gfileattribute-priv.h>
  29 #include <gfileinfo-priv.h>
  30 #include "gfile.h"
  31 #include "gfilemonitor.h"
  32 #include "gseekable.h"
  33 #include "gfileinputstream.h"
  34 #include "gfileinfo.h"
  35 #include "gfileenumerator.h"
  36 #include "gcontenttype.h"
  37 #include "gioerror.h"
  38 #include <glib/gstdio.h>
  39 #include "glibintl.h"
  40
  41 struct _GResourceFile
  42 {
  43   GObject parent_instance;
  44
  45   char *path;
  46 };
  47
  48 struct _GResourceFileEnumerator
  49 {
  50   GFileEnumerator parent;
  51
  52   GFileAttributeMatcher *matcher;
  53   char *path;
  54   char *attributes;
  55   GFileQueryInfoFlags flags;
  56   int index;
  57
  58   char **children;
  59 };
  60
  61 struct _GResourceFileEnumeratorClass
  62 {
  63   GFileEnumeratorClass parent_class;
  64 };
  65
  66 typedef struct _GResourceFileEnumerator        GResourceFileEnumerator;
  67 typedef struct _GResourceFileEnumeratorClass   GResourceFileEnumeratorClass;
  68
  69 static void g_resource_file_file_iface_init (GFileIface *iface);
  70
  71 static GFileAttributeInfoList *resource_writable_attributes = NULL;
  72 static GFileAttributeInfoList *resource_writable_namespaces = NULL;
  73
  74 static GType _g_resource_file_enumerator_get_type (void);
  75
  76 #define G_TYPE_RESOURCE_FILE_ENUMERATOR         (_g_resource_file_enumerator_get_type ())
  77 #define G_RESOURCE_FILE_ENUMERATOR(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_RESOURCE_FILE_ENUMERATOR, GResourceFileEnumerator))
  78 #define G_RESOURCE_FILE_ENUMERATOR_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_RESOURCE_FILE_ENUMERATOR, GResourceFileEnumeratorClass))
  79 #define G_IS_RESOURCE_FILE_ENUMERATOR(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_RESOURCE_FILE_ENUMERATOR))
  80 #define G_IS_RESOURCE_FILE_ENUMERATOR_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_RESOURCE_FILE_ENUMERATOR))
  81 #define G_RESOURCE_FILE_ENUMERATOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_RESOURCE_FILE_ENUMERATOR, GResourceFileEnumeratorClass))
  82
  83 #define G_TYPE_RESOURCE_FILE_INPUT_STREAM         (_g_resource_file_input_stream_get_type ())
  84 #define G_RESOURCE_FILE_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_RESOURCE_FILE_INPUT_STREAM, GResourceFileInputStream))
  85 #define G_RESOURCE_FILE_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_RESOURCE_FILE_INPUT_STREAM, GResourceFileInputStreamClass))
  86 #define G_IS_RESOURCE_FILE_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_RESOURCE_FILE_INPUT_STREAM))
  87 #define G_IS_RESOURCE_FILE_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_RESOURCE_FILE_INPUT_STREAM))
  88 #define G_RESOURCE_FILE_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_RESOURCE_FILE_INPUT_STREAM, GResourceFileInputStreamClass))
  89
  90 typedef struct _GResourceFileInputStream         GResourceFileInputStream;
  91 typedef struct _GResourceFileInputStreamClass    GResourceFileInputStreamClass;
  92
  93 #define g_resource_file_get_type _g_resource_file_get_type
  94 G_DEFINE_TYPE_WITH_CODE (GResourceFile, g_resource_file, G_TYPE_OBJECT,
  95                          G_IMPLEMENT_INTERFACE (G_TYPE_FILE,
  96                                                 g_resource_file_file_iface_init))
  97
  98 #define g_resource_file_enumerator_get_type _g_resource_file_enumerator_get_type
  99 G_DEFINE_TYPE (GResourceFileEnumerator, g_resource_file_enumerator, G_TYPE_FILE_ENUMERATOR)
 100
 101 static GFileEnumerator *_g_resource_file_enumerator_new (GResourceFile *file,
 102                                                          const char           *attributes,
 103                                                          GFileQueryInfoFlags   flags,
 104                                                          GCancellable         *cancellable,
 105                                                          GError              **error);
 106
 107
 108 static GType              _g_resource_file_input_stream_get_type (void) G_GNUC_CONST;
 109
 110 static GFileInputStream *_g_resource_file_input_stream_new (GInputStream *stream, GFile *file);
 111
 112
 113 static void
 114 g_resource_file_finalize (GObject *object)
 115 {
 116   GResourceFile *resource;
 117
 118   resource = G_RESOURCE_FILE (object);
 119
 120   g_free (resource->path);
 121
 122   G_OBJECT_CLASS (g_resource_file_parent_class)->finalize (object);
 123 }
 124
 125 static void
 126 g_resource_file_class_init (GResourceFileClass *klass)
 127 {
 128   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 129
 130   gobject_class->finalize = g_resource_file_finalize;
 131
 132   resource_writable_attributes = g_file_attribute_info_list_new ();
 133   resource_writable_namespaces = g_file_attribute_info_list_new ();
 134 }
 135
 136 static void
 137 g_resource_file_init (GResourceFile *resource)
 138 {
 139 }
 140
 141 static inline gchar *
 142 scan_backwards (const gchar *begin,
 143                 const gchar *end,
 144                 gchar        c)
 145 {
 146   while (end >= begin)
 147     {
 148       if (*end == c)
 149         return (gchar *)end;
 150       end--;
 151     }
 152
 153   return NULL;
 154 }
 155
 156 static inline void
 157 pop_to_previous_part (const gchar  *begin,
 158                       gchar       **out)
 159 {
 160   if (*out > begin)
 161     *out = scan_backwards (begin, *out - 1, '/');
 162 }
 163
 164 /*
 165  * canonicalize_filename:
 166  * @in: the path to be canonicalized
 167  *
 168  * The path @in may contain non-canonical path pieces such as "../"
 169  * or duplicated "/". This will resolve those into a form that only
 170  * contains a single / at a time and resolves all "../". The resulting
 171  * path must also start with a /.
 172  *
 173  * Returns: the canonical form of the path
 174  */
 175 static char *
 176 canonicalize_filename (const char *in)
 177 {
 178   gchar *bptr;
 179   char *out;
 180
 181   bptr = out = g_malloc (strlen (in) + 2);
 182   *out = '/';
 183
 184   while (*in != 0)
 185     {
 186       g_assert (*out == '/');
 187
 188       /* move past slashes */
 189       while (*in == '/')
 190         in++;
 191
 192       /* Handle ./ ../ .\0 ..\0 */
 193       if (*in == '.')
 194         {
 195           /* If this is ../ or ..\0 move up */
 196           if (in[1] == '.' && (in[2] == '/' || in[2] == 0))
 197             {
 198               pop_to_previous_part (bptr, &out);
 199               in += 2;
 200               continue;
 201             }
 202
 203           /* If this is ./ skip past it */
 204           if (in[1] == '/' || in[1] == 0)
 205             {
 206               in += 1;
 207               continue;
 208             }
 209         }
 210
 211       /* Scan to the next path piece */
 212       while (*in != 0 && *in != '/')
 213         *(++out) = *(in++);
 214
 215       /* Add trailing /, compress the rest on the next go round. */
 216       if (*in == '/')
 217         *(++out) = *(in++);
 218     }
 219
 220   /* Trim trailing / from path */
 221   if (out > bptr && *out == '/')
 222     *out = 0;
 223   else
 224     *(++out) = 0;
 225
 226   return bptr;
 227 }
 228
 229 static GFile *
 230 g_resource_file_new_for_path (const char *path)
 231 {
 232   GResourceFile *resource = g_object_new (G_TYPE_RESOURCE_FILE, NULL);
 233
 234   resource->path = canonicalize_filename (path);
 235
 236   return G_FILE (resource);
 237 }
 238
 239 GFile *
 240 _g_resource_file_new (const char *uri)
 241 {
 242   GFile *resource;
 243   char *path;
 244
 245   path = g_uri_unescape_string (uri + strlen ("resource:"), NULL);
 246   resource = g_resource_file_new_for_path (path);
 247   g_free (path);
 248
 249   return G_FILE (resource);
 250 }
 251
 252 static gboolean
 253 g_resource_file_is_native (GFile *file)
 254 {
 255   return FALSE;
 256 }
 257
 258 static gboolean
 259 g_resource_file_has_uri_scheme (GFile      *file,
 260                                 const char *uri_scheme)
 261 {
 262   return g_ascii_strcasecmp (uri_scheme, "resource") == 0;
 263 }
 264
 265 static char *
 266 g_resource_file_get_uri_scheme (GFile *file)
 267 {
 268   return g_strdup ("resource");
 269 }
 270
 271 static char *
 272 g_resource_file_get_basename (GFile *file)
 273 {
 274   gchar *base;
 275
 276   base = strrchr (G_RESOURCE_FILE (file)->path, '/');
 277   return g_strdup (base + 1);
 278 }
 279
 280 static char *
 281 g_resource_file_get_path (GFile *file)
 282 {
 283   return NULL;
 284 }
 285
 286 static char *
 287 g_resource_file_get_uri (GFile *file)
 288 {
 289   char *escaped, *res;
 290   escaped = g_uri_escape_string (G_RESOURCE_FILE (file)->path, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, FALSE);
 291   res = g_strconcat ("resource://", escaped, NULL);
 292   g_free (escaped);
 293   return res;
 294 }
 295
 296 static char *
 297 g_resource_file_get_parse_name (GFile *file)
 298 {
 299   return g_resource_file_get_uri (file);
 300 }
 301
 302 static GFile *
 303 g_resource_file_get_parent (GFile *file)
 304 {
 305   GResourceFile *resource = G_RESOURCE_FILE (file);
 306   GResourceFile *parent;
 307   gchar *end;
 308
 309   end = strrchr (resource->path, '/');
 310
 311   if (end == G_RESOURCE_FILE (file)->path)
 312     return NULL;
 313
 314   parent = g_object_new (G_TYPE_RESOURCE_FILE, NULL);
 315   parent->path = g_strndup (resource->path,
 316                             end - resource->path);
 317
 318   return G_FILE (parent);
 319 }
 320
 321 static GFile *
 322 g_resource_file_dup (GFile *file)
 323 {
 324   GResourceFile *resource = G_RESOURCE_FILE (file);
 325
 326   return g_resource_file_new_for_path (resource->path);
 327 }
 328
 329 static guint
 330 g_resource_file_hash (GFile *file)
 331 {
 332   GResourceFile *resource = G_RESOURCE_FILE (file);
 333
 334   return g_str_hash (resource->path);
 335 }
 336
 337 static gboolean
 338 g_resource_file_equal (GFile *file1,
 339                        GFile *file2)
 340 {
 341   GResourceFile *resource1 = G_RESOURCE_FILE (file1);
 342   GResourceFile *resource2 = G_RESOURCE_FILE (file2);
 343
 344   return g_str_equal (resource1->path, resource2->path);
 345 }
 346
 347 static const char *
 348 match_prefix (const char *path,
 349               const char *prefix)
 350 {
 351   int prefix_len;
 352
 353   prefix_len = strlen (prefix);
 354   if (strncmp (path, prefix, prefix_len) != 0)
 355     return NULL;
 356
 357   /* Handle the case where prefix is the root, so that
 358    * the IS_DIR_SEPRARATOR check below works */
 359   if (prefix_len > 0 &&
 360       prefix[prefix_len-1] == '/')
 361     prefix_len--;
 362
 363   return path + prefix_len;
 364 }
 365
 366 static gboolean
 367 g_resource_file_prefix_matches (GFile *parent,
 368                                 GFile *descendant)
 369 {
 370   GResourceFile *parent_resource = G_RESOURCE_FILE (parent);
 371   GResourceFile *descendant_resource = G_RESOURCE_FILE (descendant);
 372   const char *remainder;
 373
 374   remainder = match_prefix (descendant_resource->path, parent_resource->path);
 375   if (remainder != NULL && *remainder == '/')
 376     return TRUE;
 377   return FALSE;
 378 }
 379
 380 static char *
 381 g_resource_file_get_relative_path (GFile *parent,
 382                                    GFile *descendant)
 383 {
 384   GResourceFile *parent_resource = G_RESOURCE_FILE (parent);
 385   GResourceFile *descendant_resource = G_RESOURCE_FILE (descendant);
 386   const char *remainder;
 387
 388   remainder = match_prefix (descendant_resource->path, parent_resource->path);
 389
 390   if (remainder != NULL && *remainder == '/')
 391     return g_strdup (remainder + 1);
 392   return NULL;
 393 }
 394
 395 static GFile *
 396 g_resource_file_resolve_relative_path (GFile      *file,
 397                                        const char *relative_path)
 398 {
 399   GResourceFile *resource = G_RESOURCE_FILE (file);
 400   char *filename;
 401   GFile *child;
 402
 403   if (relative_path[0] == '/')
 404     return g_resource_file_new_for_path (relative_path);
 405
 406   filename = g_build_path ("/", resource->path, relative_path, NULL);
 407   child = g_resource_file_new_for_path (filename);
 408   g_free (filename);
 409
 410   return child;
 411 }
 412
 413 static GFileEnumerator *
 414 g_resource_file_enumerate_children (GFile                *file,
 415                                     const char           *attributes,
 416                                     GFileQueryInfoFlags   flags,
 417                                     GCancellable         *cancellable,
 418                                     GError              **error)
 419 {
 420   GResourceFile *resource = G_RESOURCE_FILE (file);
 421   return _g_resource_file_enumerator_new (resource,
 422                                           attributes, flags,
 423                                           cancellable, error);
 424 }
 425
 426 static GFile *
 427 g_resource_file_get_child_for_display_name (GFile        *file,
 428                                             const char   *display_name,
 429                                             GError      **error)
 430 {
 431   GFile *new_file;
 432
 433   new_file = g_file_get_child (file, display_name);
 434
 435   return new_file;
 436 }
 437
 438 static GFileInfo *
 439 g_resource_file_query_info (GFile                *file,
 440                             const char           *attributes,
 441                             GFileQueryInfoFlags   flags,
 442                             GCancellable         *cancellable,
 443                             GError              **error)
 444 {
 445   GResourceFile *resource = G_RESOURCE_FILE (file);
 446   GError *my_error = NULL;
 447   GFileInfo *info;
 448   GFileAttributeMatcher *matcher;
 449   gboolean res;
 450   gsize size;
 451   guint32 resource_flags;
 452   char **children;
 453   gboolean is_dir;
 454   char *base;
 455
 456   is_dir = FALSE;
 457   children = g_resources_enumerate_children (resource->path, 0, NULL);
 458   if (children != NULL)
 459     {
 460       g_strfreev (children);
 461       is_dir = TRUE;
 462     }
 463
 464   /* root is always there */
 465   if (strcmp ("/", resource->path) == 0)
 466     is_dir = TRUE;
 467
 468   if (!is_dir)
 469     {
 470       res = g_resources_get_info (resource->path, 0, &size, &resource_flags, &my_error);
 471       if (!res)
 472         {
 473           if (g_error_matches (my_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND))
 474             {
 475               g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
 476                            _("The resource at “%s” does not exist"),
 477                            resource->path);
 478             }
 479           else
 480             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 481                                  my_error->message);
 482           g_clear_error (&my_error);
 483           return FALSE;
 484         }
 485     }
 486
 487   matcher = g_file_attribute_matcher_new (attributes);
 488
 489   info = g_file_info_new ();
 490   base = g_resource_file_get_basename (file);
 491   g_file_info_set_name (info, base);
 492   g_file_info_set_display_name (info, base);
 493
 494   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ, TRUE);
 495   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_WRITE, FALSE);
 496   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_EXECUTE, FALSE);
 497   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME, FALSE);
 498   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE, FALSE);
 499   _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH, FALSE);
 500
 501   if (is_dir)
 502     {
 503       g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
 504     }
 505   else
 506     {
 507       GBytes *bytes;
 508       char *content_type;
 509
 510       g_file_info_set_file_type (info, G_FILE_TYPE_REGULAR);
 511       g_file_info_set_size (info, size);
 512
 513       if ((_g_file_attribute_matcher_matches_id (matcher, G_FILE_ATTRIBUTE_ID_STANDARD_CONTENT_TYPE) ||
 514            ((~resource_flags & G_RESOURCE_FLAGS_COMPRESSED) &&
 515             _g_file_attribute_matcher_matches_id (matcher, G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE))) &&
 516           (bytes = g_resources_lookup_data (resource->path, 0, NULL)))
 517         {
 518           const guchar *data;
 519           gsize data_size;
 520
 521           data = g_bytes_get_data (bytes, &data_size);
 522           content_type = g_content_type_guess (base, data, data_size, NULL);
 523
 524           g_bytes_unref (bytes);
 525         }
 526       else
 527         content_type = NULL;
 528
 529       if (content_type)
 530         {
 531           _g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_CONTENT_TYPE, content_type);
 532           _g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE, content_type);
 533
 534           g_free (content_type);
 535         }
 536     }
 537
 538   g_free (base);
 539   g_file_attribute_matcher_unref (matcher);
 540
 541   return info;
 542 }
 543
 544 static GFileInfo *
 545 g_resource_file_query_filesystem_info (GFile         *file,
 546                                        const char    *attributes,
 547                                        GCancellable  *cancellable,
 548                                        GError       **error)
 549 {
 550   GFileInfo *info;
 551   GFileAttributeMatcher *matcher;
 552
 553   info = g_file_info_new ();
 554
 555   matcher = g_file_attribute_matcher_new (attributes);
 556   if (g_file_attribute_matcher_matches (matcher, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE))
 557     g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, "resource");
 558
 559   if (g_file_attribute_matcher_matches (matcher, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY))    g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, TRUE);
 560
 561   g_file_attribute_matcher_unref (matcher);
 562
 563   return info;
 564 }
 565
 566 static GFileAttributeInfoList *
 567 g_resource_file_query_settable_attributes (GFile         *file,
 568                                            GCancellable  *cancellable,
 569                                            GError       **error)
 570 {
 571   return g_file_attribute_info_list_ref (resource_writable_attributes);
 572 }
 573
 574 static GFileAttributeInfoList *
 575 g_resource_file_query_writable_namespaces (GFile         *file,
 576                                            GCancellable  *cancellable,
 577                                            GError       **error)
 578 {
 579   return g_file_attribute_info_list_ref (resource_writable_namespaces);
 580 }
 581
 582 static GFileInputStream *
 583 g_resource_file_read (GFile         *file,
 584                       GCancellable  *cancellable,
 585                       GError       **error)
 586 {
 587   GResourceFile *resource = G_RESOURCE_FILE (file);
 588   GError *my_error = NULL;
 589   GInputStream *stream;
 590   GFileInputStream *res;
 591
 592   stream = g_resources_open_stream (resource->path, 0, &my_error);
 593
 594   if (stream == NULL)
 595     {
 596       if (g_error_matches (my_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND))
 597         {
 598           g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
 599                        _("The resource at “%s” does not exist"),
 600                        resource->path);
 601         }
 602       else
 603         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 604                              my_error->message);
 605       g_clear_error (&my_error);
 606       return NULL;
 607     }
 608
 609   res = _g_resource_file_input_stream_new (stream, file);
 610   g_object_unref (stream);
 611   return res;
 612 }
 613
 614 typedef GFileMonitor GResourceFileMonitor;
 615 typedef GFileMonitorClass GResourceFileMonitorClass;
 616
 617 GType g_resource_file_monitor_get_type (void);
 618
 619 G_DEFINE_TYPE (GResourceFileMonitor, g_resource_file_monitor, G_TYPE_FILE_MONITOR)
 620
 621 static gboolean
 622 g_resource_file_monitor_cancel (GFileMonitor *monitor)
 623 {
 624   return TRUE;
 625 }
 626
 627 static void
 628 g_resource_file_monitor_init (GResourceFileMonitor *monitor)
 629 {
 630 }
 631
 632 static void
 633 g_resource_file_monitor_class_init (GResourceFileMonitorClass *class)
 634 {
 635   class->cancel = g_resource_file_monitor_cancel;
 636 }
 637
 638 static GFileMonitor *
 639 g_resource_file_monitor_file (GFile              *file,
 640                               GFileMonitorFlags   flags,
 641                               GCancellable       *cancellable,
 642                               GError            **error)
 643 {
 644   return g_object_new (g_resource_file_monitor_get_type (), NULL);
 645 }
 646
 647 static void
 648 g_resource_file_file_iface_init (GFileIface *iface)
 649 {
 650   iface->dup = g_resource_file_dup;
 651   iface->hash = g_resource_file_hash;
 652   iface->equal = g_resource_file_equal;
 653   iface->is_native = g_resource_file_is_native;
 654   iface->has_uri_scheme = g_resource_file_has_uri_scheme;
 655   iface->get_uri_scheme = g_resource_file_get_uri_scheme;
 656   iface->get_basename = g_resource_file_get_basename;
 657   iface->get_path = g_resource_file_get_path;
 658   iface->get_uri = g_resource_file_get_uri;
 659   iface->get_parse_name = g_resource_file_get_parse_name;
 660   iface->get_parent = g_resource_file_get_parent;
 661   iface->prefix_matches = g_resource_file_prefix_matches;
 662   iface->get_relative_path = g_resource_file_get_relative_path;
 663   iface->resolve_relative_path = g_resource_file_resolve_relative_path;
 664   iface->get_child_for_display_name = g_resource_file_get_child_for_display_name;
 665   iface->enumerate_children = g_resource_file_enumerate_children;
 666   iface->query_info = g_resource_file_query_info;
 667   iface->query_filesystem_info = g_resource_file_query_filesystem_info;
 668   iface->query_settable_attributes = g_resource_file_query_settable_attributes;
 669   iface->query_writable_namespaces = g_resource_file_query_writable_namespaces;
 670   iface->read_fn = g_resource_file_read;
 671   iface->monitor_file = g_resource_file_monitor_file;
 672
 673   iface->supports_thread_contexts = TRUE;
 674 }
 675
 676 static GFileInfo *g_resource_file_enumerator_next_file (GFileEnumerator  *enumerator,
 677                                                         GCancellable     *cancellable,
 678                                                         GError          **error);
 679 static gboolean   g_resource_file_enumerator_close     (GFileEnumerator  *enumerator,
 680                                                         GCancellable     *cancellable,
 681                                                         GError          **error);
 682
 683 static void
 684 g_resource_file_enumerator_finalize (GObject *object)
 685 {
 686   GResourceFileEnumerator *resource;
 687
 688   resource = G_RESOURCE_FILE_ENUMERATOR (object);
 689
 690   g_strfreev (resource->children);
 691   g_free (resource->path);
 692   g_free (resource->attributes);
 693
 694   G_OBJECT_CLASS (g_resource_file_enumerator_parent_class)->finalize (object);
 695 }
 696
 697 static void
 698 g_resource_file_enumerator_class_init (GResourceFileEnumeratorClass *klass)
 699 {
 700   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 701   GFileEnumeratorClass *enumerator_class = G_FILE_ENUMERATOR_CLASS (klass);
 702
 703   gobject_class->finalize = g_resource_file_enumerator_finalize;
 704
 705   enumerator_class->next_file = g_resource_file_enumerator_next_file;
 706   enumerator_class->close_fn = g_resource_file_enumerator_close;
 707 }
 708
 709 static void
 710 g_resource_file_enumerator_init (GResourceFileEnumerator *resource)
 711 {
 712 }
 713
 714 static GFileEnumerator *
 715 _g_resource_file_enumerator_new (GResourceFile *file,
 716                                  const char           *attributes,
 717                                  GFileQueryInfoFlags   flags,
 718                                  GCancellable         *cancellable,
 719                                  GError              **error)
 720 {
 721   GResourceFileEnumerator *resource;
 722   char **children;
 723   gboolean res;
 724
 725   children = g_resources_enumerate_children (file->path, 0, NULL);
 726   if (children == NULL &&
 727       strcmp ("/", file->path) != 0)
 728     {
 729       res = g_resources_get_info (file->path, 0, NULL, NULL, NULL);
 730       if (res)
 731         g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY,
 732                      _("The resource at “%s” is not a directory"),
 733                      file->path);
 734       else
 735         g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
 736                      _("The resource at “%s” does not exist"),
 737                      file->path);
 738       return NULL;
 739     }
 740
 741   resource = g_object_new (G_TYPE_RESOURCE_FILE_ENUMERATOR,
 742                            "container", file,
 743                            NULL);
 744
 745   resource->children = children;
 746   resource->path = g_strdup (file->path);
 747   resource->attributes = g_strdup (attributes);
 748   resource->flags = flags;
 749
 750   return G_FILE_ENUMERATOR (resource);
 751 }
 752
 753 static GFileInfo *
 754 g_resource_file_enumerator_next_file (GFileEnumerator  *enumerator,
 755                                       GCancellable     *cancellable,
 756                                       GError          **error)
 757 {
 758   GResourceFileEnumerator *resource = G_RESOURCE_FILE_ENUMERATOR (enumerator);
 759   char *path;
 760   GFileInfo *info;
 761   GFile *file;
 762
 763   if (resource->children == NULL ||
 764       resource->children[resource->index] == NULL)
 765     return NULL;
 766
 767   path = g_build_path ("/", resource->path, resource->children[resource->index++], NULL);
 768   file = g_resource_file_new_for_path (path);
 769   g_free (path);
 770
 771   info = g_file_query_info (file,
 772                             resource->attributes,
 773                             resource->flags,
 774                             cancellable,
 775                             error);
 776
 777   g_object_unref (file);
 778
 779   return info;
 780 }
 781
 782 static gboolean
 783 g_resource_file_enumerator_close (GFileEnumerator  *enumerator,
 784                                GCancellable     *cancellable,
 785                                GError          **error)
 786 {
 787   return TRUE;
 788 }
 789
 790
 791 struct _GResourceFileInputStream
 792 {
 793   GFileInputStream parent_instance;
 794   GInputStream *stream;
 795   GFile *file;
 796 };
 797
 798 struct _GResourceFileInputStreamClass
 799 {
 800   GFileInputStreamClass parent_class;
 801 };
 802
 803 #define g_resource_file_input_stream_get_type _g_resource_file_input_stream_get_type
 804 G_DEFINE_TYPE (GResourceFileInputStream, g_resource_file_input_stream, G_TYPE_FILE_INPUT_STREAM)
 805
 806 static gssize     g_resource_file_input_stream_read       (GInputStream      *stream,
 807                                                            void              *buffer,
 808                                                            gsize              count,
 809                                                            GCancellable      *cancellable,
 810                                                            GError           **error);
 811 static gssize     g_resource_file_input_stream_skip       (GInputStream      *stream,
 812                                                            gsize              count,
 813                                                            GCancellable      *cancellable,
 814                                                            GError           **error);
 815 static gboolean   g_resource_file_input_stream_close      (GInputStream      *stream,
 816                                                            GCancellable      *cancellable,
 817                                                            GError           **error);
 818 static goffset    g_resource_file_input_stream_tell       (GFileInputStream  *stream);
 819 static gboolean   g_resource_file_input_stream_can_seek   (GFileInputStream  *stream);
 820 static gboolean   g_resource_file_input_stream_seek       (GFileInputStream  *stream,
 821                                                            goffset            offset,
 822                                                            GSeekType          type,
 823                                                            GCancellable      *cancellable,
 824                                                            GError           **error);
 825 static GFileInfo *g_resource_file_input_stream_query_info (GFileInputStream  *stream,
 826                                                            const char        *attributes,
 827                                                            GCancellable      *cancellable,
 828                                                            GError           **error);
 829
 830 static void
 831 g_resource_file_input_stream_finalize (GObject *object)
 832 {
 833   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (object);
 834
 835   g_object_unref (file->stream);
 836   g_object_unref (file->file);
 837   G_OBJECT_CLASS (g_resource_file_input_stream_parent_class)->finalize (object);
 838 }
 839
 840 static void
 841 g_resource_file_input_stream_class_init (GResourceFileInputStreamClass *klass)
 842 {
 843   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 844   GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass);
 845   GFileInputStreamClass *file_stream_class = G_FILE_INPUT_STREAM_CLASS (klass);
 846
 847   gobject_class->finalize = g_resource_file_input_stream_finalize;
 848
 849   stream_class->read_fn = g_resource_file_input_stream_read;
 850   stream_class->skip = g_resource_file_input_stream_skip;
 851   stream_class->close_fn = g_resource_file_input_stream_close;
 852   file_stream_class->tell = g_resource_file_input_stream_tell;
 853   file_stream_class->can_seek = g_resource_file_input_stream_can_seek;
 854   file_stream_class->seek = g_resource_file_input_stream_seek;
 855   file_stream_class->query_info = g_resource_file_input_stream_query_info;
 856 }
 857
 858 static void
 859 g_resource_file_input_stream_init (GResourceFileInputStream *info)
 860 {
 861 }
 862
 863 static GFileInputStream *
 864 _g_resource_file_input_stream_new (GInputStream *in_stream, GFile *file)
 865 {
 866   GResourceFileInputStream *stream;
 867
 868   stream = g_object_new (G_TYPE_RESOURCE_FILE_INPUT_STREAM, NULL);
 869   stream->stream = g_object_ref (in_stream);
 870   stream->file = g_object_ref (file);
 871
 872   return G_FILE_INPUT_STREAM (stream);
 873 }
 874
 875 static gssize
 876 g_resource_file_input_stream_read (GInputStream  *stream,
 877                                    void          *buffer,
 878                                    gsize          count,
 879                                    GCancellable  *cancellable,
 880                                    GError       **error)
 881 {
 882   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 883   return g_input_stream_read (file->stream,
 884                               buffer, count, cancellable, error);
 885 }
 886
 887 static gssize
 888 g_resource_file_input_stream_skip (GInputStream  *stream,
 889                                    gsize          count,
 890                                    GCancellable  *cancellable,
 891                                    GError       **error)
 892 {
 893   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 894   return g_input_stream_skip (file->stream,
 895                               count, cancellable, error);
 896 }
 897
 898 static gboolean
 899 g_resource_file_input_stream_close (GInputStream  *stream,
 900                                     GCancellable  *cancellable,
 901                                     GError       **error)
 902 {
 903   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 904   return g_input_stream_close (file->stream,
 905                                cancellable, error);
 906 }
 907
 908
 909 static goffset
 910 g_resource_file_input_stream_tell (GFileInputStream *stream)
 911 {
 912   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 913
 914   if (!G_IS_SEEKABLE (file->stream))
 915       return 0;
 916
 917   return g_seekable_tell (G_SEEKABLE (file->stream));
 918 }
 919
 920 static gboolean
 921 g_resource_file_input_stream_can_seek (GFileInputStream *stream)
 922 {
 923   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 924
 925   return G_IS_SEEKABLE (file->stream) && g_seekable_can_seek (G_SEEKABLE (file->stream));
 926 }
 927
 928 static gboolean
 929 g_resource_file_input_stream_seek (GFileInputStream  *stream,
 930                                    goffset            offset,
 931                                    GSeekType          type,
 932                                    GCancellable      *cancellable,
 933                                    GError           **error)
 934 {
 935   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 936
 937   if (!G_IS_SEEKABLE (file->stream))
 938     {
 939       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 940                            _("Input stream doesn’t implement seek"));
 941       return FALSE;
 942     }
 943
 944   return g_seekable_seek (G_SEEKABLE (file->stream),
 945                           offset, type, cancellable, error);
 946 }
 947
 948 static GFileInfo *
 949 g_resource_file_input_stream_query_info (GFileInputStream  *stream,
 950                                          const char        *attributes,
 951                                          GCancellable      *cancellable,
 952                                          GError           **error)
 953 {
 954   GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
 955
 956   return g_file_query_info (file->file, attributes, 0, cancellable, error);
 957 }