gio/gfile.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 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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include <config.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #ifdef HAVE_PWD_H
  27 #include <pwd.h>
  28 #endif
  29 #include "gfile.h"
  30 #include "gvfs.h"
  31 #include "gioscheduler.h"
  32 #include <glocalfile.h>
  33 #include "gsimpleasyncresult.h"
  34 #include "gfileattribute-priv.h"
  35 #include "gpollfilemonitor.h"
  36 #include "glibintl.h"
  37
  38 #include "gioalias.h"
  39
  40 /**
  41  * SECTION:gfile
  42  * @short_description: File and Directory Handling
  43  * @include: gio.h
  44  * @see_also: #GFileInfo, #GFileEnumerator
  45  *
  46  * #GFile is a high level abstraction for manipulating files on a
  47  * virtual file system. #GFile<!-- -->s are lightweight, immutable
  48  * objects that do no I/O upon creation. It is necessary to understand that
  49  * #GFile objects do not represent files, merely a handle to a file. All
  50  * file I/O is implemented as streaming operations (see #GInputStream and
  51  * #GOutputStream).
  52  *
  53  * To construct a #GFile, you can use:
  54  * g_file_new_for_path() if you have a path.
  55  * g_file_new_for_uri() if you have a URI.
  56  * g_file_new_for_commandline_arg() for a command line argument.
  57  *
  58  * You can move through the file system with #GFile handles with
  59  * g_file_get_parent() to get a handle to the parent directory.
  60  * g_file_get_child() to get a handle to a child within a directory.
  61  * g_file_resolve_relative_path() to resolve a relative path between
  62  * two #GFile<!-- -->s.
  63  *
  64  * Many #GFile operations have both synchronous and asynchronous versions
  65  * to suit your application. Asynchronous versions of synchronous functions
  66  * simply have _async() appended to their function names. The asynchronous
  67  * I/O functions call a #GAsyncReadyCallback which is then used to finalize
  68  * the operation, producing a GAsyncResult which is then passed to the
  69  * function's matching _finish()
  70  * operation.
  71  *
  72  * Some #GFile operations do not have synchronous analogs, as they may
  73  * take a very long time to finish, and blocking may leave an application
  74  * unusable. Notable cases include:
  75  * g_file_mount_mountable() to mount a mountable file.
  76  * g_file_unmount_mountable() to unmount a mountable file.
  77  * g_file_eject_mountable() to eject a mountable file.
  78  *
  79  * <para id="gfile-etag"><indexterm><primary>entity tag</primary></indexterm>
  80  * One notable feature of #GFile<!-- -->s are entity tags, or "etags" for
  81  * short. Entity tags are somewhat like a more abstract version of the
  82  * traditional mtime, and can be used to quickly determine if the file has
  83  * been modified from the version on the file system. See the HTTP 1.1
  84  * <ulink url="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html">specification</ulink>
  85  * for HTTP Etag headers, which are a very similar concept.
  86  * </para>
  87  **/
  88
  89 static void g_file_base_init (gpointer g_class);
  90 static void g_file_class_init (gpointer g_class,
  91                                gpointer class_data);
  92
  93 static void               g_file_real_query_info_async            (GFile                  *file,
  94                                                                    const char             *attributes,
  95                                                                    GFileQueryInfoFlags     flags,
  96                                                                    int                     io_priority,
  97                                                                    GCancellable           *cancellable,
  98                                                                    GAsyncReadyCallback     callback,
  99                                                                    gpointer                user_data);
 100 static GFileInfo *        g_file_real_query_info_finish           (GFile                  *file,
 101                                                                    GAsyncResult           *res,
 102                                                                    GError                **error);
 103 static void               g_file_real_enumerate_children_async    (GFile                  *file,
 104                                                                    const char             *attributes,
 105                                                                    GFileQueryInfoFlags     flags,
 106                                                                    int                     io_priority,
 107                                                                    GCancellable           *cancellable,
 108                                                                    GAsyncReadyCallback     callback,
 109                                                                    gpointer                user_data);
 110 static GFileEnumerator *  g_file_real_enumerate_children_finish   (GFile                  *file,
 111                                                                    GAsyncResult           *res,
 112                                                                    GError                **error);
 113 static void               g_file_real_read_async                  (GFile                  *file,
 114                                                                    int                     io_priority,
 115                                                                    GCancellable           *cancellable,
 116                                                                    GAsyncReadyCallback     callback,
 117                                                                    gpointer                user_data);
 118 static GFileInputStream * g_file_real_read_finish                 (GFile                  *file,
 119                                                                    GAsyncResult           *res,
 120                                                                    GError                **error);
 121 static void               g_file_real_append_to_async             (GFile                  *file,
 122                                                                    GFileCreateFlags        flags,
 123                                                                    int                     io_priority,
 124                                                                    GCancellable           *cancellable,
 125                                                                    GAsyncReadyCallback     callback,
 126                                                                    gpointer                user_data);
 127 static GFileOutputStream *g_file_real_append_to_finish            (GFile                  *file,
 128                                                                    GAsyncResult           *res,
 129                                                                    GError                **error);
 130 static void               g_file_real_create_async                (GFile                  *file,
 131                                                                    GFileCreateFlags        flags,
 132                                                                    int                     io_priority,
 133                                                                    GCancellable           *cancellable,
 134                                                                    GAsyncReadyCallback     callback,
 135                                                                    gpointer                user_data);
 136 static GFileOutputStream *g_file_real_create_finish               (GFile                  *file,
 137                                                                    GAsyncResult           *res,
 138                                                                    GError                **error);
 139 static void               g_file_real_replace_async               (GFile                  *file,
 140                                                                    const char             *etag,
 141                                                                    gboolean                make_backup,
 142                                                                    GFileCreateFlags        flags,
 143                                                                    int                     io_priority,
 144                                                                    GCancellable           *cancellable,
 145                                                                    GAsyncReadyCallback     callback,
 146                                                                    gpointer                user_data);
 147 static GFileOutputStream *g_file_real_replace_finish              (GFile                  *file,
 148                                                                    GAsyncResult           *res,
 149                                                                    GError                **error);
 150 static gboolean           g_file_real_set_attributes_from_info    (GFile                  *file,
 151                                                                    GFileInfo              *info,
 152                                                                    GFileQueryInfoFlags     flags,
 153                                                                    GCancellable           *cancellable,
 154                                                                    GError                **error);
 155 static void               g_file_real_set_display_name_async      (GFile                  *file,
 156                                                                    const char             *display_name,
 157                                                                    int                     io_priority,
 158                                                                    GCancellable           *cancellable,
 159                                                                    GAsyncReadyCallback     callback,
 160                                                                    gpointer                user_data);
 161 static GFile *            g_file_real_set_display_name_finish     (GFile                  *file,
 162                                                                    GAsyncResult           *res,
 163                                                                    GError                **error);
 164 static void               g_file_real_set_attributes_async        (GFile                  *file,
 165                                                                    GFileInfo              *info,
 166                                                                    GFileQueryInfoFlags     flags,
 167                                                                    int                     io_priority,
 168                                                                    GCancellable           *cancellable,
 169                                                                    GAsyncReadyCallback     callback,
 170                                                                    gpointer                user_data);
 171 static gboolean           g_file_real_set_attributes_finish       (GFile                  *file,
 172                                                                    GAsyncResult           *res,
 173                                                                    GFileInfo             **info,
 174                                                                    GError                **error);
 175 static void               g_file_real_find_enclosing_mount_async  (GFile                  *file,
 176                                                                    int                     io_priority,
 177                                                                    GCancellable           *cancellable,
 178                                                                    GAsyncReadyCallback     callback,
 179                                                                    gpointer                user_data);
 180 static GMount *           g_file_real_find_enclosing_mount_finish (GFile                  *file,
 181                                                                    GAsyncResult           *res,
 182                                                                    GError                **error);
 183 static void               g_file_real_copy_async                  (GFile                  *source,
 184                                                                    GFile                  *destination,
 185                                                                    GFileCopyFlags          flags,
 186                                                                    int                     io_priority,
 187                                                                    GCancellable           *cancellable,
 188                                                                    GFileProgressCallback   progress_callback,
 189                                                                    gpointer                progress_callback_data,
 190                                                                    GAsyncReadyCallback     callback,
 191                                                                    gpointer                user_data);
 192 static gboolean           g_file_real_copy_finish                 (GFile                  *file,
 193                                                                    GAsyncResult           *res,
 194                                                                    GError                **error);
 195
 196 GType
 197 g_file_get_type (void)
 198 {
 199   static GType file_type = 0;
 200
 201   if (! file_type)
 202     {
 203       static const GTypeInfo file_info =
 204       {
 205         sizeof (GFileIface), /* class_size */
 206         g_file_base_init,   /* base_init */
 207         NULL,           /* base_finalize */
 208         g_file_class_init,
 209         NULL,           /* class_finalize */
 210         NULL,           /* class_data */
 211         0,
 212         0,              /* n_preallocs */
 213         NULL
 214       };
 215
 216       file_type =
 217         g_type_register_static (G_TYPE_INTERFACE, I_("GFile"),
 218                                 &file_info, 0);
 219
 220       g_type_interface_add_prerequisite (file_type, G_TYPE_OBJECT);
 221     }
 222
 223   return file_type;
 224 }
 225
 226 static void
 227 g_file_class_init (gpointer g_class,
 228                    gpointer class_data)
 229 {
 230   GFileIface *iface = g_class;
 231
 232   iface->enumerate_children_async = g_file_real_enumerate_children_async;
 233   iface->enumerate_children_finish = g_file_real_enumerate_children_finish;
 234   iface->set_display_name_async = g_file_real_set_display_name_async;
 235   iface->set_display_name_finish = g_file_real_set_display_name_finish;
 236   iface->query_info_async = g_file_real_query_info_async;
 237   iface->query_info_finish = g_file_real_query_info_finish;
 238   iface->set_attributes_async = g_file_real_set_attributes_async;
 239   iface->set_attributes_finish = g_file_real_set_attributes_finish;
 240   iface->read_async = g_file_real_read_async;
 241   iface->read_finish = g_file_real_read_finish;
 242   iface->append_to_async = g_file_real_append_to_async;
 243   iface->append_to_finish = g_file_real_append_to_finish;
 244   iface->create_async = g_file_real_create_async;
 245   iface->create_finish = g_file_real_create_finish;
 246   iface->replace_async = g_file_real_replace_async;
 247   iface->replace_finish = g_file_real_replace_finish;
 248   iface->find_enclosing_mount_async = g_file_real_find_enclosing_mount_async;
 249   iface->find_enclosing_mount_finish = g_file_real_find_enclosing_mount_finish;
 250   iface->set_attributes_from_info = g_file_real_set_attributes_from_info;
 251   iface->copy_async = g_file_real_copy_async;
 252   iface->copy_finish = g_file_real_copy_finish;
 253 }
 254
 255 static void
 256 g_file_base_init (gpointer g_class)
 257 {
 258 }
 259
 260
 261 /**
 262  * g_file_is_native:
 263  * @file: input #GFile.
 264  *
 265  * Checks to see if a file is native to the platform.
 266  *
 267  * A native file s one expressed in the platform-native filename format,
 268  * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
 269  * as it might be on a locally mounted remote filesystem.
 270  *
 271  * On some systems non-native files may be available using
 272  * the native filesystem via a userspace filesystem (FUSE), in
 273  * these cases this call will return %FALSE, but g_file_get_path()
 274  * will still return a native path.
 275  *
 276  * This call does no blocking i/o.
 277  *
 278  * Returns: %TRUE if file is native.
 279  **/
 280 gboolean
 281 g_file_is_native (GFile *file)
 282 {
 283   GFileIface *iface;
 284
 285   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 286
 287   iface = G_FILE_GET_IFACE (file);
 288
 289   return (* iface->is_native) (file);
 290 }
 291
 292
 293 /**
 294  * g_file_has_uri_scheme:
 295  * @file: input #GFile.
 296  * @uri_scheme: a string containing a URI scheme.
 297  *
 298  * Checks to see if a #GFile has a given URI scheme.
 299  *
 300  * This call does no blocking i/o.
 301  *
 302  * Returns: %TRUE if #GFile's backend supports the
 303  *     given URI scheme, %FALSE if URI scheme is %NULL,
 304  *     not supported, or #GFile is invalid.
 305  **/
 306 gboolean
 307 g_file_has_uri_scheme (GFile      *file,
 308                        const char *uri_scheme)
 309 {
 310   GFileIface *iface;
 311
 312   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 313   g_return_val_if_fail (uri_scheme != NULL, FALSE);
 314
 315   iface = G_FILE_GET_IFACE (file);
 316
 317   return (* iface->has_uri_scheme) (file, uri_scheme);
 318 }
 319
 320
 321 /**
 322  * g_file_get_uri_scheme:
 323  * @file: input #GFile.
 324  *
 325  * Gets the URI scheme for a #GFile.
 326  * RFC 3986 decodes the scheme as:
 327  * <programlisting>
 328  * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 329  * </programlisting>
 330  * Common schemes include "file", "http", "ftp", etc.
 331  *
 332  * This call does no blocking i/o.
 333  *
 334  * Returns: a string containing the URI scheme for the given
 335  *     #GFile. The returned string should be freed with g_free()
 336  *     when no longer needed.
 337  **/
 338 char *
 339 g_file_get_uri_scheme (GFile *file)
 340 {
 341   GFileIface *iface;
 342
 343   g_return_val_if_fail (G_IS_FILE (file), NULL);
 344
 345   iface = G_FILE_GET_IFACE (file);
 346
 347   return (* iface->get_uri_scheme) (file);
 348 }
 349
 350
 351 /**
 352  * g_file_get_basename:
 353  * @file: input #GFile.
 354  *
 355  * Gets the base name (the last component of the path) for a given #GFile.
 356  *
 357  * If called for the top level of a system (such as the filesystem root
 358  * or a uri like sftp://host/ it will return a single directory separator
 359  * (and on Windows, possibly a drive letter).
 360  *
 361  * This call does no blocking i/o.
 362  *
 363  * Returns: string containing the #GFile's base name, or %NULL
 364  *     if given #GFile is invalid. The returned string should be
 365  *     freed with g_free() when no longer needed.
 366  **/
 367 char *
 368 g_file_get_basename (GFile *file)
 369 {
 370   GFileIface *iface;
 371
 372   g_return_val_if_fail (G_IS_FILE (file), NULL);
 373
 374   iface = G_FILE_GET_IFACE (file);
 375
 376   return (* iface->get_basename) (file);
 377 }
 378
 379 /**
 380  * g_file_get_path:
 381  * @file: input #GFile.
 382  *
 383  * Gets the local pathname for #GFile, if one exists.
 384  *
 385  * This call does no blocking i/o.
 386  *
 387  * Returns: string containing the #GFile's path, or %NULL if
 388  *     no such path exists. The returned string should be
 389  *     freed with g_free() when no longer needed.
 390  **/
 391 char *
 392 g_file_get_path (GFile *file)
 393 {
 394   GFileIface *iface;
 395
 396   g_return_val_if_fail (G_IS_FILE (file), NULL);
 397
 398   iface = G_FILE_GET_IFACE (file);
 399
 400   return (* iface->get_path) (file);
 401 }
 402
 403 /**
 404  * g_file_get_uri:
 405  * @file: input #GFile.
 406  *
 407  * Gets the URI for the @file.
 408  *
 409  * This call does no blocking i/o.
 410  *
 411  * Returns: a string containing the #GFile's URI.
 412  *     The returned string should be freed with g_free() when no longer needed.
 413  **/
 414 char *
 415 g_file_get_uri (GFile *file)
 416 {
 417   GFileIface *iface;
 418
 419   g_return_val_if_fail (G_IS_FILE (file), NULL);
 420
 421   iface = G_FILE_GET_IFACE (file);
 422
 423   return (* iface->get_uri) (file);
 424 }
 425
 426 /**
 427  * g_file_get_parse_name:
 428  * @file: input #GFile.
 429  *
 430  * Gets the parse name of the @file.
 431  * A parse name is a UTF-8 string that describes the
 432  * file such that one can get the #GFile back using
 433  * g_file_parse_name().
 434  *
 435  * This is generally used to show the #GFile as a nice
 436  * string in a user interface, like in a location entry.
 437  *
 438  * For local files with names that can safely be converted
 439  * to UTF8 the pathname is used, otherwise the IRI is used
 440  * (a form of URI that allows UTF8 characters unescaped).
 441  *
 442  * This call does no blocking i/o.
 443  *
 444  * Returns: a string containing the #GFile's parse name. The returned
 445  *     string should be freed with g_free() when no longer needed.
 446  **/
 447 char *
 448 g_file_get_parse_name (GFile *file)
 449 {
 450   GFileIface *iface;
 451
 452   g_return_val_if_fail (G_IS_FILE (file), NULL);
 453
 454   iface = G_FILE_GET_IFACE (file);
 455
 456   return (* iface->get_parse_name) (file);
 457 }
 458
 459 /**
 460  * g_file_dup:
 461  * @file: input #GFile.
 462  *
 463  * Duplicates a #GFile handle. This operation does not duplicate
 464  * the actual file or directory represented by the #GFile; see
 465  * g_file_copy() if attempting to copy a file.
 466  *
 467  * This call does no blocking i/o.
 468  *
 469  * Returns: #GFile that is a duplicate of the given #GFile.
 470  **/
 471 GFile *
 472 g_file_dup (GFile *file)
 473 {
 474   GFileIface *iface;
 475
 476   g_return_val_if_fail (G_IS_FILE (file), NULL);
 477
 478   iface = G_FILE_GET_IFACE (file);
 479
 480   return (* iface->dup) (file);
 481 }
 482
 483 /**
 484  * g_file_hash:
 485  * @file: #gconstpointer to a #GFile.
 486  *
 487  * Creates a hash value for a #GFile.
 488  *
 489  * This call does no blocking i/o.
 490  *
 491  * Returns: 0 if @file is not a valid #GFile, otherwise an
 492  *     integer that can be used as hash value for the #GFile.
 493  *     This function is intended for easily hashing a #GFile to
 494  *     add to a #GHashTable or similar data structure.
 495  **/
 496 guint
 497 g_file_hash (gconstpointer file)
 498 {
 499   GFileIface *iface;
 500
 501   g_return_val_if_fail (G_IS_FILE (file), 0);
 502
 503   iface = G_FILE_GET_IFACE (file);
 504
 505   return (* iface->hash) ((GFile *)file);
 506 }
 507
 508 /**
 509  * g_file_equal:
 510  * @file1: the first #GFile.
 511  * @file2: the second #GFile.
 512  *
 513  * Checks equality of two given #GFile<!-- -->s
 514  *
 515  * This call does no blocking i/o.
 516  *
 517  * Returns: %TRUE if @file1 and @file2 are equal.
 518  *     %FALSE if either is not a #GFile.
 519  **/
 520 gboolean
 521 g_file_equal (GFile *file1,
 522               GFile *file2)
 523 {
 524   GFileIface *iface;
 525
 526   g_return_val_if_fail (G_IS_FILE (file1), FALSE);
 527   g_return_val_if_fail (G_IS_FILE (file2), FALSE);
 528
 529   if (G_TYPE_FROM_INSTANCE (file1) != G_TYPE_FROM_INSTANCE (file2))
 530     return FALSE;
 531
 532   iface = G_FILE_GET_IFACE (file1);
 533
 534   return (* iface->equal) (file1, file2);
 535 }
 536
 537
 538 /**
 539  * g_file_get_parent:
 540  * @file: input #GFile.
 541  *
 542  * Gets the parent directory for the @file.
 543  * If the @file represents the root directory of the
 544  * file system, then %NULL will be returned.
 545  *
 546  * This call does no blocking i/o.
 547  *
 548  * Returns: a #GFile structure to the parent of the given
 549  *     #GFile or %NULL if there is no parent.
 550  **/
 551 GFile *
 552 g_file_get_parent (GFile *file)
 553 {
 554   GFileIface *iface;
 555
 556   g_return_val_if_fail (G_IS_FILE (file), NULL);
 557
 558   iface = G_FILE_GET_IFACE (file);
 559
 560   return (* iface->get_parent) (file);
 561 }
 562
 563 /**
 564  * g_file_get_child:
 565  * @file: input #GFile.
 566  * @name: string containing the child's name.
 567  *
 568  * Gets a specific child of @file with name equal to @name.
 569  *
 570  * Note that the file with that specific name might not exist, but
 571  * you can still have a #GFile that points to it. You can use this
 572  * for instance to create that file.
 573  *
 574  * This call does no blocking i/o.
 575  *
 576  * Returns: a #GFile to a child specified by @name.
 577  **/
 578 GFile *
 579 g_file_get_child (GFile      *file,
 580                   const char *name)
 581 {
 582   g_return_val_if_fail (G_IS_FILE (file), NULL);
 583   g_return_val_if_fail (name != NULL, NULL);
 584
 585   return g_file_resolve_relative_path (file, name);
 586 }
 587
 588 /**
 589  * g_file_get_child_for_display_name:
 590  * @file: input #GFile.
 591  * @display_name: string to a possible child.
 592  * @error: #GError.
 593  *
 594  * Gets the child of @file for a given @display_name (i.e. a UTF8
 595  * version of the name). If this function fails, it returns %NULL and @error will be
 596  * set. This is very useful when constructing a GFile for a new file
 597  * and the user entered the filename in the user interface, for instance
 598  * when you select a directory and type a filename in the file selector.
 599  *
 600  * This call does no blocking i/o.
 601  *
 602  * Returns: a #GFile to the specified child, or
 603  *     %NULL if the display name couldn't be converted.
 604  **/
 605 GFile *
 606 g_file_get_child_for_display_name (GFile      *file,
 607                                    const char *display_name,
 608                                    GError **error)
 609 {
 610   GFileIface *iface;
 611
 612   g_return_val_if_fail (G_IS_FILE (file), NULL);
 613   g_return_val_if_fail (display_name != NULL, NULL);
 614
 615   iface = G_FILE_GET_IFACE (file);
 616
 617   return (* iface->get_child_for_display_name) (file, display_name, error);
 618 }
 619
 620 /**
 621  * g_file_contains_file:
 622  * @parent: input #GFile.
 623  * @descendant: input #GFile.
 624  *
 625  * Checks whether @parent (recursively) contains the specified @descendant.
 626  *
 627  * This call does no blocking i/o.
 628  *
 629  * Returns:  %TRUE if the @descendant's parent, grandparent, etc is @parent. %FALSE otherwise.
 630  **/
 631 gboolean
 632 g_file_contains_file (GFile *parent,
 633                       GFile *descendant)
 634 {
 635   GFileIface *iface;
 636
 637   g_return_val_if_fail (G_IS_FILE (parent), FALSE);
 638   g_return_val_if_fail (G_IS_FILE (descendant), FALSE);
 639
 640   if (G_TYPE_FROM_INSTANCE (parent) != G_TYPE_FROM_INSTANCE (descendant))
 641     return FALSE;
 642
 643   iface = G_FILE_GET_IFACE (parent);
 644
 645   return (* iface->contains_file) (parent, descendant);
 646 }
 647
 648 /**
 649  * g_file_get_relative_path:
 650  * @parent: input #GFile.
 651  * @descendant: input #GFile.
 652  *
 653  * Gets the path for @descendant relative to @parent.
 654  *
 655  * This call does no blocking i/o.
 656  *
 657  * Returns: string with the relative path from @descendant
 658  *     to @parent, or %NULL if @descendant is not a descendant of @parent. The returned string should be freed with
 659  *     g_free() when no longer needed.
 660  **/
 661 char *
 662 g_file_get_relative_path (GFile *parent,
 663                           GFile *descendant)
 664 {
 665   GFileIface *iface;
 666
 667   g_return_val_if_fail (G_IS_FILE (parent), NULL);
 668   g_return_val_if_fail (G_IS_FILE (descendant), NULL);
 669
 670   if (G_TYPE_FROM_INSTANCE (parent) != G_TYPE_FROM_INSTANCE (descendant))
 671     return NULL;
 672
 673   iface = G_FILE_GET_IFACE (parent);
 674
 675   return (* iface->get_relative_path) (parent, descendant);
 676 }
 677
 678 /**
 679  * g_file_resolve_relative_path:
 680  * @file: input #GFile.
 681  * @relative_path: a given relative path string.
 682  *
 683  * Resolves a relative path for @file to an absolute path.
 684  *
 685  * This call does no blocking i/o.
 686  *
 687  * Returns: #GFile to the resolved path. %NULL if @relative_path
 688  *     is %NULL or if @file is invalid.
 689  **/
 690 GFile *
 691 g_file_resolve_relative_path (GFile      *file,
 692                               const char *relative_path)
 693 {
 694   GFileIface *iface;
 695
 696   g_return_val_if_fail (G_IS_FILE (file), NULL);
 697   g_return_val_if_fail (relative_path != NULL, NULL);
 698
 699   iface = G_FILE_GET_IFACE (file);
 700
 701   return (* iface->resolve_relative_path) (file, relative_path);
 702 }
 703
 704 /**
 705  * g_file_enumerate_children:
 706  * @file: input #GFile.
 707  * @attributes: an attribute query string.
 708  * @flags: a set of #GFileQueryInfoFlags.
 709  * @cancellable: optional #GCancellable object, %NULL to ignore.
 710  * @error: #GError for error reporting.
 711  *
 712  * Gets the requested information about the files in a directory. The result
 713  * is a #GFileEnumerator object that will give out #GFileInfo objects for
 714  * all the files in the directory.
 715  *
 716  * The @attribute value is a string that specifies the file attributes that
 717  * should be gathered. It is not an error if it's not possible to read a particular
 718  * requested attribute from a file - it just won't be set. @attribute should
 719  * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
 720  * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
 721  * namespace. An example attribute query be "standard::*,owner::user".
 722  * The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
 723  *
 724  * If @cancellable is not %NULL, then the operation can be cancelled by
 725  * triggering the cancellable object from another thread. If the operation
 726  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
 727  *
 728  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
 729  * If the file is not a directory, the G_FILE_ERROR_NOTDIR error will be returned.
 730  * Other errors are possible too.
 731  *
 732  * Returns: A #GFileEnumerator if successful, %NULL on error.
 733  **/
 734 GFileEnumerator *
 735 g_file_enumerate_children (GFile                *file,
 736                            const char           *attributes,
 737                            GFileQueryInfoFlags   flags,
 738                            GCancellable         *cancellable,
 739                            GError              **error)
 740
 741 {
 742   GFileIface *iface;
 743
 744   g_return_val_if_fail (G_IS_FILE (file), NULL);
 745
 746   if (g_cancellable_set_error_if_cancelled (cancellable, error))
 747     return NULL;
 748
 749   iface = G_FILE_GET_IFACE (file);
 750
 751   if (iface->enumerate_children == NULL)
 752     {
 753       g_set_error (error, G_IO_ERROR,
 754                    G_IO_ERROR_NOT_SUPPORTED,
 755                    _("Operation not supported"));
 756       return NULL;
 757     }
 758
 759   return (* iface->enumerate_children) (file, attributes, flags,
 760                                         cancellable, error);
 761 }
 762
 763 /**
 764  * g_file_enumerate_children_async:
 765  * @file: input #GFile.
 766  * @attributes: an attribute query string.
 767  * @flags: a set of #GFileQueryInfoFlags.
 768  * @io_priority: the <link linkend="io-priority">I/O priority</link>
 769  *     of the request.
 770  * @cancellable: optional #GCancellable object, %NULL to ignore.
 771  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
 772  * @user_data: the data to pass to callback function
 773  *
 774  * Asynchronously gets the requested information about the files in a directory. The result
 775  * is a #GFileEnumerator object that will give out #GFileInfo objects for
 776  * all the files in the directory.
 777  *
 778  * For more details, see g_file_enumerate_children() which is
 779  * the synchronous version of this call.
 780  *
 781  * When the operation is finished, @callback will be called. You can then call
 782  * g_file_enumerate_children_finish() to get the result of the operation.
 783  **/
 784 void
 785 g_file_enumerate_children_async (GFile               *file,
 786                                  const char          *attributes,
 787                                  GFileQueryInfoFlags  flags,
 788                                  int                  io_priority,
 789                                  GCancellable        *cancellable,
 790                                  GAsyncReadyCallback  callback,
 791                                  gpointer             user_data)
 792 {
 793   GFileIface *iface;
 794
 795   g_return_if_fail (G_IS_FILE (file));
 796
 797   iface = G_FILE_GET_IFACE (file);
 798   (* iface->enumerate_children_async) (file,
 799                                        attributes,
 800                                        flags,
 801                                        io_priority,
 802                                        cancellable,
 803                                        callback,
 804                                        user_data);
 805 }
 806
 807 /**
 808  * g_file_enumerate_children_finish:
 809  * @file: input #GFile.
 810  * @res: a #GAsyncResult.
 811  * @error: a #GError.
 812  *
 813  * Finishes an async enumerate children operation.
 814  * See g_file_enumerate_children_async().
 815  *
 816  * Returns: a #GFileEnumerator or %NULL if an error occurred.
 817  **/
 818 GFileEnumerator *
 819 g_file_enumerate_children_finish (GFile         *file,
 820                                   GAsyncResult  *res,
 821                                   GError       **error)
 822 {
 823   GFileIface *iface;
 824
 825   g_return_val_if_fail (G_IS_FILE (file), NULL);
 826   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
 827
 828   if (G_IS_SIMPLE_ASYNC_RESULT (res))
 829     {
 830       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
 831       if (g_simple_async_result_propagate_error (simple, error))
 832         return NULL;
 833     }
 834
 835   iface = G_FILE_GET_IFACE (file);
 836   return (* iface->enumerate_children_finish) (file, res, error);
 837 }
 838
 839 /**
 840  * g_file_query_exists:
 841  * @file: input #GFile.
 842  * @cancellable: optional #GCancellable object, %NULL to ignore.
 843  *
 844  * Utility function to check if a particular file exists. This is
 845  * implemented using g_file_query_info() and as such does blocking I/O.
 846  *
 847  * Note that in many cases it is racy to first check for file existance
 848  * and then execute something based on the outcome of that, because the
 849  * file might have been created or removed inbetween the operations. The
 850  * general approach to handling that is to not check, but just do the
 851  * operation and handle the errors as they come.
 852  *
 853  * As an example of race-free checking, take the case of reading a file, and
 854  * if it doesn't exist, creating it. There are two racy versions: read it, and
 855  * on error create it; and: check if it exists, if not create it. These
 856  * can both result in two processes creating the file (with perhaps a partially
 857  * written file as the result). The correct approach is to always try to create
 858  * the file with g_file_create() which will either atomically create the file
 859  * or fail with a G_IO_ERROR_EXISTS error.
 860  *
 861  * However, in many cases an existance check is useful in a user
 862  * interface, for instance to make a menu item sensitive/insensitive, so that
 863  * you don't have to fool users that something is possible and then just show
 864  * and error dialog. If you do this, you should make sure to also handle the
 865  * errors that can happen due to races when you execute the operation.
 866  *
 867  * Returns: %TRUE if the file exists (and can be detected without error), %FALSE otherwise (or if cancelled).
 868  */
 869 gboolean
 870 g_file_query_exists (GFile *file,
 871                      GCancellable *cancellable)
 872 {
 873   GFileInfo *info;
 874
 875   info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE,
 876                             G_FILE_QUERY_INFO_NONE,
 877                             cancellable, NULL);
 878   if (info != NULL)
 879     {
 880       g_object_unref (info);
 881       return TRUE;
 882     }
 883
 884   return FALSE;
 885 }
 886
 887 /**
 888  * g_file_query_info:
 889  * @file: input #GFile.
 890  * @attributes: an attribute query string.
 891  * @flags: a set of #GFileQueryInfoFlags.
 892  * @cancellable: optional #GCancellable object, %NULL to ignore.
 893  * @error: a #GError.
 894  *
 895  * Gets the requested information about specified @file. The result
 896  * is a #GFileInfo object that contains key-value attributes (such as
 897  * the type or size of the file).
 898  *
 899  * The @attribute value is a string that specifies the file attributes that
 900  * should be gathered. It is not an error if it's not possible to read a particular
 901  * requested attribute from a file - it just won't be set. @attribute should
 902  * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
 903  * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
 904  * namespace. An example attribute query be "standard::*,owner::user".
 905  * The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
 906  *
 907  * If @cancellable is not %NULL, then the operation can be cancelled by
 908  * triggering the cancellable object from another thread. If the operation
 909  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
 910  *
 911  * For symlinks, normally the information about the target of the
 912  * symlink is returned, rather than information about the symlink itself.
 913  * However if you pass #G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in @flags the
 914  * information about the symlink itself will be returned. Also, for symlinks
 915  * that point to non-existing files the information about the symlink itself
 916  * will be returned.
 917  *
 918  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
 919  * Other errors are possible too, and depend on what kind of filesystem the file is on.
 920  *
 921  * Returns: a #GFileInfo for the given @file, or %NULL on error.
 922  **/
 923 GFileInfo *
 924 g_file_query_info (GFile                *file,
 925                    const char           *attributes,
 926                    GFileQueryInfoFlags   flags,
 927                    GCancellable         *cancellable,
 928                    GError              **error)
 929 {
 930   GFileIface *iface;
 931
 932   g_return_val_if_fail (G_IS_FILE (file), NULL);
 933
 934   if (g_cancellable_set_error_if_cancelled (cancellable, error))
 935     return NULL;
 936
 937   iface = G_FILE_GET_IFACE (file);
 938
 939   if (iface->query_info == NULL)
 940     {
 941       g_set_error (error, G_IO_ERROR,
 942                    G_IO_ERROR_NOT_SUPPORTED,
 943                    _("Operation not supported"));
 944       return NULL;
 945     }
 946
 947   return (* iface->query_info) (file, attributes, flags, cancellable, error);
 948 }
 949
 950 /**
 951  * g_file_query_info_async:
 952  * @file: input #GFile.
 953  * @attributes: an attribute query string.
 954  * @flags: a set of #GFileQueryInfoFlags.
 955  * @io_priority: the <link linkend="io-priority">I/O priority</link>
 956  *     of the request.
 957  * @cancellable: optional #GCancellable object, %NULL to ignore.
 958  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
 959  * @user_data: the data to pass to callback function
 960  *
 961  * Asynchronously gets the requested information about specified @file. The result
 962  * is a #GFileInfo object that contains key-value attributes (such as type or size
 963  * for the file).
 964  *
 965  * For more details, see g_file_query_info() which is
 966  * the synchronous version of this call.
 967  *
 968  * When the operation is finished, @callback will be called. You can then call
 969  * g_file_query_info_finish() to get the result of the operation.
 970  **/
 971 void
 972 g_file_query_info_async (GFile               *file,
 973                          const char          *attributes,
 974                          GFileQueryInfoFlags  flags,
 975                          int                  io_priority,
 976                          GCancellable        *cancellable,
 977                          GAsyncReadyCallback  callback,
 978                          gpointer             user_data)
 979 {
 980   GFileIface *iface;
 981
 982   g_return_if_fail (G_IS_FILE (file));
 983
 984   iface = G_FILE_GET_IFACE (file);
 985   (* iface->query_info_async) (file,
 986                                attributes,
 987                                flags,
 988                                io_priority,
 989                                cancellable,
 990                                callback,
 991                                user_data);
 992 }
 993
 994 /**
 995  * g_file_query_info_finish:
 996  * @file: input #GFile.
 997  * @res: a #GAsyncResult.
 998  * @error: a #GError.
 999  *
1000  * Finishes an asynchronous file info query.
1001  * See g_file_query_info_async().
1002  *
1003  * Returns: #GFileInfo for given @file or %NULL on error.
1004  **/
1005 GFileInfo *
1006 g_file_query_info_finish (GFile         *file,
1007                           GAsyncResult  *res,
1008                           GError       **error)
1009 {
1010   GFileIface *iface;
1011
1012   g_return_val_if_fail (G_IS_FILE (file), NULL);
1013   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1014
1015   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1016     {
1017       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1018       if (g_simple_async_result_propagate_error (simple, error))
1019         return NULL;
1020     }
1021
1022   iface = G_FILE_GET_IFACE (file);
1023   return (* iface->query_info_finish) (file, res, error);
1024 }
1025
1026 /**
1027  * g_file_query_filesystem_info:
1028  * @file: input #GFile.
1029  * @attributes:  an attribute query string.
1030  * @cancellable: optional #GCancellable object, %NULL to ignore.
1031  * @error: a #GError.
1032  *
1033  * Similar to g_file_query_info(), but obtains information
1034  * about the filesystem the @file is on, rather than the file itself.
1035  * For instance the amount of space available and the type of
1036  * the filesystem.
1037  *
1038  * The @attribute value is a string that specifies the file attributes that
1039  * should be gathered. It is not an error if it's not possible to read a particular
1040  * requested attribute from a file - it just won't be set. @attribute should
1041  * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
1042  * means all attributes, and a wildcard like "fs:*" means all attributes in the fs
1043  * namespace. The standard namespace for filesystem attributes is "fs".
1044  * Common attributes of interest are #G_FILE_ATTRIBUTE_FILESYSTEM_SIZE
1045  * (the total size of the filesystem in bytes), #G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
1046  * bytes available), and #G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
1047  *
1048  * If @cancellable is not %NULL, then the operation can be cancelled by
1049  * triggering the cancellable object from another thread. If the operation
1050  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1051  *
1052  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1053  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1054  *
1055  * Returns: a #GFileInfo or %NULL if there was an error.
1056  **/
1057 GFileInfo *
1058 g_file_query_filesystem_info (GFile         *file,
1059                               const char    *attributes,
1060                               GCancellable  *cancellable,
1061                               GError       **error)
1062 {
1063   GFileIface *iface;
1064
1065   g_return_val_if_fail (G_IS_FILE (file), NULL);
1066
1067   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1068     return NULL;
1069
1070   iface = G_FILE_GET_IFACE (file);
1071
1072   if (iface->query_filesystem_info == NULL)
1073     {
1074       g_set_error (error, G_IO_ERROR,
1075                    G_IO_ERROR_NOT_SUPPORTED,
1076                    _("Operation not supported"));
1077       return NULL;
1078     }
1079
1080   return (* iface->query_filesystem_info) (file, attributes, cancellable, error);
1081 }
1082
1083 /**
1084  * g_file_find_enclosing_mount:
1085  * @file: input #GFile.
1086  * @cancellable: optional #GCancellable object, %NULL to ignore.
1087  * @error: a #GError.
1088  *
1089  * Gets a #GMount for the #GFile.
1090  *
1091  * If the #GFileIface for @file does not have a mount (e.g. possibly a
1092  * remote share), @error will be set to %G_IO_ERROR_NOT_FOUND and %NULL
1093  * will be returned.
1094  *
1095  * If @cancellable is not %NULL, then the operation can be cancelled by
1096  * triggering the cancellable object from another thread. If the operation
1097  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1098  *
1099  * Returns: a #GMount where the @file is located or %NULL on error.
1100  **/
1101 GMount *
1102 g_file_find_enclosing_mount (GFile         *file,
1103                              GCancellable  *cancellable,
1104                              GError       **error)
1105 {
1106   GFileIface *iface;
1107
1108   g_return_val_if_fail (G_IS_FILE (file), NULL);
1109
1110   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1111     return NULL;
1112
1113   iface = G_FILE_GET_IFACE (file);
1114   if (iface->find_enclosing_mount == NULL)
1115     {
1116       g_set_error (error, G_IO_ERROR,
1117                    G_IO_ERROR_NOT_FOUND,
1118                    _("Containing mount does not exist"));
1119       return NULL;
1120     }
1121
1122   return (* iface->find_enclosing_mount) (file, cancellable, error);
1123 }
1124 /**
1125  * g_file_find_enclosing_mount_async:
1126  * @file: a #GFile
1127  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1128  *     of the request.
1129  * @cancellable: optional #GCancellable object, %NULL to ignore.
1130  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1131  * @user_data: the data to pass to callback function
1132  *
1133  * Asynchronously gets the mount for the file.
1134  *
1135  * For more details, see g_file_find_enclosing_mount() which is
1136  * the synchronous version of this call.
1137  *
1138  * When the operation is finished, @callback will be called. You can then call
1139  * g_file_find_enclosing_mount_finish() to get the result of the operation.
1140  */
1141 void
1142 g_file_find_enclosing_mount_async (GFile              *file,
1143                                    int                   io_priority,
1144                                    GCancellable         *cancellable,
1145                                    GAsyncReadyCallback   callback,
1146                                    gpointer              user_data)
1147 {
1148   GFileIface *iface;
1149
1150   g_return_if_fail (G_IS_FILE (file));
1151
1152   iface = G_FILE_GET_IFACE (file);
1153   (* iface->find_enclosing_mount_async) (file,
1154                                          io_priority,
1155                                          cancellable,
1156                                          callback,
1157                                          user_data);
1158 }
1159
1160 /**
1161  * g_file_find_enclosing_mount_finish:
1162  * @file: a #GFile
1163  * @res: a #GAsyncResult
1164  * @error: a #GError
1165  *
1166  * Finishes an asynchronous find mount request.
1167  * See g_file_find_enclosing_mount_async().
1168  *
1169  * Returns: #GMount for given @file or %NULL on error.
1170  **/
1171 GMount *
1172 g_file_find_enclosing_mount_finish (GFile         *file,
1173                                     GAsyncResult  *res,
1174                                     GError       **error)
1175 {
1176   GFileIface *iface;
1177
1178   g_return_val_if_fail (G_IS_FILE (file), NULL);
1179   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1180
1181   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1182     {
1183       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1184       if (g_simple_async_result_propagate_error (simple, error))
1185         return NULL;
1186     }
1187
1188   iface = G_FILE_GET_IFACE (file);
1189   return (* iface->find_enclosing_mount_finish) (file, res, error);
1190 }
1191
1192
1193 /**
1194  * g_file_read:
1195  * @file: #GFile to read.
1196  * @cancellable: a #GCancellable
1197  * @error: a #GError, or %NULL
1198  *
1199  * Opens a file for reading. The result is a #GFileInputStream that
1200  * can be used to read the contents of the file.
1201  *
1202  * If @cancellable is not %NULL, then the operation can be cancelled by
1203  * triggering the cancellable object from another thread. If the operation
1204  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1205  *
1206  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1207  * If the file is a directory, the G_IO_ERROR_IS_DIRECTORY error will be returned.
1208  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1209  *
1210  * Returns: #GFileInputStream or %NULL on error.
1211  **/
1212 GFileInputStream *
1213 g_file_read (GFile         *file,
1214              GCancellable  *cancellable,
1215              GError       **error)
1216 {
1217   GFileIface *iface;
1218
1219   g_return_val_if_fail (G_IS_FILE (file), NULL);
1220
1221   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1222     return NULL;
1223
1224   iface = G_FILE_GET_IFACE (file);
1225
1226   if (iface->read_fn == NULL)
1227     {
1228       g_set_error (error, G_IO_ERROR,
1229                    G_IO_ERROR_NOT_SUPPORTED,
1230                    _("Operation not supported"));
1231       return NULL;
1232     }
1233
1234   return (* iface->read_fn) (file, cancellable, error);
1235 }
1236
1237 /**
1238  * g_file_append_to:
1239  * @file: input #GFile.
1240  * @flags: a set of #GFileCreateFlags.
1241  * @cancellable: optional #GCancellable object, %NULL to ignore.
1242  * @error: a #GError, or %NULL
1243  *
1244  * Gets an output stream for appending data to the file. If
1245  * the file doesn't already exist it is created.
1246  *
1247  * By default files created are generally readable by everyone,
1248  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1249  * will be made readable only to the current user, to the level that
1250  * is supported on the target filesystem.
1251  *
1252  * If @cancellable is not %NULL, then the operation can be cancelled by
1253  * triggering the cancellable object from another thread. If the operation
1254  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1255  *
1256  * Some file systems don't allow all file names, and may
1257  * return an G_IO_ERROR_INVALID_FILENAME error.
1258  * If the file is a directory the G_IO_ERROR_IS_DIRECTORY error will be
1259  * returned. Other errors are possible too, and depend on what kind of
1260  * filesystem the file is on.
1261  *
1262  * Returns: a #GFileOutputStream.
1263  **/
1264 GFileOutputStream *
1265 g_file_append_to (GFile             *file,
1266                   GFileCreateFlags   flags,
1267                   GCancellable      *cancellable,
1268                   GError           **error)
1269 {
1270   GFileIface *iface;
1271
1272   g_return_val_if_fail (G_IS_FILE (file), NULL);
1273
1274   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1275     return NULL;
1276
1277   iface = G_FILE_GET_IFACE (file);
1278
1279   if (iface->append_to == NULL)
1280     {
1281       g_set_error (error, G_IO_ERROR,
1282                    G_IO_ERROR_NOT_SUPPORTED,
1283                    _("Operation not supported"));
1284       return NULL;
1285     }
1286
1287   return (* iface->append_to) (file, flags, cancellable, error);
1288 }
1289
1290 /**
1291  * g_file_create:
1292  * @file: input #GFile.
1293  * @flags: a set of #GFileCreateFlags.
1294  * @cancellable: optional #GCancellable object, %NULL to ignore.
1295  * @error: a #GError, or %NULL
1296  *
1297  * Creates a new file and returns an output stream for writing to it.
1298  * The file must not already exists.
1299  *
1300  * By default files created are generally readable by everyone,
1301  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1302  * will be made readable only to the current user, to the level that
1303  * is supported on the target filesystem.
1304  *
1305  * If @cancellable is not %NULL, then the operation can be cancelled by
1306  * triggering the cancellable object from another thread. If the operation
1307  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1308  *
1309  * If a file with this name already exists the G_IO_ERROR_EXISTS error
1310  * will be returned. If the file is a directory the G_IO_ERROR_IS_DIRECTORY
1311  * error will be returned.
1312  * Some file systems don't allow all file names, and may
1313  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1314  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1315  * Other errors are possible too, and depend on what kind of
1316  * filesystem the file is on.
1317  *
1318  * Returns: a #GFileOutputStream for the newly created file, or
1319  * %NULL on error.
1320  **/
1321 GFileOutputStream *
1322 g_file_create (GFile             *file,
1323                GFileCreateFlags   flags,
1324                GCancellable      *cancellable,
1325                GError           **error)
1326 {
1327   GFileIface *iface;
1328
1329   g_return_val_if_fail (G_IS_FILE (file), NULL);
1330
1331   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1332     return NULL;
1333
1334   iface = G_FILE_GET_IFACE (file);
1335
1336   if (iface->create == NULL)
1337     {
1338       g_set_error (error, G_IO_ERROR,
1339                    G_IO_ERROR_NOT_SUPPORTED,
1340                    _("Operation not supported"));
1341       return NULL;
1342     }
1343
1344   return (* iface->create) (file, flags, cancellable, error);
1345 }
1346
1347 /**
1348  * g_file_replace:
1349  * @file: input #GFile.
1350  * @etag: an optional <link linkend="gfile-etag">entity tag</link> for the
1351  *     current #GFile, or #NULL to ignore.
1352  * @make_backup: %TRUE if a backup should be created.
1353  * @flags: a set of #GFileCreateFlags.
1354  * @cancellable: optional #GCancellable object, %NULL to ignore.
1355  * @error: a #GError, or %NULL
1356  *
1357  * Returns an output stream for overwriting the file, possibly
1358  * creating a backup copy of the file first.
1359  *
1360  * This will try to replace the file in the safest way possible so
1361  * that any errors during the writing will not affect an already
1362  * existing copy of the file. For instance, for local files it
1363  * may write to a temporary file and then atomically rename over
1364  * the destination when the stream is closed.
1365  *
1366  * By default files created are generally readable by everyone,
1367  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1368  * will be made readable only to the current user, to the level that
1369  * is supported on the target filesystem.
1370  *
1371  * If @cancellable is not %NULL, then the operation can be cancelled by
1372  * triggering the cancellable object from another thread. If the operation
1373  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1374  *
1375  * If you pass in a non-#NULL @etag value, then this value is
1376  * compared to the current entity tag of the file, and if they differ
1377  * an G_IO_ERROR_WRONG_ETAG error is returned. This generally means
1378  * that the file has been changed since you last read it. You can get
1379  * the new etag from g_file_output_stream_get_etag() after you've
1380  * finished writing and closed the #GFileOutputStream. When you load
1381  * a new file you can use g_file_input_stream_query_info() to get
1382  * the etag of the file.
1383  *
1384  * If @make_backup is %TRUE, this function will attempt to make a backup
1385  * of the current file before overwriting it. If this fails a G_IO_ERROR_CANT_CREATE_BACKUP
1386  * error will be returned. If you want to replace anyway, try again with
1387  * @make_backup set to %FALSE.
1388  *
1389  * If the file is a directory the G_IO_ERROR_IS_DIRECTORY error will be returned,
1390  * and if the file is some other form of non-regular file then a
1391  * G_IO_ERROR_NOT_REGULAR_FILE error will be returned.
1392  * Some file systems don't allow all file names, and may
1393  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1394  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1395  * Other errors are possible too, and depend on what kind of
1396  * filesystem the file is on.
1397  *
1398  * Returns: a #GFileOutputStream or %NULL on error.
1399  **/
1400 GFileOutputStream *
1401 g_file_replace (GFile             *file,
1402                 const char        *etag,
1403                 gboolean           make_backup,
1404                 GFileCreateFlags   flags,
1405                 GCancellable      *cancellable,
1406                 GError           **error)
1407 {
1408   GFileIface *iface;
1409
1410   g_return_val_if_fail (G_IS_FILE (file), NULL);
1411
1412   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1413     return NULL;
1414
1415   iface = G_FILE_GET_IFACE (file);
1416
1417   if (iface->replace == NULL)
1418     {
1419       g_set_error (error, G_IO_ERROR,
1420                    G_IO_ERROR_NOT_SUPPORTED,
1421                    _("Operation not supported"));
1422       return NULL;
1423     }
1424
1425
1426   /* Handle empty tag string as NULL in consistent way. */
1427   if (etag && *etag == 0)
1428     etag = NULL;
1429
1430   return (* iface->replace) (file, etag, make_backup, flags, cancellable, error);
1431 }
1432
1433 /**
1434  * g_file_read_async:
1435  * @file: input #GFile.
1436  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1437  *     of the request.
1438  * @cancellable: optional #GCancellable object, %NULL to ignore.
1439  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1440  * @user_data: the data to pass to callback function
1441  *
1442  * Asynchronously opens @file for reading.
1443  *
1444  * For more details, see g_file_read() which is
1445  * the synchronous version of this call.
1446  *
1447  * When the operation is finished, @callback will be called. You can then call
1448  * g_file_read_finish() to get the result of the operation.
1449  **/
1450 void
1451 g_file_read_async (GFile               *file,
1452                    int                  io_priority,
1453                    GCancellable        *cancellable,
1454                    GAsyncReadyCallback  callback,
1455                    gpointer             user_data)
1456 {
1457   GFileIface *iface;
1458
1459   g_return_if_fail (G_IS_FILE (file));
1460
1461   iface = G_FILE_GET_IFACE (file);
1462   (* iface->read_async) (file,
1463                          io_priority,
1464                          cancellable,
1465                          callback,
1466                          user_data);
1467 }
1468
1469 /**
1470  * g_file_read_finish:
1471  * @file: input #GFile.
1472  * @res: a #GAsyncResult.
1473  * @error: a #GError, or %NULL
1474  *
1475  * Finishes an asynchronous file read operation started with
1476  * g_file_read_async().
1477  *
1478  * Returns: a #GFileInputStream or %NULL on error.
1479  **/
1480 GFileInputStream *
1481 g_file_read_finish (GFile         *file,
1482                     GAsyncResult  *res,
1483                     GError       **error)
1484 {
1485   GFileIface *iface;
1486
1487   g_return_val_if_fail (G_IS_FILE (file), NULL);
1488   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1489
1490   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1491     {
1492       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1493       if (g_simple_async_result_propagate_error (simple, error))
1494         return NULL;
1495     }
1496
1497   iface = G_FILE_GET_IFACE (file);
1498   return (* iface->read_finish) (file, res, error);
1499 }
1500
1501 /**
1502  * g_file_append_to_async:
1503  * @file: input #GFile.
1504  * @flags: a set of #GFileCreateFlags.
1505  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1506  *     of the request.
1507  * @cancellable: optional #GCancellable object, %NULL to ignore.
1508  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1509  * @user_data: the data to pass to callback function
1510  *
1511  * Asynchronously opens @file for appending.
1512  *
1513  * For more details, see g_file_append_to() which is
1514  * the synchronous version of this call.
1515  *
1516  * When the operation is finished, @callback will be called. You can then call
1517  * g_file_append_to_finish() to get the result of the operation.
1518  **/
1519 void
1520 g_file_append_to_async (GFile               *file,
1521                         GFileCreateFlags     flags,
1522                         int                  io_priority,
1523                         GCancellable        *cancellable,
1524                         GAsyncReadyCallback  callback,
1525                         gpointer             user_data)
1526 {
1527   GFileIface *iface;
1528
1529   g_return_if_fail (G_IS_FILE (file));
1530
1531   iface = G_FILE_GET_IFACE (file);
1532   (* iface->append_to_async) (file,
1533                               flags,
1534                               io_priority,
1535                               cancellable,
1536                               callback,
1537                               user_data);
1538 }
1539
1540 /**
1541  * g_file_append_to_finish:
1542  * @file: input #GFile.
1543  * @res: #GAsyncResult
1544  * @error: a #GError, or %NULL
1545  *
1546  * Finishes an asynchronous file append operation started with
1547  * g_file_append_to_async().
1548  *
1549  * Returns: a valid #GFileOutputStream or %NULL on error.
1550  **/
1551 GFileOutputStream *
1552 g_file_append_to_finish (GFile         *file,
1553                          GAsyncResult  *res,
1554                          GError       **error)
1555 {
1556   GFileIface *iface;
1557
1558   g_return_val_if_fail (G_IS_FILE (file), NULL);
1559   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1560
1561   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1562     {
1563       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1564       if (g_simple_async_result_propagate_error (simple, error))
1565         return NULL;
1566     }
1567
1568   iface = G_FILE_GET_IFACE (file);
1569   return (* iface->append_to_finish) (file, res, error);
1570 }
1571
1572 /**
1573  * g_file_create_async:
1574  * @file: input #GFile.
1575  * @flags: a set of #GFileCreateFlags.
1576  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1577  *     of the request.
1578  * @cancellable: optional #GCancellable object, %NULL to ignore.
1579  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1580  * @user_data: the data to pass to callback function
1581  *
1582  * Asynchronously creates a new file and returns an output stream for writing to it.
1583  * The file must not already exists.
1584  *
1585  * For more details, see g_file_create() which is
1586  * the synchronous version of this call.
1587  *
1588  * When the operation is finished, @callback will be called. You can then call
1589  * g_file_create_finish() to get the result of the operation.
1590  **/
1591 void
1592 g_file_create_async (GFile               *file,
1593                      GFileCreateFlags     flags,
1594                      int                  io_priority,
1595                      GCancellable        *cancellable,
1596                      GAsyncReadyCallback  callback,
1597                      gpointer             user_data)
1598 {
1599   GFileIface *iface;
1600
1601   g_return_if_fail (G_IS_FILE (file));
1602
1603   iface = G_FILE_GET_IFACE (file);
1604   (* iface->create_async) (file,
1605                            flags,
1606                            io_priority,
1607                            cancellable,
1608                            callback,
1609                            user_data);
1610 }
1611
1612 /**
1613  * g_file_create_finish:
1614  * @file: input #GFile.
1615  * @res: a #GAsyncResult.
1616  * @error: a #GError, or %NULL
1617  *
1618  * Finishes an asynchronous file create operation started with
1619  * g_file_create_async().
1620  *
1621  * Returns: a #GFileOutputStream or %NULL on error.
1622  **/
1623 GFileOutputStream *
1624 g_file_create_finish (GFile         *file,
1625                       GAsyncResult  *res,
1626                       GError       **error)
1627 {
1628   GFileIface *iface;
1629
1630   g_return_val_if_fail (G_IS_FILE (file), NULL);
1631   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1632
1633   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1634     {
1635       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1636       if (g_simple_async_result_propagate_error (simple, error))
1637         return NULL;
1638     }
1639
1640   iface = G_FILE_GET_IFACE (file);
1641   return (* iface->create_finish) (file, res, error);
1642 }
1643
1644 /**
1645  * g_file_replace_async:
1646  * @file: input #GFile.
1647  * @etag: an <link linkend="gfile-etag">entity tag</link> for the
1648  *     current #GFile, or NULL to ignore.
1649  * @make_backup: %TRUE if a backup should be created.
1650  * @flags: a set of #GFileCreateFlags.
1651  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1652  *     of the request.
1653  * @cancellable: optional #GCancellable object, %NULL to ignore.
1654  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1655  * @user_data: the data to pass to callback function
1656  *
1657  * Asynchronously overwrites the file, replacing the contents, possibly
1658  * creating a backup copy of the file first.
1659  *
1660  * For more details, see g_file_replace() which is
1661  * the synchronous version of this call.
1662  *
1663  * When the operation is finished, @callback will be called. You can then call
1664  * g_file_replace_finish() to get the result of the operation.
1665  **/
1666 void
1667 g_file_replace_async (GFile               *file,
1668                       const char          *etag,
1669                       gboolean             make_backup,
1670                       GFileCreateFlags     flags,
1671                       int                  io_priority,
1672                       GCancellable        *cancellable,
1673                       GAsyncReadyCallback  callback,
1674                       gpointer             user_data)
1675 {
1676   GFileIface *iface;
1677
1678   g_return_if_fail (G_IS_FILE (file));
1679
1680   iface = G_FILE_GET_IFACE (file);
1681   (* iface->replace_async) (file,
1682                             etag,
1683                             make_backup,
1684                             flags,
1685                             io_priority,
1686                             cancellable,
1687                             callback,
1688                             user_data);
1689 }
1690
1691 /**
1692  * g_file_replace_finish:
1693  * @file: input #GFile.
1694  * @res: a #GAsyncResult.
1695  * @error: a #GError, or %NULL
1696  *
1697  * Finishes an asynchronous file replace operation started with
1698  * g_file_replace_async().
1699  *
1700  * Returns: a #GFileOutputStream, or %NULL on error.
1701  **/
1702 GFileOutputStream *
1703 g_file_replace_finish (GFile         *file,
1704                        GAsyncResult  *res,
1705                        GError       **error)
1706 {
1707   GFileIface *iface;
1708
1709   g_return_val_if_fail (G_IS_FILE (file), NULL);
1710   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1711
1712   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1713     {
1714       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1715       if (g_simple_async_result_propagate_error (simple, error))
1716         return NULL;
1717     }
1718
1719   iface = G_FILE_GET_IFACE (file);
1720   return (* iface->replace_finish) (file, res, error);
1721 }
1722
1723 static gboolean
1724 copy_symlink (GFile           *destination,
1725               GFileCopyFlags   flags,
1726               GCancellable    *cancellable,
1727               const char      *target,
1728               GError         **error)
1729 {
1730   GError *my_error;
1731   gboolean tried_delete;
1732   GFileInfo *info;
1733   GFileType file_type;
1734
1735   tried_delete = FALSE;
1736
1737  retry:
1738   my_error = NULL;
1739   if (!g_file_make_symbolic_link (destination, target, cancellable, &my_error))
1740     {
1741       /* Maybe it already existed, and we want to overwrite? */
1742       if (!tried_delete && (flags & G_FILE_COPY_OVERWRITE) &&
1743           my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_EXISTS)
1744         {
1745           g_error_free (my_error);
1746
1747
1748           /* Don't overwrite if the destination is a directory */
1749           info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
1750                                     G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1751                                     cancellable, &my_error);
1752           if (info != NULL)
1753             {
1754               file_type = g_file_info_get_file_type (info);
1755               g_object_unref (info);
1756
1757               if (file_type == G_FILE_TYPE_DIRECTORY)
1758                 {
1759                   g_set_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1760                                _("Can't copy over directory"));
1761                   return FALSE;
1762                 }
1763             }
1764
1765           if (!g_file_delete (destination, cancellable, error))
1766             return FALSE;
1767
1768           tried_delete = TRUE;
1769           goto retry;
1770         }
1771             /* Nah, fail */
1772       g_propagate_error (error, my_error);
1773       return FALSE;
1774     }
1775
1776   return TRUE;
1777 }
1778
1779 static GInputStream *
1780 open_source_for_copy (GFile           *source,
1781                       GFile           *destination,
1782                       GFileCopyFlags   flags,
1783                       GCancellable    *cancellable,
1784                       GError         **error)
1785 {
1786   GError *my_error;
1787   GInputStream *in;
1788   GFileInfo *info;
1789   GFileType file_type;
1790
1791   my_error = NULL;
1792   in = (GInputStream *)g_file_read (source, cancellable, &my_error);
1793   if (in != NULL)
1794     return in;
1795
1796   /* There was an error opening the source, try to set a good error for it: */
1797
1798   if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_IS_DIRECTORY)
1799     {
1800       /* The source is a directory, don't fail with WOULD_RECURSE immediately,
1801        * as that is less useful to the app. Better check for errors on the
1802        * target instead.
1803        */
1804       g_error_free (my_error);
1805       my_error = NULL;
1806
1807       info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
1808                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1809                                 cancellable, &my_error);
1810       if (info != NULL)
1811         {
1812           file_type = g_file_info_get_file_type (info);
1813           g_object_unref (info);
1814
1815           if (flags & G_FILE_COPY_OVERWRITE)
1816             {
1817               if (file_type == G_FILE_TYPE_DIRECTORY)
1818                 {
1819                   g_set_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_MERGE,
1820                                _("Can't copy directory over directory"));
1821                   return NULL;
1822                 }
1823               /* continue to would_recurse error */
1824             }
1825           else
1826             {
1827               g_set_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
1828                            _("Target file exists"));
1829               return NULL;
1830             }
1831         }
1832       else
1833         {
1834           /* Error getting info from target, return that error
1835            * (except for NOT_FOUND, which is no error here)
1836            */
1837           if (my_error->domain != G_IO_ERROR && my_error->code != G_IO_ERROR_NOT_FOUND)
1838             {
1839               g_propagate_error (error, my_error);
1840               return NULL;
1841             }
1842           g_error_free (my_error);
1843         }
1844
1845       g_set_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE,
1846                    _("Can't recursively copy directory"));
1847       return NULL;
1848     }
1849
1850   g_propagate_error (error, my_error);
1851   return NULL;
1852 }
1853
1854 static gboolean
1855 should_copy (GFileAttributeInfo *info,
1856              gboolean            as_move)
1857 {
1858   if (as_move)
1859     return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED;
1860   return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE;
1861 }
1862
1863 static char *
1864 build_attribute_list_for_copy (GFileAttributeInfoList *attributes,
1865                                GFileAttributeInfoList *namespaces,
1866                                gboolean                as_move)
1867 {
1868   GString *s;
1869   gboolean first;
1870   int i;
1871
1872   first = TRUE;
1873   s = g_string_new ("");
1874
1875   if (attributes)
1876     {
1877       for (i = 0; i < attributes->n_infos; i++)
1878         {
1879           if (should_copy (&attributes->infos[i], as_move))
1880             {
1881               if (first)
1882                 first = FALSE;
1883               else
1884                 g_string_append_c (s, ',');
1885
1886               g_string_append (s, attributes->infos[i].name);
1887             }
1888         }
1889     }
1890
1891   if (namespaces)
1892     {
1893       for (i = 0; i < namespaces->n_infos; i++)
1894         {
1895           if (should_copy (&namespaces->infos[i], as_move))
1896             {
1897               if (first)
1898                 first = FALSE;
1899               else
1900                 g_string_append_c (s, ',');
1901
1902               g_string_append (s, namespaces->infos[i].name);
1903               g_string_append (s, ":*");
1904             }
1905         }
1906     }
1907
1908   return g_string_free (s, FALSE);
1909 }
1910
1911 /**
1912  * g_file_copy_attributes:
1913  * @source: a #GFile with attributes.
1914  * @destination: a #GFile to copy attributes to.
1915  * @flags: a set of #GFileCopyFlags.
1916  * @cancellable: optional #GCancellable object, %NULL to ignore.
1917  * @error: a #GError, %NULL to ignore.
1918  *
1919  * Copies the file attributes from @source to @destination.
1920  *
1921  * Normally only a subset of the file attributes are copied,
1922  * those that are copies in a normal file copy operation
1923  * (which for instance does not include e.g. mtime). However
1924  * if #G_FILE_COPY_ALL_METADATA is specified in @flags, then
1925  * all the metadata that is possible to copy is copied.
1926  *
1927  * Returns: %TRUE if the attributes were copied successfully, %FALSE otherwise.
1928  **/
1929 gboolean
1930 g_file_copy_attributes (GFile           *source,
1931                         GFile           *destination,
1932                         GFileCopyFlags   flags,
1933                         GCancellable    *cancellable,
1934                         GError         **error)
1935 {
1936   GFileAttributeInfoList *attributes, *namespaces;
1937   char *attrs_to_read;
1938   gboolean res;
1939   GFileInfo *info;
1940   gboolean as_move;
1941   gboolean source_nofollow_symlinks;
1942
1943   as_move = flags & G_FILE_COPY_ALL_METADATA;
1944   source_nofollow_symlinks = flags & G_FILE_COPY_NOFOLLOW_SYMLINKS;
1945
1946   /* Ignore errors here, if the target supports no attributes there is nothing to copy */
1947   attributes = g_file_query_settable_attributes (destination, cancellable, NULL);
1948   namespaces = g_file_query_writable_namespaces (destination, cancellable, NULL);
1949
1950   if (attributes == NULL && namespaces == NULL)
1951     return TRUE;
1952
1953   attrs_to_read = build_attribute_list_for_copy (attributes, namespaces, as_move);
1954
1955   /* Ignore errors here, if we can't read some info (e.g. if it doesn't exist)
1956    * we just don't copy it.
1957    */
1958   info = g_file_query_info (source, attrs_to_read,
1959                             source_nofollow_symlinks ? G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS:0,
1960                             cancellable,
1961                             NULL);
1962
1963   g_free (attrs_to_read);
1964
1965   res = TRUE;
1966   if  (info)
1967     {
1968       res = g_file_set_attributes_from_info (destination,
1969                                              info, 0,
1970                                              cancellable,
1971                                              error);
1972       g_object_unref (info);
1973     }
1974
1975   g_file_attribute_info_list_unref (attributes);
1976   g_file_attribute_info_list_unref (namespaces);
1977
1978   return res;
1979 }
1980
1981 /* Closes the streams */
1982 static gboolean
1983 copy_stream_with_progress (GInputStream           *in,
1984                            GOutputStream          *out,
1985                            GCancellable           *cancellable,
1986                            GFileProgressCallback   progress_callback,
1987                            gpointer                progress_callback_data,
1988                            GError                **error)
1989 {
1990   gssize n_read, n_written;
1991   goffset current_size;
1992   char buffer[8192], *p;
1993   gboolean res;
1994   goffset total_size;
1995   GFileInfo *info;
1996
1997   total_size = 0;
1998   info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (in),
1999                                          G_FILE_ATTRIBUTE_STANDARD_SIZE,
2000                                          cancellable, NULL);
2001   if (info)
2002     {
2003       total_size = g_file_info_get_size (info);
2004       g_object_unref (info);
2005     }
2006
2007   current_size = 0;
2008   res = TRUE;
2009   while (TRUE)
2010     {
2011       n_read = g_input_stream_read (in, buffer, sizeof (buffer), cancellable, error);
2012       if (n_read == -1)
2013         {
2014           res = FALSE;
2015           break;
2016         }
2017
2018       if (n_read == 0)
2019         break;
2020
2021       current_size += n_read;
2022
2023       p = buffer;
2024       while (n_read > 0)
2025         {
2026           n_written = g_output_stream_write (out, p, n_read, cancellable, error);
2027           if (n_written == -1)
2028             {
2029               res = FALSE;
2030               break;
2031             }
2032
2033           p += n_written;
2034           n_read -= n_written;
2035         }
2036
2037       if (!res)
2038         break;
2039
2040       if (progress_callback)
2041         progress_callback (current_size, total_size, progress_callback_data);
2042     }
2043
2044   if (!res)
2045     error = NULL; /* Ignore further errors */
2046
2047   /* Make sure we send full copied size */
2048   if (progress_callback)
2049     progress_callback (current_size, total_size, progress_callback_data);
2050
2051
2052   /* Don't care about errors in source here */
2053   g_input_stream_close (in, cancellable, NULL);
2054
2055   /* But write errors on close are bad! */
2056   if (!g_output_stream_close (out, cancellable, error))
2057     res = FALSE;
2058
2059   g_object_unref (in);
2060   g_object_unref (out);
2061
2062   return res;
2063 }
2064
2065 static gboolean
2066 file_copy_fallback (GFile                  *source,
2067                     GFile                  *destination,
2068                     GFileCopyFlags          flags,
2069                     GCancellable           *cancellable,
2070                     GFileProgressCallback   progress_callback,
2071                     gpointer                progress_callback_data,
2072                     GError                **error)
2073 {
2074   GInputStream *in;
2075   GOutputStream *out;
2076   GFileInfo *info;
2077   const char *target;
2078
2079   /* Maybe copy the symlink? */
2080   if (flags & G_FILE_COPY_NOFOLLOW_SYMLINKS)
2081     {
2082       info = g_file_query_info (source,
2083                                 G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,
2084                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2085                                 cancellable,
2086                                 error);
2087       if (info == NULL)
2088         return FALSE;
2089
2090       if (g_file_info_get_file_type (info) == G_FILE_TYPE_SYMBOLIC_LINK &&
2091           (target = g_file_info_get_symlink_target (info)) != NULL)
2092         {
2093           if (!copy_symlink (destination, flags, cancellable, target, error))
2094             {
2095               g_object_unref (info);
2096               return FALSE;
2097             }
2098
2099           g_object_unref (info);
2100           goto copied_file;
2101         }
2102
2103       g_object_unref (info);
2104     }
2105
2106   in = open_source_for_copy (source, destination, flags, cancellable, error);
2107   if (in == NULL)
2108     return FALSE;
2109
2110   if (flags & G_FILE_COPY_OVERWRITE)
2111     {
2112       out = (GOutputStream *)g_file_replace (destination,
2113                                              NULL, 0,
2114                                              flags & G_FILE_COPY_BACKUP,
2115                                              cancellable, error);
2116     }
2117   else
2118     {
2119       out = (GOutputStream *)g_file_create (destination, 0, cancellable, error);
2120     }
2121
2122   if (out == NULL)
2123     {
2124       g_object_unref (in);
2125       return FALSE;
2126     }
2127
2128   if (!copy_stream_with_progress (in, out, cancellable,
2129                                   progress_callback, progress_callback_data,
2130                                   error))
2131     return FALSE;
2132
2133  copied_file:
2134
2135   /* Ignore errors here. Failure to copy metadata is not a hard error */
2136   g_file_copy_attributes (source, destination,
2137                           flags, cancellable, NULL);
2138
2139   return TRUE;
2140 }
2141
2142 /**
2143  * g_file_copy:
2144  * @source: input #GFile.
2145  * @destination: destination #GFile
2146  * @flags: set of #GFileCopyFlags
2147  * @cancellable: optional #GCancellable object, %NULL to ignore.
2148  * @progress_callback: function to callback with progress information
2149  * @progress_callback_data: user data to pass to @progress_callback
2150  * @error: #GError to set on error, or %NULL
2151  *
2152  * Copies the file @source to the location specified by @destination.
2153  * Can not handle recursive copies of directories.
2154  *
2155  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
2156  * existing @destination file is overwritten.
2157  *
2158  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
2159  * will be copied as symlinks, otherwise the target of the
2160  * @source symlink will be copied.
2161  *
2162  * If @cancellable is not %NULL, then the operation can be cancelled by
2163  * triggering the cancellable object from another thread. If the operation
2164  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2165  *
2166  * If @progress_callback is not %NULL, then the operation can be monitored by
2167  * setting this to a #GFileProgressCallback function. @progress_callback_data
2168  * will be passed to this function. It is guaranteed that this callback will
2169  * be called after all data has been transferred with the total number of bytes
2170  * copied during the operation.
2171  *
2172  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
2173  * error is returned, independent on the status of the @destination.
2174  *
2175  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
2176  * error G_IO_ERROR_EXISTS is returned.
2177  *
2178  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
2179  * error is returned. If trying to overwrite a directory with a directory the
2180  * G_IO_ERROR_WOULD_MERGE error is returned.
2181  *
2182  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
2183  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
2184  * is returned.
2185  *
2186  * If you are interested in copying the #GFile object itself (not the on-disk
2187  * file), see g_file_dup().
2188  *
2189  * Returns: %TRUE on success, %FALSE otherwise.
2190  **/
2191 gboolean
2192 g_file_copy (GFile                  *source,
2193              GFile                  *destination,
2194              GFileCopyFlags          flags,
2195              GCancellable           *cancellable,
2196              GFileProgressCallback   progress_callback,
2197              gpointer                progress_callback_data,
2198              GError                **error)
2199 {
2200   GFileIface *iface;
2201   GError *my_error;
2202   gboolean res;
2203
2204   g_return_val_if_fail (G_IS_FILE (source), FALSE);
2205   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
2206
2207   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2208     return FALSE;
2209
2210   iface = G_FILE_GET_IFACE (destination);
2211   if (iface->copy)
2212     {
2213       my_error = NULL;
2214       res = (* iface->copy) (source, destination,
2215                              flags, cancellable,
2216                              progress_callback, progress_callback_data,
2217                              &my_error);
2218
2219       if (res)
2220         return TRUE;
2221
2222       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2223         {
2224           g_propagate_error (error, my_error);
2225               return FALSE;
2226         }
2227     }
2228
2229   /* If the types are different, and the destination method failed
2230      also try the source method */
2231   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
2232     {
2233       iface = G_FILE_GET_IFACE (source);
2234
2235       if (iface->copy)
2236         {
2237           my_error = NULL;
2238           res = (* iface->copy) (source, destination,
2239                                  flags, cancellable,
2240                                  progress_callback, progress_callback_data,
2241                                  &my_error);
2242
2243           if (res)
2244             return TRUE;
2245
2246           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2247             {
2248               g_propagate_error (error, my_error);
2249               return FALSE;
2250             }
2251         }
2252     }
2253
2254   return file_copy_fallback (source, destination, flags, cancellable,
2255                              progress_callback, progress_callback_data,
2256                              error);
2257 }
2258
2259 /**
2260  * g_file_copy_async:
2261  * @source: input #GFile.
2262  * @destination: destination #GFile
2263  * @flags: set of #GFileCopyFlags
2264  * @cancellable: optional #GCancellable object, %NULL to ignore.
2265  * @progress_callback: function to callback with progress information
2266  * @progress_callback_data: user data to pass to @progress_callback
2267  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2268  * @user_data: the data to pass to callback function
2269  *
2270  * Copies the file @source to the location specified by @destination asynchronously.
2271  * For details of the behaviour, see g_file_copy().
2272  *
2273  * If @progress_callback is not %NULL, then that function that will be called
2274  * just like in g_file_copy(), however the callback will run in the main loop,
2275  * not in the thread that is doing the I/O operation.
2276  *
2277  * When the operation is finished, @callback will be called. You can then call
2278  * g_file_copy_finish() to get the result of the operation.
2279  **/
2280 void
2281 g_file_copy_async (GFile                  *source,
2282                    GFile                  *destination,
2283                    GFileCopyFlags          flags,
2284                    int                     io_priority,
2285                    GCancellable           *cancellable,
2286                    GFileProgressCallback   progress_callback,
2287                    gpointer                progress_callback_data,
2288                    GAsyncReadyCallback     callback,
2289                    gpointer                user_data)
2290 {
2291   GFileIface *iface;
2292
2293   g_return_if_fail (G_IS_FILE (source));
2294   g_return_if_fail (G_IS_FILE (destination));
2295
2296   iface = G_FILE_GET_IFACE (source);
2297   (* iface->copy_async) (source,
2298                          destination,
2299                          flags,
2300                          io_priority,
2301                          cancellable,
2302                          progress_callback,
2303                          progress_callback_data,
2304                          callback,
2305                          user_data);
2306 }
2307
2308 /**
2309  * g_file_copy_finish:
2310  * @file: input #GFile.
2311  * @res: a #GAsyncResult.
2312  * @error: a #GError, or %NULL
2313  *
2314  * Finishes copying the file started with
2315  * g_file_copy_async().
2316  *
2317  * Returns: a %TRUE on success, %FALSE on error.
2318  **/
2319 gboolean
2320 g_file_copy_finish (GFile        *file,
2321                     GAsyncResult *res,
2322                     GError      **error)
2323 {
2324   GFileIface *iface;
2325
2326   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2327   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
2328
2329   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2330     {
2331       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2332
2333       if (g_simple_async_result_propagate_error (simple, error))
2334         return FALSE;
2335     }
2336
2337   iface = G_FILE_GET_IFACE (file);
2338   return (* iface->copy_finish) (file, res, error);
2339 }
2340
2341 /**
2342  * g_file_move:
2343  * @source: #GFile pointing to the source location.
2344  * @destination: #GFile pointing to the destination location.
2345  * @flags: set of #GFileCopyFlags.
2346  * @cancellable: optional #GCancellable object, %NULL to ignore.
2347  * @progress_callback: #GFileProgressCallback function for updates.
2348  * @progress_callback_data: gpointer to user data for the callback function.
2349  * @error: #GError for returning error conditions, or %NULL
2350  *
2351  *
2352  * Tries to move the file or directory @source to the location specified by @destination.
2353  * If native move operations are supported then this is used, otherwise a copy + delete
2354  * fallback is used. The native implementation may support moving directories (for instance
2355  * on moves inside the same filesystem), but the fallback code does not.
2356  *
2357  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
2358  * existing @destination file is overwritten.
2359  *
2360  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
2361  * will be copied as symlinks, otherwise the target of the
2362  * @source symlink will be copied.
2363  *
2364  * If @cancellable is not %NULL, then the operation can be cancelled by
2365  * triggering the cancellable object from another thread. If the operation
2366  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2367  *
2368  * If @progress_callback is not %NULL, then the operation can be monitored by
2369  * setting this to a #GFileProgressCallback function. @progress_callback_data
2370  * will be passed to this function. It is guaranteed that this callback will
2371  * be called after all data has been transferred with the total number of bytes
2372  * copied during the operation.
2373  *
2374  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
2375  * error is returned, independent on the status of the @destination.
2376  *
2377  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
2378  * error G_IO_ERROR_EXISTS is returned.
2379  *
2380  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
2381  * error is returned. If trying to overwrite a directory with a directory the
2382  * G_IO_ERROR_WOULD_MERGE error is returned.
2383  *
2384  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
2385  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
2386  * may be returned (if the native move operation isn't available).
2387  *
2388  * Returns: %TRUE on successful move, %FALSE otherwise.
2389  **/
2390 gboolean
2391 g_file_move (GFile                  *source,
2392              GFile                  *destination,
2393              GFileCopyFlags          flags,
2394              GCancellable           *cancellable,
2395              GFileProgressCallback   progress_callback,
2396              gpointer                progress_callback_data,
2397              GError                **error)
2398 {
2399   GFileIface *iface;
2400   GError *my_error;
2401   gboolean res;
2402
2403   g_return_val_if_fail (G_IS_FILE (source), FALSE);
2404   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
2405
2406   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2407     return FALSE;
2408
2409   iface = G_FILE_GET_IFACE (destination);
2410   if (iface->move)
2411     {
2412       my_error = NULL;
2413       res = (* iface->move) (source, destination,
2414                              flags, cancellable,
2415                              progress_callback, progress_callback_data,
2416                              &my_error);
2417
2418       if (res)
2419         return TRUE;
2420
2421       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2422         {
2423           g_propagate_error (error, my_error);
2424           return FALSE;
2425         }
2426     }
2427
2428   /* If the types are different, and the destination method failed
2429      also try the source method */
2430   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
2431     {
2432       iface = G_FILE_GET_IFACE (source);
2433
2434       if (iface->move)
2435         {
2436           my_error = NULL;
2437           res = (* iface->move) (source, destination,
2438                                  flags, cancellable,
2439                                  progress_callback, progress_callback_data,
2440                                  &my_error);
2441
2442           if (res)
2443             return TRUE;
2444
2445           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2446             {
2447               g_propagate_error (error, my_error);
2448               return FALSE;
2449             }
2450         }
2451     }
2452
2453   if (flags & G_FILE_COPY_NO_FALLBACK_FOR_MOVE)
2454     {
2455       g_set_error (error, G_IO_ERROR,
2456                    G_IO_ERROR_NOT_SUPPORTED,
2457                    _("Operation not supported"));
2458       return FALSE;
2459     }
2460
2461   flags |= G_FILE_COPY_ALL_METADATA;
2462   if (!g_file_copy (source, destination, flags, cancellable,
2463                     progress_callback, progress_callback_data,
2464                     error))
2465     return FALSE;
2466
2467   return g_file_delete (source, cancellable, error);
2468 }
2469
2470 /**
2471  * g_file_make_directory
2472  * @file: input #GFile.
2473  * @cancellable: optional #GCancellable object, %NULL to ignore.
2474  * @error: a #GError, or %NULL
2475  *
2476  * Creates a directory.
2477  *
2478  * If @cancellable is not %NULL, then the operation can be cancelled by
2479  * triggering the cancellable object from another thread. If the operation
2480  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2481  *
2482  * Returns: %TRUE on successful creation, %FALSE otherwise.
2483  **/
2484 gboolean
2485 g_file_make_directory (GFile         *file,
2486                        GCancellable  *cancellable,
2487                        GError       **error)
2488 {
2489   GFileIface *iface;
2490
2491   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2492
2493   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2494     return FALSE;
2495
2496   iface = G_FILE_GET_IFACE (file);
2497
2498   if (iface->make_directory == NULL)
2499     {
2500       g_set_error (error, G_IO_ERROR,
2501                    G_IO_ERROR_NOT_SUPPORTED,
2502                    _("Operation not supported"));
2503       return FALSE;
2504     }
2505
2506   return (* iface->make_directory) (file, cancellable, error);
2507 }
2508
2509 /**
2510  * g_file_make_symbolic_link:
2511  * @file: input #GFile.
2512  * @symlink_value: a string with the value of the new symlink.
2513  * @cancellable: optional #GCancellable object, %NULL to ignore.
2514  * @error: a #GError.
2515  *
2516  * Creates a symbolic link.
2517  *
2518  * If @cancellable is not %NULL, then the operation can be cancelled by
2519  * triggering the cancellable object from another thread. If the operation
2520  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2521  *
2522  * Returns: %TRUE on the creation of a new symlink, %FALSE otherwise.
2523  **/
2524 gboolean
2525 g_file_make_symbolic_link (GFile         *file,
2526                            const char    *symlink_value,
2527                            GCancellable  *cancellable,
2528                            GError       **error)
2529 {
2530   GFileIface *iface;
2531
2532   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2533   g_return_val_if_fail (symlink_value != NULL, FALSE);
2534
2535   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2536     return FALSE;
2537
2538   if (*symlink_value == '\0')
2539     {
2540       g_set_error (error, G_IO_ERROR,
2541                    G_IO_ERROR_INVALID_ARGUMENT,
2542                    _("Invalid symlink value given"));
2543       return FALSE;
2544     }
2545
2546   iface = G_FILE_GET_IFACE (file);
2547
2548   if (iface->make_symbolic_link == NULL)
2549     {
2550       g_set_error (error, G_IO_ERROR,
2551                    G_IO_ERROR_NOT_SUPPORTED,
2552                    _("Operation not supported"));
2553       return FALSE;
2554     }
2555
2556   return (* iface->make_symbolic_link) (file, symlink_value, cancellable, error);
2557 }
2558
2559 /**
2560  * g_file_delete:
2561  * @file: input #GFile.
2562  * @cancellable: optional #GCancellable object, %NULL to ignore.
2563  * @error: a #GError, or %NULL
2564  *
2565  * Deletes a file.
2566  *
2567  * If @cancellable is not %NULL, then the operation can be cancelled by
2568  * triggering the cancellable object from another thread. If the operation
2569  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2570  *
2571  * Returns: %TRUE if the file was deleted. %FALSE otherwise.
2572  **/
2573 gboolean
2574 g_file_delete (GFile         *file,
2575                GCancellable  *cancellable,
2576                GError       **error)
2577 {
2578   GFileIface *iface;
2579
2580   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2581
2582   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2583     return FALSE;
2584
2585   iface = G_FILE_GET_IFACE (file);
2586
2587   if (iface->delete_file == NULL)
2588     {
2589       g_set_error (error, G_IO_ERROR,
2590                    G_IO_ERROR_NOT_SUPPORTED,
2591                    _("Operation not supported"));
2592       return FALSE;
2593     }
2594
2595   return (* iface->delete_file) (file, cancellable, error);
2596 }
2597
2598 /**
2599  * g_file_trash:
2600  * @file: #GFile to send to trash.
2601  * @cancellable: optional #GCancellable object, %NULL to ignore.
2602  * @error: a #GError, or %NULL
2603  *
2604  * Sends @file to the "Trashcan", if possible. This is similar to
2605  * deleting it, but the user can recover it before emptying the trashcan.
2606  * Not all file systems support trashing, so this call can return the
2607  * %G_IO_ERROR_NOT_SUPPORTED error.
2608  *
2609  *
2610  * If @cancellable is not %NULL, then the operation can be cancelled by
2611  * triggering the cancellable object from another thread. If the operation
2612  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2613  *
2614  * Returns: %TRUE on successful trash, %FALSE otherwise.
2615  **/
2616 gboolean
2617 g_file_trash (GFile         *file,
2618               GCancellable  *cancellable,
2619               GError       **error)
2620 {
2621   GFileIface *iface;
2622
2623   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2624
2625   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2626     return FALSE;
2627
2628   iface = G_FILE_GET_IFACE (file);
2629
2630   if (iface->trash == NULL)
2631     {
2632       g_set_error (error,
2633                    G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
2634                    _("Trash not supported"));
2635       return FALSE;
2636     }
2637
2638   return (* iface->trash) (file, cancellable, error);
2639 }
2640
2641 /**
2642  * g_file_set_display_name:
2643  * @file: input #GFile.
2644  * @display_name: a string.
2645  * @cancellable: optional #GCancellable object, %NULL to ignore.
2646  * @error: a #GError, or %NULL
2647  *
2648  * Renames @file to the specified display name.
2649  *
2650  * The display name is converted from UTF8 to the correct encoding for the target
2651  * filesystem if possible and the @file is renamed to this.
2652  *
2653  * If you want to implement a rename operation in the user interface the edit name
2654  * (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename
2655  * widget, and then the result after editing should be passed to g_file_set_display_name().
2656  *
2657  * On success the resulting converted filename is returned.
2658  *
2659  * If @cancellable is not %NULL, then the operation can be cancelled by
2660  * triggering the cancellable object from another thread. If the operation
2661  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2662  *
2663  * Returns: a #GFile specifying what @file was renamed to, or %NULL if there was an error.
2664  **/
2665 GFile *
2666 g_file_set_display_name (GFile         *file,
2667                          const char    *display_name,
2668                          GCancellable  *cancellable,
2669                          GError       **error)
2670 {
2671   GFileIface *iface;
2672
2673   g_return_val_if_fail (G_IS_FILE (file), NULL);
2674   g_return_val_if_fail (display_name != NULL, NULL);
2675
2676   if (strchr (display_name, G_DIR_SEPARATOR) != NULL)
2677     {
2678       g_set_error (error,
2679                    G_IO_ERROR,
2680                    G_IO_ERROR_INVALID_ARGUMENT,
2681                    _("File names cannot contain '%c'"), G_DIR_SEPARATOR);
2682       return NULL;
2683     }
2684
2685   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2686     return NULL;
2687
2688   iface = G_FILE_GET_IFACE (file);
2689
2690   return (* iface->set_display_name) (file, display_name, cancellable, error);
2691 }
2692
2693 /**
2694  * g_file_set_display_name_async:
2695  * @file: input #GFile.
2696  * @display_name: a string.
2697  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2698  *     of the request.
2699  * @cancellable: optional #GCancellable object, %NULL to ignore.
2700  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2701  * @user_data: the data to pass to callback function
2702  *
2703  * Asynchronously sets the display name for a given #GFile.
2704  *
2705  * For more details, see g_set_display_name() which is
2706  * the synchronous version of this call.
2707  *
2708  * When the operation is finished, @callback will be called. You can then call
2709  * g_file_set_display_name_finish() to get the result of the operation.
2710  **/
2711 void
2712 g_file_set_display_name_async (GFile               *file,
2713                                const char          *display_name,
2714                                int                  io_priority,
2715                                GCancellable        *cancellable,
2716                                GAsyncReadyCallback  callback,
2717                                gpointer             user_data)
2718 {
2719   GFileIface *iface;
2720
2721   g_return_if_fail (G_IS_FILE (file));
2722   g_return_if_fail (display_name != NULL);
2723
2724   iface = G_FILE_GET_IFACE (file);
2725   (* iface->set_display_name_async) (file,
2726                                      display_name,
2727                                      io_priority,
2728                                      cancellable,
2729                                      callback,
2730                                      user_data);
2731 }
2732
2733 /**
2734  * g_file_set_display_name_finish:
2735  * @file: input #GFile.
2736  * @res: a #GAsyncResult.
2737  * @error: a #GError, or %NULL
2738  *
2739  * Finishes setting a display name started with
2740  * g_file_set_display_name_async().
2741  *
2742  * Returns: a #GFile or %NULL on error.
2743  **/
2744 GFile *
2745 g_file_set_display_name_finish (GFile         *file,
2746                                 GAsyncResult  *res,
2747                                 GError       **error)
2748 {
2749   GFileIface *iface;
2750
2751   g_return_val_if_fail (G_IS_FILE (file), NULL);
2752   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2753
2754   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2755     {
2756       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2757       if (g_simple_async_result_propagate_error (simple, error))
2758         return NULL;
2759     }
2760
2761   iface = G_FILE_GET_IFACE (file);
2762   return (* iface->set_display_name_finish) (file, res, error);
2763 }
2764
2765 /**
2766  * g_file_query_settable_attributes:
2767  * @file: input #GFile.
2768  * @cancellable: optional #GCancellable object, %NULL to ignore.
2769  * @error: a #GError, or %NULL
2770  *
2771  * Obtain the list of settable attributes for the file.
2772  *
2773  * Returns the type and full attribute name of all the attributes
2774  * that can be set on this file. This doesn't mean setting it will always
2775  * succeed though, you might get an access failure, or some specific
2776  * file may not support a specific attribute.
2777  *
2778  * If @cancellable is not %NULL, then the operation can be cancelled by
2779  * triggering the cancellable object from another thread. If the operation
2780  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2781  *
2782  * Returns: a #GFileAttributeInfoList describing the settable attributes.
2783  * When you are done with it, release it with g_file_attribute_info_list_unref()
2784  **/
2785 GFileAttributeInfoList *
2786 g_file_query_settable_attributes (GFile         *file,
2787                                   GCancellable  *cancellable,
2788                                   GError       **error)
2789 {
2790   GFileIface *iface;
2791   GError *my_error;
2792   GFileAttributeInfoList *list;
2793
2794   g_return_val_if_fail (G_IS_FILE (file), NULL);
2795
2796   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2797     return NULL;
2798
2799   iface = G_FILE_GET_IFACE (file);
2800
2801   if (iface->query_settable_attributes == NULL)
2802     return g_file_attribute_info_list_new ();
2803
2804   my_error = NULL;
2805   list = (* iface->query_settable_attributes) (file, cancellable, &my_error);
2806
2807   if (list == NULL)
2808     {
2809       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
2810         {
2811           list = g_file_attribute_info_list_new ();
2812           g_error_free (my_error);
2813         }
2814       else
2815         g_propagate_error (error, my_error);
2816     }
2817
2818   return list;
2819 }
2820
2821 /**
2822  * g_file_query_writable_namespaces:
2823  * @file: input #GFile.
2824  * @cancellable: optional #GCancellable object, %NULL to ignore.
2825  * @error: a #GError, or %NULL
2826  *
2827  * Obtain the list of attribute namespaces where new attributes
2828  * can be created by a user. An example of this is extended
2829  * attributes (in the "xattr" namespace).
2830  *
2831  * If @cancellable is not %NULL, then the operation can be cancelled by
2832  * triggering the cancellable object from another thread. If the operation
2833  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2834  *
2835  * Returns: a #GFileAttributeInfoList describing the writable namespaces.
2836  * When you are done with it, release it with g_file_attribute_info_list_unref()
2837  **/
2838 GFileAttributeInfoList *
2839 g_file_query_writable_namespaces (GFile         *file,
2840                                   GCancellable  *cancellable,
2841                                   GError       **error)
2842 {
2843   GFileIface *iface;
2844   GError *my_error;
2845   GFileAttributeInfoList *list;
2846
2847   g_return_val_if_fail (G_IS_FILE (file), NULL);
2848
2849   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2850     return NULL;
2851
2852   iface = G_FILE_GET_IFACE (file);
2853
2854   if (iface->query_writable_namespaces == NULL)
2855     return g_file_attribute_info_list_new ();
2856
2857   my_error = NULL;
2858   list = (* iface->query_writable_namespaces) (file, cancellable, &my_error);
2859
2860   if (list == NULL)
2861     {
2862       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
2863         {
2864           list = g_file_attribute_info_list_new ();
2865           g_error_free (my_error);
2866         }
2867       else
2868         g_propagate_error (error, my_error);
2869     }
2870
2871   return list;
2872 }
2873
2874 /**
2875  * g_file_set_attribute:
2876  * @file: input #GFile.
2877  * @attribute: a string containing the attribute's name.
2878  * @type: The type of the attribute
2879  * @value_p: a pointer to the value (or the pointer itself if the type is a pointer type)
2880  * @flags: a set of #GFileQueryInfoFlags.
2881  * @cancellable: optional #GCancellable object, %NULL to ignore.
2882  * @error: a #GError, or %NULL
2883  *
2884  * Sets an attribute in the file with attribute name @attribute to @value.
2885  *
2886  * If @cancellable is not %NULL, then the operation can be cancelled by
2887  * triggering the cancellable object from another thread. If the operation
2888  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2889  *
2890  * Returns: %TRUE if the attribute was set, %FALSE otherwise.
2891  **/
2892 gboolean
2893 g_file_set_attribute (GFile                      *file,
2894                       const char                 *attribute,
2895                       GFileAttributeType          type,
2896                       gpointer                    value_p,
2897                       GFileQueryInfoFlags         flags,
2898                       GCancellable               *cancellable,
2899                       GError                    **error)
2900 {
2901   GFileIface *iface;
2902
2903   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2904   g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
2905
2906   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2907     return FALSE;
2908
2909   iface = G_FILE_GET_IFACE (file);
2910
2911   if (iface->set_attribute == NULL)
2912     {
2913       g_set_error (error, G_IO_ERROR,
2914                    G_IO_ERROR_NOT_SUPPORTED,
2915                    _("Operation not supported"));
2916       return FALSE;
2917     }
2918
2919   return (* iface->set_attribute) (file, attribute, type, value_p, flags, cancellable, error);
2920 }
2921
2922 /**
2923  * g_file_set_attributes_from_info:
2924  * @file: input #GFile.
2925  * @info: a #GFileInfo.
2926  * @flags: #GFileQueryInfoFlags
2927  * @cancellable: optional #GCancellable object, %NULL to ignore.
2928  * @error: a #GError, or %NULL
2929  *
2930  * Tries to set all attributes in the #GFileInfo on the target values,
2931  * not stopping on the first error.
2932  *
2933  * If there is any error during this operation then @error will be set to
2934  * the first error. Error on particular fields are flagged by setting
2935  * the "status" field in the attribute value to
2936  * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
2937  * further errors.
2938  *
2939  * If @cancellable is not %NULL, then the operation can be cancelled by
2940  * triggering the cancellable object from another thread. If the operation
2941  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2942  *
2943  * Returns: %TRUE if there was any error, %FALSE otherwise.
2944  **/
2945 gboolean
2946 g_file_set_attributes_from_info (GFile                *file,
2947                                  GFileInfo            *info,
2948                                  GFileQueryInfoFlags   flags,
2949                                  GCancellable         *cancellable,
2950                                  GError              **error)
2951 {
2952   GFileIface *iface;
2953
2954   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2955   g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
2956
2957   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2958     return FALSE;
2959
2960   g_file_info_clear_status (info);
2961
2962   iface = G_FILE_GET_IFACE (file);
2963
2964   return (* iface->set_attributes_from_info) (file,
2965                                               info,
2966                                               flags,
2967                                               cancellable,
2968                                               error);
2969 }
2970
2971
2972 static gboolean
2973 g_file_real_set_attributes_from_info (GFile                *file,
2974                                       GFileInfo            *info,
2975                                       GFileQueryInfoFlags   flags,
2976                                       GCancellable         *cancellable,
2977                                       GError              **error)
2978 {
2979   char **attributes;
2980   int i;
2981   gboolean res;
2982   GFileAttributeValue *value;
2983
2984   res = TRUE;
2985
2986   attributes = g_file_info_list_attributes (info, NULL);
2987
2988   for (i = 0; attributes[i] != NULL; i++)
2989     {
2990       value = _g_file_info_get_attribute_value (info, attributes[i]);
2991
2992       if (value->status != G_FILE_ATTRIBUTE_STATUS_UNSET)
2993         continue;
2994
2995       if (!g_file_set_attribute (file, attributes[i],
2996                                  value->type, _g_file_attribute_value_peek_as_pointer (value),
2997                                  flags, cancellable, error))
2998         {
2999           value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
3000           res = FALSE;
3001           /* Don't set error multiple times */
3002           error = NULL;
3003         }
3004       else
3005         value->status = G_FILE_ATTRIBUTE_STATUS_SET;
3006     }
3007
3008   g_strfreev (attributes);
3009
3010   return res;
3011 }
3012
3013 /**
3014  * g_file_set_attributes_async:
3015  * @file: input #GFile.
3016  * @info: a #GFileInfo.
3017  * @flags: a #GFileQueryInfoFlags.
3018  * @io_priority: the <link linkend="io-priority">I/O priority</link>
3019  *     of the request.
3020  * @cancellable: optional #GCancellable object, %NULL to ignore.
3021  * @callback: a #GAsyncReadyCallback.
3022  * @user_data: a #gpointer.
3023  *
3024  * Asynchronously sets the attributes of @file with @info.
3025  *
3026  * For more details, see g_file_set_attributes_from_info() which is
3027  * the synchronous version of this call.
3028  *
3029  * When the operation is finished, @callback will be called. You can then call
3030  * g_file_set_attributes_finish() to get the result of the operation.
3031  **/
3032 void
3033 g_file_set_attributes_async (GFile               *file,
3034                              GFileInfo           *info,
3035                              GFileQueryInfoFlags  flags,
3036                              int                  io_priority,
3037                              GCancellable        *cancellable,
3038                              GAsyncReadyCallback  callback,
3039                              gpointer             user_data)
3040 {
3041   GFileIface *iface;
3042
3043   g_return_if_fail (G_IS_FILE (file));
3044   g_return_if_fail (G_IS_FILE_INFO (info));
3045
3046   iface = G_FILE_GET_IFACE (file);
3047   (* iface->set_attributes_async) (file,
3048                                    info,
3049                                    flags,
3050                                    io_priority,
3051                                    cancellable,
3052                                    callback,
3053                                    user_data);
3054 }
3055
3056 /**
3057  * g_file_set_attributes_finish:
3058  * @file: input #GFile.
3059  * @result: a #GAsyncResult.
3060  * @info: a #GFileInfo.
3061  * @error: a #GError, or %NULL
3062  *
3063  * Finishes setting an attribute started in g_file_set_attributes_async().
3064  *
3065  * Returns: %TRUE if the attributes were set correctly, %FALSE otherwise.
3066  **/
3067 gboolean
3068 g_file_set_attributes_finish (GFile         *file,
3069                               GAsyncResult  *result,
3070                               GFileInfo    **info,
3071                               GError       **error)
3072 {
3073   GFileIface *iface;
3074
3075   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3076   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3077
3078   /* No standard handling of errors here, as we must set info even
3079    * on errors
3080    */
3081   iface = G_FILE_GET_IFACE (file);
3082   return (* iface->set_attributes_finish) (file, result, info, error);
3083 }
3084
3085 /**
3086  * g_file_set_attribute_string:
3087  * @file: input #GFile.
3088  * @attribute: a string containing the attribute's name.
3089  * @value: a string containing the attribute's value.
3090  * @flags: #GFileQueryInfoFlags.
3091  * @cancellable: optional #GCancellable object, %NULL to ignore.
3092  * @error: a #GError, or %NULL
3093  *
3094  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value.
3095  * If @attribute is of a different type, this operation will fail.
3096  *
3097  * If @cancellable is not %NULL, then the operation can be cancelled by
3098  * triggering the cancellable object from another thread. If the operation
3099  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3100  *
3101  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
3102  **/
3103 gboolean
3104 g_file_set_attribute_string (GFile                *file,
3105                              const char           *attribute,
3106                              const char           *value,
3107                              GFileQueryInfoFlags   flags,
3108                              GCancellable         *cancellable,
3109                              GError              **error)
3110 {
3111   return g_file_set_attribute (file, attribute,
3112                                G_FILE_ATTRIBUTE_TYPE_STRING, (gpointer)value,
3113                                flags, cancellable, error);
3114 }
3115
3116 /**
3117  * g_file_set_attribute_byte_string:
3118  * @file: input #GFile.
3119  * @attribute: a string containing the attribute's name.
3120  * @value: a string containing the attribute's new value.
3121  * @flags: a #GFileQueryInfoFlags.
3122  * @cancellable: optional #GCancellable object, %NULL to ignore.
3123  * @error: a #GError, or %NULL
3124  *
3125  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value.
3126  * If @attribute is of a different type, this operation will fail,
3127  * returning %FALSE.
3128  *
3129  * If @cancellable is not %NULL, then the operation can be cancelled by
3130  * triggering the cancellable object from another thread. If the operation
3131  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3132  *
3133  * Returns: %TRUE if the @attribute was successfully set to @value
3134  * in the @file, %FALSE otherwise.
3135  **/
3136 gboolean
3137 g_file_set_attribute_byte_string  (GFile                *file,
3138                                    const char           *attribute,
3139                                    const char           *value,
3140                                    GFileQueryInfoFlags   flags,
3141                                    GCancellable         *cancellable,
3142                                    GError              **error)
3143 {
3144   return g_file_set_attribute (file, attribute,
3145                                G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, (gpointer)value,
3146                                flags, cancellable, error);
3147 }
3148
3149 /**
3150  * g_file_set_attribute_uint32:
3151  * @file: input #GFile.
3152  * @attribute: a string containing the attribute's name.
3153  * @value: a #guint32 containing the attribute's new value.
3154  * @flags: a #GFileQueryInfoFlags.
3155  * @cancellable: optional #GCancellable object, %NULL to ignore.
3156  * @error: a #GError, or %NULL
3157  *
3158  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value.
3159  * If @attribute is of a different type, this operation will fail.
3160  *
3161  * If @cancellable is not %NULL, then the operation can be cancelled by
3162  * triggering the cancellable object from another thread. If the operation
3163  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3164  *
3165  * Returns: %TRUE if the @attribute was successfully set to @value
3166  * in the @file, %FALSE otherwise.
3167  **/
3168 gboolean
3169 g_file_set_attribute_uint32 (GFile                *file,
3170                              const char           *attribute,
3171                              guint32               value,
3172                              GFileQueryInfoFlags   flags,
3173                              GCancellable         *cancellable,
3174                              GError              **error)
3175 {
3176   return g_file_set_attribute (file, attribute,
3177                                G_FILE_ATTRIBUTE_TYPE_UINT32, &value,
3178                                flags, cancellable, error);
3179 }
3180
3181 /**
3182  * g_file_set_attribute_int32:
3183  * @file: input #GFile.
3184  * @attribute: a string containing the attribute's name.
3185  * @value: a #gint32 containing the attribute's new value.
3186  * @flags: a #GFileQueryInfoFlags.
3187  * @cancellable: optional #GCancellable object, %NULL to ignore.
3188  * @error: a #GError, or %NULL
3189  *
3190  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value.
3191  * If @attribute is of a different type, this operation will fail.
3192  *
3193  * If @cancellable is not %NULL, then the operation can be cancelled by
3194  * triggering the cancellable object from another thread. If the operation
3195  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3196  *
3197  * Returns: %TRUE if the @attribute was successfully set to @value
3198  * in the @file, %FALSE otherwise.
3199  **/
3200 gboolean
3201 g_file_set_attribute_int32 (GFile                *file,
3202                             const char           *attribute,
3203                             gint32                value,
3204                             GFileQueryInfoFlags   flags,
3205                             GCancellable         *cancellable,
3206                             GError              **error)
3207 {
3208   return g_file_set_attribute (file, attribute,
3209                                G_FILE_ATTRIBUTE_TYPE_INT32, &value,
3210                                flags, cancellable, error);
3211 }
3212
3213 /**
3214  * g_file_set_attribute_uint64:
3215  * @file: input #GFile.
3216  * @attribute: a string containing the attribute's name.
3217  * @value: a #guint64 containing the attribute's new value.
3218  * @flags: a #GFileQueryInfoFlags.
3219  * @cancellable: optional #GCancellable object, %NULL to ignore.
3220  * @error: a #GError, or %NULL
3221  *
3222  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value.
3223  * If @attribute is of a different type, this operation will fail.
3224  *
3225  * If @cancellable is not %NULL, then the operation can be cancelled by
3226  * triggering the cancellable object from another thread. If the operation
3227  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3228  *
3229  * Returns: %TRUE if the @attribute was successfully set to @value
3230  * in the @file, %FALSE otherwise.
3231  **/
3232 gboolean
3233 g_file_set_attribute_uint64 (GFile                *file,
3234                              const char           *attribute,
3235                              guint64               value,
3236                              GFileQueryInfoFlags   flags,
3237                              GCancellable         *cancellable,
3238                              GError              **error)
3239  {
3240   return g_file_set_attribute (file, attribute,
3241                                G_FILE_ATTRIBUTE_TYPE_UINT64, &value,
3242                                flags, cancellable, error);
3243 }
3244
3245 /**
3246  * g_file_set_attribute_int64:
3247  * @file: input #GFile.
3248  * @attribute: a string containing the attribute's name.
3249  * @value: a #guint64 containing the attribute's new value.
3250  * @flags: a #GFileQueryInfoFlags.
3251  * @cancellable: optional #GCancellable object, %NULL to ignore.
3252  * @error: a #GError, or %NULL
3253  *
3254  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value.
3255  * If @attribute is of a different type, this operation will fail.
3256  *
3257  * If @cancellable is not %NULL, then the operation can be cancelled by
3258  * triggering the cancellable object from another thread. If the operation
3259  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3260  *
3261  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
3262  **/
3263 gboolean
3264 g_file_set_attribute_int64 (GFile                *file,
3265                             const char           *attribute,
3266                             gint64                value,
3267                             GFileQueryInfoFlags   flags,
3268                             GCancellable         *cancellable,
3269                             GError              **error)
3270 {
3271   return g_file_set_attribute (file, attribute,
3272                                G_FILE_ATTRIBUTE_TYPE_INT64, &value,
3273                                flags, cancellable, error);
3274 }
3275
3276 /**
3277  * g_file_mount_mountable:
3278  * @file: input #GFile.
3279  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
3280  * @cancellable: optional #GCancellable object, %NULL to ignore.
3281  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3282  * @user_data: the data to pass to callback function
3283  *
3284  * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
3285  * Using @mount_operation, you can request callbacks when, for instance,
3286  * passwords are needed during authentication.
3287  *
3288  * If @cancellable is not %NULL, then the operation can be cancelled by
3289  * triggering the cancellable object from another thread. If the operation
3290  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3291  *
3292  * When the operation is finished, @callback will be called. You can then call
3293  * g_file_mount_mountable_finish() to get the result of the operation.
3294  **/
3295 void
3296 g_file_mount_mountable (GFile               *file,
3297                         GMountOperation     *mount_operation,
3298                         GCancellable        *cancellable,
3299                         GAsyncReadyCallback  callback,
3300                         gpointer             user_data)
3301 {
3302   GFileIface *iface;
3303
3304   g_return_if_fail (G_IS_FILE (file));
3305
3306   iface = G_FILE_GET_IFACE (file);
3307
3308   if (iface->mount_mountable == NULL)
3309     g_simple_async_report_error_in_idle (G_OBJECT (file),
3310                                          callback,
3311                                          user_data,
3312                                          G_IO_ERROR,
3313                                          G_IO_ERROR_NOT_SUPPORTED,
3314                                          _("Operation not supported"));
3315
3316   (* iface->mount_mountable) (file,
3317                               mount_operation,
3318                               cancellable,
3319                               callback,
3320                               user_data);
3321 }
3322
3323 /**
3324  * g_file_mount_mountable_finish:
3325  * @file: input #GFile.
3326  * @result: a #GAsyncResult.
3327  * @error: a #GError, or %NULL
3328  *
3329  * Finishes a mount operation. See g_file_mount_mountable() for details.
3330  *
3331  * Finish an asynchronous mount operation that was started
3332  * with g_file_mount_mountable().
3333  *
3334  * Returns: a #GFile or %NULL on error.
3335  **/
3336 GFile *
3337 g_file_mount_mountable_finish (GFile         *file,
3338                                GAsyncResult  *result,
3339                                GError       **error)
3340 {
3341   GFileIface *iface;
3342
3343   g_return_val_if_fail (G_IS_FILE (file), NULL);
3344   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
3345
3346   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3347     {
3348       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3349       if (g_simple_async_result_propagate_error (simple, error))
3350         return NULL;
3351     }
3352
3353   iface = G_FILE_GET_IFACE (file);
3354   return (* iface->mount_mountable_finish) (file, result, error);
3355 }
3356
3357 /**
3358  * g_file_unmount_mountable:
3359  * @file: input #GFile.
3360  * @flags: flags affecting the operation
3361  * @cancellable: optional #GCancellable object, %NULL to ignore.
3362  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3363  * @user_data: the data to pass to callback function
3364  *
3365  * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
3366  *
3367  * If @cancellable is not %NULL, then the operation can be cancelled by
3368  * triggering the cancellable object from another thread. If the operation
3369  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3370  *
3371  * When the operation is finished, @callback will be called. You can then call
3372  * g_file_unmount_mountable_finish() to get the result of the operation.
3373  **/
3374 void
3375 g_file_unmount_mountable (GFile               *file,
3376                           GMountUnmountFlags   flags,
3377                           GCancellable        *cancellable,
3378                           GAsyncReadyCallback  callback,
3379                           gpointer             user_data)
3380 {
3381   GFileIface *iface;
3382
3383   g_return_if_fail (G_IS_FILE (file));
3384
3385   iface = G_FILE_GET_IFACE (file);
3386
3387   if (iface->unmount_mountable == NULL)
3388     g_simple_async_report_error_in_idle (G_OBJECT (file),
3389                                          callback,
3390                                          user_data,
3391                                          G_IO_ERROR,
3392                                          G_IO_ERROR_NOT_SUPPORTED,
3393                                          _("Operation not supported"));
3394
3395   (* iface->unmount_mountable) (file,
3396                                 flags,
3397                                 cancellable,
3398                                 callback,
3399                                 user_data);
3400 }
3401
3402 /**
3403  * g_file_unmount_mountable_finish:
3404  * @file: input #GFile.
3405  * @result: a #GAsyncResult.
3406  * @error: a #GError, or %NULL
3407  *
3408  * Finishes an unmount operation, see g_file_unmount_mountable() for details.
3409  *
3410  * Finish an asynchronous unmount operation that was started
3411  * with g_file_unmount_mountable().
3412  *
3413  * Returns: %TRUE if the operation finished successfully. %FALSE
3414  * otherwise.
3415  **/
3416 gboolean
3417 g_file_unmount_mountable_finish (GFile         *file,
3418                                  GAsyncResult  *result,
3419                                  GError       **error)
3420 {
3421   GFileIface *iface;
3422
3423   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3424   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3425
3426   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3427     {
3428       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3429       if (g_simple_async_result_propagate_error (simple, error))
3430         return FALSE;
3431     }
3432
3433   iface = G_FILE_GET_IFACE (file);
3434   return (* iface->unmount_mountable_finish) (file, result, error);
3435 }
3436
3437 /**
3438  * g_file_eject_mountable:
3439  * @file: input #GFile.
3440  * @flags: flags affecting the operation
3441  * @cancellable: optional #GCancellable object, %NULL to ignore.
3442  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3443  * @user_data: the data to pass to callback function
3444  *
3445  * Starts an asynchronous eject on a mountable.
3446  * When this operation has completed, @callback will be called with
3447  * @user_user data, and the operation can be finalized with
3448  * g_file_eject_mountable_finish().
3449  *
3450  * If @cancellable is not %NULL, then the operation can be cancelled by
3451  * triggering the cancellable object from another thread. If the operation
3452  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3453  **/
3454 void
3455 g_file_eject_mountable (GFile               *file,
3456                         GMountUnmountFlags   flags,
3457                         GCancellable        *cancellable,
3458                         GAsyncReadyCallback  callback,
3459                         gpointer             user_data)
3460 {
3461   GFileIface *iface;
3462
3463   g_return_if_fail (G_IS_FILE (file));
3464
3465   iface = G_FILE_GET_IFACE (file);
3466
3467   if (iface->eject_mountable == NULL)
3468     g_simple_async_report_error_in_idle (G_OBJECT (file),
3469                                          callback,
3470                                          user_data,
3471                                          G_IO_ERROR,
3472                                          G_IO_ERROR_NOT_SUPPORTED,
3473                                          _("Operation not supported"));
3474
3475   (* iface->eject_mountable) (file,
3476                               flags,
3477                               cancellable,
3478                               callback,
3479                               user_data);
3480 }
3481
3482 /**
3483  * g_file_eject_mountable_finish:
3484  * @file: input #GFile.
3485  * @result: a #GAsyncResult.
3486  * @error: a #GError, or %NULL
3487  *
3488  * Finishes an asynchronous eject operation started by
3489  * g_file_eject_mountable().
3490  *
3491  * Returns: %TRUE if the @file was ejected successfully. %FALSE
3492  * otherwise.
3493  **/
3494 gboolean
3495 g_file_eject_mountable_finish (GFile         *file,
3496                                GAsyncResult  *result,
3497                                GError       **error)
3498 {
3499   GFileIface *iface;
3500
3501   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3502   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3503
3504   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3505     {
3506       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3507       if (g_simple_async_result_propagate_error (simple, error))
3508         return FALSE;
3509     }
3510
3511   iface = G_FILE_GET_IFACE (file);
3512   return (* iface->eject_mountable_finish) (file, result, error);
3513 }
3514
3515 /**
3516  * g_file_monitor_directory:
3517  * @file: input #GFile.
3518  * @flags: a set of #GFileMonitorFlags.
3519  * @cancellable: optional #GCancellable object, %NULL to ignore.
3520  * @error: a #GError, or %NULL.
3521  *
3522  * Obtains a directory monitor for the given file.
3523  * This may fail if directory monitoring is not supported.
3524  *
3525  * If @cancellable is not %NULL, then the operation can be cancelled by
3526  * triggering the cancellable object from another thread. If the operation
3527  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3528  *
3529  * Returns: a #GFileMonitor for the given @file,
3530  * or %NULL on error.
3531  **/
3532 GFileMonitor*
3533 g_file_monitor_directory (GFile             *file,
3534                           GFileMonitorFlags  flags,
3535                           GCancellable      *cancellable,
3536                           GError           **error)
3537 {
3538   GFileIface *iface;
3539
3540   g_return_val_if_fail (G_IS_FILE (file), NULL);
3541
3542   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3543     return NULL;
3544
3545   iface = G_FILE_GET_IFACE (file);
3546
3547   if (iface->monitor_dir == NULL)
3548     {
3549       g_set_error (error, G_IO_ERROR,
3550                    G_IO_ERROR_NOT_SUPPORTED,
3551                    _("Operation not supported"));
3552       return NULL;
3553     }
3554
3555   return (* iface->monitor_dir) (file, flags, cancellable, error);
3556 }
3557
3558 /**
3559  * g_file_monitor_file:
3560  * @file: input #GFile.
3561  * @flags: a set of #GFileMonitorFlags.
3562  * @cancellable: optional #GCancellable object, %NULL to ignore.
3563  * @error: a #GError, or %NULL.
3564  *
3565  * Obtains a file monitor for the given file. If no file notification
3566  * mechanism exists, then regular polling of the file is used.
3567  *
3568  * If @cancellable is not %NULL, then the operation can be cancelled by
3569  * triggering the cancellable object from another thread. If the operation
3570  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3571  *
3572  * Returns: a #GFileMonitor for the given @file.
3573  **/
3574 GFileMonitor*
3575 g_file_monitor_file (GFile             *file,
3576                      GFileMonitorFlags  flags,
3577                      GCancellable      *cancellable,
3578                      GError           **error)
3579 {
3580   GFileIface *iface;
3581   GFileMonitor *monitor;
3582
3583   g_return_val_if_fail (G_IS_FILE (file), NULL);
3584
3585   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3586     return NULL;
3587
3588   iface = G_FILE_GET_IFACE (file);
3589
3590   monitor = NULL;
3591
3592   if (iface->monitor_file)
3593     monitor = (* iface->monitor_file) (file, flags, cancellable, NULL);
3594
3595 /* Fallback to polling */
3596   if (monitor == NULL)
3597     monitor = _g_poll_file_monitor_new (file);
3598
3599   return monitor;
3600 }
3601
3602 /********************************************
3603  *   Default implementation of async ops    *
3604  ********************************************/
3605
3606 typedef struct {
3607   char *attributes;
3608   GFileQueryInfoFlags flags;
3609   GFileInfo *info;
3610 } QueryInfoAsyncData;
3611
3612 static void
3613 query_info_data_free (QueryInfoAsyncData *data)
3614 {
3615   if (data->info)
3616     g_object_unref (data->info);
3617   g_free (data->attributes);
3618   g_free (data);
3619 }
3620
3621 static void
3622 query_info_async_thread (GSimpleAsyncResult *res,
3623                          GObject            *object,
3624                          GCancellable       *cancellable)
3625 {
3626   GError *error = NULL;
3627   QueryInfoAsyncData *data;
3628   GFileInfo *info;
3629
3630   data = g_simple_async_result_get_op_res_gpointer (res);
3631
3632   info = g_file_query_info (G_FILE (object), data->attributes, data->flags, cancellable, &error);
3633
3634   if (info == NULL)
3635     {
3636       g_simple_async_result_set_from_error (res, error);
3637       g_error_free (error);
3638     }
3639   else
3640     data->info = info;
3641 }
3642
3643 static void
3644 g_file_real_query_info_async (GFile               *file,
3645                               const char          *attributes,
3646                               GFileQueryInfoFlags  flags,
3647                               int                  io_priority,
3648                               GCancellable        *cancellable,
3649                               GAsyncReadyCallback  callback,
3650                               gpointer             user_data)
3651 {
3652   GSimpleAsyncResult *res;
3653   QueryInfoAsyncData *data;
3654
3655   data = g_new0 (QueryInfoAsyncData, 1);
3656   data->attributes = g_strdup (attributes);
3657   data->flags = flags;
3658
3659   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_query_info_async);
3660   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_info_data_free);
3661
3662   g_simple_async_result_run_in_thread (res, query_info_async_thread, io_priority, cancellable);
3663   g_object_unref (res);
3664 }
3665
3666 static GFileInfo *
3667 g_file_real_query_info_finish (GFile         *file,
3668                                GAsyncResult  *res,
3669                                GError       **error)
3670 {
3671   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3672   QueryInfoAsyncData *data;
3673
3674   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_query_info_async);
3675
3676   data = g_simple_async_result_get_op_res_gpointer (simple);
3677   if (data->info)
3678     return g_object_ref (data->info);
3679
3680   return NULL;
3681 }
3682
3683 typedef struct {
3684   char *attributes;
3685   GFileQueryInfoFlags flags;
3686   GFileEnumerator *enumerator;
3687 } EnumerateChildrenAsyncData;
3688
3689 static void
3690 enumerate_children_data_free (EnumerateChildrenAsyncData *data)
3691 {
3692   if (data->enumerator)
3693     g_object_unref (data->enumerator);
3694   g_free (data->attributes);
3695   g_free (data);
3696 }
3697
3698 static void
3699 enumerate_children_async_thread (GSimpleAsyncResult *res,
3700                                  GObject            *object,
3701                                  GCancellable       *cancellable)
3702 {
3703   GError *error = NULL;
3704   EnumerateChildrenAsyncData *data;
3705   GFileEnumerator *enumerator;
3706
3707   data = g_simple_async_result_get_op_res_gpointer (res);
3708
3709   enumerator = g_file_enumerate_children (G_FILE (object), data->attributes, data->flags, cancellable, &error);
3710
3711   if (enumerator == NULL)
3712     {
3713       g_simple_async_result_set_from_error (res, error);
3714       g_error_free (error);
3715     }
3716   else
3717     data->enumerator = enumerator;
3718 }
3719
3720 static void
3721 g_file_real_enumerate_children_async (GFile               *file,
3722                                       const char          *attributes,
3723                                       GFileQueryInfoFlags  flags,
3724                                       int                  io_priority,
3725                                       GCancellable        *cancellable,
3726                                       GAsyncReadyCallback  callback,
3727                                       gpointer             user_data)
3728 {
3729   GSimpleAsyncResult *res;
3730   EnumerateChildrenAsyncData *data;
3731
3732   data = g_new0 (EnumerateChildrenAsyncData, 1);
3733   data->attributes = g_strdup (attributes);
3734   data->flags = flags;
3735
3736   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_enumerate_children_async);
3737   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)enumerate_children_data_free);
3738
3739   g_simple_async_result_run_in_thread (res, enumerate_children_async_thread, io_priority, cancellable);
3740   g_object_unref (res);
3741 }
3742
3743 static GFileEnumerator *
3744 g_file_real_enumerate_children_finish (GFile         *file,
3745                                        GAsyncResult  *res,
3746                                        GError       **error)
3747 {
3748   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3749   EnumerateChildrenAsyncData *data;
3750
3751   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_enumerate_children_async);
3752
3753   data = g_simple_async_result_get_op_res_gpointer (simple);
3754   if (data->enumerator)
3755     return g_object_ref (data->enumerator);
3756
3757   return NULL;
3758 }
3759
3760 static void
3761 open_read_async_thread (GSimpleAsyncResult *res,
3762                         GObject            *object,
3763                         GCancellable       *cancellable)
3764 {
3765   GFileIface *iface;
3766   GFileInputStream *stream;
3767   GError *error = NULL;
3768
3769   iface = G_FILE_GET_IFACE (object);
3770
3771   stream = iface->read_fn (G_FILE (object), cancellable, &error);
3772
3773   if (stream == NULL)
3774     {
3775       g_simple_async_result_set_from_error (res, error);
3776       g_error_free (error);
3777     }
3778   else
3779     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3780 }
3781
3782 static void
3783 g_file_real_read_async (GFile               *file,
3784                         int                  io_priority,
3785                         GCancellable        *cancellable,
3786                         GAsyncReadyCallback  callback,
3787                         gpointer             user_data)
3788 {
3789   GSimpleAsyncResult *res;
3790
3791   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_read_async);
3792
3793   g_simple_async_result_run_in_thread (res, open_read_async_thread, io_priority, cancellable);
3794   g_object_unref (res);
3795 }
3796
3797 static GFileInputStream *
3798 g_file_real_read_finish (GFile         *file,
3799                          GAsyncResult  *res,
3800                          GError       **error)
3801 {
3802   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3803   gpointer op;
3804
3805   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_read_async);
3806
3807   op = g_simple_async_result_get_op_res_gpointer (simple);
3808   if (op)
3809     return g_object_ref (op);
3810
3811   return NULL;
3812 }
3813
3814 static void
3815 append_to_async_thread (GSimpleAsyncResult *res,
3816                         GObject            *object,
3817                         GCancellable       *cancellable)
3818 {
3819   GFileIface *iface;
3820   GFileCreateFlags *data;
3821   GFileOutputStream *stream;
3822   GError *error = NULL;
3823
3824   iface = G_FILE_GET_IFACE (object);
3825
3826   data = g_simple_async_result_get_op_res_gpointer (res);
3827
3828   stream = iface->append_to (G_FILE (object), *data, cancellable, &error);
3829
3830   if (stream == NULL)
3831     {
3832       g_simple_async_result_set_from_error (res, error);
3833       g_error_free (error);
3834     }
3835   else
3836     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3837 }
3838
3839 static void
3840 g_file_real_append_to_async (GFile               *file,
3841                              GFileCreateFlags     flags,
3842                              int                  io_priority,
3843                              GCancellable        *cancellable,
3844                              GAsyncReadyCallback  callback,
3845                              gpointer             user_data)
3846 {
3847   GFileCreateFlags *data;
3848   GSimpleAsyncResult *res;
3849
3850   data = g_new0 (GFileCreateFlags, 1);
3851   *data = flags;
3852
3853   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_append_to_async);
3854   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
3855
3856   g_simple_async_result_run_in_thread (res, append_to_async_thread, io_priority, cancellable);
3857   g_object_unref (res);
3858 }
3859
3860 static GFileOutputStream *
3861 g_file_real_append_to_finish (GFile         *file,
3862                               GAsyncResult  *res,
3863                               GError       **error)
3864 {
3865   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3866   gpointer op;
3867
3868   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_append_to_async);
3869
3870   op = g_simple_async_result_get_op_res_gpointer (simple);
3871   if (op)
3872     return g_object_ref (op);
3873
3874   return NULL;
3875 }
3876
3877 static void
3878 create_async_thread (GSimpleAsyncResult *res,
3879                      GObject            *object,
3880                      GCancellable       *cancellable)
3881 {
3882   GFileIface *iface;
3883   GFileCreateFlags *data;
3884   GFileOutputStream *stream;
3885   GError *error = NULL;
3886
3887   iface = G_FILE_GET_IFACE (object);
3888
3889   data = g_simple_async_result_get_op_res_gpointer (res);
3890
3891   stream = iface->create (G_FILE (object), *data, cancellable, &error);
3892
3893   if (stream == NULL)
3894     {
3895       g_simple_async_result_set_from_error (res, error);
3896       g_error_free (error);
3897     }
3898   else
3899     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3900 }
3901
3902 static void
3903 g_file_real_create_async (GFile               *file,
3904                           GFileCreateFlags     flags,
3905                           int                  io_priority,
3906                           GCancellable        *cancellable,
3907                           GAsyncReadyCallback  callback,
3908                           gpointer             user_data)
3909 {
3910   GFileCreateFlags *data;
3911   GSimpleAsyncResult *res;
3912
3913   data = g_new0 (GFileCreateFlags, 1);
3914   *data = flags;
3915
3916   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_create_async);
3917   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
3918
3919   g_simple_async_result_run_in_thread (res, create_async_thread, io_priority, cancellable);
3920   g_object_unref (res);
3921 }
3922
3923 static GFileOutputStream *
3924 g_file_real_create_finish (GFile         *file,
3925                            GAsyncResult  *res,
3926                            GError       **error)
3927 {
3928   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3929   gpointer op;
3930
3931   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_create_async);
3932
3933   op = g_simple_async_result_get_op_res_gpointer (simple);
3934   if (op)
3935     return g_object_ref (op);
3936
3937   return NULL;
3938 }
3939
3940 typedef struct {
3941   GFileOutputStream *stream;
3942   char *etag;
3943   gboolean make_backup;
3944   GFileCreateFlags flags;
3945 } ReplaceAsyncData;
3946
3947 static void
3948 replace_async_data_free (ReplaceAsyncData *data)
3949 {
3950   if (data->stream)
3951     g_object_unref (data->stream);
3952   g_free (data->etag);
3953   g_free (data);
3954 }
3955
3956 static void
3957 replace_async_thread (GSimpleAsyncResult *res,
3958                       GObject            *object,
3959                       GCancellable       *cancellable)
3960 {
3961   GFileIface *iface;
3962   GFileOutputStream *stream;
3963   GError *error = NULL;
3964   ReplaceAsyncData *data;
3965
3966   iface = G_FILE_GET_IFACE (object);
3967
3968   data = g_simple_async_result_get_op_res_gpointer (res);
3969
3970   stream = iface->replace (G_FILE (object),
3971                            data->etag,
3972                            data->make_backup,
3973                            data->flags,
3974                            cancellable,
3975                            &error);
3976
3977   if (stream == NULL)
3978     {
3979       g_simple_async_result_set_from_error (res, error);
3980       g_error_free (error);
3981     }
3982   else
3983     data->stream = stream;
3984 }
3985
3986 static void
3987 g_file_real_replace_async (GFile               *file,
3988                            const char          *etag,
3989                            gboolean             make_backup,
3990                            GFileCreateFlags     flags,
3991                            int                  io_priority,
3992                            GCancellable        *cancellable,
3993                            GAsyncReadyCallback  callback,
3994                            gpointer             user_data)
3995 {
3996   GSimpleAsyncResult *res;
3997   ReplaceAsyncData *data;
3998
3999   data = g_new0 (ReplaceAsyncData, 1);
4000   data->etag = g_strdup (etag);
4001   data->make_backup = make_backup;
4002   data->flags = flags;
4003
4004   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_replace_async);
4005   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_async_data_free);
4006
4007   g_simple_async_result_run_in_thread (res, replace_async_thread, io_priority, cancellable);
4008   g_object_unref (res);
4009 }
4010
4011 static GFileOutputStream *
4012 g_file_real_replace_finish (GFile         *file,
4013                             GAsyncResult  *res,
4014                             GError       **error)
4015 {
4016   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4017   ReplaceAsyncData *data;
4018
4019   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_replace_async);
4020
4021   data = g_simple_async_result_get_op_res_gpointer (simple);
4022   if (data->stream)
4023     return g_object_ref (data->stream);
4024
4025   return NULL;
4026 }
4027
4028 typedef struct {
4029   char *name;
4030   GFile *file;
4031 } SetDisplayNameAsyncData;
4032
4033 static void
4034 set_display_name_data_free (SetDisplayNameAsyncData *data)
4035 {
4036   g_free (data->name);
4037   if (data->file)
4038     g_object_unref (data->file);
4039   g_free (data);
4040 }
4041
4042 static void
4043 set_display_name_async_thread (GSimpleAsyncResult *res,
4044                                GObject            *object,
4045                                GCancellable       *cancellable)
4046 {
4047   GError *error = NULL;
4048   SetDisplayNameAsyncData *data;
4049   GFile *file;
4050
4051   data = g_simple_async_result_get_op_res_gpointer (res);
4052
4053   file = g_file_set_display_name (G_FILE (object), data->name, cancellable, &error);
4054
4055   if (file == NULL)
4056     {
4057       g_simple_async_result_set_from_error (res, error);
4058       g_error_free (error);
4059     }
4060   else
4061     data->file = file;
4062 }
4063
4064 static void
4065 g_file_real_set_display_name_async (GFile               *file,
4066                                     const char          *display_name,
4067                                     int                  io_priority,
4068                                     GCancellable        *cancellable,
4069                                     GAsyncReadyCallback  callback,
4070                                     gpointer             user_data)
4071 {
4072   GSimpleAsyncResult *res;
4073   SetDisplayNameAsyncData *data;
4074
4075   data = g_new0 (SetDisplayNameAsyncData, 1);
4076   data->name = g_strdup (display_name);
4077
4078   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_display_name_async);
4079   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_display_name_data_free);
4080
4081   g_simple_async_result_run_in_thread (res, set_display_name_async_thread, io_priority, cancellable);
4082   g_object_unref (res);
4083 }
4084
4085 static GFile *
4086 g_file_real_set_display_name_finish (GFile         *file,
4087                                      GAsyncResult  *res,
4088                                      GError       **error)
4089 {
4090   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4091   SetDisplayNameAsyncData *data;
4092
4093   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_display_name_async);
4094
4095   data = g_simple_async_result_get_op_res_gpointer (simple);
4096   if (data->file)
4097     return g_object_ref (data->file);
4098
4099   return NULL;
4100 }
4101
4102 typedef struct {
4103   GFileQueryInfoFlags flags;
4104   GFileInfo *info;
4105   gboolean res;
4106   GError *error;
4107 } SetInfoAsyncData;
4108
4109 static void
4110 set_info_data_free (SetInfoAsyncData *data)
4111 {
4112   if (data->info)
4113     g_object_unref (data->info);
4114   if (data->error)
4115     g_error_free (data->error);
4116   g_free (data);
4117 }
4118
4119 static void
4120 set_info_async_thread (GSimpleAsyncResult *res,
4121                        GObject            *object,
4122                        GCancellable       *cancellable)
4123 {
4124   SetInfoAsyncData *data;
4125
4126   data = g_simple_async_result_get_op_res_gpointer (res);
4127
4128   data->error = NULL;
4129   data->res = g_file_set_attributes_from_info (G_FILE (object),
4130                                                data->info,
4131                                                data->flags,
4132                                                cancellable,
4133                                                &data->error);
4134 }
4135
4136 static void
4137 g_file_real_set_attributes_async (GFile               *file,
4138                                   GFileInfo           *info,
4139                                   GFileQueryInfoFlags  flags,
4140                                   int                  io_priority,
4141                                   GCancellable        *cancellable,
4142                                   GAsyncReadyCallback  callback,
4143                                   gpointer             user_data)
4144 {
4145   GSimpleAsyncResult *res;
4146   SetInfoAsyncData *data;
4147
4148   data = g_new0 (SetInfoAsyncData, 1);
4149   data->info = g_file_info_dup (info);
4150   data->flags = flags;
4151
4152   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_attributes_async);
4153   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_info_data_free);
4154
4155   g_simple_async_result_run_in_thread (res, set_info_async_thread, io_priority, cancellable);
4156   g_object_unref (res);
4157 }
4158
4159 static gboolean
4160 g_file_real_set_attributes_finish (GFile         *file,
4161                                    GAsyncResult  *res,
4162                                    GFileInfo    **info,
4163                                    GError       **error)
4164 {
4165   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4166   SetInfoAsyncData *data;
4167
4168   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_attributes_async);
4169
4170   data = g_simple_async_result_get_op_res_gpointer (simple);
4171
4172   if (info)
4173     *info = g_object_ref (data->info);
4174
4175   if (error != NULL && data->error)
4176     *error = g_error_copy (data->error);
4177
4178   return data->res;
4179 }
4180
4181 static void
4182 find_enclosing_mount_async_thread (GSimpleAsyncResult *res,
4183                                     GObject            *object,
4184                                     GCancellable       *cancellable)
4185 {
4186   GError *error = NULL;
4187   GMount *mount;
4188
4189   mount = g_file_find_enclosing_mount (G_FILE (object), cancellable, &error);
4190
4191   if (mount == NULL)
4192     {
4193       g_simple_async_result_set_from_error (res, error);
4194       g_error_free (error);
4195     }
4196   else
4197     g_simple_async_result_set_op_res_gpointer (res, mount, (GDestroyNotify)g_object_unref);
4198 }
4199
4200 static void
4201 g_file_real_find_enclosing_mount_async (GFile               *file,
4202                                         int                  io_priority,
4203                                         GCancellable        *cancellable,
4204                                         GAsyncReadyCallback  callback,
4205                                         gpointer             user_data)
4206 {
4207   GSimpleAsyncResult *res;
4208
4209   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_find_enclosing_mount_async);
4210
4211   g_simple_async_result_run_in_thread (res, find_enclosing_mount_async_thread, io_priority, cancellable);
4212   g_object_unref (res);
4213 }
4214
4215 static GMount *
4216 g_file_real_find_enclosing_mount_finish (GFile         *file,
4217                                           GAsyncResult  *res,
4218                                           GError       **error)
4219 {
4220   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4221   GMount *mount;
4222
4223   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_find_enclosing_mount_async);
4224
4225   mount = g_simple_async_result_get_op_res_gpointer (simple);
4226   return g_object_ref (mount);
4227 }
4228
4229
4230 typedef struct {
4231   GFile *source;
4232   GFile *destination;
4233   GFileCopyFlags flags;
4234   GFileProgressCallback progress_cb;
4235   gpointer progress_cb_data;
4236   GIOSchedulerJob *job;
4237 } CopyAsyncData;
4238
4239 static void
4240 copy_async_data_free (CopyAsyncData *data)
4241 {
4242   g_object_unref (data->source);
4243   g_object_unref (data->destination);
4244   g_free (data);
4245 }
4246
4247 typedef struct {
4248   CopyAsyncData *data;
4249   goffset current_num_bytes;
4250   goffset total_num_bytes;
4251 } ProgressData;
4252
4253 static gboolean
4254 copy_async_progress_in_main (gpointer user_data)
4255 {
4256   ProgressData *progress = user_data;
4257   CopyAsyncData *data = progress->data;
4258
4259   data->progress_cb (progress->current_num_bytes,
4260                      progress->total_num_bytes,
4261                      data->progress_cb_data);
4262
4263   return FALSE;
4264 }
4265
4266 static gboolean
4267 mainloop_barrier (gpointer user_data)
4268 {
4269   /* Does nothing, but ensures all queued idles before
4270      this are run */
4271   return FALSE;
4272 }
4273
4274
4275 static void
4276 copy_async_progress_callback (goffset  current_num_bytes,
4277                               goffset  total_num_bytes,
4278                               gpointer user_data)
4279 {
4280   CopyAsyncData *data = user_data;
4281   ProgressData *progress;
4282
4283   progress = g_new (ProgressData, 1);
4284   progress->data = data;
4285   progress->current_num_bytes = current_num_bytes;
4286   progress->total_num_bytes = total_num_bytes;
4287
4288   g_io_scheduler_job_send_to_mainloop_async (data->job,
4289                                              copy_async_progress_in_main,
4290                                              progress,
4291                                              g_free);
4292 }
4293
4294 static gboolean
4295 copy_async_thread (GIOSchedulerJob *job,
4296                    GCancellable    *cancellable,
4297                    gpointer         user_data)
4298 {
4299   GSimpleAsyncResult *res;
4300   CopyAsyncData *data;
4301   gboolean result;
4302   GError *error;
4303
4304   res = user_data;
4305   data = g_simple_async_result_get_op_res_gpointer (res);
4306
4307   error = NULL;
4308   data->job = job;
4309   result = g_file_copy (data->source,
4310                         data->destination,
4311                         data->flags,
4312                         cancellable,
4313                         (data->progress_cb != NULL) ? copy_async_progress_callback : NULL,
4314                         data,
4315                         &error);
4316
4317   /* Ensure all progress callbacks are done running in main thread */
4318   if (data->progress_cb != NULL)
4319     g_io_scheduler_job_send_to_mainloop (job,
4320                                          mainloop_barrier,
4321                                          NULL, NULL);
4322
4323   if (!result)
4324     {
4325       g_simple_async_result_set_from_error (res, error);
4326       g_error_free (error);
4327     }
4328
4329   g_simple_async_result_complete_in_idle (res);
4330
4331   return FALSE;
4332 }
4333
4334 static void
4335 g_file_real_copy_async (GFile                  *source,
4336                         GFile                  *destination,
4337                         GFileCopyFlags          flags,
4338                         int                     io_priority,
4339                         GCancellable           *cancellable,
4340                         GFileProgressCallback   progress_callback,
4341                         gpointer                progress_callback_data,
4342                         GAsyncReadyCallback     callback,
4343                         gpointer                user_data)
4344 {
4345   GSimpleAsyncResult *res;
4346   CopyAsyncData *data;
4347
4348   data = g_new0 (CopyAsyncData, 1);
4349   data->source = g_object_ref (source);
4350   data->destination = g_object_ref (destination);
4351   data->flags = flags;
4352   data->progress_cb = progress_callback;
4353   data->progress_cb_data = progress_callback_data;
4354
4355   res = g_simple_async_result_new (G_OBJECT (source), callback, user_data, g_file_real_copy_async);
4356   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)copy_async_data_free);
4357
4358   g_io_scheduler_push_job (copy_async_thread, res, g_object_unref, io_priority, cancellable);
4359 }
4360
4361 static gboolean
4362 g_file_real_copy_finish (GFile        *file,
4363                          GAsyncResult *res,
4364                          GError      **error)
4365 {
4366   /* Error handled in g_file_copy_finish() */
4367   return TRUE;
4368 }
4369
4370
4371 /********************************************
4372  *   Default VFS operations                 *
4373  ********************************************/
4374
4375 /**
4376  * g_file_new_for_path:
4377  * @path: a string containing a relative or absolute path.
4378  *
4379  * Constructs a #GFile for a given path. This operation never
4380  * fails, but the returned object might not support any I/O
4381  * operation if @path is malformed.
4382  *
4383  * Returns: a new #GFile for the given @path.
4384  **/
4385 GFile *
4386 g_file_new_for_path (const char *path)
4387 {
4388   g_return_val_if_fail (path != NULL, NULL);
4389
4390   return g_vfs_get_file_for_path (g_vfs_get_default (), path);
4391 }
4392
4393 /**
4394  * g_file_new_for_uri:
4395  * @uri: a string containing a URI.
4396  *
4397  * Constructs a #GFile for a given URI. This operation never
4398  * fails, but the returned object might not support any I/O
4399  * operation if @uri is malformed or if the uri type is
4400  * not supported.
4401  *
4402  * Returns: a #GFile for the given @uri.
4403  **/
4404 GFile *
4405 g_file_new_for_uri (const char *uri)
4406 {
4407   g_return_val_if_fail (uri != NULL, NULL);
4408
4409   return g_vfs_get_file_for_uri (g_vfs_get_default (), uri);
4410 }
4411
4412 /**
4413  * g_file_parse_name:
4414  * @parse_name: a file name or path to be parsed.
4415  *
4416  * Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()).
4417  * This operation never fails, but the returned object might not support any I/O
4418  * operation if the @parse_name cannot be parsed.
4419  *
4420  * Returns: a new #GFile.
4421  **/
4422 GFile *
4423 g_file_parse_name (const char *parse_name)
4424 {
4425   g_return_val_if_fail (parse_name != NULL, NULL);
4426
4427   return g_vfs_parse_name (g_vfs_get_default (), parse_name);
4428 }
4429
4430 static gboolean
4431 is_valid_scheme_character (char c)
4432 {
4433   return g_ascii_isalnum (c) || c == '+' || c == '-' || c == '.';
4434 }
4435
4436 static gboolean
4437 has_valid_scheme (const char *uri)
4438 {
4439   const char *p;
4440
4441   p = uri;
4442
4443   if (!is_valid_scheme_character (*p))
4444     return FALSE;
4445
4446   do {
4447     p++;
4448   } while (is_valid_scheme_character (*p));
4449
4450   return *p == ':';
4451 }
4452
4453 /**
4454  * g_file_new_for_commandline_arg:
4455  * @arg: a command line string.
4456  *
4457  * Creates a #GFile with the given argument from the command line. The value of
4458  * @arg can be either a URI, an absolute path or a relative path resolved
4459  * relative to the current working directory.
4460  * This operation never fails, but the returned object might not support any
4461  * I/O operation if @arg points to a malformed path.
4462  *
4463  * Returns: a new #GFile.
4464  **/
4465 GFile *
4466 g_file_new_for_commandline_arg (const char *arg)
4467 {
4468   GFile *file;
4469   char *filename;
4470   char *current_dir;
4471
4472   g_return_val_if_fail (arg != NULL, NULL);
4473
4474   if (g_path_is_absolute (arg))
4475     return g_file_new_for_path (arg);
4476
4477   if (has_valid_scheme (arg))
4478     return g_file_new_for_uri (arg);
4479
4480   current_dir = g_get_current_dir ();
4481   filename = g_build_filename (current_dir, arg, NULL);
4482   g_free (current_dir);
4483
4484   file = g_file_new_for_path (filename);
4485   g_free (filename);
4486
4487   return file;
4488 }
4489
4490 /**
4491  * g_file_mount_enclosing_volume:
4492  * @location: input #GFile.
4493  * @mount_operation: a #GMountOperation or %NULL to avoid user interaction.
4494  * @cancellable: optional #GCancellable object, %NULL to ignore.
4495  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4496  * @user_data: the data to pass to callback function
4497  *
4498  * Starts a @mount_operation, mounting the volume that contains the file @location.
4499  *
4500  * When this operation has completed, @callback will be called with
4501  * @user_user data, and the operation can be finalized with
4502  * g_file_mount_enclosing_volume_finish().
4503  *
4504  * If @cancellable is not %NULL, then the operation can be cancelled by
4505  * triggering the cancellable object from another thread. If the operation
4506  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4507  **/
4508 void
4509 g_file_mount_enclosing_volume (GFile               *location,
4510                                GMountOperation     *mount_operation,
4511                                GCancellable        *cancellable,
4512                                GAsyncReadyCallback  callback,
4513                                gpointer             user_data)
4514 {
4515   GFileIface *iface;
4516
4517   g_return_if_fail (G_IS_FILE (location));
4518
4519   iface = G_FILE_GET_IFACE (location);
4520
4521   if (iface->mount_enclosing_volume == NULL)
4522     {
4523       g_simple_async_report_error_in_idle (G_OBJECT (location),
4524                                            callback, user_data,
4525                                            G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
4526                                            _("volume doesn't implement mount"));
4527
4528       return;
4529     }
4530
4531   (* iface->mount_enclosing_volume) (location, mount_operation, cancellable, callback, user_data);
4532
4533 }
4534
4535 /**
4536  * g_file_mount_enclosing_volume_finish:
4537  * @location: input #GFile.
4538  * @result: a #GAsyncResult.
4539  * @error: a #GError, or %NULL
4540  *
4541  * Finishes a mount operation started by g_file_mount_enclosing_volume().
4542  *
4543  * Returns: %TRUE if successful. If an error
4544  * has occurred, this function will return %FALSE and set @error
4545  * appropriately if present.
4546  **/
4547 gboolean
4548 g_file_mount_enclosing_volume_finish (GFile         *location,
4549                                       GAsyncResult  *result,
4550                                       GError       **error)
4551 {
4552   GFileIface *iface;
4553
4554   g_return_val_if_fail (G_IS_FILE (location), FALSE);
4555   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4556
4557   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4558     {
4559       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4560       if (g_simple_async_result_propagate_error (simple, error))
4561         return FALSE;
4562     }
4563
4564   iface = G_FILE_GET_IFACE (location);
4565
4566   return (* iface->mount_enclosing_volume_finish) (location, result, error);
4567 }
4568
4569 /********************************************
4570  *   Utility functions                      *
4571  ********************************************/
4572
4573 #define GET_CONTENT_BLOCK_SIZE 8192
4574
4575 /**
4576  * g_file_load_contents:
4577  * @file: input #GFile.
4578  * @cancellable: optional #GCancellable object, %NULL to ignore.
4579  * @contents: a location to place the contents of the file.
4580  * @length: a location to place the length of the contents of the file.
4581  * @etag_out: a location to place the current entity tag for the file.
4582  * @error: a #GError, or %NULL
4583  *
4584  * Loads the content of the file into memory, returning the size of
4585  * the data. The data is always zero terminated, but this is not
4586  * included in the resultant @length.
4587  *
4588  * If @cancellable is not %NULL, then the operation can be cancelled by
4589  * triggering the cancellable object from another thread. If the operation
4590  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4591  *
4592  * Returns: %TRUE if the @file's contents were successfully loaded.
4593  * %FALSE if there were errors..
4594  **/
4595 gboolean
4596 g_file_load_contents (GFile         *file,
4597                       GCancellable  *cancellable,
4598                       char         **contents,
4599                       gsize         *length,
4600                       char         **etag_out,
4601                       GError       **error)
4602 {
4603   GFileInputStream *in;
4604   GByteArray *content;
4605   gsize pos;
4606   gssize res;
4607   GFileInfo *info;
4608
4609   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4610   g_return_val_if_fail (contents != NULL, FALSE);
4611
4612   in = g_file_read (file, cancellable, error);
4613   if (in == NULL)
4614     return FALSE;
4615
4616   content = g_byte_array_new ();
4617   pos = 0;
4618
4619   g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
4620   while ((res = g_input_stream_read (G_INPUT_STREAM (in),
4621                                      content->data + pos,
4622                                      GET_CONTENT_BLOCK_SIZE,
4623                                      cancellable, error)) > 0)
4624     {
4625       pos += res;
4626       g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
4627     }
4628
4629   if (etag_out)
4630     {
4631       *etag_out = NULL;
4632
4633       info = g_file_input_stream_query_info (in,
4634                                              G_FILE_ATTRIBUTE_ETAG_VALUE,
4635                                              cancellable,
4636                                              NULL);
4637       if (info)
4638         {
4639           *etag_out = g_strdup (g_file_info_get_etag (info));
4640           g_object_unref (info);
4641         }
4642     }
4643
4644   /* Ignore errors on close */
4645   g_input_stream_close (G_INPUT_STREAM (in), cancellable, NULL);
4646   g_object_unref (in);
4647
4648   if (res < 0)
4649     {
4650       /* error is set already */
4651       g_byte_array_free (content, TRUE);
4652       return FALSE;
4653     }
4654
4655   if (length)
4656     *length = pos;
4657
4658   /* Zero terminate (we got an extra byte allocated for this */
4659   content->data[pos] = 0;
4660
4661   *contents = (char *)g_byte_array_free (content, FALSE);
4662
4663   return TRUE;
4664 }
4665
4666 typedef struct {
4667   GFile *file;
4668   GError *error;
4669   GCancellable *cancellable;
4670   GFileReadMoreCallback read_more_callback;
4671   GAsyncReadyCallback callback;
4672   gpointer user_data;
4673   GByteArray *content;
4674   gsize pos;
4675   char *etag;
4676 } LoadContentsData;
4677
4678
4679 static void
4680 load_contents_data_free (LoadContentsData *data)
4681 {
4682   if (data->error)
4683     g_error_free (data->error);
4684   if (data->cancellable)
4685     g_object_unref (data->cancellable);
4686   if (data->content)
4687     g_byte_array_free (data->content, TRUE);
4688   g_free (data->etag);
4689   g_object_unref (data->file);
4690   g_free (data);
4691 }
4692
4693 static void
4694 load_contents_close_callback (GObject      *obj,
4695                               GAsyncResult *close_res,
4696                               gpointer      user_data)
4697 {
4698   GInputStream *stream = G_INPUT_STREAM (obj);
4699   LoadContentsData *data = user_data;
4700   GSimpleAsyncResult *res;
4701
4702   /* Ignore errors here, we're only reading anyway */
4703   g_input_stream_close_finish (stream, close_res, NULL);
4704   g_object_unref (stream);
4705
4706   res = g_simple_async_result_new (G_OBJECT (data->file),
4707                                    data->callback,
4708                                    data->user_data,
4709                                    g_file_load_contents_async);
4710   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)load_contents_data_free);
4711   g_simple_async_result_complete (res);
4712   g_object_unref (res);
4713 }
4714
4715 static void
4716 load_contents_fstat_callback (GObject      *obj,
4717                               GAsyncResult *stat_res,
4718                               gpointer      user_data)
4719 {
4720   GInputStream *stream = G_INPUT_STREAM (obj);
4721   LoadContentsData *data = user_data;
4722   GFileInfo *info;
4723
4724   info = g_file_input_stream_query_info_finish (G_FILE_INPUT_STREAM (stream),
4725                                                    stat_res, NULL);
4726   if (info)
4727     {
4728       data->etag = g_strdup (g_file_info_get_etag (info));
4729       g_object_unref (info);
4730     }
4731
4732   g_input_stream_close_async (stream, 0,
4733                               data->cancellable,
4734                               load_contents_close_callback, data);
4735 }
4736
4737 static void
4738 load_contents_read_callback (GObject      *obj,
4739                              GAsyncResult *read_res,
4740                              gpointer      user_data)
4741 {
4742   GInputStream *stream = G_INPUT_STREAM (obj);
4743   LoadContentsData *data = user_data;
4744   GError *error = NULL;
4745   gssize read_size;
4746
4747   read_size = g_input_stream_read_finish (stream, read_res, &error);
4748
4749   if (read_size < 0)
4750     {
4751       /* Error or EOF, close the file */
4752       data->error = error;
4753       g_input_stream_close_async (stream, 0,
4754                                   data->cancellable,
4755                                   load_contents_close_callback, data);
4756     }
4757   else if (read_size == 0)
4758     {
4759       g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
4760                                             G_FILE_ATTRIBUTE_ETAG_VALUE,
4761                                             0,
4762                                             data->cancellable,
4763                                             load_contents_fstat_callback,
4764                                             data);
4765     }
4766   else if (read_size > 0)
4767     {
4768       data->pos += read_size;
4769
4770       g_byte_array_set_size (data->content,
4771                              data->pos + GET_CONTENT_BLOCK_SIZE);
4772
4773
4774       if (data->read_more_callback &&
4775           !data->read_more_callback ((char *)data->content->data, data->pos, data->user_data))
4776         g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
4777                                               G_FILE_ATTRIBUTE_ETAG_VALUE,
4778                                               0,
4779                                               data->cancellable,
4780                                               load_contents_fstat_callback,
4781                                               data);
4782       else
4783         g_input_stream_read_async (stream,
4784                                    data->content->data + data->pos,
4785                                    GET_CONTENT_BLOCK_SIZE,
4786                                    0,
4787                                    data->cancellable,
4788                                    load_contents_read_callback,
4789                                    data);
4790     }
4791 }
4792
4793 static void
4794 load_contents_open_callback (GObject      *obj,
4795                              GAsyncResult *open_res,
4796                              gpointer      user_data)
4797 {
4798   GFile *file = G_FILE (obj);
4799   GFileInputStream *stream;
4800   LoadContentsData *data = user_data;
4801   GError *error = NULL;
4802   GSimpleAsyncResult *res;
4803
4804   stream = g_file_read_finish (file, open_res, &error);
4805
4806   if (stream)
4807     {
4808       g_byte_array_set_size (data->content,
4809                              data->pos + GET_CONTENT_BLOCK_SIZE);
4810       g_input_stream_read_async (G_INPUT_STREAM (stream),
4811                                  data->content->data + data->pos,
4812                                  GET_CONTENT_BLOCK_SIZE,
4813                                  0,
4814                                  data->cancellable,
4815                                  load_contents_read_callback,
4816                                  data);
4817
4818     }
4819   else
4820     {
4821       res = g_simple_async_result_new_from_error (G_OBJECT (data->file),
4822                                                   data->callback,
4823                                                   data->user_data,
4824                                                   error);
4825       g_simple_async_result_complete (res);
4826       g_error_free (error);
4827       load_contents_data_free (data);
4828       g_object_unref (res);
4829     }
4830 }
4831
4832 /**
4833  * g_file_load_partial_contents_async:
4834  * @file: input #GFile.
4835  * @cancellable: optional #GCancellable object, %NULL to ignore.
4836  * @read_more_callback: a #GFileReadMoreCallback to receive partial data and to specify whether further data should be read.
4837  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
4838  * @user_data: the data to pass to the callback functions.
4839  *
4840  * Reads the partial contents of a file. A #GFileReadMoreCallback should be
4841  * used to stop reading from the file when appropriate, else this function
4842  * will behave exactly as g_file_load_contents_async(). This operation
4843  * can be finished by g_file_load_partial_contents_finish().
4844  *
4845  * Users of this function should be aware that @user_data is passed to
4846  * both the @read_more_callback and the @callback.
4847  *
4848  * If @cancellable is not %NULL, then the operation can be cancelled by
4849  * triggering the cancellable object from another thread. If the operation
4850  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4851  **/
4852 void
4853 g_file_load_partial_contents_async (GFile                 *file,
4854                                     GCancellable          *cancellable,
4855                                     GFileReadMoreCallback  read_more_callback,
4856                                     GAsyncReadyCallback    callback,
4857                                     gpointer               user_data)
4858 {
4859   LoadContentsData *data;
4860
4861   g_return_if_fail (G_IS_FILE (file));
4862
4863   data = g_new0 (LoadContentsData, 1);
4864
4865   if (cancellable)
4866     data->cancellable = g_object_ref (cancellable);
4867   data->read_more_callback = read_more_callback;
4868   data->callback = callback;
4869   data->user_data = user_data;
4870   data->content = g_byte_array_new ();
4871   data->file = g_object_ref (file);
4872
4873   g_file_read_async (file,
4874                      0,
4875                      cancellable,
4876                      load_contents_open_callback,
4877                      data);
4878 }
4879
4880 /**
4881  * g_file_load_partial_contents_finish:
4882  * @file: input #GFile.
4883  * @res: a #GAsyncResult.
4884  * @contents: a location to place the contents of the file.
4885  * @length: a location to place the length of the contents of the file.
4886  * @etag_out: a location to place the current entity tag for the file.
4887  * @error: a #GError, or %NULL
4888  *
4889  * Finishes an asynchronous partial load operation that was started
4890  * with g_file_load_partial_contents_async().
4891  *
4892  * Returns: %TRUE if the load was successful. If %FALSE and @error is
4893  * present, it will be set appropriately.
4894  **/
4895 gboolean
4896 g_file_load_partial_contents_finish (GFile         *file,
4897                                      GAsyncResult  *res,
4898                                      char         **contents,
4899                                      gsize         *length,
4900                                      char         **etag_out,
4901                                      GError       **error)
4902 {
4903   GSimpleAsyncResult *simple;
4904   LoadContentsData *data;
4905
4906   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4907   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
4908   g_return_val_if_fail (contents != NULL, FALSE);
4909
4910   simple = G_SIMPLE_ASYNC_RESULT (res);
4911
4912   if (g_simple_async_result_propagate_error (simple, error))
4913     return FALSE;
4914
4915   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_load_contents_async);
4916
4917   data = g_simple_async_result_get_op_res_gpointer (simple);
4918
4919   if (data->error)
4920     {
4921       g_propagate_error (error, data->error);
4922       data->error = NULL;
4923       *contents = NULL;
4924       if (length)
4925         *length = 0;
4926       return FALSE;
4927     }
4928
4929   if (length)
4930     *length = data->pos;
4931
4932   if (etag_out)
4933     {
4934       *etag_out = data->etag;
4935       data->etag = NULL;
4936     }
4937
4938   /* Zero terminate */
4939   g_byte_array_set_size (data->content, data->pos + 1);
4940   data->content->data[data->pos] = 0;
4941
4942   *contents = (char *)g_byte_array_free (data->content, FALSE);
4943   data->content = NULL;
4944
4945   return TRUE;
4946 }
4947
4948 /**
4949  * g_file_load_contents_async:
4950  * @file: input #GFile.
4951  * @cancellable: optional #GCancellable object, %NULL to ignore.
4952  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
4953  * @user_data: the data to pass to callback function
4954  *
4955  * Starts an asynchronous load of the @file's contents.
4956  *
4957  * For more details, see g_file_load_contents() which is
4958  * the synchronous version of this call.
4959  *
4960  * When the load operation has completed, @callback will be called
4961  * with @user data. To finish the operation, call
4962  * g_file_load_contents_finish() with the #GAsyncResult returned by
4963  * the @callback.
4964  *
4965  * If @cancellable is not %NULL, then the operation can be cancelled by
4966  * triggering the cancellable object from another thread. If the operation
4967  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4968  **/
4969 void
4970 g_file_load_contents_async (GFile               *file,
4971                            GCancellable        *cancellable,
4972                            GAsyncReadyCallback  callback,
4973                            gpointer             user_data)
4974 {
4975   g_file_load_partial_contents_async (file,
4976                                       cancellable,
4977                                       NULL,
4978                                       callback, user_data);
4979 }
4980
4981 /**
4982  * g_file_load_contents_finish:
4983  * @file: input #GFile.
4984  * @res: a #GAsyncResult.
4985  * @contents: a location to place the contents of the file.
4986  * @length: a location to place the length of the contents of the file.
4987  * @etag_out: a location to place the current entity tag for the file.
4988  * @error: a #GError, or %NULL
4989  *
4990  * Finishes an asynchronous load of the @file's contents.
4991  * The contents are placed in @contents, and @length is set to the
4992  * size of the @contents string. If @etag_out is present, it will be
4993  * set to the new entity tag for the @file.
4994  *
4995  * Returns: %TRUE if the load was successful. If %FALSE and @error is
4996  * present, it will be set appropriately.
4997  **/
4998 gboolean
4999 g_file_load_contents_finish (GFile         *file,
5000                              GAsyncResult  *res,
5001                              char         **contents,
5002                              gsize         *length,
5003                              char         **etag_out,
5004                              GError       **error)
5005 {
5006   return g_file_load_partial_contents_finish (file,
5007                                               res,
5008                                               contents,
5009                                               length,
5010                                               etag_out,
5011                                               error);
5012 }
5013
5014 /**
5015  * g_file_replace_contents:
5016  * @file: input #GFile.
5017  * @contents: a string containing the new contents for @file.
5018  * @length: the length of @contents in bytes.
5019  * @etag: the old <link linkend="gfile-etag">entity tag</link>
5020  *     for the document.
5021  * @make_backup: %TRUE if a backup should be created.
5022  * @flags: a set of #GFileCreateFlags.
5023  * @new_etag: a location to a new <link linkend="gfile-etag">entity tag</link>
5024  *      for the document.
5025  * @cancellable: optional #GCancellable object, %NULL to ignore.
5026  * @error: a #GError, or %NULL
5027  *
5028  * Replaces the contents of @file with @contents of @length bytes.
5029
5030  * If @etag is specified (not %NULL) any existing file must have that etag, or
5031  * the error %G_IO_ERROR_WRONG_ETAG will be returned.
5032  *
5033  * If @make_backup is %TRUE, this function will attempt to make a backup of @file.
5034  *
5035  * If @cancellable is not %NULL, then the operation can be cancelled by
5036  * triggering the cancellable object from another thread. If the operation
5037  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5038  *
5039  * The returned @new_etag can be used to verify that the file hasn't changed the
5040  * next time it is saved over.
5041  *
5042  * Returns: %TRUE if successful. If an error
5043  * has occurred, this function will return %FALSE and set @error
5044  * appropriately if present.
5045  **/
5046 gboolean
5047 g_file_replace_contents (GFile             *file,
5048                          const char        *contents,
5049                          gsize              length,
5050                          const char        *etag,
5051                          gboolean           make_backup,
5052                          GFileCreateFlags   flags,
5053                          char             **new_etag,
5054                          GCancellable      *cancellable,
5055                          GError           **error)
5056 {
5057   GFileOutputStream *out;
5058   gsize pos, remainder;
5059   gssize res;
5060
5061   g_return_val_if_fail (G_IS_FILE (file), FALSE);
5062   g_return_val_if_fail (contents != NULL, FALSE);
5063
5064   out = g_file_replace (file, etag, make_backup, flags, cancellable, error);
5065   if (out == NULL)
5066     return FALSE;
5067
5068   pos = 0;
5069   remainder = length;
5070   while (remainder > 0 &&
5071          (res = g_output_stream_write (G_OUTPUT_STREAM (out),
5072                                        contents + pos,
5073                                        MIN (remainder, GET_CONTENT_BLOCK_SIZE),
5074                                        cancellable,
5075                                        error)) > 0)
5076     {
5077       pos += res;
5078       remainder -= res;
5079     }
5080
5081   if (remainder > 0 && res < 0)
5082     {
5083       /* Ignore errors on close */
5084       g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, NULL);
5085
5086       /* error is set already */
5087       return FALSE;
5088     }
5089
5090   if (!g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, error))
5091     return FALSE;
5092
5093   if (new_etag)
5094     *new_etag = g_file_output_stream_get_etag (out);
5095
5096   return TRUE;
5097 }
5098
5099 typedef struct {
5100   GFile *file;
5101   GError *error;
5102   GCancellable *cancellable;
5103   GAsyncReadyCallback callback;
5104   gpointer user_data;
5105   const char *content;
5106   gsize length;
5107   gsize pos;
5108   char *etag;
5109 } ReplaceContentsData;
5110
5111 static void
5112 replace_contents_data_free (ReplaceContentsData *data)
5113 {
5114   if (data->error)
5115     g_error_free (data->error);
5116   if (data->cancellable)
5117     g_object_unref (data->cancellable);
5118   g_object_unref (data->file);
5119   g_free (data->etag);
5120   g_free (data);
5121 }
5122
5123 static void
5124 replace_contents_close_callback (GObject      *obj,
5125                                  GAsyncResult *close_res,
5126                                  gpointer      user_data)
5127 {
5128   GOutputStream *stream = G_OUTPUT_STREAM (obj);
5129   ReplaceContentsData *data = user_data;
5130   GSimpleAsyncResult *res;
5131
5132   /* Ignore errors here, we're only reading anyway */
5133   g_output_stream_close_finish (stream, close_res, NULL);
5134   g_object_unref (stream);
5135
5136   data->etag = g_file_output_stream_get_etag (G_FILE_OUTPUT_STREAM (stream));
5137
5138   res = g_simple_async_result_new (G_OBJECT (data->file),
5139                                    data->callback,
5140                                    data->user_data,
5141                                    g_file_replace_contents_async);
5142   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_contents_data_free);
5143   g_simple_async_result_complete (res);
5144   g_object_unref (res);
5145 }
5146
5147 static void
5148 replace_contents_write_callback (GObject      *obj,
5149                                  GAsyncResult *read_res,
5150                                  gpointer      user_data)
5151 {
5152   GOutputStream *stream = G_OUTPUT_STREAM (obj);
5153   ReplaceContentsData *data = user_data;
5154   GError *error = NULL;
5155   gssize write_size;
5156
5157   write_size = g_output_stream_write_finish (stream, read_res, &error);
5158
5159   if (write_size <= 0)
5160     {
5161       /* Error or EOF, close the file */
5162       if (write_size < 0)
5163         data->error = error;
5164       g_output_stream_close_async (stream, 0,
5165                                    data->cancellable,
5166                                    replace_contents_close_callback, data);
5167     }
5168   else if (write_size > 0)
5169     {
5170       data->pos += write_size;
5171
5172       if (data->pos >= data->length)
5173         g_output_stream_close_async (stream, 0,
5174                                      data->cancellable,
5175                                      replace_contents_close_callback, data);
5176       else
5177         g_output_stream_write_async (stream,
5178                                      data->content + data->pos,
5179                                      data->length - data->pos,
5180                                      0,
5181                                      data->cancellable,
5182                                      replace_contents_write_callback,
5183                                      data);
5184     }
5185 }
5186
5187 static void
5188 replace_contents_open_callback (GObject      *obj,
5189                                 GAsyncResult *open_res,
5190                                 gpointer      user_data)
5191 {
5192   GFile *file = G_FILE (obj);
5193   GFileOutputStream *stream;
5194   ReplaceContentsData *data = user_data;
5195   GError *error = NULL;
5196   GSimpleAsyncResult *res;
5197
5198   stream = g_file_replace_finish (file, open_res, &error);
5199
5200   if (stream)
5201     {
5202       g_output_stream_write_async (G_OUTPUT_STREAM (stream),
5203                                    data->content + data->pos,
5204                                    data->length - data->pos,
5205                                    0,
5206                                    data->cancellable,
5207                                    replace_contents_write_callback,
5208                                    data);
5209
5210     }
5211   else
5212     {
5213       res = g_simple_async_result_new_from_error (G_OBJECT (data->file),
5214                                                   data->callback,
5215                                                   data->user_data,
5216                                                   error);
5217       g_simple_async_result_complete (res);
5218       g_error_free (error);
5219       replace_contents_data_free (data);
5220       g_object_unref (res);
5221     }
5222 }
5223
5224 /**
5225  * g_file_replace_contents_async:
5226  * @file: input #GFile.
5227  * @contents: string of contents to replace the file with.
5228  * @length: the length of @contents in bytes.
5229  * @etag: a new <link linkend="gfile-etag">entity tag</link> for the @file.
5230  * @make_backup: %TRUE if a backup should be created.
5231  * @flags: a set of #GFileCreateFlags.
5232  * @cancellable: optional #GCancellable object, %NULL to ignore.
5233  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
5234  * @user_data: the data to pass to callback function
5235  *
5236  * Starts an asynchronous replacement of @file with the given
5237  * @contents of @length bytes. @etag will replace the document's
5238  * current entity tag.
5239  *
5240  * When this operation has completed, @callback will be called with
5241  * @user_user data, and the operation can be finalized with
5242  * g_file_replace_contents_finish().
5243  *
5244  * If @cancellable is not %NULL, then the operation can be cancelled by
5245  * triggering the cancellable object from another thread. If the operation
5246  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5247  *
5248  * If @make_backup is %TRUE, this function will attempt to
5249  * make a backup of @file.
5250  **/
5251 void
5252 g_file_replace_contents_async  (GFile               *file,
5253                                 const char          *contents,
5254                                 gsize                length,
5255                                 const char          *etag,
5256                                 gboolean             make_backup,
5257                                 GFileCreateFlags     flags,
5258                                 GCancellable        *cancellable,
5259                                 GAsyncReadyCallback  callback,
5260                                 gpointer             user_data)
5261 {
5262   ReplaceContentsData *data;
5263
5264   g_return_if_fail (G_IS_FILE (file));
5265   g_return_if_fail (contents != NULL);
5266
5267   data = g_new0 (ReplaceContentsData, 1);
5268
5269   if (cancellable)
5270     data->cancellable = g_object_ref (cancellable);
5271   data->callback = callback;
5272   data->user_data = user_data;
5273   data->content = contents;
5274   data->length = length;
5275   data->pos = 0;
5276   data->file = g_object_ref (file);
5277
5278   g_file_replace_async (file,
5279                         etag,
5280                         make_backup,
5281                         flags,
5282                         0,
5283                         cancellable,
5284                         replace_contents_open_callback,
5285                         data);
5286 }
5287
5288 /**
5289  * g_file_replace_contents_finish:
5290  * @file: input #GFile.
5291  * @res: a #GAsyncResult.
5292  * @new_etag: a location of a new <link linkend="gfile-etag">entity tag</link>
5293  *     for the document.
5294  * @error: a #GError, or %NULL
5295  *
5296  * Finishes an asynchronous replace of the given @file. See
5297  * g_file_replace_contents_async(). Sets @new_etag to the new entity
5298  * tag for the document, if present.
5299  *
5300  * Returns: %TRUE on success, %FALSE on failure.
5301  **/
5302 gboolean
5303 g_file_replace_contents_finish (GFile         *file,
5304                                 GAsyncResult  *res,
5305                                 char         **new_etag,
5306                                 GError       **error)
5307 {
5308   GSimpleAsyncResult *simple;
5309   ReplaceContentsData *data;
5310
5311   g_return_val_if_fail (G_IS_FILE (file), FALSE);
5312   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
5313
5314   simple = G_SIMPLE_ASYNC_RESULT (res);
5315
5316   if (g_simple_async_result_propagate_error (simple, error))
5317     return FALSE;
5318
5319   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_replace_contents_async);
5320
5321   data = g_simple_async_result_get_op_res_gpointer (simple);
5322
5323   if (data->error)
5324     {
5325       g_propagate_error (error, data->error);
5326       data->error = NULL;
5327       return FALSE;
5328     }
5329
5330
5331   if (new_etag)
5332     {
5333       *new_etag = data->etag;
5334       data->etag = NULL; /* Take ownership */
5335     }
5336
5337   return TRUE;
5338 }
5339
5340 #define __G_FILE_C__
5341 #include "gioaliasdef.c"