gio/gfile.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2
   3 /* GIO - GLib Input, Output and Streaming Library
   4  *
   5  * Copyright (C) 2006-2007 Red Hat, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Author: Alexander Larsson <alexl@redhat.com>
  23  */
  24
  25 #include "config.h"
  26 #ifdef HAVE_SPLICE
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #endif
  32 #include <string.h>
  33 #include <sys/types.h>
  34 #ifdef HAVE_PWD_H
  35 #include <pwd.h>
  36 #endif
  37 #include "gfile.h"
  38 #include "gvfs.h"
  39 #include "gioscheduler.h"
  40 #include "gsimpleasyncresult.h"
  41 #include "gfileattribute-priv.h"
  42 #include "gfiledescriptorbased.h"
  43 #include "gpollfilemonitor.h"
  44 #include "gappinfo.h"
  45 #include "gfileinputstream.h"
  46 #include "gfileoutputstream.h"
  47 #include "gcancellable.h"
  48 #include "gasyncresult.h"
  49 #include "gioerror.h"
  50 #include "glibintl.h"
  51
  52
  53 /**
  54  * SECTION:gfile
  55  * @short_description: File and Directory Handling
  56  * @include: gio/gio.h
  57  * @see_also: #GFileInfo, #GFileEnumerator
  58  *
  59  * #GFile is a high level abstraction for manipulating files on a
  60  * virtual file system. #GFile<!-- -->s are lightweight, immutable
  61  * objects that do no I/O upon creation. It is necessary to understand that
  62  * #GFile objects do not represent files, merely an identifier for a file. All
  63  * file content I/O is implemented as streaming operations (see #GInputStream and
  64  * #GOutputStream).
  65  *
  66  * To construct a #GFile, you can use:
  67  * g_file_new_for_path() if you have a path.
  68  * g_file_new_for_uri() if you have a URI.
  69  * g_file_new_for_commandline_arg() for a command line argument.
  70  * g_file_parse_name() from a utf8 string gotten from g_file_get_parse_name().
  71  *
  72  * One way to think of a #GFile is as an abstraction of a pathname. For normal
  73  * files the system pathname is what is stored internally, but as #GFile<!-- -->s
  74  * are extensible it could also be something else that corresponds to a pathname
  75  * in a userspace implementation of a filesystem.
  76  *
  77  * #GFile<!-- -->s make up hierarchies of directories and files that correspond to the
  78  * files on a filesystem. You can move through the file system with #GFile using
  79  * g_file_get_parent() to get an identifier for the parent directory, g_file_get_child()
  80  * to get a child within a directory, g_file_resolve_relative_path() to resolve a relative
  81  * path between two #GFile<!-- -->s. There can be multiple hierarchies, so you may not
  82  * end up at the same root if you repeatedly call g_file_get_parent() on two different
  83  * files.
  84  *
  85  * All #GFile<!-- -->s have a basename (get with g_file_get_basename()). These names
  86  * are byte strings that are used to identify the file on the filesystem (relative to
  87  * its parent directory) and there is no guarantees that they have any particular charset
  88  * encoding or even make any sense at all. If you want to use filenames in a user
  89  * interface you should use the display name that you can get by requesting the
  90  * %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME attribute with g_file_query_info().
  91  * This is guaranteed to be in utf8 and can be used in a user interface. But always
  92  * store the real basename or the #GFile to use to actually access the file, because
  93  * there is no way to go from a display name to the actual name.
  94  *
  95  * Using #GFile as an identifier has the same weaknesses as using a path in that
  96  * there may be multiple aliases for the same file. For instance, hard or
  97  * soft links may cause two different #GFile<!-- -->s to refer to the same file.
  98  * Other possible causes for aliases are: case insensitive filesystems, short
  99  * and long names on Fat/NTFS, or bind mounts in Linux. If you want to check if
 100  * two #GFile<!-- -->s point to the same file you can query for the
 101  * %G_FILE_ATTRIBUTE_ID_FILE attribute. Note that #GFile does some trivial
 102  * canonicalization of pathnames passed in, so that trivial differences in the
 103  * path string used at creation (duplicated slashes, slash at end of path, "."
 104  * or ".." path segments, etc) does not create different #GFile<!-- -->s.
 105  *
 106  * Many #GFile operations have both synchronous and asynchronous versions
 107  * to suit your application. Asynchronous versions of synchronous functions
 108  * simply have _async() appended to their function names. The asynchronous
 109  * I/O functions call a #GAsyncReadyCallback which is then used to finalize
 110  * the operation, producing a GAsyncResult which is then passed to the
 111  * function's matching _finish() operation.
 112  *
 113  * Some #GFile operations do not have synchronous analogs, as they may
 114  * take a very long time to finish, and blocking may leave an application
 115  * unusable. Notable cases include:
 116  * g_file_mount_mountable() to mount a mountable file.
 117  * g_file_unmount_mountable_with_operation() to unmount a mountable file.
 118  * g_file_eject_mountable_with_operation() to eject a mountable file.
 119  *
 120  * <para id="gfile-etag"><indexterm><primary>entity tag</primary></indexterm>
 121  * One notable feature of #GFile<!-- -->s are entity tags, or "etags" for
 122  * short. Entity tags are somewhat like a more abstract version of the
 123  * traditional mtime, and can be used to quickly determine if the file has
 124  * been modified from the version on the file system. See the HTTP 1.1
 125  * <ulink url="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html">specification</ulink>
 126  * for HTTP Etag headers, which are a very similar concept.
 127  * </para>
 128  **/
 129
 130 static void               g_file_real_query_info_async            (GFile                  *file,
 131                                                                    const char             *attributes,
 132                                                                    GFileQueryInfoFlags     flags,
 133                                                                    int                     io_priority,
 134                                                                    GCancellable           *cancellable,
 135                                                                    GAsyncReadyCallback     callback,
 136                                                                    gpointer                user_data);
 137 static GFileInfo *        g_file_real_query_info_finish           (GFile                  *file,
 138                                                                    GAsyncResult           *res,
 139                                                                    GError                **error);
 140 static void               g_file_real_query_filesystem_info_async (GFile                  *file,
 141                                                                    const char             *attributes,
 142                                                                    int                     io_priority,
 143                                                                    GCancellable           *cancellable,
 144                                                                    GAsyncReadyCallback     callback,
 145                                                                    gpointer                user_data);
 146 static GFileInfo *        g_file_real_query_filesystem_info_finish (GFile                  *file,
 147                                                                    GAsyncResult           *res,
 148                                                                    GError                **error);
 149 static void               g_file_real_enumerate_children_async    (GFile                  *file,
 150                                                                    const char             *attributes,
 151                                                                    GFileQueryInfoFlags     flags,
 152                                                                    int                     io_priority,
 153                                                                    GCancellable           *cancellable,
 154                                                                    GAsyncReadyCallback     callback,
 155                                                                    gpointer                user_data);
 156 static GFileEnumerator *  g_file_real_enumerate_children_finish   (GFile                  *file,
 157                                                                    GAsyncResult           *res,
 158                                                                    GError                **error);
 159 static void               g_file_real_read_async                  (GFile                  *file,
 160                                                                    int                     io_priority,
 161                                                                    GCancellable           *cancellable,
 162                                                                    GAsyncReadyCallback     callback,
 163                                                                    gpointer                user_data);
 164 static GFileInputStream * g_file_real_read_finish                 (GFile                  *file,
 165                                                                    GAsyncResult           *res,
 166                                                                    GError                **error);
 167 static void               g_file_real_append_to_async             (GFile                  *file,
 168                                                                    GFileCreateFlags        flags,
 169                                                                    int                     io_priority,
 170                                                                    GCancellable           *cancellable,
 171                                                                    GAsyncReadyCallback     callback,
 172                                                                    gpointer                user_data);
 173 static GFileOutputStream *g_file_real_append_to_finish            (GFile                  *file,
 174                                                                    GAsyncResult           *res,
 175                                                                    GError                **error);
 176 static void               g_file_real_create_async                (GFile                  *file,
 177                                                                    GFileCreateFlags        flags,
 178                                                                    int                     io_priority,
 179                                                                    GCancellable           *cancellable,
 180                                                                    GAsyncReadyCallback     callback,
 181                                                                    gpointer                user_data);
 182 static GFileOutputStream *g_file_real_create_finish               (GFile                  *file,
 183                                                                    GAsyncResult           *res,
 184                                                                    GError                **error);
 185 static void               g_file_real_replace_async               (GFile                  *file,
 186                                                                    const char             *etag,
 187                                                                    gboolean                make_backup,
 188                                                                    GFileCreateFlags        flags,
 189                                                                    int                     io_priority,
 190                                                                    GCancellable           *cancellable,
 191                                                                    GAsyncReadyCallback     callback,
 192                                                                    gpointer                user_data);
 193 static GFileOutputStream *g_file_real_replace_finish              (GFile                  *file,
 194                                                                    GAsyncResult           *res,
 195                                                                    GError                **error);
 196 static void               g_file_real_open_readwrite_async        (GFile                  *file,
 197                                                                    int                  io_priority,
 198                                                                    GCancellable           *cancellable,
 199                                                                    GAsyncReadyCallback     callback,
 200                                                                    gpointer                user_data);
 201 static GFileIOStream *    g_file_real_open_readwrite_finish       (GFile                  *file,
 202                                                                    GAsyncResult           *res,
 203                                                                    GError                **error);
 204 static void               g_file_real_create_readwrite_async      (GFile                  *file,
 205                                                                    GFileCreateFlags        flags,
 206                                                                    int                     io_priority,
 207                                                                    GCancellable           *cancellable,
 208                                                                    GAsyncReadyCallback     callback,
 209                                                                    gpointer                user_data);
 210 static GFileIOStream *    g_file_real_create_readwrite_finish     (GFile                  *file,
 211                                                                    GAsyncResult           *res,
 212                                                                    GError                **error);
 213 static void               g_file_real_replace_readwrite_async     (GFile                  *file,
 214                                                                    const char             *etag,
 215                                                                    gboolean                make_backup,
 216                                                                    GFileCreateFlags        flags,
 217                                                                    int                     io_priority,
 218                                                                    GCancellable           *cancellable,
 219                                                                    GAsyncReadyCallback     callback,
 220                                                                    gpointer                user_data);
 221 static GFileIOStream *    g_file_real_replace_readwrite_finish    (GFile                  *file,
 222                                                                   GAsyncResult            *res,
 223                                                                   GError                 **error);
 224 static gboolean           g_file_real_set_attributes_from_info    (GFile                  *file,
 225                                                                    GFileInfo              *info,
 226                                                                    GFileQueryInfoFlags     flags,
 227                                                                    GCancellable           *cancellable,
 228                                                                    GError                **error);
 229 static void               g_file_real_set_display_name_async      (GFile                  *file,
 230                                                                    const char             *display_name,
 231                                                                    int                     io_priority,
 232                                                                    GCancellable           *cancellable,
 233                                                                    GAsyncReadyCallback     callback,
 234                                                                    gpointer                user_data);
 235 static GFile *            g_file_real_set_display_name_finish     (GFile                  *file,
 236                                                                    GAsyncResult           *res,
 237                                                                    GError                **error);
 238 static void               g_file_real_set_attributes_async        (GFile                  *file,
 239                                                                    GFileInfo              *info,
 240                                                                    GFileQueryInfoFlags     flags,
 241                                                                    int                     io_priority,
 242                                                                    GCancellable           *cancellable,
 243                                                                    GAsyncReadyCallback     callback,
 244                                                                    gpointer                user_data);
 245 static gboolean           g_file_real_set_attributes_finish       (GFile                  *file,
 246                                                                    GAsyncResult           *res,
 247                                                                    GFileInfo             **info,
 248                                                                    GError                **error);
 249 static void               g_file_real_find_enclosing_mount_async  (GFile                  *file,
 250                                                                    int                     io_priority,
 251                                                                    GCancellable           *cancellable,
 252                                                                    GAsyncReadyCallback     callback,
 253                                                                    gpointer                user_data);
 254 static GMount *           g_file_real_find_enclosing_mount_finish (GFile                  *file,
 255                                                                    GAsyncResult           *res,
 256                                                                    GError                **error);
 257 static void               g_file_real_copy_async                  (GFile                  *source,
 258                                                                    GFile                  *destination,
 259                                                                    GFileCopyFlags          flags,
 260                                                                    int                     io_priority,
 261                                                                    GCancellable           *cancellable,
 262                                                                    GFileProgressCallback   progress_callback,
 263                                                                    gpointer                progress_callback_data,
 264                                                                    GAsyncReadyCallback     callback,
 265                                                                    gpointer                user_data);
 266 static gboolean           g_file_real_copy_finish                 (GFile                  *file,
 267                                                                    GAsyncResult           *res,
 268                                                                    GError                **error);
 269
 270 typedef GFileIface GFileInterface;
 271 G_DEFINE_INTERFACE (GFile, g_file, G_TYPE_OBJECT)
 272
 273 static void
 274 g_file_default_init (GFileIface *iface)
 275 {
 276   iface->enumerate_children_async = g_file_real_enumerate_children_async;
 277   iface->enumerate_children_finish = g_file_real_enumerate_children_finish;
 278   iface->set_display_name_async = g_file_real_set_display_name_async;
 279   iface->set_display_name_finish = g_file_real_set_display_name_finish;
 280   iface->query_info_async = g_file_real_query_info_async;
 281   iface->query_info_finish = g_file_real_query_info_finish;
 282   iface->query_filesystem_info_async = g_file_real_query_filesystem_info_async;
 283   iface->query_filesystem_info_finish = g_file_real_query_filesystem_info_finish;
 284   iface->set_attributes_async = g_file_real_set_attributes_async;
 285   iface->set_attributes_finish = g_file_real_set_attributes_finish;
 286   iface->read_async = g_file_real_read_async;
 287   iface->read_finish = g_file_real_read_finish;
 288   iface->append_to_async = g_file_real_append_to_async;
 289   iface->append_to_finish = g_file_real_append_to_finish;
 290   iface->create_async = g_file_real_create_async;
 291   iface->create_finish = g_file_real_create_finish;
 292   iface->replace_async = g_file_real_replace_async;
 293   iface->replace_finish = g_file_real_replace_finish;
 294   iface->open_readwrite_async = g_file_real_open_readwrite_async;
 295   iface->open_readwrite_finish = g_file_real_open_readwrite_finish;
 296   iface->create_readwrite_async = g_file_real_create_readwrite_async;
 297   iface->create_readwrite_finish = g_file_real_create_readwrite_finish;
 298   iface->replace_readwrite_async = g_file_real_replace_readwrite_async;
 299   iface->replace_readwrite_finish = g_file_real_replace_readwrite_finish;
 300   iface->find_enclosing_mount_async = g_file_real_find_enclosing_mount_async;
 301   iface->find_enclosing_mount_finish = g_file_real_find_enclosing_mount_finish;
 302   iface->set_attributes_from_info = g_file_real_set_attributes_from_info;
 303   iface->copy_async = g_file_real_copy_async;
 304   iface->copy_finish = g_file_real_copy_finish;
 305 }
 306
 307
 308 /**
 309  * g_file_is_native:
 310  * @file: input #GFile.
 311  *
 312  * Checks to see if a file is native to the platform.
 313  *
 314  * A native file s one expressed in the platform-native filename format,
 315  * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
 316  * as it might be on a locally mounted remote filesystem.
 317  *
 318  * On some systems non-native files may be available using
 319  * the native filesystem via a userspace filesystem (FUSE), in
 320  * these cases this call will return %FALSE, but g_file_get_path()
 321  * will still return a native path.
 322  *
 323  * This call does no blocking i/o.
 324  *
 325  * Returns: %TRUE if file is native.
 326  **/
 327 gboolean
 328 g_file_is_native (GFile *file)
 329 {
 330   GFileIface *iface;
 331
 332   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 333
 334   iface = G_FILE_GET_IFACE (file);
 335
 336   return (* iface->is_native) (file);
 337 }
 338
 339
 340 /**
 341  * g_file_has_uri_scheme:
 342  * @file: input #GFile.
 343  * @uri_scheme: a string containing a URI scheme.
 344  *
 345  * Checks to see if a #GFile has a given URI scheme.
 346  *
 347  * This call does no blocking i/o.
 348  *
 349  * Returns: %TRUE if #GFile's backend supports the
 350  *     given URI scheme, %FALSE if URI scheme is %NULL,
 351  *     not supported, or #GFile is invalid.
 352  **/
 353 gboolean
 354 g_file_has_uri_scheme (GFile      *file,
 355                        const char *uri_scheme)
 356 {
 357   GFileIface *iface;
 358
 359   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 360   g_return_val_if_fail (uri_scheme != NULL, FALSE);
 361
 362   iface = G_FILE_GET_IFACE (file);
 363
 364   return (* iface->has_uri_scheme) (file, uri_scheme);
 365 }
 366
 367
 368 /**
 369  * g_file_get_uri_scheme:
 370  * @file: input #GFile.
 371  *
 372  * Gets the URI scheme for a #GFile.
 373  * RFC 3986 decodes the scheme as:
 374  * <programlisting>
 375  * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 376  * </programlisting>
 377  * Common schemes include "file", "http", "ftp", etc.
 378  *
 379  * This call does no blocking i/o.
 380  *
 381  * Returns: a string containing the URI scheme for the given
 382  *     #GFile. The returned string should be freed with g_free()
 383  *     when no longer needed.
 384  **/
 385 char *
 386 g_file_get_uri_scheme (GFile *file)
 387 {
 388   GFileIface *iface;
 389
 390   g_return_val_if_fail (G_IS_FILE (file), NULL);
 391
 392   iface = G_FILE_GET_IFACE (file);
 393
 394   return (* iface->get_uri_scheme) (file);
 395 }
 396
 397
 398 /**
 399  * g_file_get_basename:
 400  * @file: input #GFile.
 401  *
 402  * Gets the base name (the last component of the path) for a given #GFile.
 403  *
 404  * If called for the top level of a system (such as the filesystem root
 405  * or a uri like sftp://host/) it will return a single directory separator
 406  * (and on Windows, possibly a drive letter).
 407  *
 408  * The base name is a byte string (*not* UTF-8). It has no defined encoding
 409  * or rules other than it may not contain zero bytes.  If you want to use
 410  * filenames in a user interface you should use the display name that you
 411  * can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
 412  * attribute with g_file_query_info().
 413  *
 414  * This call does no blocking i/o.
 415  *
 416  * Returns: string containing the #GFile's base name, or %NULL
 417  *     if given #GFile is invalid. The returned string should be
 418  *     freed with g_free() when no longer needed.
 419  **/
 420 char *
 421 g_file_get_basename (GFile *file)
 422 {
 423   GFileIface *iface;
 424
 425   g_return_val_if_fail (G_IS_FILE (file), NULL);
 426
 427   iface = G_FILE_GET_IFACE (file);
 428
 429   return (* iface->get_basename) (file);
 430 }
 431
 432 /**
 433  * g_file_get_path:
 434  * @file: input #GFile.
 435  *
 436  * Gets the local pathname for #GFile, if one exists.
 437  *
 438  * This call does no blocking i/o.
 439  *
 440  * Returns: string containing the #GFile's path, or %NULL if
 441  *     no such path exists. The returned string should be
 442  *     freed with g_free() when no longer needed.
 443  **/
 444 char *
 445 g_file_get_path (GFile *file)
 446 {
 447   GFileIface *iface;
 448
 449   g_return_val_if_fail (G_IS_FILE (file), NULL);
 450
 451   iface = G_FILE_GET_IFACE (file);
 452
 453   return (* iface->get_path) (file);
 454 }
 455
 456 /**
 457  * g_file_get_uri:
 458  * @file: input #GFile.
 459  *
 460  * Gets the URI for the @file.
 461  *
 462  * This call does no blocking i/o.
 463  *
 464  * Returns: a string containing the #GFile's URI.
 465  *     The returned string should be freed with g_free() when no longer needed.
 466  **/
 467 char *
 468 g_file_get_uri (GFile *file)
 469 {
 470   GFileIface *iface;
 471
 472   g_return_val_if_fail (G_IS_FILE (file), NULL);
 473
 474   iface = G_FILE_GET_IFACE (file);
 475
 476   return (* iface->get_uri) (file);
 477 }
 478
 479 /**
 480  * g_file_get_parse_name:
 481  * @file: input #GFile.
 482  *
 483  * Gets the parse name of the @file.
 484  * A parse name is a UTF-8 string that describes the
 485  * file such that one can get the #GFile back using
 486  * g_file_parse_name().
 487  *
 488  * This is generally used to show the #GFile as a nice
 489  * full-pathname kind of string in a user interface,
 490  * like in a location entry.
 491  *
 492  * For local files with names that can safely be converted
 493  * to UTF8 the pathname is used, otherwise the IRI is used
 494  * (a form of URI that allows UTF8 characters unescaped).
 495  *
 496  * This call does no blocking i/o.
 497  *
 498  * Returns: a string containing the #GFile's parse name. The returned
 499  *     string should be freed with g_free() when no longer needed.
 500  **/
 501 char *
 502 g_file_get_parse_name (GFile *file)
 503 {
 504   GFileIface *iface;
 505
 506   g_return_val_if_fail (G_IS_FILE (file), NULL);
 507
 508   iface = G_FILE_GET_IFACE (file);
 509
 510   return (* iface->get_parse_name) (file);
 511 }
 512
 513 /**
 514  * g_file_dup:
 515  * @file: input #GFile.
 516  *
 517  * Duplicates a #GFile handle. This operation does not duplicate
 518  * the actual file or directory represented by the #GFile; see
 519  * g_file_copy() if attempting to copy a file.
 520  *
 521  * This call does no blocking i/o.
 522  *
 523  * Returns: (transfer full): a new #GFile that is a duplicate of the given #GFile.
 524  **/
 525 GFile *
 526 g_file_dup (GFile *file)
 527 {
 528   GFileIface *iface;
 529
 530   g_return_val_if_fail (G_IS_FILE (file), NULL);
 531
 532   iface = G_FILE_GET_IFACE (file);
 533
 534   return (* iface->dup) (file);
 535 }
 536
 537 /**
 538  * g_file_hash:
 539  * @file: (type GFile): #gconstpointer to a #GFile.
 540  *
 541  * Creates a hash value for a #GFile.
 542  *
 543  * This call does no blocking i/o.
 544  *
 545  * Virtual: hash
 546  * Returns: 0 if @file is not a valid #GFile, otherwise an
 547  *     integer that can be used as hash value for the #GFile.
 548  *     This function is intended for easily hashing a #GFile to
 549  *     add to a #GHashTable or similar data structure.
 550  **/
 551 guint
 552 g_file_hash (gconstpointer file)
 553 {
 554   GFileIface *iface;
 555
 556   g_return_val_if_fail (G_IS_FILE (file), 0);
 557
 558   iface = G_FILE_GET_IFACE (file);
 559
 560   return (* iface->hash) ((GFile *)file);
 561 }
 562
 563 /**
 564  * g_file_equal:
 565  * @file1: the first #GFile.
 566  * @file2: the second #GFile.
 567  *
 568  * Checks equality of two given #GFile<!-- -->s. Note that two
 569  * #GFile<!-- -->s that differ can still refer to the same
 570  * file on the filesystem due to various forms of filename
 571  * aliasing.
 572  *
 573  * This call does no blocking i/o.
 574  *
 575  * Returns: %TRUE if @file1 and @file2 are equal.
 576  *     %FALSE if either is not a #GFile.
 577  **/
 578 gboolean
 579 g_file_equal (GFile *file1,
 580               GFile *file2)
 581 {
 582   GFileIface *iface;
 583
 584   g_return_val_if_fail (G_IS_FILE (file1), FALSE);
 585   g_return_val_if_fail (G_IS_FILE (file2), FALSE);
 586
 587   if (G_TYPE_FROM_INSTANCE (file1) != G_TYPE_FROM_INSTANCE (file2))
 588     return FALSE;
 589
 590   iface = G_FILE_GET_IFACE (file1);
 591
 592   return (* iface->equal) (file1, file2);
 593 }
 594
 595
 596 /**
 597  * g_file_get_parent:
 598  * @file: input #GFile.
 599  *
 600  * Gets the parent directory for the @file.
 601  * If the @file represents the root directory of the
 602  * file system, then %NULL will be returned.
 603  *
 604  * This call does no blocking i/o.
 605  *
 606  * Returns: (transfer full): a #GFile structure to the parent of the given
 607  *     #GFile or %NULL if there is no parent.
 608  *     Free the returned object with g_object_unref().
 609  **/
 610 GFile *
 611 g_file_get_parent (GFile *file)
 612 {
 613   GFileIface *iface;
 614
 615   g_return_val_if_fail (G_IS_FILE (file), NULL);
 616
 617   iface = G_FILE_GET_IFACE (file);
 618
 619   return (* iface->get_parent) (file);
 620 }
 621
 622 /**
 623  * g_file_has_parent:
 624  * @file: input #GFile
 625  * @parent: the parent to check for, or %NULL
 626  *
 627  * Checks if @file has a parent, and optionally, if it is @parent.
 628  *
 629  * If @parent is %NULL then this function returns %TRUE if @file has any
 630  * parent at all.  If @parent is non-%NULL then %TRUE is only returned
 631  * if @file is a child of @parent.
 632  *
 633  * Returns: %TRUE if @file is a child of @parent (or any parent in the
 634  *          case that @parent is %NULL).
 635  *
 636  * Since: 2.24
 637  **/
 638 gboolean
 639 g_file_has_parent (GFile *file,
 640                    GFile *parent)
 641 {
 642   GFile *actual_parent;
 643   gboolean result;
 644
 645   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 646   g_return_val_if_fail (parent == NULL || G_IS_FILE (parent), FALSE);
 647
 648   actual_parent = g_file_get_parent (file);
 649
 650   if (actual_parent != NULL)
 651     {
 652       if (parent != NULL)
 653         result = g_file_equal (parent, actual_parent);
 654       else
 655         result = TRUE;
 656
 657       g_object_unref (actual_parent);
 658     }
 659   else
 660     result = FALSE;
 661
 662   return result;
 663 }
 664
 665 /**
 666  * g_file_get_child:
 667  * @file: input #GFile.
 668  * @name: string containing the child's basename.
 669  *
 670  * Gets a child of @file with basename equal to @name.
 671  *
 672  * Note that the file with that specific name might not exist, but
 673  * you can still have a #GFile that points to it. You can use this
 674  * for instance to create that file.
 675  *
 676  * This call does no blocking i/o.
 677  *
 678  * Returns: (transfer full): a #GFile to a child specified by @name.
 679  *     Free the returned object with g_object_unref().
 680  **/
 681 GFile *
 682 g_file_get_child (GFile      *file,
 683                   const char *name)
 684 {
 685   g_return_val_if_fail (G_IS_FILE (file), NULL);
 686   g_return_val_if_fail (name != NULL, NULL);
 687
 688   return g_file_resolve_relative_path (file, name);
 689 }
 690
 691 /**
 692  * g_file_get_child_for_display_name:
 693  * @file: input #GFile.
 694  * @display_name: string to a possible child.
 695  * @error: #GError.
 696  *
 697  * Gets the child of @file for a given @display_name (i.e. a UTF8
 698  * version of the name). If this function fails, it returns %NULL and @error will be
 699  * set. This is very useful when constructing a GFile for a new file
 700  * and the user entered the filename in the user interface, for instance
 701  * when you select a directory and type a filename in the file selector.
 702  *
 703  * This call does no blocking i/o.
 704  *
 705  * Returns: (transfer full): a #GFile to the specified child, or
 706  *     %NULL if the display name couldn't be converted.
 707  *     Free the returned object with g_object_unref().
 708  **/
 709 GFile *
 710 g_file_get_child_for_display_name (GFile      *file,
 711                                    const char *display_name,
 712                                    GError **error)
 713 {
 714   GFileIface *iface;
 715
 716   g_return_val_if_fail (G_IS_FILE (file), NULL);
 717   g_return_val_if_fail (display_name != NULL, NULL);
 718
 719   iface = G_FILE_GET_IFACE (file);
 720
 721   return (* iface->get_child_for_display_name) (file, display_name, error);
 722 }
 723
 724 /**
 725  * g_file_has_prefix:
 726  * @file: input #GFile.
 727  * @prefix: input #GFile.
 728  *
 729  * Checks whether @file has the prefix specified by @prefix. In other word,
 730  * if the names of initial elements of @file<!-- -->s pathname match @prefix.
 731  * Only full pathname elements are matched, so a path like /foo is not
 732  * considered a prefix of /foobar, only of /foo/bar.
 733  *
 734  * This call does no i/o, as it works purely on names. As such it can
 735  * sometimes return %FALSE even if @file is inside a @prefix (from a
 736  * filesystem point of view), because the prefix of @file is an alias
 737  * of @prefix.
 738  *
 739  * Virtual: prefix_matches
 740  * Returns:  %TRUE if the @files's parent, grandparent, etc is @prefix.
 741  *     %FALSE otherwise.
 742  **/
 743 gboolean
 744 g_file_has_prefix (GFile *file,
 745                    GFile *prefix)
 746 {
 747   GFileIface *iface;
 748
 749   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 750   g_return_val_if_fail (G_IS_FILE (prefix), FALSE);
 751
 752   if (G_TYPE_FROM_INSTANCE (file) != G_TYPE_FROM_INSTANCE (prefix))
 753     return FALSE;
 754
 755   iface = G_FILE_GET_IFACE (file);
 756
 757   /* The vtable function differs in arg order since we're
 758      using the old contains_file call */
 759   return (* iface->prefix_matches) (prefix, file);
 760 }
 761
 762 /**
 763  * g_file_get_relative_path:
 764  * @parent: input #GFile.
 765  * @descendant: input #GFile.
 766  *
 767  * Gets the path for @descendant relative to @parent.
 768  *
 769  * This call does no blocking i/o.
 770  *
 771  * Returns: string with the relative path from @descendant
 772  *     to @parent, or %NULL if @descendant doesn't have @parent as prefix.
 773  *     The returned string should be freed with g_free() when no longer needed.
 774  **/
 775 char *
 776 g_file_get_relative_path (GFile *parent,
 777                           GFile *descendant)
 778 {
 779   GFileIface *iface;
 780
 781   g_return_val_if_fail (G_IS_FILE (parent), NULL);
 782   g_return_val_if_fail (G_IS_FILE (descendant), NULL);
 783
 784   if (G_TYPE_FROM_INSTANCE (parent) != G_TYPE_FROM_INSTANCE (descendant))
 785     return NULL;
 786
 787   iface = G_FILE_GET_IFACE (parent);
 788
 789   return (* iface->get_relative_path) (parent, descendant);
 790 }
 791
 792 /**
 793  * g_file_resolve_relative_path:
 794  * @file: input #GFile.
 795  * @relative_path: a given relative path string.
 796  *
 797  * Resolves a relative path for @file to an absolute path.
 798  *
 799  * This call does no blocking i/o.
 800  *
 801  * Returns: (transfer full): #GFile to the resolved path. %NULL if @relative_path
 802  *     is %NULL or if @file is invalid.
 803  *     Free the returned object with g_object_unref().
 804  **/
 805 GFile *
 806 g_file_resolve_relative_path (GFile      *file,
 807                               const char *relative_path)
 808 {
 809   GFileIface *iface;
 810
 811   g_return_val_if_fail (G_IS_FILE (file), NULL);
 812   g_return_val_if_fail (relative_path != NULL, NULL);
 813
 814   iface = G_FILE_GET_IFACE (file);
 815
 816   return (* iface->resolve_relative_path) (file, relative_path);
 817 }
 818
 819 /**
 820  * g_file_enumerate_children:
 821  * @file: input #GFile.
 822  * @attributes: an attribute query string.
 823  * @flags: a set of #GFileQueryInfoFlags.
 824  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 825  * @error: #GError for error reporting.
 826  *
 827  * Gets the requested information about the files in a directory. The result
 828  * is a #GFileEnumerator object that will give out #GFileInfo objects for
 829  * all the files in the directory.
 830  *
 831  * The @attributes value is a string that specifies the file attributes that
 832  * should be gathered. It is not an error if it's not possible to read a particular
 833  * requested attribute from a file - it just won't be set. @attributes should
 834  * be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
 835  * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
 836  * namespace. An example attribute query be "standard::*,owner::user".
 837  * The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
 838  *
 839  * If @cancellable is not %NULL, then the operation can be cancelled by
 840  * triggering the cancellable object from another thread. If the operation
 841  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
 842  *
 843  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
 844  * If the file is not a directory, the G_FILE_ERROR_NOTDIR error will be returned.
 845  * Other errors are possible too.
 846  *
 847  * Returns: (transfer full): A #GFileEnumerator if successful, %NULL on error.
 848  *     Free the returned object with g_object_unref().
 849  **/
 850 GFileEnumerator *
 851 g_file_enumerate_children (GFile                *file,
 852                            const char           *attributes,
 853                            GFileQueryInfoFlags   flags,
 854                            GCancellable         *cancellable,
 855                            GError              **error)
 856
 857 {
 858   GFileIface *iface;
 859
 860   g_return_val_if_fail (G_IS_FILE (file), NULL);
 861
 862   if (g_cancellable_set_error_if_cancelled (cancellable, error))
 863     return NULL;
 864
 865   iface = G_FILE_GET_IFACE (file);
 866
 867   if (iface->enumerate_children == NULL)
 868     {
 869       g_set_error_literal (error, G_IO_ERROR,
 870                            G_IO_ERROR_NOT_SUPPORTED,
 871                            _("Operation not supported"));
 872       return NULL;
 873     }
 874
 875   return (* iface->enumerate_children) (file, attributes, flags,
 876                                         cancellable, error);
 877 }
 878
 879 /**
 880  * g_file_enumerate_children_async:
 881  * @file: input #GFile.
 882  * @attributes: an attribute query string.
 883  * @flags: a set of #GFileQueryInfoFlags.
 884  * @io_priority: the <link linkend="io-priority">I/O priority</link>
 885  *     of the request.
 886  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 887  * @callback: (scope async): a #GAsyncReadyCallback to call when the
 888  *     request is satisfied
 889  * @user_data: (closure): the data to pass to callback function
 890  *
 891  * Asynchronously gets the requested information about the files in a directory. The result
 892  * is a #GFileEnumerator object that will give out #GFileInfo objects for
 893  * all the files in the directory.
 894  *
 895  * For more details, see g_file_enumerate_children() which is
 896  * the synchronous version of this call.
 897  *
 898  * When the operation is finished, @callback will be called. You can then call
 899  * g_file_enumerate_children_finish() to get the result of the operation.
 900  **/
 901 void
 902 g_file_enumerate_children_async (GFile               *file,
 903                                  const char          *attributes,
 904                                  GFileQueryInfoFlags  flags,
 905                                  int                  io_priority,
 906                                  GCancellable        *cancellable,
 907                                  GAsyncReadyCallback  callback,
 908                                  gpointer             user_data)
 909 {
 910   GFileIface *iface;
 911
 912   g_return_if_fail (G_IS_FILE (file));
 913
 914   iface = G_FILE_GET_IFACE (file);
 915   (* iface->enumerate_children_async) (file,
 916                                        attributes,
 917                                        flags,
 918                                        io_priority,
 919                                        cancellable,
 920                                        callback,
 921                                        user_data);
 922 }
 923
 924 /**
 925  * g_file_enumerate_children_finish:
 926  * @file: input #GFile.
 927  * @res: a #GAsyncResult.
 928  * @error: a #GError.
 929  *
 930  * Finishes an async enumerate children operation.
 931  * See g_file_enumerate_children_async().
 932  *
 933  * Returns: (transfer full): a #GFileEnumerator or %NULL if an error occurred.
 934  *     Free the returned object with g_object_unref().
 935  **/
 936 GFileEnumerator *
 937 g_file_enumerate_children_finish (GFile         *file,
 938                                   GAsyncResult  *res,
 939                                   GError       **error)
 940 {
 941   GFileIface *iface;
 942
 943   g_return_val_if_fail (G_IS_FILE (file), NULL);
 944   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
 945
 946   if (G_IS_SIMPLE_ASYNC_RESULT (res))
 947     {
 948       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
 949       if (g_simple_async_result_propagate_error (simple, error))
 950         return NULL;
 951     }
 952
 953   iface = G_FILE_GET_IFACE (file);
 954   return (* iface->enumerate_children_finish) (file, res, error);
 955 }
 956
 957 /**
 958  * g_file_query_exists:
 959  * @file: input #GFile.
 960  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 961  *
 962  * Utility function to check if a particular file exists. This is
 963  * implemented using g_file_query_info() and as such does blocking I/O.
 964  *
 965  * Note that in many cases it is racy to first check for file existence
 966  * and then execute something based on the outcome of that, because the
 967  * file might have been created or removed in between the operations. The
 968  * general approach to handling that is to not check, but just do the
 969  * operation and handle the errors as they come.
 970  *
 971  * As an example of race-free checking, take the case of reading a file, and
 972  * if it doesn't exist, creating it. There are two racy versions: read it, and
 973  * on error create it; and: check if it exists, if not create it. These
 974  * can both result in two processes creating the file (with perhaps a partially
 975  * written file as the result). The correct approach is to always try to create
 976  * the file with g_file_create() which will either atomically create the file
 977  * or fail with a G_IO_ERROR_EXISTS error.
 978  *
 979  * However, in many cases an existence check is useful in a user
 980  * interface, for instance to make a menu item sensitive/insensitive, so that
 981  * you don't have to fool users that something is possible and then just show
 982  * and error dialog. If you do this, you should make sure to also handle the
 983  * errors that can happen due to races when you execute the operation.
 984  *
 985  * Returns: %TRUE if the file exists (and can be detected without error), %FALSE otherwise (or if cancelled).
 986  */
 987 gboolean
 988 g_file_query_exists (GFile *file,
 989                      GCancellable *cancellable)
 990 {
 991   GFileInfo *info;
 992
 993   g_return_val_if_fail (G_IS_FILE(file), FALSE);
 994
 995   info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE,
 996                             G_FILE_QUERY_INFO_NONE, cancellable, NULL);
 997   if (info != NULL)
 998     {
 999       g_object_unref (info);
1000       return TRUE;
1001     }
1002
1003   return FALSE;
1004 }
1005
1006 /**
1007  * g_file_query_file_type:
1008  * @file: input #GFile.
1009  * @flags: a set of #GFileQueryInfoFlags passed to g_file_query_info().
1010  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1011  *
1012  * Utility function to inspect the #GFileType of a file. This is
1013  * implemented using g_file_query_info() and as such does blocking I/O.
1014  *
1015  * The primary use case of this method is to check if a file is a regular file,
1016  * directory, or symlink.
1017  *
1018  * Returns: The #GFileType of the file and #G_FILE_TYPE_UNKNOWN if the file
1019  *          does not exist
1020  *
1021  * Since: 2.18
1022  */
1023 GFileType
1024 g_file_query_file_type (GFile *file,
1025                         GFileQueryInfoFlags   flags,
1026                         GCancellable *cancellable)
1027 {
1028   GFileInfo *info;
1029   GFileType file_type;
1030
1031   g_return_val_if_fail (G_IS_FILE(file), G_FILE_TYPE_UNKNOWN);
1032   info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, flags,
1033                             cancellable, NULL);
1034   if (info != NULL)
1035     {
1036       file_type = g_file_info_get_file_type (info);
1037       g_object_unref (info);
1038     }
1039   else
1040     file_type = G_FILE_TYPE_UNKNOWN;
1041
1042   return file_type;
1043 }
1044
1045 /**
1046  * g_file_query_info:
1047  * @file: input #GFile.
1048  * @attributes: an attribute query string.
1049  * @flags: a set of #GFileQueryInfoFlags.
1050  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1051  * @error: a #GError.
1052  *
1053  * Gets the requested information about specified @file. The result
1054  * is a #GFileInfo object that contains key-value attributes (such as
1055  * the type or size of the file).
1056  *
1057  * The @attributes value is a string that specifies the file attributes that
1058  * should be gathered. It is not an error if it's not possible to read a particular
1059  * requested attribute from a file - it just won't be set. @attributes should
1060  * be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
1061  * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
1062  * namespace. An example attribute query be "standard::*,owner::user".
1063  * The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
1064  *
1065  * If @cancellable is not %NULL, then the operation can be cancelled by
1066  * triggering the cancellable object from another thread. If the operation
1067  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1068  *
1069  * For symlinks, normally the information about the target of the
1070  * symlink is returned, rather than information about the symlink itself.
1071  * However if you pass #G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in @flags the
1072  * information about the symlink itself will be returned. Also, for symlinks
1073  * that point to non-existing files the information about the symlink itself
1074  * will be returned.
1075  *
1076  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1077  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1078  *
1079  * Returns: (transfer full): a #GFileInfo for the given @file, or %NULL on error.
1080  *     Free the returned object with g_object_unref().
1081  **/
1082 GFileInfo *
1083 g_file_query_info (GFile                *file,
1084                    const char           *attributes,
1085                    GFileQueryInfoFlags   flags,
1086                    GCancellable         *cancellable,
1087                    GError              **error)
1088 {
1089   GFileIface *iface;
1090
1091   g_return_val_if_fail (G_IS_FILE (file), NULL);
1092
1093   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1094     return NULL;
1095
1096   iface = G_FILE_GET_IFACE (file);
1097
1098   if (iface->query_info == NULL)
1099     {
1100       g_set_error_literal (error, G_IO_ERROR,
1101                            G_IO_ERROR_NOT_SUPPORTED,
1102                            _("Operation not supported"));
1103       return NULL;
1104     }
1105
1106   return (* iface->query_info) (file, attributes, flags, cancellable, error);
1107 }
1108
1109 /**
1110  * g_file_query_info_async:
1111  * @file: input #GFile.
1112  * @attributes: an attribute query string.
1113  * @flags: a set of #GFileQueryInfoFlags.
1114  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1115  *     of the request.
1116  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1117  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1118  * @user_data: (closure): the data to pass to callback function
1119  *
1120  * Asynchronously gets the requested information about specified @file. The result
1121  * is a #GFileInfo object that contains key-value attributes (such as type or size
1122  * for the file).
1123  *
1124  * For more details, see g_file_query_info() which is
1125  * the synchronous version of this call.
1126  *
1127  * When the operation is finished, @callback will be called. You can then call
1128  * g_file_query_info_finish() to get the result of the operation.
1129  **/
1130 void
1131 g_file_query_info_async (GFile               *file,
1132                          const char          *attributes,
1133                          GFileQueryInfoFlags  flags,
1134                          int                  io_priority,
1135                          GCancellable        *cancellable,
1136                          GAsyncReadyCallback  callback,
1137                          gpointer             user_data)
1138 {
1139   GFileIface *iface;
1140
1141   g_return_if_fail (G_IS_FILE (file));
1142
1143   iface = G_FILE_GET_IFACE (file);
1144   (* iface->query_info_async) (file,
1145                                attributes,
1146                                flags,
1147                                io_priority,
1148                                cancellable,
1149                                callback,
1150                                user_data);
1151 }
1152
1153 /**
1154  * g_file_query_info_finish:
1155  * @file: input #GFile.
1156  * @res: a #GAsyncResult.
1157  * @error: a #GError.
1158  *
1159  * Finishes an asynchronous file info query.
1160  * See g_file_query_info_async().
1161  *
1162  * Returns: (transfer full): #GFileInfo for given @file or %NULL on error.
1163  *     Free the returned object with g_object_unref().
1164  **/
1165 GFileInfo *
1166 g_file_query_info_finish (GFile         *file,
1167                           GAsyncResult  *res,
1168                           GError       **error)
1169 {
1170   GFileIface *iface;
1171
1172   g_return_val_if_fail (G_IS_FILE (file), NULL);
1173   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1174
1175   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1176     {
1177       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1178       if (g_simple_async_result_propagate_error (simple, error))
1179         return NULL;
1180     }
1181
1182   iface = G_FILE_GET_IFACE (file);
1183   return (* iface->query_info_finish) (file, res, error);
1184 }
1185
1186 /**
1187  * g_file_query_filesystem_info:
1188  * @file: input #GFile.
1189  * @attributes:  an attribute query string.
1190  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1191  * @error: a #GError.
1192  *
1193  * Similar to g_file_query_info(), but obtains information
1194  * about the filesystem the @file is on, rather than the file itself.
1195  * For instance the amount of space available and the type of
1196  * the filesystem.
1197  *
1198  * The @attributes value is a string that specifies the file attributes that
1199  * should be gathered. It is not an error if it's not possible to read a particular
1200  * requested attribute from a file - it just won't be set. @attributes should
1201  * be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
1202  * means all attributes, and a wildcard like "filesystem::*" means all attributes in the
1203  * filesystem namespace. The standard namespace for filesystem attributes is "filesystem".
1204  * Common attributes of interest are #G_FILE_ATTRIBUTE_FILESYSTEM_SIZE
1205  * (the total size of the filesystem in bytes), #G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
1206  * bytes available), and #G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
1207  *
1208  * If @cancellable is not %NULL, then the operation can be cancelled by
1209  * triggering the cancellable object from another thread. If the operation
1210  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1211  *
1212  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1213  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1214  *
1215  * Returns: (transfer full): a #GFileInfo or %NULL if there was an error.
1216  *     Free the returned object with g_object_unref().
1217  **/
1218 GFileInfo *
1219 g_file_query_filesystem_info (GFile         *file,
1220                               const char    *attributes,
1221                               GCancellable  *cancellable,
1222                               GError       **error)
1223 {
1224   GFileIface *iface;
1225
1226   g_return_val_if_fail (G_IS_FILE (file), NULL);
1227
1228   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1229     return NULL;
1230
1231   iface = G_FILE_GET_IFACE (file);
1232
1233   if (iface->query_filesystem_info == NULL)
1234     {
1235       g_set_error_literal (error, G_IO_ERROR,
1236                            G_IO_ERROR_NOT_SUPPORTED,
1237                            _("Operation not supported"));
1238       return NULL;
1239     }
1240
1241   return (* iface->query_filesystem_info) (file, attributes, cancellable, error);
1242 }
1243
1244 /**
1245  * g_file_query_filesystem_info_async:
1246  * @file: input #GFile.
1247  * @attributes: an attribute query string.
1248  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1249  *     of the request.
1250  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1251  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1252  * @user_data: (closure): the data to pass to callback function
1253  *
1254  * Asynchronously gets the requested information about the filesystem
1255  * that the specified @file is on. The result is a #GFileInfo object
1256  * that contains key-value attributes (such as type or size for the
1257  * file).
1258  *
1259  * For more details, see g_file_query_filesystem_info() which is the
1260  * synchronous version of this call.
1261  *
1262  * When the operation is finished, @callback will be called. You can
1263  * then call g_file_query_info_finish() to get the result of the
1264  * operation.
1265  **/
1266 void
1267 g_file_query_filesystem_info_async (GFile               *file,
1268                                     const char          *attributes,
1269                                     int                  io_priority,
1270                                     GCancellable        *cancellable,
1271                                     GAsyncReadyCallback  callback,
1272                                     gpointer             user_data)
1273 {
1274   GFileIface *iface;
1275
1276   g_return_if_fail (G_IS_FILE (file));
1277
1278   iface = G_FILE_GET_IFACE (file);
1279   (* iface->query_filesystem_info_async) (file,
1280                                           attributes,
1281                                           io_priority,
1282                                           cancellable,
1283                                           callback,
1284                                           user_data);
1285 }
1286
1287 /**
1288  * g_file_query_filesystem_info_finish:
1289  * @file: input #GFile.
1290  * @res: a #GAsyncResult.
1291  * @error: a #GError.
1292  *
1293  * Finishes an asynchronous filesystem info query.  See
1294  * g_file_query_filesystem_info_async().
1295  *
1296  * Returns: (transfer full): #GFileInfo for given @file or %NULL on error.
1297  *     Free the returned object with g_object_unref().
1298  **/
1299 GFileInfo *
1300 g_file_query_filesystem_info_finish (GFile         *file,
1301                                      GAsyncResult  *res,
1302                                      GError       **error)
1303 {
1304   GFileIface *iface;
1305
1306   g_return_val_if_fail (G_IS_FILE (file), NULL);
1307   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1308
1309   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1310     {
1311       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1312       if (g_simple_async_result_propagate_error (simple, error))
1313         return NULL;
1314     }
1315
1316   iface = G_FILE_GET_IFACE (file);
1317   return (* iface->query_filesystem_info_finish) (file, res, error);
1318 }
1319
1320 /**
1321  * g_file_find_enclosing_mount:
1322  * @file: input #GFile.
1323  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1324  * @error: a #GError.
1325  *
1326  * Gets a #GMount for the #GFile.
1327  *
1328  * If the #GFileIface for @file does not have a mount (e.g. possibly a
1329  * remote share), @error will be set to %G_IO_ERROR_NOT_FOUND and %NULL
1330  * will be returned.
1331  *
1332  * If @cancellable is not %NULL, then the operation can be cancelled by
1333  * triggering the cancellable object from another thread. If the operation
1334  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1335  *
1336  * Returns: (transfer full): a #GMount where the @file is located or %NULL on error.
1337  *     Free the returned object with g_object_unref().
1338  **/
1339 GMount *
1340 g_file_find_enclosing_mount (GFile         *file,
1341                              GCancellable  *cancellable,
1342                              GError       **error)
1343 {
1344   GFileIface *iface;
1345
1346   g_return_val_if_fail (G_IS_FILE (file), NULL);
1347
1348   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1349     return NULL;
1350
1351   iface = G_FILE_GET_IFACE (file);
1352   if (iface->find_enclosing_mount == NULL)
1353     {
1354
1355       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
1356                         /* Translators: This is an error message when trying to find the
1357                          * enclosing (user visible) mount of a file, but none exists. */
1358                    _("Containing mount does not exist"));
1359       return NULL;
1360     }
1361
1362   return (* iface->find_enclosing_mount) (file, cancellable, error);
1363 }
1364
1365 /**
1366  * g_file_find_enclosing_mount_async:
1367  * @file: a #GFile
1368  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1369  *     of the request.
1370  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1371  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1372  * @user_data: (closure): the data to pass to callback function
1373  *
1374  * Asynchronously gets the mount for the file.
1375  *
1376  * For more details, see g_file_find_enclosing_mount() which is
1377  * the synchronous version of this call.
1378  *
1379  * When the operation is finished, @callback will be called. You can then call
1380  * g_file_find_enclosing_mount_finish() to get the result of the operation.
1381  */
1382 void
1383 g_file_find_enclosing_mount_async (GFile              *file,
1384                                    int                   io_priority,
1385                                    GCancellable         *cancellable,
1386                                    GAsyncReadyCallback   callback,
1387                                    gpointer              user_data)
1388 {
1389   GFileIface *iface;
1390
1391   g_return_if_fail (G_IS_FILE (file));
1392
1393   iface = G_FILE_GET_IFACE (file);
1394   (* iface->find_enclosing_mount_async) (file,
1395                                          io_priority,
1396                                          cancellable,
1397                                          callback,
1398                                          user_data);
1399 }
1400
1401 /**
1402  * g_file_find_enclosing_mount_finish:
1403  * @file: a #GFile
1404  * @res: a #GAsyncResult
1405  * @error: a #GError
1406  *
1407  * Finishes an asynchronous find mount request.
1408  * See g_file_find_enclosing_mount_async().
1409  *
1410  * Returns: (transfer full): #GMount for given @file or %NULL on error.
1411  *     Free the returned object with g_object_unref().
1412  **/
1413 GMount *
1414 g_file_find_enclosing_mount_finish (GFile         *file,
1415                                     GAsyncResult  *res,
1416                                     GError       **error)
1417 {
1418   GFileIface *iface;
1419
1420   g_return_val_if_fail (G_IS_FILE (file), NULL);
1421   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1422
1423   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1424     {
1425       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1426       if (g_simple_async_result_propagate_error (simple, error))
1427         return NULL;
1428     }
1429
1430   iface = G_FILE_GET_IFACE (file);
1431   return (* iface->find_enclosing_mount_finish) (file, res, error);
1432 }
1433
1434
1435 /**
1436  * g_file_read:
1437  * @file: #GFile to read.
1438  * @cancellable: (allow-none): a #GCancellable
1439  * @error: a #GError, or %NULL
1440  *
1441  * Opens a file for reading. The result is a #GFileInputStream that
1442  * can be used to read the contents of the file.
1443  *
1444  * If @cancellable is not %NULL, then the operation can be cancelled by
1445  * triggering the cancellable object from another thread. If the operation
1446  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1447  *
1448  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1449  * If the file is a directory, the G_IO_ERROR_IS_DIRECTORY error will be returned.
1450  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1451  *
1452  * Virtual: read_fn
1453  * Returns: (transfer full): #GFileInputStream or %NULL on error.
1454  *     Free the returned object with g_object_unref().
1455  **/
1456 GFileInputStream *
1457 g_file_read (GFile         *file,
1458              GCancellable  *cancellable,
1459              GError       **error)
1460 {
1461   GFileIface *iface;
1462
1463   g_return_val_if_fail (G_IS_FILE (file), NULL);
1464
1465   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1466     return NULL;
1467
1468   iface = G_FILE_GET_IFACE (file);
1469
1470   if (iface->read_fn == NULL)
1471     {
1472       g_set_error_literal (error, G_IO_ERROR,
1473                            G_IO_ERROR_NOT_SUPPORTED,
1474                            _("Operation not supported"));
1475       return NULL;
1476     }
1477
1478   return (* iface->read_fn) (file, cancellable, error);
1479 }
1480
1481 /**
1482  * g_file_append_to:
1483  * @file: input #GFile.
1484  * @flags: a set of #GFileCreateFlags.
1485  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1486  * @error: a #GError, or %NULL
1487  *
1488  * Gets an output stream for appending data to the file. If
1489  * the file doesn't already exist it is created.
1490  *
1491  * By default files created are generally readable by everyone,
1492  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1493  * will be made readable only to the current user, to the level that
1494  * is supported on the target filesystem.
1495  *
1496  * If @cancellable is not %NULL, then the operation can be cancelled by
1497  * triggering the cancellable object from another thread. If the operation
1498  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1499  *
1500  * Some file systems don't allow all file names, and may
1501  * return an %G_IO_ERROR_INVALID_FILENAME error.
1502  * If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be
1503  * returned. Other errors are possible too, and depend on what kind of
1504  * filesystem the file is on.
1505  *
1506  * Returns: (transfer full): a #GFileOutputStream, or %NULL on error.
1507  *     Free the returned object with g_object_unref().
1508  **/
1509 GFileOutputStream *
1510 g_file_append_to (GFile             *file,
1511                   GFileCreateFlags   flags,
1512                   GCancellable      *cancellable,
1513                   GError           **error)
1514 {
1515   GFileIface *iface;
1516
1517   g_return_val_if_fail (G_IS_FILE (file), NULL);
1518
1519   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1520     return NULL;
1521
1522   iface = G_FILE_GET_IFACE (file);
1523
1524   if (iface->append_to == NULL)
1525     {
1526       g_set_error_literal (error, G_IO_ERROR,
1527                            G_IO_ERROR_NOT_SUPPORTED,
1528                            _("Operation not supported"));
1529       return NULL;
1530     }
1531
1532   return (* iface->append_to) (file, flags, cancellable, error);
1533 }
1534
1535 /**
1536  * g_file_create:
1537  * @file: input #GFile.
1538  * @flags: a set of #GFileCreateFlags.
1539  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1540  * @error: a #GError, or %NULL
1541  *
1542  * Creates a new file and returns an output stream for writing to it.
1543  * The file must not already exist.
1544  *
1545  * By default files created are generally readable by everyone,
1546  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1547  * will be made readable only to the current user, to the level that
1548  * is supported on the target filesystem.
1549  *
1550  * If @cancellable is not %NULL, then the operation can be cancelled by
1551  * triggering the cancellable object from another thread. If the operation
1552  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1553  *
1554  * If a file or directory with this name already exists the G_IO_ERROR_EXISTS
1555  * error will be returned.
1556  * Some file systems don't allow all file names, and may
1557  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1558  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1559  * Other errors are possible too, and depend on what kind of
1560  * filesystem the file is on.
1561  *
1562  * Returns: (transfer full): a #GFileOutputStream for the newly created file, or
1563  *     %NULL on error.
1564  *     Free the returned object with g_object_unref().
1565  **/
1566 GFileOutputStream *
1567 g_file_create (GFile             *file,
1568                GFileCreateFlags   flags,
1569                GCancellable      *cancellable,
1570                GError           **error)
1571 {
1572   GFileIface *iface;
1573
1574   g_return_val_if_fail (G_IS_FILE (file), NULL);
1575
1576   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1577     return NULL;
1578
1579   iface = G_FILE_GET_IFACE (file);
1580
1581   if (iface->create == NULL)
1582     {
1583       g_set_error_literal (error, G_IO_ERROR,
1584                            G_IO_ERROR_NOT_SUPPORTED,
1585                            _("Operation not supported"));
1586       return NULL;
1587     }
1588
1589   return (* iface->create) (file, flags, cancellable, error);
1590 }
1591
1592 /**
1593  * g_file_replace:
1594  * @file: input #GFile.
1595  * @etag: (allow-none): an optional <link linkend="gfile-etag">entity tag</link> for the
1596  *     current #GFile, or #NULL to ignore.
1597  * @make_backup: %TRUE if a backup should be created.
1598  * @flags: a set of #GFileCreateFlags.
1599  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1600  * @error: a #GError, or %NULL
1601  *
1602  * Returns an output stream for overwriting the file, possibly
1603  * creating a backup copy of the file first. If the file doesn't exist,
1604  * it will be created.
1605  *
1606  * This will try to replace the file in the safest way possible so
1607  * that any errors during the writing will not affect an already
1608  * existing copy of the file. For instance, for local files it
1609  * may write to a temporary file and then atomically rename over
1610  * the destination when the stream is closed.
1611  *
1612  * By default files created are generally readable by everyone,
1613  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1614  * will be made readable only to the current user, to the level that
1615  * is supported on the target filesystem.
1616  *
1617  * If @cancellable is not %NULL, then the operation can be cancelled by
1618  * triggering the cancellable object from another thread. If the operation
1619  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1620  *
1621  * If you pass in a non-#NULL @etag value, then this value is
1622  * compared to the current entity tag of the file, and if they differ
1623  * an G_IO_ERROR_WRONG_ETAG error is returned. This generally means
1624  * that the file has been changed since you last read it. You can get
1625  * the new etag from g_file_output_stream_get_etag() after you've
1626  * finished writing and closed the #GFileOutputStream. When you load
1627  * a new file you can use g_file_input_stream_query_info() to get
1628  * the etag of the file.
1629  *
1630  * If @make_backup is %TRUE, this function will attempt to make a backup
1631  * of the current file before overwriting it. If this fails a G_IO_ERROR_CANT_CREATE_BACKUP
1632  * error will be returned. If you want to replace anyway, try again with
1633  * @make_backup set to %FALSE.
1634  *
1635  * If the file is a directory the G_IO_ERROR_IS_DIRECTORY error will be returned,
1636  * and if the file is some other form of non-regular file then a
1637  * G_IO_ERROR_NOT_REGULAR_FILE error will be returned.
1638  * Some file systems don't allow all file names, and may
1639  * return an G_IO_ERROR_INVALID_FILENAME error, and if the name
1640  * is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
1641  * Other errors are possible too, and depend on what kind of
1642  * filesystem the file is on.
1643  *
1644  * Returns: (transfer full): a #GFileOutputStream or %NULL on error.
1645  *     Free the returned object with g_object_unref().
1646  **/
1647 GFileOutputStream *
1648 g_file_replace (GFile             *file,
1649                 const char        *etag,
1650                 gboolean           make_backup,
1651                 GFileCreateFlags   flags,
1652                 GCancellable      *cancellable,
1653                 GError           **error)
1654 {
1655   GFileIface *iface;
1656
1657   g_return_val_if_fail (G_IS_FILE (file), NULL);
1658
1659   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1660     return NULL;
1661
1662   iface = G_FILE_GET_IFACE (file);
1663
1664   if (iface->replace == NULL)
1665     {
1666       g_set_error_literal (error, G_IO_ERROR,
1667                            G_IO_ERROR_NOT_SUPPORTED,
1668                            _("Operation not supported"));
1669       return NULL;
1670     }
1671
1672
1673   /* Handle empty tag string as NULL in consistent way. */
1674   if (etag && *etag == 0)
1675     etag = NULL;
1676
1677   return (* iface->replace) (file, etag, make_backup, flags, cancellable, error);
1678 }
1679
1680 /**
1681  * g_file_open_readwrite:
1682  * @file: #GFile to open
1683  * @cancellable: (allow-none): a #GCancellable
1684  * @error: a #GError, or %NULL
1685  *
1686  * Opens an existing file for reading and writing. The result is
1687  * a #GFileIOStream that can be used to read and write the contents of the file.
1688  *
1689  * If @cancellable is not %NULL, then the operation can be cancelled by
1690  * triggering the cancellable object from another thread. If the operation
1691  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1692  *
1693  * If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
1694  * If the file is a directory, the G_IO_ERROR_IS_DIRECTORY error will be returned.
1695  * Other errors are possible too, and depend on what kind of filesystem the file is on.
1696  * Note that in many non-local file cases read and write streams are not supported,
1697  * so make sure you really need to do read and write streaming, rather than
1698  * just opening for reading or writing.
1699  *
1700  * Returns: (transfer full): #GFileIOStream or %NULL on error.
1701  *     Free the returned object with g_object_unref().
1702  *
1703  * Since: 2.22
1704  **/
1705 GFileIOStream *
1706 g_file_open_readwrite (GFile                      *file,
1707                        GCancellable               *cancellable,
1708                        GError                    **error)
1709 {
1710   GFileIface *iface;
1711
1712   g_return_val_if_fail (G_IS_FILE (file), NULL);
1713
1714   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1715     return NULL;
1716
1717   iface = G_FILE_GET_IFACE (file);
1718
1719   if (iface->open_readwrite == NULL)
1720     {
1721       g_set_error_literal (error, G_IO_ERROR,
1722                            G_IO_ERROR_NOT_SUPPORTED,
1723                            _("Operation not supported"));
1724       return NULL;
1725     }
1726
1727   return (* iface->open_readwrite) (file, cancellable, error);
1728 }
1729
1730 /**
1731  * g_file_create_readwrite:
1732  * @file: a #GFile
1733  * @flags: a set of #GFileCreateFlags
1734  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
1735  * @error: return location for a #GError, or %NULL
1736  *
1737  * Creates a new file and returns a stream for reading and writing to it.
1738  * The file must not already exist.
1739  *
1740  * By default files created are generally readable by everyone,
1741  * but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
1742  * will be made readable only to the current user, to the level that
1743  * is supported on the target filesystem.
1744  *
1745  * If @cancellable is not %NULL, then the operation can be cancelled by
1746  * triggering the cancellable object from another thread. If the operation
1747  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1748  *
1749  * If a file or directory with this name already exists the %G_IO_ERROR_EXISTS
1750  * error will be returned. Some file systems don't allow all file names,
1751  * and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name
1752  * is too long, %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors
1753  * are possible too, and depend on what kind of filesystem the file is on.
1754  *
1755  * Note that in many non-local file cases read and write streams are not
1756  * supported, so make sure you really need to do read and write streaming,
1757  * rather than just opening for reading or writing.
1758  *
1759  * Returns: (transfer full): a #GFileIOStream for the newly created file, or %NULL on error.
1760  *     Free the returned object with g_object_unref().
1761  *
1762  * Since: 2.22
1763  */
1764 GFileIOStream *
1765 g_file_create_readwrite (GFile             *file,
1766                          GFileCreateFlags   flags,
1767                          GCancellable      *cancellable,
1768                          GError           **error)
1769 {
1770   GFileIface *iface;
1771
1772   g_return_val_if_fail (G_IS_FILE (file), NULL);
1773
1774   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1775     return NULL;
1776
1777   iface = G_FILE_GET_IFACE (file);
1778
1779   if (iface->create_readwrite == NULL)
1780     {
1781       g_set_error_literal (error, G_IO_ERROR,
1782                            G_IO_ERROR_NOT_SUPPORTED,
1783                            _("Operation not supported"));
1784       return NULL;
1785     }
1786
1787   return (* iface->create_readwrite) (file, flags, cancellable, error);
1788 }
1789
1790 /**
1791  * g_file_replace_readwrite:
1792  * @file: a #GFile
1793  * @etag: (allow-none): an optional <link linkend="gfile-etag">entity tag</link> for the
1794  *     current #GFile, or #NULL to ignore
1795  * @make_backup: %TRUE if a backup should be created
1796  * @flags: a set of #GFileCreateFlags
1797  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
1798  * @error: return location for a #GError, or %NULL
1799  *
1800  * Returns an output stream for overwriting the file in readwrite mode,
1801  * possibly creating a backup copy of the file first. If the file doesn't
1802  * exist, it will be created.
1803  *
1804  * For details about the behaviour, see g_file_replace() which does the same
1805  * thing but returns an output stream only.
1806  *
1807  * Note that in many non-local file cases read and write streams are not
1808  * supported, so make sure you really need to do read and write streaming,
1809  * rather than just opening for reading or writing.
1810  *
1811  * Returns: (transfer full): a #GFileIOStream or %NULL on error.
1812  *     Free the returned object with g_object_unref().
1813  *
1814  * Since: 2.22
1815  */
1816 GFileIOStream *
1817 g_file_replace_readwrite (GFile             *file,
1818                           const char        *etag,
1819                           gboolean           make_backup,
1820                           GFileCreateFlags   flags,
1821                           GCancellable      *cancellable,
1822                           GError           **error)
1823 {
1824   GFileIface *iface;
1825
1826   g_return_val_if_fail (G_IS_FILE (file), NULL);
1827
1828   if (g_cancellable_set_error_if_cancelled (cancellable, error))
1829     return NULL;
1830
1831   iface = G_FILE_GET_IFACE (file);
1832
1833   if (iface->replace_readwrite == NULL)
1834     {
1835       g_set_error_literal (error, G_IO_ERROR,
1836                            G_IO_ERROR_NOT_SUPPORTED,
1837                            _("Operation not supported"));
1838       return NULL;
1839     }
1840
1841   return (* iface->replace_readwrite) (file, etag, make_backup, flags, cancellable, error);
1842 }
1843
1844 /**
1845  * g_file_read_async:
1846  * @file: input #GFile
1847  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1848  *     of the request.
1849  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1850  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1851  * @user_data: (closure): the data to pass to callback function
1852  *
1853  * Asynchronously opens @file for reading.
1854  *
1855  * For more details, see g_file_read() which is
1856  * the synchronous version of this call.
1857  *
1858  * When the operation is finished, @callback will be called. You can then call
1859  * g_file_read_finish() to get the result of the operation.
1860  **/
1861 void
1862 g_file_read_async (GFile               *file,
1863                    int                  io_priority,
1864                    GCancellable        *cancellable,
1865                    GAsyncReadyCallback  callback,
1866                    gpointer             user_data)
1867 {
1868   GFileIface *iface;
1869
1870   g_return_if_fail (G_IS_FILE (file));
1871
1872   iface = G_FILE_GET_IFACE (file);
1873   (* iface->read_async) (file,
1874                          io_priority,
1875                          cancellable,
1876                          callback,
1877                          user_data);
1878 }
1879
1880 /**
1881  * g_file_read_finish:
1882  * @file: input #GFile.
1883  * @res: a #GAsyncResult.
1884  * @error: a #GError, or %NULL
1885  *
1886  * Finishes an asynchronous file read operation started with
1887  * g_file_read_async().
1888  *
1889  * Returns: (transfer full): a #GFileInputStream or %NULL on error.
1890  *     Free the returned object with g_object_unref().
1891  **/
1892 GFileInputStream *
1893 g_file_read_finish (GFile         *file,
1894                     GAsyncResult  *res,
1895                     GError       **error)
1896 {
1897   GFileIface *iface;
1898
1899   g_return_val_if_fail (G_IS_FILE (file), NULL);
1900   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1901
1902   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1903     {
1904       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1905       if (g_simple_async_result_propagate_error (simple, error))
1906         return NULL;
1907     }
1908
1909   iface = G_FILE_GET_IFACE (file);
1910   return (* iface->read_finish) (file, res, error);
1911 }
1912
1913 /**
1914  * g_file_append_to_async:
1915  * @file: input #GFile.
1916  * @flags: a set of #GFileCreateFlags.
1917  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1918  *     of the request.
1919  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1920  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1921  * @user_data: (closure): the data to pass to callback function
1922  *
1923  * Asynchronously opens @file for appending.
1924  *
1925  * For more details, see g_file_append_to() which is
1926  * the synchronous version of this call.
1927  *
1928  * When the operation is finished, @callback will be called. You can then call
1929  * g_file_append_to_finish() to get the result of the operation.
1930  **/
1931 void
1932 g_file_append_to_async (GFile               *file,
1933                         GFileCreateFlags     flags,
1934                         int                  io_priority,
1935                         GCancellable        *cancellable,
1936                         GAsyncReadyCallback  callback,
1937                         gpointer             user_data)
1938 {
1939   GFileIface *iface;
1940
1941   g_return_if_fail (G_IS_FILE (file));
1942
1943   iface = G_FILE_GET_IFACE (file);
1944   (* iface->append_to_async) (file,
1945                               flags,
1946                               io_priority,
1947                               cancellable,
1948                               callback,
1949                               user_data);
1950 }
1951
1952 /**
1953  * g_file_append_to_finish:
1954  * @file: input #GFile.
1955  * @res: #GAsyncResult
1956  * @error: a #GError, or %NULL
1957  *
1958  * Finishes an asynchronous file append operation started with
1959  * g_file_append_to_async().
1960  *
1961  * Returns: (transfer full): a valid #GFileOutputStream or %NULL on error.
1962  *     Free the returned object with g_object_unref().
1963  **/
1964 GFileOutputStream *
1965 g_file_append_to_finish (GFile         *file,
1966                          GAsyncResult  *res,
1967                          GError       **error)
1968 {
1969   GFileIface *iface;
1970
1971   g_return_val_if_fail (G_IS_FILE (file), NULL);
1972   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
1973
1974   if (G_IS_SIMPLE_ASYNC_RESULT (res))
1975     {
1976       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
1977       if (g_simple_async_result_propagate_error (simple, error))
1978         return NULL;
1979     }
1980
1981   iface = G_FILE_GET_IFACE (file);
1982   return (* iface->append_to_finish) (file, res, error);
1983 }
1984
1985 /**
1986  * g_file_create_async:
1987  * @file: input #GFile.
1988  * @flags: a set of #GFileCreateFlags.
1989  * @io_priority: the <link linkend="io-priority">I/O priority</link>
1990  *     of the request.
1991  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1992  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1993  * @user_data: (closure): the data to pass to callback function
1994  *
1995  * Asynchronously creates a new file and returns an output stream for writing to it.
1996  * The file must not already exist.
1997  *
1998  * For more details, see g_file_create() which is
1999  * the synchronous version of this call.
2000  *
2001  * When the operation is finished, @callback will be called. You can then call
2002  * g_file_create_finish() to get the result of the operation.
2003  **/
2004 void
2005 g_file_create_async (GFile               *file,
2006                      GFileCreateFlags     flags,
2007                      int                  io_priority,
2008                      GCancellable        *cancellable,
2009                      GAsyncReadyCallback  callback,
2010                      gpointer             user_data)
2011 {
2012   GFileIface *iface;
2013
2014   g_return_if_fail (G_IS_FILE (file));
2015
2016   iface = G_FILE_GET_IFACE (file);
2017   (* iface->create_async) (file,
2018                            flags,
2019                            io_priority,
2020                            cancellable,
2021                            callback,
2022                            user_data);
2023 }
2024
2025 /**
2026  * g_file_create_finish:
2027  * @file: input #GFile.
2028  * @res: a #GAsyncResult.
2029  * @error: a #GError, or %NULL
2030  *
2031  * Finishes an asynchronous file create operation started with
2032  * g_file_create_async().
2033  *
2034  * Returns: (transfer full): a #GFileOutputStream or %NULL on error.
2035  *     Free the returned object with g_object_unref().
2036  **/
2037 GFileOutputStream *
2038 g_file_create_finish (GFile         *file,
2039                       GAsyncResult  *res,
2040                       GError       **error)
2041 {
2042   GFileIface *iface;
2043
2044   g_return_val_if_fail (G_IS_FILE (file), NULL);
2045   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2046
2047   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2048     {
2049       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2050       if (g_simple_async_result_propagate_error (simple, error))
2051         return NULL;
2052     }
2053
2054   iface = G_FILE_GET_IFACE (file);
2055   return (* iface->create_finish) (file, res, error);
2056 }
2057
2058 /**
2059  * g_file_replace_async:
2060  * @file: input #GFile.
2061  * @etag: (allow-none): an <link linkend="gfile-etag">entity tag</link> for the
2062  *     current #GFile, or NULL to ignore.
2063  * @make_backup: %TRUE if a backup should be created.
2064  * @flags: a set of #GFileCreateFlags.
2065  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2066  *     of the request.
2067  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
2068  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
2069  * @user_data: (closure): the data to pass to callback function
2070  *
2071  * Asynchronously overwrites the file, replacing the contents, possibly
2072  * creating a backup copy of the file first.
2073  *
2074  * For more details, see g_file_replace() which is
2075  * the synchronous version of this call.
2076  *
2077  * When the operation is finished, @callback will be called. You can then call
2078  * g_file_replace_finish() to get the result of the operation.
2079  **/
2080 void
2081 g_file_replace_async (GFile               *file,
2082                       const char          *etag,
2083                       gboolean             make_backup,
2084                       GFileCreateFlags     flags,
2085                       int                  io_priority,
2086                       GCancellable        *cancellable,
2087                       GAsyncReadyCallback  callback,
2088                       gpointer             user_data)
2089 {
2090   GFileIface *iface;
2091
2092   g_return_if_fail (G_IS_FILE (file));
2093
2094   iface = G_FILE_GET_IFACE (file);
2095   (* iface->replace_async) (file,
2096                             etag,
2097                             make_backup,
2098                             flags,
2099                             io_priority,
2100                             cancellable,
2101                             callback,
2102                             user_data);
2103 }
2104
2105 /**
2106  * g_file_replace_finish:
2107  * @file: input #GFile.
2108  * @res: a #GAsyncResult.
2109  * @error: a #GError, or %NULL
2110  *
2111  * Finishes an asynchronous file replace operation started with
2112  * g_file_replace_async().
2113  *
2114  * Returns: (transfer full): a #GFileOutputStream, or %NULL on error.
2115  *     Free the returned object with g_object_unref().
2116  **/
2117 GFileOutputStream *
2118 g_file_replace_finish (GFile         *file,
2119                        GAsyncResult  *res,
2120                        GError       **error)
2121 {
2122   GFileIface *iface;
2123
2124   g_return_val_if_fail (G_IS_FILE (file), NULL);
2125   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2126
2127   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2128     {
2129       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2130       if (g_simple_async_result_propagate_error (simple, error))
2131         return NULL;
2132     }
2133
2134   iface = G_FILE_GET_IFACE (file);
2135   return (* iface->replace_finish) (file, res, error);
2136 }
2137
2138
2139 /**
2140  * g_file_open_readwrite_async:
2141  * @file: input #GFile.
2142  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2143  *     of the request.
2144  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
2145  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
2146  * @user_data: (closure): the data to pass to callback function
2147  *
2148  * Asynchronously opens @file for reading and writing.
2149  *
2150  * For more details, see g_file_open_readwrite() which is
2151  * the synchronous version of this call.
2152  *
2153  * When the operation is finished, @callback will be called. You can then call
2154  * g_file_open_readwrite_finish() to get the result of the operation.
2155  *
2156  * Since: 2.22
2157  **/
2158 void
2159 g_file_open_readwrite_async (GFile                      *file,
2160                              int                         io_priority,
2161                              GCancellable               *cancellable,
2162                              GAsyncReadyCallback         callback,
2163                              gpointer                    user_data)
2164 {
2165   GFileIface *iface;
2166
2167   g_return_if_fail (G_IS_FILE (file));
2168
2169   iface = G_FILE_GET_IFACE (file);
2170   (* iface->open_readwrite_async) (file,
2171                                    io_priority,
2172                                    cancellable,
2173                                    callback,
2174                                    user_data);
2175 }
2176
2177 /**
2178  * g_file_open_readwrite_finish:
2179  * @file: input #GFile.
2180  * @res: a #GAsyncResult.
2181  * @error: a #GError, or %NULL
2182  *
2183  * Finishes an asynchronous file read operation started with
2184  * g_file_open_readwrite_async().
2185  *
2186  * Returns: (transfer full): a #GFileIOStream or %NULL on error.
2187  *     Free the returned object with g_object_unref().
2188  *
2189  * Since: 2.22
2190  **/
2191 GFileIOStream *
2192 g_file_open_readwrite_finish (GFile                      *file,
2193                               GAsyncResult               *res,
2194                               GError                    **error)
2195 {
2196   GFileIface *iface;
2197
2198   g_return_val_if_fail (G_IS_FILE (file), NULL);
2199   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2200
2201   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2202     {
2203       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2204       if (g_simple_async_result_propagate_error (simple, error))
2205         return NULL;
2206     }
2207
2208   iface = G_FILE_GET_IFACE (file);
2209   return (* iface->open_readwrite_finish) (file, res, error);
2210 }
2211
2212
2213 /**
2214  * g_file_create_readwrite_async:
2215  * @file: input #GFile
2216  * @flags: a set of #GFileCreateFlags
2217  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2218  *     of the request
2219  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
2220  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
2221  * @user_data: (closure): the data to pass to callback function
2222  *
2223  * Asynchronously creates a new file and returns a stream for reading and
2224  * writing to it. The file must not already exist.
2225  *
2226  * For more details, see g_file_create_readwrite() which is
2227  * the synchronous version of this call.
2228  *
2229  * When the operation is finished, @callback will be called. You can then
2230  * call g_file_create_readwrite_finish() to get the result of the operation.
2231  *
2232  * Since: 2.22
2233  */
2234 void
2235 g_file_create_readwrite_async (GFile               *file,
2236                                GFileCreateFlags     flags,
2237                                int                  io_priority,
2238                                GCancellable        *cancellable,
2239                                GAsyncReadyCallback  callback,
2240                                gpointer             user_data)
2241 {
2242   GFileIface *iface;
2243
2244   g_return_if_fail (G_IS_FILE (file));
2245
2246   iface = G_FILE_GET_IFACE (file);
2247   (* iface->create_readwrite_async) (file,
2248                                      flags,
2249                                      io_priority,
2250                                      cancellable,
2251                                      callback,
2252                                      user_data);
2253 }
2254
2255 /**
2256  * g_file_create_readwrite_finish:
2257  * @file: input #GFile
2258  * @res: a #GAsyncResult
2259  * @error: a #GError, or %NULL
2260  *
2261  * Finishes an asynchronous file create operation started with
2262  * g_file_create_readwrite_async().
2263  *
2264  * Returns: (transfer full): a #GFileIOStream or %NULL on error.
2265  *     Free the returned object with g_object_unref().
2266  *
2267  * Since: 2.22
2268  **/
2269 GFileIOStream *
2270 g_file_create_readwrite_finish (GFile         *file,
2271                                 GAsyncResult  *res,
2272                                 GError       **error)
2273 {
2274   GFileIface *iface;
2275
2276   g_return_val_if_fail (G_IS_FILE (file), NULL);
2277   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2278
2279   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2280     {
2281       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2282       if (g_simple_async_result_propagate_error (simple, error))
2283         return NULL;
2284     }
2285
2286   iface = G_FILE_GET_IFACE (file);
2287   return (* iface->create_readwrite_finish) (file, res, error);
2288 }
2289
2290 /**
2291  * g_file_replace_readwrite_async:
2292  * @file: input #GFile.
2293  * @etag: (allow-none): an <link linkend="gfile-etag">entity tag</link> for the
2294  *     current #GFile, or NULL to ignore.
2295  * @make_backup: %TRUE if a backup should be created.
2296  * @flags: a set of #GFileCreateFlags.
2297  * @io_priority: the <link linkend="io-priority">I/O priority</link>
2298  *     of the request.
2299  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
2300  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
2301  * @user_data: (closure): the data to pass to callback function
2302  *
2303  * Asynchronously overwrites the file in read-write mode, replacing the
2304  * contents, possibly creating a backup copy of the file first.
2305  *
2306  * For more details, see g_file_replace_readwrite() which is
2307  * the synchronous version of this call.
2308  *
2309  * When the operation is finished, @callback will be called. You can then
2310  * call g_file_replace_readwrite_finish() to get the result of the operation.
2311  *
2312  * Since: 2.22
2313  */
2314 void
2315 g_file_replace_readwrite_async (GFile               *file,
2316                                 const char          *etag,
2317                                 gboolean             make_backup,
2318                                 GFileCreateFlags     flags,
2319                                 int                  io_priority,
2320                                 GCancellable        *cancellable,
2321                                 GAsyncReadyCallback  callback,
2322                                 gpointer             user_data)
2323 {
2324   GFileIface *iface;
2325
2326   g_return_if_fail (G_IS_FILE (file));
2327
2328   iface = G_FILE_GET_IFACE (file);
2329   (* iface->replace_readwrite_async) (file,
2330                                       etag,
2331                                       make_backup,
2332                                       flags,
2333                                       io_priority,
2334                                       cancellable,
2335                                       callback,
2336                                       user_data);
2337 }
2338
2339 /**
2340  * g_file_replace_readwrite_finish:
2341  * @file: input #GFile.
2342  * @res: a #GAsyncResult.
2343  * @error: a #GError, or %NULL
2344  *
2345  * Finishes an asynchronous file replace operation started with
2346  * g_file_replace_readwrite_async().
2347  *
2348  * Returns: (transfer full): a #GFileIOStream, or %NULL on error.
2349  *     Free the returned object with g_object_unref().
2350  *
2351  * Since: 2.22
2352  */
2353 GFileIOStream *
2354 g_file_replace_readwrite_finish (GFile         *file,
2355                                  GAsyncResult  *res,
2356                                  GError       **error)
2357 {
2358   GFileIface *iface;
2359
2360   g_return_val_if_fail (G_IS_FILE (file), NULL);
2361   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
2362
2363   if (G_IS_SIMPLE_ASYNC_RESULT (res))
2364     {
2365       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
2366       if (g_simple_async_result_propagate_error (simple, error))
2367         return NULL;
2368     }
2369
2370   iface = G_FILE_GET_IFACE (file);
2371   return (* iface->replace_readwrite_finish) (file, res, error);
2372 }
2373
2374 static gboolean
2375 copy_symlink (GFile           *destination,
2376               GFileCopyFlags   flags,
2377               GCancellable    *cancellable,
2378               const char      *target,
2379               GError         **error)
2380 {
2381   GError *my_error;
2382   gboolean tried_delete;
2383   GFileInfo *info;
2384   GFileType file_type;
2385
2386   tried_delete = FALSE;
2387
2388  retry:
2389   my_error = NULL;
2390   if (!g_file_make_symbolic_link (destination, target, cancellable, &my_error))
2391     {
2392       /* Maybe it already existed, and we want to overwrite? */
2393       if (!tried_delete && (flags & G_FILE_COPY_OVERWRITE) &&
2394           my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_EXISTS)
2395         {
2396           g_error_free (my_error);
2397
2398
2399           /* Don't overwrite if the destination is a directory */
2400           info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
2401                                     G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2402                                     cancellable, &my_error);
2403           if (info != NULL)
2404             {
2405               file_type = g_file_info_get_file_type (info);
2406               g_object_unref (info);
2407
2408               if (file_type == G_FILE_TYPE_DIRECTORY)
2409                 {
2410                   g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
2411                                        _("Can't copy over directory"));
2412                   return FALSE;
2413                 }
2414             }
2415
2416           if (!g_file_delete (destination, cancellable, error))
2417             return FALSE;
2418
2419           tried_delete = TRUE;
2420           goto retry;
2421         }
2422             /* Nah, fail */
2423       g_propagate_error (error, my_error);
2424       return FALSE;
2425     }
2426
2427   return TRUE;
2428 }
2429
2430 static GInputStream *
2431 open_source_for_copy (GFile           *source,
2432                       GFile           *destination,
2433                       GFileCopyFlags   flags,
2434                       GCancellable    *cancellable,
2435                       GError         **error)
2436 {
2437   GError *my_error;
2438   GInputStream *in;
2439   GFileInfo *info;
2440   GFileType file_type;
2441
2442   my_error = NULL;
2443   in = (GInputStream *)g_file_read (source, cancellable, &my_error);
2444   if (in != NULL)
2445     return in;
2446
2447   /* There was an error opening the source, try to set a good error for it: */
2448
2449   if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_IS_DIRECTORY)
2450     {
2451       /* The source is a directory, don't fail with WOULD_RECURSE immediately,
2452        * as that is less useful to the app. Better check for errors on the
2453        * target instead.
2454        */
2455       g_error_free (my_error);
2456       my_error = NULL;
2457
2458       info = g_file_query_info (destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
2459                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2460                                 cancellable, &my_error);
2461       if (info != NULL &&
2462           g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_TYPE))
2463         {
2464           file_type = g_file_info_get_file_type (info);
2465           g_object_unref (info);
2466
2467           if (flags & G_FILE_COPY_OVERWRITE)
2468             {
2469               if (file_type == G_FILE_TYPE_DIRECTORY)
2470                 {
2471                   g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_WOULD_MERGE,
2472                                        _("Can't copy directory over directory"));
2473                   return NULL;
2474                 }
2475               /* continue to would_recurse error */
2476             }
2477           else
2478             {
2479               g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
2480                                    _("Target file exists"));
2481               return NULL;
2482             }
2483         }
2484       else
2485         {
2486           /* Error getting info from target, return that error
2487            * (except for NOT_FOUND, which is no error here)
2488            */
2489           if (my_error != NULL && !g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
2490             {
2491               g_propagate_error (error, my_error);
2492               return NULL;
2493             }
2494           g_clear_error (&my_error);
2495         }
2496
2497       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE,
2498                            _("Can't recursively copy directory"));
2499       return NULL;
2500     }
2501
2502   g_propagate_error (error, my_error);
2503   return NULL;
2504 }
2505
2506 static gboolean
2507 should_copy (GFileAttributeInfo *info,
2508              gboolean            as_move,
2509              gboolean            skip_perms)
2510 {
2511   if (skip_perms && strcmp(info->name, "unix::mode") == 0)
2512         return FALSE;
2513
2514   if (as_move)
2515     return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED;
2516   return info->flags & G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE;
2517 }
2518
2519 static char *
2520 build_attribute_list_for_copy (GFileAttributeInfoList *attributes,
2521                                GFileAttributeInfoList *namespaces,
2522                                gboolean                as_move,
2523                                gboolean                skip_perms)
2524 {
2525   GString *s;
2526   gboolean first;
2527   int i;
2528
2529   first = TRUE;
2530   s = g_string_new ("");
2531
2532   if (attributes)
2533     {
2534       for (i = 0; i < attributes->n_infos; i++)
2535         {
2536           if (should_copy (&attributes->infos[i], as_move, skip_perms))
2537             {
2538               if (first)
2539                 first = FALSE;
2540               else
2541                 g_string_append_c (s, ',');
2542
2543               g_string_append (s, attributes->infos[i].name);
2544             }
2545         }
2546     }
2547
2548   if (namespaces)
2549     {
2550       for (i = 0; i < namespaces->n_infos; i++)
2551         {
2552           if (should_copy (&namespaces->infos[i], as_move, FALSE))
2553             {
2554               if (first)
2555                 first = FALSE;
2556               else
2557                 g_string_append_c (s, ',');
2558
2559               g_string_append (s, namespaces->infos[i].name);
2560               g_string_append (s, "::*");
2561             }
2562         }
2563     }
2564
2565   return g_string_free (s, FALSE);
2566 }
2567
2568 /**
2569  * g_file_copy_attributes:
2570  * @source: a #GFile with attributes.
2571  * @destination: a #GFile to copy attributes to.
2572  * @flags: a set of #GFileCopyFlags.
2573  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
2574  * @error: a #GError, %NULL to ignore.
2575  *
2576  * Copies the file attributes from @source to @destination.
2577  *
2578  * Normally only a subset of the file attributes are copied,
2579  * those that are copies in a normal file copy operation
2580  * (which for instance does not include e.g. owner). However
2581  * if #G_FILE_COPY_ALL_METADATA is specified in @flags, then
2582  * all the metadata that is possible to copy is copied. This
2583  * is useful when implementing move by copy + delete source.
2584  *
2585  * Returns: %TRUE if the attributes were copied successfully, %FALSE otherwise.
2586  **/
2587 gboolean
2588 g_file_copy_attributes (GFile           *source,
2589                         GFile           *destination,
2590                         GFileCopyFlags   flags,
2591                         GCancellable    *cancellable,
2592                         GError         **error)
2593 {
2594   GFileAttributeInfoList *attributes, *namespaces;
2595   char *attrs_to_read;
2596   gboolean res;
2597   GFileInfo *info;
2598   gboolean as_move;
2599   gboolean source_nofollow_symlinks;
2600   gboolean skip_perms;
2601
2602   as_move = flags & G_FILE_COPY_ALL_METADATA;
2603   source_nofollow_symlinks = flags & G_FILE_COPY_NOFOLLOW_SYMLINKS;
2604   skip_perms = (flags & G_FILE_COPY_TARGET_DEFAULT_PERMS) != 0;
2605
2606   /* Ignore errors here, if the target supports no attributes there is nothing to copy */
2607   attributes = g_file_query_settable_attributes (destination, cancellable, NULL);
2608   namespaces = g_file_query_writable_namespaces (destination, cancellable, NULL);
2609
2610   if (attributes == NULL && namespaces == NULL)
2611     return TRUE;
2612
2613   attrs_to_read = build_attribute_list_for_copy (attributes, namespaces, as_move, skip_perms);
2614
2615   /* Ignore errors here, if we can't read some info (e.g. if it doesn't exist)
2616    * we just don't copy it.
2617    */
2618   info = g_file_query_info (source, attrs_to_read,
2619                             source_nofollow_symlinks ? G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS:0,
2620                             cancellable,
2621                             NULL);
2622
2623   g_free (attrs_to_read);
2624
2625   res = TRUE;
2626   if  (info)
2627     {
2628       res = g_file_set_attributes_from_info (destination,
2629                                              info,
2630                          G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2631                                              cancellable,
2632                                              error);
2633       g_object_unref (info);
2634     }
2635
2636   g_file_attribute_info_list_unref (attributes);
2637   g_file_attribute_info_list_unref (namespaces);
2638
2639   return res;
2640 }
2641
2642 static gboolean
2643 copy_stream_with_progress (GInputStream           *in,
2644                            GOutputStream          *out,
2645                            GFile                  *source,
2646                            GCancellable           *cancellable,
2647                            GFileProgressCallback   progress_callback,
2648                            gpointer                progress_callback_data,
2649                            GError                **error)
2650 {
2651   gssize n_read, n_written;
2652   goffset current_size;
2653   char buffer[1024*64], *p;
2654   gboolean res;
2655   goffset total_size;
2656   GFileInfo *info;
2657
2658   total_size = -1;
2659   /* avoid performance impact of querying total size when it's not needed */
2660   if (progress_callback)
2661     {
2662       info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (in),
2663                                              G_FILE_ATTRIBUTE_STANDARD_SIZE,
2664                                              cancellable, NULL);
2665       if (info)
2666         {
2667           if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
2668             total_size = g_file_info_get_size (info);
2669           g_object_unref (info);
2670         }
2671
2672       if (total_size == -1)
2673         {
2674           info = g_file_query_info (source,
2675                                     G_FILE_ATTRIBUTE_STANDARD_SIZE,
2676                                     G_FILE_QUERY_INFO_NONE,
2677                                     cancellable, NULL);
2678           if (info)
2679             {
2680               if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
2681                 total_size = g_file_info_get_size (info);
2682               g_object_unref (info);
2683             }
2684         }
2685     }
2686
2687   if (total_size == -1)
2688     total_size = 0;
2689
2690   current_size = 0;
2691   res = TRUE;
2692   while (TRUE)
2693     {
2694       n_read = g_input_stream_read (in, buffer, sizeof (buffer), cancellable, error);
2695       if (n_read == -1)
2696         {
2697           res = FALSE;
2698           break;
2699         }
2700
2701       if (n_read == 0)
2702         break;
2703
2704       current_size += n_read;
2705
2706       p = buffer;
2707       while (n_read > 0)
2708         {
2709           n_written = g_output_stream_write (out, p, n_read, cancellable, error);
2710           if (n_written == -1)
2711             {
2712               res = FALSE;
2713               break;
2714             }
2715
2716           p += n_written;
2717           n_read -= n_written;
2718         }
2719
2720       if (!res)
2721         break;
2722
2723       if (progress_callback)
2724         progress_callback (current_size, total_size, progress_callback_data);
2725     }
2726
2727   /* Make sure we send full copied size */
2728   if (progress_callback)
2729     progress_callback (current_size, total_size, progress_callback_data);
2730
2731   return res;
2732 }
2733
2734 #ifdef HAVE_SPLICE
2735
2736 static gboolean
2737 do_splice (int     fd_in,
2738            loff_t *off_in,
2739            int     fd_out,
2740            loff_t *off_out,
2741            size_t  len,
2742            long   *bytes_transferd,
2743            GError **error)
2744 {
2745   long result;
2746
2747 retry:
2748   result = splice (fd_in, off_in, fd_out, off_out, len, SPLICE_F_MORE);
2749
2750   if (result == -1)
2751     {
2752       int errsv = errno;
2753
2754       if (errsv == EINTR)
2755         goto retry;
2756       else if (errsv == ENOSYS || errsv == EINVAL)
2757         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
2758                              _("Splice not supported"));
2759       else
2760         g_set_error (error, G_IO_ERROR,
2761                      g_io_error_from_errno (errsv),
2762                      _("Error splicing file: %s"),
2763                      g_strerror (errsv));
2764
2765       return FALSE;
2766     }
2767
2768   *bytes_transferd = result;
2769   return TRUE;
2770 }
2771
2772 static gboolean
2773 splice_stream_with_progress (GInputStream           *in,
2774                              GOutputStream          *out,
2775                              GCancellable           *cancellable,
2776                              GFileProgressCallback   progress_callback,
2777                              gpointer                progress_callback_data,
2778                              GError                **error)
2779 {
2780   int buffer[2];
2781   gboolean res;
2782   goffset total_size;
2783   loff_t offset_in;
2784   loff_t offset_out;
2785   int fd_in, fd_out;
2786
2787   fd_in = g_file_descriptor_based_get_fd (G_FILE_DESCRIPTOR_BASED (in));
2788   fd_out = g_file_descriptor_based_get_fd (G_FILE_DESCRIPTOR_BASED (out));
2789
2790   if (pipe (buffer) != 0)
2791     {
2792       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
2793                            "Pipe creation failed");
2794       return FALSE;
2795     }
2796
2797   total_size = -1;
2798   /* avoid performance impact of querying total size when it's not needed */
2799   if (progress_callback)
2800     {
2801       struct stat sbuf;
2802
2803       if (fstat (fd_in, &sbuf) == 0)
2804         total_size = sbuf.st_size;
2805     }
2806
2807   if (total_size == -1)
2808     total_size = 0;
2809
2810   offset_in = offset_out = 0;
2811   res = FALSE;
2812   while (TRUE)
2813     {
2814       long n_read;
2815       long n_written;
2816
2817       if (g_cancellable_set_error_if_cancelled (cancellable, error))
2818         break;
2819
2820       if (!do_splice (fd_in, &offset_in, buffer[1], NULL, 1024*64, &n_read, error))
2821         break;
2822
2823       if (n_read == 0)
2824         {
2825           res = TRUE;
2826           break;
2827         }
2828
2829       while (n_read > 0)
2830         {
2831           if (g_cancellable_set_error_if_cancelled (cancellable, error))
2832             goto out;
2833
2834           if (!do_splice (buffer[0], NULL, fd_out, &offset_out, n_read, &n_written, error))
2835             goto out;
2836
2837           n_read -= n_written;
2838         }
2839
2840       if (progress_callback)
2841         progress_callback (offset_in, total_size, progress_callback_data);
2842     }
2843
2844   /* Make sure we send full copied size */
2845   if (progress_callback)
2846     progress_callback (offset_in, total_size, progress_callback_data);
2847
2848  out:
2849   close (buffer[0]);
2850   close (buffer[1]);
2851
2852   return res;
2853 }
2854 #endif
2855
2856 static gboolean
2857 file_copy_fallback (GFile                  *source,
2858                     GFile                  *destination,
2859                     GFileCopyFlags          flags,
2860                     GCancellable           *cancellable,
2861                     GFileProgressCallback   progress_callback,
2862                     gpointer                progress_callback_data,
2863                     GError                **error)
2864 {
2865   GInputStream *in;
2866   GOutputStream *out;
2867   GFileInfo *info;
2868   const char *target;
2869   gboolean result;
2870 #ifdef HAVE_SPLICE
2871   gboolean fallback = TRUE;
2872 #endif
2873
2874   /* need to know the file type */
2875   info = g_file_query_info (source,
2876                             G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,
2877                             G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2878                             cancellable,
2879                             error);
2880
2881   if (info == NULL)
2882           return FALSE;
2883
2884   /* Maybe copy the symlink? */
2885   if ((flags & G_FILE_COPY_NOFOLLOW_SYMLINKS) &&
2886       g_file_info_get_file_type (info) == G_FILE_TYPE_SYMBOLIC_LINK)
2887     {
2888       target = g_file_info_get_symlink_target (info);
2889       if (target)
2890         {
2891           if (!copy_symlink (destination, flags, cancellable, target, error))
2892             {
2893               g_object_unref (info);
2894               return FALSE;
2895             }
2896
2897           g_object_unref (info);
2898           goto copied_file;
2899         }
2900         /* ... else fall back on a regular file copy */
2901         g_object_unref (info);
2902     }
2903   /* Handle "special" files (pipes, device nodes, ...)? */
2904   else if (g_file_info_get_file_type (info) == G_FILE_TYPE_SPECIAL)
2905     {
2906       /* FIXME: could try to recreate device nodes and others? */
2907
2908       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
2909                            _("Can't copy special file"));
2910       g_object_unref (info);
2911       return FALSE;
2912     }
2913   /* Everything else should just fall back on a regular copy. */
2914   else
2915     g_object_unref (info);
2916
2917   in = open_source_for_copy (source, destination, flags, cancellable, error);
2918   if (in == NULL)
2919     return FALSE;
2920
2921   if (flags & G_FILE_COPY_OVERWRITE)
2922     {
2923       out = (GOutputStream *)g_file_replace (destination,
2924                                              NULL,
2925                                              flags & G_FILE_COPY_BACKUP,
2926                                              G_FILE_CREATE_REPLACE_DESTINATION,
2927                                              cancellable, error);
2928     }
2929   else
2930     {
2931       out = (GOutputStream *)g_file_create (destination, 0, cancellable, error);
2932     }
2933
2934   if (out == NULL)
2935     {
2936       g_object_unref (in);
2937       return FALSE;
2938     }
2939
2940 #ifdef HAVE_SPLICE
2941   if (G_IS_FILE_DESCRIPTOR_BASED (in) && G_IS_FILE_DESCRIPTOR_BASED (out))
2942     {
2943       GError *splice_err = NULL;
2944
2945       result = splice_stream_with_progress (in, out, cancellable,
2946                                             progress_callback, progress_callback_data,
2947                                             &splice_err);
2948
2949       if (result || !g_error_matches (splice_err, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
2950         {
2951           fallback = FALSE;
2952           if (!result)
2953             g_propagate_error (error, splice_err);
2954         }
2955       else
2956         g_clear_error (&splice_err);
2957     }
2958
2959   if (fallback)
2960 #endif
2961     result = copy_stream_with_progress (in, out, source, cancellable,
2962                                         progress_callback, progress_callback_data,
2963                                         error);
2964
2965   /* Don't care about errors in source here */
2966   g_input_stream_close (in, cancellable, NULL);
2967
2968   /* But write errors on close are bad! */
2969   if (!g_output_stream_close (out, cancellable, result ? error : NULL))
2970     result = FALSE;
2971
2972   g_object_unref (in);
2973   g_object_unref (out);
2974
2975   if (result == FALSE)
2976     return FALSE;
2977
2978  copied_file:
2979   /* Ignore errors here. Failure to copy metadata is not a hard error */
2980   g_file_copy_attributes (source, destination,
2981                           flags, cancellable, NULL);
2982
2983   return TRUE;
2984 }
2985
2986 /**
2987  * g_file_copy:
2988  * @source: input #GFile.
2989  * @destination: destination #GFile
2990  * @flags: set of #GFileCopyFlags
2991  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
2992  * @progress_callback: (scope call): function to callback with progress information
2993  * @progress_callback_data: (closure): user data to pass to @progress_callback
2994  * @error: #GError to set on error, or %NULL
2995  *
2996  * Copies the file @source to the location specified by @destination.
2997  * Can not handle recursive copies of directories.
2998  *
2999  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
3000  * existing @destination file is overwritten.
3001  *
3002  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
3003  * will be copied as symlinks, otherwise the target of the
3004  * @source symlink will be copied.
3005  *
3006  * If @cancellable is not %NULL, then the operation can be cancelled by
3007  * triggering the cancellable object from another thread. If the operation
3008  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3009  *
3010  * If @progress_callback is not %NULL, then the operation can be monitored by
3011  * setting this to a #GFileProgressCallback function. @progress_callback_data
3012  * will be passed to this function. It is guaranteed that this callback will
3013  * be called after all data has been transferred with the total number of bytes
3014  * copied during the operation.
3015  *
3016  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
3017  * error is returned, independent on the status of the @destination.
3018  *
3019  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
3020  * error G_IO_ERROR_EXISTS is returned.
3021  *
3022  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
3023  * error is returned. If trying to overwrite a directory with a directory the
3024  * G_IO_ERROR_WOULD_MERGE error is returned.
3025  *
3026  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
3027  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
3028  * is returned.
3029  *
3030  * If you are interested in copying the #GFile object itself (not the on-disk
3031  * file), see g_file_dup().
3032  *
3033  * Returns: %TRUE on success, %FALSE otherwise.
3034  **/
3035 gboolean
3036 g_file_copy (GFile                  *source,
3037              GFile                  *destination,
3038              GFileCopyFlags          flags,
3039              GCancellable           *cancellable,
3040              GFileProgressCallback   progress_callback,
3041              gpointer                progress_callback_data,
3042              GError                **error)
3043 {
3044   GFileIface *iface;
3045   GError *my_error;
3046   gboolean res;
3047
3048   g_return_val_if_fail (G_IS_FILE (source), FALSE);
3049   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
3050
3051   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3052     return FALSE;
3053
3054   iface = G_FILE_GET_IFACE (destination);
3055   if (iface->copy)
3056     {
3057       my_error = NULL;
3058       res = (* iface->copy) (source, destination,
3059                              flags, cancellable,
3060                              progress_callback, progress_callback_data,
3061                              &my_error);
3062
3063       if (res)
3064         return TRUE;
3065
3066       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
3067         {
3068           g_propagate_error (error, my_error);
3069               return FALSE;
3070         }
3071       else
3072         g_clear_error (&my_error);
3073     }
3074
3075   /* If the types are different, and the destination method failed
3076      also try the source method */
3077   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
3078     {
3079       iface = G_FILE_GET_IFACE (source);
3080
3081       if (iface->copy)
3082         {
3083           my_error = NULL;
3084           res = (* iface->copy) (source, destination,
3085                                  flags, cancellable,
3086                                  progress_callback, progress_callback_data,
3087                                  &my_error);
3088
3089           if (res)
3090             return TRUE;
3091
3092           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
3093             {
3094               g_propagate_error (error, my_error);
3095               return FALSE;
3096             }
3097           else
3098             g_clear_error (&my_error);
3099         }
3100     }
3101
3102   return file_copy_fallback (source, destination, flags, cancellable,
3103                              progress_callback, progress_callback_data,
3104                              error);
3105 }
3106
3107 /**
3108  * g_file_copy_async: (skip)
3109  * @source: input #GFile.
3110  * @destination: destination #GFile
3111  * @flags: set of #GFileCopyFlags
3112  * @io_priority: the <link linkend="io-priority">I/O priority</link>
3113  *     of the request.
3114  * @cancellable: optional #GCancellable object, %NULL to ignore.
3115  * @progress_callback: function to callback with progress information
3116  * @progress_callback_data: user data to pass to @progress_callback
3117  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
3118  * @user_data: the data to pass to callback function
3119  *
3120  * Copies the file @source to the location specified by @destination
3121  * asynchronously. For details of the behaviour, see g_file_copy().
3122  *
3123  * If @progress_callback is not %NULL, then that function that will be called
3124  * just like in g_file_copy(), however the callback will run in the main loop,
3125  * not in the thread that is doing the I/O operation.
3126  *
3127  * When the operation is finished, @callback will be called. You can then call
3128  * g_file_copy_finish() to get the result of the operation.
3129  **/
3130 void
3131 g_file_copy_async (GFile                  *source,
3132                    GFile                  *destination,
3133                    GFileCopyFlags          flags,
3134                    int                     io_priority,
3135                    GCancellable           *cancellable,
3136                    GFileProgressCallback   progress_callback,
3137                    gpointer                progress_callback_data,
3138                    GAsyncReadyCallback     callback,
3139                    gpointer                user_data)
3140 {
3141   GFileIface *iface;
3142
3143   g_return_if_fail (G_IS_FILE (source));
3144   g_return_if_fail (G_IS_FILE (destination));
3145
3146   iface = G_FILE_GET_IFACE (source);
3147   (* iface->copy_async) (source,
3148                          destination,
3149                          flags,
3150                          io_priority,
3151                          cancellable,
3152                          progress_callback,
3153                          progress_callback_data,
3154                          callback,
3155                          user_data);
3156 }
3157
3158 /**
3159  * g_file_copy_finish:
3160  * @file: input #GFile.
3161  * @res: a #GAsyncResult.
3162  * @error: a #GError, or %NULL
3163  *
3164  * Finishes copying the file started with
3165  * g_file_copy_async().
3166  *
3167  * Returns: a %TRUE on success, %FALSE on error.
3168  **/
3169 gboolean
3170 g_file_copy_finish (GFile        *file,
3171                     GAsyncResult *res,
3172                     GError      **error)
3173 {
3174   GFileIface *iface;
3175
3176   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3177   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
3178
3179   if (G_IS_SIMPLE_ASYNC_RESULT (res))
3180     {
3181       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3182
3183       if (g_simple_async_result_propagate_error (simple, error))
3184         return FALSE;
3185     }
3186
3187   iface = G_FILE_GET_IFACE (file);
3188   return (* iface->copy_finish) (file, res, error);
3189 }
3190
3191 /**
3192  * g_file_move:
3193  * @source: #GFile pointing to the source location.
3194  * @destination: #GFile pointing to the destination location.
3195  * @flags: set of #GFileCopyFlags.
3196  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3197  * @progress_callback: (scope call): #GFileProgressCallback function for updates.
3198  * @progress_callback_data: (closure): gpointer to user data for the callback function.
3199  * @error: #GError for returning error conditions, or %NULL
3200  *
3201  *
3202  * Tries to move the file or directory @source to the location specified by @destination.
3203  * If native move operations are supported then this is used, otherwise a copy + delete
3204  * fallback is used. The native implementation may support moving directories (for instance
3205  * on moves inside the same filesystem), but the fallback code does not.
3206  *
3207  * If the flag #G_FILE_COPY_OVERWRITE is specified an already
3208  * existing @destination file is overwritten.
3209  *
3210  * If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
3211  * will be copied as symlinks, otherwise the target of the
3212  * @source symlink will be copied.
3213  *
3214  * If @cancellable is not %NULL, then the operation can be cancelled by
3215  * triggering the cancellable object from another thread. If the operation
3216  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3217  *
3218  * If @progress_callback is not %NULL, then the operation can be monitored by
3219  * setting this to a #GFileProgressCallback function. @progress_callback_data
3220  * will be passed to this function. It is guaranteed that this callback will
3221  * be called after all data has been transferred with the total number of bytes
3222  * copied during the operation.
3223  *
3224  * If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
3225  * error is returned, independent on the status of the @destination.
3226  *
3227  * If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
3228  * error G_IO_ERROR_EXISTS is returned.
3229  *
3230  * If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
3231  * error is returned. If trying to overwrite a directory with a directory the
3232  * G_IO_ERROR_WOULD_MERGE error is returned.
3233  *
3234  * If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
3235  * specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
3236  * may be returned (if the native move operation isn't available).
3237  *
3238  * Returns: %TRUE on successful move, %FALSE otherwise.
3239  **/
3240 gboolean
3241 g_file_move (GFile                  *source,
3242              GFile                  *destination,
3243              GFileCopyFlags          flags,
3244              GCancellable           *cancellable,
3245              GFileProgressCallback   progress_callback,
3246              gpointer                progress_callback_data,
3247              GError                **error)
3248 {
3249   GFileIface *iface;
3250   GError *my_error;
3251   gboolean res;
3252
3253   g_return_val_if_fail (G_IS_FILE (source), FALSE);
3254   g_return_val_if_fail (G_IS_FILE (destination), FALSE);
3255
3256   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3257     return FALSE;
3258
3259   iface = G_FILE_GET_IFACE (destination);
3260   if (iface->move)
3261     {
3262       my_error = NULL;
3263       res = (* iface->move) (source, destination,
3264                              flags, cancellable,
3265                              progress_callback, progress_callback_data,
3266                              &my_error);
3267
3268       if (res)
3269         return TRUE;
3270
3271       if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
3272         {
3273           g_propagate_error (error, my_error);
3274           return FALSE;
3275         }
3276     }
3277
3278   /* If the types are different, and the destination method failed
3279      also try the source method */
3280   if (G_OBJECT_TYPE (source) != G_OBJECT_TYPE (destination))
3281     {
3282       iface = G_FILE_GET_IFACE (source);
3283
3284       if (iface->move)
3285         {
3286           my_error = NULL;
3287           res = (* iface->move) (source, destination,
3288                                  flags, cancellable,
3289                                  progress_callback, progress_callback_data,
3290                                  &my_error);
3291
3292           if (res)
3293             return TRUE;
3294
3295           if (my_error->domain != G_IO_ERROR || my_error->code != G_IO_ERROR_NOT_SUPPORTED)
3296             {
3297               g_propagate_error (error, my_error);
3298               return FALSE;
3299             }
3300         }
3301     }
3302
3303   if (flags & G_FILE_COPY_NO_FALLBACK_FOR_MOVE)
3304     {
3305       g_set_error_literal (error, G_IO_ERROR,
3306                            G_IO_ERROR_NOT_SUPPORTED,
3307                            _("Operation not supported"));
3308       return FALSE;
3309     }
3310
3311   flags |= G_FILE_COPY_ALL_METADATA;
3312   if (!g_file_copy (source, destination, flags, cancellable,
3313                     progress_callback, progress_callback_data,
3314                     error))
3315     return FALSE;
3316
3317   return g_file_delete (source, cancellable, error);
3318 }
3319
3320 /**
3321  * g_file_make_directory
3322  * @file: input #GFile.
3323  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3324  * @error: a #GError, or %NULL
3325  *
3326  * Creates a directory. Note that this will only create a child directory of
3327  * the immediate parent directory of the path or URI given by the #GFile. To
3328  * recursively create directories, see g_file_make_directory_with_parents().
3329  * This function will fail if the parent directory does not exist, setting
3330  * @error to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support creating
3331  * directories, this function will fail, setting @error to
3332  * %G_IO_ERROR_NOT_SUPPORTED.
3333  *
3334  * For a local #GFile the newly created directory will have the default
3335  * (current) ownership and permissions of the current process.
3336  *
3337  * If @cancellable is not %NULL, then the operation can be cancelled by
3338  * triggering the cancellable object from another thread. If the operation
3339  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3340  *
3341  * Returns: %TRUE on successful creation, %FALSE otherwise.
3342  **/
3343 gboolean
3344 g_file_make_directory (GFile         *file,
3345                        GCancellable  *cancellable,
3346                        GError       **error)
3347 {
3348   GFileIface *iface;
3349
3350   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3351
3352   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3353     return FALSE;
3354
3355   iface = G_FILE_GET_IFACE (file);
3356
3357   if (iface->make_directory == NULL)
3358     {
3359       g_set_error_literal (error, G_IO_ERROR,
3360                            G_IO_ERROR_NOT_SUPPORTED,
3361                            _("Operation not supported"));
3362       return FALSE;
3363     }
3364
3365   return (* iface->make_directory) (file, cancellable, error);
3366 }
3367
3368 /**
3369  * g_file_make_directory_with_parents:
3370  * @file: input #GFile.
3371  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3372  * @error: a #GError, or %NULL
3373  *
3374  * Creates a directory and any parent directories that may not exist similar to
3375  * 'mkdir -p'. If the file system does not support creating directories, this
3376  * function will fail, setting @error to %G_IO_ERROR_NOT_SUPPORTED. If the
3377  * directory itself already exists, this function will fail setting @error
3378  * to %G_IO_ERROR_EXISTS, unlike the similar g_mkdir_with_parents().
3379  *
3380  * For a local #GFile the newly created directories will have the default
3381  * (current) ownership and permissions of the current process.
3382  *
3383  * If @cancellable is not %NULL, then the operation can be cancelled by
3384  * triggering the cancellable object from another thread. If the operation
3385  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3386  *
3387  * Returns: %TRUE if all directories have been successfully created, %FALSE
3388  * otherwise.
3389  *
3390  * Since: 2.18
3391  **/
3392 gboolean
3393 g_file_make_directory_with_parents (GFile         *file,
3394                                     GCancellable  *cancellable,
3395                                     GError       **error)
3396 {
3397   gboolean result;
3398   GFile *parent_file, *work_file;
3399   GList *list = NULL, *l;
3400   GError *my_error = NULL;
3401
3402   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3403     return FALSE;
3404
3405   result = g_file_make_directory (file, cancellable, &my_error);
3406   if (result || my_error->code != G_IO_ERROR_NOT_FOUND)
3407     {
3408       if (my_error)
3409         g_propagate_error (error, my_error);
3410       return result;
3411     }
3412
3413   work_file = file;
3414
3415   while (!result && my_error->code == G_IO_ERROR_NOT_FOUND)
3416     {
3417       g_clear_error (&my_error);
3418
3419       parent_file = g_file_get_parent (work_file);
3420       if (parent_file == NULL)
3421         break;
3422       result = g_file_make_directory (parent_file, cancellable, &my_error);
3423
3424       if (!result && my_error->code == G_IO_ERROR_NOT_FOUND)
3425         list = g_list_prepend (list, parent_file);
3426
3427       work_file = parent_file;
3428     }
3429
3430   for (l = list; result && l; l = l->next)
3431     {
3432       result = g_file_make_directory ((GFile *) l->data, cancellable, &my_error);
3433     }
3434
3435   /* Clean up */
3436   while (list != NULL)
3437     {
3438       g_object_unref ((GFile *) list->data);
3439       list = g_list_remove (list, list->data);
3440     }
3441
3442   if (!result)
3443     {
3444       g_propagate_error (error, my_error);
3445       return result;
3446     }
3447
3448   return g_file_make_directory (file, cancellable, error);
3449 }
3450
3451 /**
3452  * g_file_make_symbolic_link:
3453  * @file: a #GFile with the name of the symlink to create
3454  * @symlink_value: a string with the path for the target of the new symlink
3455  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3456  * @error: a #GError.
3457  *
3458  * Creates a symbolic link named @file which contains the string
3459  * @symlink_value.
3460  *
3461  * If @cancellable is not %NULL, then the operation can be cancelled by
3462  * triggering the cancellable object from another thread. If the operation
3463  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3464  *
3465  * Returns: %TRUE on the creation of a new symlink, %FALSE otherwise.
3466  */
3467 gboolean
3468 g_file_make_symbolic_link (GFile         *file,
3469                            const char    *symlink_value,
3470                            GCancellable  *cancellable,
3471                            GError       **error)
3472 {
3473   GFileIface *iface;
3474
3475   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3476   g_return_val_if_fail (symlink_value != NULL, FALSE);
3477
3478   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3479     return FALSE;
3480
3481   if (*symlink_value == '\0')
3482     {
3483       g_set_error_literal (error, G_IO_ERROR,
3484                            G_IO_ERROR_INVALID_ARGUMENT,
3485                            _("Invalid symlink value given"));
3486       return FALSE;
3487     }
3488
3489   iface = G_FILE_GET_IFACE (file);
3490
3491   if (iface->make_symbolic_link == NULL)
3492     {
3493       g_set_error_literal (error, G_IO_ERROR,
3494                            G_IO_ERROR_NOT_SUPPORTED,
3495                            _("Operation not supported"));
3496       return FALSE;
3497     }
3498
3499   return (* iface->make_symbolic_link) (file, symlink_value, cancellable, error);
3500 }
3501
3502 /**
3503  * g_file_delete:
3504  * @file: input #GFile.
3505  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3506  * @error: a #GError, or %NULL
3507  *
3508  * Deletes a file. If the @file is a directory, it will only be deleted if it
3509  * is empty.
3510  *
3511  * If @cancellable is not %NULL, then the operation can be cancelled by
3512  * triggering the cancellable object from another thread. If the operation
3513  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3514  *
3515  * Virtual: delete_file
3516  * Returns: %TRUE if the file was deleted. %FALSE otherwise.
3517  **/
3518 gboolean
3519 g_file_delete (GFile         *file,
3520                GCancellable  *cancellable,
3521                GError       **error)
3522 {
3523   GFileIface *iface;
3524
3525   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3526
3527   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3528     return FALSE;
3529
3530   iface = G_FILE_GET_IFACE (file);
3531
3532   if (iface->delete_file == NULL)
3533     {
3534       g_set_error_literal (error, G_IO_ERROR,
3535                            G_IO_ERROR_NOT_SUPPORTED,
3536                            _("Operation not supported"));
3537       return FALSE;
3538     }
3539
3540   return (* iface->delete_file) (file, cancellable, error);
3541 }
3542
3543 /**
3544  * g_file_trash:
3545  * @file: #GFile to send to trash.
3546  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3547  * @error: a #GError, or %NULL
3548  *
3549  * Sends @file to the "Trashcan", if possible. This is similar to
3550  * deleting it, but the user can recover it before emptying the trashcan.
3551  * Not all file systems support trashing, so this call can return the
3552  * %G_IO_ERROR_NOT_SUPPORTED error.
3553  *
3554  *
3555  * If @cancellable is not %NULL, then the operation can be cancelled by
3556  * triggering the cancellable object from another thread. If the operation
3557  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3558  *
3559  * Returns: %TRUE on successful trash, %FALSE otherwise.
3560  **/
3561 gboolean
3562 g_file_trash (GFile         *file,
3563               GCancellable  *cancellable,
3564               GError       **error)
3565 {
3566   GFileIface *iface;
3567
3568   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3569
3570   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3571     return FALSE;
3572
3573   iface = G_FILE_GET_IFACE (file);
3574
3575   if (iface->trash == NULL)
3576     {
3577       g_set_error_literal (error,
3578                            G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
3579                            _("Trash not supported"));
3580       return FALSE;
3581     }
3582
3583   return (* iface->trash) (file, cancellable, error);
3584 }
3585
3586 /**
3587  * g_file_set_display_name:
3588  * @file: input #GFile.
3589  * @display_name: a string.
3590  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3591  * @error: a #GError, or %NULL
3592  *
3593  * Renames @file to the specified display name.
3594  *
3595  * The display name is converted from UTF8 to the correct encoding for the target
3596  * filesystem if possible and the @file is renamed to this.
3597  *
3598  * If you want to implement a rename operation in the user interface the edit name
3599  * (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename
3600  * widget, and then the result after editing should be passed to g_file_set_display_name().
3601  *
3602  * On success the resulting converted filename is returned.
3603  *
3604  * If @cancellable is not %NULL, then the operation can be cancelled by
3605  * triggering the cancellable object from another thread. If the operation
3606  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3607  *
3608  * Returns: (transfer full): a #GFile specifying what @file was renamed to, or %NULL
3609  *     if there was an error.
3610  *     Free the returned object with g_object_unref().
3611  **/
3612 GFile *
3613 g_file_set_display_name (GFile         *file,
3614                          const char    *display_name,
3615                          GCancellable  *cancellable,
3616                          GError       **error)
3617 {
3618   GFileIface *iface;
3619
3620   g_return_val_if_fail (G_IS_FILE (file), NULL);
3621   g_return_val_if_fail (display_name != NULL, NULL);
3622
3623   if (strchr (display_name, G_DIR_SEPARATOR) != NULL)
3624     {
3625       g_set_error (error,
3626                    G_IO_ERROR,
3627                    G_IO_ERROR_INVALID_ARGUMENT,
3628                    _("File names cannot contain '%c'"), G_DIR_SEPARATOR);
3629       return NULL;
3630     }
3631
3632   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3633     return NULL;
3634
3635   iface = G_FILE_GET_IFACE (file);
3636
3637   return (* iface->set_display_name) (file, display_name, cancellable, error);
3638 }
3639
3640 /**
3641  * g_file_set_display_name_async:
3642  * @file: input #GFile.
3643  * @display_name: a string.
3644  * @io_priority: the <link linkend="io-priority">I/O priority</link>
3645  *     of the request.
3646  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3647  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
3648  * @user_data: (closure): the data to pass to callback function
3649  *
3650  * Asynchronously sets the display name for a given #GFile.
3651  *
3652  * For more details, see g_file_set_display_name() which is
3653  * the synchronous version of this call.
3654  *
3655  * When the operation is finished, @callback will be called. You can then call
3656  * g_file_set_display_name_finish() to get the result of the operation.
3657  **/
3658 void
3659 g_file_set_display_name_async (GFile               *file,
3660                                const char          *display_name,
3661                                int                  io_priority,
3662                                GCancellable        *cancellable,
3663                                GAsyncReadyCallback  callback,
3664                                gpointer             user_data)
3665 {
3666   GFileIface *iface;
3667
3668   g_return_if_fail (G_IS_FILE (file));
3669   g_return_if_fail (display_name != NULL);
3670
3671   iface = G_FILE_GET_IFACE (file);
3672   (* iface->set_display_name_async) (file,
3673                                      display_name,
3674                                      io_priority,
3675                                      cancellable,
3676                                      callback,
3677                                      user_data);
3678 }
3679
3680 /**
3681  * g_file_set_display_name_finish:
3682  * @file: input #GFile.
3683  * @res: a #GAsyncResult.
3684  * @error: a #GError, or %NULL
3685  *
3686  * Finishes setting a display name started with
3687  * g_file_set_display_name_async().
3688  *
3689  * Returns: (transfer full): a #GFile or %NULL on error.
3690  *     Free the returned object with g_object_unref().
3691  **/
3692 GFile *
3693 g_file_set_display_name_finish (GFile         *file,
3694                                 GAsyncResult  *res,
3695                                 GError       **error)
3696 {
3697   GFileIface *iface;
3698
3699   g_return_val_if_fail (G_IS_FILE (file), NULL);
3700   g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
3701
3702   if (G_IS_SIMPLE_ASYNC_RESULT (res))
3703     {
3704       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
3705       if (g_simple_async_result_propagate_error (simple, error))
3706         return NULL;
3707     }
3708
3709   iface = G_FILE_GET_IFACE (file);
3710   return (* iface->set_display_name_finish) (file, res, error);
3711 }
3712
3713 /**
3714  * g_file_query_settable_attributes:
3715  * @file: input #GFile.
3716  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3717  * @error: a #GError, or %NULL
3718  *
3719  * Obtain the list of settable attributes for the file.
3720  *
3721  * Returns the type and full attribute name of all the attributes
3722  * that can be set on this file. This doesn't mean setting it will always
3723  * succeed though, you might get an access failure, or some specific
3724  * file may not support a specific attribute.
3725  *
3726  * If @cancellable is not %NULL, then the operation can be cancelled by
3727  * triggering the cancellable object from another thread. If the operation
3728  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3729  *
3730  * Returns: a #GFileAttributeInfoList describing the settable attributes.
3731  * When you are done with it, release it with g_file_attribute_info_list_unref()
3732  **/
3733 GFileAttributeInfoList *
3734 g_file_query_settable_attributes (GFile         *file,
3735                                   GCancellable  *cancellable,
3736                                   GError       **error)
3737 {
3738   GFileIface *iface;
3739   GError *my_error;
3740   GFileAttributeInfoList *list;
3741
3742   g_return_val_if_fail (G_IS_FILE (file), NULL);
3743
3744   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3745     return NULL;
3746
3747   iface = G_FILE_GET_IFACE (file);
3748
3749   if (iface->query_settable_attributes == NULL)
3750     return g_file_attribute_info_list_new ();
3751
3752   my_error = NULL;
3753   list = (* iface->query_settable_attributes) (file, cancellable, &my_error);
3754
3755   if (list == NULL)
3756     {
3757       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
3758         {
3759           list = g_file_attribute_info_list_new ();
3760           g_error_free (my_error);
3761         }
3762       else
3763         g_propagate_error (error, my_error);
3764     }
3765
3766   return list;
3767 }
3768
3769 /**
3770  * g_file_query_writable_namespaces:
3771  * @file: input #GFile.
3772  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3773  * @error: a #GError, or %NULL
3774  *
3775  * Obtain the list of attribute namespaces where new attributes
3776  * can be created by a user. An example of this is extended
3777  * attributes (in the "xattr" namespace).
3778  *
3779  * If @cancellable is not %NULL, then the operation can be cancelled by
3780  * triggering the cancellable object from another thread. If the operation
3781  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3782  *
3783  * Returns: a #GFileAttributeInfoList describing the writable namespaces.
3784  * When you are done with it, release it with g_file_attribute_info_list_unref()
3785  **/
3786 GFileAttributeInfoList *
3787 g_file_query_writable_namespaces (GFile         *file,
3788                                   GCancellable  *cancellable,
3789                                   GError       **error)
3790 {
3791   GFileIface *iface;
3792   GError *my_error;
3793   GFileAttributeInfoList *list;
3794
3795   g_return_val_if_fail (G_IS_FILE (file), NULL);
3796
3797   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3798     return NULL;
3799
3800   iface = G_FILE_GET_IFACE (file);
3801
3802   if (iface->query_writable_namespaces == NULL)
3803     return g_file_attribute_info_list_new ();
3804
3805   my_error = NULL;
3806   list = (* iface->query_writable_namespaces) (file, cancellable, &my_error);
3807
3808   if (list == NULL)
3809     {
3810       if (my_error->domain == G_IO_ERROR && my_error->code == G_IO_ERROR_NOT_SUPPORTED)
3811         {
3812           list = g_file_attribute_info_list_new ();
3813           g_error_free (my_error);
3814         }
3815       else
3816         g_propagate_error (error, my_error);
3817     }
3818
3819   return list;
3820 }
3821
3822 /**
3823  * g_file_set_attribute:
3824  * @file: input #GFile.
3825  * @attribute: a string containing the attribute's name.
3826  * @type: The type of the attribute
3827  * @value_p: a pointer to the value (or the pointer itself if the type is a pointer type)
3828  * @flags: a set of #GFileQueryInfoFlags.
3829  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3830  * @error: a #GError, or %NULL
3831  *
3832  * Sets an attribute in the file with attribute name @attribute to @value.
3833  *
3834  * Some attributes can be unset by setting @attribute to
3835  * %G_FILE_ATTRIBUTE_TYPE_INVALID and @value to %NULL.
3836  *
3837  * If @cancellable is not %NULL, then the operation can be cancelled by
3838  * triggering the cancellable object from another thread. If the operation
3839  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3840  *
3841  * Returns: %TRUE if the attribute was set, %FALSE otherwise.
3842  **/
3843 gboolean
3844 g_file_set_attribute (GFile                      *file,
3845                       const char                 *attribute,
3846                       GFileAttributeType          type,
3847                       gpointer                    value_p,
3848                       GFileQueryInfoFlags         flags,
3849                       GCancellable               *cancellable,
3850                       GError                    **error)
3851 {
3852   GFileIface *iface;
3853
3854   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3855   g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
3856
3857   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3858     return FALSE;
3859
3860   iface = G_FILE_GET_IFACE (file);
3861
3862   if (iface->set_attribute == NULL)
3863     {
3864       g_set_error_literal (error, G_IO_ERROR,
3865                            G_IO_ERROR_NOT_SUPPORTED,
3866                            _("Operation not supported"));
3867       return FALSE;
3868     }
3869
3870   return (* iface->set_attribute) (file, attribute, type, value_p, flags, cancellable, error);
3871 }
3872
3873 /**
3874  * g_file_set_attributes_from_info:
3875  * @file: input #GFile.
3876  * @info: a #GFileInfo.
3877  * @flags: #GFileQueryInfoFlags
3878  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3879  * @error: a #GError, or %NULL
3880  *
3881  * Tries to set all attributes in the #GFileInfo on the target values,
3882  * not stopping on the first error.
3883  *
3884  * If there is any error during this operation then @error will be set to
3885  * the first error. Error on particular fields are flagged by setting
3886  * the "status" field in the attribute value to
3887  * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
3888  * further errors.
3889  *
3890  * If @cancellable is not %NULL, then the operation can be cancelled by
3891  * triggering the cancellable object from another thread. If the operation
3892  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
3893  *
3894  * Returns: %TRUE if there was any error, %FALSE otherwise.
3895  **/
3896 gboolean
3897 g_file_set_attributes_from_info (GFile                *file,
3898                                  GFileInfo            *info,
3899                                  GFileQueryInfoFlags   flags,
3900                                  GCancellable         *cancellable,
3901                                  GError              **error)
3902 {
3903   GFileIface *iface;
3904
3905   g_return_val_if_fail (G_IS_FILE (file), FALSE);
3906   g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
3907
3908   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3909     return FALSE;
3910
3911   g_file_info_clear_status (info);
3912
3913   iface = G_FILE_GET_IFACE (file);
3914
3915   return (* iface->set_attributes_from_info) (file,
3916                                               info,
3917                                               flags,
3918                                               cancellable,
3919                                               error);
3920 }
3921
3922
3923 static gboolean
3924 g_file_real_set_attributes_from_info (GFile                *file,
3925                                       GFileInfo            *info,
3926                                       GFileQueryInfoFlags   flags,
3927                                       GCancellable         *cancellable,
3928                                       GError              **error)
3929 {
3930   char **attributes;
3931   int i;
3932   gboolean res;
3933   GFileAttributeValue *value;
3934
3935   res = TRUE;
3936
3937   attributes = g_file_info_list_attributes (info, NULL);
3938
3939   for (i = 0; attributes[i] != NULL; i++)
3940     {
3941       value = _g_file_info_get_attribute_value (info, attributes[i]);
3942
3943       if (value->status != G_FILE_ATTRIBUTE_STATUS_UNSET)
3944         continue;
3945
3946       if (!g_file_set_attribute (file, attributes[i],
3947                                  value->type, _g_file_attribute_value_peek_as_pointer (value),
3948                                  flags, cancellable, error))
3949         {
3950           value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
3951           res = FALSE;
3952           /* Don't set error multiple times */
3953           error = NULL;
3954         }
3955       else
3956         value->status = G_FILE_ATTRIBUTE_STATUS_SET;
3957     }
3958
3959   g_strfreev (attributes);
3960
3961   return res;
3962 }
3963
3964 /**
3965  * g_file_set_attributes_async:
3966  * @file: input #GFile.
3967  * @info: a #GFileInfo.
3968  * @flags: a #GFileQueryInfoFlags.
3969  * @io_priority: the <link linkend="io-priority">I/O priority</link>
3970  *     of the request.
3971  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
3972  * @callback: (scope async): a #GAsyncReadyCallback.
3973  * @user_data: (closure): a #gpointer.
3974  *
3975  * Asynchronously sets the attributes of @file with @info.
3976  *
3977  * For more details, see g_file_set_attributes_from_info() which is
3978  * the synchronous version of this call.
3979  *
3980  * When the operation is finished, @callback will be called. You can then call
3981  * g_file_set_attributes_finish() to get the result of the operation.
3982  **/
3983 void
3984 g_file_set_attributes_async (GFile               *file,
3985                              GFileInfo           *info,
3986                              GFileQueryInfoFlags  flags,
3987                              int                  io_priority,
3988                              GCancellable        *cancellable,
3989                              GAsyncReadyCallback  callback,
3990                              gpointer             user_data)
3991 {
3992   GFileIface *iface;
3993
3994   g_return_if_fail (G_IS_FILE (file));
3995   g_return_if_fail (G_IS_FILE_INFO (info));
3996
3997   iface = G_FILE_GET_IFACE (file);
3998   (* iface->set_attributes_async) (file,
3999                                    info,
4000                                    flags,
4001                                    io_priority,
4002                                    cancellable,
4003                                    callback,
4004                                    user_data);
4005 }
4006
4007 /**
4008  * g_file_set_attributes_finish:
4009  * @file: input #GFile.
4010  * @result: a #GAsyncResult.
4011  * @info: (out) (transfer full): a #GFileInfo.
4012  * @error: a #GError, or %NULL
4013  *
4014  * Finishes setting an attribute started in g_file_set_attributes_async().
4015  *
4016  * Returns: %TRUE if the attributes were set correctly, %FALSE otherwise.
4017  **/
4018 gboolean
4019 g_file_set_attributes_finish (GFile         *file,
4020                               GAsyncResult  *result,
4021                               GFileInfo    **info,
4022                               GError       **error)
4023 {
4024   GFileIface *iface;
4025
4026   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4027   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4028
4029   /* No standard handling of errors here, as we must set info even
4030    * on errors
4031    */
4032   iface = G_FILE_GET_IFACE (file);
4033   return (* iface->set_attributes_finish) (file, result, info, error);
4034 }
4035
4036 /**
4037  * g_file_set_attribute_string:
4038  * @file: input #GFile.
4039  * @attribute: a string containing the attribute's name.
4040  * @value: a string containing the attribute's value.
4041  * @flags: #GFileQueryInfoFlags.
4042  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4043  * @error: a #GError, or %NULL
4044  *
4045  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value.
4046  * If @attribute is of a different type, this operation will fail.
4047  *
4048  * If @cancellable is not %NULL, then the operation can be cancelled by
4049  * triggering the cancellable object from another thread. If the operation
4050  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4051  *
4052  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
4053  **/
4054 gboolean
4055 g_file_set_attribute_string (GFile                *file,
4056                              const char           *attribute,
4057                              const char           *value,
4058                              GFileQueryInfoFlags   flags,
4059                              GCancellable         *cancellable,
4060                              GError              **error)
4061 {
4062   return g_file_set_attribute (file, attribute,
4063                                G_FILE_ATTRIBUTE_TYPE_STRING, (gpointer)value,
4064                                flags, cancellable, error);
4065 }
4066
4067 /**
4068  * g_file_set_attribute_byte_string:
4069  * @file: input #GFile.
4070  * @attribute: a string containing the attribute's name.
4071  * @value: a string containing the attribute's new value.
4072  * @flags: a #GFileQueryInfoFlags.
4073  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4074  * @error: a #GError, or %NULL
4075  *
4076  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value.
4077  * If @attribute is of a different type, this operation will fail,
4078  * returning %FALSE.
4079  *
4080  * If @cancellable is not %NULL, then the operation can be cancelled by
4081  * triggering the cancellable object from another thread. If the operation
4082  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4083  *
4084  * Returns: %TRUE if the @attribute was successfully set to @value
4085  * in the @file, %FALSE otherwise.
4086  **/
4087 gboolean
4088 g_file_set_attribute_byte_string  (GFile                *file,
4089                                    const char           *attribute,
4090                                    const char           *value,
4091                                    GFileQueryInfoFlags   flags,
4092                                    GCancellable         *cancellable,
4093                                    GError              **error)
4094 {
4095   return g_file_set_attribute (file, attribute,
4096                                G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, (gpointer)value,
4097                                flags, cancellable, error);
4098 }
4099
4100 /**
4101  * g_file_set_attribute_uint32:
4102  * @file: input #GFile.
4103  * @attribute: a string containing the attribute's name.
4104  * @value: a #guint32 containing the attribute's new value.
4105  * @flags: a #GFileQueryInfoFlags.
4106  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4107  * @error: a #GError, or %NULL
4108  *
4109  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value.
4110  * If @attribute is of a different type, this operation will fail.
4111  *
4112  * If @cancellable is not %NULL, then the operation can be cancelled by
4113  * triggering the cancellable object from another thread. If the operation
4114  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4115  *
4116  * Returns: %TRUE if the @attribute was successfully set to @value
4117  * in the @file, %FALSE otherwise.
4118  **/
4119 gboolean
4120 g_file_set_attribute_uint32 (GFile                *file,
4121                              const char           *attribute,
4122                              guint32               value,
4123                              GFileQueryInfoFlags   flags,
4124                              GCancellable         *cancellable,
4125                              GError              **error)
4126 {
4127   return g_file_set_attribute (file, attribute,
4128                                G_FILE_ATTRIBUTE_TYPE_UINT32, &value,
4129                                flags, cancellable, error);
4130 }
4131
4132 /**
4133  * g_file_set_attribute_int32:
4134  * @file: input #GFile.
4135  * @attribute: a string containing the attribute's name.
4136  * @value: a #gint32 containing the attribute's new value.
4137  * @flags: a #GFileQueryInfoFlags.
4138  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4139  * @error: a #GError, or %NULL
4140  *
4141  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value.
4142  * If @attribute is of a different type, this operation will fail.
4143  *
4144  * If @cancellable is not %NULL, then the operation can be cancelled by
4145  * triggering the cancellable object from another thread. If the operation
4146  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4147  *
4148  * Returns: %TRUE if the @attribute was successfully set to @value
4149  * in the @file, %FALSE otherwise.
4150  **/
4151 gboolean
4152 g_file_set_attribute_int32 (GFile                *file,
4153                             const char           *attribute,
4154                             gint32                value,
4155                             GFileQueryInfoFlags   flags,
4156                             GCancellable         *cancellable,
4157                             GError              **error)
4158 {
4159   return g_file_set_attribute (file, attribute,
4160                                G_FILE_ATTRIBUTE_TYPE_INT32, &value,
4161                                flags, cancellable, error);
4162 }
4163
4164 /**
4165  * g_file_set_attribute_uint64:
4166  * @file: input #GFile.
4167  * @attribute: a string containing the attribute's name.
4168  * @value: a #guint64 containing the attribute's new value.
4169  * @flags: a #GFileQueryInfoFlags.
4170  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4171  * @error: a #GError, or %NULL
4172  *
4173  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value.
4174  * If @attribute is of a different type, this operation will fail.
4175  *
4176  * If @cancellable is not %NULL, then the operation can be cancelled by
4177  * triggering the cancellable object from another thread. If the operation
4178  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4179  *
4180  * Returns: %TRUE if the @attribute was successfully set to @value
4181  * in the @file, %FALSE otherwise.
4182  **/
4183 gboolean
4184 g_file_set_attribute_uint64 (GFile                *file,
4185                              const char           *attribute,
4186                              guint64               value,
4187                              GFileQueryInfoFlags   flags,
4188                              GCancellable         *cancellable,
4189                              GError              **error)
4190  {
4191   return g_file_set_attribute (file, attribute,
4192                                G_FILE_ATTRIBUTE_TYPE_UINT64, &value,
4193                                flags, cancellable, error);
4194 }
4195
4196 /**
4197  * g_file_set_attribute_int64:
4198  * @file: input #GFile.
4199  * @attribute: a string containing the attribute's name.
4200  * @value: a #guint64 containing the attribute's new value.
4201  * @flags: a #GFileQueryInfoFlags.
4202  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4203  * @error: a #GError, or %NULL
4204  *
4205  * Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value.
4206  * If @attribute is of a different type, this operation will fail.
4207  *
4208  * If @cancellable is not %NULL, then the operation can be cancelled by
4209  * triggering the cancellable object from another thread. If the operation
4210  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4211  *
4212  * Returns: %TRUE if the @attribute was successfully set, %FALSE otherwise.
4213  **/
4214 gboolean
4215 g_file_set_attribute_int64 (GFile                *file,
4216                             const char           *attribute,
4217                             gint64                value,
4218                             GFileQueryInfoFlags   flags,
4219                             GCancellable         *cancellable,
4220                             GError              **error)
4221 {
4222   return g_file_set_attribute (file, attribute,
4223                                G_FILE_ATTRIBUTE_TYPE_INT64, &value,
4224                                flags, cancellable, error);
4225 }
4226
4227 /**
4228  * g_file_mount_mountable:
4229  * @file: input #GFile.
4230  * @flags: flags affecting the operation
4231  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
4232  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4233  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4234  * @user_data: (closure): the data to pass to callback function
4235  *
4236  * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
4237  * Using @mount_operation, you can request callbacks when, for instance,
4238  * passwords are needed during authentication.
4239  *
4240  * If @cancellable is not %NULL, then the operation can be cancelled by
4241  * triggering the cancellable object from another thread. If the operation
4242  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4243  *
4244  * When the operation is finished, @callback will be called. You can then call
4245  * g_file_mount_mountable_finish() to get the result of the operation.
4246  **/
4247 void
4248 g_file_mount_mountable (GFile               *file,
4249                         GMountMountFlags     flags,
4250                         GMountOperation     *mount_operation,
4251                         GCancellable        *cancellable,
4252                         GAsyncReadyCallback  callback,
4253                         gpointer             user_data)
4254 {
4255   GFileIface *iface;
4256
4257   g_return_if_fail (G_IS_FILE (file));
4258
4259   iface = G_FILE_GET_IFACE (file);
4260
4261   if (iface->mount_mountable == NULL)
4262     {
4263       g_simple_async_report_error_in_idle (G_OBJECT (file),
4264                                            callback,
4265                                            user_data,
4266                                            G_IO_ERROR,
4267                                            G_IO_ERROR_NOT_SUPPORTED,
4268                                            _("Operation not supported"));
4269       return;
4270     }
4271
4272   (* iface->mount_mountable) (file,
4273                               flags,
4274                               mount_operation,
4275                               cancellable,
4276                               callback,
4277                               user_data);
4278 }
4279
4280 /**
4281  * g_file_mount_mountable_finish:
4282  * @file: input #GFile.
4283  * @result: a #GAsyncResult.
4284  * @error: a #GError, or %NULL
4285  *
4286  * Finishes a mount operation. See g_file_mount_mountable() for details.
4287  *
4288  * Finish an asynchronous mount operation that was started
4289  * with g_file_mount_mountable().
4290  *
4291  * Returns: (transfer full): a #GFile or %NULL on error.
4292  *     Free the returned object with g_object_unref().
4293  **/
4294 GFile *
4295 g_file_mount_mountable_finish (GFile         *file,
4296                                GAsyncResult  *result,
4297                                GError       **error)
4298 {
4299   GFileIface *iface;
4300
4301   g_return_val_if_fail (G_IS_FILE (file), NULL);
4302   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
4303
4304   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4305     {
4306       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4307       if (g_simple_async_result_propagate_error (simple, error))
4308         return NULL;
4309     }
4310
4311   iface = G_FILE_GET_IFACE (file);
4312   return (* iface->mount_mountable_finish) (file, result, error);
4313 }
4314
4315 /**
4316  * g_file_unmount_mountable:
4317  * @file: input #GFile.
4318  * @flags: flags affecting the operation
4319  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4320  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4321  * @user_data: (closure): the data to pass to callback function
4322  *
4323  * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
4324  *
4325  * If @cancellable is not %NULL, then the operation can be cancelled by
4326  * triggering the cancellable object from another thread. If the operation
4327  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4328  *
4329  * When the operation is finished, @callback will be called. You can then call
4330  * g_file_unmount_mountable_finish() to get the result of the operation.
4331  *
4332  * Deprecated: 2.22: Use g_file_unmount_mountable_with_operation() instead.
4333  **/
4334 void
4335 g_file_unmount_mountable (GFile               *file,
4336                           GMountUnmountFlags   flags,
4337                           GCancellable        *cancellable,
4338                           GAsyncReadyCallback  callback,
4339                           gpointer             user_data)
4340 {
4341   GFileIface *iface;
4342
4343   g_return_if_fail (G_IS_FILE (file));
4344
4345   iface = G_FILE_GET_IFACE (file);
4346
4347   if (iface->unmount_mountable == NULL)
4348     {
4349       g_simple_async_report_error_in_idle (G_OBJECT (file),
4350                                            callback,
4351                                            user_data,
4352                                            G_IO_ERROR,
4353                                            G_IO_ERROR_NOT_SUPPORTED,
4354                                            _("Operation not supported"));
4355       return;
4356     }
4357
4358   (* iface->unmount_mountable) (file,
4359                                 flags,
4360                                 cancellable,
4361                                 callback,
4362                                 user_data);
4363 }
4364
4365 /**
4366  * g_file_unmount_mountable_finish:
4367  * @file: input #GFile.
4368  * @result: a #GAsyncResult.
4369  * @error: a #GError, or %NULL
4370  *
4371  * Finishes an unmount operation, see g_file_unmount_mountable() for details.
4372  *
4373  * Finish an asynchronous unmount operation that was started
4374  * with g_file_unmount_mountable().
4375  *
4376  * Returns: %TRUE if the operation finished successfully. %FALSE
4377  * otherwise.
4378  *
4379  * Deprecated: 2.22: Use g_file_unmount_mountable_with_operation_finish() instead.
4380  **/
4381 gboolean
4382 g_file_unmount_mountable_finish (GFile         *file,
4383                                  GAsyncResult  *result,
4384                                  GError       **error)
4385 {
4386   GFileIface *iface;
4387
4388   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4389   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4390
4391   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4392     {
4393       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4394       if (g_simple_async_result_propagate_error (simple, error))
4395         return FALSE;
4396     }
4397
4398   iface = G_FILE_GET_IFACE (file);
4399   return (* iface->unmount_mountable_finish) (file, result, error);
4400 }
4401
4402 /**
4403  * g_file_unmount_mountable_with_operation:
4404  * @file: input #GFile.
4405  * @flags: flags affecting the operation
4406  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
4407  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4408  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4409  * @user_data: (closure): the data to pass to callback function
4410  *
4411  * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
4412  *
4413  * If @cancellable is not %NULL, then the operation can be cancelled by
4414  * triggering the cancellable object from another thread. If the operation
4415  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4416  *
4417  * When the operation is finished, @callback will be called. You can then call
4418  * g_file_unmount_mountable_finish() to get the result of the operation.
4419  *
4420  * Since: 2.22
4421  **/
4422 void
4423 g_file_unmount_mountable_with_operation (GFile               *file,
4424                                          GMountUnmountFlags   flags,
4425                                          GMountOperation     *mount_operation,
4426                                          GCancellable        *cancellable,
4427                                          GAsyncReadyCallback  callback,
4428                                          gpointer             user_data)
4429 {
4430   GFileIface *iface;
4431
4432   g_return_if_fail (G_IS_FILE (file));
4433
4434   iface = G_FILE_GET_IFACE (file);
4435
4436   if (iface->unmount_mountable == NULL && iface->unmount_mountable_with_operation == NULL)
4437     {
4438       g_simple_async_report_error_in_idle (G_OBJECT (file),
4439                                            callback,
4440                                            user_data,
4441                                            G_IO_ERROR,
4442                                            G_IO_ERROR_NOT_SUPPORTED,
4443                                            _("Operation not supported"));
4444       return;
4445     }
4446
4447   if (iface->unmount_mountable_with_operation != NULL)
4448     (* iface->unmount_mountable_with_operation) (file,
4449                                                  flags,
4450                                                  mount_operation,
4451                                                  cancellable,
4452                                                  callback,
4453                                                  user_data);
4454   else
4455     (* iface->unmount_mountable) (file,
4456                                   flags,
4457                                   cancellable,
4458                                   callback,
4459                                   user_data);
4460 }
4461
4462 /**
4463  * g_file_unmount_mountable_with_operation_finish:
4464  * @file: input #GFile.
4465  * @result: a #GAsyncResult.
4466  * @error: a #GError, or %NULL
4467  *
4468  * Finishes an unmount operation, see g_file_unmount_mountable_with_operation() for details.
4469  *
4470  * Finish an asynchronous unmount operation that was started
4471  * with g_file_unmount_mountable_with_operation().
4472  *
4473  * Returns: %TRUE if the operation finished successfully. %FALSE
4474  * otherwise.
4475  *
4476  * Since: 2.22
4477  **/
4478 gboolean
4479 g_file_unmount_mountable_with_operation_finish (GFile         *file,
4480                                                 GAsyncResult  *result,
4481                                                 GError       **error)
4482 {
4483   GFileIface *iface;
4484
4485   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4486   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4487
4488   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4489     {
4490       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4491       if (g_simple_async_result_propagate_error (simple, error))
4492         return FALSE;
4493     }
4494
4495   iface = G_FILE_GET_IFACE (file);
4496   if (iface->unmount_mountable_with_operation_finish != NULL)
4497     return (* iface->unmount_mountable_with_operation_finish) (file, result, error);
4498   else
4499     return (* iface->unmount_mountable_finish) (file, result, error);
4500 }
4501
4502 /**
4503  * g_file_eject_mountable:
4504  * @file: input #GFile.
4505  * @flags: flags affecting the operation
4506  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4507  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4508  * @user_data: (closure): the data to pass to callback function
4509  *
4510  * Starts an asynchronous eject on a mountable.
4511  * When this operation has completed, @callback will be called with
4512  * @user_user data, and the operation can be finalized with
4513  * g_file_eject_mountable_finish().
4514  *
4515  * If @cancellable is not %NULL, then the operation can be cancelled by
4516  * triggering the cancellable object from another thread. If the operation
4517  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4518  *
4519  * Deprecated: 2.22: Use g_file_eject_mountable_with_operation() instead.
4520  **/
4521 void
4522 g_file_eject_mountable (GFile               *file,
4523                         GMountUnmountFlags   flags,
4524                         GCancellable        *cancellable,
4525                         GAsyncReadyCallback  callback,
4526                         gpointer             user_data)
4527 {
4528   GFileIface *iface;
4529
4530   g_return_if_fail (G_IS_FILE (file));
4531
4532   iface = G_FILE_GET_IFACE (file);
4533
4534   if (iface->eject_mountable == NULL)
4535     {
4536       g_simple_async_report_error_in_idle (G_OBJECT (file),
4537                                            callback,
4538                                            user_data,
4539                                            G_IO_ERROR,
4540                                            G_IO_ERROR_NOT_SUPPORTED,
4541                                            _("Operation not supported"));
4542       return;
4543     }
4544
4545   (* iface->eject_mountable) (file,
4546                               flags,
4547                               cancellable,
4548                               callback,
4549                               user_data);
4550 }
4551
4552 /**
4553  * g_file_eject_mountable_finish:
4554  * @file: input #GFile.
4555  * @result: a #GAsyncResult.
4556  * @error: a #GError, or %NULL
4557  *
4558  * Finishes an asynchronous eject operation started by
4559  * g_file_eject_mountable().
4560  *
4561  * Returns: %TRUE if the @file was ejected successfully. %FALSE
4562  * otherwise.
4563  *
4564  * Deprecated: 2.22: Use g_file_eject_mountable_with_operation_finish() instead.
4565  **/
4566 gboolean
4567 g_file_eject_mountable_finish (GFile         *file,
4568                                GAsyncResult  *result,
4569                                GError       **error)
4570 {
4571   GFileIface *iface;
4572
4573   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4574   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4575
4576   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4577     {
4578       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4579       if (g_simple_async_result_propagate_error (simple, error))
4580         return FALSE;
4581     }
4582
4583   iface = G_FILE_GET_IFACE (file);
4584   return (* iface->eject_mountable_finish) (file, result, error);
4585 }
4586
4587 /**
4588  * g_file_eject_mountable_with_operation:
4589  * @file: input #GFile.
4590  * @flags: flags affecting the operation
4591  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
4592  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4593  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
4594  * @user_data: (closure): the data to pass to callback function
4595  *
4596  * Starts an asynchronous eject on a mountable.
4597  * When this operation has completed, @callback will be called with
4598  * @user_user data, and the operation can be finalized with
4599  * g_file_eject_mountable_with_operation_finish().
4600  *
4601  * If @cancellable is not %NULL, then the operation can be cancelled by
4602  * triggering the cancellable object from another thread. If the operation
4603  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4604  *
4605  * Since: 2.22
4606  **/
4607 void
4608 g_file_eject_mountable_with_operation (GFile               *file,
4609                                        GMountUnmountFlags   flags,
4610                                        GMountOperation     *mount_operation,
4611                                        GCancellable        *cancellable,
4612                                        GAsyncReadyCallback  callback,
4613                                        gpointer             user_data)
4614 {
4615   GFileIface *iface;
4616
4617   g_return_if_fail (G_IS_FILE (file));
4618
4619   iface = G_FILE_GET_IFACE (file);
4620
4621   if (iface->eject_mountable == NULL && iface->eject_mountable_with_operation == NULL)
4622     {
4623       g_simple_async_report_error_in_idle (G_OBJECT (file),
4624                                            callback,
4625                                            user_data,
4626                                            G_IO_ERROR,
4627                                            G_IO_ERROR_NOT_SUPPORTED,
4628                                            _("Operation not supported"));
4629       return;
4630     }
4631
4632   if (iface->eject_mountable_with_operation != NULL)
4633     (* iface->eject_mountable_with_operation) (file,
4634                                                flags,
4635                                                mount_operation,
4636                                                cancellable,
4637                                                callback,
4638                                                user_data);
4639   else
4640     (* iface->eject_mountable) (file,
4641                                 flags,
4642                                 cancellable,
4643                                 callback,
4644                                 user_data);
4645 }
4646
4647 /**
4648  * g_file_eject_mountable_with_operation_finish:
4649  * @file: input #GFile.
4650  * @result: a #GAsyncResult.
4651  * @error: a #GError, or %NULL
4652  *
4653  * Finishes an asynchronous eject operation started by
4654  * g_file_eject_mountable_with_operation().
4655  *
4656  * Returns: %TRUE if the @file was ejected successfully. %FALSE
4657  * otherwise.
4658  *
4659  * Since: 2.22
4660  **/
4661 gboolean
4662 g_file_eject_mountable_with_operation_finish (GFile         *file,
4663                                               GAsyncResult  *result,
4664                                               GError       **error)
4665 {
4666   GFileIface *iface;
4667
4668   g_return_val_if_fail (G_IS_FILE (file), FALSE);
4669   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
4670
4671   if (G_IS_SIMPLE_ASYNC_RESULT (result))
4672     {
4673       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
4674       if (g_simple_async_result_propagate_error (simple, error))
4675         return FALSE;
4676     }
4677
4678   iface = G_FILE_GET_IFACE (file);
4679   if (iface->eject_mountable_with_operation_finish != NULL)
4680     return (* iface->eject_mountable_with_operation_finish) (file, result, error);
4681   else
4682     return (* iface->eject_mountable_finish) (file, result, error);
4683 }
4684
4685 /**
4686  * g_file_monitor_directory:
4687  * @file: input #GFile.
4688  * @flags: a set of #GFileMonitorFlags.
4689  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4690  * @error: a #GError, or %NULL.
4691  *
4692  * Obtains a directory monitor for the given file.
4693  * This may fail if directory monitoring is not supported.
4694  *
4695  * If @cancellable is not %NULL, then the operation can be cancelled by
4696  * triggering the cancellable object from another thread. If the operation
4697  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4698  *
4699  * Virtual: monitor_dir
4700  * Returns: (transfer full): a #GFileMonitor for the given @file, or %NULL on error.
4701  *     Free the returned object with g_object_unref().
4702  **/
4703 GFileMonitor*
4704 g_file_monitor_directory (GFile             *file,
4705                           GFileMonitorFlags  flags,
4706                           GCancellable      *cancellable,
4707                           GError           **error)
4708 {
4709   GFileIface *iface;
4710
4711   g_return_val_if_fail (G_IS_FILE (file), NULL);
4712
4713   if (g_cancellable_set_error_if_cancelled (cancellable, error))
4714     return NULL;
4715
4716   iface = G_FILE_GET_IFACE (file);
4717
4718   if (iface->monitor_dir == NULL)
4719     {
4720       g_set_error_literal (error, G_IO_ERROR,
4721                            G_IO_ERROR_NOT_SUPPORTED,
4722                            _("Operation not supported"));
4723       return NULL;
4724     }
4725
4726   return (* iface->monitor_dir) (file, flags, cancellable, error);
4727 }
4728
4729 /**
4730  * g_file_monitor_file:
4731  * @file: input #GFile.
4732  * @flags: a set of #GFileMonitorFlags.
4733  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
4734  * @error: a #GError, or %NULL.
4735  *
4736  * Obtains a file monitor for the given file. If no file notification
4737  * mechanism exists, then regular polling of the file is used.
4738  *
4739  * If @cancellable is not %NULL, then the operation can be cancelled by
4740  * triggering the cancellable object from another thread. If the operation
4741  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4742  *
4743  * Returns: (transfer full): a #GFileMonitor for the given @file, or %NULL on error.
4744  *     Free the returned object with g_object_unref().
4745  **/
4746 GFileMonitor*
4747 g_file_monitor_file (GFile             *file,
4748                      GFileMonitorFlags  flags,
4749                      GCancellable      *cancellable,
4750                      GError           **error)
4751 {
4752   GFileIface *iface;
4753   GFileMonitor *monitor;
4754
4755   g_return_val_if_fail (G_IS_FILE (file), NULL);
4756
4757   if (g_cancellable_set_error_if_cancelled (cancellable, error))
4758     return NULL;
4759
4760   iface = G_FILE_GET_IFACE (file);
4761
4762   monitor = NULL;
4763
4764   if (iface->monitor_file)
4765     monitor = (* iface->monitor_file) (file, flags, cancellable, NULL);
4766
4767 /* Fallback to polling */
4768   if (monitor == NULL)
4769     monitor = _g_poll_file_monitor_new (file);
4770
4771   return monitor;
4772 }
4773
4774 /**
4775  * g_file_monitor:
4776  * @file: input #GFile
4777  * @flags: a set of #GFileMonitorFlags
4778  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
4779  * @error: a #GError, or %NULL
4780  *
4781  * Obtains a file or directory monitor for the given file, depending
4782  * on the type of the file.
4783  *
4784  * If @cancellable is not %NULL, then the operation can be cancelled by
4785  * triggering the cancellable object from another thread. If the operation
4786  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4787  *
4788  * Returns: (transfer full): a #GFileMonitor for the given @file, or %NULL on error.
4789  *     Free the returned object with g_object_unref().
4790  *
4791  * Since: 2.18
4792  */
4793 GFileMonitor*
4794 g_file_monitor (GFile             *file,
4795                 GFileMonitorFlags  flags,
4796                 GCancellable      *cancellable,
4797                 GError           **error)
4798 {
4799   if (g_file_query_file_type (file, 0, cancellable) == G_FILE_TYPE_DIRECTORY)
4800     return g_file_monitor_directory (file, flags, cancellable, error);
4801   else
4802     return g_file_monitor_file (file, flags, cancellable, error);
4803 }
4804
4805 /********************************************
4806  *   Default implementation of async ops    *
4807  ********************************************/
4808
4809 typedef struct {
4810   char *attributes;
4811   GFileQueryInfoFlags flags;
4812   GFileInfo *info;
4813 } QueryInfoAsyncData;
4814
4815 static void
4816 query_info_data_free (QueryInfoAsyncData *data)
4817 {
4818   if (data->info)
4819     g_object_unref (data->info);
4820   g_free (data->attributes);
4821   g_free (data);
4822 }
4823
4824 static void
4825 query_info_async_thread (GSimpleAsyncResult *res,
4826                          GObject            *object,
4827                          GCancellable       *cancellable)
4828 {
4829   GError *error = NULL;
4830   QueryInfoAsyncData *data;
4831   GFileInfo *info;
4832
4833   data = g_simple_async_result_get_op_res_gpointer (res);
4834
4835   info = g_file_query_info (G_FILE (object), data->attributes, data->flags, cancellable, &error);
4836
4837   if (info == NULL)
4838     g_simple_async_result_take_error (res, error);
4839   else
4840     data->info = info;
4841 }
4842
4843 static void
4844 g_file_real_query_info_async (GFile               *file,
4845                               const char          *attributes,
4846                               GFileQueryInfoFlags  flags,
4847                               int                  io_priority,
4848                               GCancellable        *cancellable,
4849                               GAsyncReadyCallback  callback,
4850                               gpointer             user_data)
4851 {
4852   GSimpleAsyncResult *res;
4853   QueryInfoAsyncData *data;
4854
4855   data = g_new0 (QueryInfoAsyncData, 1);
4856   data->attributes = g_strdup (attributes);
4857   data->flags = flags;
4858
4859   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_query_info_async);
4860   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_info_data_free);
4861
4862   g_simple_async_result_run_in_thread (res, query_info_async_thread, io_priority, cancellable);
4863   g_object_unref (res);
4864 }
4865
4866 static GFileInfo *
4867 g_file_real_query_info_finish (GFile         *file,
4868                                GAsyncResult  *res,
4869                                GError       **error)
4870 {
4871   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4872   QueryInfoAsyncData *data;
4873
4874   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_query_info_async);
4875
4876   data = g_simple_async_result_get_op_res_gpointer (simple);
4877   if (data->info)
4878     return g_object_ref (data->info);
4879
4880   return NULL;
4881 }
4882
4883 typedef struct {
4884   char *attributes;
4885   GFileInfo *info;
4886 } QueryFilesystemInfoAsyncData;
4887
4888 static void
4889 query_filesystem_info_data_free (QueryFilesystemInfoAsyncData *data)
4890 {
4891   if (data->info)
4892     g_object_unref (data->info);
4893   g_free (data->attributes);
4894   g_free (data);
4895 }
4896
4897 static void
4898 query_filesystem_info_async_thread (GSimpleAsyncResult *res,
4899                                     GObject            *object,
4900                                     GCancellable       *cancellable)
4901 {
4902   GError *error = NULL;
4903   QueryFilesystemInfoAsyncData *data;
4904   GFileInfo *info;
4905
4906   data = g_simple_async_result_get_op_res_gpointer (res);
4907
4908   info = g_file_query_filesystem_info (G_FILE (object), data->attributes, cancellable, &error);
4909
4910   if (info == NULL)
4911     g_simple_async_result_take_error (res, error);
4912   else
4913     data->info = info;
4914 }
4915
4916 static void
4917 g_file_real_query_filesystem_info_async (GFile               *file,
4918                                          const char          *attributes,
4919                                          int                  io_priority,
4920                                          GCancellable        *cancellable,
4921                                          GAsyncReadyCallback  callback,
4922                                          gpointer             user_data)
4923 {
4924   GSimpleAsyncResult *res;
4925   QueryFilesystemInfoAsyncData *data;
4926
4927   data = g_new0 (QueryFilesystemInfoAsyncData, 1);
4928   data->attributes = g_strdup (attributes);
4929
4930   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_query_filesystem_info_async);
4931   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_filesystem_info_data_free);
4932
4933   g_simple_async_result_run_in_thread (res, query_filesystem_info_async_thread, io_priority, cancellable);
4934   g_object_unref (res);
4935 }
4936
4937 static GFileInfo *
4938 g_file_real_query_filesystem_info_finish (GFile         *file,
4939                                           GAsyncResult  *res,
4940                                           GError       **error)
4941 {
4942   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
4943   QueryFilesystemInfoAsyncData *data;
4944
4945   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_query_filesystem_info_async);
4946
4947   data = g_simple_async_result_get_op_res_gpointer (simple);
4948   if (data->info)
4949     return g_object_ref (data->info);
4950
4951   return NULL;
4952 }
4953
4954 typedef struct {
4955   char *attributes;
4956   GFileQueryInfoFlags flags;
4957   GFileEnumerator *enumerator;
4958 } EnumerateChildrenAsyncData;
4959
4960 static void
4961 enumerate_children_data_free (EnumerateChildrenAsyncData *data)
4962 {
4963   if (data->enumerator)
4964     g_object_unref (data->enumerator);
4965   g_free (data->attributes);
4966   g_free (data);
4967 }
4968
4969 static void
4970 enumerate_children_async_thread (GSimpleAsyncResult *res,
4971                                  GObject            *object,
4972                                  GCancellable       *cancellable)
4973 {
4974   GError *error = NULL;
4975   EnumerateChildrenAsyncData *data;
4976   GFileEnumerator *enumerator;
4977
4978   data = g_simple_async_result_get_op_res_gpointer (res);
4979
4980   enumerator = g_file_enumerate_children (G_FILE (object), data->attributes, data->flags, cancellable, &error);
4981
4982   if (enumerator == NULL)
4983     g_simple_async_result_take_error (res, error);
4984   else
4985     data->enumerator = enumerator;
4986 }
4987
4988 static void
4989 g_file_real_enumerate_children_async (GFile               *file,
4990                                       const char          *attributes,
4991                                       GFileQueryInfoFlags  flags,
4992                                       int                  io_priority,
4993                                       GCancellable        *cancellable,
4994                                       GAsyncReadyCallback  callback,
4995                                       gpointer             user_data)
4996 {
4997   GSimpleAsyncResult *res;
4998   EnumerateChildrenAsyncData *data;
4999
5000   data = g_new0 (EnumerateChildrenAsyncData, 1);
5001   data->attributes = g_strdup (attributes);
5002   data->flags = flags;
5003
5004   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_enumerate_children_async);
5005   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)enumerate_children_data_free);
5006
5007   g_simple_async_result_run_in_thread (res, enumerate_children_async_thread, io_priority, cancellable);
5008   g_object_unref (res);
5009 }
5010
5011 static GFileEnumerator *
5012 g_file_real_enumerate_children_finish (GFile         *file,
5013                                        GAsyncResult  *res,
5014                                        GError       **error)
5015 {
5016   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5017   EnumerateChildrenAsyncData *data;
5018
5019   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_enumerate_children_async);
5020
5021   data = g_simple_async_result_get_op_res_gpointer (simple);
5022   if (data->enumerator)
5023     return g_object_ref (data->enumerator);
5024
5025   return NULL;
5026 }
5027
5028 static void
5029 open_read_async_thread (GSimpleAsyncResult *res,
5030                         GObject            *object,
5031                         GCancellable       *cancellable)
5032 {
5033   GFileIface *iface;
5034   GFileInputStream *stream;
5035   GError *error = NULL;
5036
5037   iface = G_FILE_GET_IFACE (object);
5038
5039   if (iface->read_fn == NULL)
5040     {
5041       g_set_error_literal (&error, G_IO_ERROR,
5042                            G_IO_ERROR_NOT_SUPPORTED,
5043                            _("Operation not supported"));
5044
5045       g_simple_async_result_take_error (res, error);
5046
5047       return;
5048     }
5049
5050   stream = iface->read_fn (G_FILE (object), cancellable, &error);
5051
5052   if (stream == NULL)
5053     g_simple_async_result_take_error (res, error);
5054   else
5055     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
5056 }
5057
5058 static void
5059 g_file_real_read_async (GFile               *file,
5060                         int                  io_priority,
5061                         GCancellable        *cancellable,
5062                         GAsyncReadyCallback  callback,
5063                         gpointer             user_data)
5064 {
5065   GSimpleAsyncResult *res;
5066
5067   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_read_async);
5068
5069   g_simple_async_result_run_in_thread (res, open_read_async_thread, io_priority, cancellable);
5070   g_object_unref (res);
5071 }
5072
5073 static GFileInputStream *
5074 g_file_real_read_finish (GFile         *file,
5075                          GAsyncResult  *res,
5076                          GError       **error)
5077 {
5078   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5079   gpointer op;
5080
5081   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_read_async);
5082
5083   op = g_simple_async_result_get_op_res_gpointer (simple);
5084   if (op)
5085     return g_object_ref (op);
5086
5087   return NULL;
5088 }
5089
5090 static void
5091 append_to_async_thread (GSimpleAsyncResult *res,
5092                         GObject            *object,
5093                         GCancellable       *cancellable)
5094 {
5095   GFileIface *iface;
5096   GFileCreateFlags *data;
5097   GFileOutputStream *stream;
5098   GError *error = NULL;
5099
5100   iface = G_FILE_GET_IFACE (object);
5101
5102   data = g_simple_async_result_get_op_res_gpointer (res);
5103
5104   stream = iface->append_to (G_FILE (object), *data, cancellable, &error);
5105
5106   if (stream == NULL)
5107     g_simple_async_result_take_error (res, error);
5108   else
5109     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
5110 }
5111
5112 static void
5113 g_file_real_append_to_async (GFile               *file,
5114                              GFileCreateFlags     flags,
5115                              int                  io_priority,
5116                              GCancellable        *cancellable,
5117                              GAsyncReadyCallback  callback,
5118                              gpointer             user_data)
5119 {
5120   GFileCreateFlags *data;
5121   GSimpleAsyncResult *res;
5122
5123   data = g_new0 (GFileCreateFlags, 1);
5124   *data = flags;
5125
5126   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_append_to_async);
5127   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
5128
5129   g_simple_async_result_run_in_thread (res, append_to_async_thread, io_priority, cancellable);
5130   g_object_unref (res);
5131 }
5132
5133 static GFileOutputStream *
5134 g_file_real_append_to_finish (GFile         *file,
5135                               GAsyncResult  *res,
5136                               GError       **error)
5137 {
5138   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5139   gpointer op;
5140
5141   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_append_to_async);
5142
5143   op = g_simple_async_result_get_op_res_gpointer (simple);
5144   if (op)
5145     return g_object_ref (op);
5146
5147   return NULL;
5148 }
5149
5150 static void
5151 create_async_thread (GSimpleAsyncResult *res,
5152                      GObject            *object,
5153                      GCancellable       *cancellable)
5154 {
5155   GFileIface *iface;
5156   GFileCreateFlags *data;
5157   GFileOutputStream *stream;
5158   GError *error = NULL;
5159
5160   iface = G_FILE_GET_IFACE (object);
5161
5162   data = g_simple_async_result_get_op_res_gpointer (res);
5163
5164   stream = iface->create (G_FILE (object), *data, cancellable, &error);
5165
5166   if (stream == NULL)
5167     g_simple_async_result_take_error (res, error);
5168   else
5169     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
5170 }
5171
5172 static void
5173 g_file_real_create_async (GFile               *file,
5174                           GFileCreateFlags     flags,
5175                           int                  io_priority,
5176                           GCancellable        *cancellable,
5177                           GAsyncReadyCallback  callback,
5178                           gpointer             user_data)
5179 {
5180   GFileCreateFlags *data;
5181   GSimpleAsyncResult *res;
5182
5183   data = g_new0 (GFileCreateFlags, 1);
5184   *data = flags;
5185
5186   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_create_async);
5187   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
5188
5189   g_simple_async_result_run_in_thread (res, create_async_thread, io_priority, cancellable);
5190   g_object_unref (res);
5191 }
5192
5193 static GFileOutputStream *
5194 g_file_real_create_finish (GFile         *file,
5195                            GAsyncResult  *res,
5196                            GError       **error)
5197 {
5198   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5199   gpointer op;
5200
5201   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_create_async);
5202
5203   op = g_simple_async_result_get_op_res_gpointer (simple);
5204   if (op)
5205     return g_object_ref (op);
5206
5207   return NULL;
5208 }
5209
5210 typedef struct {
5211   GFileOutputStream *stream;
5212   char *etag;
5213   gboolean make_backup;
5214   GFileCreateFlags flags;
5215 } ReplaceAsyncData;
5216
5217 static void
5218 replace_async_data_free (ReplaceAsyncData *data)
5219 {
5220   if (data->stream)
5221     g_object_unref (data->stream);
5222   g_free (data->etag);
5223   g_free (data);
5224 }
5225
5226 static void
5227 replace_async_thread (GSimpleAsyncResult *res,
5228                       GObject            *object,
5229                       GCancellable       *cancellable)
5230 {
5231   GFileIface *iface;
5232   GFileOutputStream *stream;
5233   GError *error = NULL;
5234   ReplaceAsyncData *data;
5235
5236   iface = G_FILE_GET_IFACE (object);
5237
5238   data = g_simple_async_result_get_op_res_gpointer (res);
5239
5240   stream = iface->replace (G_FILE (object),
5241                            data->etag,
5242                            data->make_backup,
5243                            data->flags,
5244                            cancellable,
5245                            &error);
5246
5247   if (stream == NULL)
5248     g_simple_async_result_take_error (res, error);
5249   else
5250     data->stream = stream;
5251 }
5252
5253 static void
5254 g_file_real_replace_async (GFile               *file,
5255                            const char          *etag,
5256                            gboolean             make_backup,
5257                            GFileCreateFlags     flags,
5258                            int                  io_priority,
5259                            GCancellable        *cancellable,
5260                            GAsyncReadyCallback  callback,
5261                            gpointer             user_data)
5262 {
5263   GSimpleAsyncResult *res;
5264   ReplaceAsyncData *data;
5265
5266   data = g_new0 (ReplaceAsyncData, 1);
5267   data->etag = g_strdup (etag);
5268   data->make_backup = make_backup;
5269   data->flags = flags;
5270
5271   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_replace_async);
5272   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_async_data_free);
5273
5274   g_simple_async_result_run_in_thread (res, replace_async_thread, io_priority, cancellable);
5275   g_object_unref (res);
5276 }
5277
5278 static GFileOutputStream *
5279 g_file_real_replace_finish (GFile         *file,
5280                             GAsyncResult  *res,
5281                             GError       **error)
5282 {
5283   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5284   ReplaceAsyncData *data;
5285
5286   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_replace_async);
5287
5288   data = g_simple_async_result_get_op_res_gpointer (simple);
5289   if (data->stream)
5290     return g_object_ref (data->stream);
5291
5292   return NULL;
5293 }
5294
5295 static void
5296 open_readwrite_async_thread (GSimpleAsyncResult *res,
5297                              GObject            *object,
5298                              GCancellable       *cancellable)
5299 {
5300   GFileIface *iface;
5301   GFileIOStream *stream;
5302   GError *error = NULL;
5303
5304   iface = G_FILE_GET_IFACE (object);
5305
5306   if (iface->open_readwrite == NULL)
5307     {
5308       g_set_error_literal (&error, G_IO_ERROR,
5309                            G_IO_ERROR_NOT_SUPPORTED,
5310                            _("Operation not supported"));
5311
5312       g_simple_async_result_take_error (res, error);
5313
5314       return;
5315     }
5316
5317   stream = iface->open_readwrite (G_FILE (object), cancellable, &error);
5318
5319   if (stream == NULL)
5320     g_simple_async_result_take_error (res, error);
5321   else
5322     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
5323 }
5324
5325 static void
5326 g_file_real_open_readwrite_async (GFile               *file,
5327                                   int                  io_priority,
5328                                   GCancellable        *cancellable,
5329                                   GAsyncReadyCallback  callback,
5330                                   gpointer             user_data)
5331 {
5332   GSimpleAsyncResult *res;
5333
5334   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_open_readwrite_async);
5335
5336   g_simple_async_result_run_in_thread (res, open_readwrite_async_thread, io_priority, cancellable);
5337   g_object_unref (res);
5338 }
5339
5340 static GFileIOStream *
5341 g_file_real_open_readwrite_finish (GFile         *file,
5342                                    GAsyncResult  *res,
5343                                    GError       **error)
5344 {
5345   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5346   gpointer op;
5347
5348   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_open_readwrite_async);
5349
5350   op = g_simple_async_result_get_op_res_gpointer (simple);
5351   if (op)
5352     return g_object_ref (op);
5353
5354   return NULL;
5355 }
5356
5357 static void
5358 create_readwrite_async_thread (GSimpleAsyncResult *res,
5359                                GObject            *object,
5360                                GCancellable       *cancellable)
5361 {
5362   GFileIface *iface;
5363   GFileCreateFlags *data;
5364   GFileIOStream *stream;
5365   GError *error = NULL;
5366
5367   iface = G_FILE_GET_IFACE (object);
5368
5369   data = g_simple_async_result_get_op_res_gpointer (res);
5370
5371   if (iface->create_readwrite == NULL)
5372     {
5373       g_set_error_literal (&error, G_IO_ERROR,
5374                            G_IO_ERROR_NOT_SUPPORTED,
5375                            _("Operation not supported"));
5376
5377       g_simple_async_result_take_error (res, error);
5378
5379       return;
5380     }
5381
5382   stream = iface->create_readwrite (G_FILE (object), *data, cancellable, &error);
5383
5384   if (stream == NULL)
5385     g_simple_async_result_take_error (res, error);
5386   else
5387     g_simple_async_result_set_op_res_gpointer (res, stream, g_object_unref);
5388 }
5389
5390 static void
5391 g_file_real_create_readwrite_async (GFile               *file,
5392                                     GFileCreateFlags     flags,
5393                                     int                  io_priority,
5394                                     GCancellable        *cancellable,
5395                                     GAsyncReadyCallback  callback,
5396                                     gpointer             user_data)
5397 {
5398   GFileCreateFlags *data;
5399   GSimpleAsyncResult *res;
5400
5401   data = g_new0 (GFileCreateFlags, 1);
5402   *data = flags;
5403
5404   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_create_readwrite_async);
5405   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)g_free);
5406
5407   g_simple_async_result_run_in_thread (res, create_readwrite_async_thread, io_priority, cancellable);
5408   g_object_unref (res);
5409 }
5410
5411 static GFileIOStream *
5412 g_file_real_create_readwrite_finish (GFile         *file,
5413                                      GAsyncResult  *res,
5414                                      GError       **error)
5415 {
5416   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5417   gpointer op;
5418
5419   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_create_readwrite_async);
5420
5421   op = g_simple_async_result_get_op_res_gpointer (simple);
5422   if (op)
5423     return g_object_ref (op);
5424
5425   return NULL;
5426 }
5427
5428 typedef struct {
5429   GFileIOStream *stream;
5430   char *etag;
5431   gboolean make_backup;
5432   GFileCreateFlags flags;
5433 } ReplaceRWAsyncData;
5434
5435 static void
5436 replace_rw_async_data_free (ReplaceRWAsyncData *data)
5437 {
5438   if (data->stream)
5439     g_object_unref (data->stream);
5440   g_free (data->etag);
5441   g_free (data);
5442 }
5443
5444 static void
5445 replace_readwrite_async_thread (GSimpleAsyncResult *res,
5446                                 GObject            *object,
5447                                 GCancellable       *cancellable)
5448 {
5449   GFileIface *iface;
5450   GFileIOStream *stream;
5451   GError *error = NULL;
5452   ReplaceRWAsyncData *data;
5453
5454   iface = G_FILE_GET_IFACE (object);
5455
5456   data = g_simple_async_result_get_op_res_gpointer (res);
5457
5458   stream = iface->replace_readwrite (G_FILE (object),
5459                                      data->etag,
5460                                      data->make_backup,
5461                                      data->flags,
5462                                      cancellable,
5463                                      &error);
5464
5465   if (stream == NULL)
5466     g_simple_async_result_take_error (res, error);
5467   else
5468     data->stream = stream;
5469 }
5470
5471 static void
5472 g_file_real_replace_readwrite_async (GFile               *file,
5473                                      const char          *etag,
5474                                      gboolean             make_backup,
5475                                      GFileCreateFlags     flags,
5476                                      int                  io_priority,
5477                                      GCancellable        *cancellable,
5478                                      GAsyncReadyCallback  callback,
5479                                      gpointer             user_data)
5480 {
5481   GSimpleAsyncResult *res;
5482   ReplaceRWAsyncData *data;
5483
5484   data = g_new0 (ReplaceRWAsyncData, 1);
5485   data->etag = g_strdup (etag);
5486   data->make_backup = make_backup;
5487   data->flags = flags;
5488
5489   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_replace_readwrite_async);
5490   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_rw_async_data_free);
5491
5492   g_simple_async_result_run_in_thread (res, replace_readwrite_async_thread, io_priority, cancellable);
5493   g_object_unref (res);
5494 }
5495
5496 static GFileIOStream *
5497 g_file_real_replace_readwrite_finish (GFile         *file,
5498                                       GAsyncResult  *res,
5499                                       GError       **error)
5500 {
5501   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5502   ReplaceRWAsyncData *data;
5503
5504   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_replace_readwrite_async);
5505
5506   data = g_simple_async_result_get_op_res_gpointer (simple);
5507   if (data->stream)
5508     return g_object_ref (data->stream);
5509
5510   return NULL;
5511 }
5512
5513 typedef struct {
5514   char *name;
5515   GFile *file;
5516 } SetDisplayNameAsyncData;
5517
5518 static void
5519 set_display_name_data_free (SetDisplayNameAsyncData *data)
5520 {
5521   g_free (data->name);
5522   if (data->file)
5523     g_object_unref (data->file);
5524   g_free (data);
5525 }
5526
5527 static void
5528 set_display_name_async_thread (GSimpleAsyncResult *res,
5529                                GObject            *object,
5530                                GCancellable       *cancellable)
5531 {
5532   GError *error = NULL;
5533   SetDisplayNameAsyncData *data;
5534   GFile *file;
5535
5536   data = g_simple_async_result_get_op_res_gpointer (res);
5537
5538   file = g_file_set_display_name (G_FILE (object), data->name, cancellable, &error);
5539
5540   if (file == NULL)
5541     g_simple_async_result_take_error (res, error);
5542   else
5543     data->file = file;
5544 }
5545
5546 static void
5547 g_file_real_set_display_name_async (GFile               *file,
5548                                     const char          *display_name,
5549                                     int                  io_priority,
5550                                     GCancellable        *cancellable,
5551                                     GAsyncReadyCallback  callback,
5552                                     gpointer             user_data)
5553 {
5554   GSimpleAsyncResult *res;
5555   SetDisplayNameAsyncData *data;
5556
5557   data = g_new0 (SetDisplayNameAsyncData, 1);
5558   data->name = g_strdup (display_name);
5559
5560   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_display_name_async);
5561   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_display_name_data_free);
5562
5563   g_simple_async_result_run_in_thread (res, set_display_name_async_thread, io_priority, cancellable);
5564   g_object_unref (res);
5565 }
5566
5567 static GFile *
5568 g_file_real_set_display_name_finish (GFile         *file,
5569                                      GAsyncResult  *res,
5570                                      GError       **error)
5571 {
5572   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5573   SetDisplayNameAsyncData *data;
5574
5575   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_display_name_async);
5576
5577   data = g_simple_async_result_get_op_res_gpointer (simple);
5578   if (data->file)
5579     return g_object_ref (data->file);
5580
5581   return NULL;
5582 }
5583
5584 typedef struct {
5585   GFileQueryInfoFlags flags;
5586   GFileInfo *info;
5587   gboolean res;
5588   GError *error;
5589 } SetInfoAsyncData;
5590
5591 static void
5592 set_info_data_free (SetInfoAsyncData *data)
5593 {
5594   if (data->info)
5595     g_object_unref (data->info);
5596   if (data->error)
5597     g_error_free (data->error);
5598   g_free (data);
5599 }
5600
5601 static void
5602 set_info_async_thread (GSimpleAsyncResult *res,
5603                        GObject            *object,
5604                        GCancellable       *cancellable)
5605 {
5606   SetInfoAsyncData *data;
5607
5608   data = g_simple_async_result_get_op_res_gpointer (res);
5609
5610   data->error = NULL;
5611   data->res = g_file_set_attributes_from_info (G_FILE (object),
5612                                                data->info,
5613                                                data->flags,
5614                                                cancellable,
5615                                                &data->error);
5616 }
5617
5618 static void
5619 g_file_real_set_attributes_async (GFile               *file,
5620                                   GFileInfo           *info,
5621                                   GFileQueryInfoFlags  flags,
5622                                   int                  io_priority,
5623                                   GCancellable        *cancellable,
5624                                   GAsyncReadyCallback  callback,
5625                                   gpointer             user_data)
5626 {
5627   GSimpleAsyncResult *res;
5628   SetInfoAsyncData *data;
5629
5630   data = g_new0 (SetInfoAsyncData, 1);
5631   data->info = g_file_info_dup (info);
5632   data->flags = flags;
5633
5634   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_set_attributes_async);
5635   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)set_info_data_free);
5636
5637   g_simple_async_result_run_in_thread (res, set_info_async_thread, io_priority, cancellable);
5638   g_object_unref (res);
5639 }
5640
5641 static gboolean
5642 g_file_real_set_attributes_finish (GFile         *file,
5643                                    GAsyncResult  *res,
5644                                    GFileInfo    **info,
5645                                    GError       **error)
5646 {
5647   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5648   SetInfoAsyncData *data;
5649
5650   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_set_attributes_async);
5651
5652   data = g_simple_async_result_get_op_res_gpointer (simple);
5653
5654   if (info)
5655     *info = g_object_ref (data->info);
5656
5657   if (error != NULL && data->error)
5658     *error = g_error_copy (data->error);
5659
5660   return data->res;
5661 }
5662
5663 static void
5664 find_enclosing_mount_async_thread (GSimpleAsyncResult *res,
5665                                     GObject            *object,
5666                                     GCancellable       *cancellable)
5667 {
5668   GError *error = NULL;
5669   GMount *mount;
5670
5671   mount = g_file_find_enclosing_mount (G_FILE (object), cancellable, &error);
5672
5673   if (mount == NULL)
5674     g_simple_async_result_take_error (res, error);
5675   else
5676     g_simple_async_result_set_op_res_gpointer (res, mount, (GDestroyNotify)g_object_unref);
5677 }
5678
5679 static void
5680 g_file_real_find_enclosing_mount_async (GFile               *file,
5681                                         int                  io_priority,
5682                                         GCancellable        *cancellable,
5683                                         GAsyncReadyCallback  callback,
5684                                         gpointer             user_data)
5685 {
5686   GSimpleAsyncResult *res;
5687
5688   res = g_simple_async_result_new (G_OBJECT (file), callback, user_data, g_file_real_find_enclosing_mount_async);
5689
5690   g_simple_async_result_run_in_thread (res, find_enclosing_mount_async_thread, io_priority, cancellable);
5691   g_object_unref (res);
5692 }
5693
5694 static GMount *
5695 g_file_real_find_enclosing_mount_finish (GFile         *file,
5696                                           GAsyncResult  *res,
5697                                           GError       **error)
5698 {
5699   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
5700   GMount *mount;
5701
5702   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_real_find_enclosing_mount_async);
5703
5704   mount = g_simple_async_result_get_op_res_gpointer (simple);
5705   return g_object_ref (mount);
5706 }
5707
5708
5709 typedef struct {
5710   GFile *source;
5711   GFile *destination;
5712   GFileCopyFlags flags;
5713   GFileProgressCallback progress_cb;
5714   gpointer progress_cb_data;
5715   GIOSchedulerJob *job;
5716 } CopyAsyncData;
5717
5718 static void
5719 copy_async_data_free (CopyAsyncData *data)
5720 {
5721   g_object_unref (data->source);
5722   g_object_unref (data->destination);
5723   g_free (data);
5724 }
5725
5726 typedef struct {
5727   CopyAsyncData *data;
5728   goffset current_num_bytes;
5729   goffset total_num_bytes;
5730 } ProgressData;
5731
5732 static gboolean
5733 copy_async_progress_in_main (gpointer user_data)
5734 {
5735   ProgressData *progress = user_data;
5736   CopyAsyncData *data = progress->data;
5737
5738   data->progress_cb (progress->current_num_bytes,
5739                      progress->total_num_bytes,
5740                      data->progress_cb_data);
5741
5742   return FALSE;
5743 }
5744
5745 static gboolean
5746 mainloop_barrier (gpointer user_data)
5747 {
5748   /* Does nothing, but ensures all queued idles before
5749      this are run */
5750   return FALSE;
5751 }
5752
5753
5754 static void
5755 copy_async_progress_callback (goffset  current_num_bytes,
5756                               goffset  total_num_bytes,
5757                               gpointer user_data)
5758 {
5759   CopyAsyncData *data = user_data;
5760   ProgressData *progress;
5761
5762   progress = g_new (ProgressData, 1);
5763   progress->data = data;
5764   progress->current_num_bytes = current_num_bytes;
5765   progress->total_num_bytes = total_num_bytes;
5766
5767   g_io_scheduler_job_send_to_mainloop_async (data->job,
5768                                              copy_async_progress_in_main,
5769                                              progress,
5770                                              g_free);
5771 }
5772
5773 static gboolean
5774 copy_async_thread (GIOSchedulerJob *job,
5775                    GCancellable    *cancellable,
5776                    gpointer         user_data)
5777 {
5778   GSimpleAsyncResult *res;
5779   CopyAsyncData *data;
5780   gboolean result;
5781   GError *error;
5782
5783   res = user_data;
5784   data = g_simple_async_result_get_op_res_gpointer (res);
5785
5786   error = NULL;
5787   data->job = job;
5788   result = g_file_copy (data->source,
5789                         data->destination,
5790                         data->flags,
5791                         cancellable,
5792                         (data->progress_cb != NULL) ? copy_async_progress_callback : NULL,
5793                         data,
5794                         &error);
5795
5796   /* Ensure all progress callbacks are done running in main thread */
5797   if (data->progress_cb != NULL)
5798     g_io_scheduler_job_send_to_mainloop (job,
5799                                          mainloop_barrier,
5800                                          NULL, NULL);
5801
5802   if (!result)
5803     g_simple_async_result_take_error (res, error);
5804
5805   g_simple_async_result_complete_in_idle (res);
5806
5807   return FALSE;
5808 }
5809
5810 static void
5811 g_file_real_copy_async (GFile                  *source,
5812                         GFile                  *destination,
5813                         GFileCopyFlags          flags,
5814                         int                     io_priority,
5815                         GCancellable           *cancellable,
5816                         GFileProgressCallback   progress_callback,
5817                         gpointer                progress_callback_data,
5818                         GAsyncReadyCallback     callback,
5819                         gpointer                user_data)
5820 {
5821   GSimpleAsyncResult *res;
5822   CopyAsyncData *data;
5823
5824   data = g_new0 (CopyAsyncData, 1);
5825   data->source = g_object_ref (source);
5826   data->destination = g_object_ref (destination);
5827   data->flags = flags;
5828   data->progress_cb = progress_callback;
5829   data->progress_cb_data = progress_callback_data;
5830
5831   res = g_simple_async_result_new (G_OBJECT (source), callback, user_data, g_file_real_copy_async);
5832   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)copy_async_data_free);
5833
5834   g_io_scheduler_push_job (copy_async_thread, res, g_object_unref, io_priority, cancellable);
5835 }
5836
5837 static gboolean
5838 g_file_real_copy_finish (GFile        *file,
5839                          GAsyncResult *res,
5840                          GError      **error)
5841 {
5842   /* Error handled in g_file_copy_finish() */
5843   return TRUE;
5844 }
5845
5846
5847 /********************************************
5848  *   Default VFS operations                 *
5849  ********************************************/
5850
5851 /**
5852  * g_file_new_for_path:
5853  * @path: a string containing a relative or absolute path. The string
5854  *   must be encoded in the glib filename encoding.
5855  *
5856  * Constructs a #GFile for a given path. This operation never
5857  * fails, but the returned object might not support any I/O
5858  * operation if @path is malformed.
5859  *
5860  * Returns: (transfer full): a new #GFile for the given @path.
5861  *   Free the returned object with g_object_unref().
5862  **/
5863 GFile *
5864 g_file_new_for_path (const char *path)
5865 {
5866   g_return_val_if_fail (path != NULL, NULL);
5867
5868   return g_vfs_get_file_for_path (g_vfs_get_default (), path);
5869 }
5870
5871 /**
5872  * g_file_new_for_uri:
5873  * @uri: a UTF8 string containing a URI.
5874  *
5875  * Constructs a #GFile for a given URI. This operation never
5876  * fails, but the returned object might not support any I/O
5877  * operation if @uri is malformed or if the uri type is
5878  * not supported.
5879  *
5880  * Returns: (transfer full): a new #GFile for the given @uri.
5881  *   Free the returned object with g_object_unref().
5882  **/
5883 GFile *
5884 g_file_new_for_uri (const char *uri)
5885 {
5886   g_return_val_if_fail (uri != NULL, NULL);
5887
5888   return g_vfs_get_file_for_uri (g_vfs_get_default (), uri);
5889 }
5890
5891 /**
5892  * g_file_parse_name:
5893  * @parse_name: a file name or path to be parsed.
5894  *
5895  * Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()).
5896  * This operation never fails, but the returned object might not support any I/O
5897  * operation if the @parse_name cannot be parsed.
5898  *
5899  * Returns: (transfer full): a new #GFile.
5900  **/
5901 GFile *
5902 g_file_parse_name (const char *parse_name)
5903 {
5904   g_return_val_if_fail (parse_name != NULL, NULL);
5905
5906   return g_vfs_parse_name (g_vfs_get_default (), parse_name);
5907 }
5908
5909 static gboolean
5910 is_valid_scheme_character (char c)
5911 {
5912   return g_ascii_isalnum (c) || c == '+' || c == '-' || c == '.';
5913 }
5914
5915 /* Following RFC 2396, valid schemes are built like:
5916  *       scheme        = alpha *( alpha | digit | "+" | "-" | "." )
5917  */
5918 static gboolean
5919 has_valid_scheme (const char *uri)
5920 {
5921   const char *p;
5922
5923   p = uri;
5924
5925   if (!g_ascii_isalpha (*p))
5926     return FALSE;
5927
5928   do {
5929     p++;
5930   } while (is_valid_scheme_character (*p));
5931
5932   return *p == ':';
5933 }
5934
5935 /**
5936  * g_file_new_for_commandline_arg:
5937  * @arg: a command line string.
5938  *
5939  * Creates a #GFile with the given argument from the command line. The value of
5940  * @arg can be either a URI, an absolute path or a relative path resolved
5941  * relative to the current working directory.
5942  * This operation never fails, but the returned object might not support any
5943  * I/O operation if @arg points to a malformed path.
5944  *
5945  * Returns: (transfer full): a new #GFile.
5946  *  Free the returned object with g_object_unref().
5947  **/
5948 GFile *
5949 g_file_new_for_commandline_arg (const char *arg)
5950 {
5951   GFile *file;
5952   char *filename;
5953   char *current_dir;
5954
5955   g_return_val_if_fail (arg != NULL, NULL);
5956
5957   if (g_path_is_absolute (arg))
5958     return g_file_new_for_path (arg);
5959
5960   if (has_valid_scheme (arg))
5961     return g_file_new_for_uri (arg);
5962
5963   current_dir = g_get_current_dir ();
5964   filename = g_build_filename (current_dir, arg, NULL);
5965   g_free (current_dir);
5966
5967   file = g_file_new_for_path (filename);
5968   g_free (filename);
5969
5970   return file;
5971 }
5972
5973 /**
5974  * g_file_mount_enclosing_volume:
5975  * @location: input #GFile.
5976  * @flags: flags affecting the operation
5977  * @mount_operation: a #GMountOperation or %NULL to avoid user interaction.
5978  * @cancellable: optional #GCancellable object, %NULL to ignore.
5979  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
5980  * @user_data: the data to pass to callback function
5981  *
5982  * Starts a @mount_operation, mounting the volume that contains the file @location.
5983  *
5984  * When this operation has completed, @callback will be called with
5985  * @user_user data, and the operation can be finalized with
5986  * g_file_mount_enclosing_volume_finish().
5987  *
5988  * If @cancellable is not %NULL, then the operation can be cancelled by
5989  * triggering the cancellable object from another thread. If the operation
5990  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
5991  **/
5992 void
5993 g_file_mount_enclosing_volume (GFile               *location,
5994                                GMountMountFlags     flags,
5995                                GMountOperation     *mount_operation,
5996                                GCancellable        *cancellable,
5997                                GAsyncReadyCallback  callback,
5998                                gpointer             user_data)
5999 {
6000   GFileIface *iface;
6001
6002   g_return_if_fail (G_IS_FILE (location));
6003
6004   iface = G_FILE_GET_IFACE (location);
6005
6006   if (iface->mount_enclosing_volume == NULL)
6007     {
6008       g_simple_async_report_error_in_idle (G_OBJECT (location),
6009                                            callback, user_data,
6010                                            G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
6011                                            _("volume doesn't implement mount"));
6012
6013       return;
6014     }
6015
6016   (* iface->mount_enclosing_volume) (location, flags, mount_operation, cancellable, callback, user_data);
6017
6018 }
6019
6020 /**
6021  * g_file_mount_enclosing_volume_finish:
6022  * @location: input #GFile.
6023  * @result: a #GAsyncResult.
6024  * @error: a #GError, or %NULL
6025  *
6026  * Finishes a mount operation started by g_file_mount_enclosing_volume().
6027  *
6028  * Returns: %TRUE if successful. If an error
6029  * has occurred, this function will return %FALSE and set @error
6030  * appropriately if present.
6031  **/
6032 gboolean
6033 g_file_mount_enclosing_volume_finish (GFile         *location,
6034                                       GAsyncResult  *result,
6035                                       GError       **error)
6036 {
6037   GFileIface *iface;
6038
6039   g_return_val_if_fail (G_IS_FILE (location), FALSE);
6040   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
6041
6042   if (G_IS_SIMPLE_ASYNC_RESULT (result))
6043     {
6044       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
6045       if (g_simple_async_result_propagate_error (simple, error))
6046         return FALSE;
6047     }
6048
6049   iface = G_FILE_GET_IFACE (location);
6050
6051   return (* iface->mount_enclosing_volume_finish) (location, result, error);
6052 }
6053
6054 /********************************************
6055  *   Utility functions                      *
6056  ********************************************/
6057
6058 /**
6059  * g_file_query_default_handler:
6060  * @file: a #GFile to open.
6061  * @cancellable: optional #GCancellable object, %NULL to ignore.
6062  * @error: a #GError, or %NULL
6063  *
6064  * Returns the #GAppInfo that is registered as the default
6065  * application to handle the file specified by @file.
6066  *
6067  * If @cancellable is not %NULL, then the operation can be cancelled by
6068  * triggering the cancellable object from another thread. If the operation
6069  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6070  *
6071  * Returns: (transfer full): a #GAppInfo if the handle was found, %NULL if there were errors.
6072  * When you are done with it, release it with g_object_unref()
6073  **/
6074 GAppInfo *
6075 g_file_query_default_handler (GFile                  *file,
6076                               GCancellable           *cancellable,
6077                               GError                **error)
6078 {
6079   char *uri_scheme;
6080   const char *content_type;
6081   GAppInfo *appinfo;
6082   GFileInfo *info;
6083   char *path;
6084
6085   uri_scheme = g_file_get_uri_scheme (file);
6086   if (uri_scheme && uri_scheme[0] != '\0')
6087     {
6088       appinfo = g_app_info_get_default_for_uri_scheme (uri_scheme);
6089       g_free (uri_scheme);
6090
6091       if (appinfo != NULL)
6092         return appinfo;
6093     }
6094
6095   info = g_file_query_info (file,
6096                             G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
6097                             0,
6098                             cancellable,
6099                             error);
6100   if (info == NULL)
6101     return NULL;
6102
6103   appinfo = NULL;
6104
6105   content_type = g_file_info_get_content_type (info);
6106   if (content_type)
6107     {
6108       /* Don't use is_native(), as we want to support fuse paths if available */
6109       path = g_file_get_path (file);
6110       appinfo = g_app_info_get_default_for_type (content_type,
6111                                                  path == NULL);
6112       g_free (path);
6113     }
6114
6115   g_object_unref (info);
6116
6117   if (appinfo != NULL)
6118     return appinfo;
6119
6120   g_set_error_literal (error, G_IO_ERROR,
6121                        G_IO_ERROR_NOT_SUPPORTED,
6122                        _("No application is registered as handling this file"));
6123   return NULL;
6124
6125 }
6126
6127
6128 #define GET_CONTENT_BLOCK_SIZE 8192
6129
6130 /**
6131  * g_file_load_contents:
6132  * @file: input #GFile.
6133  * @cancellable: optional #GCancellable object, %NULL to ignore.
6134  * @contents: (out) (transfer full) (element-type guint8) (array length=length): a location to place the contents of the file.
6135  * @length: (out) (allow-none): a location to place the length of the contents of the file,
6136  *    or %NULL if the length is not needed
6137  * @etag_out: (out) (allow-none): a location to place the current entity tag for the file,
6138  *    or %NULL if the entity tag is not needed
6139  * @error: a #GError, or %NULL
6140  *
6141  * Loads the content of the file into memory. The data is always
6142  * zero-terminated, but this is not included in the resultant @length.
6143  * The returned @content should be freed with g_free() when no longer
6144  * needed.
6145  *
6146  * If @cancellable is not %NULL, then the operation can be cancelled by
6147  * triggering the cancellable object from another thread. If the operation
6148  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6149  *
6150  * Returns: %TRUE if the @file's contents were successfully loaded.
6151  * %FALSE if there were errors.
6152  **/
6153 gboolean
6154 g_file_load_contents (GFile         *file,
6155                       GCancellable  *cancellable,
6156                       char         **contents,
6157                       gsize         *length,
6158                       char         **etag_out,
6159                       GError       **error)
6160 {
6161   GFileInputStream *in;
6162   GByteArray *content;
6163   gsize pos;
6164   gssize res;
6165   GFileInfo *info;
6166
6167   g_return_val_if_fail (G_IS_FILE (file), FALSE);
6168   g_return_val_if_fail (contents != NULL, FALSE);
6169
6170   in = g_file_read (file, cancellable, error);
6171   if (in == NULL)
6172     return FALSE;
6173
6174   content = g_byte_array_new ();
6175   pos = 0;
6176
6177   g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
6178   while ((res = g_input_stream_read (G_INPUT_STREAM (in),
6179                                      content->data + pos,
6180                                      GET_CONTENT_BLOCK_SIZE,
6181                                      cancellable, error)) > 0)
6182     {
6183       pos += res;
6184       g_byte_array_set_size (content, pos + GET_CONTENT_BLOCK_SIZE + 1);
6185     }
6186
6187   if (etag_out)
6188     {
6189       *etag_out = NULL;
6190
6191       info = g_file_input_stream_query_info (in,
6192                                              G_FILE_ATTRIBUTE_ETAG_VALUE,
6193                                              cancellable,
6194                                              NULL);
6195       if (info)
6196         {
6197           *etag_out = g_strdup (g_file_info_get_etag (info));
6198           g_object_unref (info);
6199         }
6200     }
6201
6202   /* Ignore errors on close */
6203   g_input_stream_close (G_INPUT_STREAM (in), cancellable, NULL);
6204   g_object_unref (in);
6205
6206   if (res < 0)
6207     {
6208       /* error is set already */
6209       g_byte_array_free (content, TRUE);
6210       return FALSE;
6211     }
6212
6213   if (length)
6214     *length = pos;
6215
6216   /* Zero terminate (we got an extra byte allocated for this */
6217   content->data[pos] = 0;
6218
6219   *contents = (char *)g_byte_array_free (content, FALSE);
6220
6221   return TRUE;
6222 }
6223
6224 typedef struct {
6225   GFile *file;
6226   GError *error;
6227   GCancellable *cancellable;
6228   GFileReadMoreCallback read_more_callback;
6229   GAsyncReadyCallback callback;
6230   gpointer user_data;
6231   GByteArray *content;
6232   gsize pos;
6233   char *etag;
6234 } LoadContentsData;
6235
6236
6237 static void
6238 load_contents_data_free (LoadContentsData *data)
6239 {
6240   if (data->error)
6241     g_error_free (data->error);
6242   if (data->cancellable)
6243     g_object_unref (data->cancellable);
6244   if (data->content)
6245     g_byte_array_free (data->content, TRUE);
6246   g_free (data->etag);
6247   g_object_unref (data->file);
6248   g_free (data);
6249 }
6250
6251 static void
6252 load_contents_close_callback (GObject      *obj,
6253                               GAsyncResult *close_res,
6254                               gpointer      user_data)
6255 {
6256   GInputStream *stream = G_INPUT_STREAM (obj);
6257   LoadContentsData *data = user_data;
6258   GSimpleAsyncResult *res;
6259
6260   /* Ignore errors here, we're only reading anyway */
6261   g_input_stream_close_finish (stream, close_res, NULL);
6262   g_object_unref (stream);
6263
6264   res = g_simple_async_result_new (G_OBJECT (data->file),
6265                                    data->callback,
6266                                    data->user_data,
6267                                    g_file_load_contents_async);
6268   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)load_contents_data_free);
6269   g_simple_async_result_complete (res);
6270   g_object_unref (res);
6271 }
6272
6273 static void
6274 load_contents_fstat_callback (GObject      *obj,
6275                               GAsyncResult *stat_res,
6276                               gpointer      user_data)
6277 {
6278   GInputStream *stream = G_INPUT_STREAM (obj);
6279   LoadContentsData *data = user_data;
6280   GFileInfo *info;
6281
6282   info = g_file_input_stream_query_info_finish (G_FILE_INPUT_STREAM (stream),
6283                                                    stat_res, NULL);
6284   if (info)
6285     {
6286       data->etag = g_strdup (g_file_info_get_etag (info));
6287       g_object_unref (info);
6288     }
6289
6290   g_input_stream_close_async (stream, 0,
6291                               data->cancellable,
6292                               load_contents_close_callback, data);
6293 }
6294
6295 static void
6296 load_contents_read_callback (GObject      *obj,
6297                              GAsyncResult *read_res,
6298                              gpointer      user_data)
6299 {
6300   GInputStream *stream = G_INPUT_STREAM (obj);
6301   LoadContentsData *data = user_data;
6302   GError *error = NULL;
6303   gssize read_size;
6304
6305   read_size = g_input_stream_read_finish (stream, read_res, &error);
6306
6307   if (read_size < 0)
6308     {
6309       /* Error or EOF, close the file */
6310       data->error = error;
6311       g_input_stream_close_async (stream, 0,
6312                                   data->cancellable,
6313                                   load_contents_close_callback, data);
6314     }
6315   else if (read_size == 0)
6316     {
6317       g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
6318                                             G_FILE_ATTRIBUTE_ETAG_VALUE,
6319                                             0,
6320                                             data->cancellable,
6321                                             load_contents_fstat_callback,
6322                                             data);
6323     }
6324   else if (read_size > 0)
6325     {
6326       data->pos += read_size;
6327
6328       g_byte_array_set_size (data->content,
6329                              data->pos + GET_CONTENT_BLOCK_SIZE);
6330
6331
6332       if (data->read_more_callback &&
6333           !data->read_more_callback ((char *)data->content->data, data->pos, data->user_data))
6334         g_file_input_stream_query_info_async (G_FILE_INPUT_STREAM (stream),
6335                                               G_FILE_ATTRIBUTE_ETAG_VALUE,
6336                                               0,
6337                                               data->cancellable,
6338                                               load_contents_fstat_callback,
6339                                               data);
6340       else
6341         g_input_stream_read_async (stream,
6342                                    data->content->data + data->pos,
6343                                    GET_CONTENT_BLOCK_SIZE,
6344                                    0,
6345                                    data->cancellable,
6346                                    load_contents_read_callback,
6347                                    data);
6348     }
6349 }
6350
6351 static void
6352 load_contents_open_callback (GObject      *obj,
6353                              GAsyncResult *open_res,
6354                              gpointer      user_data)
6355 {
6356   GFile *file = G_FILE (obj);
6357   GFileInputStream *stream;
6358   LoadContentsData *data = user_data;
6359   GError *error = NULL;
6360   GSimpleAsyncResult *res;
6361
6362   stream = g_file_read_finish (file, open_res, &error);
6363
6364   if (stream)
6365     {
6366       g_byte_array_set_size (data->content,
6367                              data->pos + GET_CONTENT_BLOCK_SIZE);
6368       g_input_stream_read_async (G_INPUT_STREAM (stream),
6369                                  data->content->data + data->pos,
6370                                  GET_CONTENT_BLOCK_SIZE,
6371                                  0,
6372                                  data->cancellable,
6373                                  load_contents_read_callback,
6374                                  data);
6375
6376     }
6377   else
6378     {
6379       res = g_simple_async_result_new_take_error (G_OBJECT (data->file),
6380                                                   data->callback,
6381                                                   data->user_data,
6382                                                   error);
6383       g_simple_async_result_complete (res);
6384       load_contents_data_free (data);
6385       g_object_unref (res);
6386     }
6387 }
6388
6389 /**
6390  * g_file_load_partial_contents_async: (skip)
6391  * @file: input #GFile.
6392  * @cancellable: optional #GCancellable object, %NULL to ignore.
6393  * @read_more_callback: a #GFileReadMoreCallback to receive partial data and to specify whether further data should be read.
6394  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
6395  * @user_data: the data to pass to the callback functions.
6396  *
6397  * Reads the partial contents of a file. A #GFileReadMoreCallback should be
6398  * used to stop reading from the file when appropriate, else this function
6399  * will behave exactly as g_file_load_contents_async(). This operation
6400  * can be finished by g_file_load_partial_contents_finish().
6401  *
6402  * Users of this function should be aware that @user_data is passed to
6403  * both the @read_more_callback and the @callback.
6404  *
6405  * If @cancellable is not %NULL, then the operation can be cancelled by
6406  * triggering the cancellable object from another thread. If the operation
6407  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6408  **/
6409 void
6410 g_file_load_partial_contents_async (GFile                 *file,
6411                                     GCancellable          *cancellable,
6412                                     GFileReadMoreCallback  read_more_callback,
6413                                     GAsyncReadyCallback    callback,
6414                                     gpointer               user_data)
6415 {
6416   LoadContentsData *data;
6417
6418   g_return_if_fail (G_IS_FILE (file));
6419
6420   data = g_new0 (LoadContentsData, 1);
6421
6422   if (cancellable)
6423     data->cancellable = g_object_ref (cancellable);
6424   data->read_more_callback = read_more_callback;
6425   data->callback = callback;
6426   data->user_data = user_data;
6427   data->content = g_byte_array_new ();
6428   data->file = g_object_ref (file);
6429
6430   g_file_read_async (file,
6431                      0,
6432                      cancellable,
6433                      load_contents_open_callback,
6434                      data);
6435 }
6436
6437 /**
6438  * g_file_load_partial_contents_finish:
6439  * @file: input #GFile.
6440  * @res: a #GAsyncResult.
6441  * @contents: (out) (transfer full) (element-type guint8) (array length=length): a location to place the contents of the file.
6442  * @length: (out) (allow-none): a location to place the length of the contents of the file,
6443  *     or %NULL if the length is not needed
6444  * @etag_out: (out) (allow-none): a location to place the current entity tag for the file,
6445  *     or %NULL if the entity tag is not needed
6446  * @error: a #GError, or %NULL
6447  *
6448  * Finishes an asynchronous partial load operation that was started
6449  * with g_file_load_partial_contents_async(). The data is always
6450  * zero-terminated, but this is not included in the resultant @length.
6451  * The returned @content should be freed with g_free() when no longer
6452  * needed.
6453  *
6454  * Returns: %TRUE if the load was successful. If %FALSE and @error is
6455  * present, it will be set appropriately.
6456  **/
6457 gboolean
6458 g_file_load_partial_contents_finish (GFile         *file,
6459                                      GAsyncResult  *res,
6460                                      char         **contents,
6461                                      gsize         *length,
6462                                      char         **etag_out,
6463                                      GError       **error)
6464 {
6465   GSimpleAsyncResult *simple;
6466   LoadContentsData *data;
6467
6468   g_return_val_if_fail (G_IS_FILE (file), FALSE);
6469   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
6470   g_return_val_if_fail (contents != NULL, FALSE);
6471
6472   simple = G_SIMPLE_ASYNC_RESULT (res);
6473
6474   if (g_simple_async_result_propagate_error (simple, error))
6475     return FALSE;
6476
6477   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_load_contents_async);
6478
6479   data = g_simple_async_result_get_op_res_gpointer (simple);
6480
6481   if (data->error)
6482     {
6483       g_propagate_error (error, data->error);
6484       data->error = NULL;
6485       *contents = NULL;
6486       if (length)
6487         *length = 0;
6488       return FALSE;
6489     }
6490
6491   if (length)
6492     *length = data->pos;
6493
6494   if (etag_out)
6495     {
6496       *etag_out = data->etag;
6497       data->etag = NULL;
6498     }
6499
6500   /* Zero terminate */
6501   g_byte_array_set_size (data->content, data->pos + 1);
6502   data->content->data[data->pos] = 0;
6503
6504   *contents = (char *)g_byte_array_free (data->content, FALSE);
6505   data->content = NULL;
6506
6507   return TRUE;
6508 }
6509
6510 /**
6511  * g_file_load_contents_async:
6512  * @file: input #GFile.
6513  * @cancellable: optional #GCancellable object, %NULL to ignore.
6514  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
6515  * @user_data: the data to pass to callback function
6516  *
6517  * Starts an asynchronous load of the @file's contents.
6518  *
6519  * For more details, see g_file_load_contents() which is
6520  * the synchronous version of this call.
6521  *
6522  * When the load operation has completed, @callback will be called
6523  * with @user data. To finish the operation, call
6524  * g_file_load_contents_finish() with the #GAsyncResult returned by
6525  * the @callback.
6526  *
6527  * If @cancellable is not %NULL, then the operation can be cancelled by
6528  * triggering the cancellable object from another thread. If the operation
6529  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6530  **/
6531 void
6532 g_file_load_contents_async (GFile               *file,
6533                            GCancellable        *cancellable,
6534                            GAsyncReadyCallback  callback,
6535                            gpointer             user_data)
6536 {
6537   g_file_load_partial_contents_async (file,
6538                                       cancellable,
6539                                       NULL,
6540                                       callback, user_data);
6541 }
6542
6543 /**
6544  * g_file_load_contents_finish:
6545  * @file: input #GFile.
6546  * @res: a #GAsyncResult.
6547  * @contents: (out) (transfer full) (element-type guint8) (array length=length): a location to place the contents of the file.
6548  * @length: (out) (allow-none): a location to place the length of the contents of the file,
6549  *     or %NULL if the length is not needed
6550  * @etag_out: (out) (allow-none): a location to place the current entity tag for the file,
6551  *     or %NULL if the entity tag is not needed
6552  * @error: a #GError, or %NULL
6553  *
6554  * Finishes an asynchronous load of the @file's contents.
6555  * The contents are placed in @contents, and @length is set to the
6556  * size of the @contents string. The @content should be freed with
6557  * g_free() when no longer needed. If @etag_out is present, it will be
6558  * set to the new entity tag for the @file.
6559  *
6560  * Returns: %TRUE if the load was successful. If %FALSE and @error is
6561  * present, it will be set appropriately.
6562  **/
6563 gboolean
6564 g_file_load_contents_finish (GFile         *file,
6565                              GAsyncResult  *res,
6566                              char         **contents,
6567                              gsize         *length,
6568                              char         **etag_out,
6569                              GError       **error)
6570 {
6571   return g_file_load_partial_contents_finish (file,
6572                                               res,
6573                                               contents,
6574                                               length,
6575                                               etag_out,
6576                                               error);
6577 }
6578
6579 /**
6580  * g_file_replace_contents:
6581  * @file: input #GFile.
6582  * @contents: (element-type guint8) (array length=length): a string containing the new contents for @file.
6583  * @length: the length of @contents in bytes.
6584  * @etag: (allow-none): the old <link linkend="gfile-etag">entity tag</link>
6585  *     for the document, or %NULL
6586  * @make_backup: %TRUE if a backup should be created.
6587  * @flags: a set of #GFileCreateFlags.
6588  * @new_etag: (allow-none) (out): a location to a new <link linkend="gfile-etag">entity tag</link>
6589  *      for the document. This should be freed with g_free() when no longer
6590  *      needed, or %NULL
6591  * @cancellable: optional #GCancellable object, %NULL to ignore.
6592  * @error: a #GError, or %NULL
6593  *
6594  * Replaces the contents of @file with @contents of @length bytes.
6595
6596  * If @etag is specified (not %NULL) any existing file must have that etag, or
6597  * the error %G_IO_ERROR_WRONG_ETAG will be returned.
6598  *
6599  * If @make_backup is %TRUE, this function will attempt to make a backup of @file.
6600  *
6601  * If @cancellable is not %NULL, then the operation can be cancelled by
6602  * triggering the cancellable object from another thread. If the operation
6603  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6604  *
6605  * The returned @new_etag can be used to verify that the file hasn't changed the
6606  * next time it is saved over.
6607  *
6608  * Returns: %TRUE if successful. If an error
6609  * has occurred, this function will return %FALSE and set @error
6610  * appropriately if present.
6611  **/
6612 gboolean
6613 g_file_replace_contents (GFile             *file,
6614                          const char        *contents,
6615                          gsize              length,
6616                          const char        *etag,
6617                          gboolean           make_backup,
6618                          GFileCreateFlags   flags,
6619                          char             **new_etag,
6620                          GCancellable      *cancellable,
6621                          GError           **error)
6622 {
6623   GFileOutputStream *out;
6624   gsize pos, remainder;
6625   gssize res;
6626   gboolean ret;
6627
6628   g_return_val_if_fail (G_IS_FILE (file), FALSE);
6629   g_return_val_if_fail (contents != NULL, FALSE);
6630
6631   out = g_file_replace (file, etag, make_backup, flags, cancellable, error);
6632   if (out == NULL)
6633     return FALSE;
6634
6635   pos = 0;
6636   remainder = length;
6637   while (remainder > 0 &&
6638          (res = g_output_stream_write (G_OUTPUT_STREAM (out),
6639                                        contents + pos,
6640                                        MIN (remainder, GET_CONTENT_BLOCK_SIZE),
6641                                        cancellable,
6642                                        error)) > 0)
6643     {
6644       pos += res;
6645       remainder -= res;
6646     }
6647
6648   if (remainder > 0 && res < 0)
6649     {
6650       /* Ignore errors on close */
6651       g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, NULL);
6652       g_object_unref (out);
6653
6654       /* error is set already */
6655       return FALSE;
6656     }
6657
6658   ret = g_output_stream_close (G_OUTPUT_STREAM (out), cancellable, error);
6659
6660   if (new_etag)
6661     *new_etag = g_file_output_stream_get_etag (out);
6662
6663   g_object_unref (out);
6664
6665   return ret;
6666 }
6667
6668 typedef struct {
6669   GFile *file;
6670   GError *error;
6671   GCancellable *cancellable;
6672   GAsyncReadyCallback callback;
6673   gpointer user_data;
6674   const char *content;
6675   gsize length;
6676   gsize pos;
6677   char *etag;
6678 } ReplaceContentsData;
6679
6680 static void
6681 replace_contents_data_free (ReplaceContentsData *data)
6682 {
6683   if (data->error)
6684     g_error_free (data->error);
6685   if (data->cancellable)
6686     g_object_unref (data->cancellable);
6687   g_object_unref (data->file);
6688   g_free (data->etag);
6689   g_free (data);
6690 }
6691
6692 static void
6693 replace_contents_close_callback (GObject      *obj,
6694                                  GAsyncResult *close_res,
6695                                  gpointer      user_data)
6696 {
6697   GOutputStream *stream = G_OUTPUT_STREAM (obj);
6698   ReplaceContentsData *data = user_data;
6699   GSimpleAsyncResult *res;
6700
6701   /* Ignore errors here, we're only reading anyway */
6702   g_output_stream_close_finish (stream, close_res, NULL);
6703   g_object_unref (stream);
6704
6705   data->etag = g_file_output_stream_get_etag (G_FILE_OUTPUT_STREAM (stream));
6706
6707   res = g_simple_async_result_new (G_OBJECT (data->file),
6708                                    data->callback,
6709                                    data->user_data,
6710                                    g_file_replace_contents_async);
6711   g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)replace_contents_data_free);
6712   g_simple_async_result_complete (res);
6713   g_object_unref (res);
6714 }
6715
6716 static void
6717 replace_contents_write_callback (GObject      *obj,
6718                                  GAsyncResult *read_res,
6719                                  gpointer      user_data)
6720 {
6721   GOutputStream *stream = G_OUTPUT_STREAM (obj);
6722   ReplaceContentsData *data = user_data;
6723   GError *error = NULL;
6724   gssize write_size;
6725
6726   write_size = g_output_stream_write_finish (stream, read_res, &error);
6727
6728   if (write_size <= 0)
6729     {
6730       /* Error or EOF, close the file */
6731       if (write_size < 0)
6732         data->error = error;
6733       g_output_stream_close_async (stream, 0,
6734                                    data->cancellable,
6735                                    replace_contents_close_callback, data);
6736     }
6737   else if (write_size > 0)
6738     {
6739       data->pos += write_size;
6740
6741       if (data->pos >= data->length)
6742         g_output_stream_close_async (stream, 0,
6743                                      data->cancellable,
6744                                      replace_contents_close_callback, data);
6745       else
6746         g_output_stream_write_async (stream,
6747                                      data->content + data->pos,
6748                                      data->length - data->pos,
6749                                      0,
6750                                      data->cancellable,
6751                                      replace_contents_write_callback,
6752                                      data);
6753     }
6754 }
6755
6756 static void
6757 replace_contents_open_callback (GObject      *obj,
6758                                 GAsyncResult *open_res,
6759                                 gpointer      user_data)
6760 {
6761   GFile *file = G_FILE (obj);
6762   GFileOutputStream *stream;
6763   ReplaceContentsData *data = user_data;
6764   GError *error = NULL;
6765   GSimpleAsyncResult *res;
6766
6767   stream = g_file_replace_finish (file, open_res, &error);
6768
6769   if (stream)
6770     {
6771       g_output_stream_write_async (G_OUTPUT_STREAM (stream),
6772                                    data->content + data->pos,
6773                                    data->length - data->pos,
6774                                    0,
6775                                    data->cancellable,
6776                                    replace_contents_write_callback,
6777                                    data);
6778
6779     }
6780   else
6781     {
6782       res = g_simple_async_result_new_take_error (G_OBJECT (data->file),
6783                                                   data->callback,
6784                                                   data->user_data,
6785                                                   error);
6786       g_simple_async_result_complete (res);
6787       replace_contents_data_free (data);
6788       g_object_unref (res);
6789     }
6790 }
6791
6792 /**
6793  * g_file_replace_contents_async:
6794  * @file: input #GFile.
6795  * @contents: (element-type guint8) (array length=length): string of contents to replace the file with.
6796  * @length: the length of @contents in bytes.
6797  * @etag: (allow-none): a new <link linkend="gfile-etag">entity tag</link> for the @file, or %NULL
6798  * @make_backup: %TRUE if a backup should be created.
6799  * @flags: a set of #GFileCreateFlags.
6800  * @cancellable: optional #GCancellable object, %NULL to ignore.
6801  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
6802  * @user_data: the data to pass to callback function
6803  *
6804  * Starts an asynchronous replacement of @file with the given
6805  * @contents of @length bytes. @etag will replace the document's
6806  * current entity tag.
6807  *
6808  * When this operation has completed, @callback will be called with
6809  * @user_user data, and the operation can be finalized with
6810  * g_file_replace_contents_finish().
6811  *
6812  * If @cancellable is not %NULL, then the operation can be cancelled by
6813  * triggering the cancellable object from another thread. If the operation
6814  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6815  *
6816  * If @make_backup is %TRUE, this function will attempt to
6817  * make a backup of @file.
6818  **/
6819 void
6820 g_file_replace_contents_async  (GFile               *file,
6821                                 const char          *contents,
6822                                 gsize                length,
6823                                 const char          *etag,
6824                                 gboolean             make_backup,
6825                                 GFileCreateFlags     flags,
6826                                 GCancellable        *cancellable,
6827                                 GAsyncReadyCallback  callback,
6828                                 gpointer             user_data)
6829 {
6830   ReplaceContentsData *data;
6831
6832   g_return_if_fail (G_IS_FILE (file));
6833   g_return_if_fail (contents != NULL);
6834
6835   data = g_new0 (ReplaceContentsData, 1);
6836
6837   if (cancellable)
6838     data->cancellable = g_object_ref (cancellable);
6839   data->callback = callback;
6840   data->user_data = user_data;
6841   data->content = contents;
6842   data->length = length;
6843   data->pos = 0;
6844   data->file = g_object_ref (file);
6845
6846   g_file_replace_async (file,
6847                         etag,
6848                         make_backup,
6849                         flags,
6850                         0,
6851                         cancellable,
6852                         replace_contents_open_callback,
6853                         data);
6854 }
6855
6856 /**
6857  * g_file_replace_contents_finish:
6858  * @file: input #GFile.
6859  * @res: a #GAsyncResult.
6860  * @new_etag: (out) (allow-none): a location of a new <link linkend="gfile-etag">entity tag</link>
6861  *     for the document. This should be freed with g_free() when it is no
6862  *     longer needed, or %NULL
6863  * @error: a #GError, or %NULL
6864  *
6865  * Finishes an asynchronous replace of the given @file. See
6866  * g_file_replace_contents_async(). Sets @new_etag to the new entity
6867  * tag for the document, if present.
6868  *
6869  * Returns: %TRUE on success, %FALSE on failure.
6870  **/
6871 gboolean
6872 g_file_replace_contents_finish (GFile         *file,
6873                                 GAsyncResult  *res,
6874                                 char         **new_etag,
6875                                 GError       **error)
6876 {
6877   GSimpleAsyncResult *simple;
6878   ReplaceContentsData *data;
6879
6880   g_return_val_if_fail (G_IS_FILE (file), FALSE);
6881   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
6882
6883   simple = G_SIMPLE_ASYNC_RESULT (res);
6884
6885   if (g_simple_async_result_propagate_error (simple, error))
6886     return FALSE;
6887
6888   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_file_replace_contents_async);
6889
6890   data = g_simple_async_result_get_op_res_gpointer (simple);
6891
6892   if (data->error)
6893     {
6894       g_propagate_error (error, data->error);
6895       data->error = NULL;
6896       return FALSE;
6897     }
6898
6899
6900   if (new_etag)
6901     {
6902       *new_etag = data->etag;
6903       data->etag = NULL; /* Take ownership */
6904     }
6905
6906   return TRUE;
6907 }
6908
6909 /**
6910  * g_file_start_mountable:
6911  * @file: input #GFile.
6912  * @flags: flags affecting the operation
6913  * @start_operation: a #GMountOperation, or %NULL to avoid user interaction.
6914  * @cancellable: optional #GCancellable object, %NULL to ignore.
6915  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
6916  * @user_data: the data to pass to callback function
6917  *
6918  * Starts a file of type G_FILE_TYPE_MOUNTABLE.
6919  * Using @start_operation, you can request callbacks when, for instance,
6920  * passwords are needed during authentication.
6921  *
6922  * If @cancellable is not %NULL, then the operation can be cancelled by
6923  * triggering the cancellable object from another thread. If the operation
6924  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
6925  *
6926  * When the operation is finished, @callback will be called. You can then call
6927  * g_file_mount_mountable_finish() to get the result of the operation.
6928  *
6929  * Since: 2.22
6930  */
6931 void
6932 g_file_start_mountable (GFile                      *file,
6933                         GDriveStartFlags            flags,
6934                         GMountOperation            *start_operation,
6935                         GCancellable               *cancellable,
6936                         GAsyncReadyCallback         callback,
6937                         gpointer                    user_data)
6938 {
6939   GFileIface *iface;
6940
6941   g_return_if_fail (G_IS_FILE (file));
6942
6943   iface = G_FILE_GET_IFACE (file);
6944
6945   if (iface->start_mountable == NULL)
6946     {
6947       g_simple_async_report_error_in_idle (G_OBJECT (file),
6948                                            callback,
6949                                            user_data,
6950                                            G_IO_ERROR,
6951                                            G_IO_ERROR_NOT_SUPPORTED,
6952                                            _("Operation not supported"));
6953       return;
6954     }
6955
6956   (* iface->start_mountable) (file,
6957                               flags,
6958                               start_operation,
6959                               cancellable,
6960                               callback,
6961                               user_data);
6962 }
6963
6964 /**
6965  * g_file_start_mountable_finish:
6966  * @file: input #GFile.
6967  * @result: a #GAsyncResult.
6968  * @error: a #GError, or %NULL
6969  *
6970  * Finishes a start operation. See g_file_start_mountable() for details.
6971  *
6972  * Finish an asynchronous start operation that was started
6973  * with g_file_start_mountable().
6974  *
6975  * Returns: %TRUE if the operation finished successfully. %FALSE
6976  * otherwise.
6977  *
6978  * Since: 2.22
6979  */
6980 gboolean
6981 g_file_start_mountable_finish (GFile                      *file,
6982                                GAsyncResult               *result,
6983                                GError                    **error)
6984 {
6985   GFileIface *iface;
6986
6987   g_return_val_if_fail (G_IS_FILE (file), FALSE);
6988   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
6989
6990   if (G_IS_SIMPLE_ASYNC_RESULT (result))
6991     {
6992       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
6993       if (g_simple_async_result_propagate_error (simple, error))
6994         return FALSE;
6995     }
6996
6997   iface = G_FILE_GET_IFACE (file);
6998   return (* iface->start_mountable_finish) (file, result, error);
6999 }
7000
7001 /**
7002  * g_file_stop_mountable:
7003  * @file: input #GFile.
7004  * @flags: flags affecting the operation
7005  * @mount_operation: a #GMountOperation, or %NULL to avoid user interaction.
7006  * @cancellable: optional #GCancellable object, %NULL to ignore.
7007  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
7008  * @user_data: the data to pass to callback function
7009  *
7010  * Stops a file of type G_FILE_TYPE_MOUNTABLE.
7011  *
7012  * If @cancellable is not %NULL, then the operation can be cancelled by
7013  * triggering the cancellable object from another thread. If the operation
7014  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
7015  *
7016  * When the operation is finished, @callback will be called. You can then call
7017  * g_file_stop_mountable_finish() to get the result of the operation.
7018  *
7019  * Since: 2.22
7020  */
7021 void
7022 g_file_stop_mountable (GFile                      *file,
7023                        GMountUnmountFlags          flags,
7024                        GMountOperation            *mount_operation,
7025                        GCancellable               *cancellable,
7026                        GAsyncReadyCallback         callback,
7027                        gpointer                    user_data)
7028 {
7029   GFileIface *iface;
7030
7031   g_return_if_fail (G_IS_FILE (file));
7032
7033   iface = G_FILE_GET_IFACE (file);
7034
7035   if (iface->stop_mountable == NULL)
7036     {
7037       g_simple_async_report_error_in_idle (G_OBJECT (file),
7038                                            callback,
7039                                            user_data,
7040                                            G_IO_ERROR,
7041                                            G_IO_ERROR_NOT_SUPPORTED,
7042                                            _("Operation not supported"));
7043       return;
7044     }
7045
7046   (* iface->stop_mountable) (file,
7047                              flags,
7048                              mount_operation,
7049                              cancellable,
7050                              callback,
7051                              user_data);
7052 }
7053
7054 /**
7055  * g_file_stop_mountable_finish:
7056  * @file: input #GFile.
7057  * @result: a #GAsyncResult.
7058  * @error: a #GError, or %NULL
7059  *
7060  * Finishes an stop operation, see g_file_stop_mountable() for details.
7061  *
7062  * Finish an asynchronous stop operation that was started
7063  * with g_file_stop_mountable().
7064  *
7065  * Returns: %TRUE if the operation finished successfully. %FALSE
7066  * otherwise.
7067  *
7068  * Since: 2.22
7069  */
7070 gboolean
7071 g_file_stop_mountable_finish (GFile                      *file,
7072                               GAsyncResult               *result,
7073                               GError                    **error)
7074 {
7075   GFileIface *iface;
7076
7077   g_return_val_if_fail (G_IS_FILE (file), FALSE);
7078   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
7079
7080   if (G_IS_SIMPLE_ASYNC_RESULT (result))
7081     {
7082       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
7083       if (g_simple_async_result_propagate_error (simple, error))
7084         return FALSE;
7085     }
7086
7087   iface = G_FILE_GET_IFACE (file);
7088   return (* iface->stop_mountable_finish) (file, result, error);
7089 }
7090
7091 /**
7092  * g_file_poll_mountable:
7093  * @file: input #GFile.
7094  * @cancellable: optional #GCancellable object, %NULL to ignore.
7095  * @callback: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
7096  * @user_data: the data to pass to callback function
7097  *
7098  * Polls a file of type G_FILE_TYPE_MOUNTABLE.
7099  *
7100  * If @cancellable is not %NULL, then the operation can be cancelled by
7101  * triggering the cancellable object from another thread. If the operation
7102  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
7103  *
7104  * When the operation is finished, @callback will be called. You can then call
7105  * g_file_mount_mountable_finish() to get the result of the operation.
7106  *
7107  * Since: 2.22
7108  */
7109 void
7110 g_file_poll_mountable (GFile                      *file,
7111                        GCancellable               *cancellable,
7112                        GAsyncReadyCallback         callback,
7113                        gpointer                    user_data)
7114 {
7115   GFileIface *iface;
7116
7117   g_return_if_fail (G_IS_FILE (file));
7118
7119   iface = G_FILE_GET_IFACE (file);
7120
7121   if (iface->poll_mountable == NULL)
7122     {
7123       g_simple_async_report_error_in_idle (G_OBJECT (file),
7124                                            callback,
7125                                            user_data,
7126                                            G_IO_ERROR,
7127                                            G_IO_ERROR_NOT_SUPPORTED,
7128                                            _("Operation not supported"));
7129       return;
7130     }
7131
7132   (* iface->poll_mountable) (file,
7133                              cancellable,
7134                              callback,
7135                              user_data);
7136 }
7137
7138 /**
7139  * g_file_poll_mountable_finish:
7140  * @file: input #GFile.
7141  * @result: a #GAsyncResult.
7142  * @error: a #GError, or %NULL
7143  *
7144  * Finishes a poll operation. See g_file_poll_mountable() for details.
7145  *
7146  * Finish an asynchronous poll operation that was polled
7147  * with g_file_poll_mountable().
7148  *
7149  * Returns: %TRUE if the operation finished successfully. %FALSE
7150  * otherwise.
7151  *
7152  * Since: 2.22
7153  */
7154 gboolean
7155 g_file_poll_mountable_finish (GFile                      *file,
7156                               GAsyncResult               *result,
7157                               GError                    **error)
7158 {
7159   GFileIface *iface;
7160
7161   g_return_val_if_fail (G_IS_FILE (file), FALSE);
7162   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
7163
7164   if (G_IS_SIMPLE_ASYNC_RESULT (result))
7165     {
7166       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
7167       if (g_simple_async_result_propagate_error (simple, error))
7168         return FALSE;
7169     }
7170
7171   iface = G_FILE_GET_IFACE (file);
7172   return (* iface->poll_mountable_finish) (file, result, error);
7173 }
7174
7175 /**
7176  * g_file_supports_thread_contexts:
7177  * @file: a #GFile.
7178  *
7179  * Checks if @file supports <link
7180  * linkend="g-main-context-push-thread-default-context">thread-default
7181  * contexts</link>. If this returns %FALSE, you cannot perform
7182  * asynchronous operations on @file in a thread that has a
7183  * thread-default context.
7184  *
7185  * Returns: Whether or not @file supports thread-default contexts.
7186  *
7187  * Since: 2.22
7188  */
7189 gboolean
7190 g_file_supports_thread_contexts (GFile *file)
7191 {
7192  GFileIface *iface;
7193
7194  g_return_val_if_fail (G_IS_FILE (file), FALSE);
7195
7196  iface = G_FILE_GET_IFACE (file);
7197  return iface->supports_thread_contexts;
7198 }