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