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 or directory with this name already exists the G_IO_ERROR_EXISTS
1310  * error will be returned.
1311  * Some file systems don't allow all file names, and may
1312  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1313  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1314  * Other errors are possible too, and depend on what kind of
1315  * filesystem the file is on.
1316  *
1317  * Returns: a #GFileOutputStream for the newly created file, or
1318  * %NULL on error.
1319  **/
1320 GFileOutputStream *
1321 g_file_create (GFile             *file,
1322                GFileCreateFlags   flags,
1323                GCancellable      *cancellable,
1324                GError           **error)
1325 {
1326   GFileIface *iface;
1327
1328   g_return_val_if_fail (G_IS_FILE (file), NULL);
1329
1330   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1331     return NULL;
1332
1333   iface = G_FILE_GET_IFACE (file);
1334
1335   if (iface->create == NULL)
1336     {
1337       g_set_error (error, G_IO_ERROR,
1338                    G_IO_ERROR_NOT_SUPPORTED,
1339                    _("Operation not supported"));
1340       return NULL;
1341     }
1342
1343   return (* iface->create) (file, flags, cancellable, error);
1344 }
1345
1346 /**
1347  * g_file_replace:
1348  * @file: input #GFile.
1349  * @etag: an optional <link linkend="gfile-etag">entity tag</link> for the
1350  *     current #GFile, or #NULL to ignore.
1351  * @make_backup: %TRUE if a backup should be created.
1352  * @flags: a set of #GFileCreateFlags.
1353  * @cancellable: optional #GCancellable object, %NULL to ignore.
1354  * @error: a #GError, or %NULL
1355  *
1356  * Returns an output stream for overwriting the file, possibly
1357  * creating a backup copy of the file first.
1358  *
1359  * This will try to replace the file in the safest way possible so
1360  * that any errors during the writing will not affect an already
1361  * existing copy of the file. For instance, for local files it
1362  * may write to a temporary file and then atomically rename over
1363  * the destination when the stream is closed.
1364  *
1365  * By default files created are generally readable by everyone,
1366  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1367  * will be made readable only to the current user, to the level that
1368  * is supported on the target filesystem.
1369  *
1370  * If @cancellable is not %NULL, then the operation can be cancelled by
1371  * triggering the cancellable object from another thread. If the operation
1372  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1373  *
1374  * If you pass in a non-#NULL @etag value, then this value is
1375  * compared to the current entity tag of the file, and if they differ
1376  * an G_IO_ERROR_WRONG_ETAG error is returned. This generally means
1377  * that the file has been changed since you last read it. You can get
1378  * the new etag from g_file_output_stream_get_etag() after you've
1379  * finished writing and closed the #GFileOutputStream. When you load
1380  * a new file you can use g_file_input_stream_query_info() to get
1381  * the etag of the file.
1382  *
1383  * If @make_backup is %TRUE, this function will attempt to make a backup
1384  * of the current file before overwriting it. If this fails a G_IO_ERROR_CANT_CREATE_BACKUP
1385  * error will be returned. If you want to replace anyway, try again with
1386  * @make_backup set to %FALSE.
1387  *
1388  * If the file is a directory the G_IO_ERROR_IS_DIRECTORY error will be returned,
1389  * and if the file is some other form of non-regular file then a
1390  * G_IO_ERROR_NOT_REGULAR_FILE error will be returned.
1391  * Some file systems don't allow all file names, and may
1392  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1393  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1394  * Other errors are possible too, and depend on what kind of
1395  * filesystem the file is on.
1396  *
1397  * Returns: a #GFileOutputStream or %NULL on error.
1398  **/
1399 GFileOutputStream *
1400 g_file_replace (GFile             *file,
1401                 const char        *etag,
1402                 gboolean           make_backup,
1403                 GFileCreateFlags   flags,
1404                 GCancellable      *cancellable,
1405                 GError           **error)
1406 {
1407   GFileIface *iface;
1408
1409   g_return_val_if_fail (G_IS_FILE (file), NULL);
1410
1411   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1412     return NULL;
1413
1414   iface = G_FILE_GET_IFACE (file);
1415
1416   if (iface->replace == NULL)
1417     {
1418       g_set_error (error, G_IO_ERROR,
1419                    G_IO_ERROR_NOT_SUPPORTED,
1420                    _("Operation not supported"));
1421       return NULL;
1422     }
1423
1424
1425   /* Handle empty tag string as NULL in consistent way. */
1426   if (etag && *etag == 0)
1427     etag = NULL;
1428
1429   return (* iface->replace) (file, etag, make_backup, flags, cancellable, error);
1430 }
1431
1432 /**
1433  * g_file_read_async:
1434  * @file: input #GFile.
1435  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1436  *     of the request.
1437  * @cancellable: optional #GCancellable object, %NULL to ignore.
1438  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1439  * @user_data: the data to pass to callback function
1440  *
1441  * Asynchronously opens @file for reading.
1442  *
1443  * For more details, see g_file_read() which is
1444  * the synchronous version of this call.
1445  *
1446  * When the operation is finished, @callback will be called. You can then call
1447  * g_file_read_finish() to get the result of the operation.
1448  **/
1449 void
1450 g_file_read_async (GFile               *file,
1451                    int                  io_priority,
1452                    GCancellable        *cancellable,
1453                    GAsyncReadyCallback  callback,
1454                    gpointer             user_data)
1455 {
1456   GFileIface *iface;
1457
1458   g_return_if_fail (G_IS_FILE (file));
1459
1460   iface = G_FILE_GET_IFACE (file);
1461   (* iface->read_async) (file,
1462                          io_priority,
1463                          cancellable,
1464                          callback,
1465                          user_data);
1466 }
1467
1468 /**
1469  * g_file_read_finish:
1470  * @file: input #GFile.
1471  * @res: a #GAsyncResult.
1472  * @error: a #GError, or %NULL
1473  *
1474  * Finishes an asynchronous file read operation started with
1475  * g_file_read_async().
1476  *
1477  * Returns: a #GFileInputStream or %NULL on error.
1478  **/
1479 GFileInputStream *
1480 g_file_read_finish (GFile         *file,
1481                     GAsyncResult  *res,
1482                     GError       **error)
1483 {
1484   GFileIface *iface;
1485
1486   g_return_val_if_fail (G_IS_FILE (file), NULL);
1487   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1488
1489   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1490     {
1491       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1492       if (g_simple_async_result_propagate_error (simple, error))
1493         return NULL;
1494     }
1495
1496   iface = G_FILE_GET_IFACE (file);
1497   return (* iface->read_finish) (file, res, error);
1498 }
1499
1500 /**
1501  * g_file_append_to_async:
1502  * @file: input #GFile.
1503  * @flags: a set of #GFileCreateFlags.
1504  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1505  *     of the request.
1506  * @cancellable: optional #GCancellable object, %NULL to ignore.
1507  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1508  * @user_data: the data to pass to callback function
1509  *
1510  * Asynchronously opens @file for appending.
1511  *
1512  * For more details, see g_file_append_to() which is
1513  * the synchronous version of this call.
1514  *
1515  * When the operation is finished, @callback will be called. You can then call
1516  * g_file_append_to_finish() to get the result of the operation.
1517  **/
1518 void
1519 g_file_append_to_async (GFile               *file,
1520                         GFileCreateFlags     flags,
1521                         int                  io_priority,
1522                         GCancellable        *cancellable,
1523                         GAsyncReadyCallback  callback,
1524                         gpointer             user_data)
1525 {
1526   GFileIface *iface;
1527
1528   g_return_if_fail (G_IS_FILE (file));
1529
1530   iface = G_FILE_GET_IFACE (file);
1531   (* iface->append_to_async) (file,
1532                               flags,
1533                               io_priority,
1534                               cancellable,
1535                               callback,
1536                               user_data);
1537 }
1538
1539 /**
1540  * g_file_append_to_finish:
1541  * @file: input #GFile.
1542  * @res: #GAsyncResult
1543  * @error: a #GError, or %NULL
1544  *
1545  * Finishes an asynchronous file append operation started with
1546  * g_file_append_to_async().
1547  *
1548  * Returns: a valid #GFileOutputStream or %NULL on error.
1549  **/
1550 GFileOutputStream *
1551 g_file_append_to_finish (GFile         *file,
1552                          GAsyncResult  *res,
1553                          GError       **error)
1554 {
1555   GFileIface *iface;
1556
1557   g_return_val_if_fail (G_IS_FILE (file), NULL);
1558   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1559
1560   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1561     {
1562       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1563       if (g_simple_async_result_propagate_error (simple, error))
1564         return NULL;
1565     }
1566
1567   iface = G_FILE_GET_IFACE (file);
1568   return (* iface->append_to_finish) (file, res, error);
1569 }
1570
1571 /**
1572  * g_file_create_async:
1573  * @file: input #GFile.
1574  * @flags: a set of #GFileCreateFlags.
1575  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1576  *     of the request.
1577  * @cancellable: optional #GCancellable object, %NULL to ignore.
1578  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1579  * @user_data: the data to pass to callback function
1580  *
1581  * Asynchronously creates a new file and returns an output stream for writing to it.
1582  * The file must not already exists.
1583  *
1584  * For more details, see g_file_create() which is
1585  * the synchronous version of this call.
1586  *
1587  * When the operation is finished, @callback will be called. You can then call
1588  * g_file_create_finish() to get the result of the operation.
1589  **/
1590 void
1591 g_file_create_async (GFile               *file,
1592                      GFileCreateFlags     flags,
1593                      int                  io_priority,
1594                      GCancellable        *cancellable,
1595                      GAsyncReadyCallback  callback,
1596                      gpointer             user_data)
1597 {
1598   GFileIface *iface;
1599
1600   g_return_if_fail (G_IS_FILE (file));
1601
1602   iface = G_FILE_GET_IFACE (file);
1603   (* iface->create_async) (file,
1604                            flags,
1605                            io_priority,
1606                            cancellable,
1607                            callback,
1608                            user_data);
1609 }
1610
1611 /**
1612  * g_file_create_finish:
1613  * @file: input #GFile.
1614  * @res: a #GAsyncResult.
1615  * @error: a #GError, or %NULL
1616  *
1617  * Finishes an asynchronous file create operation started with
1618  * g_file_create_async().
1619  *
1620  * Returns: a #GFileOutputStream or %NULL on error.
1621  **/
1622 GFileOutputStream *
1623 g_file_create_finish (GFile         *file,
1624                       GAsyncResult  *res,
1625                       GError       **error)
1626 {
1627   GFileIface *iface;
1628
1629   g_return_val_if_fail (G_IS_FILE (file), NULL);
1630   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1631
1632   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1633     {
1634       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1635       if (g_simple_async_result_propagate_error (simple, error))
1636         return NULL;
1637     }
1638
1639   iface = G_FILE_GET_IFACE (file);
1640   return (* iface->create_finish) (file, res, error);
1641 }
1642
1643 /**
1644  * g_file_replace_async:
1645  * @file: input #GFile.
1646  * @etag: an <link linkend="gfile-etag">entity tag</link> for the
1647  *     current #GFile, or NULL to ignore.
1648  * @make_backup: %TRUE if a backup should be created.
1649  * @flags: a set of #GFileCreateFlags.
1650  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1651  *     of the request.
1652  * @cancellable: optional #GCancellable object, %NULL to ignore.
1653  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
1654  * @user_data: the data to pass to callback function
1655  *
1656  * Asynchronously overwrites the file, replacing the contents, possibly
1657  * creating a backup copy of the file first.
1658  *
1659  * For more details, see g_file_replace() which is
1660  * the synchronous version of this call.
1661  *
1662  * When the operation is finished, @callback will be called. You can then call
1663  * g_file_replace_finish() to get the result of the operation.
1664  **/
1665 void
1666 g_file_replace_async (GFile               *file,
1667                       const char          *etag,
1668                       gboolean             make_backup,
1669                       GFileCreateFlags     flags,
1670                       int                  io_priority,
1671                       GCancellable        *cancellable,
1672                       GAsyncReadyCallback  callback,
1673                       gpointer             user_data)
1674 {
1675   GFileIface *iface;
1676
1677   g_return_if_fail (G_IS_FILE (file));
1678
1679   iface = G_FILE_GET_IFACE (file);
1680   (* iface->replace_async) (file,
1681                             etag,
1682                             make_backup,
1683                             flags,
1684                             io_priority,
1685                             cancellable,
1686                             callback,
1687                             user_data);
1688 }
1689
1690 /**
1691  * g_file_replace_finish:
1692  * @file: input #GFile.
1693  * @res: a #GAsyncResult.
1694  * @error: a #GError, or %NULL
1695  *
1696  * Finishes an asynchronous file replace operation started with
1697  * g_file_replace_async().
1698  *
1699  * Returns: a #GFileOutputStream, or %NULL on error.
1700  **/
1701 GFileOutputStream *
1702 g_file_replace_finish (GFile         *file,
1703                        GAsyncResult  *res,
1704                        GError       **error)
1705 {
1706   GFileIface *iface;
1707
1708   g_return_val_if_fail (G_IS_FILE (file), NULL);
1709   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1710
1711   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1712     {
1713       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1714       if (g_simple_async_result_propagate_error (simple, error))
1715         return NULL;
1716     }
1717
1718   iface = G_FILE_GET_IFACE (file);
1719   return (* iface->replace_finish) (file, res, error);
1720 }
1721
1722 static gboolean
1723 copy_symlink (GFile           *destination,
1724               GFileCopyFlags   flags,
1725               GCancellable    *cancellable,
1726               const char      *target,
1727               GError         **error)
1728 {
1729   GError *my_error;
1730   gboolean tried_delete;
1731   GFileInfo *info;
1732   GFileType file_type;
1733
1734   tried_delete = FALSE;
1735
1736  retry:
1737   my_error = NULL;
1738   if (!g_file_make_symbolic_link (destination, target, cancellable, &my_error))
1739     {
1740       /* Maybe it already existed, and we want to overwrite? */
1741       if (!tried_delete && (flags & G_FILE_COPY_OVERWRITE) &&
1742           my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_EXISTS)
1743         {
1744           g_error_free (my_error);
1745
1746
1747           /* Don't overwrite if the destination is a directory */
1748           info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
1749                                     G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1750                                     cancellable, &my_error);
1751           if (info != NULL)
1752             {
1753               file_type = g_file_info_get_file_type (info);
1754               g_object_unref (info);
1755
1756               if (file_type == G_FILE_TYPE_DIRECTORY)
1757                 {
1758                   g_set_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1759                                _("Can't copy over directory"));
1760                   return FALSE;
1761                 }
1762             }
1763
1764           if (!g_file_delete (destination, cancellable, error))
1765             return FALSE;
1766
1767           tried_delete = TRUE;
1768           goto retry;
1769         }
1770             /* Nah, fail */
1771       g_propagate_error (error, my_error);
1772       return FALSE;
1773     }
1774
1775   return TRUE;
1776 }
1777
1778 static GInputStream *
1779 open_source_for_copy (GFile           *source,
1780                       GFile           *destination,
1781                       GFileCopyFlags   flags,
1782                       GCancellable    *cancellable,
1783                       GError         **error)
1784 {
1785   GError *my_error;
1786   GInputStream *in;
1787   GFileInfo *info;
1788   GFileType file_type;
1789
1790   my_error = NULL;
1791   in = (GInputStream *)g_file_read (source, cancellable, &my_error);
1792   if (in != NULL)
1793     return in;
1794
1795   /* There was an error opening the source, try to set a good error for it: */
1796
1797   if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_IS_DIRECTORY)
1798     {
1799       /* The source is a directory, don't fail with WOULD_RECURSE immediately,
1800        * as that is less useful to the app. Better check for errors on the
1801        * target instead.
1802        */
1803       g_error_free (my_error);
1804       my_error = NULL;
1805
1806       info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
1807                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1808                                 cancellable, &my_error);
1809       if (info != NULL)
1810         {
1811           file_type = g_file_info_get_file_type (info);
1812           g_object_unref (info);
1813
1814           if (flags & G_FILE_COPY_OVERWRITE)
1815             {
1816               if (file_type == G_FILE_TYPE_DIRECTORY)
1817                 {
1818                   g_set_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_MERGE,
1819                                _("Can't copy directory over directory"));
1820                   return NULL;
1821                 }
1822               /* continue to would_recurse error */
1823             }
1824           else
1825             {
1826               g_set_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
1827                            _("Target file exists"));
1828               return NULL;
1829             }
1830         }
1831       else
1832         {
1833           /* Error getting info from target, return that error
1834            * (except for NOT_FOUND, which is no error here)
1835            */
1836           if (my_error->domain != G_IO_ERROR && my_error->code != G_IO_ERROR_NOT_FOUND)
1837             {
1838               g_propagate_error (error, my_error);
1839               return NULL;
1840             }
1841           g_error_free (my_error);
1842         }
1843
1844       g_set_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE,
1845                    _("Can't recursively copy directory"));
1846       return NULL;
1847     }
1848
1849   g_propagate_error (error, my_error);
1850   return NULL;
1851 }
1852
1853 static gboolean
1854 should_copy (GFileAttributeInfo *info,
1855              gboolean            as_move)
1856 {
1857   if (as_move)
1858     return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED;
1859   return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE;
1860 }
1861
1862 static char *
1863 build_attribute_list_for_copy (GFileAttributeInfoList *attributes,
1864                                GFileAttributeInfoList *namespaces,
1865                                gboolean                as_move)
1866 {
1867   GString *s;
1868   gboolean first;
1869   int i;
1870
1871   first = TRUE;
1872   s = g_string_new ("");
1873
1874   if (attributes)
1875     {
1876       for (i = 0; i < attributes->n_infos; i++)
1877         {
1878           if (should_copy (&attributes->infos[i], as_move))
1879             {
1880               if (first)
1881                 first = FALSE;
1882               else
1883                 g_string_append_c (s, ',');
1884
1885               g_string_append (s, attributes->infos[i].name);
1886             }
1887         }
1888     }
1889
1890   if (namespaces)
1891     {
1892       for (i = 0; i < namespaces->n_infos; i++)
1893         {
1894           if (should_copy (&namespaces->infos[i], as_move))
1895             {
1896               if (first)
1897                 first = FALSE;
1898               else
1899                 g_string_append_c (s, ',');
1900
1901               g_string_append (s, namespaces->infos[i].name);
1902               g_string_append (s, ":*");
1903             }
1904         }
1905     }
1906
1907   return g_string_free (s, FALSE);
1908 }
1909
1910 /**
1911  * g_file_copy_attributes:
1912  * @source: a #GFile with attributes.
1913  * @destination: a #GFile to copy attributes to.
1914  * @flags: a set of #GFileCopyFlags.
1915  * @cancellable: optional #GCancellable object, %NULL to ignore.
1916  * @error: a #GError, %NULL to ignore.
1917  *
1918  * Copies the file attributes from @source to @destination.
1919  *
1920  * Normally only a subset of the file attributes are copied,
1921  * those that are copies in a normal file copy operation
1922  * (which for instance does not include e.g. mtime). However
1923  * if #G_FILE_COPY_ALL_METADATA is specified in @flags, then
1924  * all the metadata that is possible to copy is copied.
1925  *
1926  * Returns: %TRUE if the attributes were copied successfully, %FALSE otherwise.
1927  **/
1928 gboolean
1929 g_file_copy_attributes (GFile           *source,
1930                         GFile           *destination,
1931                         GFileCopyFlags   flags,
1932                         GCancellable    *cancellable,
1933                         GError         **error)
1934 {
1935   GFileAttributeInfoList *attributes, *namespaces;
1936   char *attrs_to_read;
1937   gboolean res;
1938   GFileInfo *info;
1939   gboolean as_move;
1940   gboolean source_nofollow_symlinks;
1941
1942   as_move = flags & G_FILE_COPY_ALL_METADATA;
1943   source_nofollow_symlinks = flags & G_FILE_COPY_NOFOLLOW_SYMLINKS;
1944
1945   /* Ignore errors here, if the target supports no attributes there is nothing to copy */
1946   attributes = g_file_query_settable_attributes (destination, cancellable, NULL);
1947   namespaces = g_file_query_writable_namespaces (destination, cancellable, NULL);
1948
1949   if (attributes == NULL && namespaces == NULL)
1950     return TRUE;
1951
1952   attrs_to_read = build_attribute_list_for_copy (attributes, namespaces, as_move);
1953
1954   /* Ignore errors here, if we can't read some info (e.g. if it doesn't exist)
1955    * we just don't copy it.
1956    */
1957   info = g_file_query_info (source, attrs_to_read,
1958                             source_nofollow_symlinks ? G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS:0,
1959                             cancellable,
1960                             NULL);
1961
1962   g_free (attrs_to_read);
1963
1964   res = TRUE;
1965   if  (info)
1966     {
1967       res = g_file_set_attributes_from_info (destination,
1968                                              info, 0,
1969                                              cancellable,
1970                                              error);
1971       g_object_unref (info);
1972     }
1973
1974   g_file_attribute_info_list_unref (attributes);
1975   g_file_attribute_info_list_unref (namespaces);
1976
1977   return res;
1978 }
1979
1980 /* Closes the streams */
1981 static gboolean
1982 copy_stream_with_progress (GInputStream           *in,
1983                            GOutputStream          *out,
1984                            GCancellable           *cancellable,
1985                            GFileProgressCallback   progress_callback,
1986                            gpointer                progress_callback_data,
1987                            GError                **error)
1988 {
1989   gssize n_read, n_written;
1990   goffset current_size;
1991   char buffer[8192], *p;
1992   gboolean res;
1993   goffset total_size;
1994   GFileInfo *info;
1995
1996   total_size = 0;
1997   info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (in),
1998                                          G_FILE_ATTRIBUTE_STANDARD_SIZE,
1999                                          cancellable, NULL);
2000   if (info)
2001     {
2002       total_size = g_file_info_get_size (info);
2003       g_object_unref (info);
2004     }
2005
2006   current_size = 0;
2007   res = TRUE;
2008   while (TRUE)
2009     {
2010       n_read = g_input_stream_read (in, buffer, sizeof (buffer), cancellable, error);
2011       if (n_read == -1)
2012         {
2013           res = FALSE;
2014           break;
2015         }
2016
2017       if (n_read == 0)
2018         break;
2019
2020       current_size += n_read;
2021
2022       p = buffer;
2023       while (n_read > 0)
2024         {
2025           n_written = g_output_stream_write (out, p, n_read, cancellable, error);
2026           if (n_written == -1)
2027             {
2028               res = FALSE;
2029               break;
2030             }
2031
2032           p += n_written;
2033           n_read -= n_written;
2034         }
2035
2036       if (!res)
2037         break;
2038
2039       if (progress_callback)
2040         progress_callback (current_size, total_size, progress_callback_data);
2041     }
2042
2043   if (!res)
2044     error = NULL; /* Ignore further errors */
2045
2046   /* Make sure we send full copied size */
2047   if (progress_callback)
2048     progress_callback (current_size, total_size, progress_callback_data);
2049
2050
2051   /* Don't care about errors in source here */
2052   g_input_stream_close (in, cancellable, NULL);
2053
2054   /* But write errors on close are bad! */
2055   if (!g_output_stream_close (out, cancellable, error))
2056     res = FALSE;
2057
2058   g_object_unref (in);
2059   g_object_unref (out);
2060
2061   return res;
2062 }
2063
2064 static gboolean
2065 file_copy_fallback (GFile                  *source,
2066                     GFile                  *destination,
2067                     GFileCopyFlags          flags,
2068                     GCancellable           *cancellable,
2069                     GFileProgressCallback   progress_callback,
2070                     gpointer                progress_callback_data,
2071                     GError                **error)
2072 {
2073   GInputStream *in;
2074   GOutputStream *out;
2075   GFileInfo *info;
2076   const char *target;
2077
2078   /* Maybe copy the symlink? */
2079   if (flags & G_FILE_COPY_NOFOLLOW_SYMLINKS)
2080     {
2081       info = g_file_query_info (source,
2082                                 G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,
2083                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2084                                 cancellable,
2085                                 error);
2086       if (info == NULL)
2087         return FALSE;
2088
2089       if (g_file_info_get_file_type (info) == G_FILE_TYPE_SYMBOLIC_LINK &&
2090           (target = g_file_info_get_symlink_target (info)) != NULL)
2091         {
2092           if (!copy_symlink (destination, flags, cancellable, target, error))
2093             {
2094               g_object_unref (info);
2095               return FALSE;
2096             }
2097
2098           g_object_unref (info);
2099           goto copied_file;
2100         }
2101
2102       g_object_unref (info);
2103     }
2104
2105   in = open_source_for_copy (source, destination, flags, cancellable, error);
2106   if (in == NULL)
2107     return FALSE;
2108
2109   if (flags & G_FILE_COPY_OVERWRITE)
2110     {
2111       out = (GOutputStream *)g_file_replace (destination,
2112                                              NULL, 0,
2113                                              flags & G_FILE_COPY_BACKUP,
2114                                              cancellable, error);
2115     }
2116   else
2117     {
2118       out = (GOutputStream *)g_file_create (destination, 0, cancellable, error);
2119     }
2120
2121   if (out == NULL)
2122     {
2123       g_object_unref (in);
2124       return FALSE;
2125     }
2126
2127   if (!copy_stream_with_progress (in, out, cancellable,
2128                                   progress_callback, progress_callback_data,
2129                                   error))
2130     return FALSE;
2131
2132  copied_file:
2133
2134   /* Ignore errors here. Failure to copy metadata is not a hard error */
2135   g_file_copy_attributes (source, destination,
2136                           flags, cancellable, NULL);
2137
2138   return TRUE;
2139 }
2140
2141 /**
2142  * g_file_copy:
2143  * @source: input #GFile.
2144  * @destination: destination #GFile
2145  * @flags: set of #GFileCopyFlags
2146  * @cancellable: optional #GCancellable object, %NULL to ignore.
2147  * @progress_callback: function to callback with progress information
2148  * @progress_callback_data: user data to pass to @progress_callback
2149  * @error: #GError to set on error, or %NULL
2150  *
2151  * Copies the file @source to the location specified by @destination.
2152  * Can not handle recursive copies of directories.
2153  *
2154  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
2155  * existing @destination file is overwritten.
2156  *
2157  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
2158  * will be copied as symlinks, otherwise the target of the
2159  * @source symlink will be copied.
2160  *
2161  * If @cancellable is not %NULL, then the operation can be cancelled by
2162  * triggering the cancellable object from another thread. If the operation
2163  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2164  *
2165  * If @progress_callback is not %NULL, then the operation can be monitored by
2166  * setting this to a #GFileProgressCallback function. @progress_callback_data
2167  * will be passed to this function. It is guaranteed that this callback will
2168  * be called after all data has been transferred with the total number of bytes
2169  * copied during the operation.
2170  *
2171  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
2172  * error is returned, independent on the status of the @destination.
2173  *
2174  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
2175  * error G_IO_ERROR_EXISTS is returned.
2176  *
2177  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
2178  * error is returned. If trying to overwrite a directory with a directory the
2179  * G_IO_ERROR_WOULD_MERGE error is returned.
2180  *
2181  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
2182  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
2183  * is returned.
2184  *
2185  * If you are interested in copying the #GFile object itself (not the on-disk
2186  * file), see g_file_dup().
2187  *
2188  * Returns: %TRUE on success, %FALSE otherwise.
2189  **/
2190 gboolean
2191 g_file_copy (GFile                  *source,
2192              GFile                  *destination,
2193              GFileCopyFlags          flags,
2194              GCancellable           *cancellable,
2195              GFileProgressCallback   progress_callback,
2196              gpointer                progress_callback_data,
2197              GError                **error)
2198 {
2199   GFileIface *iface;
2200   GError *my_error;
2201   gboolean res;
2202
2203   g_return_val_if_fail (G_IS_FILE (source), FALSE);
2204   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
2205
2206   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2207     return FALSE;
2208
2209   iface = G_FILE_GET_IFACE (destination);
2210   if (iface->copy)
2211     {
2212       my_error = NULL;
2213       res = (* iface->copy) (source, destination,
2214                              flags, cancellable,
2215                              progress_callback, progress_callback_data,
2216                              &my_error);
2217
2218       if (res)
2219         return TRUE;
2220
2221       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2222         {
2223           g_propagate_error (error, my_error);
2224               return FALSE;
2225         }
2226     }
2227
2228   /* If the types are different, and the destination method failed
2229      also try the source method */
2230   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
2231     {
2232       iface = G_FILE_GET_IFACE (source);
2233
2234       if (iface->copy)
2235         {
2236           my_error = NULL;
2237           res = (* iface->copy) (source, destination,
2238                                  flags, cancellable,
2239                                  progress_callback, progress_callback_data,
2240                                  &my_error);
2241
2242           if (res)
2243             return TRUE;
2244
2245           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2246             {
2247               g_propagate_error (error, my_error);
2248               return FALSE;
2249             }
2250         }
2251     }
2252
2253   return file_copy_fallback (source, destination, flags, cancellable,
2254                              progress_callback, progress_callback_data,
2255                              error);
2256 }
2257
2258 /**
2259  * g_file_copy_async:
2260  * @source: input #GFile.
2261  * @destination: destination #GFile
2262  * @flags: set of #GFileCopyFlags
2263  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2264  *     of the request.
2265  * @cancellable: optional #GCancellable object, %NULL to ignore.
2266  * @progress_callback: function to callback with progress information
2267  * @progress_callback_data: user data to pass to @progress_callback
2268  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2269  * @user_data: the data to pass to callback function
2270  *
2271  * Copies the file @source to the location specified by @destination
2272  * asynchronously. For details of the behaviour, see g_file_copy().
2273  *
2274  * If @progress_callback is not %NULL, then that function that will be called
2275  * just like in g_file_copy(), however the callback will run in the main loop,
2276  * not in the thread that is doing the I/O operation.
2277  *
2278  * When the operation is finished, @callback will be called. You can then call
2279  * g_file_copy_finish() to get the result of the operation.
2280  **/
2281 void
2282 g_file_copy_async (GFile                  *source,
2283                    GFile                  *destination,
2284                    GFileCopyFlags          flags,
2285                    int                     io_priority,
2286                    GCancellable           *cancellable,
2287                    GFileProgressCallback   progress_callback,
2288                    gpointer                progress_callback_data,
2289                    GAsyncReadyCallback     callback,
2290                    gpointer                user_data)
2291 {
2292   GFileIface *iface;
2293
2294   g_return_if_fail (G_IS_FILE (source));
2295   g_return_if_fail (G_IS_FILE (destination));
2296
2297   iface = G_FILE_GET_IFACE (source);
2298   (* iface->copy_async) (source,
2299                          destination,
2300                          flags,
2301                          io_priority,
2302                          cancellable,
2303                          progress_callback,
2304                          progress_callback_data,
2305                          callback,
2306                          user_data);
2307 }
2308
2309 /**
2310  * g_file_copy_finish:
2311  * @file: input #GFile.
2312  * @res: a #GAsyncResult.
2313  * @error: a #GError, or %NULL
2314  *
2315  * Finishes copying the file started with
2316  * g_file_copy_async().
2317  *
2318  * Returns: a %TRUE on success, %FALSE on error.
2319  **/
2320 gboolean
2321 g_file_copy_finish (GFile        *file,
2322                     GAsyncResult *res,
2323                     GError      **error)
2324 {
2325   GFileIface *iface;
2326
2327   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2328   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
2329
2330   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2331     {
2332       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2333
2334       if (g_simple_async_result_propagate_error (simple, error))
2335         return FALSE;
2336     }
2337
2338   iface = G_FILE_GET_IFACE (file);
2339   return (* iface->copy_finish) (file, res, error);
2340 }
2341
2342 /**
2343  * g_file_move:
2344  * @source: #GFile pointing to the source location.
2345  * @destination: #GFile pointing to the destination location.
2346  * @flags: set of #GFileCopyFlags.
2347  * @cancellable: optional #GCancellable object, %NULL to ignore.
2348  * @progress_callback: #GFileProgressCallback function for updates.
2349  * @progress_callback_data: gpointer to user data for the callback function.
2350  * @error: #GError for returning error conditions, or %NULL
2351  *
2352  *
2353  * Tries to move the file or directory @source to the location specified by @destination.
2354  * If native move operations are supported then this is used, otherwise a copy + delete
2355  * fallback is used. The native implementation may support moving directories (for instance
2356  * on moves inside the same filesystem), but the fallback code does not.
2357  *
2358  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
2359  * existing @destination file is overwritten.
2360  *
2361  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
2362  * will be copied as symlinks, otherwise the target of the
2363  * @source symlink will be copied.
2364  *
2365  * If @cancellable is not %NULL, then the operation can be cancelled by
2366  * triggering the cancellable object from another thread. If the operation
2367  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2368  *
2369  * If @progress_callback is not %NULL, then the operation can be monitored by
2370  * setting this to a #GFileProgressCallback function. @progress_callback_data
2371  * will be passed to this function. It is guaranteed that this callback will
2372  * be called after all data has been transferred with the total number of bytes
2373  * copied during the operation.
2374  *
2375  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
2376  * error is returned, independent on the status of the @destination.
2377  *
2378  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
2379  * error G_IO_ERROR_EXISTS is returned.
2380  *
2381  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
2382  * error is returned. If trying to overwrite a directory with a directory the
2383  * G_IO_ERROR_WOULD_MERGE error is returned.
2384  *
2385  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
2386  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
2387  * may be returned (if the native move operation isn't available).
2388  *
2389  * Returns: %TRUE on successful move, %FALSE otherwise.
2390  **/
2391 gboolean
2392 g_file_move (GFile                  *source,
2393              GFile                  *destination,
2394              GFileCopyFlags          flags,
2395              GCancellable           *cancellable,
2396              GFileProgressCallback   progress_callback,
2397              gpointer                progress_callback_data,
2398              GError                **error)
2399 {
2400   GFileIface *iface;
2401   GError *my_error;
2402   gboolean res;
2403
2404   g_return_val_if_fail (G_IS_FILE (source), FALSE);
2405   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
2406
2407   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2408     return FALSE;
2409
2410   iface = G_FILE_GET_IFACE (destination);
2411   if (iface->move)
2412     {
2413       my_error = NULL;
2414       res = (* iface->move) (source, destination,
2415                              flags, cancellable,
2416                              progress_callback, progress_callback_data,
2417                              &my_error);
2418
2419       if (res)
2420         return TRUE;
2421
2422       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2423         {
2424           g_propagate_error (error, my_error);
2425           return FALSE;
2426         }
2427     }
2428
2429   /* If the types are different, and the destination method failed
2430      also try the source method */
2431   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
2432     {
2433       iface = G_FILE_GET_IFACE (source);
2434
2435       if (iface->move)
2436         {
2437           my_error = NULL;
2438           res = (* iface->move) (source, destination,
2439                                  flags, cancellable,
2440                                  progress_callback, progress_callback_data,
2441                                  &my_error);
2442
2443           if (res)
2444             return TRUE;
2445
2446           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
2447             {
2448               g_propagate_error (error, my_error);
2449               return FALSE;
2450             }
2451         }
2452     }
2453
2454   if (flags & G_FILE_COPY_NO_FALLBACK_FOR_MOVE)
2455     {
2456       g_set_error (error, G_IO_ERROR,
2457                    G_IO_ERROR_NOT_SUPPORTED,
2458                    _("Operation not supported"));
2459       return FALSE;
2460     }
2461
2462   flags |= G_FILE_COPY_ALL_METADATA;
2463   if (!g_file_copy (source, destination, flags, cancellable,
2464                     progress_callback, progress_callback_data,
2465                     error))
2466     return FALSE;
2467
2468   return g_file_delete (source, cancellable, error);
2469 }
2470
2471 /**
2472  * g_file_make_directory
2473  * @file: input #GFile.
2474  * @cancellable: optional #GCancellable object, %NULL to ignore.
2475  * @error: a #GError, or %NULL
2476  *
2477  * Creates a directory.
2478  *
2479  * If @cancellable is not %NULL, then the operation can be cancelled by
2480  * triggering the cancellable object from another thread. If the operation
2481  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2482  *
2483  * Returns: %TRUE on successful creation, %FALSE otherwise.
2484  **/
2485 gboolean
2486 g_file_make_directory (GFile         *file,
2487                        GCancellable  *cancellable,
2488                        GError       **error)
2489 {
2490   GFileIface *iface;
2491
2492   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2493
2494   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2495     return FALSE;
2496
2497   iface = G_FILE_GET_IFACE (file);
2498
2499   if (iface->make_directory == NULL)
2500     {
2501       g_set_error (error, G_IO_ERROR,
2502                    G_IO_ERROR_NOT_SUPPORTED,
2503                    _("Operation not supported"));
2504       return FALSE;
2505     }
2506
2507   return (* iface->make_directory) (file, cancellable, error);
2508 }
2509
2510 /**
2511  * g_file_make_symbolic_link:
2512  * @file: input #GFile.
2513  * @symlink_value: a string with the value of the new symlink.
2514  * @cancellable: optional #GCancellable object, %NULL to ignore.
2515  * @error: a #GError.
2516  *
2517  * Creates a symbolic link.
2518  *
2519  * If @cancellable is not %NULL, then the operation can be cancelled by
2520  * triggering the cancellable object from another thread. If the operation
2521  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2522  *
2523  * Returns: %TRUE on the creation of a new symlink, %FALSE otherwise.
2524  **/
2525 gboolean
2526 g_file_make_symbolic_link (GFile         *file,
2527                            const char    *symlink_value,
2528                            GCancellable  *cancellable,
2529                            GError       **error)
2530 {
2531   GFileIface *iface;
2532
2533   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2534   g_return_val_if_fail (symlink_value != NULL, FALSE);
2535
2536   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2537     return FALSE;
2538
2539   if (*symlink_value == '\0')
2540     {
2541       g_set_error (error, G_IO_ERROR,
2542                    G_IO_ERROR_INVALID_ARGUMENT,
2543                    _("Invalid symlink value given"));
2544       return FALSE;
2545     }
2546
2547   iface = G_FILE_GET_IFACE (file);
2548
2549   if (iface->make_symbolic_link == NULL)
2550     {
2551       g_set_error (error, G_IO_ERROR,
2552                    G_IO_ERROR_NOT_SUPPORTED,
2553                    _("Operation not supported"));
2554       return FALSE;
2555     }
2556
2557   return (* iface->make_symbolic_link) (file, symlink_value, cancellable, error);
2558 }
2559
2560 /**
2561  * g_file_delete:
2562  * @file: input #GFile.
2563  * @cancellable: optional #GCancellable object, %NULL to ignore.
2564  * @error: a #GError, or %NULL
2565  *
2566  * Deletes a file.
2567  *
2568  * If @cancellable is not %NULL, then the operation can be cancelled by
2569  * triggering the cancellable object from another thread. If the operation
2570  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2571  *
2572  * Returns: %TRUE if the file was deleted. %FALSE otherwise.
2573  **/
2574 gboolean
2575 g_file_delete (GFile         *file,
2576                GCancellable  *cancellable,
2577                GError       **error)
2578 {
2579   GFileIface *iface;
2580
2581   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2582
2583   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2584     return FALSE;
2585
2586   iface = G_FILE_GET_IFACE (file);
2587
2588   if (iface->delete_file == NULL)
2589     {
2590       g_set_error (error, G_IO_ERROR,
2591                    G_IO_ERROR_NOT_SUPPORTED,
2592                    _("Operation not supported"));
2593       return FALSE;
2594     }
2595
2596   return (* iface->delete_file) (file, cancellable, error);
2597 }
2598
2599 /**
2600  * g_file_trash:
2601  * @file: #GFile to send to trash.
2602  * @cancellable: optional #GCancellable object, %NULL to ignore.
2603  * @error: a #GError, or %NULL
2604  *
2605  * Sends @file to the "Trashcan", if possible. This is similar to
2606  * deleting it, but the user can recover it before emptying the trashcan.
2607  * Not all file systems support trashing, so this call can return the
2608  * %G_IO_ERROR_NOT_SUPPORTED error.
2609  *
2610  *
2611  * If @cancellable is not %NULL, then the operation can be cancelled by
2612  * triggering the cancellable object from another thread. If the operation
2613  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2614  *
2615  * Returns: %TRUE on successful trash, %FALSE otherwise.
2616  **/
2617 gboolean
2618 g_file_trash (GFile         *file,
2619               GCancellable  *cancellable,
2620               GError       **error)
2621 {
2622   GFileIface *iface;
2623
2624   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2625
2626   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2627     return FALSE;
2628
2629   iface = G_FILE_GET_IFACE (file);
2630
2631   if (iface->trash == NULL)
2632     {
2633       g_set_error (error,
2634                    G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
2635                    _("Trash not supported"));
2636       return FALSE;
2637     }
2638
2639   return (* iface->trash) (file, cancellable, error);
2640 }
2641
2642 /**
2643  * g_file_set_display_name:
2644  * @file: input #GFile.
2645  * @display_name: a string.
2646  * @cancellable: optional #GCancellable object, %NULL to ignore.
2647  * @error: a #GError, or %NULL
2648  *
2649  * Renames @file to the specified display name.
2650  *
2651  * The display name is converted from UTF8 to the correct encoding for the target
2652  * filesystem if possible and the @file is renamed to this.
2653  *
2654  * If you want to implement a rename operation in the user interface the edit name
2655  * (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename
2656  * widget, and then the result after editing should be passed to g_file_set_display_name().
2657  *
2658  * On success the resulting converted filename is returned.
2659  *
2660  * If @cancellable is not %NULL, then the operation can be cancelled by
2661  * triggering the cancellable object from another thread. If the operation
2662  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2663  *
2664  * Returns: a #GFile specifying what @file was renamed to, or %NULL if there was an error.
2665  **/
2666 GFile *
2667 g_file_set_display_name (GFile         *file,
2668                          const char    *display_name,
2669                          GCancellable  *cancellable,
2670                          GError       **error)
2671 {
2672   GFileIface *iface;
2673
2674   g_return_val_if_fail (G_IS_FILE (file), NULL);
2675   g_return_val_if_fail (display_name != NULL, NULL);
2676
2677   if (strchr (display_name, G_DIR_SEPARATOR) != NULL)
2678     {
2679       g_set_error (error,
2680                    G_IO_ERROR,
2681                    G_IO_ERROR_INVALID_ARGUMENT,
2682                    _("File names cannot contain '%c'"), G_DIR_SEPARATOR);
2683       return NULL;
2684     }
2685
2686   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2687     return NULL;
2688
2689   iface = G_FILE_GET_IFACE (file);
2690
2691   return (* iface->set_display_name) (file, display_name, cancellable, error);
2692 }
2693
2694 /**
2695  * g_file_set_display_name_async:
2696  * @file: input #GFile.
2697  * @display_name: a string.
2698  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2699  *     of the request.
2700  * @cancellable: optional #GCancellable object, %NULL to ignore.
2701  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2702  * @user_data: the data to pass to callback function
2703  *
2704  * Asynchronously sets the display name for a given #GFile.
2705  *
2706  * For more details, see g_set_display_name() which is
2707  * the synchronous version of this call.
2708  *
2709  * When the operation is finished, @callback will be called. You can then call
2710  * g_file_set_display_name_finish() to get the result of the operation.
2711  **/
2712 void
2713 g_file_set_display_name_async (GFile               *file,
2714                                const char          *display_name,
2715                                int                  io_priority,
2716                                GCancellable        *cancellable,
2717                                GAsyncReadyCallback  callback,
2718                                gpointer             user_data)
2719 {
2720   GFileIface *iface;
2721
2722   g_return_if_fail (G_IS_FILE (file));
2723   g_return_if_fail (display_name != NULL);
2724
2725   iface = G_FILE_GET_IFACE (file);
2726   (* iface->set_display_name_async) (file,
2727                                      display_name,
2728                                      io_priority,
2729                                      cancellable,
2730                                      callback,
2731                                      user_data);
2732 }
2733
2734 /**
2735  * g_file_set_display_name_finish:
2736  * @file: input #GFile.
2737  * @res: a #GAsyncResult.
2738  * @error: a #GError, or %NULL
2739  *
2740  * Finishes setting a display name started with
2741  * g_file_set_display_name_async().
2742  *
2743  * Returns: a #GFile or %NULL on error.
2744  **/
2745 GFile *
2746 g_file_set_display_name_finish (GFile         *file,
2747                                 GAsyncResult  *res,
2748                                 GError       **error)
2749 {
2750   GFileIface *iface;
2751
2752   g_return_val_if_fail (G_IS_FILE (file), NULL);
2753   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2754
2755   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2756     {
2757       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2758       if (g_simple_async_result_propagate_error (simple, error))
2759         return NULL;
2760     }
2761
2762   iface = G_FILE_GET_IFACE (file);
2763   return (* iface->set_display_name_finish) (file, res, error);
2764 }
2765
2766 /**
2767  * g_file_query_settable_attributes:
2768  * @file: input #GFile.
2769  * @cancellable: optional #GCancellable object, %NULL to ignore.
2770  * @error: a #GError, or %NULL
2771  *
2772  * Obtain the list of settable attributes for the file.
2773  *
2774  * Returns the type and full attribute name of all the attributes
2775  * that can be set on this file. This doesn't mean setting it will always
2776  * succeed though, you might get an access failure, or some specific
2777  * file may not support a specific attribute.
2778  *
2779  * If @cancellable is not %NULL, then the operation can be cancelled by
2780  * triggering the cancellable object from another thread. If the operation
2781  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2782  *
2783  * Returns: a #GFileAttributeInfoList describing the settable attributes.
2784  * When you are done with it, release it with g_file_attribute_info_list_unref()
2785  **/
2786 GFileAttributeInfoList *
2787 g_file_query_settable_attributes (GFile         *file,
2788                                   GCancellable  *cancellable,
2789                                   GError       **error)
2790 {
2791   GFileIface *iface;
2792   GError *my_error;
2793   GFileAttributeInfoList *list;
2794
2795   g_return_val_if_fail (G_IS_FILE (file), NULL);
2796
2797   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2798     return NULL;
2799
2800   iface = G_FILE_GET_IFACE (file);
2801
2802   if (iface->query_settable_attributes == NULL)
2803     return g_file_attribute_info_list_new ();
2804
2805   my_error = NULL;
2806   list = (* iface->query_settable_attributes) (file, cancellable, &my_error);
2807
2808   if (list == NULL)
2809     {
2810       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
2811         {
2812           list = g_file_attribute_info_list_new ();
2813           g_error_free (my_error);
2814         }
2815       else
2816         g_propagate_error (error, my_error);
2817     }
2818
2819   return list;
2820 }
2821
2822 /**
2823  * g_file_query_writable_namespaces:
2824  * @file: input #GFile.
2825  * @cancellable: optional #GCancellable object, %NULL to ignore.
2826  * @error: a #GError, or %NULL
2827  *
2828  * Obtain the list of attribute namespaces where new attributes
2829  * can be created by a user. An example of this is extended
2830  * attributes (in the "xattr" namespace).
2831  *
2832  * If @cancellable is not %NULL, then the operation can be cancelled by
2833  * triggering the cancellable object from another thread. If the operation
2834  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2835  *
2836  * Returns: a #GFileAttributeInfoList describing the writable namespaces.
2837  * When you are done with it, release it with g_file_attribute_info_list_unref()
2838  **/
2839 GFileAttributeInfoList *
2840 g_file_query_writable_namespaces (GFile         *file,
2841                                   GCancellable  *cancellable,
2842                                   GError       **error)
2843 {
2844   GFileIface *iface;
2845   GError *my_error;
2846   GFileAttributeInfoList *list;
2847
2848   g_return_val_if_fail (G_IS_FILE (file), NULL);
2849
2850   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2851     return NULL;
2852
2853   iface = G_FILE_GET_IFACE (file);
2854
2855   if (iface->query_writable_namespaces == NULL)
2856     return g_file_attribute_info_list_new ();
2857
2858   my_error = NULL;
2859   list = (* iface->query_writable_namespaces) (file, cancellable, &my_error);
2860
2861   if (list == NULL)
2862     {
2863       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
2864         {
2865           list = g_file_attribute_info_list_new ();
2866           g_error_free (my_error);
2867         }
2868       else
2869         g_propagate_error (error, my_error);
2870     }
2871
2872   return list;
2873 }
2874
2875 /**
2876  * g_file_set_attribute:
2877  * @file: input #GFile.
2878  * @attribute: a string containing the attribute's name.
2879  * @type: The type of the attribute
2880  * @value_p: a pointer to the value (or the pointer itself if the type is a pointer type)
2881  * @flags: a set of #GFileQueryInfoFlags.
2882  * @cancellable: optional #GCancellable object, %NULL to ignore.
2883  * @error: a #GError, or %NULL
2884  *
2885  * Sets an attribute in the file with attribute name @attribute to @value.
2886  *
2887  * If @cancellable is not %NULL, then the operation can be cancelled by
2888  * triggering the cancellable object from another thread. If the operation
2889  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2890  *
2891  * Returns: %TRUE if the attribute was set, %FALSE otherwise.
2892  **/
2893 gboolean
2894 g_file_set_attribute (GFile                      *file,
2895                       const char                 *attribute,
2896                       GFileAttributeType          type,
2897                       gpointer                    value_p,
2898                       GFileQueryInfoFlags         flags,
2899                       GCancellable               *cancellable,
2900                       GError                    **error)
2901 {
2902   GFileIface *iface;
2903
2904   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2905   g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
2906
2907   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2908     return FALSE;
2909
2910   iface = G_FILE_GET_IFACE (file);
2911
2912   if (iface->set_attribute == NULL)
2913     {
2914       g_set_error (error, G_IO_ERROR,
2915                    G_IO_ERROR_NOT_SUPPORTED,
2916                    _("Operation not supported"));
2917       return FALSE;
2918     }
2919
2920   return (* iface->set_attribute) (file, attribute, type, value_p, flags, cancellable, error);
2921 }
2922
2923 /**
2924  * g_file_set_attributes_from_info:
2925  * @file: input #GFile.
2926  * @info: a #GFileInfo.
2927  * @flags: #GFileQueryInfoFlags
2928  * @cancellable: optional #GCancellable object, %NULL to ignore.
2929  * @error: a #GError, or %NULL
2930  *
2931  * Tries to set all attributes in the #GFileInfo on the target values,
2932  * not stopping on the first error.
2933  *
2934  * If there is any error during this operation then @error will be set to
2935  * the first error. Error on particular fields are flagged by setting
2936  * the "status" field in the attribute value to
2937  * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
2938  * further errors.
2939  *
2940  * If @cancellable is not %NULL, then the operation can be cancelled by
2941  * triggering the cancellable object from another thread. If the operation
2942  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
2943  *
2944  * Returns: %TRUE if there was any error, %FALSE otherwise.
2945  **/
2946 gboolean
2947 g_file_set_attributes_from_info (GFile                *file,
2948                                  GFileInfo            *info,
2949                                  GFileQueryInfoFlags   flags,
2950                                  GCancellable         *cancellable,
2951                                  GError              **error)
2952 {
2953   GFileIface *iface;
2954
2955   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2956   g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
2957
2958   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2959     return FALSE;
2960
2961   g_file_info_clear_status (info);
2962
2963   iface = G_FILE_GET_IFACE (file);
2964
2965   return (* iface->set_attributes_from_info) (file,
2966                                               info,
2967                                               flags,
2968                                               cancellable,
2969                                               error);
2970 }
2971
2972
2973 static gboolean
2974 g_file_real_set_attributes_from_info (GFile                *file,
2975                                       GFileInfo            *info,
2976                                       GFileQueryInfoFlags   flags,
2977                                       GCancellable         *cancellable,
2978                                       GError              **error)
2979 {
2980   char **attributes;
2981   int i;
2982   gboolean res;
2983   GFileAttributeValue *value;
2984
2985   res = TRUE;
2986
2987   attributes = g_file_info_list_attributes (info, NULL);
2988
2989   for (i = 0; attributes[i] != NULL; i++)
2990     {
2991       value = _g_file_info_get_attribute_value (info, attributes[i]);
2992
2993       if (value->status != G_FILE_ATTRIBUTE_STATUS_UNSET)
2994         continue;
2995
2996       if (!g_file_set_attribute (file, attributes[i],
2997                                  value->type, _g_file_attribute_value_peek_as_pointer (value),
2998                                  flags, cancellable, error))
2999         {
3000           value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
3001           res = FALSE;
3002           /* Don't set error multiple times */
3003           error = NULL;
3004         }
3005       else
3006         value->status = G_FILE_ATTRIBUTE_STATUS_SET;
3007     }
3008
3009   g_strfreev (attributes);
3010
3011   return res;
3012 }
3013
3014 /**
3015  * g_file_set_attributes_async:
3016  * @file: input #GFile.
3017  * @info: a #GFileInfo.
3018  * @flags: a #GFileQueryInfoFlags.
3019  * @io_priority: the <link linkend="io-priority">I/O priority</link>
3020  *     of the request.
3021  * @cancellable: optional #GCancellable object, %NULL to ignore.
3022  * @callback: a #GAsyncReadyCallback.
3023  * @user_data: a #gpointer.
3024  *
3025  * Asynchronously sets the attributes of @file with @info.
3026  *
3027  * For more details, see g_file_set_attributes_from_info() which is
3028  * the synchronous version of this call.
3029  *
3030  * When the operation is finished, @callback will be called. You can then call
3031  * g_file_set_attributes_finish() to get the result of the operation.
3032  **/
3033 void
3034 g_file_set_attributes_async (GFile               *file,
3035                              GFileInfo           *info,
3036                              GFileQueryInfoFlags  flags,
3037                              int                  io_priority,
3038                              GCancellable        *cancellable,
3039                              GAsyncReadyCallback  callback,
3040                              gpointer             user_data)
3041 {
3042   GFileIface *iface;
3043
3044   g_return_if_fail (G_IS_FILE (file));
3045   g_return_if_fail (G_IS_FILE_INFO (info));
3046
3047   iface = G_FILE_GET_IFACE (file);
3048   (* iface->set_attributes_async) (file,
3049                                    info,
3050                                    flags,
3051                                    io_priority,
3052                                    cancellable,
3053                                    callback,
3054                                    user_data);
3055 }
3056
3057 /**
3058  * g_file_set_attributes_finish:
3059  * @file: input #GFile.
3060  * @result: a #GAsyncResult.
3061  * @info: a #GFileInfo.
3062  * @error: a #GError, or %NULL
3063  *
3064  * Finishes setting an attribute started in g_file_set_attributes_async().
3065  *
3066  * Returns: %TRUE if the attributes were set correctly, %FALSE otherwise.
3067  **/
3068 gboolean
3069 g_file_set_attributes_finish (GFile         *file,
3070                               GAsyncResult  *result,
3071                               GFileInfo    **info,
3072                               GError       **error)
3073 {
3074   GFileIface *iface;
3075
3076   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3077   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3078
3079   /* No standard handling of errors here, as we must set info even
3080    * on errors
3081    */
3082   iface = G_FILE_GET_IFACE (file);
3083   return (* iface->set_attributes_finish) (file, result, info, error);
3084 }
3085
3086 /**
3087  * g_file_set_attribute_string:
3088  * @file: input #GFile.
3089  * @attribute: a string containing the attribute's name.
3090  * @value: a string containing the attribute's value.
3091  * @flags: #GFileQueryInfoFlags.
3092  * @cancellable: optional #GCancellable object, %NULL to ignore.
3093  * @error: a #GError, or %NULL
3094  *
3095  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value.
3096  * If @attribute is of a different type, this operation will fail.
3097  *
3098  * If @cancellable is not %NULL, then the operation can be cancelled by
3099  * triggering the cancellable object from another thread. If the operation
3100  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3101  *
3102  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
3103  **/
3104 gboolean
3105 g_file_set_attribute_string (GFile                *file,
3106                              const char           *attribute,
3107                              const char           *value,
3108                              GFileQueryInfoFlags   flags,
3109                              GCancellable         *cancellable,
3110                              GError              **error)
3111 {
3112   return g_file_set_attribute (file, attribute,
3113                                G_FILE_ATTRIBUTE_TYPE_STRING, (gpointer)value,
3114                                flags, cancellable, error);
3115 }
3116
3117 /**
3118  * g_file_set_attribute_byte_string:
3119  * @file: input #GFile.
3120  * @attribute: a string containing the attribute's name.
3121  * @value: a string containing the attribute's new value.
3122  * @flags: a #GFileQueryInfoFlags.
3123  * @cancellable: optional #GCancellable object, %NULL to ignore.
3124  * @error: a #GError, or %NULL
3125  *
3126  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value.
3127  * If @attribute is of a different type, this operation will fail,
3128  * returning %FALSE.
3129  *
3130  * If @cancellable is not %NULL, then the operation can be cancelled by
3131  * triggering the cancellable object from another thread. If the operation
3132  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3133  *
3134  * Returns: %TRUE if the @attribute was successfully set to @value
3135  * in the @file, %FALSE otherwise.
3136  **/
3137 gboolean
3138 g_file_set_attribute_byte_string  (GFile                *file,
3139                                    const char           *attribute,
3140                                    const char           *value,
3141                                    GFileQueryInfoFlags   flags,
3142                                    GCancellable         *cancellable,
3143                                    GError              **error)
3144 {
3145   return g_file_set_attribute (file, attribute,
3146                                G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, (gpointer)value,
3147                                flags, cancellable, error);
3148 }
3149
3150 /**
3151  * g_file_set_attribute_uint32:
3152  * @file: input #GFile.
3153  * @attribute: a string containing the attribute's name.
3154  * @value: a #guint32 containing the attribute's new value.
3155  * @flags: a #GFileQueryInfoFlags.
3156  * @cancellable: optional #GCancellable object, %NULL to ignore.
3157  * @error: a #GError, or %NULL
3158  *
3159  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value.
3160  * If @attribute is of a different type, this operation will fail.
3161  *
3162  * If @cancellable is not %NULL, then the operation can be cancelled by
3163  * triggering the cancellable object from another thread. If the operation
3164  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3165  *
3166  * Returns: %TRUE if the @attribute was successfully set to @value
3167  * in the @file, %FALSE otherwise.
3168  **/
3169 gboolean
3170 g_file_set_attribute_uint32 (GFile                *file,
3171                              const char           *attribute,
3172                              guint32               value,
3173                              GFileQueryInfoFlags   flags,
3174                              GCancellable         *cancellable,
3175                              GError              **error)
3176 {
3177   return g_file_set_attribute (file, attribute,
3178                                G_FILE_ATTRIBUTE_TYPE_UINT32, &value,
3179                                flags, cancellable, error);
3180 }
3181
3182 /**
3183  * g_file_set_attribute_int32:
3184  * @file: input #GFile.
3185  * @attribute: a string containing the attribute's name.
3186  * @value: a #gint32 containing the attribute's new value.
3187  * @flags: a #GFileQueryInfoFlags.
3188  * @cancellable: optional #GCancellable object, %NULL to ignore.
3189  * @error: a #GError, or %NULL
3190  *
3191  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value.
3192  * If @attribute is of a different type, this operation will fail.
3193  *
3194  * If @cancellable is not %NULL, then the operation can be cancelled by
3195  * triggering the cancellable object from another thread. If the operation
3196  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3197  *
3198  * Returns: %TRUE if the @attribute was successfully set to @value
3199  * in the @file, %FALSE otherwise.
3200  **/
3201 gboolean
3202 g_file_set_attribute_int32 (GFile                *file,
3203                             const char           *attribute,
3204                             gint32                value,
3205                             GFileQueryInfoFlags   flags,
3206                             GCancellable         *cancellable,
3207                             GError              **error)
3208 {
3209   return g_file_set_attribute (file, attribute,
3210                                G_FILE_ATTRIBUTE_TYPE_INT32, &value,
3211                                flags, cancellable, error);
3212 }
3213
3214 /**
3215  * g_file_set_attribute_uint64:
3216  * @file: input #GFile.
3217  * @attribute: a string containing the attribute's name.
3218  * @value: a #guint64 containing the attribute's new value.
3219  * @flags: a #GFileQueryInfoFlags.
3220  * @cancellable: optional #GCancellable object, %NULL to ignore.
3221  * @error: a #GError, or %NULL
3222  *
3223  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value.
3224  * If @attribute is of a different type, this operation will fail.
3225  *
3226  * If @cancellable is not %NULL, then the operation can be cancelled by
3227  * triggering the cancellable object from another thread. If the operation
3228  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3229  *
3230  * Returns: %TRUE if the @attribute was successfully set to @value
3231  * in the @file, %FALSE otherwise.
3232  **/
3233 gboolean
3234 g_file_set_attribute_uint64 (GFile                *file,
3235                              const char           *attribute,
3236                              guint64               value,
3237                              GFileQueryInfoFlags   flags,
3238                              GCancellable         *cancellable,
3239                              GError              **error)
3240  {
3241   return g_file_set_attribute (file, attribute,
3242                                G_FILE_ATTRIBUTE_TYPE_UINT64, &value,
3243                                flags, cancellable, error);
3244 }
3245
3246 /**
3247  * g_file_set_attribute_int64:
3248  * @file: input #GFile.
3249  * @attribute: a string containing the attribute's name.
3250  * @value: a #guint64 containing the attribute's new value.
3251  * @flags: a #GFileQueryInfoFlags.
3252  * @cancellable: optional #GCancellable object, %NULL to ignore.
3253  * @error: a #GError, or %NULL
3254  *
3255  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value.
3256  * If @attribute is of a different type, this operation will fail.
3257  *
3258  * If @cancellable is not %NULL, then the operation can be cancelled by
3259  * triggering the cancellable object from another thread. If the operation
3260  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3261  *
3262  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
3263  **/
3264 gboolean
3265 g_file_set_attribute_int64 (GFile                *file,
3266                             const char           *attribute,
3267                             gint64                value,
3268                             GFileQueryInfoFlags   flags,
3269                             GCancellable         *cancellable,
3270                             GError              **error)
3271 {
3272   return g_file_set_attribute (file, attribute,
3273                                G_FILE_ATTRIBUTE_TYPE_INT64, &value,
3274                                flags, cancellable, error);
3275 }
3276
3277 /**
3278  * g_file_mount_mountable:
3279  * @file: input #GFile.
3280  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
3281  * @cancellable: optional #GCancellable object, %NULL to ignore.
3282  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3283  * @user_data: the data to pass to callback function
3284  *
3285  * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
3286  * Using @mount_operation, you can request callbacks when, for instance,
3287  * passwords are needed during authentication.
3288  *
3289  * If @cancellable is not %NULL, then the operation can be cancelled by
3290  * triggering the cancellable object from another thread. If the operation
3291  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3292  *
3293  * When the operation is finished, @callback will be called. You can then call
3294  * g_file_mount_mountable_finish() to get the result of the operation.
3295  **/
3296 void
3297 g_file_mount_mountable (GFile               *file,
3298                         GMountOperation     *mount_operation,
3299                         GCancellable        *cancellable,
3300                         GAsyncReadyCallback  callback,
3301                         gpointer             user_data)
3302 {
3303   GFileIface *iface;
3304
3305   g_return_if_fail (G_IS_FILE (file));
3306
3307   iface = G_FILE_GET_IFACE (file);
3308
3309   if (iface->mount_mountable == NULL)
3310     g_simple_async_report_error_in_idle (G_OBJECT (file),
3311                                          callback,
3312                                          user_data,
3313                                          G_IO_ERROR,
3314                                          G_IO_ERROR_NOT_SUPPORTED,
3315                                          _("Operation not supported"));
3316
3317   (* iface->mount_mountable) (file,
3318                               mount_operation,
3319                               cancellable,
3320                               callback,
3321                               user_data);
3322 }
3323
3324 /**
3325  * g_file_mount_mountable_finish:
3326  * @file: input #GFile.
3327  * @result: a #GAsyncResult.
3328  * @error: a #GError, or %NULL
3329  *
3330  * Finishes a mount operation. See g_file_mount_mountable() for details.
3331  *
3332  * Finish an asynchronous mount operation that was started
3333  * with g_file_mount_mountable().
3334  *
3335  * Returns: a #GFile or %NULL on error.
3336  **/
3337 GFile *
3338 g_file_mount_mountable_finish (GFile         *file,
3339                                GAsyncResult  *result,
3340                                GError       **error)
3341 {
3342   GFileIface *iface;
3343
3344   g_return_val_if_fail (G_IS_FILE (file), NULL);
3345   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
3346
3347   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3348     {
3349       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3350       if (g_simple_async_result_propagate_error (simple, error))
3351         return NULL;
3352     }
3353
3354   iface = G_FILE_GET_IFACE (file);
3355   return (* iface->mount_mountable_finish) (file, result, error);
3356 }
3357
3358 /**
3359  * g_file_unmount_mountable:
3360  * @file: input #GFile.
3361  * @flags: flags affecting the operation
3362  * @cancellable: optional #GCancellable object, %NULL to ignore.
3363  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3364  * @user_data: the data to pass to callback function
3365  *
3366  * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
3367  *
3368  * If @cancellable is not %NULL, then the operation can be cancelled by
3369  * triggering the cancellable object from another thread. If the operation
3370  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3371  *
3372  * When the operation is finished, @callback will be called. You can then call
3373  * g_file_unmount_mountable_finish() to get the result of the operation.
3374  **/
3375 void
3376 g_file_unmount_mountable (GFile               *file,
3377                           GMountUnmountFlags   flags,
3378                           GCancellable        *cancellable,
3379                           GAsyncReadyCallback  callback,
3380                           gpointer             user_data)
3381 {
3382   GFileIface *iface;
3383
3384   g_return_if_fail (G_IS_FILE (file));
3385
3386   iface = G_FILE_GET_IFACE (file);
3387
3388   if (iface->unmount_mountable == NULL)
3389     g_simple_async_report_error_in_idle (G_OBJECT (file),
3390                                          callback,
3391                                          user_data,
3392                                          G_IO_ERROR,
3393                                          G_IO_ERROR_NOT_SUPPORTED,
3394                                          _("Operation not supported"));
3395
3396   (* iface->unmount_mountable) (file,
3397                                 flags,
3398                                 cancellable,
3399                                 callback,
3400                                 user_data);
3401 }
3402
3403 /**
3404  * g_file_unmount_mountable_finish:
3405  * @file: input #GFile.
3406  * @result: a #GAsyncResult.
3407  * @error: a #GError, or %NULL
3408  *
3409  * Finishes an unmount operation, see g_file_unmount_mountable() for details.
3410  *
3411  * Finish an asynchronous unmount operation that was started
3412  * with g_file_unmount_mountable().
3413  *
3414  * Returns: %TRUE if the operation finished successfully. %FALSE
3415  * otherwise.
3416  **/
3417 gboolean
3418 g_file_unmount_mountable_finish (GFile         *file,
3419                                  GAsyncResult  *result,
3420                                  GError       **error)
3421 {
3422   GFileIface *iface;
3423
3424   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3425   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3426
3427   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3428     {
3429       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3430       if (g_simple_async_result_propagate_error (simple, error))
3431         return FALSE;
3432     }
3433
3434   iface = G_FILE_GET_IFACE (file);
3435   return (* iface->unmount_mountable_finish) (file, result, error);
3436 }
3437
3438 /**
3439  * g_file_eject_mountable:
3440  * @file: input #GFile.
3441  * @flags: flags affecting the operation
3442  * @cancellable: optional #GCancellable object, %NULL to ignore.
3443  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
3444  * @user_data: the data to pass to callback function
3445  *
3446  * Starts an asynchronous eject on a mountable.
3447  * When this operation has completed, @callback will be called with
3448  * @user_user data, and the operation can be finalized with
3449  * g_file_eject_mountable_finish().
3450  *
3451  * If @cancellable is not %NULL, then the operation can be cancelled by
3452  * triggering the cancellable object from another thread. If the operation
3453  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3454  **/
3455 void
3456 g_file_eject_mountable (GFile               *file,
3457                         GMountUnmountFlags   flags,
3458                         GCancellable        *cancellable,
3459                         GAsyncReadyCallback  callback,
3460                         gpointer             user_data)
3461 {
3462   GFileIface *iface;
3463
3464   g_return_if_fail (G_IS_FILE (file));
3465
3466   iface = G_FILE_GET_IFACE (file);
3467
3468   if (iface->eject_mountable == NULL)
3469     g_simple_async_report_error_in_idle (G_OBJECT (file),
3470                                          callback,
3471                                          user_data,
3472                                          G_IO_ERROR,
3473                                          G_IO_ERROR_NOT_SUPPORTED,
3474                                          _("Operation not supported"));
3475
3476   (* iface->eject_mountable) (file,
3477                               flags,
3478                               cancellable,
3479                               callback,
3480                               user_data);
3481 }
3482
3483 /**
3484  * g_file_eject_mountable_finish:
3485  * @file: input #GFile.
3486  * @result: a #GAsyncResult.
3487  * @error: a #GError, or %NULL
3488  *
3489  * Finishes an asynchronous eject operation started by
3490  * g_file_eject_mountable().
3491  *
3492  * Returns: %TRUE if the @file was ejected successfully. %FALSE
3493  * otherwise.
3494  **/
3495 gboolean
3496 g_file_eject_mountable_finish (GFile         *file,
3497                                GAsyncResult  *result,
3498                                GError       **error)
3499 {
3500   GFileIface *iface;
3501
3502   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3503   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
3504
3505   if (G_IS_SIMPLE_ASYNC_RESULT (result))
3506     {
3507       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
3508       if (g_simple_async_result_propagate_error (simple, error))
3509         return FALSE;
3510     }
3511
3512   iface = G_FILE_GET_IFACE (file);
3513   return (* iface->eject_mountable_finish) (file, result, error);
3514 }
3515
3516 /**
3517  * g_file_monitor_directory:
3518  * @file: input #GFile.
3519  * @flags: a set of #GFileMonitorFlags.
3520  * @cancellable: optional #GCancellable object, %NULL to ignore.
3521  * @error: a #GError, or %NULL.
3522  *
3523  * Obtains a directory monitor for the given file.
3524  * This may fail if directory monitoring is not supported.
3525  *
3526  * If @cancellable is not %NULL, then the operation can be cancelled by
3527  * triggering the cancellable object from another thread. If the operation
3528  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3529  *
3530  * Returns: a #GFileMonitor for the given @file,
3531  * or %NULL on error.
3532  **/
3533 GFileMonitor*
3534 g_file_monitor_directory (GFile             *file,
3535                           GFileMonitorFlags  flags,
3536                           GCancellable      *cancellable,
3537                           GError           **error)
3538 {
3539   GFileIface *iface;
3540
3541   g_return_val_if_fail (G_IS_FILE (file), NULL);
3542
3543   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3544     return NULL;
3545
3546   iface = G_FILE_GET_IFACE (file);
3547
3548   if (iface->monitor_dir == NULL)
3549     {
3550       g_set_error (error, G_IO_ERROR,
3551                    G_IO_ERROR_NOT_SUPPORTED,
3552                    _("Operation not supported"));
3553       return NULL;
3554     }
3555
3556   return (* iface->monitor_dir) (file, flags, cancellable, error);
3557 }
3558
3559 /**
3560  * g_file_monitor_file:
3561  * @file: input #GFile.
3562  * @flags: a set of #GFileMonitorFlags.
3563  * @cancellable: optional #GCancellable object, %NULL to ignore.
3564  * @error: a #GError, or %NULL.
3565  *
3566  * Obtains a file monitor for the given file. If no file notification
3567  * mechanism exists, then regular polling of the file is used.
3568  *
3569  * If @cancellable is not %NULL, then the operation can be cancelled by
3570  * triggering the cancellable object from another thread. If the operation
3571  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3572  *
3573  * Returns: a #GFileMonitor for the given @file.
3574  **/
3575 GFileMonitor*
3576 g_file_monitor_file (GFile             *file,
3577                      GFileMonitorFlags  flags,
3578                      GCancellable      *cancellable,
3579                      GError           **error)
3580 {
3581   GFileIface *iface;
3582   GFileMonitor *monitor;
3583
3584   g_return_val_if_fail (G_IS_FILE (file), NULL);
3585
3586   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3587     return NULL;
3588
3589   iface = G_FILE_GET_IFACE (file);
3590
3591   monitor = NULL;
3592
3593   if (iface->monitor_file)
3594     monitor = (* iface->monitor_file) (file, flags, cancellable, NULL);
3595
3596 /* Fallback to polling */
3597   if (monitor == NULL)
3598     monitor = _g_poll_file_monitor_new (file);
3599
3600   return monitor;
3601 }
3602
3603 /********************************************
3604  *   Default implementation of async ops    *
3605  ********************************************/
3606
3607 typedef struct {
3608   char *attributes;
3609   GFileQueryInfoFlags flags;
3610   GFileInfo *info;
3611 } QueryInfoAsyncData;
3612
3613 static void
3614 query_info_data_free (QueryInfoAsyncData *data)
3615 {
3616   if (data->info)
3617     g_object_unref (data->info);
3618   g_free (data->attributes);
3619   g_free (data);
3620 }
3621
3622 static void
3623 query_info_async_thread (GSimpleAsyncResult *res,
3624                          GObject            *object,
3625                          GCancellable       *cancellable)
3626 {
3627   GError *error = NULL;
3628   QueryInfoAsyncData *data;
3629   GFileInfo *info;
3630
3631   data = g_simple_async_result_get_op_res_gpointer (res);
3632
3633   info = g_file_query_info (G_FILE (object), data->attributes, data->flags, cancellable, &error);
3634
3635   if (info == NULL)
3636     {
3637       g_simple_async_result_set_from_error (res, error);
3638       g_error_free (error);
3639     }
3640   else
3641     data->info = info;
3642 }
3643
3644 static void
3645 g_file_real_query_info_async (GFile               *file,
3646                               const char          *attributes,
3647                               GFileQueryInfoFlags  flags,
3648                               int                  io_priority,
3649                               GCancellable        *cancellable,
3650                               GAsyncReadyCallback  callback,
3651                               gpointer             user_data)
3652 {
3653   GSimpleAsyncResult *res;
3654   QueryInfoAsyncData *data;
3655
3656   data = g_new0 (QueryInfoAsyncData, 1);
3657   data->attributes = g_strdup (attributes);
3658   data->flags = flags;
3659
3660   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_query_info_async);
3661   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_info_data_free);
3662
3663   g_simple_async_result_run_in_thread (res, query_info_async_thread, io_priority, cancellable);
3664   g_object_unref (res);
3665 }
3666
3667 static GFileInfo *
3668 g_file_real_query_info_finish (GFile         *file,
3669                                GAsyncResult  *res,
3670                                GError       **error)
3671 {
3672   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3673   QueryInfoAsyncData *data;
3674
3675   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_query_info_async);
3676
3677   data = g_simple_async_result_get_op_res_gpointer (simple);
3678   if (data->info)
3679     return g_object_ref (data->info);
3680
3681   return NULL;
3682 }
3683
3684 typedef struct {
3685   char *attributes;
3686   GFileQueryInfoFlags flags;
3687   GFileEnumerator *enumerator;
3688 } EnumerateChildrenAsyncData;
3689
3690 static void
3691 enumerate_children_data_free (EnumerateChildrenAsyncData *data)
3692 {
3693   if (data->enumerator)
3694     g_object_unref (data->enumerator);
3695   g_free (data->attributes);
3696   g_free (data);
3697 }
3698
3699 static void
3700 enumerate_children_async_thread (GSimpleAsyncResult *res,
3701                                  GObject            *object,
3702                                  GCancellable       *cancellable)
3703 {
3704   GError *error = NULL;
3705   EnumerateChildrenAsyncData *data;
3706   GFileEnumerator *enumerator;
3707
3708   data = g_simple_async_result_get_op_res_gpointer (res);
3709
3710   enumerator = g_file_enumerate_children (G_FILE (object), data->attributes, data->flags, cancellable, &error);
3711
3712   if (enumerator == NULL)
3713     {
3714       g_simple_async_result_set_from_error (res, error);
3715       g_error_free (error);
3716     }
3717   else
3718     data->enumerator = enumerator;
3719 }
3720
3721 static void
3722 g_file_real_enumerate_children_async (GFile               *file,
3723                                       const char          *attributes,
3724                                       GFileQueryInfoFlags  flags,
3725                                       int                  io_priority,
3726                                       GCancellable        *cancellable,
3727                                       GAsyncReadyCallback  callback,
3728                                       gpointer             user_data)
3729 {
3730   GSimpleAsyncResult *res;
3731   EnumerateChildrenAsyncData *data;
3732
3733   data = g_new0 (EnumerateChildrenAsyncData, 1);
3734   data->attributes = g_strdup (attributes);
3735   data->flags = flags;
3736
3737   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_enumerate_children_async);
3738   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)enumerate_children_data_free);
3739
3740   g_simple_async_result_run_in_thread (res, enumerate_children_async_thread, io_priority, cancellable);
3741   g_object_unref (res);
3742 }
3743
3744 static GFileEnumerator *
3745 g_file_real_enumerate_children_finish (GFile         *file,
3746                                        GAsyncResult  *res,
3747                                        GError       **error)
3748 {
3749   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3750   EnumerateChildrenAsyncData *data;
3751
3752   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_enumerate_children_async);
3753
3754   data = g_simple_async_result_get_op_res_gpointer (simple);
3755   if (data->enumerator)
3756     return g_object_ref (data->enumerator);
3757
3758   return NULL;
3759 }
3760
3761 static void
3762 open_read_async_thread (GSimpleAsyncResult *res,
3763                         GObject            *object,
3764                         GCancellable       *cancellable)
3765 {
3766   GFileIface *iface;
3767   GFileInputStream *stream;
3768   GError *error = NULL;
3769
3770   iface = G_FILE_GET_IFACE (object);
3771
3772   stream = iface->read_fn (G_FILE (object), cancellable, &error);
3773
3774   if (stream == NULL)
3775     {
3776       g_simple_async_result_set_from_error (res, error);
3777       g_error_free (error);
3778     }
3779   else
3780     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3781 }
3782
3783 static void
3784 g_file_real_read_async (GFile               *file,
3785                         int                  io_priority,
3786                         GCancellable        *cancellable,
3787                         GAsyncReadyCallback  callback,
3788                         gpointer             user_data)
3789 {
3790   GSimpleAsyncResult *res;
3791
3792   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_read_async);
3793
3794   g_simple_async_result_run_in_thread (res, open_read_async_thread, io_priority, cancellable);
3795   g_object_unref (res);
3796 }
3797
3798 static GFileInputStream *
3799 g_file_real_read_finish (GFile         *file,
3800                          GAsyncResult  *res,
3801                          GError       **error)
3802 {
3803   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3804   gpointer op;
3805
3806   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_read_async);
3807
3808   op = g_simple_async_result_get_op_res_gpointer (simple);
3809   if (op)
3810     return g_object_ref (op);
3811
3812   return NULL;
3813 }
3814
3815 static void
3816 append_to_async_thread (GSimpleAsyncResult *res,
3817                         GObject            *object,
3818                         GCancellable       *cancellable)
3819 {
3820   GFileIface *iface;
3821   GFileCreateFlags *data;
3822   GFileOutputStream *stream;
3823   GError *error = NULL;
3824
3825   iface = G_FILE_GET_IFACE (object);
3826
3827   data = g_simple_async_result_get_op_res_gpointer (res);
3828
3829   stream = iface->append_to (G_FILE (object), *data, cancellable, &error);
3830
3831   if (stream == NULL)
3832     {
3833       g_simple_async_result_set_from_error (res, error);
3834       g_error_free (error);
3835     }
3836   else
3837     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3838 }
3839
3840 static void
3841 g_file_real_append_to_async (GFile               *file,
3842                              GFileCreateFlags     flags,
3843                              int                  io_priority,
3844                              GCancellable        *cancellable,
3845                              GAsyncReadyCallback  callback,
3846                              gpointer             user_data)
3847 {
3848   GFileCreateFlags *data;
3849   GSimpleAsyncResult *res;
3850
3851   data = g_new0 (GFileCreateFlags, 1);
3852   *data = flags;
3853
3854   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_append_to_async);
3855   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
3856
3857   g_simple_async_result_run_in_thread (res, append_to_async_thread, io_priority, cancellable);
3858   g_object_unref (res);
3859 }
3860
3861 static GFileOutputStream *
3862 g_file_real_append_to_finish (GFile         *file,
3863                               GAsyncResult  *res,
3864                               GError       **error)
3865 {
3866   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3867   gpointer op;
3868
3869   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_append_to_async);
3870
3871   op = g_simple_async_result_get_op_res_gpointer (simple);
3872   if (op)
3873     return g_object_ref (op);
3874
3875   return NULL;
3876 }
3877
3878 static void
3879 create_async_thread (GSimpleAsyncResult *res,
3880                      GObject            *object,
3881                      GCancellable       *cancellable)
3882 {
3883   GFileIface *iface;
3884   GFileCreateFlags *data;
3885   GFileOutputStream *stream;
3886   GError *error = NULL;
3887
3888   iface = G_FILE_GET_IFACE (object);
3889
3890   data = g_simple_async_result_get_op_res_gpointer (res);
3891
3892   stream = iface->create (G_FILE (object), *data, cancellable, &error);
3893
3894   if (stream == NULL)
3895     {
3896       g_simple_async_result_set_from_error (res, error);
3897       g_error_free (error);
3898     }
3899   else
3900     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
3901 }
3902
3903 static void
3904 g_file_real_create_async (GFile               *file,
3905                           GFileCreateFlags     flags,
3906                           int                  io_priority,
3907                           GCancellable        *cancellable,
3908                           GAsyncReadyCallback  callback,
3909                           gpointer             user_data)
3910 {
3911   GFileCreateFlags *data;
3912   GSimpleAsyncResult *res;
3913
3914   data = g_new0 (GFileCreateFlags, 1);
3915   *data = flags;
3916
3917   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_create_async);
3918   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
3919
3920   g_simple_async_result_run_in_thread (res, create_async_thread, io_priority, cancellable);
3921   g_object_unref (res);
3922 }
3923
3924 static GFileOutputStream *
3925 g_file_real_create_finish (GFile         *file,
3926                            GAsyncResult  *res,
3927                            GError       **error)
3928 {
3929   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3930   gpointer op;
3931
3932   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_create_async);
3933
3934   op = g_simple_async_result_get_op_res_gpointer (simple);
3935   if (op)
3936     return g_object_ref (op);
3937
3938   return NULL;
3939 }
3940
3941 typedef struct {
3942   GFileOutputStream *stream;
3943   char *etag;
3944   gboolean make_backup;
3945   GFileCreateFlags flags;
3946 } ReplaceAsyncData;
3947
3948 static void
3949 replace_async_data_free (ReplaceAsyncData *data)
3950 {
3951   if (data->stream)
3952     g_object_unref (data->stream);
3953   g_free (data->etag);
3954   g_free (data);
3955 }
3956
3957 static void
3958 replace_async_thread (GSimpleAsyncResult *res,
3959                       GObject            *object,
3960                       GCancellable       *cancellable)
3961 {
3962   GFileIface *iface;
3963   GFileOutputStream *stream;
3964   GError *error = NULL;
3965   ReplaceAsyncData *data;
3966
3967   iface = G_FILE_GET_IFACE (object);
3968
3969   data = g_simple_async_result_get_op_res_gpointer (res);
3970
3971   stream = iface->replace (G_FILE (object),
3972                            data->etag,
3973                            data->make_backup,
3974                            data->flags,
3975                            cancellable,
3976                            &error);
3977
3978   if (stream == NULL)
3979     {
3980       g_simple_async_result_set_from_error (res, error);
3981       g_error_free (error);
3982     }
3983   else
3984     data->stream = stream;
3985 }
3986
3987 static void
3988 g_file_real_replace_async (GFile               *file,
3989                            const char          *etag,
3990                            gboolean             make_backup,
3991                            GFileCreateFlags     flags,
3992                            int                  io_priority,
3993                            GCancellable        *cancellable,
3994                            GAsyncReadyCallback  callback,
3995                            gpointer             user_data)
3996 {
3997   GSimpleAsyncResult *res;
3998   ReplaceAsyncData *data;
3999
4000   data = g_new0 (ReplaceAsyncData, 1);
4001   data->etag = g_strdup (etag);
4002   data->make_backup = make_backup;
4003   data->flags = flags;
4004
4005   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_replace_async);
4006   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_async_data_free);
4007
4008   g_simple_async_result_run_in_thread (res, replace_async_thread, io_priority, cancellable);
4009   g_object_unref (res);
4010 }
4011
4012 static GFileOutputStream *
4013 g_file_real_replace_finish (GFile         *file,
4014                             GAsyncResult  *res,
4015                             GError       **error)
4016 {
4017   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4018   ReplaceAsyncData *data;
4019
4020   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_replace_async);
4021
4022   data = g_simple_async_result_get_op_res_gpointer (simple);
4023   if (data->stream)
4024     return g_object_ref (data->stream);
4025
4026   return NULL;
4027 }
4028
4029 typedef struct {
4030   char *name;
4031   GFile *file;
4032 } SetDisplayNameAsyncData;
4033
4034 static void
4035 set_display_name_data_free (SetDisplayNameAsyncData *data)
4036 {
4037   g_free (data->name);
4038   if (data->file)
4039     g_object_unref (data->file);
4040   g_free (data);
4041 }
4042
4043 static void
4044 set_display_name_async_thread (GSimpleAsyncResult *res,
4045                                GObject            *object,
4046                                GCancellable       *cancellable)
4047 {
4048   GError *error = NULL;
4049   SetDisplayNameAsyncData *data;
4050   GFile *file;
4051
4052   data = g_simple_async_result_get_op_res_gpointer (res);
4053
4054   file = g_file_set_display_name (G_FILE (object), data->name, cancellable, &error);
4055
4056   if (file == NULL)
4057     {
4058       g_simple_async_result_set_from_error (res, error);
4059       g_error_free (error);
4060     }
4061   else
4062     data->file = file;
4063 }
4064
4065 static void
4066 g_file_real_set_display_name_async (GFile               *file,
4067                                     const char          *display_name,
4068                                     int                  io_priority,
4069                                     GCancellable        *cancellable,
4070                                     GAsyncReadyCallback  callback,
4071                                     gpointer             user_data)
4072 {
4073   GSimpleAsyncResult *res;
4074   SetDisplayNameAsyncData *data;
4075
4076   data = g_new0 (SetDisplayNameAsyncData, 1);
4077   data->name = g_strdup (display_name);
4078
4079   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_display_name_async);
4080   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_display_name_data_free);
4081
4082   g_simple_async_result_run_in_thread (res, set_display_name_async_thread, io_priority, cancellable);
4083   g_object_unref (res);
4084 }
4085
4086 static GFile *
4087 g_file_real_set_display_name_finish (GFile         *file,
4088                                      GAsyncResult  *res,
4089                                      GError       **error)
4090 {
4091   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4092   SetDisplayNameAsyncData *data;
4093
4094   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_display_name_async);
4095
4096   data = g_simple_async_result_get_op_res_gpointer (simple);
4097   if (data->file)
4098     return g_object_ref (data->file);
4099
4100   return NULL;
4101 }
4102
4103 typedef struct {
4104   GFileQueryInfoFlags flags;
4105   GFileInfo *info;
4106   gboolean res;
4107   GError *error;
4108 } SetInfoAsyncData;
4109
4110 static void
4111 set_info_data_free (SetInfoAsyncData *data)
4112 {
4113   if (data->info)
4114     g_object_unref (data->info);
4115   if (data->error)
4116     g_error_free (data->error);
4117   g_free (data);
4118 }
4119
4120 static void
4121 set_info_async_thread (GSimpleAsyncResult *res,
4122                        GObject            *object,
4123                        GCancellable       *cancellable)
4124 {
4125   SetInfoAsyncData *data;
4126
4127   data = g_simple_async_result_get_op_res_gpointer (res);
4128
4129   data->error = NULL;
4130   data->res = g_file_set_attributes_from_info (G_FILE (object),
4131                                                data->info,
4132                                                data->flags,
4133                                                cancellable,
4134                                                &data->error);
4135 }
4136
4137 static void
4138 g_file_real_set_attributes_async (GFile               *file,
4139                                   GFileInfo           *info,
4140                                   GFileQueryInfoFlags  flags,
4141                                   int                  io_priority,
4142                                   GCancellable        *cancellable,
4143                                   GAsyncReadyCallback  callback,
4144                                   gpointer             user_data)
4145 {
4146   GSimpleAsyncResult *res;
4147   SetInfoAsyncData *data;
4148
4149   data = g_new0 (SetInfoAsyncData, 1);
4150   data->info = g_file_info_dup (info);
4151   data->flags = flags;
4152
4153   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_attributes_async);
4154   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_info_data_free);
4155
4156   g_simple_async_result_run_in_thread (res, set_info_async_thread, io_priority, cancellable);
4157   g_object_unref (res);
4158 }
4159
4160 static gboolean
4161 g_file_real_set_attributes_finish (GFile         *file,
4162                                    GAsyncResult  *res,
4163                                    GFileInfo    **info,
4164                                    GError       **error)
4165 {
4166   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4167   SetInfoAsyncData *data;
4168
4169   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_attributes_async);
4170
4171   data = g_simple_async_result_get_op_res_gpointer (simple);
4172
4173   if (info)
4174     *info = g_object_ref (data->info);
4175
4176   if (error != NULL && data->error)
4177     *error = g_error_copy (data->error);
4178
4179   return data->res;
4180 }
4181
4182 static void
4183 find_enclosing_mount_async_thread (GSimpleAsyncResult *res,
4184                                     GObject            *object,
4185                                     GCancellable       *cancellable)
4186 {
4187   GError *error = NULL;
4188   GMount *mount;
4189
4190   mount = g_file_find_enclosing_mount (G_FILE (object), cancellable, &error);
4191
4192   if (mount == NULL)
4193     {
4194       g_simple_async_result_set_from_error (res, error);
4195       g_error_free (error);
4196     }
4197   else
4198     g_simple_async_result_set_op_res_gpointer (res, mount, (GDestroyNotify)g_object_unref);
4199 }
4200
4201 static void
4202 g_file_real_find_enclosing_mount_async (GFile               *file,
4203                                         int                  io_priority,
4204                                         GCancellable        *cancellable,
4205                                         GAsyncReadyCallback  callback,
4206                                         gpointer             user_data)
4207 {
4208   GSimpleAsyncResult *res;
4209
4210   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_find_enclosing_mount_async);
4211
4212   g_simple_async_result_run_in_thread (res, find_enclosing_mount_async_thread, io_priority, cancellable);
4213   g_object_unref (res);
4214 }
4215
4216 static GMount *
4217 g_file_real_find_enclosing_mount_finish (GFile         *file,
4218                                           GAsyncResult  *res,
4219                                           GError       **error)
4220 {
4221   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4222   GMount *mount;
4223
4224   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_find_enclosing_mount_async);
4225
4226   mount = g_simple_async_result_get_op_res_gpointer (simple);
4227   return g_object_ref (mount);
4228 }
4229
4230
4231 typedef struct {
4232   GFile *source;
4233   GFile *destination;
4234   GFileCopyFlags flags;
4235   GFileProgressCallback progress_cb;
4236   gpointer progress_cb_data;
4237   GIOSchedulerJob *job;
4238 } CopyAsyncData;
4239
4240 static void
4241 copy_async_data_free (CopyAsyncData *data)
4242 {
4243   g_object_unref (data->source);
4244   g_object_unref (data->destination);
4245   g_free (data);
4246 }
4247
4248 typedef struct {
4249   CopyAsyncData *data;
4250   goffset current_num_bytes;
4251   goffset total_num_bytes;
4252 } ProgressData;
4253
4254 static gboolean
4255 copy_async_progress_in_main (gpointer user_data)
4256 {
4257   ProgressData *progress = user_data;
4258   CopyAsyncData *data = progress->data;
4259
4260   data->progress_cb (progress->current_num_bytes,
4261                      progress->total_num_bytes,
4262                      data->progress_cb_data);
4263
4264   return FALSE;
4265 }
4266
4267 static gboolean
4268 mainloop_barrier (gpointer user_data)
4269 {
4270   /* Does nothing, but ensures all queued idles before
4271      this are run */
4272   return FALSE;
4273 }
4274
4275
4276 static void
4277 copy_async_progress_callback (goffset  current_num_bytes,
4278                               goffset  total_num_bytes,
4279                               gpointer user_data)
4280 {
4281   CopyAsyncData *data = user_data;
4282   ProgressData *progress;
4283
4284   progress = g_new (ProgressData, 1);
4285   progress->data = data;
4286   progress->current_num_bytes = current_num_bytes;
4287   progress->total_num_bytes = total_num_bytes;
4288
4289   g_io_scheduler_job_send_to_mainloop_async (data->job,
4290                                              copy_async_progress_in_main,
4291                                              progress,
4292                                              g_free);
4293 }
4294
4295 static gboolean
4296 copy_async_thread (GIOSchedulerJob *job,
4297                    GCancellable    *cancellable,
4298                    gpointer         user_data)
4299 {
4300   GSimpleAsyncResult *res;
4301   CopyAsyncData *data;
4302   gboolean result;
4303   GError *error;
4304
4305   res = user_data;
4306   data = g_simple_async_result_get_op_res_gpointer (res);
4307
4308   error = NULL;
4309   data->job = job;
4310   result = g_file_copy (data->source,
4311                         data->destination,
4312                         data->flags,
4313                         cancellable,
4314                         (data->progress_cb != NULL) ? copy_async_progress_callback : NULL,
4315                         data,
4316                         &error);
4317
4318   /* Ensure all progress callbacks are done running in main thread */
4319   if (data->progress_cb != NULL)
4320     g_io_scheduler_job_send_to_mainloop (job,
4321                                          mainloop_barrier,
4322                                          NULL, NULL);
4323
4324   if (!result)
4325     {
4326       g_simple_async_result_set_from_error (res, error);
4327       g_error_free (error);
4328     }
4329
4330   g_simple_async_result_complete_in_idle (res);
4331
4332   return FALSE;
4333 }
4334
4335 static void
4336 g_file_real_copy_async (GFile                  *source,
4337                         GFile                  *destination,
4338                         GFileCopyFlags          flags,
4339                         int                     io_priority,
4340                         GCancellable           *cancellable,
4341                         GFileProgressCallback   progress_callback,
4342                         gpointer                progress_callback_data,
4343                         GAsyncReadyCallback     callback,
4344                         gpointer                user_data)
4345 {
4346   GSimpleAsyncResult *res;
4347   CopyAsyncData *data;
4348
4349   data = g_new0 (CopyAsyncData, 1);
4350   data->source = g_object_ref (source);
4351   data->destination = g_object_ref (destination);
4352   data->flags = flags;
4353   data->progress_cb = progress_callback;
4354   data->progress_cb_data = progress_callback_data;
4355
4356   res = g_simple_async_result_new (G_OBJECT (source), callback, user_data, g_file_real_copy_async);
4357   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)copy_async_data_free);
4358
4359   g_io_scheduler_push_job (copy_async_thread, res, g_object_unref, io_priority, cancellable);
4360 }
4361
4362 static gboolean
4363 g_file_real_copy_finish (GFile        *file,
4364                          GAsyncResult *res,
4365                          GError      **error)
4366 {
4367   /* Error handled in g_file_copy_finish() */
4368   return TRUE;
4369 }
4370
4371
4372 /********************************************
4373  *   Default VFS operations                 *
4374  ********************************************/
4375
4376 /**
4377  * g_file_new_for_path:
4378  * @path: a string containing a relative or absolute path.
4379  *
4380  * Constructs a #GFile for a given path. This operation never
4381  * fails, but the returned object might not support any I/O
4382  * operation if @path is malformed.
4383  *
4384  * Returns: a new #GFile for the given @path.
4385  **/
4386 GFile *
4387 g_file_new_for_path (const char *path)
4388 {
4389   g_return_val_if_fail (path != NULL, NULL);
4390
4391   return g_vfs_get_file_for_path (g_vfs_get_default (), path);
4392 }
4393
4394 /**
4395  * g_file_new_for_uri:
4396  * @uri: a string containing a URI.
4397  *
4398  * Constructs a #GFile for a given URI. This operation never
4399  * fails, but the returned object might not support any I/O
4400  * operation if @uri is malformed or if the uri type is
4401  * not supported.
4402  *
4403  * Returns: a #GFile for the given @uri.
4404  **/
4405 GFile *
4406 g_file_new_for_uri (const char *uri)
4407 {
4408   g_return_val_if_fail (uri != NULL, NULL);
4409
4410   return g_vfs_get_file_for_uri (g_vfs_get_default (), uri);
4411 }
4412
4413 /**
4414  * g_file_parse_name:
4415  * @parse_name: a file name or path to be parsed.
4416  *
4417  * Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()).
4418  * This operation never fails, but the returned object might not support any I/O
4419  * operation if the @parse_name cannot be parsed.
4420  *
4421  * Returns: a new #GFile.
4422  **/
4423 GFile *
4424 g_file_parse_name (const char *parse_name)
4425 {
4426   g_return_val_if_fail (parse_name != NULL, NULL);
4427
4428   return g_vfs_parse_name (g_vfs_get_default (), parse_name);
4429 }
4430
4431 static gboolean
4432 is_valid_scheme_character (char c)
4433 {
4434   return g_ascii_isalnum (c) || c == '+' || c == '-' || c == '.';
4435 }
4436
4437 static gboolean
4438 has_valid_scheme (const char *uri)
4439 {
4440   const char *p;
4441
4442   p = uri;
4443
4444   if (!is_valid_scheme_character (*p))
4445     return FALSE;
4446
4447   do {
4448     p++;
4449   } while (is_valid_scheme_character (*p));
4450
4451   return *p == ':';
4452 }
4453
4454 /**
4455  * g_file_new_for_commandline_arg:
4456  * @arg: a command line string.
4457  *
4458  * Creates a #GFile with the given argument from the command line. The value of
4459  * @arg can be either a URI, an absolute path or a relative path resolved
4460  * relative to the current working directory.
4461  * This operation never fails, but the returned object might not support any
4462  * I/O operation if @arg points to a malformed path.
4463  *
4464  * Returns: a new #GFile.
4465  **/
4466 GFile *
4467 g_file_new_for_commandline_arg (const char *arg)
4468 {
4469   GFile *file;
4470   char *filename;
4471   char *current_dir;
4472
4473   g_return_val_if_fail (arg != NULL, NULL);
4474
4475   if (g_path_is_absolute (arg))
4476     return g_file_new_for_path (arg);
4477
4478   if (has_valid_scheme (arg))
4479     return g_file_new_for_uri (arg);
4480
4481   current_dir = g_get_current_dir ();
4482   filename = g_build_filename (current_dir, arg, NULL);
4483   g_free (current_dir);
4484
4485   file = g_file_new_for_path (filename);
4486   g_free (filename);
4487
4488   return file;
4489 }
4490
4491 /**
4492  * g_file_mount_enclosing_volume:
4493  * @location: input #GFile.
4494  * @mount_operation: a #GMountOperation or %NULL to avoid user interaction.
4495  * @cancellable: optional #GCancellable object, %NULL to ignore.
4496  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4497  * @user_data: the data to pass to callback function
4498  *
4499  * Starts a @mount_operation, mounting the volume that contains the file @location.
4500  *
4501  * When this operation has completed, @callback will be called with
4502  * @user_user data, and the operation can be finalized with
4503  * g_file_mount_enclosing_volume_finish().
4504  *
4505  * If @cancellable is not %NULL, then the operation can be cancelled by
4506  * triggering the cancellable object from another thread. If the operation
4507  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4508  **/
4509 void
4510 g_file_mount_enclosing_volume (GFile               *location,
4511                                GMountOperation     *mount_operation,
4512                                GCancellable        *cancellable,
4513                                GAsyncReadyCallback  callback,
4514                                gpointer             user_data)
4515 {
4516   GFileIface *iface;
4517
4518   g_return_if_fail (G_IS_FILE (location));
4519
4520   iface = G_FILE_GET_IFACE (location);
4521
4522   if (iface->mount_enclosing_volume == NULL)
4523     {
4524       g_simple_async_report_error_in_idle (G_OBJECT (location),
4525                                            callback, user_data,
4526                                            G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
4527                                            _("volume doesn't implement mount"));
4528
4529       return;
4530     }
4531
4532   (* iface->mount_enclosing_volume) (location, mount_operation, cancellable, callback, user_data);
4533
4534 }
4535
4536 /**
4537  * g_file_mount_enclosing_volume_finish:
4538  * @location: input #GFile.
4539  * @result: a #GAsyncResult.
4540  * @error: a #GError, or %NULL
4541  *
4542  * Finishes a mount operation started by g_file_mount_enclosing_volume().
4543  *
4544  * Returns: %TRUE if successful. If an error
4545  * has occurred, this function will return %FALSE and set @error
4546  * appropriately if present.
4547  **/
4548 gboolean
4549 g_file_mount_enclosing_volume_finish (GFile         *location,
4550                                       GAsyncResult  *result,
4551                                       GError       **error)
4552 {
4553   GFileIface *iface;
4554
4555   g_return_val_if_fail (G_IS_FILE (location), FALSE);
4556   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4557
4558   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4559     {
4560       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4561       if (g_simple_async_result_propagate_error (simple, error))
4562         return FALSE;
4563     }
4564
4565   iface = G_FILE_GET_IFACE (location);
4566
4567   return (* iface->mount_enclosing_volume_finish) (location, result, error);
4568 }
4569
4570 /********************************************
4571  *   Utility functions                      *
4572  ********************************************/
4573
4574 /**
4575  * g_file_query_default_handler:
4576  * @file: a #GFile to open.
4577  * @cancellable: optional #GCancellable object, %NULL to ignore.
4578  * @error: a #GError, or %NULL
4579  *
4580  * Returns the #GAppInfo that is registered as the default
4581  * application to handle the file specified bu @file.
4582  *
4583  * If @cancellable is not %NULL, then the operation can be cancelled by
4584  * triggering the cancellable object from another thread. If the operation
4585  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4586  *
4587  * Returns: a #GAppInfo if the handle was found, %NULL if there were errors.
4588  * When you are done with it, release it with g_object_unref()
4589  **/
4590 GAppInfo *
4591 g_file_query_default_handler (GFile                  *file,
4592                               GCancellable           *cancellable,
4593                               GError                **error)
4594 {
4595   char *uri_scheme;
4596   const char *content_type;
4597   GAppInfo *appinfo;
4598   GFileInfo *info;
4599   char *path;
4600
4601   uri_scheme = g_file_get_uri_scheme (file);
4602   appinfo = g_app_info_get_default_for_uri_scheme (uri_scheme);
4603   g_free (uri_scheme);
4604
4605   if (appinfo != NULL)
4606     return appinfo;
4607
4608   info = g_file_query_info (file,
4609                             G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
4610                             0,
4611                             cancellable,
4612                             error);
4613   if (info == NULL)
4614     return NULL;
4615
4616   appinfo = NULL;
4617
4618   content_type = g_file_info_get_content_type (info);
4619   if (content_type)
4620     {
4621       /* Don't use is_native(), as we want to support fuse paths if availible */
4622       path = g_file_get_path (file);
4623       appinfo = g_app_info_get_default_for_type (content_type,
4624                                                  path == NULL);
4625       g_free (path);
4626     }
4627
4628   g_object_unref (info);
4629
4630   if (appinfo != NULL)
4631     return appinfo;
4632
4633   g_set_error (error, G_IO_ERROR,
4634                G_IO_ERROR_NOT_SUPPORTED,
4635                _("No application is registered as handling this file"));
4636   return NULL;
4637
4638 }
4639
4640
4641 #define GET_CONTENT_BLOCK_SIZE 8192
4642
4643 /**
4644  * g_file_load_contents:
4645  * @file: input #GFile.
4646  * @cancellable: optional #GCancellable object, %NULL to ignore.
4647  * @contents: a location to place the contents of the file.
4648  * @length: a location to place the length of the contents of the file.
4649  * @etag_out: a location to place the current entity tag for the file.
4650  * @error: a #GError, or %NULL
4651  *
4652  * Loads the content of the file into memory, returning the size of
4653  * the data. The data is always zero terminated, but this is not
4654  * included in the resultant @length.
4655  *
4656  * If @cancellable is not %NULL, then the operation can be cancelled by
4657  * triggering the cancellable object from another thread. If the operation
4658  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4659  *
4660  * Returns: %TRUE if the @file's contents were successfully loaded.
4661  * %FALSE if there were errors..
4662  **/
4663 gboolean
4664 g_file_load_contents (GFile         *file,
4665                       GCancellable  *cancellable,
4666                       char         **contents,
4667                       gsize         *length,
4668                       char         **etag_out,
4669                       GError       **error)
4670 {
4671   GFileInputStream *in;
4672   GByteArray *content;
4673   gsize pos;
4674   gssize res;
4675   GFileInfo *info;
4676
4677   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4678   g_return_val_if_fail (contents != NULL, FALSE);
4679
4680   in = g_file_read (file, cancellable, error);
4681   if (in == NULL)
4682     return FALSE;
4683
4684   content = g_byte_array_new ();
4685   pos = 0;
4686
4687   g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
4688   while ((res = g_input_stream_read (G_INPUT_STREAM (in),
4689                                      content->data + pos,
4690                                      GET_CONTENT_BLOCK_SIZE,
4691                                      cancellable, error)) > 0)
4692     {
4693       pos += res;
4694       g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
4695     }
4696
4697   if (etag_out)
4698     {
4699       *etag_out = NULL;
4700
4701       info = g_file_input_stream_query_info (in,
4702                                              G_FILE_ATTRIBUTE_ETAG_VALUE,
4703                                              cancellable,
4704                                              NULL);
4705       if (info)
4706         {
4707           *etag_out = g_strdup (g_file_info_get_etag (info));
4708           g_object_unref (info);
4709         }
4710     }
4711
4712   /* Ignore errors on close */
4713   g_input_stream_close (G_INPUT_STREAM (in), cancellable, NULL);
4714   g_object_unref (in);
4715
4716   if (res < 0)
4717     {
4718       /* error is set already */
4719       g_byte_array_free (content, TRUE);
4720       return FALSE;
4721     }
4722
4723   if (length)
4724     *length = pos;
4725
4726   /* Zero terminate (we got an extra byte allocated for this */
4727   content->data[pos] = 0;
4728
4729   *contents = (char *)g_byte_array_free (content, FALSE);
4730
4731   return TRUE;
4732 }
4733
4734 typedef struct {
4735   GFile *file;
4736   GError *error;
4737   GCancellable *cancellable;
4738   GFileReadMoreCallback read_more_callback;
4739   GAsyncReadyCallback callback;
4740   gpointer user_data;
4741   GByteArray *content;
4742   gsize pos;
4743   char *etag;
4744 } LoadContentsData;
4745
4746
4747 static void
4748 load_contents_data_free (LoadContentsData *data)
4749 {
4750   if (data->error)
4751     g_error_free (data->error);
4752   if (data->cancellable)
4753     g_object_unref (data->cancellable);
4754   if (data->content)
4755     g_byte_array_free (data->content, TRUE);
4756   g_free (data->etag);
4757   g_object_unref (data->file);
4758   g_free (data);
4759 }
4760
4761 static void
4762 load_contents_close_callback (GObject      *obj,
4763                               GAsyncResult *close_res,
4764                               gpointer      user_data)
4765 {
4766   GInputStream *stream = G_INPUT_STREAM (obj);
4767   LoadContentsData *data = user_data;
4768   GSimpleAsyncResult *res;
4769
4770   /* Ignore errors here, we're only reading anyway */
4771   g_input_stream_close_finish (stream, close_res, NULL);
4772   g_object_unref (stream);
4773
4774   res = g_simple_async_result_new (G_OBJECT (data->file),
4775                                    data->callback,
4776                                    data->user_data,
4777                                    g_file_load_contents_async);
4778   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)load_contents_data_free);
4779   g_simple_async_result_complete (res);
4780   g_object_unref (res);
4781 }
4782
4783 static void
4784 load_contents_fstat_callback (GObject      *obj,
4785                               GAsyncResult *stat_res,
4786                               gpointer      user_data)
4787 {
4788   GInputStream *stream = G_INPUT_STREAM (obj);
4789   LoadContentsData *data = user_data;
4790   GFileInfo *info;
4791
4792   info = g_file_input_stream_query_info_finish (G_FILE_INPUT_STREAM (stream),
4793                                                    stat_res, NULL);
4794   if (info)
4795     {
4796       data->etag = g_strdup (g_file_info_get_etag (info));
4797       g_object_unref (info);
4798     }
4799
4800   g_input_stream_close_async (stream, 0,
4801                               data->cancellable,
4802                               load_contents_close_callback, data);
4803 }
4804
4805 static void
4806 load_contents_read_callback (GObject      *obj,
4807                              GAsyncResult *read_res,
4808                              gpointer      user_data)
4809 {
4810   GInputStream *stream = G_INPUT_STREAM (obj);
4811   LoadContentsData *data = user_data;
4812   GError *error = NULL;
4813   gssize read_size;
4814
4815   read_size = g_input_stream_read_finish (stream, read_res, &error);
4816
4817   if (read_size < 0)
4818     {
4819       /* Error or EOF, close the file */
4820       data->error = error;
4821       g_input_stream_close_async (stream, 0,
4822                                   data->cancellable,
4823                                   load_contents_close_callback, data);
4824     }
4825   else if (read_size == 0)
4826     {
4827       g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
4828                                             G_FILE_ATTRIBUTE_ETAG_VALUE,
4829                                             0,
4830                                             data->cancellable,
4831                                             load_contents_fstat_callback,
4832                                             data);
4833     }
4834   else if (read_size > 0)
4835     {
4836       data->pos += read_size;
4837
4838       g_byte_array_set_size (data->content,
4839                              data->pos + GET_CONTENT_BLOCK_SIZE);
4840
4841
4842       if (data->read_more_callback &&
4843           !data->read_more_callback ((char *)data->content->data, data->pos, data->user_data))
4844         g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
4845                                               G_FILE_ATTRIBUTE_ETAG_VALUE,
4846                                               0,
4847                                               data->cancellable,
4848                                               load_contents_fstat_callback,
4849                                               data);
4850       else
4851         g_input_stream_read_async (stream,
4852                                    data->content->data + data->pos,
4853                                    GET_CONTENT_BLOCK_SIZE,
4854                                    0,
4855                                    data->cancellable,
4856                                    load_contents_read_callback,
4857                                    data);
4858     }
4859 }
4860
4861 static void
4862 load_contents_open_callback (GObject      *obj,
4863                              GAsyncResult *open_res,
4864                              gpointer      user_data)
4865 {
4866   GFile *file = G_FILE (obj);
4867   GFileInputStream *stream;
4868   LoadContentsData *data = user_data;
4869   GError *error = NULL;
4870   GSimpleAsyncResult *res;
4871
4872   stream = g_file_read_finish (file, open_res, &error);
4873
4874   if (stream)
4875     {
4876       g_byte_array_set_size (data->content,
4877                              data->pos + GET_CONTENT_BLOCK_SIZE);
4878       g_input_stream_read_async (G_INPUT_STREAM (stream),
4879                                  data->content->data + data->pos,
4880                                  GET_CONTENT_BLOCK_SIZE,
4881                                  0,
4882                                  data->cancellable,
4883                                  load_contents_read_callback,
4884                                  data);
4885
4886     }
4887   else
4888     {
4889       res = g_simple_async_result_new_from_error (G_OBJECT (data->file),
4890                                                   data->callback,
4891                                                   data->user_data,
4892                                                   error);
4893       g_simple_async_result_complete (res);
4894       g_error_free (error);
4895       load_contents_data_free (data);
4896       g_object_unref (res);
4897     }
4898 }
4899
4900 /**
4901  * g_file_load_partial_contents_async:
4902  * @file: input #GFile.
4903  * @cancellable: optional #GCancellable object, %NULL to ignore.
4904  * @read_more_callback: a #GFileReadMoreCallback to receive partial data and to specify whether further data should be read.
4905  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
4906  * @user_data: the data to pass to the callback functions.
4907  *
4908  * Reads the partial contents of a file. A #GFileReadMoreCallback should be
4909  * used to stop reading from the file when appropriate, else this function
4910  * will behave exactly as g_file_load_contents_async(). This operation
4911  * can be finished by g_file_load_partial_contents_finish().
4912  *
4913  * Users of this function should be aware that @user_data is passed to
4914  * both the @read_more_callback and the @callback.
4915  *
4916  * If @cancellable is not %NULL, then the operation can be cancelled by
4917  * triggering the cancellable object from another thread. If the operation
4918  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4919  **/
4920 void
4921 g_file_load_partial_contents_async (GFile                 *file,
4922                                     GCancellable          *cancellable,
4923                                     GFileReadMoreCallback  read_more_callback,
4924                                     GAsyncReadyCallback    callback,
4925                                     gpointer               user_data)
4926 {
4927   LoadContentsData *data;
4928
4929   g_return_if_fail (G_IS_FILE (file));
4930
4931   data = g_new0 (LoadContentsData, 1);
4932
4933   if (cancellable)
4934     data->cancellable = g_object_ref (cancellable);
4935   data->read_more_callback = read_more_callback;
4936   data->callback = callback;
4937   data->user_data = user_data;
4938   data->content = g_byte_array_new ();
4939   data->file = g_object_ref (file);
4940
4941   g_file_read_async (file,
4942                      0,
4943                      cancellable,
4944                      load_contents_open_callback,
4945                      data);
4946 }
4947
4948 /**
4949  * g_file_load_partial_contents_finish:
4950  * @file: input #GFile.
4951  * @res: a #GAsyncResult.
4952  * @contents: a location to place the contents of the file.
4953  * @length: a location to place the length of the contents of the file.
4954  * @etag_out: a location to place the current entity tag for the file.
4955  * @error: a #GError, or %NULL
4956  *
4957  * Finishes an asynchronous partial load operation that was started
4958  * with g_file_load_partial_contents_async().
4959  *
4960  * Returns: %TRUE if the load was successful. If %FALSE and @error is
4961  * present, it will be set appropriately.
4962  **/
4963 gboolean
4964 g_file_load_partial_contents_finish (GFile         *file,
4965                                      GAsyncResult  *res,
4966                                      char         **contents,
4967                                      gsize         *length,
4968                                      char         **etag_out,
4969                                      GError       **error)
4970 {
4971   GSimpleAsyncResult *simple;
4972   LoadContentsData *data;
4973
4974   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4975   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
4976   g_return_val_if_fail (contents != NULL, FALSE);
4977
4978   simple = G_SIMPLE_ASYNC_RESULT (res);
4979
4980   if (g_simple_async_result_propagate_error (simple, error))
4981     return FALSE;
4982
4983   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_load_contents_async);
4984
4985   data = g_simple_async_result_get_op_res_gpointer (simple);
4986
4987   if (data->error)
4988     {
4989       g_propagate_error (error, data->error);
4990       data->error = NULL;
4991       *contents = NULL;
4992       if (length)
4993         *length = 0;
4994       return FALSE;
4995     }
4996
4997   if (length)
4998     *length = data->pos;
4999
5000   if (etag_out)
5001     {
5002       *etag_out = data->etag;
5003       data->etag = NULL;
5004     }
5005
5006   /* Zero terminate */
5007   g_byte_array_set_size (data->content, data->pos + 1);
5008   data->content->data[data->pos] = 0;
5009
5010   *contents = (char *)g_byte_array_free (data->content, FALSE);
5011   data->content = NULL;
5012
5013   return TRUE;
5014 }
5015
5016 /**
5017  * g_file_load_contents_async:
5018  * @file: input #GFile.
5019  * @cancellable: optional #GCancellable object, %NULL to ignore.
5020  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
5021  * @user_data: the data to pass to callback function
5022  *
5023  * Starts an asynchronous load of the @file's contents.
5024  *
5025  * For more details, see g_file_load_contents() which is
5026  * the synchronous version of this call.
5027  *
5028  * When the load operation has completed, @callback will be called
5029  * with @user data. To finish the operation, call
5030  * g_file_load_contents_finish() with the #GAsyncResult returned by
5031  * the @callback.
5032  *
5033  * If @cancellable is not %NULL, then the operation can be cancelled by
5034  * triggering the cancellable object from another thread. If the operation
5035  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5036  **/
5037 void
5038 g_file_load_contents_async (GFile               *file,
5039                            GCancellable        *cancellable,
5040                            GAsyncReadyCallback  callback,
5041                            gpointer             user_data)
5042 {
5043   g_file_load_partial_contents_async (file,
5044                                       cancellable,
5045                                       NULL,
5046                                       callback, user_data);
5047 }
5048
5049 /**
5050  * g_file_load_contents_finish:
5051  * @file: input #GFile.
5052  * @res: a #GAsyncResult.
5053  * @contents: a location to place the contents of the file.
5054  * @length: a location to place the length of the contents of the file.
5055  * @etag_out: a location to place the current entity tag for the file.
5056  * @error: a #GError, or %NULL
5057  *
5058  * Finishes an asynchronous load of the @file's contents.
5059  * The contents are placed in @contents, and @length is set to the
5060  * size of the @contents string. If @etag_out is present, it will be
5061  * set to the new entity tag for the @file.
5062  *
5063  * Returns: %TRUE if the load was successful. If %FALSE and @error is
5064  * present, it will be set appropriately.
5065  **/
5066 gboolean
5067 g_file_load_contents_finish (GFile         *file,
5068                              GAsyncResult  *res,
5069                              char         **contents,
5070                              gsize         *length,
5071                              char         **etag_out,
5072                              GError       **error)
5073 {
5074   return g_file_load_partial_contents_finish (file,
5075                                               res,
5076                                               contents,
5077                                               length,
5078                                               etag_out,
5079                                               error);
5080 }
5081
5082 /**
5083  * g_file_replace_contents:
5084  * @file: input #GFile.
5085  * @contents: a string containing the new contents for @file.
5086  * @length: the length of @contents in bytes.
5087  * @etag: the old <link linkend="gfile-etag">entity tag</link>
5088  *     for the document.
5089  * @make_backup: %TRUE if a backup should be created.
5090  * @flags: a set of #GFileCreateFlags.
5091  * @new_etag: a location to a new <link linkend="gfile-etag">entity tag</link>
5092  *      for the document. This should be freed with g_free() when no longer
5093  *      needed.
5094  * @cancellable: optional #GCancellable object, %NULL to ignore.
5095  * @error: a #GError, or %NULL
5096  *
5097  * Replaces the contents of @file with @contents of @length bytes.
5098
5099  * If @etag is specified (not %NULL) any existing file must have that etag, or
5100  * the error %G_IO_ERROR_WRONG_ETAG will be returned.
5101  *
5102  * If @make_backup is %TRUE, this function will attempt to make a backup of @file.
5103  *
5104  * If @cancellable is not %NULL, then the operation can be cancelled by
5105  * triggering the cancellable object from another thread. If the operation
5106  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5107  *
5108  * The returned @new_etag can be used to verify that the file hasn't changed the
5109  * next time it is saved over.
5110  *
5111  * Returns: %TRUE if successful. If an error
5112  * has occurred, this function will return %FALSE and set @error
5113  * appropriately if present.
5114  **/
5115 gboolean
5116 g_file_replace_contents (GFile             *file,
5117                          const char        *contents,
5118                          gsize              length,
5119                          const char        *etag,
5120                          gboolean           make_backup,
5121                          GFileCreateFlags   flags,
5122                          char             **new_etag,
5123                          GCancellable      *cancellable,
5124                          GError           **error)
5125 {
5126   GFileOutputStream *out;
5127   gsize pos, remainder;
5128   gssize res;
5129
5130   g_return_val_if_fail (G_IS_FILE (file), FALSE);
5131   g_return_val_if_fail (contents != NULL, FALSE);
5132
5133   out = g_file_replace (file, etag, make_backup, flags, cancellable, error);
5134   if (out == NULL)
5135     return FALSE;
5136
5137   pos = 0;
5138   remainder = length;
5139   while (remainder > 0 &&
5140          (res = g_output_stream_write (G_OUTPUT_STREAM (out),
5141                                        contents + pos,
5142                                        MIN (remainder, GET_CONTENT_BLOCK_SIZE),
5143                                        cancellable,
5144                                        error)) > 0)
5145     {
5146       pos += res;
5147       remainder -= res;
5148     }
5149
5150   if (remainder > 0 && res < 0)
5151     {
5152       /* Ignore errors on close */
5153       g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, NULL);
5154
5155       /* error is set already */
5156       return FALSE;
5157     }
5158
5159   if (!g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, error))
5160     return FALSE;
5161
5162   if (new_etag)
5163     *new_etag = g_file_output_stream_get_etag (out);
5164
5165   return TRUE;
5166 }
5167
5168 typedef struct {
5169   GFile *file;
5170   GError *error;
5171   GCancellable *cancellable;
5172   GAsyncReadyCallback callback;
5173   gpointer user_data;
5174   const char *content;
5175   gsize length;
5176   gsize pos;
5177   char *etag;
5178 } ReplaceContentsData;
5179
5180 static void
5181 replace_contents_data_free (ReplaceContentsData *data)
5182 {
5183   if (data->error)
5184     g_error_free (data->error);
5185   if (data->cancellable)
5186     g_object_unref (data->cancellable);
5187   g_object_unref (data->file);
5188   g_free (data->etag);
5189   g_free (data);
5190 }
5191
5192 static void
5193 replace_contents_close_callback (GObject      *obj,
5194                                  GAsyncResult *close_res,
5195                                  gpointer      user_data)
5196 {
5197   GOutputStream *stream = G_OUTPUT_STREAM (obj);
5198   ReplaceContentsData *data = user_data;
5199   GSimpleAsyncResult *res;
5200
5201   /* Ignore errors here, we're only reading anyway */
5202   g_output_stream_close_finish (stream, close_res, NULL);
5203   g_object_unref (stream);
5204
5205   data->etag = g_file_output_stream_get_etag (G_FILE_OUTPUT_STREAM (stream));
5206
5207   res = g_simple_async_result_new (G_OBJECT (data->file),
5208                                    data->callback,
5209                                    data->user_data,
5210                                    g_file_replace_contents_async);
5211   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_contents_data_free);
5212   g_simple_async_result_complete (res);
5213   g_object_unref (res);
5214 }
5215
5216 static void
5217 replace_contents_write_callback (GObject      *obj,
5218                                  GAsyncResult *read_res,
5219                                  gpointer      user_data)
5220 {
5221   GOutputStream *stream = G_OUTPUT_STREAM (obj);
5222   ReplaceContentsData *data = user_data;
5223   GError *error = NULL;
5224   gssize write_size;
5225
5226   write_size = g_output_stream_write_finish (stream, read_res, &error);
5227
5228   if (write_size <= 0)
5229     {
5230       /* Error or EOF, close the file */
5231       if (write_size < 0)
5232         data->error = error;
5233       g_output_stream_close_async (stream, 0,
5234                                    data->cancellable,
5235                                    replace_contents_close_callback, data);
5236     }
5237   else if (write_size > 0)
5238     {
5239       data->pos += write_size;
5240
5241       if (data->pos >= data->length)
5242         g_output_stream_close_async (stream, 0,
5243                                      data->cancellable,
5244                                      replace_contents_close_callback, data);
5245       else
5246         g_output_stream_write_async (stream,
5247                                      data->content + data->pos,
5248                                      data->length - data->pos,
5249                                      0,
5250                                      data->cancellable,
5251                                      replace_contents_write_callback,
5252                                      data);
5253     }
5254 }
5255
5256 static void
5257 replace_contents_open_callback (GObject      *obj,
5258                                 GAsyncResult *open_res,
5259                                 gpointer      user_data)
5260 {
5261   GFile *file = G_FILE (obj);
5262   GFileOutputStream *stream;
5263   ReplaceContentsData *data = user_data;
5264   GError *error = NULL;
5265   GSimpleAsyncResult *res;
5266
5267   stream = g_file_replace_finish (file, open_res, &error);
5268
5269   if (stream)
5270     {
5271       g_output_stream_write_async (G_OUTPUT_STREAM (stream),
5272                                    data->content + data->pos,
5273                                    data->length - data->pos,
5274                                    0,
5275                                    data->cancellable,
5276                                    replace_contents_write_callback,
5277                                    data);
5278
5279     }
5280   else
5281     {
5282       res = g_simple_async_result_new_from_error (G_OBJECT (data->file),
5283                                                   data->callback,
5284                                                   data->user_data,
5285                                                   error);
5286       g_simple_async_result_complete (res);
5287       g_error_free (error);
5288       replace_contents_data_free (data);
5289       g_object_unref (res);
5290     }
5291 }
5292
5293 /**
5294  * g_file_replace_contents_async:
5295  * @file: input #GFile.
5296  * @contents: string of contents to replace the file with.
5297  * @length: the length of @contents in bytes.
5298  * @etag: a new <link linkend="gfile-etag">entity tag</link> for the @file.
5299  * @make_backup: %TRUE if a backup should be created.
5300  * @flags: a set of #GFileCreateFlags.
5301  * @cancellable: optional #GCancellable object, %NULL to ignore.
5302  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
5303  * @user_data: the data to pass to callback function
5304  *
5305  * Starts an asynchronous replacement of @file with the given
5306  * @contents of @length bytes. @etag will replace the document's
5307  * current entity tag.
5308  *
5309  * When this operation has completed, @callback will be called with
5310  * @user_user data, and the operation can be finalized with
5311  * g_file_replace_contents_finish().
5312  *
5313  * If @cancellable is not %NULL, then the operation can be cancelled by
5314  * triggering the cancellable object from another thread. If the operation
5315  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5316  *
5317  * If @make_backup is %TRUE, this function will attempt to
5318  * make a backup of @file.
5319  **/
5320 void
5321 g_file_replace_contents_async  (GFile               *file,
5322                                 const char          *contents,
5323                                 gsize                length,
5324                                 const char          *etag,
5325                                 gboolean             make_backup,
5326                                 GFileCreateFlags     flags,
5327                                 GCancellable        *cancellable,
5328                                 GAsyncReadyCallback  callback,
5329                                 gpointer             user_data)
5330 {
5331   ReplaceContentsData *data;
5332
5333   g_return_if_fail (G_IS_FILE (file));
5334   g_return_if_fail (contents != NULL);
5335
5336   data = g_new0 (ReplaceContentsData, 1);
5337
5338   if (cancellable)
5339     data->cancellable = g_object_ref (cancellable);
5340   data->callback = callback;
5341   data->user_data = user_data;
5342   data->content = contents;
5343   data->length = length;
5344   data->pos = 0;
5345   data->file = g_object_ref (file);
5346
5347   g_file_replace_async (file,
5348                         etag,
5349                         make_backup,
5350                         flags,
5351                         0,
5352                         cancellable,
5353                         replace_contents_open_callback,
5354                         data);
5355 }
5356
5357 /**
5358  * g_file_replace_contents_finish:
5359  * @file: input #GFile.
5360  * @res: a #GAsyncResult.
5361  * @new_etag: a location of a new <link linkend="gfile-etag">entity tag</link>
5362  *     for the document. This should be freed with g_free() when it is no
5363  *     longer needed.
5364  * @error: a #GError, or %NULL
5365  *
5366  * Finishes an asynchronous replace of the given @file. See
5367  * g_file_replace_contents_async(). Sets @new_etag to the new entity
5368  * tag for the document, if present.
5369  *
5370  * Returns: %TRUE on success, %FALSE on failure.
5371  **/
5372 gboolean
5373 g_file_replace_contents_finish (GFile         *file,
5374                                 GAsyncResult  *res,
5375                                 char         **new_etag,
5376                                 GError       **error)
5377 {
5378   GSimpleAsyncResult *simple;
5379   ReplaceContentsData *data;
5380
5381   g_return_val_if_fail (G_IS_FILE (file), FALSE);
5382   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
5383
5384   simple = G_SIMPLE_ASYNC_RESULT (res);
5385
5386   if (g_simple_async_result_propagate_error (simple, error))
5387     return FALSE;
5388
5389   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_replace_contents_async);
5390
5391   data = g_simple_async_result_get_op_res_gpointer (simple);
5392
5393   if (data->error)
5394     {
5395       g_propagate_error (error, data->error);
5396       data->error = NULL;
5397       return FALSE;
5398     }
5399
5400
5401   if (new_etag)
5402     {
5403       *new_etag = data->etag;
5404       data->etag = NULL; /* Take ownership */
5405     }
5406
5407   return TRUE;
5408 }
5409
5410 #define __G_FILE_C__
5411 #include "gioaliasdef.c"