1	/* GIO - GLib Input, Output and Streaming Library
2	*
3	* Copyright (C) 2006-2007 Red Hat, Inc.
4	*
5	* This library is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU Lesser General Public
7	* License as published by the Free Software Foundation; either
8	* version 2.1 of the License, or (at your option) any later version.
9	*
10	* This library is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	* Lesser General Public License for more details.
14	*
15	* You should have received a copy of the GNU Lesser General
16	* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17	*
18	* Author: Alexander Larsson <alexl@redhat.com>
19	*/
20
21	#include "config.h"
22
23	#include <sys/types.h>
24	#include <sys/stat.h>
25	#include <string.h>
26	#include <errno.h>
27	#include <fcntl.h>
28	#if G_OS_UNIX
29	#include <dirent.h>
30	#include <unistd.h>
31	#endif
32
33	#if HAVE_SYS_STATFS_H
34	#include <sys/statfs.h>
35	#endif
36	#if HAVE_SYS_STATVFS_H
37	#include <sys/statvfs.h>
38	#endif
39	#if HAVE_SYS_VFS_H
40	#include <sys/vfs.h>
41	#elif HAVE_SYS_MOUNT_H
42	#if HAVE_SYS_PARAM_H
43	#include <sys/param.h>
44	#endif
45	#include <sys/mount.h>
46	#endif
47
48	#ifndef O_BINARY
49	#define O_BINARY 0
50	#endif
51
52	#include "gfileattribute.h"
53	#include "glocalfile.h"
54	#include "glocalfileinfo.h"
55	#include "glocalfileenumerator.h"
56	#include "glocalfileinputstream.h"
57	#include "glocalfileoutputstream.h"
58	#include "glocalfileiostream.h"
59	#include "glocalfilemonitor.h"
60	#include "gmountprivate.h"
61	#include "gunixmounts.h"
62	#include "gioerror.h"
63	#include <glib/gstdio.h>
64	#include <glib/gstdioprivate.h>
65	#include "glibintl.h"
66	#ifdef G_OS_UNIX
67	#include "glib-unix.h"
68	#include "gportalsupport.h"
69	#include "gtrashportal.h"
70	#endif
71
72	#include "glib-private.h"
73
74	#ifdef G_OS_WIN32
75	#include <windows.h>
76	#include <io.h>
77	#include <direct.h>
78
79	#ifndef FILE_READ_ONLY_VOLUME
80	#define FILE_READ_ONLY_VOLUME 0x00080000
81	#endif
82
83	#ifndef S_ISDIR
84	#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
85	#endif
86	#ifndef S_ISLNK
87	#define S_ISLNK(m) (0)
88	#endif
89
90	#ifndef ECANCELED
91	#define ECANCELED 105
92	#endif
93	#endif
94
95
96	static void g_local_file_file_iface_init (GFileIface *iface);
97
98	static GFileAttributeInfoList *local_writable_attributes = NULL;
99	static /* GFileAttributeInfoList * */ gsize local_writable_namespaces = 0;
100
101	struct _GLocalFile
102	{
103	GObject parent_instance;
104
105	char *filename;
106	};
107
108	#define g_local_file_get_type _g_local_file_get_type
109	G_DEFINE_TYPE_WITH_CODE (GLocalFile, g_local_file, G_TYPE_OBJECT,
110	G_IMPLEMENT_INTERFACE (G_TYPE_FILE,
111	g_local_file_file_iface_init))
112
113	static char *find_mountpoint_for (const char *file, dev_t dev, gboolean resolve_basename_symlink);
114
115	#ifndef G_OS_WIN32
116	static gboolean is_remote_fs_type (const gchar *fsname);
117	#endif
118
119	static void
120	g_local_file_finalize (GObject *object)
121	{
122	GLocalFile *local;
123
124	local = G_LOCAL_FILE (object);
125
126	g_free (mem: local->filename);
127
128	G_OBJECT_CLASS (g_local_file_parent_class)->finalize (object);
129	}
130
131	static void
132	g_local_file_class_init (GLocalFileClass *klass)
133	{
134	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
135	GFileAttributeInfoList *list;
136
137	gobject_class->finalize = g_local_file_finalize;
138
139	/* Set up attribute lists */
140
141	/* Writable attributes: */
142
143	list = g_file_attribute_info_list_new ();
144
145	g_file_attribute_info_list_add (list,
146	G_FILE_ATTRIBUTE_UNIX_MODE,
147	type: G_FILE_ATTRIBUTE_TYPE_UINT32,
148	flags: G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |
149	G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
150
151	#ifdef G_OS_UNIX
152	g_file_attribute_info_list_add (list,
153	G_FILE_ATTRIBUTE_UNIX_UID,
154	type: G_FILE_ATTRIBUTE_TYPE_UINT32,
155	flags: G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
156	g_file_attribute_info_list_add (list,
157	G_FILE_ATTRIBUTE_UNIX_GID,
158	type: G_FILE_ATTRIBUTE_TYPE_UINT32,
159	flags: G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
160	#endif
161
162	#ifdef HAVE_SYMLINK
163	g_file_attribute_info_list_add (list,
164	G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,
165	type: G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
166	flags: 0);
167	#endif
168
169	#ifdef HAVE_UTIMES
170	g_file_attribute_info_list_add (list,
171	G_FILE_ATTRIBUTE_TIME_MODIFIED,
172	type: G_FILE_ATTRIBUTE_TYPE_UINT64,
173	flags: G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |
174	G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
175	g_file_attribute_info_list_add (list,
176	G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
177	type: G_FILE_ATTRIBUTE_TYPE_UINT32,
178	flags: G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |
179	G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
180	/* When copying, the target file is accessed. Replicating
181	* the source access time does not make sense in this case.
182	*/
183	g_file_attribute_info_list_add (list,
184	G_FILE_ATTRIBUTE_TIME_ACCESS,
185	type: G_FILE_ATTRIBUTE_TYPE_UINT64,
186	flags: G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
187	g_file_attribute_info_list_add (list,
188	G_FILE_ATTRIBUTE_TIME_ACCESS_USEC,
189	type: G_FILE_ATTRIBUTE_TYPE_UINT32,
190	flags: G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
191	#endif
192
193	local_writable_attributes = list;
194	}
195
196	static void
197	g_local_file_init (GLocalFile *local)
198	{
199	}
200
201	const char *
202	_g_local_file_get_filename (GLocalFile *file)
203	{
204	return file->filename;
205	}
206
207	GFile *
208	_g_local_file_new (const char *filename)
209	{
210	GLocalFile *local;
211
212	local = g_object_new (G_TYPE_LOCAL_FILE, NULL);
213	local->filename = g_canonicalize_filename (filename, NULL);
214
215	return G_FILE (local);
216	}
217
218	/*< internal >
219	* g_local_file_new_from_dirname_and_basename:
220	* @dirname: an absolute, canonical directory name
221	* @basename: the name of a child inside @dirname
222	*
223	* Creates a #GFile from @dirname and @basename.
224	*
225	* This is more efficient than pasting the fields together for yourself
226	* and creating a #GFile from the result, and also more efficient than
227	* creating a #GFile for the dirname and using g_file_get_child().
228	*
229	* @dirname must be canonical, as per GLocalFile's opinion of what
230	* canonical means. This means that you should only pass strings that
231	* were returned by _g_local_file_get_filename().
232	*
233	* Returns: a #GFile
234	*/
235	GFile *
236	g_local_file_new_from_dirname_and_basename (const gchar *dirname,
237	const gchar *basename)
238	{
239	GLocalFile *local;
240
241	g_return_val_if_fail (dirname != NULL, NULL);
242	g_return_val_if_fail (basename && basename[0] && !strchr (basename, '/'), NULL);
243
244	local = g_object_new (G_TYPE_LOCAL_FILE, NULL);
245	local->filename = g_build_filename (first_element: dirname, basename, NULL);
246
247	return G_FILE (local);
248	}
249
250	static gboolean
251	g_local_file_is_native (GFile *file)
252	{
253	return TRUE;
254	}
255
256	static gboolean
257	g_local_file_has_uri_scheme (GFile *file,
258	const char *uri_scheme)
259	{
260	return g_ascii_strcasecmp (s1: uri_scheme, s2: "file") == 0;
261	}
262
263	static char *
264	g_local_file_get_uri_scheme (GFile *file)
265	{
266	return g_strdup (str: "file");
267	}
268
269	static char *
270	g_local_file_get_basename (GFile *file)
271	{
272	return g_path_get_basename (G_LOCAL_FILE (file)->filename);
273	}
274
275	static char *
276	g_local_file_get_path (GFile *file)
277	{
278	return g_strdup (G_LOCAL_FILE (file)->filename);
279	}
280
281	static char *
282	g_local_file_get_uri (GFile *file)
283	{
284	return g_filename_to_uri (G_LOCAL_FILE (file)->filename, NULL, NULL);
285	}
286
287	static gboolean
288	get_filename_charset (const gchar **filename_charset)
289	{
290	const gchar **charsets;
291	gboolean is_utf8;
292
293	is_utf8 = g_get_filename_charsets (filename_charsets: &charsets);
294
295	if (filename_charset)
296	*filename_charset = charsets[0];
297
298	return is_utf8;
299	}
300
301	static gboolean
302	name_is_valid_for_display (const char *string,
303	gboolean is_valid_utf8)
304	{
305	char c;
306
307	if (!is_valid_utf8 &&
308	!g_utf8_validate (str: string, max_len: -1, NULL))
309	return FALSE;
310
311	while ((c = *string++) != 0)
312	{
313	if (g_ascii_iscntrl (c))
314	return FALSE;
315	}
316
317	return TRUE;
318	}
319
320	static char *
321	g_local_file_get_parse_name (GFile *file)
322	{
323	const char *filename;
324	char *parse_name;
325	const gchar *charset;
326	char *utf8_filename;
327	char *roundtripped_filename;
328	gboolean free_utf8_filename;
329	gboolean is_valid_utf8;
330	char *escaped_path;
331
332	filename = G_LOCAL_FILE (file)->filename;
333	if (get_filename_charset (filename_charset: &charset))
334	{
335	utf8_filename = (char *)filename;
336	free_utf8_filename = FALSE;
337	is_valid_utf8 = FALSE; /* Can't guarantee this */
338	}
339	else
340	{
341	utf8_filename = g_convert (str: filename, len: -1,
342	to_codeset: "UTF-8", from_codeset: charset, NULL, NULL, NULL);
343	free_utf8_filename = TRUE;
344	is_valid_utf8 = TRUE;
345
346	if (utf8_filename != NULL)
347	{
348	/* Make sure we can roundtrip: */
349	roundtripped_filename = g_convert (str: utf8_filename, len: -1,
350	to_codeset: charset, from_codeset: "UTF-8", NULL, NULL, NULL);
351
352	if (roundtripped_filename == NULL ||
353	strcmp (s1: filename, s2: roundtripped_filename) != 0)
354	{
355	g_free (mem: utf8_filename);
356	utf8_filename = NULL;
357	}
358
359	g_free (mem: roundtripped_filename);
360	}
361	}
362
363	if (utf8_filename != NULL &&
364	name_is_valid_for_display (string: utf8_filename, is_valid_utf8))
365	{
366	if (free_utf8_filename)
367	parse_name = utf8_filename;
368	else
369	parse_name = g_strdup (str: utf8_filename);
370	}
371	else
372	{
373	#ifdef G_OS_WIN32
374	char *dup_filename, *p, *backslash;
375
376	/* Turn backslashes into forward slashes like
377	* g_filename_to_uri() would do (but we can't use that because
378	* it doesn't output IRIs).
379	*/
380	dup_filename = g_strdup (filename);
381	filename = p = dup_filename;
382
383	while ((backslash = strchr (p, '\\')) != NULL)
384	{
385	*backslash = '/';
386	p = backslash + 1;
387	}
388	#endif
389
390	escaped_path = g_uri_escape_string (unescaped: filename,
391	G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT "/",
392	TRUE);
393	parse_name = g_strconcat (string1: "file://",
394	(*escaped_path != '/') ? "/" : "",
395	escaped_path,
396	NULL);
397
398	g_free (mem: escaped_path);
399	#ifdef G_OS_WIN32
400	g_free (dup_filename);
401	#endif
402	if (free_utf8_filename)
403	g_free (mem: utf8_filename);
404	}
405
406	return parse_name;
407	}
408
409	static GFile *
410	g_local_file_get_parent (GFile *file)
411	{
412	GLocalFile *local = G_LOCAL_FILE (file);
413	const char *non_root;
414	char *dirname;
415	GFile *parent;
416
417	/* Check for root; local->filename is guaranteed to be absolute, so
418	* g_path_skip_root() should never return NULL. */
419	non_root = g_path_skip_root (file_name: local->filename);
420	g_assert (non_root != NULL);
421
422	if (*non_root == 0)
423	return NULL;
424
425	dirname = g_path_get_dirname (file_name: local->filename);
426	parent = _g_local_file_new (filename: dirname);
427	g_free (mem: dirname);
428	return parent;
429	}
430
431	static GFile *
432	g_local_file_dup (GFile *file)
433	{
434	GLocalFile *local = G_LOCAL_FILE (file);
435
436	return _g_local_file_new (filename: local->filename);
437	}
438
439	static guint
440	g_local_file_hash (GFile *file)
441	{
442	GLocalFile *local = G_LOCAL_FILE (file);
443
444	return g_str_hash (v: local->filename);
445	}
446
447	static gboolean
448	g_local_file_equal (GFile *file1,
449	GFile *file2)
450	{
451	GLocalFile *local1 = G_LOCAL_FILE (file1);
452	GLocalFile *local2 = G_LOCAL_FILE (file2);
453
454	return g_str_equal (v1: local1->filename, v2: local2->filename);
455	}
456
457	static const char *
458	match_prefix (const char *path,
459	const char *prefix)
460	{
461	int prefix_len;
462
463	prefix_len = strlen (s: prefix);
464	if (strncmp (s1: path, s2: prefix, n: prefix_len) != 0)
465	return NULL;
466
467	/* Handle the case where prefix is the root, so that
468	* the IS_DIR_SEPRARATOR check below works */
469	if (prefix_len > 0 &&
470	G_IS_DIR_SEPARATOR (prefix[prefix_len-1]))
471	prefix_len--;
472
473	return path + prefix_len;
474	}
475
476	static gboolean
477	g_local_file_prefix_matches (GFile *parent,
478	GFile *descendant)
479	{
480	GLocalFile *parent_local = G_LOCAL_FILE (parent);
481	GLocalFile *descendant_local = G_LOCAL_FILE (descendant);
482	const char *remainder;
483
484	remainder = match_prefix (path: descendant_local->filename, prefix: parent_local->filename);
485	if (remainder != NULL && G_IS_DIR_SEPARATOR (*remainder))
486	return TRUE;
487	return FALSE;
488	}
489
490	static char *
491	g_local_file_get_relative_path (GFile *parent,
492	GFile *descendant)
493	{
494	GLocalFile *parent_local = G_LOCAL_FILE (parent);
495	GLocalFile *descendant_local = G_LOCAL_FILE (descendant);
496	const char *remainder;
497
498	remainder = match_prefix (path: descendant_local->filename, prefix: parent_local->filename);
499
500	if (remainder != NULL && G_IS_DIR_SEPARATOR (*remainder))
501	return g_strdup (str: remainder + 1);
502	return NULL;
503	}
504
505	static GFile *
506	g_local_file_resolve_relative_path (GFile *file,
507	const char *relative_path)
508	{
509	GLocalFile *local = G_LOCAL_FILE (file);
510	char *filename;
511	GFile *child;
512
513	if (g_path_is_absolute (file_name: relative_path))
514	return _g_local_file_new (filename: relative_path);
515
516	filename = g_build_filename (first_element: local->filename, relative_path, NULL);
517	child = _g_local_file_new (filename);
518	g_free (mem: filename);
519
520	return child;
521	}
522
523	static GFileEnumerator *
524	g_local_file_enumerate_children (GFile *file,
525	const char *attributes,
526	GFileQueryInfoFlags flags,
527	GCancellable *cancellable,
528	GError **error)
529	{
530	GLocalFile *local = G_LOCAL_FILE (file);
531	return _g_local_file_enumerator_new (file: local,
532	attributes, flags,
533	cancellable, error);
534	}
535
536	static GFile *
537	g_local_file_get_child_for_display_name (GFile *file,
538	const char *display_name,
539	GError **error)
540	{
541	GFile *new_file;
542	char *basename;
543
544	basename = g_filename_from_utf8 (utf8string: display_name, len: -1, NULL, NULL, NULL);
545	if (basename == NULL)
546	{
547	g_set_error (err: error, G_IO_ERROR,
548	code: G_IO_ERROR_INVALID_FILENAME,
549	_("Invalid filename %s"), display_name);
550	return NULL;
551	}
552
553	new_file = g_file_get_child (file, name: basename);
554	g_free (mem: basename);
555
556	return new_file;
557	}
558
559	#if defined(USE_STATFS) && !defined(HAVE_STRUCT_STATFS_F_FSTYPENAME)
560	static const char *
561	get_fs_type (long f_type)
562	{
563	/* filesystem ids taken from linux manpage */
564	switch (f_type)
565	{
566	case 0xadf5:
567	return "adfs";
568	case 0x5346414f:
569	return "afs";
570	case 0x0187:
571	return "autofs";
572	case 0xADFF:
573	return "affs";
574	case 0x62646576:
575	return "bdevfs";
576	case 0x42465331:
577	return "befs";
578	case 0x1BADFACE:
579	return "bfs";
580	case 0x42494e4d:
581	return "binfmt_misc";
582	case 0x9123683E:
583	return "btrfs";
584	case 0x73727279:
585	return "btrfs_test_fs";
586	case 0x27e0eb:
587	return "cgroup";
588	case 0x63677270:
589	return "cgroup2";
590	case 0xFF534D42:
591	return "cifs";
592	case 0x73757245:
593	return "coda";
594	case 0x012FF7B7:
595	return "coh";
596	case 0x62656570:
597	return "configfs";
598	case 0x28cd3d45:
599	return "cramfs";
600	case 0x64626720:
601	return "debugfs";
602	case 0x1373:
603	return "devfs";
604	case 0x1cd1:
605	return "devpts";
606	case 0xf15f:
607	return "ecryptfs";
608	case 0xde5e81e4:
609	return "efivarfs";
610	case 0x00414A53:
611	return "efs";
612	case 0x137D:
613	return "ext";
614	case 0xEF51:
615	return "ext2";
616	case 0xEF53:
617	return "ext3/ext4";
618	case 0xF2F52010:
619	return "f2fs";
620	case 0x65735546:
621	return "fuse";
622	case 0x65735543:
623	return "fusectl";
624	case 0xBAD1DEA:
625	return "futexfs";
626	case 0x4244:
627	return "hfs";
628	case 0x00c0ffee:
629	return "hostfs";
630	case 0xF995E849:
631	return "hpfs";
632	case 0x958458f6:
633	return "hugetlbfs";
634	case 0x9660:
635	return "isofs";
636	case 0x72b6:
637	return "jffs2";
638	case 0x3153464a:
639	return "jfs";
640	case 0x137F:
641	return "minix";
642	case 0x138F:
643	return "minix2";
644	case 0x2468:
645	return "minix2";
646	case 0x2478:
647	return "minix22";
648	case 0x4d5a:
649	return "minix3";
650	case 0x19800202:
651	return "mqueue";
652	case 0x4d44:
653	return "msdos";
654	case 0x564c:
655	return "ncp";
656	case 0x6969:
657	return "nfs";
658	case 0x3434:
659	return "nilfs";
660	case 0x6e736673:
661	return "nsfs";
662	case 0x5346544e:
663	return "ntfs";
664	case 0x7461636f:
665	return "ocfs2";
666	case 0x9fa1:
667	return "openprom";
668	case 0x794c7630:
669	return "overlay";
670	case 0x50495045:
671	return "pipefs";
672	case 0x9fa0:
673	return "proc";
674	case 0x6165676C:
675	return "pstore";
676	case 0x002f:
677	return "qnx4";
678	case 0x68191122:
679	return "qnx6";
680	case 0x858458f6:
681	return "ramfs";
682	case 0x52654973:
683	return "reiserfs";
684	case 0x7275:
685	return "romfs";
686	case 0x67596969:
687	return "rpc_pipefs";
688	case 0x73636673:
689	return "securityfs";
690	case 0xf97cff8c:
691	return "selinuxfs";
692	case 0x43415d53:
693	return "smackfs";
694	case 0x517B:
695	return "smb";
696	case 0xfe534d42:
697	return "smb2";
698	case 0x534F434B:
699	return "sockfs";
700	case 0x73717368:
701	return "squashfs";
702	case 0x62656572:
703	return "sysfs";
704	case 0x012FF7B6:
705	return "sysv2";
706	case 0x012FF7B5:
707	return "sysv4";
708	case 0x01021994:
709	return "tmpfs";
710	case 0x74726163:
711	return "tracefs";
712	case 0x15013346:
713	return "udf";
714	case 0x00011954:
715	return "ufs";
716	case 0x9fa2:
717	return "usbdevice";
718	case 0x01021997:
719	return "v9fs";
720	case 0xa501FCF5:
721	return "vxfs";
722	case 0xabba1974:
723	return "xenfs";
724	case 0x012FF7B4:
725	return "xenix";
726	case 0x58465342:
727	return "xfs";
728	case 0x012FD16D:
729	return "xiafs";
730	case 0x52345362:
731	return "reiser4";
732	default:
733	return NULL;
734	}
735	}
736	#endif
737
738	#ifndef G_OS_WIN32
739
740	G_LOCK_DEFINE_STATIC(mount_info_hash);
741	static GHashTable *mount_info_hash = NULL;
742	static guint64 mount_info_hash_cache_time = 0;
743
744	typedef enum {
745	MOUNT_INFO_READONLY = 1<<0
746	} MountInfo;
747
748	static gboolean
749	device_equal (gconstpointer v1,
750	gconstpointer v2)
751	{
752	return *(dev_t *)v1 == *(dev_t *)v2;
753	}
754
755	static guint
756	device_hash (gconstpointer v)
757	{
758	return (guint) *(dev_t *)v;
759	}
760
761	static void
762	get_mount_info (GFileInfo *fs_info,
763	const char *path,
764	GFileAttributeMatcher *matcher)
765	{
766	GStatBuf buf;
767	gboolean got_info;
768	gpointer info_as_ptr;
769	guint mount_info;
770	char *mountpoint;
771	dev_t *dev;
772	GUnixMountEntry *mount;
773	guint64 cache_time;
774
775	if (g_lstat (file: path, buf: &buf) != 0)
776	return;
777
778	G_LOCK (mount_info_hash);
779
780	if (mount_info_hash == NULL)
781	mount_info_hash = g_hash_table_new_full (hash_func: device_hash, key_equal_func: device_equal,
782	key_destroy_func: g_free, NULL);
783
784
785	if (g_unix_mounts_changed_since (time: mount_info_hash_cache_time))
786	g_hash_table_remove_all (hash_table: mount_info_hash);
787
788	got_info = g_hash_table_lookup_extended (hash_table: mount_info_hash,
789	lookup_key: &buf.st_dev,
790	NULL,
791	value: &info_as_ptr);
792
793	G_UNLOCK (mount_info_hash);
794
795	mount_info = GPOINTER_TO_UINT (info_as_ptr);
796
797	if (!got_info)
798	{
799	mount_info = 0;
800
801	mountpoint = find_mountpoint_for (file: path, dev: buf.st_dev, FALSE);
802	if (mountpoint == NULL)
803	mountpoint = g_strdup (str: "/");
804
805	mount = g_unix_mount_at (mount_path: mountpoint, time_read: &cache_time);
806	if (mount)
807	{
808	if (g_unix_mount_is_readonly (mount_entry: mount))
809	mount_info |= MOUNT_INFO_READONLY;
810
811	g_unix_mount_free (mount_entry: mount);
812	}
813
814	g_free (mem: mountpoint);
815
816	dev = g_new0 (dev_t, 1);
817	*dev = buf.st_dev;
818
819	G_LOCK (mount_info_hash);
820	mount_info_hash_cache_time = cache_time;
821	g_hash_table_insert (hash_table: mount_info_hash, key: dev, GUINT_TO_POINTER (mount_info));
822	G_UNLOCK (mount_info_hash);
823	}
824
825	if (mount_info & MOUNT_INFO_READONLY)
826	g_file_info_set_attribute_boolean (info: fs_info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, TRUE);
827	}
828
829	#endif
830
831	#ifdef G_OS_WIN32
832
833	static wchar_t *
834	get_volume_for_path (const char *path)
835	{
836	long len;
837	wchar_t *wpath;
838	wchar_t *result;
839
840	wpath = g_utf8_to_utf16 (path, -1, NULL, NULL, NULL);
841	result = g_new (wchar_t, MAX_PATH);
842
843	if (!GetVolumePathNameW (wpath, result, MAX_PATH))
844	{
845	char *msg = g_win32_error_message (GetLastError ());
846	g_critical ("GetVolumePathName failed: %s", msg);
847	g_free (msg);
848	g_free (result);
849	g_free (wpath);
850	return NULL;
851	}
852
853	len = wcslen (result);
854	if (len > 0 && result[len-1] != L'\\')
855	{
856	result = g_renew (wchar_t, result, len + 2);
857	result[len] = L'\\';
858	result[len + 1] = 0;
859	}
860
861	g_free (wpath);
862	return result;
863	}
864
865	static char *
866	find_mountpoint_for (const char *file, dev_t dev, gboolean resolve_basename_symlink)
867	{
868	wchar_t *wpath;
869	char *utf8_path;
870
871	wpath = get_volume_for_path (file);
872	if (!wpath)
873	return NULL;
874
875	utf8_path = g_utf16_to_utf8 (wpath, -1, NULL, NULL, NULL);
876
877	g_free (wpath);
878	return utf8_path;
879	}
880
881	static void
882	get_filesystem_readonly (GFileInfo *info,
883	const char *path)
884	{
885	wchar_t *rootdir;
886
887	rootdir = get_volume_for_path (path);
888
889	if (rootdir)
890	{
891	DWORD flags;
892	if (GetVolumeInformationW (rootdir, NULL, 0, NULL, NULL, &flags, NULL, 0))
893	g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY,
894	(flags & FILE_READ_ONLY_VOLUME) != 0);
895	}
896
897	g_free (rootdir);
898	}
899
900	#endif /* G_OS_WIN32 */
901
902	#pragma GCC diagnostic push
903	#pragma GCC diagnostic ignored "-Wformat-nonliteral"
904	static void
905	g_set_io_error (GError **error,
906	const gchar *msg,
907	GFile *file,
908	gint errsv)
909	{
910	GLocalFile *local = G_LOCAL_FILE (file);
911	gchar *display_name;
912
913	display_name = g_filename_display_name (filename: local->filename);
914	g_set_error (err: error, G_IO_ERROR, code: g_io_error_from_errno (err_no: errsv),
915	format: msg, display_name, g_strerror (errnum: errsv));
916	g_free (mem: display_name);
917	}
918	#pragma GCC diagnostic pop
919
920	static GFileInfo *
921	g_local_file_query_filesystem_info (GFile *file,
922	const char *attributes,
923	GCancellable *cancellable,
924	GError **error)
925	{
926	GLocalFile *local = G_LOCAL_FILE (file);
927	GFileInfo *info;
928	int statfs_result = 0;
929	gboolean no_size;
930	#ifndef G_OS_WIN32
931	const char *fstype;
932	#ifdef USE_STATFS
933	guint64 block_size;
934	struct statfs statfs_buffer;
935	#elif defined(USE_STATVFS)
936	guint64 block_size;
937	struct statvfs statfs_buffer;
938	#endif /* USE_STATFS */
939	#endif /* G_OS_WIN32 */
940	GFileAttributeMatcher *attribute_matcher;
941
942	no_size = FALSE;
943
944	#ifdef USE_STATFS
945
946	#if STATFS_ARGS == 2
947	statfs_result = statfs (file: local->filename, buf: &statfs_buffer);
948	#elif STATFS_ARGS == 4
949	statfs_result = statfs (local->filename, &statfs_buffer,
950	sizeof (statfs_buffer), 0);
951	#endif /* STATFS_ARGS == 2 */
952	block_size = statfs_buffer.f_bsize;
953
954	/* Many backends can't report free size (for instance the gvfs fuse
955	* backend for backend not supporting this), and set f_bfree to 0,
956	* but it can be 0 for real too. We treat the available == 0 and
957	* free == 0 case as "both of these are invalid", but only on file systems
958	* which are known to not support this (otherwise we can omit metadata for
959	* systems which are legitimately full). */
960	#if defined(__linux__)
961	if (statfs_result == 0 &&
962	statfs_buffer.f_bavail == 0 && statfs_buffer.f_bfree == 0 &&
963	(/* linux/ncp_fs.h: NCP_SUPER_MAGIC == 0x564c */
964	statfs_buffer.f_type == 0x564c ||
965	/* man statfs: FUSE_SUPER_MAGIC == 0x65735546 */
966	statfs_buffer.f_type == 0x65735546))
967	no_size = TRUE;
968	#endif /* __linux__ */
969
970	#elif defined(USE_STATVFS)
971	statfs_result = statvfs (local->filename, &statfs_buffer);
972	block_size = statfs_buffer.f_frsize;
973	#endif /* USE_STATFS */
974
975	if (statfs_result == -1)
976	{
977	int errsv = errno;
978
979	g_set_io_error (error,
980	_("Error getting filesystem info for %s: %s"),
981	file, errsv);
982	return NULL;
983	}
984
985	info = g_file_info_new ();
986
987	attribute_matcher = g_file_attribute_matcher_new (attributes);
988
989	if (!no_size &&
990	g_file_attribute_matcher_matches (matcher: attribute_matcher,
991	G_FILE_ATTRIBUTE_FILESYSTEM_FREE))
992	{
993	#ifdef G_OS_WIN32
994	gchar *localdir = g_path_get_dirname (local->filename);
995	wchar_t *wdirname = g_utf8_to_utf16 (localdir, -1, NULL, NULL, NULL);
996	ULARGE_INTEGER li;
997
998	g_free (localdir);
999	if (GetDiskFreeSpaceExW (wdirname, &li, NULL, NULL))
1000	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, (guint64)li.QuadPart);
1001	g_free (wdirname);
1002	#else
1003	#if defined(USE_STATFS) || defined(USE_STATVFS)
1004	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, attr_value: block_size * statfs_buffer.f_bavail);
1005	#endif
1006	#endif
1007	}
1008	if (!no_size &&
1009	g_file_attribute_matcher_matches (matcher: attribute_matcher,
1010	G_FILE_ATTRIBUTE_FILESYSTEM_SIZE))
1011	{
1012	#ifdef G_OS_WIN32
1013	gchar *localdir = g_path_get_dirname (local->filename);
1014	wchar_t *wdirname = g_utf8_to_utf16 (localdir, -1, NULL, NULL, NULL);
1015	ULARGE_INTEGER li;
1016
1017	g_free (localdir);
1018	if (GetDiskFreeSpaceExW (wdirname, NULL, &li, NULL))
1019	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE, (guint64)li.QuadPart);
1020	g_free (wdirname);
1021	#else
1022	#if defined(USE_STATFS) || defined(USE_STATVFS)
1023	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE, attr_value: block_size * statfs_buffer.f_blocks);
1024	#endif
1025	#endif /* G_OS_WIN32 */
1026	}
1027
1028	if (!no_size &&
1029	g_file_attribute_matcher_matches (matcher: attribute_matcher,
1030	G_FILE_ATTRIBUTE_FILESYSTEM_USED))
1031	{
1032	#ifdef G_OS_WIN32
1033	gchar *localdir = g_path_get_dirname (local->filename);
1034	wchar_t *wdirname = g_utf8_to_utf16 (localdir, -1, NULL, NULL, NULL);
1035	ULARGE_INTEGER li_free;
1036	ULARGE_INTEGER li_total;
1037
1038	g_free (localdir);
1039	if (GetDiskFreeSpaceExW (wdirname, &li_free, &li_total, NULL))
1040	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED, (guint64)li_total.QuadPart - (guint64)li_free.QuadPart);
1041	g_free (wdirname);
1042	#else
1043	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED, attr_value: block_size * (statfs_buffer.f_blocks - statfs_buffer.f_bfree));
1044	#endif /* G_OS_WIN32 */
1045	}
1046
1047	#ifndef G_OS_WIN32
1048	#ifdef USE_STATFS
1049	#if defined(HAVE_STRUCT_STATFS_F_FSTYPENAME)
1050	fstype = statfs_buffer.f_fstypename;
1051	#else
1052	fstype = get_fs_type (f_type: statfs_buffer.f_type);
1053	#endif
1054
1055	#elif defined(USE_STATVFS)
1056	#if defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME)
1057	fstype = statfs_buffer.f_fstypename;
1058	#elif defined(HAVE_STRUCT_STATVFS_F_BASETYPE)
1059	fstype = statfs_buffer.f_basetype;
1060	#else
1061	fstype = NULL;
1062	#endif
1063	#endif /* USE_STATFS */
1064
1065	if (fstype &&
1066	g_file_attribute_matcher_matches (matcher: attribute_matcher,
1067	G_FILE_ATTRIBUTE_FILESYSTEM_TYPE))
1068	g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, attr_value: fstype);
1069	#endif /* G_OS_WIN32 */
1070
1071	if (g_file_attribute_matcher_matches (matcher: attribute_matcher,
1072	G_FILE_ATTRIBUTE_FILESYSTEM_READONLY))
1073	{
1074	#ifdef G_OS_WIN32
1075	get_filesystem_readonly (info, local->filename);
1076	#else
1077	get_mount_info (fs_info: info, path: local->filename, matcher: attribute_matcher);
1078	#endif /* G_OS_WIN32 */
1079	}
1080
1081	#ifndef G_OS_WIN32
1082	if (g_file_attribute_matcher_matches (matcher: attribute_matcher,
1083	G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE))
1084	g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE,
1085	attr_value: is_remote_fs_type (fsname: fstype));
1086	#endif
1087
1088	g_file_attribute_matcher_unref (matcher: attribute_matcher);
1089
1090	return info;
1091	}
1092
1093	static GMount *
1094	g_local_file_find_enclosing_mount (GFile *file,
1095	GCancellable *cancellable,
1096	GError **error)
1097	{
1098	GLocalFile *local = G_LOCAL_FILE (file);
1099	GStatBuf buf;
1100	char *mountpoint;
1101	GMount *mount;
1102
1103	if (g_lstat (file: local->filename, buf: &buf) != 0)
1104	goto error;
1105
1106	mountpoint = find_mountpoint_for (file: local->filename, dev: buf.st_dev, FALSE);
1107	if (mountpoint == NULL)
1108	goto error;
1109
1110	mount = _g_mount_get_for_mount_path (mount_path: mountpoint, cancellable);
1111	g_free (mem: mountpoint);
1112	if (mount)
1113	return mount;
1114
1115	error:
1116	g_set_io_error (error,
1117	/* Translators: This is an error message when trying to find
1118	* the enclosing (user visible) mount of a file, but none
1119	* exists.
1120	*/
1121	_("Containing mount for file %s not found"),
1122	file, errsv: 0);
1123
1124	return NULL;
1125	}
1126
1127	static GFile *
1128	g_local_file_set_display_name (GFile *file,
1129	const char *display_name,
1130	GCancellable *cancellable,
1131	GError **error)
1132	{
1133	GLocalFile *local, *new_local;
1134	GFile *new_file, *parent;
1135	GStatBuf statbuf;
1136	GVfsClass *class;
1137	GVfs *vfs;
1138	int errsv;
1139
1140	parent = g_file_get_parent (file);
1141	if (parent == NULL)
1142	{
1143	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
1144	_("Can’t rename root directory"));
1145	return NULL;
1146	}
1147
1148	new_file = g_file_get_child_for_display_name (file: parent, display_name, error);
1149	g_object_unref (object: parent);
1150
1151	if (new_file == NULL)
1152	return NULL;
1153	local = G_LOCAL_FILE (file);
1154	new_local = G_LOCAL_FILE (new_file);
1155
1156	if (g_lstat (file: new_local->filename, buf: &statbuf) == -1)
1157	{
1158	errsv = errno;
1159
1160	if (errsv != ENOENT)
1161	{
1162	g_set_io_error (error, _("Error renaming file %s: %s"), file: new_file, errsv);
1163	return NULL;
1164	}
1165	}
1166	else
1167	{
1168	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_EXISTS,
1169	_("Can’t rename file, filename already exists"));
1170	return NULL;
1171	}
1172
1173	if (g_rename (old: local->filename, new: new_local->filename) == -1)
1174	{
1175	errsv = errno;
1176
1177	if (errsv == EINVAL)
1178	/* We can't get a rename file into itself error here,
1179	* so this must be an invalid filename, on e.g. FAT
1180	*/
1181	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_INVALID_FILENAME,
1182	_("Invalid filename"));
1183	else
1184	g_set_io_error (error,
1185	_("Error renaming file %s: %s"),
1186	file, errsv);
1187	g_object_unref (object: new_file);
1188	return NULL;
1189	}
1190
1191	vfs = g_vfs_get_default ();
1192	class = G_VFS_GET_CLASS (vfs);
1193	if (class->local_file_moved)
1194	class->local_file_moved (vfs, local->filename, new_local->filename);
1195
1196	return new_file;
1197	}
1198
1199	static GFileInfo *
1200	g_local_file_query_info (GFile *file,
1201	const char *attributes,
1202	GFileQueryInfoFlags flags,
1203	GCancellable *cancellable,
1204	GError **error)
1205	{
1206	GLocalFile *local = G_LOCAL_FILE (file);
1207	GFileInfo *info;
1208	GFileAttributeMatcher *matcher;
1209	char *basename, *dirname;
1210	GLocalParentFileInfo parent_info;
1211
1212	matcher = g_file_attribute_matcher_new (attributes);
1213
1214	basename = g_path_get_basename (file_name: local->filename);
1215
1216	dirname = g_path_get_dirname (file_name: local->filename);
1217	_g_local_file_info_get_parent_info (dir: dirname, attribute_matcher: matcher, parent_info: &parent_info);
1218	g_free (mem: dirname);
1219
1220	info = _g_local_file_info_get (basename, path: local->filename,
1221	attribute_matcher: matcher, flags, parent_info: &parent_info,
1222	error);
1223
1224
1225	_g_local_file_info_free_parent_info (parent_info: &parent_info);
1226	g_free (mem: basename);
1227
1228	g_file_attribute_matcher_unref (matcher);
1229
1230	return info;
1231	}
1232
1233	static GFileAttributeInfoList *
1234	g_local_file_query_settable_attributes (GFile *file,
1235	GCancellable *cancellable,
1236	GError **error)
1237	{
1238	return g_file_attribute_info_list_ref (list: local_writable_attributes);
1239	}
1240
1241	static GFileAttributeInfoList *
1242	g_local_file_query_writable_namespaces (GFile *file,
1243	GCancellable *cancellable,
1244	GError **error)
1245	{
1246	GFileAttributeInfoList *list;
1247	GVfsClass *class;
1248	GVfs *vfs;
1249
1250	if (g_once_init_enter (&local_writable_namespaces))
1251	{
1252	/* Writable namespaces: */
1253
1254	list = g_file_attribute_info_list_new ();
1255
1256	#ifdef HAVE_XATTR
1257	g_file_attribute_info_list_add (list,
1258	name: "xattr",
1259	type: G_FILE_ATTRIBUTE_TYPE_STRING,
1260	flags: G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |
1261	G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
1262	g_file_attribute_info_list_add (list,
1263	name: "xattr-sys",
1264	type: G_FILE_ATTRIBUTE_TYPE_STRING,
1265	flags: G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);
1266	#endif
1267
1268	vfs = g_vfs_get_default ();
1269	class = G_VFS_GET_CLASS (vfs);
1270	if (class->add_writable_namespaces)
1271	class->add_writable_namespaces (vfs, list);
1272
1273	g_once_init_leave (&local_writable_namespaces, (gsize)list);
1274	}
1275	list = (GFileAttributeInfoList *)local_writable_namespaces;
1276
1277	return g_file_attribute_info_list_ref (list);
1278	}
1279
1280	static gboolean
1281	g_local_file_set_attribute (GFile *file,
1282	const char *attribute,
1283	GFileAttributeType type,
1284	gpointer value_p,
1285	GFileQueryInfoFlags flags,
1286	GCancellable *cancellable,
1287	GError **error)
1288	{
1289	GLocalFile *local = G_LOCAL_FILE (file);
1290
1291	return _g_local_file_info_set_attribute (filename: local->filename,
1292	attribute,
1293	type,
1294	value_p,
1295	flags,
1296	cancellable,
1297	error);
1298	}
1299
1300	static gboolean
1301	g_local_file_set_attributes_from_info (GFile *file,
1302	GFileInfo *info,
1303	GFileQueryInfoFlags flags,
1304	GCancellable *cancellable,
1305	GError **error)
1306	{
1307	GLocalFile *local = G_LOCAL_FILE (file);
1308	int res, chained_res;
1309	GFileIface *default_iface;
1310
1311	res = _g_local_file_info_set_attributes (filename: local->filename,
1312	info, flags,
1313	cancellable,
1314	error);
1315
1316	if (!res)
1317	error = NULL; /* Don't write over error if further errors */
1318
1319	default_iface = g_type_default_interface_peek (G_TYPE_FILE);
1320
1321	chained_res = (default_iface->set_attributes_from_info) (file, info, flags, cancellable, error);
1322
1323	return res && chained_res;
1324	}
1325
1326	static GFileInputStream *
1327	g_local_file_read (GFile *file,
1328	GCancellable *cancellable,
1329	GError **error)
1330	{
1331	GLocalFile *local = G_LOCAL_FILE (file);
1332	int fd, ret;
1333	GLocalFileStat buf;
1334
1335	fd = g_open (file: local->filename, O_RDONLY|O_BINARY, 0);
1336	if (fd == -1)
1337	{
1338	int errsv = errno;
1339
1340	#ifdef G_OS_WIN32
1341	if (errsv == EACCES)
1342	{
1343	/* Exploit the fact that on W32 the glib filename encoding is UTF8 */
1344	ret = GLIB_PRIVATE_CALL (g_win32_stat_utf8) (local->filename, &buf);
1345	if (ret == 0 && S_ISDIR (buf.st_mode))
1346	errsv = EISDIR;
1347	}
1348	#endif
1349	g_set_io_error (error,
1350	_("Error opening file %s: %s"),
1351	file, errsv);
1352	return NULL;
1353	}
1354
1355	ret = g_local_file_fstat (fd, mask: G_LOCAL_FILE_STAT_FIELD_TYPE, G_LOCAL_FILE_STAT_FIELD_ALL, stat_buf: &buf);
1356
1357	if (ret == 0 && S_ISDIR (_g_stat_mode (&buf)))
1358	{
1359	(void) g_close (fd, NULL);
1360	g_set_io_error (error,
1361	_("Error opening file %s: %s"),
1362	file, EISDIR);
1363	return NULL;
1364	}
1365
1366	return _g_local_file_input_stream_new (fd);
1367	}
1368
1369	static GFileOutputStream *
1370	g_local_file_append_to (GFile *file,
1371	GFileCreateFlags flags,
1372	GCancellable *cancellable,
1373	GError **error)
1374	{
1375	return _g_local_file_output_stream_append (G_LOCAL_FILE (file)->filename,
1376	flags, cancellable, error);
1377	}
1378
1379	static GFileOutputStream *
1380	g_local_file_create (GFile *file,
1381	GFileCreateFlags flags,
1382	GCancellable *cancellable,
1383	GError **error)
1384	{
1385	return _g_local_file_output_stream_create (G_LOCAL_FILE (file)->filename,
1386	FALSE, flags, NULL,
1387	cancellable, error);
1388	}
1389
1390	static GFileOutputStream *
1391	g_local_file_replace (GFile *file,
1392	const char *etag,
1393	gboolean make_backup,
1394	GFileCreateFlags flags,
1395	GCancellable *cancellable,
1396	GError **error)
1397	{
1398	return _g_local_file_output_stream_replace (G_LOCAL_FILE (file)->filename,
1399	FALSE,
1400	etag, create_backup: make_backup, flags, NULL,
1401	cancellable, error);
1402	}
1403
1404	static GFileIOStream *
1405	g_local_file_open_readwrite (GFile *file,
1406	GCancellable *cancellable,
1407	GError **error)
1408	{
1409	GFileOutputStream *output;
1410	GFileIOStream *res;
1411
1412	output = _g_local_file_output_stream_open (G_LOCAL_FILE (file)->filename,
1413	TRUE,
1414	cancellable, error);
1415	if (output == NULL)
1416	return NULL;
1417
1418	res = _g_local_file_io_stream_new (G_LOCAL_FILE_OUTPUT_STREAM (output));
1419	g_object_unref (object: output);
1420	return res;
1421	}
1422
1423	static GFileIOStream *
1424	g_local_file_create_readwrite (GFile *file,
1425	GFileCreateFlags flags,
1426	GCancellable *cancellable,
1427	GError **error)
1428	{
1429	GFileOutputStream *output;
1430	GFileIOStream *res;
1431
1432	output = _g_local_file_output_stream_create (G_LOCAL_FILE (file)->filename,
1433	TRUE, flags, NULL,
1434	cancellable, error);
1435	if (output == NULL)
1436	return NULL;
1437
1438	res = _g_local_file_io_stream_new (G_LOCAL_FILE_OUTPUT_STREAM (output));
1439	g_object_unref (object: output);
1440	return res;
1441	}
1442
1443	static GFileIOStream *
1444	g_local_file_replace_readwrite (GFile *file,
1445	const char *etag,
1446	gboolean make_backup,
1447	GFileCreateFlags flags,
1448	GCancellable *cancellable,
1449	GError **error)
1450	{
1451	GFileOutputStream *output;
1452	GFileIOStream *res;
1453
1454	output = _g_local_file_output_stream_replace (G_LOCAL_FILE (file)->filename,
1455	TRUE,
1456	etag, create_backup: make_backup, flags, NULL,
1457	cancellable, error);
1458	if (output == NULL)
1459	return NULL;
1460
1461	res = _g_local_file_io_stream_new (G_LOCAL_FILE_OUTPUT_STREAM (output));
1462	g_object_unref (object: output);
1463	return res;
1464	}
1465
1466	static gboolean
1467	g_local_file_delete (GFile *file,
1468	GCancellable *cancellable,
1469	GError **error)
1470	{
1471	GLocalFile *local = G_LOCAL_FILE (file);
1472	GVfsClass *class;
1473	GVfs *vfs;
1474
1475	if (g_remove (filename: local->filename) == -1)
1476	{
1477	int errsv = errno;
1478
1479	/* Posix allows EEXIST too, but the clearer error
1480	is G_IO_ERROR_NOT_FOUND, and it's what nautilus
1481	expects */
1482	if (errsv == EEXIST)
1483	errsv = ENOTEMPTY;
1484
1485	g_set_io_error (error,
1486	_("Error removing file %s: %s"),
1487	file, errsv);
1488	return FALSE;
1489	}
1490
1491	vfs = g_vfs_get_default ();
1492	class = G_VFS_GET_CLASS (vfs);
1493	if (class->local_file_removed)
1494	class->local_file_removed (vfs, local->filename);
1495
1496	return TRUE;
1497	}
1498
1499	#ifndef G_OS_WIN32
1500
1501	static char *
1502	strip_trailing_slashes (const char *path)
1503	{
1504	char *path_copy;
1505	int len;
1506
1507	path_copy = g_strdup (str: path);
1508	len = strlen (s: path_copy);
1509	while (len > 1 && path_copy[len-1] == '/')
1510	path_copy[--len] = 0;
1511
1512	return path_copy;
1513	}
1514
1515	static char *
1516	expand_symlink (const char *link)
1517	{
1518	char *resolved, *canonical, *parent, *link2;
1519	char symlink_value[4096];
1520	#ifdef G_OS_WIN32
1521	#else
1522	gssize res;
1523	#endif
1524
1525	#ifdef G_OS_WIN32
1526	#else
1527	res = readlink (path: link, buf: symlink_value, len: sizeof (symlink_value) - 1);
1528
1529	if (res == -1)
1530	return g_strdup (str: link);
1531	symlink_value[res] = 0;
1532	#endif
1533
1534	if (g_path_is_absolute (file_name: symlink_value))
1535	return g_canonicalize_filename (filename: symlink_value, NULL);
1536	else
1537	{
1538	link2 = strip_trailing_slashes (path: link);
1539	parent = g_path_get_dirname (file_name: link2);
1540	g_free (mem: link2);
1541
1542	resolved = g_build_filename (first_element: parent, symlink_value, NULL);
1543	g_free (mem: parent);
1544
1545	canonical = g_canonicalize_filename (filename: resolved, NULL);
1546
1547	g_free (mem: resolved);
1548
1549	return canonical;
1550	}
1551	}
1552
1553	static char *
1554	expand_symlinks (const char *path,
1555	dev_t *dev)
1556	{
1557	char *tmp, *target;
1558	GStatBuf target_stat;
1559	int num_recursions;
1560
1561	target = g_strdup (str: path);
1562
1563	num_recursions = 0;
1564	do
1565	{
1566	if (g_lstat (file: target, buf: &target_stat) != 0)
1567	{
1568	g_free (mem: target);
1569	return NULL;
1570	}
1571
1572	if (S_ISLNK (target_stat.st_mode))
1573	{
1574	tmp = target;
1575	target = expand_symlink (link: target);
1576	g_free (mem: tmp);
1577	}
1578
1579	num_recursions++;
1580
1581	#ifdef MAXSYMLINKS
1582	if (num_recursions > MAXSYMLINKS)
1583	#else
1584	/* 40 is used in kernel sources currently:
1585	* https://github.com/torvalds/linux/include/linux/namei.h
1586	*/
1587	if (num_recursions > 40)
1588	#endif
1589	{
1590	g_free (mem: target);
1591	return NULL;
1592	}
1593	}
1594	while (S_ISLNK (target_stat.st_mode));
1595
1596	if (dev)
1597	*dev = target_stat.st_dev;
1598
1599	return target;
1600	}
1601
1602	static char *
1603	get_parent (const char *path,
1604	dev_t *parent_dev)
1605	{
1606	char *parent, *res;
1607	char *path_copy;
1608
1609	path_copy = strip_trailing_slashes (path);
1610
1611	parent = g_path_get_dirname (file_name: path_copy);
1612	if (strcmp (s1: parent, s2: ".") == 0)
1613	{
1614	g_free (mem: parent);
1615	g_free (mem: path_copy);
1616	return NULL;
1617	}
1618	g_free (mem: path_copy);
1619
1620	res = expand_symlinks (path: parent, dev: parent_dev);
1621	g_free (mem: parent);
1622
1623	return res;
1624	}
1625
1626	static char *
1627	expand_all_symlinks (const char *path)
1628	{
1629	char *parent, *parent_expanded;
1630	char *basename, *res;
1631	dev_t parent_dev;
1632
1633	parent = get_parent (path, parent_dev: &parent_dev);
1634	if (parent == NULL)
1635	return NULL;
1636
1637	if (g_strcmp0 (str1: parent, str2: "/") != 0)
1638	{
1639	parent_expanded = expand_all_symlinks (path: parent);
1640	basename = g_path_get_basename (file_name: path);
1641	res = g_build_filename (first_element: parent_expanded, basename, NULL);
1642	g_free (mem: basename);
1643	g_free (mem: parent_expanded);
1644	}
1645	else
1646	res = g_strdup (str: path);
1647
1648	g_free (mem: parent);
1649
1650	return res;
1651	}
1652
1653	static char *
1654	find_mountpoint_for (const char *file,
1655	dev_t dev,
1656	gboolean resolve_basename_symlink)
1657	{
1658	char *dir, *parent;
1659	dev_t dir_dev, parent_dev;
1660
1661	if (resolve_basename_symlink)
1662	{
1663	dir = expand_symlinks (path: file, NULL);
1664	if (dir == NULL)
1665	return NULL;
1666	}
1667	else
1668	dir = g_strdup (str: file);
1669
1670	dir_dev = dev;
1671
1672	while (g_strcmp0 (str1: dir, str2: "/") != 0)
1673	{
1674	parent = get_parent (path: dir, parent_dev: &parent_dev);
1675	if (parent == NULL)
1676	{
1677	g_free (mem: dir);
1678	return NULL;
1679	}
1680
1681	if (parent_dev != dir_dev)
1682	{
1683	g_free (mem: parent);
1684	return dir;
1685	}
1686
1687	g_free (mem: dir);
1688	dir = parent;
1689	}
1690
1691	return dir;
1692	}
1693
1694	char *
1695	_g_local_file_find_topdir_for (const char *file)
1696	{
1697	char *dir;
1698	char *mountpoint = NULL;
1699	dev_t dir_dev;
1700
1701	dir = get_parent (path: file, parent_dev: &dir_dev);
1702	if (dir == NULL)
1703	return NULL;
1704
1705	mountpoint = find_mountpoint_for (file: dir, dev: dir_dev, TRUE);
1706	g_free (mem: dir);
1707
1708	return mountpoint;
1709	}
1710
1711	static char *
1712	get_unique_filename (const char *basename,
1713	int id)
1714	{
1715	const char *dot;
1716
1717	if (id == 1)
1718	return g_strdup (str: basename);
1719
1720	dot = strchr (s: basename, c: '.');
1721	if (dot)
1722	return g_strdup_printf (format: "%.*s.%d%s", (int)(dot - basename), basename, id, dot);
1723	else
1724	return g_strdup_printf (format: "%s.%d", basename, id);
1725	}
1726
1727	static gboolean
1728	path_has_prefix (const char *path,
1729	const char *prefix)
1730	{
1731	int prefix_len;
1732
1733	if (prefix == NULL)
1734	return TRUE;
1735
1736	prefix_len = strlen (s: prefix);
1737
1738	if (strncmp (s1: path, s2: prefix, n: prefix_len) == 0 &&
1739	(prefix_len == 0 || /* empty prefix always matches */
1740	prefix[prefix_len - 1] == '/' || /* last char in prefix was a /, so it must be in path too */
1741	path[prefix_len] == 0 ||
1742	path[prefix_len] == '/'))
1743	return TRUE;
1744
1745	return FALSE;
1746	}
1747
1748	static char *
1749	try_make_relative (const char *path,
1750	const char *base)
1751	{
1752	char *path2, *base2;
1753	char *relative;
1754
1755	path2 = expand_all_symlinks (path);
1756	base2 = expand_all_symlinks (path: base);
1757
1758	relative = NULL;
1759	if (path2 != NULL && base2 != NULL && path_has_prefix (path: path2, prefix: base2))
1760	{
1761	relative = path2 + strlen (s: base2);
1762	while (*relative == '/')
1763	relative ++;
1764	relative = g_strdup (str: relative);
1765	}
1766	g_free (mem: path2);
1767	g_free (mem: base2);
1768
1769	if (relative)
1770	return relative;
1771
1772	/* Failed, use abs path */
1773	return g_strdup (str: path);
1774	}
1775
1776	static gboolean
1777	ignore_trash_mount (GUnixMountEntry *mount)
1778	{
1779	GUnixMountPoint *mount_point = NULL;
1780	const gchar *mount_options;
1781	gboolean retval = TRUE;
1782
1783	if (g_unix_mount_is_system_internal (mount_entry: mount))
1784	return TRUE;
1785
1786	mount_options = g_unix_mount_get_options (mount_entry: mount);
1787	if (mount_options == NULL)
1788	{
1789	mount_point = g_unix_mount_point_at (mount_path: g_unix_mount_get_mount_path (mount_entry: mount),
1790	NULL);
1791	if (mount_point != NULL)
1792	mount_options = g_unix_mount_point_get_options (mount_point);
1793	}
1794
1795	if (mount_options == NULL ||
1796	strstr (haystack: mount_options, needle: "x-gvfs-notrash") == NULL)
1797	retval = FALSE;
1798
1799	g_clear_pointer (&mount_point, g_unix_mount_point_free);
1800
1801	return retval;
1802	}
1803
1804	static gboolean
1805	ignore_trash_path (const gchar *topdir)
1806	{
1807	GUnixMountEntry *mount;
1808	gboolean retval = TRUE;
1809
1810	mount = g_unix_mount_at (mount_path: topdir, NULL);
1811	if (mount == NULL)
1812	goto out;
1813
1814	retval = ignore_trash_mount (mount);
1815
1816	out:
1817	g_clear_pointer (&mount, g_unix_mount_free);
1818
1819	return retval;
1820	}
1821
1822	gboolean
1823	_g_local_file_has_trash_dir (const char *dirname, dev_t dir_dev)
1824	{
1825	static gsize home_dev_set = 0;
1826	static dev_t home_dev;
1827	static gboolean home_dev_valid = FALSE;
1828	char *topdir, *globaldir, *trashdir, *tmpname;
1829	uid_t uid;
1830	char uid_str[32];
1831	GStatBuf global_stat, trash_stat;
1832	gboolean res;
1833
1834	if (g_once_init_enter (&home_dev_set))
1835	{
1836	GStatBuf home_stat;
1837
1838	if (g_stat (file: g_get_home_dir (), buf: &home_stat) == 0)
1839	{
1840	home_dev = home_stat.st_dev;
1841	home_dev_valid = TRUE;
1842	}
1843	else
1844	{
1845	home_dev_valid = FALSE;
1846	}
1847
1848	g_once_init_leave (&home_dev_set, 1);
1849	}
1850
1851	/* Assume we can trash to the home */
1852	if (!home_dev_valid)
1853	return FALSE;
1854	else if (dir_dev == home_dev)
1855	return TRUE;
1856
1857	topdir = find_mountpoint_for (file: dirname, dev: dir_dev, TRUE);
1858	if (topdir == NULL)
1859	return FALSE;
1860
1861	if (ignore_trash_path (topdir))
1862	{
1863	g_free (mem: topdir);
1864
1865	return FALSE;
1866	}
1867
1868	globaldir = g_build_filename (first_element: topdir, ".Trash", NULL);
1869	if (g_lstat (file: globaldir, buf: &global_stat) == 0 &&
1870	S_ISDIR (global_stat.st_mode) &&
1871	(global_stat.st_mode & S_ISVTX) != 0)
1872	{
1873	/* got a toplevel sysadmin created dir, assume we
1874	* can trash to it (we should be able to create a dir)
1875	* This fails for the FAT case where the ownership of
1876	* that dir would be wrong though..
1877	*/
1878	g_free (mem: globaldir);
1879	g_free (mem: topdir);
1880	return TRUE;
1881	}
1882	g_free (mem: globaldir);
1883
1884	/* No global trash dir, or it failed the tests, fall back to $topdir/.Trash-$uid */
1885	uid = geteuid ();
1886	g_snprintf (string: uid_str, n: sizeof (uid_str), format: "%lu", (unsigned long) uid);
1887
1888	tmpname = g_strdup_printf (format: ".Trash-%s", uid_str);
1889	trashdir = g_build_filename (first_element: topdir, tmpname, NULL);
1890	g_free (mem: tmpname);
1891
1892	if (g_lstat (file: trashdir, buf: &trash_stat) == 0)
1893	{
1894	g_free (mem: topdir);
1895	g_free (mem: trashdir);
1896	return S_ISDIR (trash_stat.st_mode) &&
1897	trash_stat.st_uid == uid;
1898	}
1899	g_free (mem: trashdir);
1900
1901	/* User specific trash didn't exist, can we create it? */
1902	res = g_access (filename: topdir, W_OK) == 0;
1903	g_free (mem: topdir);
1904
1905	return res;
1906	}
1907
1908	#ifdef G_OS_UNIX
1909	gboolean
1910	_g_local_file_is_lost_found_dir (const char *path, dev_t path_dev)
1911	{
1912	gboolean ret = FALSE;
1913	gchar *mount_dir = NULL;
1914	size_t mount_dir_len;
1915	GStatBuf statbuf;
1916
1917	if (!g_str_has_suffix (str: path, suffix: "/lost+found"))
1918	goto out;
1919
1920	mount_dir = find_mountpoint_for (file: path, dev: path_dev, FALSE);
1921	if (mount_dir == NULL)
1922	goto out;
1923
1924	mount_dir_len = strlen (s: mount_dir);
1925	/* We special-case rootfs ('/') since it's the only case where
1926	* mount_dir ends in '/'
1927	*/
1928	if (mount_dir_len == 1)
1929	mount_dir_len--;
1930	if (mount_dir_len + strlen (s: "/lost+found") != strlen (s: path))
1931	goto out;
1932
1933	if (g_lstat (file: path, buf: &statbuf) != 0)
1934	goto out;
1935
1936	if (!(S_ISDIR (statbuf.st_mode) &&
1937	statbuf.st_uid == 0 &&
1938	statbuf.st_gid == 0))
1939	goto out;
1940
1941	ret = TRUE;
1942
1943	out:
1944	g_free (mem: mount_dir);
1945	return ret;
1946	}
1947	#endif
1948
1949	static gboolean
1950	g_local_file_trash (GFile *file,
1951	GCancellable *cancellable,
1952	GError **error)
1953	{
1954	GLocalFile *local = G_LOCAL_FILE (file);
1955	GStatBuf file_stat, home_stat;
1956	const char *homedir;
1957	char *trashdir, *topdir, *infodir, *filesdir;
1958	char *basename, *trashname, *trashfile, *infoname, *infofile;
1959	char *original_name, *original_name_escaped;
1960	int i;
1961	char *data;
1962	char *path;
1963	gboolean is_homedir_trash;
1964	char *delete_time = NULL;
1965	int fd;
1966	GStatBuf trash_stat, global_stat;
1967	char *dirname, *globaldir;
1968	GVfsClass *class;
1969	GVfs *vfs;
1970	int errsv;
1971
1972	if (glib_should_use_portal ())
1973	return g_trash_portal_trash_file (file, error);
1974
1975	if (g_lstat (file: local->filename, buf: &file_stat) != 0)
1976	{
1977	errsv = errno;
1978
1979	g_set_io_error (error,
1980	_("Error trashing file %s: %s"),
1981	file, errsv);
1982	return FALSE;
1983	}
1984
1985	homedir = g_get_home_dir ();
1986	if (g_stat (file: homedir, buf: &home_stat) != 0)
1987	{
1988	errsv = errno;
1989
1990	g_set_io_error (error,
1991	_("Error trashing file %s: %s"),
1992	file, errsv);
1993	return FALSE;
1994	}
1995
1996	is_homedir_trash = FALSE;
1997	trashdir = NULL;
1998
1999	/* On overlayfs, a file's st_dev will be different to the home directory's.
2000	* We still want to create our trash directory under the home directory, so
2001	* instead we should stat the directory that the file we're deleting is in as
2002	* this will have the same st_dev.
2003	*/
2004	if (!S_ISDIR (file_stat.st_mode))
2005	{
2006	path = g_path_get_dirname (file_name: local->filename);
2007	/* If the parent is a symlink to a different device then it might have
2008	* st_dev equal to the home directory's, in which case we will end up
2009	* trying to rename across a filesystem boundary, which doesn't work. So
2010	* we use g_stat here instead of g_lstat, to know where the symlink
2011	* points to. */
2012	g_stat (file: path, buf: &file_stat);
2013	g_free (mem: path);
2014	}
2015
2016	if (file_stat.st_dev == home_stat.st_dev)
2017	{
2018	is_homedir_trash = TRUE;
2019	errno = 0;
2020	trashdir = g_build_filename (first_element: g_get_user_data_dir (), "Trash", NULL);
2021	if (g_mkdir_with_parents (pathname: trashdir, mode: 0700) < 0)
2022	{
2023	char *display_name;
2024	errsv = errno;
2025
2026	display_name = g_filename_display_name (filename: trashdir);
2027	g_set_error (err: error, G_IO_ERROR,
2028	code: g_io_error_from_errno (err_no: errsv),
2029	_("Unable to create trash directory %s: %s"),
2030	display_name, g_strerror (errnum: errsv));
2031	g_free (mem: display_name);
2032	g_free (mem: trashdir);
2033	return FALSE;
2034	}
2035	topdir = g_strdup (str: g_get_user_data_dir ());
2036	}
2037	else
2038	{
2039	uid_t uid;
2040	char uid_str[32];
2041	gboolean success = FALSE;
2042
2043	uid = geteuid ();
2044	g_snprintf (string: uid_str, n: sizeof (uid_str), format: "%lu", (unsigned long)uid);
2045
2046	topdir = _g_local_file_find_topdir_for (file: local->filename);
2047	if (topdir == NULL)
2048	{
2049	g_set_io_error (error,
2050	_("Unable to find toplevel directory to trash %s"),
2051	file, ENOTSUP);
2052	return FALSE;
2053	}
2054
2055	if (ignore_trash_path (topdir))
2056	{
2057	g_set_error (err: error, G_IO_ERROR, code: G_IO_ERROR_NOT_SUPPORTED,
2058	_("Trashing on system internal mounts is not supported"));
2059	g_free (mem: topdir);
2060
2061	return FALSE;
2062	}
2063
2064	/* Try looking for global trash dir $topdir/.Trash/$uid */
2065	globaldir = g_build_filename (first_element: topdir, ".Trash", NULL);
2066	if (g_lstat (file: globaldir, buf: &global_stat) == 0 &&
2067	S_ISDIR (global_stat.st_mode) &&
2068	(global_stat.st_mode & S_ISVTX) != 0)
2069	{
2070	trashdir = g_build_filename (first_element: globaldir, uid_str, NULL);
2071	success = TRUE;
2072
2073	if (g_lstat (file: trashdir, buf: &trash_stat) == 0)
2074	{
2075	if (!S_ISDIR (trash_stat.st_mode) ||
2076	trash_stat.st_uid != uid)
2077	{
2078	/* Not a directory or not owned by user, ignore */
2079	g_free (mem: trashdir);
2080	trashdir = NULL;
2081	success = FALSE;
2082	}
2083	}
2084	else if (g_mkdir (path: trashdir, mode: 0700) == -1)
2085	{
2086	g_free (mem: trashdir);
2087	trashdir = NULL;
2088	success = FALSE;
2089	}
2090	}
2091	g_free (mem: globaldir);
2092
2093	if (trashdir == NULL)
2094	{
2095	gboolean tried_create;
2096
2097	/* No global trash dir, or it failed the tests, fall back to $topdir/.Trash-$uid */
2098	dirname = g_strdup_printf (format: ".Trash-%s", uid_str);
2099	trashdir = g_build_filename (first_element: topdir, dirname, NULL);
2100	success = TRUE;
2101	g_free (mem: dirname);
2102
2103	tried_create = FALSE;
2104
2105	retry:
2106	if (g_lstat (file: trashdir, buf: &trash_stat) == 0)
2107	{
2108	if (!S_ISDIR (trash_stat.st_mode) ||
2109	trash_stat.st_uid != uid)
2110	{
2111	/* Remove the failed directory */
2112	if (tried_create)
2113	g_remove (filename: trashdir);
2114
2115	/* Not a directory or not owned by user, ignore */
2116	success = FALSE;
2117	}
2118	}
2119	else
2120	{
2121	if (!tried_create &&
2122	g_mkdir (path: trashdir, mode: 0700) != -1)
2123	{
2124	/* Ensure that the created dir has the right uid etc.
2125	This might fail on e.g. a FAT dir */
2126	tried_create = TRUE;
2127	goto retry;
2128	}
2129	else
2130	{
2131	success = FALSE;
2132	}
2133	}
2134	}
2135
2136	if (!success)
2137	{
2138	gchar *trashdir_display_name = NULL, *file_display_name = NULL;
2139
2140	trashdir_display_name = g_filename_display_name (filename: trashdir);
2141	file_display_name = g_filename_display_name (filename: local->filename);
2142	g_set_error (err: error, G_IO_ERROR,
2143	code: G_IO_ERROR_NOT_SUPPORTED,
2144	_("Unable to find or create trash directory %s to trash %s"),
2145	trashdir_display_name, file_display_name);
2146
2147	g_free (mem: trashdir_display_name);
2148	g_free (mem: file_display_name);
2149
2150	g_free (mem: topdir);
2151	g_free (mem: trashdir);
2152
2153	return FALSE;
2154	}
2155	}
2156
2157	/* Trashdir points to the trash dir with the "info" and "files" subdirectories */
2158
2159	infodir = g_build_filename (first_element: trashdir, "info", NULL);
2160	filesdir = g_build_filename (first_element: trashdir, "files", NULL);
2161
2162	/* Make sure we have the subdirectories */
2163	if ((g_mkdir (path: infodir, mode: 0700) == -1 && errno != EEXIST) ||
2164	(g_mkdir (path: filesdir, mode: 0700) == -1 && errno != EEXIST))
2165	{
2166	gchar *trashdir_display_name = NULL, *file_display_name = NULL;
2167
2168	trashdir_display_name = g_filename_display_name (filename: trashdir);
2169	file_display_name = g_filename_display_name (filename: local->filename);
2170	g_set_error (err: error, G_IO_ERROR,
2171	code: G_IO_ERROR_NOT_SUPPORTED,
2172	_("Unable to find or create trash directory %s to trash %s"),
2173	trashdir_display_name, file_display_name);
2174
2175	g_free (mem: trashdir_display_name);
2176	g_free (mem: file_display_name);
2177
2178	g_free (mem: topdir);
2179	g_free (mem: trashdir);
2180	g_free (mem: infodir);
2181	g_free (mem: filesdir);
2182
2183	return FALSE;
2184	}
2185
2186	g_free (mem: trashdir);
2187
2188	basename = g_path_get_basename (file_name: local->filename);
2189	i = 1;
2190	trashname = NULL;
2191	infofile = NULL;
2192	do {
2193	g_free (mem: trashname);
2194	g_free (mem: infofile);
2195
2196	trashname = get_unique_filename (basename, id: i++);
2197	infoname = g_strconcat (string1: trashname, ".trashinfo", NULL);
2198	infofile = g_build_filename (first_element: infodir, infoname, NULL);
2199	g_free (mem: infoname);
2200
2201	fd = g_open (file: infofile, O_CREAT | O_EXCL, 0666);
2202	errsv = errno;
2203	} while (fd == -1 && errsv == EEXIST);
2204
2205	g_free (mem: basename);
2206	g_free (mem: infodir);
2207
2208	if (fd == -1)
2209	{
2210	errsv = errno;
2211
2212	g_free (mem: filesdir);
2213	g_free (mem: topdir);
2214	g_free (mem: trashname);
2215	g_free (mem: infofile);
2216
2217	g_set_io_error (error,
2218	_("Unable to create trashing info file for %s: %s"),
2219	file, errsv);
2220	return FALSE;
2221	}
2222
2223	(void) g_close (fd, NULL);
2224
2225	/* Write the full content of the info file before trashing to make
2226	* sure someone doesn't read an empty file. See #749314
2227	*/
2228
2229	/* Use absolute names for homedir */
2230	if (is_homedir_trash)
2231	original_name = g_strdup (str: local->filename);
2232	else
2233	original_name = try_make_relative (path: local->filename, base: topdir);
2234	original_name_escaped = g_uri_escape_string (unescaped: original_name, reserved_chars_allowed: "/", FALSE);
2235
2236	g_free (mem: original_name);
2237	g_free (mem: topdir);
2238
2239	{
2240	GDateTime *now = g_date_time_new_now_local ();
2241	if (now != NULL)
2242	delete_time = g_date_time_format (datetime: now, format: "%Y-%m-%dT%H:%M:%S");
2243	else
2244	delete_time = g_strdup (str: "9999-12-31T23:59:59");
2245	g_date_time_unref (datetime: now);
2246	}
2247
2248	data = g_strdup_printf (format: "[Trash Info]\nPath=%s\nDeletionDate=%s\n",
2249	original_name_escaped, delete_time);
2250	g_free (mem: delete_time);
2251
2252	g_file_set_contents_full (filename: infofile, contents: data, length: -1,
2253	flags: G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING,
2254	mode: 0600, NULL);
2255
2256	/* TODO: Maybe we should verify that you can delete the file from the trash
2257	* before moving it? OTOH, that is hard, as it needs a recursive scan
2258	*/
2259
2260	trashfile = g_build_filename (first_element: filesdir, trashname, NULL);
2261
2262	g_free (mem: filesdir);
2263
2264	if (g_rename (old: local->filename, new: trashfile) == -1)
2265	{
2266	errsv = errno;
2267
2268	g_unlink (filename: infofile);
2269
2270	g_free (mem: trashname);
2271	g_free (mem: infofile);
2272	g_free (mem: trashfile);
2273
2274	if (errsv == EXDEV)
2275	/* The trash dir was actually on another fs anyway!?
2276	* This can happen when the same device is mounted multiple
2277	* times, or with bind mounts of the same fs.
2278	*/
2279	g_set_io_error (error,
2280	_("Unable to trash file %s across filesystem boundaries"),
2281	file, ENOTSUP);
2282	else
2283	g_set_io_error (error,
2284	_("Unable to trash file %s: %s"),
2285	file, errsv);
2286	return FALSE;
2287	}
2288
2289	vfs = g_vfs_get_default ();
2290	class = G_VFS_GET_CLASS (vfs);
2291	if (class->local_file_moved)
2292	class->local_file_moved (vfs, local->filename, trashfile);
2293
2294	g_free (mem: trashfile);
2295
2296	/* TODO: Do we need to update mtime/atime here after the move? */
2297
2298	g_free (mem: infofile);
2299	g_free (mem: data);
2300
2301	g_free (mem: original_name_escaped);
2302	g_free (mem: trashname);
2303
2304	return TRUE;
2305	}
2306	#else /* G_OS_WIN32 */
2307	gboolean
2308	_g_local_file_has_trash_dir (const char *dirname, dev_t dir_dev)
2309	{
2310	return FALSE; /* XXX ??? */
2311	}
2312
2313	static gboolean
2314	g_local_file_trash (GFile *file,
2315	GCancellable *cancellable,
2316	GError **error)
2317	{
2318	GLocalFile *local = G_LOCAL_FILE (file);
2319	SHFILEOPSTRUCTW op = {0};
2320	gboolean success;
2321	wchar_t *wfilename;
2322	long len;
2323
2324	wfilename = g_utf8_to_utf16 (local->filename, -1, NULL, &len, NULL);
2325	/* SHFILEOPSTRUCT.pFrom is double-zero-terminated */
2326	wfilename = g_renew (wchar_t, wfilename, len + 2);
2327	wfilename[len + 1] = 0;
2328
2329	op.wFunc = FO_DELETE;
2330	op.pFrom = wfilename;
2331	op.fFlags = FOF_ALLOWUNDO;
2332
2333	success = SHFileOperationW (&op) == 0;
2334
2335	if (success && op.fAnyOperationsAborted)
2336	{
2337	if (cancellable && !g_cancellable_is_cancelled (cancellable))
2338	g_cancellable_cancel (cancellable);
2339	g_set_io_error (error,
2340	_("Unable to trash file %s: %s"),
2341	file, ECANCELED);
2342	success = FALSE;
2343	}
2344	else if (!success)
2345	g_set_io_error (error,
2346	_("Unable to trash file %s"),
2347	file, 0);
2348
2349	g_free (wfilename);
2350	return success;
2351	}
2352	#endif /* G_OS_WIN32 */
2353
2354	static gboolean
2355	g_local_file_make_directory (GFile *file,
2356	GCancellable *cancellable,
2357	GError **error)
2358	{
2359	GLocalFile *local = G_LOCAL_FILE (file);
2360
2361	if (g_mkdir (path: local->filename, mode: 0777) == -1)
2362	{
2363	int errsv = errno;
2364
2365	if (errsv == EINVAL)
2366	/* This must be an invalid filename, on e.g. FAT */
2367	g_set_error_literal (err: error, G_IO_ERROR,
2368	code: G_IO_ERROR_INVALID_FILENAME,
2369	_("Invalid filename"));
2370	else
2371	g_set_io_error (error,
2372	_("Error creating directory %s: %s"),
2373	file, errsv);
2374	return FALSE;
2375	}
2376
2377	return TRUE;
2378	}
2379
2380	#ifdef HAVE_SYMLINK
2381	static gboolean
2382	g_local_file_make_symbolic_link (GFile *file,
2383	const char *symlink_value,
2384	GCancellable *cancellable,
2385	GError **error)
2386	{
2387	GLocalFile *local = G_LOCAL_FILE (file);
2388
2389	if (symlink (from: symlink_value, to: local->filename) == -1)
2390	{
2391	int errsv = errno;
2392
2393	if (errsv == EINVAL)
2394	/* This must be an invalid filename, on e.g. FAT */
2395	g_set_error_literal (err: error, G_IO_ERROR,
2396	code: G_IO_ERROR_INVALID_FILENAME,
2397	_("Invalid filename"));
2398	else if (errsv == EPERM)
2399	g_set_error (err: error, G_IO_ERROR,
2400	code: G_IO_ERROR_NOT_SUPPORTED,
2401	_("Filesystem does not support symbolic links"));
2402	else
2403	g_set_io_error (error,
2404	_("Error making symbolic link %s: %s"),
2405	file, errsv);
2406	return FALSE;
2407	}
2408	return TRUE;
2409	}
2410	#endif
2411
2412	static gboolean
2413	g_local_file_move (GFile *source,
2414	GFile *destination,
2415	GFileCopyFlags flags,
2416	GCancellable *cancellable,
2417	GFileProgressCallback progress_callback,
2418	gpointer progress_callback_data,
2419	GError **error)
2420	{
2421	GLocalFile *local_source, *local_destination;
2422	GStatBuf statbuf;
2423	gboolean destination_exist, source_is_dir;
2424	char *backup_name;
2425	int res;
2426	off_t source_size;
2427	GVfsClass *class;
2428	GVfs *vfs;
2429
2430	if (!G_IS_LOCAL_FILE (source) ||
2431	!G_IS_LOCAL_FILE (destination))
2432	{
2433	/* Fall back to default move */
2434	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_NOT_SUPPORTED, message: "Move not supported");
2435	return FALSE;
2436	}
2437
2438	local_source = G_LOCAL_FILE (source);
2439	local_destination = G_LOCAL_FILE (destination);
2440
2441	res = g_lstat (file: local_source->filename, buf: &statbuf);
2442	if (res == -1)
2443	{
2444	int errsv = errno;
2445
2446	g_set_io_error (error,
2447	_("Error moving file %s: %s"),
2448	file: source, errsv);
2449	return FALSE;
2450	}
2451
2452	source_is_dir = S_ISDIR (statbuf.st_mode);
2453	source_size = statbuf.st_size;
2454
2455	destination_exist = FALSE;
2456	res = g_lstat (file: local_destination->filename, buf: &statbuf);
2457	if (res == 0)
2458	{
2459	destination_exist = TRUE; /* Target file exists */
2460
2461	if (flags & G_FILE_COPY_OVERWRITE)
2462	{
2463	/* Always fail on dirs, even with overwrite */
2464	if (S_ISDIR (statbuf.st_mode))
2465	{
2466	if (source_is_dir)
2467	g_set_error_literal (err: error,
2468	G_IO_ERROR,
2469	code: G_IO_ERROR_WOULD_MERGE,
2470	_("Can’t move directory over directory"));
2471	else
2472	g_set_error_literal (err: error,
2473	G_IO_ERROR,
2474	code: G_IO_ERROR_IS_DIRECTORY,
2475	_("Can’t copy over directory"));
2476	return FALSE;
2477	}
2478	}
2479	else
2480	{
2481	g_set_io_error (error,
2482	_("Error moving file %s: %s"),
2483	file: source, EEXIST);
2484	return FALSE;
2485	}
2486	}
2487
2488	if (flags & G_FILE_COPY_BACKUP && destination_exist)
2489	{
2490	backup_name = g_strconcat (string1: local_destination->filename, "~", NULL);
2491	if (g_rename (old: local_destination->filename, new: backup_name) == -1)
2492	{
2493	g_set_error_literal (err: error,
2494	G_IO_ERROR,
2495	code: G_IO_ERROR_CANT_CREATE_BACKUP,
2496	_("Backup file creation failed"));
2497	g_free (mem: backup_name);
2498	return FALSE;
2499	}
2500	g_free (mem: backup_name);
2501	destination_exist = FALSE; /* It did, but no more */
2502	}
2503
2504	if (source_is_dir && destination_exist && (flags & G_FILE_COPY_OVERWRITE))
2505	{
2506	/* Source is a dir, destination exists (and is not a dir, because that would have failed
2507	earlier), and we're overwriting. Manually remove the target so we can do the rename. */
2508	res = g_unlink (filename: local_destination->filename);
2509	if (res == -1)
2510	{
2511	int errsv = errno;
2512
2513	g_set_error (err: error, G_IO_ERROR,
2514	code: g_io_error_from_errno (err_no: errsv),
2515	_("Error removing target file: %s"),
2516	g_strerror (errnum: errsv));
2517	return FALSE;
2518	}
2519	}
2520
2521	if (g_rename (old: local_source->filename, new: local_destination->filename) == -1)
2522	{
2523	int errsv = errno;
2524
2525	if (errsv == EXDEV)
2526	/* This will cause the fallback code to run */
2527	g_set_error_literal (err: error, G_IO_ERROR,
2528	code: G_IO_ERROR_NOT_SUPPORTED,
2529	_("Move between mounts not supported"));
2530	else if (errsv == EINVAL)
2531	/* This must be an invalid filename, on e.g. FAT, or
2532	we're trying to move the file into itself...
2533	We return invalid filename for both... */
2534	g_set_error_literal (err: error, G_IO_ERROR,
2535	code: G_IO_ERROR_INVALID_FILENAME,
2536	_("Invalid filename"));
2537	else
2538	g_set_io_error (error,
2539	_("Error moving file %s: %s"),
2540	file: source, errsv);
2541	return FALSE;
2542	}
2543
2544	vfs = g_vfs_get_default ();
2545	class = G_VFS_GET_CLASS (vfs);
2546	if (class->local_file_moved)
2547	class->local_file_moved (vfs, local_source->filename, local_destination->filename);
2548
2549	/* Make sure we send full copied size */
2550	if (progress_callback)
2551	progress_callback (source_size, source_size, progress_callback_data);
2552
2553	return TRUE;
2554	}
2555
2556	#ifdef G_OS_WIN32
2557
2558	gboolean
2559	g_local_file_is_nfs_home (const gchar *filename)
2560	{
2561	return FALSE;
2562	}
2563
2564	#else
2565
2566	static gboolean
2567	is_remote_fs_type (const gchar *fsname)
2568	{
2569	if (fsname != NULL)
2570	{
2571	if (strcmp (s1: fsname, s2: "nfs") == 0)
2572	return TRUE;
2573	if (strcmp (s1: fsname, s2: "nfs4") == 0)
2574	return TRUE;
2575	if (strcmp (s1: fsname, s2: "cifs") == 0)
2576	return TRUE;
2577	if (strcmp (s1: fsname, s2: "smb") == 0)
2578	return TRUE;
2579	if (strcmp (s1: fsname, s2: "smb2") == 0)
2580	return TRUE;
2581	}
2582
2583	return FALSE;
2584	}
2585
2586	gboolean
2587	g_local_file_is_nfs_home (const gchar *filename)
2588	{
2589	static gboolean remote_home = FALSE;
2590	static gsize initialized;
2591	const gchar *home;
2592
2593	home = g_get_home_dir ();
2594	if (path_has_prefix (path: filename, prefix: home))
2595	{
2596	if (g_once_init_enter (&initialized))
2597	{
2598	GFile *file;
2599	GFileInfo *info;
2600	const gchar *fs_type = NULL;
2601
2602	file = _g_local_file_new (filename: home);
2603	info = g_local_file_query_filesystem_info (file, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, NULL, NULL);
2604	if (info != NULL)
2605	fs_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
2606	if (g_strcmp0 (str1: fs_type, str2: "nfs") == 0 || g_strcmp0 (str1: fs_type, str2: "nfs4") == 0)
2607	remote_home = TRUE;
2608	g_clear_object (&info);
2609	g_object_unref (object: file);
2610
2611	g_once_init_leave (&initialized, TRUE);
2612	}
2613	return remote_home;
2614	}
2615
2616	return FALSE;
2617	}
2618	#endif /* !G_OS_WIN32 */
2619
2620	static GFileMonitor*
2621	g_local_file_monitor_dir (GFile *file,
2622	GFileMonitorFlags flags,
2623	GCancellable *cancellable,
2624	GError **error)
2625	{
2626	GLocalFile *local_file = G_LOCAL_FILE (file);
2627
2628	return g_local_file_monitor_new_for_path (pathname: local_file->filename, TRUE, flags, error);
2629	}
2630
2631	static GFileMonitor*
2632	g_local_file_monitor_file (GFile *file,
2633	GFileMonitorFlags flags,
2634	GCancellable *cancellable,
2635	GError **error)
2636	{
2637	GLocalFile *local_file = G_LOCAL_FILE (file);
2638
2639	return g_local_file_monitor_new_for_path (pathname: local_file->filename, FALSE, flags, error);
2640	}
2641
2642	/* Here is the GLocalFile implementation of g_file_measure_disk_usage().
2643	*
2644	* If available, we use fopenat() in preference to filenames for
2645	* efficiency and safety reasons. We know that fopenat() is available
2646	* based on if AT_FDCWD is defined. POSIX guarantees that this will be
2647	* defined as a macro.
2648	*
2649	* We use a linked list of stack-allocated GSList nodes in order to be
2650	* able to reconstruct the filename for error messages. We actually
2651	* pass the filename to operate on through the top node of the list.
2652	*
2653	* In case we're using openat(), this top filename will be a basename
2654	* which should be opened in the directory which has also had its fd
2655	* passed along. If we're not using openat() then it will be a full
2656	* absolute filename.
2657	*/
2658
2659	static gboolean
2660	g_local_file_measure_size_error (GFileMeasureFlags flags,
2661	gint saved_errno,
2662	GSList *name,
2663	GError **error)
2664	{
2665	/* Only report an error if we were at the toplevel or if the caller
2666	* requested reporting of all errors.
2667	*/
2668	if ((name->next == NULL) || (flags & G_FILE_MEASURE_REPORT_ANY_ERROR))
2669	{
2670	GString *filename;
2671	GSList *node;
2672
2673	/* Skip some work if there is no error return */
2674	if (!error)
2675	return FALSE;
2676
2677	#ifdef AT_FDCWD
2678	/* If using openat() we need to rebuild the filename for the message */
2679	filename = g_string_new (init: name->data);
2680	for (node = name->next; node; node = node->next)
2681	{
2682	gchar *utf8;
2683
2684	g_string_prepend_c (string: filename, G_DIR_SEPARATOR);
2685	utf8 = g_filename_display_name (filename: node->data);
2686	g_string_prepend (string: filename, val: utf8);
2687	g_free (mem: utf8);
2688	}
2689	#else
2690	{
2691	gchar *utf8;
2692
2693	/* Otherwise, we already have it, so just use it. */
2694	node = name;
2695	filename = g_string_new (NULL);
2696	utf8 = g_filename_display_name (node->data);
2697	g_string_append (filename, utf8);
2698	g_free (utf8);
2699	}
2700	#endif
2701
2702	g_set_error (err: error, G_IO_ERROR, code: g_io_error_from_errno (err_no: saved_errno),
2703	_("Could not determine the disk usage of %s: %s"),
2704	filename->str, g_strerror (errnum: saved_errno));
2705
2706	g_string_free (string: filename, TRUE);
2707
2708	return FALSE;
2709	}
2710
2711	else
2712	/* We're not reporting this error... */
2713	return TRUE;
2714	}
2715
2716	typedef struct
2717	{
2718	GFileMeasureFlags flags;
2719	dev_t contained_on;
2720	GCancellable *cancellable;
2721
2722	GFileMeasureProgressCallback progress_callback;
2723	gpointer progress_data;
2724
2725	guint64 disk_usage;
2726	guint64 num_dirs;
2727	guint64 num_files;
2728
2729	guint64 last_progress_report;
2730	} MeasureState;
2731
2732	static gboolean
2733	g_local_file_measure_size_of_contents (gint fd,
2734	GSList *dir_name,
2735	MeasureState *state,
2736	GError **error);
2737
2738	static gboolean
2739	g_local_file_measure_size_of_file (gint parent_fd,
2740	GSList *name,
2741	MeasureState *state,
2742	GError **error)
2743	{
2744	GLocalFileStat buf;
2745
2746	if (g_cancellable_set_error_if_cancelled (cancellable: state->cancellable, error))
2747	return FALSE;
2748
2749	#if defined (AT_FDCWD)
2750	if (g_local_file_fstatat (fd: parent_fd, path: name->data, AT_SYMLINK_NOFOLLOW,
2751	G_LOCAL_FILE_STAT_FIELD_BASIC_STATS,
2752	G_LOCAL_FILE_STAT_FIELD_ALL & (~G_LOCAL_FILE_STAT_FIELD_ATIME),
2753	stat_buf: &buf) != 0)
2754	{
2755	int errsv = errno;
2756	return g_local_file_measure_size_error (flags: state->flags, saved_errno: errsv, name, error);
2757	}
2758	#elif defined (HAVE_LSTAT) || !defined (G_OS_WIN32)
2759	if (g_lstat (name->data, &buf) != 0)
2760	{
2761	int errsv = errno;
2762	return g_local_file_measure_size_error (state->flags, errsv, name, error);
2763	}
2764	#else /* !AT_FDCWD && !HAVE_LSTAT && G_OS_WIN32 */
2765	if (GLIB_PRIVATE_CALL (g_win32_lstat_utf8) (name->data, &buf) != 0)
2766	{
2767	int errsv = errno;
2768	return g_local_file_measure_size_error (state->flags, errsv, name, error);
2769	}
2770	#endif
2771
2772	if (name->next)
2773	{
2774	/* If not at the toplevel, check for a device boundary. */
2775
2776	if (state->flags & G_FILE_MEASURE_NO_XDEV)
2777	if (state->contained_on != _g_stat_dev (buf: &buf))
2778	return TRUE;
2779	}
2780	else
2781	{
2782	/* If, however, this is the toplevel, set the device number so
2783	* that recursive invocations can compare against it.
2784	*/
2785	state->contained_on = _g_stat_dev (buf: &buf);
2786	}
2787
2788	#if defined (G_OS_WIN32)
2789	if (~state->flags & G_FILE_MEASURE_APPARENT_SIZE)
2790	state->disk_usage += buf.allocated_size;
2791	else
2792	#elif defined (HAVE_STRUCT_STAT_ST_BLOCKS)
2793	if (~state->flags & G_FILE_MEASURE_APPARENT_SIZE)
2794	state->disk_usage += _g_stat_blocks (buf: &buf) * G_GUINT64_CONSTANT (512);
2795	else
2796	#endif
2797	state->disk_usage += _g_stat_size (buf: &buf);
2798
2799	if (S_ISDIR (_g_stat_mode (&buf)))
2800	state->num_dirs++;
2801	else
2802	state->num_files++;
2803
2804	if (state->progress_callback)
2805	{
2806	/* We could attempt to do some cleverness here in order to avoid
2807	* calling clock_gettime() so much, but we're doing stats and opens
2808	* all over the place already...
2809	*/
2810	if (state->last_progress_report)
2811	{
2812	guint64 now;
2813
2814	now = g_get_monotonic_time ();
2815
2816	if (state->last_progress_report + 200 * G_TIME_SPAN_MILLISECOND < now)
2817	{
2818	(* state->progress_callback) (TRUE,
2819	state->disk_usage, state->num_dirs, state->num_files,
2820	state->progress_data);
2821	state->last_progress_report = now;
2822	}
2823	}
2824	else
2825	{
2826	/* We must do an initial report to inform that more reports
2827	* will be coming.
2828	*/
2829	(* state->progress_callback) (TRUE, 0, 0, 0, state->progress_data);
2830	state->last_progress_report = g_get_monotonic_time ();
2831	}
2832	}
2833
2834	if (S_ISDIR (_g_stat_mode (&buf)))
2835	{
2836	int dir_fd = -1;
2837	#ifdef AT_FDCWD
2838	int errsv;
2839	#endif
2840
2841	if (g_cancellable_set_error_if_cancelled (cancellable: state->cancellable, error))
2842	return FALSE;
2843
2844	#ifdef AT_FDCWD
2845	#ifdef HAVE_OPEN_O_DIRECTORY
2846	dir_fd = openat (fd: parent_fd, file: name->data, O_RDONLY|O_DIRECTORY);
2847	#else
2848	dir_fd = openat (parent_fd, name->data, O_RDONLY);
2849	#endif
2850	errsv = errno;
2851	if (dir_fd < 0)
2852	return g_local_file_measure_size_error (flags: state->flags, saved_errno: errsv, name, error);
2853	#endif
2854
2855	if (!g_local_file_measure_size_of_contents (fd: dir_fd, dir_name: name, state, error))
2856	return FALSE;
2857	}
2858
2859	return TRUE;
2860	}
2861
2862	static gboolean
2863	g_local_file_measure_size_of_contents (gint fd,
2864	GSList *dir_name,
2865	MeasureState *state,
2866	GError **error)
2867	{
2868	gboolean success = TRUE;
2869	const gchar *name;
2870	GDir *dir;
2871	gint saved_errno;
2872
2873	#ifdef AT_FDCWD
2874	{
2875	/* If this fails, we want to preserve the errno from fdopendir() */
2876	DIR *dirp;
2877	dirp = fdopendir (fd: fd);
2878	saved_errno = errno;
2879	dir = dirp ? GLIB_PRIVATE_CALL(g_dir_new_from_dirp) (dirp) : NULL;
2880	g_assert ((dirp == NULL) == (dir == NULL));
2881	}
2882	#else
2883	dir = GLIB_PRIVATE_CALL(g_dir_open_with_errno) (dir_name->data, 0);
2884	saved_errno = errno;
2885	#endif
2886
2887	if (dir == NULL)
2888	{
2889	#ifdef AT_FDCWD
2890	close (fd: fd);
2891	#endif
2892
2893	return g_local_file_measure_size_error (flags: state->flags, saved_errno, name: dir_name, error);
2894	}
2895
2896	while (success && (name = g_dir_read_name (dir)))
2897	{
2898	GSList node;
2899
2900	node.next = dir_name;
2901	#ifdef AT_FDCWD
2902	node.data = (gchar *) name;
2903	#else
2904	node.data = g_build_filename (dir_name->data, name, NULL);
2905	#endif
2906
2907	success = g_local_file_measure_size_of_file (parent_fd: fd, name: &node, state, error);
2908
2909	#ifndef AT_FDCWD
2910	g_free (node.data);
2911	#endif
2912	}
2913
2914	g_dir_close (dir);
2915
2916	return success;
2917	}
2918
2919	static gboolean
2920	g_local_file_measure_disk_usage (GFile *file,
2921	GFileMeasureFlags flags,
2922	GCancellable *cancellable,
2923	GFileMeasureProgressCallback progress_callback,
2924	gpointer progress_data,
2925	guint64 *disk_usage,
2926	guint64 *num_dirs,
2927	guint64 *num_files,
2928	GError **error)
2929	{
2930	GLocalFile *local_file = G_LOCAL_FILE (file);
2931	MeasureState state = { 0, };
2932	gint root_fd = -1;
2933	GSList node;
2934
2935	state.flags = flags;
2936	state.cancellable = cancellable;
2937	state.progress_callback = progress_callback;
2938	state.progress_data = progress_data;
2939
2940	#ifdef AT_FDCWD
2941	root_fd = AT_FDCWD;
2942	#endif
2943
2944	node.data = local_file->filename;
2945	node.next = NULL;
2946
2947	if (!g_local_file_measure_size_of_file (parent_fd: root_fd, name: &node, state: &state, error))
2948	return FALSE;
2949
2950	if (disk_usage)
2951	*disk_usage = state.disk_usage;
2952
2953	if (num_dirs)
2954	*num_dirs = state.num_dirs;
2955
2956	if (num_files)
2957	*num_files = state.num_files;
2958
2959	return TRUE;
2960	}
2961
2962	static void
2963	g_local_file_file_iface_init (GFileIface *iface)
2964	{
2965	iface->dup = g_local_file_dup;
2966	iface->hash = g_local_file_hash;
2967	iface->equal = g_local_file_equal;
2968	iface->is_native = g_local_file_is_native;
2969	iface->has_uri_scheme = g_local_file_has_uri_scheme;
2970	iface->get_uri_scheme = g_local_file_get_uri_scheme;
2971	iface->get_basename = g_local_file_get_basename;
2972	iface->get_path = g_local_file_get_path;
2973	iface->get_uri = g_local_file_get_uri;
2974	iface->get_parse_name = g_local_file_get_parse_name;
2975	iface->get_parent = g_local_file_get_parent;
2976	iface->prefix_matches = g_local_file_prefix_matches;
2977	iface->get_relative_path = g_local_file_get_relative_path;
2978	iface->resolve_relative_path = g_local_file_resolve_relative_path;
2979	iface->get_child_for_display_name = g_local_file_get_child_for_display_name;
2980	iface->set_display_name = g_local_file_set_display_name;
2981	iface->enumerate_children = g_local_file_enumerate_children;
2982	iface->query_info = g_local_file_query_info;
2983	iface->query_filesystem_info = g_local_file_query_filesystem_info;
2984	iface->find_enclosing_mount = g_local_file_find_enclosing_mount;
2985	iface->query_settable_attributes = g_local_file_query_settable_attributes;
2986	iface->query_writable_namespaces = g_local_file_query_writable_namespaces;
2987	iface->set_attribute = g_local_file_set_attribute;
2988	iface->set_attributes_from_info = g_local_file_set_attributes_from_info;
2989	iface->read_fn = g_local_file_read;
2990	iface->append_to = g_local_file_append_to;
2991	iface->create = g_local_file_create;
2992	iface->replace = g_local_file_replace;
2993	iface->open_readwrite = g_local_file_open_readwrite;
2994	iface->create_readwrite = g_local_file_create_readwrite;
2995	iface->replace_readwrite = g_local_file_replace_readwrite;
2996	iface->delete_file = g_local_file_delete;
2997	iface->trash = g_local_file_trash;
2998	iface->make_directory = g_local_file_make_directory;
2999	#ifdef HAVE_SYMLINK
3000	iface->make_symbolic_link = g_local_file_make_symbolic_link;
3001	#endif
3002	iface->move = g_local_file_move;
3003	iface->monitor_dir = g_local_file_monitor_dir;
3004	iface->monitor_file = g_local_file_monitor_file;
3005	iface->measure_disk_usage = g_local_file_measure_disk_usage;
3006
3007	iface->supports_thread_contexts = TRUE;
3008	}
3009