1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
3 /* GIO - GLib Input, Output and Streaming Library
5 * Copyright (C) 2006-2007 Red Hat, Inc.
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.
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.
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.
22 * Author: Alexander Larsson <alexl@redhat.com>
27 #include <sys/types.h>
30 #ifndef HAVE_SYSCTLBYNAME
31 #ifdef HAVE_SYS_PARAM_H
32 #include <sys/param.h>
34 #ifdef HAVE_SYS_POLL_H
49 #include "gunixmounts.h"
51 #include "gfilemonitor.h"
53 #include "gthemedicon.h"
57 static const char *_resolve_dev_root (void);
61 * @include: gio/gunixmounts.h
62 * @short_description: Unix Mounts
64 * Routines for managing mounted UNIX mount points and paths.
70 * @G_UNIX_MOUNT_TYPE_UNKNOWN: Unknown UNIX mount type.
71 * @G_UNIX_MOUNT_TYPE_FLOPPY: Floppy disk UNIX mount type.
72 * @G_UNIX_MOUNT_TYPE_CDROM: CDROM UNIX mount type.
73 * @G_UNIX_MOUNT_TYPE_NFS: Network File System (NFS) UNIX mount type.
74 * @G_UNIX_MOUNT_TYPE_ZIP: ZIP UNIX mount type.
75 * @G_UNIX_MOUNT_TYPE_JAZ: JAZZ UNIX mount type.
76 * @G_UNIX_MOUNT_TYPE_MEMSTICK: Memory Stick UNIX mount type.
77 * @G_UNIX_MOUNT_TYPE_CF: Compact Flash UNIX mount type.
78 * @G_UNIX_MOUNT_TYPE_SM: Smart Media UNIX mount type.
79 * @G_UNIX_MOUNT_TYPE_SDMMC: SD/MMC UNIX mount type.
80 * @G_UNIX_MOUNT_TYPE_IPOD: iPod UNIX mount type.
81 * @G_UNIX_MOUNT_TYPE_CAMERA: Digital camera UNIX mount type.
82 * @G_UNIX_MOUNT_TYPE_HD: Hard drive UNIX mount type.
84 * Types of UNIX mounts.
87 G_UNIX_MOUNT_TYPE_UNKNOWN,
88 G_UNIX_MOUNT_TYPE_FLOPPY,
89 G_UNIX_MOUNT_TYPE_CDROM,
90 G_UNIX_MOUNT_TYPE_NFS,
91 G_UNIX_MOUNT_TYPE_ZIP,
92 G_UNIX_MOUNT_TYPE_JAZ,
93 G_UNIX_MOUNT_TYPE_MEMSTICK,
96 G_UNIX_MOUNT_TYPE_SDMMC,
97 G_UNIX_MOUNT_TYPE_IPOD,
98 G_UNIX_MOUNT_TYPE_CAMERA,
102 struct _GUnixMountEntry {
105 char *filesystem_type;
106 gboolean is_read_only;
107 gboolean is_system_internal;
110 struct _GUnixMountPoint {
113 char *filesystem_type;
114 gboolean is_read_only;
115 gboolean is_user_mountable;
116 gboolean is_loopback;
125 static guint signals[LAST_SIGNAL];
127 struct _GUnixMountMonitor {
130 GFileMonitor *fstab_monitor;
131 GFileMonitor *mtab_monitor;
134 struct _GUnixMountMonitorClass {
135 GObjectClass parent_class;
138 static GUnixMountMonitor *the_mount_monitor = NULL;
140 static GList *_g_get_unix_mounts (void);
141 static GList *_g_get_unix_mount_points (void);
143 G_DEFINE_TYPE (GUnixMountMonitor, g_unix_mount_monitor, G_TYPE_OBJECT);
145 #define MOUNT_POLL_INTERVAL 4000
147 #ifdef HAVE_SYS_MNTTAB_H
148 #define MNTOPT_RO "ro"
153 #elif defined (HAVE_SYS_MNTTAB_H)
154 #include <sys/mnttab.h>
157 #ifdef HAVE_SYS_VFSTAB_H
158 #include <sys/vfstab.h>
161 #if defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)
162 #include <sys/mntctl.h>
164 #include <sys/vmount.h>
168 #if defined(HAVE_GETMNTINFO) && defined(HAVE_FSTAB_H) && defined(HAVE_SYS_MOUNT_H)
169 #include <sys/ucred.h>
170 #include <sys/mount.h>
172 #ifdef HAVE_SYS_SYSCTL_H
173 #include <sys/sysctl.h>
177 #ifndef HAVE_SETMNTENT
178 #define setmntent(f,m) fopen(f,m)
180 #ifndef HAVE_ENDMNTENT
181 #define endmntent(f) fclose(f)
185 is_in (const char *value, const char *set[])
188 for (i = 0; set[i] != NULL; i++)
190 if (strcmp (set[i], value) == 0)
197 * g_unix_is_mount_path_system_internal:
198 * @mount_path: a mount path, e.g. <filename>/media/disk</filename>
199 * or <filename>/usr</filename>
201 * Determines if @mount_path is considered an implementation of the
202 * OS. This is primarily used for hiding mountable and mounted volumes
203 * that only are used in the OS and has little to no relevance to the
206 * Returns: %TRUE if @mount_path is considered an implementation detail
210 g_unix_is_mount_path_system_internal (const char *mount_path)
212 const char *ignore_mountpoints[] = {
213 /* Includes all FHS 2.3 toplevel dirs and other specilized
214 * directories that we want to hide from the user.
216 "/", /* we already have "Filesystem root" in Nautilus */
234 "/var/log/audit", /* https://bugzilla.redhat.com/show_bug.cgi?id=333041 */
235 "/var/tmp", /* https://bugzilla.redhat.com/show_bug.cgi?id=335241 */
242 if (is_in (mount_path, ignore_mountpoints))
245 if (g_str_has_prefix (mount_path, "/dev") ||
246 g_str_has_prefix (mount_path, "/proc") ||
247 g_str_has_prefix (mount_path, "/sys"))
250 if (strstr (mount_path, "/.gvfs") != NULL)
257 guess_system_internal (const char *mountpoint,
261 const char *ignore_fs[] = {
282 const char *ignore_devices[] = {
292 if (is_in (fs, ignore_fs))
295 if (is_in (device, ignore_devices))
298 if (g_unix_is_mount_path_system_internal (mountpoint))
307 get_mtab_read_file (void)
311 return "/proc/mounts";
313 return _PATH_MOUNTED;
321 get_mtab_monitor_file (void)
324 return _PATH_MOUNTED;
330 #ifndef HAVE_GETMNTENT_R
331 G_LOCK_DEFINE_STATIC(getmntent);
335 _g_get_unix_mounts ()
337 #ifdef HAVE_GETMNTENT_R
341 struct mntent *mntent;
344 GUnixMountEntry *mount_entry;
345 GHashTable *mounts_hash;
348 read_file = get_mtab_read_file ();
350 file = setmntent (read_file, "r");
356 mounts_hash = g_hash_table_new (g_str_hash, g_str_equal);
358 #ifdef HAVE_GETMNTENT_R
359 while ((mntent = getmntent_r (file, &ent, buf, sizeof (buf))) != NULL)
362 while ((mntent = getmntent (file)) != NULL)
365 /* ignore any mnt_fsname that is repeated and begins with a '/'
367 * We do this to avoid being fooled by --bind mounts, since
368 * these have the same device as the location they bind to.
369 * Its not an ideal solution to the problem, but it's likely that
370 * the most important mountpoint is first and the --bind ones after
371 * that aren't as important. So it should work.
373 * The '/' is to handle procfs, tmpfs and other no device mounts.
375 if (mntent->mnt_fsname != NULL &&
376 mntent->mnt_fsname[0] == '/' &&
377 g_hash_table_lookup (mounts_hash, mntent->mnt_fsname))
380 mount_entry = g_new0 (GUnixMountEntry, 1);
381 mount_entry->mount_path = g_strdup (mntent->mnt_dir);
382 if (strcmp (mntent->mnt_fsname, "/dev/root") == 0)
383 mount_entry->device_path = g_strdup (_resolve_dev_root ());
385 mount_entry->device_path = g_strdup (mntent->mnt_fsname);
386 mount_entry->filesystem_type = g_strdup (mntent->mnt_type);
388 #if defined (HAVE_HASMNTOPT)
389 if (hasmntopt (mntent, MNTOPT_RO) != NULL)
390 mount_entry->is_read_only = TRUE;
393 mount_entry->is_system_internal =
394 guess_system_internal (mount_entry->mount_path,
395 mount_entry->filesystem_type,
396 mount_entry->device_path);
398 g_hash_table_insert (mounts_hash,
399 mount_entry->device_path,
400 mount_entry->device_path);
402 return_list = g_list_prepend (return_list, mount_entry);
404 g_hash_table_destroy (mounts_hash);
408 #ifndef HAVE_GETMNTENT_R
409 G_UNLOCK (getmntent);
412 return g_list_reverse (return_list);
415 #elif defined (HAVE_SYS_MNTTAB_H)
417 G_LOCK_DEFINE_STATIC(getmntent);
420 get_mtab_read_file (void)
423 return _PATH_MOUNTED;
425 return "/etc/mnttab";
430 get_mtab_monitor_file (void)
432 return get_mtab_read_file ();
436 _g_get_unix_mounts (void)
438 struct mnttab mntent;
441 GUnixMountEntry *mount_entry;
444 read_file = get_mtab_read_file ();
446 file = setmntent (read_file, "r");
453 while (! getmntent (file, &mntent))
455 mount_entry = g_new0 (GUnixMountEntry, 1);
457 mount_entry->mount_path = g_strdup (mntent.mnt_mountp);
458 mount_entry->device_path = g_strdup (mntent.mnt_special);
459 mount_entry->filesystem_type = g_strdup (mntent.mnt_fstype);
461 #if defined (HAVE_HASMNTOPT)
462 if (hasmntopt (&mntent, MNTOPT_RO) != NULL)
463 mount_entry->is_read_only = TRUE;
466 mount_entry->is_system_internal =
467 guess_system_internal (mount_entry->mount_path,
468 mount_entry->filesystem_type,
469 mount_entry->device_path);
471 return_list = g_list_prepend (return_list, mount_entry);
476 G_UNLOCK (getmntent);
478 return g_list_reverse (return_list);
481 #elif defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)
484 get_mtab_monitor_file (void)
490 _g_get_unix_mounts (void)
492 struct vfs_ent *fs_info;
493 struct vmount *vmount_info;
495 unsigned int vmount_size;
499 if (mntctl (MCTL_QUERY, sizeof (vmount_size), &vmount_size) != 0)
501 g_warning ("Unable to know the number of mounted volumes\n");
506 vmount_info = (struct vmount*)g_malloc (vmount_size);
508 vmount_number = mntctl (MCTL_QUERY, vmount_size, vmount_info);
510 if (vmount_info->vmt_revision != VMT_REVISION)
511 g_warning ("Bad vmount structure revision number, want %d, got %d\n", VMT_REVISION, vmount_info->vmt_revision);
513 if (vmount_number < 0)
515 g_warning ("Unable to recover mounted volumes information\n");
517 g_free (vmount_info);
522 while (vmount_number > 0)
524 mount_entry = g_new0 (GUnixMountEntry, 1);
526 mount_entry->device_path = g_strdup (vmt2dataptr (vmount_info, VMT_OBJECT));
527 mount_entry->mount_path = g_strdup (vmt2dataptr (vmount_info, VMT_STUB));
528 /* is_removable = (vmount_info->vmt_flags & MNT_REMOVABLE) ? 1 : 0; */
529 mount_entry->is_read_only = (vmount_info->vmt_flags & MNT_READONLY) ? 1 : 0;
531 fs_info = getvfsbytype (vmount_info->vmt_gfstype);
534 mount_entry->filesystem_type = g_strdup ("unknown");
536 mount_entry->filesystem_type = g_strdup (fs_info->vfsent_name);
538 mount_entry->is_system_internal =
539 guess_system_internal (mount_entry->mount_path,
540 mount_entry->filesystem_type,
541 mount_entry->device_path);
543 return_list = g_list_prepend (return_list, mount_entry);
545 vmount_info = (struct vmount *)( (char*)vmount_info
546 + vmount_info->vmt_length);
551 g_free (vmount_info);
553 return g_list_reverse (return_list);
556 #elif defined(HAVE_GETMNTINFO) && defined(HAVE_FSTAB_H) && defined(HAVE_SYS_MOUNT_H)
559 get_mtab_monitor_file (void)
565 _g_get_unix_mounts (void)
567 struct statfs *mntent = NULL;
569 GUnixMountEntry *mount_entry;
572 /* Pass MNT_NOWAIT to avoid blocking trying to update NFS mounts. */
573 if ((num_mounts = getmntinfo (&mntent, MNT_NOWAIT)) == 0)
578 for (i = 0; i < num_mounts; i++)
580 mount_entry = g_new0 (GUnixMountEntry, 1);
582 mount_entry->mount_path = g_strdup (mntent[i].f_mntonname);
583 mount_entry->device_path = g_strdup (mntent[i].f_mntfromname);
584 mount_entry->filesystem_type = g_strdup (mntent[i].f_fstypename);
585 if (mntent[i].f_flags & MNT_RDONLY)
586 mount_entry->is_read_only = TRUE;
588 mount_entry->is_system_internal =
589 guess_system_internal (mount_entry->mount_path,
590 mount_entry->filesystem_type,
591 mount_entry->device_path);
593 return_list = g_list_prepend (return_list, mount_entry);
596 return g_list_reverse (return_list);
599 #error No _g_get_unix_mounts() implementation for system
602 /* _g_get_unix_mount_points():
604 * don't return swap and ignore mounts.
608 get_fstab_file (void)
610 #if defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)
612 return "/etc/filesystems";
613 #elif defined(_PATH_MNTTAB)
615 #elif defined(VFSTAB)
624 _g_get_unix_mount_points (void)
626 #ifdef HAVE_GETMNTENT_R
630 struct mntent *mntent;
633 GUnixMountPoint *mount_entry;
636 read_file = get_fstab_file ();
638 file = setmntent (read_file, "r");
644 #ifdef HAVE_GETMNTENT_R
645 while ((mntent = getmntent_r (file, &ent, buf, sizeof (buf))) != NULL)
648 while ((mntent = getmntent (file)) != NULL)
651 if ((strcmp (mntent->mnt_dir, "ignore") == 0) ||
652 (strcmp (mntent->mnt_dir, "swap") == 0))
655 mount_entry = g_new0 (GUnixMountPoint, 1);
656 mount_entry->mount_path = g_strdup (mntent->mnt_dir);
657 if (strcmp (mntent->mnt_fsname, "/dev/root") == 0)
658 mount_entry->device_path = g_strdup (_resolve_dev_root ());
660 mount_entry->device_path = g_strdup (mntent->mnt_fsname);
661 mount_entry->filesystem_type = g_strdup (mntent->mnt_type);
663 #ifdef HAVE_HASMNTOPT
664 if (hasmntopt (mntent, MNTOPT_RO) != NULL)
665 mount_entry->is_read_only = TRUE;
667 if (hasmntopt (mntent, "loop") != NULL)
668 mount_entry->is_loopback = TRUE;
672 if ((mntent->mnt_type != NULL && strcmp ("supermount", mntent->mnt_type) == 0)
673 #ifdef HAVE_HASMNTOPT
674 || (hasmntopt (mntent, "user") != NULL
675 && hasmntopt (mntent, "user") != hasmntopt (mntent, "user_xattr"))
676 || hasmntopt (mntent, "pamconsole") != NULL
677 || hasmntopt (mntent, "users") != NULL
678 || hasmntopt (mntent, "owner") != NULL
681 mount_entry->is_user_mountable = TRUE;
683 return_list = g_list_prepend (return_list, mount_entry);
688 #ifndef HAVE_GETMNTENT_R
689 G_UNLOCK (getmntent);
692 return g_list_reverse (return_list);
695 #elif defined (HAVE_SYS_MNTTAB_H)
698 _g_get_unix_mount_points (void)
700 struct mnttab mntent;
703 GUnixMountPoint *mount_entry;
706 read_file = get_fstab_file ();
708 file = setmntent (read_file, "r");
715 while (! getmntent (file, &mntent))
717 if ((strcmp (mntent.mnt_mountp, "ignore") == 0) ||
718 (strcmp (mntent.mnt_mountp, "swap") == 0))
721 mount_entry = g_new0 (GUnixMountPoint, 1);
723 mount_entry->mount_path = g_strdup (mntent.mnt_mountp);
724 mount_entry->device_path = g_strdup (mntent.mnt_special);
725 mount_entry->filesystem_type = g_strdup (mntent.mnt_fstype);
727 #ifdef HAVE_HASMNTOPT
728 if (hasmntopt (&mntent, MNTOPT_RO) != NULL)
729 mount_entry->is_read_only = TRUE;
731 if (hasmntopt (&mntent, "lofs") != NULL)
732 mount_entry->is_loopback = TRUE;
735 if ((mntent.mnt_fstype != NULL)
736 #ifdef HAVE_HASMNTOPT
737 || (hasmntopt (&mntent, "user") != NULL
738 && hasmntopt (&mntent, "user") != hasmntopt (&mntent, "user_xattr"))
739 || hasmntopt (&mntent, "pamconsole") != NULL
740 || hasmntopt (&mntent, "users") != NULL
741 || hasmntopt (&mntent, "owner") != NULL
744 mount_entry->is_user_mountable = TRUE;
747 return_list = g_list_prepend (return_list, mount_entry);
751 G_UNLOCK (getmntent);
753 return g_list_reverse (return_list);
755 #elif defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)
757 /* functions to parse /etc/filesystems on aix */
759 /* read character, ignoring comments (begin with '*', end with '\n' */
761 aix_fs_getc (FILE *fd)
765 while ((c = getc (fd)) == '*')
767 while (((c = getc (fd)) != '\n') && (c != EOF))
772 /* eat all continuous spaces in a file */
774 aix_fs_ignorespace (FILE *fd)
778 while ((c = aix_fs_getc (fd)) != EOF)
780 if (!g_ascii_isspace (c))
790 /* read one word from file */
792 aix_fs_getword (FILE *fd,
797 aix_fs_ignorespace (fd);
799 while (((c = aix_fs_getc (fd)) != EOF) && !g_ascii_isspace (c))
803 while (((c = aix_fs_getc (fd)) != EOF) && (c != '"'))
815 char mnt_mount[PATH_MAX];
816 char mnt_special[PATH_MAX];
818 char mnt_options[128];
819 } AixMountTableEntry;
821 /* read mount points properties */
823 aix_fs_get (FILE *fd,
824 AixMountTableEntry *prop)
826 static char word[PATH_MAX] = { 0 };
827 char value[PATH_MAX];
832 if (aix_fs_getword (fd, word) == EOF)
836 word[strlen(word) - 1] = 0;
837 strcpy (prop->mnt_mount, word);
839 /* read attributes and value */
841 while (aix_fs_getword (fd, word) != EOF)
843 /* test if is attribute or new stanza */
844 if (word[strlen(word) - 1] == ':')
848 aix_fs_getword (fd, value);
851 aix_fs_getword (fd, value);
853 if (strcmp (word, "dev") == 0)
854 strcpy (prop->mnt_special, value);
855 else if (strcmp (word, "vfs") == 0)
856 strcpy (prop->mnt_fstype, value);
857 else if (strcmp (word, "options") == 0)
858 strcpy(prop->mnt_options, value);
865 _g_get_unix_mount_points (void)
867 struct mntent *mntent;
870 GUnixMountPoint *mount_entry;
871 AixMountTableEntry mntent;
874 read_file = get_fstab_file ();
876 file = setmntent (read_file, "r");
882 while (!aix_fs_get (file, &mntent))
884 if (strcmp ("cdrfs", mntent.mnt_fstype) == 0)
886 mount_entry = g_new0 (GUnixMountPoint, 1);
889 mount_entry->mount_path = g_strdup (mntent.mnt_mount);
890 mount_entry->device_path = g_strdup (mntent.mnt_special);
891 mount_entry->filesystem_type = g_strdup (mntent.mnt_fstype);
892 mount_entry->is_read_only = TRUE;
893 mount_entry->is_user_mountable = TRUE;
895 return_list = g_list_prepend (return_list, mount_entry);
901 return g_list_reverse (return_list);
904 #elif defined(HAVE_GETMNTINFO) && defined(HAVE_FSTAB_H) && defined(HAVE_SYS_MOUNT_H)
907 _g_get_unix_mount_points (void)
909 struct fstab *fstab = NULL;
910 GUnixMountPoint *mount_entry;
912 #ifdef HAVE_SYS_SYSCTL_H
914 size_t len = sizeof(usermnt);
923 #ifdef HAVE_SYS_SYSCTL_H
924 #if defined(HAVE_SYSCTLBYNAME)
925 sysctlbyname ("vfs.usermount", &usermnt, &len, NULL, 0);
926 #elif defined(CTL_VFS) && defined(VFS_USERMOUNT)
931 mib[1] = VFS_USERMOUNT;
932 sysctl (mib, 2, &usermnt, &len, NULL, 0);
934 #elif defined(CTL_KERN) && defined(KERN_USERMOUNT)
939 mib[1] = KERN_USERMOUNT;
940 sysctl (mib, 2, &usermnt, &len, NULL, 0);
945 while ((fstab = getfsent ()) != NULL)
947 if (strcmp (fstab->fs_vfstype, "swap") == 0)
950 mount_entry = g_new0 (GUnixMountPoint, 1);
952 mount_entry->mount_path = g_strdup (fstab->fs_file);
953 mount_entry->device_path = g_strdup (fstab->fs_spec);
954 mount_entry->filesystem_type = g_strdup (fstab->fs_vfstype);
956 if (strcmp (fstab->fs_type, "ro") == 0)
957 mount_entry->is_read_only = TRUE;
959 #ifdef HAVE_SYS_SYSCTL_H
962 uid_t uid = getuid ();
963 if (stat (fstab->fs_file, &sb) == 0)
965 if (uid == 0 || sb.st_uid == uid)
966 mount_entry->is_user_mountable = TRUE;
971 return_list = g_list_prepend (return_list, mount_entry);
976 return g_list_reverse (return_list);
979 #error No g_get_mount_table() implementation for system
983 get_mounts_timestamp (void)
985 const char *monitor_file;
988 monitor_file = get_mtab_monitor_file ();
991 if (stat (monitor_file, &buf) == 0)
992 return (guint64)buf.st_mtime;
998 get_mount_points_timestamp (void)
1000 const char *monitor_file;
1003 monitor_file = get_fstab_file ();
1006 if (stat (monitor_file, &buf) == 0)
1007 return (guint64)buf.st_mtime;
1013 * g_unix_mounts_get:
1014 * @time_read: guint64 to contain a timestamp.
1016 * Gets a #GList of strings containing the unix mounts.
1017 * If @time_read is set, it will be filled with the mount
1018 * timestamp, allowing for checking if the mounts have changed
1019 * with g_unix_mounts_changed_since().
1021 * Returns: a #GList of the UNIX mounts.
1024 g_unix_mounts_get (guint64 *time_read)
1027 *time_read = get_mounts_timestamp ();
1029 return _g_get_unix_mounts ();
1034 * @mount_path: path for a possible unix mount.
1035 * @time_read: guint64 to contain a timestamp.
1037 * Gets a #GUnixMountEntry for a given mount path. If @time_read
1038 * is set, it will be filled with a unix timestamp for checking
1039 * if the mounts have changed since with g_unix_mounts_changed_since().
1041 * Returns: a #GUnixMount.
1044 g_unix_mount_at (const char *mount_path,
1048 GUnixMountEntry *mount_entry, *found;
1050 mounts = g_unix_mounts_get (time_read);
1053 for (l = mounts; l != NULL; l = l->next)
1055 mount_entry = l->data;
1057 if (strcmp (mount_path, mount_entry->mount_path) == 0)
1058 found = mount_entry;
1060 g_unix_mount_free (mount_entry);
1063 g_list_free (mounts);
1069 * g_unix_mount_points_get:
1070 * @time_read: guint64 to contain a timestamp.
1072 * Gets a #GList of strings containing the unix mount points.
1073 * If @time_read is set, it will be filled with the mount timestamp,
1074 * allowing for checking if the mounts have changed with
1075 * g_unix_mounts_points_changed_since().
1077 * Returns: a #GList of the UNIX mountpoints.
1080 g_unix_mount_points_get (guint64 *time_read)
1083 *time_read = get_mount_points_timestamp ();
1085 return _g_get_unix_mount_points ();
1089 * g_unix_mounts_changed_since:
1090 * @time: guint64 to contain a timestamp.
1092 * Checks if the unix mounts have changed since a given unix time.
1094 * Returns: %TRUE if the mounts have changed since @time.
1097 g_unix_mounts_changed_since (guint64 time)
1099 return get_mounts_timestamp () != time;
1103 * g_unix_mount_points_changed_since:
1104 * @time: guint64 to contain a timestamp.
1106 * Checks if the unix mount points have changed since a given unix time.
1108 * Returns: %TRUE if the mount points have changed since @time.
1111 g_unix_mount_points_changed_since (guint64 time)
1113 return get_mount_points_timestamp () != time;
1117 g_unix_mount_monitor_finalize (GObject *object)
1119 GUnixMountMonitor *monitor;
1121 monitor = G_UNIX_MOUNT_MONITOR (object);
1123 if (monitor->fstab_monitor)
1125 g_file_monitor_cancel (monitor->fstab_monitor);
1126 g_object_unref (monitor->fstab_monitor);
1129 if (monitor->mtab_monitor)
1131 g_file_monitor_cancel (monitor->mtab_monitor);
1132 g_object_unref (monitor->mtab_monitor);
1135 the_mount_monitor = NULL;
1137 G_OBJECT_CLASS (g_unix_mount_monitor_parent_class)->finalize (object);
1142 g_unix_mount_monitor_class_init (GUnixMountMonitorClass *klass)
1144 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
1146 gobject_class->finalize = g_unix_mount_monitor_finalize;
1148 * GUnixMountMonitor::mounts-changed:
1149 * @monitor: the object on which the signal is emitted
1151 * Emitted when the unix mounts have changed.
1153 signals[MOUNTS_CHANGED] =
1154 g_signal_new ("mounts-changed",
1155 G_TYPE_FROM_CLASS (klass),
1159 g_cclosure_marshal_VOID__VOID,
1162 * GUnixMountMonitor::mountpoints-changed:
1163 * @monitor: the object on which the signal is emitted
1165 * Emitted when the unix mount points have changed.
1167 signals[MOUNTPOINTS_CHANGED] =
1168 g_signal_new ("mountpoints-changed",
1169 G_TYPE_FROM_CLASS (klass),
1173 g_cclosure_marshal_VOID__VOID,
1178 fstab_file_changed (GFileMonitor *monitor,
1181 GFileMonitorEvent event_type,
1184 GUnixMountMonitor *mount_monitor;
1186 if (event_type != G_FILE_MONITOR_EVENT_CHANGED &&
1187 event_type != G_FILE_MONITOR_EVENT_CREATED &&
1188 event_type != G_FILE_MONITOR_EVENT_DELETED)
1191 mount_monitor = user_data;
1192 g_signal_emit (mount_monitor, signals[MOUNTPOINTS_CHANGED], 0);
1196 mtab_file_changed (GFileMonitor *monitor,
1199 GFileMonitorEvent event_type,
1202 GUnixMountMonitor *mount_monitor;
1204 if (event_type != G_FILE_MONITOR_EVENT_CHANGED &&
1205 event_type != G_FILE_MONITOR_EVENT_CREATED &&
1206 event_type != G_FILE_MONITOR_EVENT_DELETED)
1209 mount_monitor = user_data;
1210 g_signal_emit (mount_monitor, signals[MOUNTS_CHANGED], 0);
1214 g_unix_mount_monitor_init (GUnixMountMonitor *monitor)
1218 if (get_fstab_file () != NULL)
1220 file = g_file_new_for_path (get_fstab_file ());
1221 monitor->fstab_monitor = g_file_monitor_file (file, 0, NULL, NULL);
1222 g_object_unref (file);
1224 g_signal_connect (monitor->fstab_monitor, "changed", (GCallback)fstab_file_changed, monitor);
1227 if (get_mtab_monitor_file () != NULL)
1229 file = g_file_new_for_path (get_mtab_monitor_file ());
1230 monitor->mtab_monitor = g_file_monitor_file (file, 0, NULL, NULL);
1231 g_object_unref (file);
1233 g_signal_connect (monitor->mtab_monitor, "changed", (GCallback)mtab_file_changed, monitor);
1238 * g_unix_mount_monitor_set_rate_limit:
1239 * @mount_monitor: a #GUnixMountMonitor
1240 * @limit_msec: a integer with the limit in milliseconds to
1243 * Sets the rate limit to which the @mount_monitor will report
1244 * consecutive change events to the mount and mount point entry files.
1249 g_unix_mount_monitor_set_rate_limit (GUnixMountMonitor *mount_monitor,
1252 g_return_if_fail (G_IS_UNIX_MOUNT_MONITOR (mount_monitor));
1254 if (mount_monitor->fstab_monitor != NULL)
1255 g_file_monitor_set_rate_limit (mount_monitor->fstab_monitor, limit_msec);
1257 if (mount_monitor->mtab_monitor != NULL)
1258 g_file_monitor_set_rate_limit (mount_monitor->mtab_monitor, limit_msec);
1262 * g_unix_mount_monitor_new:
1264 * Gets a new #GUnixMountMonitor. The default rate limit for which the
1265 * monitor will report consecutive changes for the mount and mount
1266 * point entry files is the default for a #GFileMonitor. Use
1267 * g_unix_mount_monitor_set_rate_limit() to change this.
1269 * Returns: a #GUnixMountMonitor.
1272 g_unix_mount_monitor_new (void)
1274 if (the_mount_monitor == NULL)
1276 the_mount_monitor = g_object_new (G_TYPE_UNIX_MOUNT_MONITOR, NULL);
1277 return the_mount_monitor;
1280 return g_object_ref (the_mount_monitor);
1284 * g_unix_mount_free:
1285 * @mount_entry: a #GUnixMount.
1287 * Frees a unix mount.
1290 g_unix_mount_free (GUnixMountEntry *mount_entry)
1292 g_return_if_fail (mount_entry != NULL);
1294 g_free (mount_entry->mount_path);
1295 g_free (mount_entry->device_path);
1296 g_free (mount_entry->filesystem_type);
1297 g_free (mount_entry);
1301 * g_unix_mount_point_free:
1302 * @mount_point: unix mount point to free.
1304 * Frees a unix mount point.
1307 g_unix_mount_point_free (GUnixMountPoint *mount_point)
1309 g_return_if_fail (mount_point != NULL);
1311 g_free (mount_point->mount_path);
1312 g_free (mount_point->device_path);
1313 g_free (mount_point->filesystem_type);
1314 g_free (mount_point);
1318 * g_unix_mount_compare:
1319 * @mount1: first #GUnixMountEntry to compare.
1320 * @mount2: second #GUnixMountEntry to compare.
1322 * Compares two unix mounts.
1324 * Returns: 1, 0 or -1 if @mount1 is greater than, equal to,
1325 * or less than @mount2, respectively.
1328 g_unix_mount_compare (GUnixMountEntry *mount1,
1329 GUnixMountEntry *mount2)
1333 g_return_val_if_fail (mount1 != NULL && mount2 != NULL, 0);
1335 res = g_strcmp0 (mount1->mount_path, mount2->mount_path);
1339 res = g_strcmp0 (mount1->device_path, mount2->device_path);
1343 res = g_strcmp0 (mount1->filesystem_type, mount2->filesystem_type);
1347 res = mount1->is_read_only - mount2->is_read_only;
1355 * g_unix_mount_get_mount_path:
1356 * @mount_entry: input #GUnixMountEntry to get the mount path for.
1358 * Gets the mount path for a unix mount.
1360 * Returns: the mount path for @mount_entry.
1363 g_unix_mount_get_mount_path (GUnixMountEntry *mount_entry)
1365 g_return_val_if_fail (mount_entry != NULL, NULL);
1367 return mount_entry->mount_path;
1371 * g_unix_mount_get_device_path:
1372 * @mount_entry: a #GUnixMount.
1374 * Gets the device path for a unix mount.
1376 * Returns: a string containing the device path.
1379 g_unix_mount_get_device_path (GUnixMountEntry *mount_entry)
1381 g_return_val_if_fail (mount_entry != NULL, NULL);
1383 return mount_entry->device_path;
1387 * g_unix_mount_get_fs_type:
1388 * @mount_entry: a #GUnixMount.
1390 * Gets the filesystem type for the unix mount.
1392 * Returns: a string containing the file system type.
1395 g_unix_mount_get_fs_type (GUnixMountEntry *mount_entry)
1397 g_return_val_if_fail (mount_entry != NULL, NULL);
1399 return mount_entry->filesystem_type;
1403 * g_unix_mount_is_readonly:
1404 * @mount_entry: a #GUnixMount.
1406 * Checks if a unix mount is mounted read only.
1408 * Returns: %TRUE if @mount_entry is read only.
1411 g_unix_mount_is_readonly (GUnixMountEntry *mount_entry)
1413 g_return_val_if_fail (mount_entry != NULL, FALSE);
1415 return mount_entry->is_read_only;
1419 * g_unix_mount_is_system_internal:
1420 * @mount_entry: a #GUnixMount.
1422 * Checks if a unix mount is a system path.
1424 * Returns: %TRUE if the unix mount is for a system path.
1427 g_unix_mount_is_system_internal (GUnixMountEntry *mount_entry)
1429 g_return_val_if_fail (mount_entry != NULL, FALSE);
1431 return mount_entry->is_system_internal;
1435 * g_unix_mount_point_compare:
1436 * @mount1: a #GUnixMount.
1437 * @mount2: a #GUnixMount.
1439 * Compares two unix mount points.
1441 * Returns: 1, 0 or -1 if @mount1 is greater than, equal to,
1442 * or less than @mount2, respectively.
1445 g_unix_mount_point_compare (GUnixMountPoint *mount1,
1446 GUnixMountPoint *mount2)
1450 g_return_val_if_fail (mount1 != NULL && mount2 != NULL, 0);
1452 res = g_strcmp0 (mount1->mount_path, mount2->mount_path);
1456 res = g_strcmp0 (mount1->device_path, mount2->device_path);
1460 res = g_strcmp0 (mount1->filesystem_type, mount2->filesystem_type);
1464 res = mount1->is_read_only - mount2->is_read_only;
1468 res = mount1->is_user_mountable - mount2->is_user_mountable;
1472 res = mount1->is_loopback - mount2->is_loopback;
1480 * g_unix_mount_point_get_mount_path:
1481 * @mount_point: a #GUnixMountPoint.
1483 * Gets the mount path for a unix mount point.
1485 * Returns: a string containing the mount path.
1488 g_unix_mount_point_get_mount_path (GUnixMountPoint *mount_point)
1490 g_return_val_if_fail (mount_point != NULL, NULL);
1492 return mount_point->mount_path;
1496 * g_unix_mount_point_get_device_path:
1497 * @mount_point: a #GUnixMountPoint.
1499 * Gets the device path for a unix mount point.
1501 * Returns: a string containing the device path.
1504 g_unix_mount_point_get_device_path (GUnixMountPoint *mount_point)
1506 g_return_val_if_fail (mount_point != NULL, NULL);
1508 return mount_point->device_path;
1512 * g_unix_mount_point_get_fs_type:
1513 * @mount_point: a #GUnixMountPoint.
1515 * Gets the file system type for the mount point.
1517 * Returns: a string containing the file system type.
1520 g_unix_mount_point_get_fs_type (GUnixMountPoint *mount_point)
1522 g_return_val_if_fail (mount_point != NULL, NULL);
1524 return mount_point->filesystem_type;
1528 * g_unix_mount_point_is_readonly:
1529 * @mount_point: a #GUnixMountPoint.
1531 * Checks if a unix mount point is read only.
1533 * Returns: %TRUE if a mount point is read only.
1536 g_unix_mount_point_is_readonly (GUnixMountPoint *mount_point)
1538 g_return_val_if_fail (mount_point != NULL, FALSE);
1540 return mount_point->is_read_only;
1544 * g_unix_mount_point_is_user_mountable:
1545 * @mount_point: a #GUnixMountPoint.
1547 * Checks if a unix mount point is mountable by the user.
1549 * Returns: %TRUE if the mount point is user mountable.
1552 g_unix_mount_point_is_user_mountable (GUnixMountPoint *mount_point)
1554 g_return_val_if_fail (mount_point != NULL, FALSE);
1556 return mount_point->is_user_mountable;
1560 * g_unix_mount_point_is_loopback:
1561 * @mount_point: a #GUnixMountPoint.
1563 * Checks if a unix mount point is a loopback device.
1565 * Returns: %TRUE if the mount point is a loopback. %FALSE otherwise.
1568 g_unix_mount_point_is_loopback (GUnixMountPoint *mount_point)
1570 g_return_val_if_fail (mount_point != NULL, FALSE);
1572 return mount_point->is_loopback;
1575 static GUnixMountType
1576 guess_mount_type (const char *mount_path,
1577 const char *device_path,
1578 const char *filesystem_type)
1580 GUnixMountType type;
1583 type = G_UNIX_MOUNT_TYPE_UNKNOWN;
1585 if ((strcmp (filesystem_type, "udf") == 0) ||
1586 (strcmp (filesystem_type, "iso9660") == 0) ||
1587 (strcmp (filesystem_type, "cd9660") == 0))
1588 type = G_UNIX_MOUNT_TYPE_CDROM;
1589 else if ((strcmp (filesystem_type, "nfs") == 0) ||
1590 (strcmp (filesystem_type, "nfs4") == 0))
1591 type = G_UNIX_MOUNT_TYPE_NFS;
1592 else if (g_str_has_prefix (device_path, "/vol/dev/diskette/") ||
1593 g_str_has_prefix (device_path, "/dev/fd") ||
1594 g_str_has_prefix (device_path, "/dev/floppy"))
1595 type = G_UNIX_MOUNT_TYPE_FLOPPY;
1596 else if (g_str_has_prefix (device_path, "/dev/cdrom") ||
1597 g_str_has_prefix (device_path, "/dev/acd") ||
1598 g_str_has_prefix (device_path, "/dev/cd"))
1599 type = G_UNIX_MOUNT_TYPE_CDROM;
1600 else if (g_str_has_prefix (device_path, "/vol/"))
1602 const char *name = mount_path + strlen ("/");
1604 if (g_str_has_prefix (name, "cdrom"))
1605 type = G_UNIX_MOUNT_TYPE_CDROM;
1606 else if (g_str_has_prefix (name, "floppy") ||
1607 g_str_has_prefix (device_path, "/vol/dev/diskette/"))
1608 type = G_UNIX_MOUNT_TYPE_FLOPPY;
1609 else if (g_str_has_prefix (name, "rmdisk"))
1610 type = G_UNIX_MOUNT_TYPE_ZIP;
1611 else if (g_str_has_prefix (name, "jaz"))
1612 type = G_UNIX_MOUNT_TYPE_JAZ;
1613 else if (g_str_has_prefix (name, "memstick"))
1614 type = G_UNIX_MOUNT_TYPE_MEMSTICK;
1618 basename = g_path_get_basename (mount_path);
1620 if (g_str_has_prefix (basename, "cdr") ||
1621 g_str_has_prefix (basename, "cdwriter") ||
1622 g_str_has_prefix (basename, "burn") ||
1623 g_str_has_prefix (basename, "dvdr"))
1624 type = G_UNIX_MOUNT_TYPE_CDROM;
1625 else if (g_str_has_prefix (basename, "floppy"))
1626 type = G_UNIX_MOUNT_TYPE_FLOPPY;
1627 else if (g_str_has_prefix (basename, "zip"))
1628 type = G_UNIX_MOUNT_TYPE_ZIP;
1629 else if (g_str_has_prefix (basename, "jaz"))
1630 type = G_UNIX_MOUNT_TYPE_JAZ;
1631 else if (g_str_has_prefix (basename, "camera"))
1632 type = G_UNIX_MOUNT_TYPE_CAMERA;
1633 else if (g_str_has_prefix (basename, "memstick") ||
1634 g_str_has_prefix (basename, "memory_stick") ||
1635 g_str_has_prefix (basename, "ram"))
1636 type = G_UNIX_MOUNT_TYPE_MEMSTICK;
1637 else if (g_str_has_prefix (basename, "compact_flash"))
1638 type = G_UNIX_MOUNT_TYPE_CF;
1639 else if (g_str_has_prefix (basename, "smart_media"))
1640 type = G_UNIX_MOUNT_TYPE_SM;
1641 else if (g_str_has_prefix (basename, "sd_mmc"))
1642 type = G_UNIX_MOUNT_TYPE_SDMMC;
1643 else if (g_str_has_prefix (basename, "ipod"))
1644 type = G_UNIX_MOUNT_TYPE_IPOD;
1649 if (type == G_UNIX_MOUNT_TYPE_UNKNOWN)
1650 type = G_UNIX_MOUNT_TYPE_HD;
1656 * g_unix_mount_guess_type:
1657 * @mount_entry: a #GUnixMount.
1659 * Guesses the type of a unix mount. If the mount type cannot be
1660 * determined, returns %G_UNIX_MOUNT_TYPE_UNKNOWN.
1662 * Returns: a #GUnixMountType.
1664 static GUnixMountType
1665 g_unix_mount_guess_type (GUnixMountEntry *mount_entry)
1667 g_return_val_if_fail (mount_entry != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1668 g_return_val_if_fail (mount_entry->mount_path != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1669 g_return_val_if_fail (mount_entry->device_path != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1670 g_return_val_if_fail (mount_entry->filesystem_type != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1672 return guess_mount_type (mount_entry->mount_path,
1673 mount_entry->device_path,
1674 mount_entry->filesystem_type);
1678 * g_unix_mount_point_guess_type:
1679 * @mount_point: a #GUnixMountPoint.
1681 * Guesses the type of a unix mount point.
1682 * If the mount type cannot be determined,
1683 * returns %G_UNIX_MOUNT_TYPE_UNKNOWN.
1685 * Returns: a #GUnixMountType.
1687 static GUnixMountType
1688 g_unix_mount_point_guess_type (GUnixMountPoint *mount_point)
1690 g_return_val_if_fail (mount_point != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1691 g_return_val_if_fail (mount_point->mount_path != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1692 g_return_val_if_fail (mount_point->device_path != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1693 g_return_val_if_fail (mount_point->filesystem_type != NULL, G_UNIX_MOUNT_TYPE_UNKNOWN);
1695 return guess_mount_type (mount_point->mount_path,
1696 mount_point->device_path,
1697 mount_point->filesystem_type);
1701 type_to_icon (GUnixMountType type, gboolean is_mount_point)
1703 const char *icon_name;
1707 case G_UNIX_MOUNT_TYPE_HD:
1709 icon_name = "drive-removable-media";
1711 icon_name = "drive-harddisk";
1713 case G_UNIX_MOUNT_TYPE_FLOPPY:
1714 case G_UNIX_MOUNT_TYPE_ZIP:
1715 case G_UNIX_MOUNT_TYPE_JAZ:
1717 icon_name = "drive-removable-media";
1719 icon_name = "media-floppy";
1721 case G_UNIX_MOUNT_TYPE_CDROM:
1723 icon_name = "drive-optical";
1725 icon_name = "media-optical";
1727 case G_UNIX_MOUNT_TYPE_NFS:
1728 /* TODO: Would like a better icon here... */
1730 icon_name = "drive-removable-media";
1732 icon_name = "drive-harddisk";
1734 case G_UNIX_MOUNT_TYPE_MEMSTICK:
1736 icon_name = "drive-removable-media";
1738 icon_name = "media-flash";
1740 case G_UNIX_MOUNT_TYPE_CAMERA:
1742 icon_name = "drive-removable-media";
1744 icon_name = "camera-photo";
1746 case G_UNIX_MOUNT_TYPE_IPOD:
1748 icon_name = "drive-removable-media";
1750 icon_name = "multimedia-player";
1752 case G_UNIX_MOUNT_TYPE_UNKNOWN:
1755 icon_name = "drive-removable-media";
1757 icon_name = "drive-harddisk";
1765 * g_unix_mount_guess_name:
1766 * @mount_entry: a #GUnixMountEntry
1768 * Guesses the name of a Unix mount.
1769 * The result is a translated string.
1771 * Returns: A newly allocated string that must
1772 * be freed with g_free()
1775 g_unix_mount_guess_name (GUnixMountEntry *mount_entry)
1779 if (strcmp (mount_entry->mount_path, "/") == 0)
1780 name = g_strdup (_("Filesystem root"));
1782 name = g_filename_display_basename (mount_entry->mount_path);
1788 * g_unix_mount_guess_icon:
1789 * @mount_entry: a #GUnixMountEntry
1791 * Guesses the icon of a Unix mount.
1796 g_unix_mount_guess_icon (GUnixMountEntry *mount_entry)
1798 return g_themed_icon_new_with_default_fallbacks (type_to_icon (g_unix_mount_guess_type (mount_entry), FALSE));
1802 * g_unix_mount_point_guess_name:
1803 * @mount_point: a #GUnixMountPoint
1805 * Guesses the name of a Unix mount point.
1806 * The result is a translated string.
1808 * Returns: A newly allocated string that must
1809 * be freed with g_free()
1812 g_unix_mount_point_guess_name (GUnixMountPoint *mount_point)
1816 if (strcmp (mount_point->mount_path, "/") == 0)
1817 name = g_strdup (_("Filesystem root"));
1819 name = g_filename_display_basename (mount_point->mount_path);
1825 * g_unix_mount_point_guess_icon:
1826 * @mount_point: a #GUnixMountPoint
1828 * Guesses the icon of a Unix mount point.
1833 g_unix_mount_point_guess_icon (GUnixMountPoint *mount_point)
1835 return g_themed_icon_new_with_default_fallbacks (type_to_icon (g_unix_mount_point_guess_type (mount_point), TRUE));
1839 * g_unix_mount_guess_can_eject:
1840 * @mount_entry: a #GUnixMountEntry
1842 * Guesses whether a Unix mount can be ejected.
1844 * Returns: %TRUE if @mount_entry is deemed to be ejectable.
1847 g_unix_mount_guess_can_eject (GUnixMountEntry *mount_entry)
1849 GUnixMountType guessed_type;
1851 guessed_type = g_unix_mount_guess_type (mount_entry);
1852 if (guessed_type == G_UNIX_MOUNT_TYPE_IPOD ||
1853 guessed_type == G_UNIX_MOUNT_TYPE_CDROM)
1860 * g_unix_mount_guess_should_display:
1861 * @mount_entry: a #GUnixMountEntry
1863 * Guesses whether a Unix mount should be displayed in the UI.
1865 * Returns: %TRUE if @mount_entry is deemed to be displayable.
1868 g_unix_mount_guess_should_display (GUnixMountEntry *mount_entry)
1870 const char *mount_path;
1872 /* Never display internal mountpoints */
1873 if (g_unix_mount_is_system_internal (mount_entry))
1876 /* Only display things in /media (which are generally user mountable)
1877 and home dir (fuse stuff) */
1878 mount_path = mount_entry->mount_path;
1879 if (mount_path != NULL)
1881 if (g_str_has_prefix (mount_path, "/media/")) {
1883 /* Avoid displaying mounts that are not accessible to the user.
1885 * See http://bugzilla.gnome.org/show_bug.cgi?id=526320 for why we
1886 * want to avoid g_access() for mount points which can potentially
1887 * block or fail stat()'ing, such as network mounts.
1889 path = g_path_get_dirname (mount_path);
1890 if (g_str_has_prefix (path, "/media/"))
1892 if (g_access (path, R_OK|X_OK) != 0) {
1899 if (mount_entry->device_path && mount_entry->device_path[0] == '/')
1902 if (g_stat (mount_entry->device_path, &st) == 0 &&
1903 S_ISBLK(st.st_mode) &&
1904 g_access (mount_path, R_OK|X_OK) != 0)
1910 if (g_str_has_prefix (mount_path, g_get_home_dir ()) && mount_path[strlen (g_get_home_dir())] == G_DIR_SEPARATOR)
1918 * g_unix_mount_point_guess_can_eject:
1919 * @mount_point: a #GUnixMountPoint
1921 * Guesses whether a Unix mount point can be ejected.
1923 * Returns: %TRUE if @mount_point is deemed to be ejectable.
1926 g_unix_mount_point_guess_can_eject (GUnixMountPoint *mount_point)
1928 GUnixMountType guessed_type;
1930 guessed_type = g_unix_mount_point_guess_type (mount_point);
1931 if (guessed_type == G_UNIX_MOUNT_TYPE_IPOD ||
1932 guessed_type == G_UNIX_MOUNT_TYPE_CDROM)
1939 /* borrowed from gtk/gtkfilesystemunix.c in GTK+ on 02/23/2006 */
1941 _canonicalize_filename (gchar *filename)
1944 gboolean last_was_slash = FALSE;
1951 if (*p == G_DIR_SEPARATOR)
1953 if (!last_was_slash)
1954 *q++ = G_DIR_SEPARATOR;
1956 last_was_slash = TRUE;
1960 if (last_was_slash && *p == '.')
1962 if (*(p + 1) == G_DIR_SEPARATOR ||
1965 if (*(p + 1) == '\0')
1970 else if (*(p + 1) == '.' &&
1971 (*(p + 2) == G_DIR_SEPARATOR ||
1974 if (q > filename + 1)
1977 while (q > filename + 1 &&
1978 *(q - 1) != G_DIR_SEPARATOR)
1982 if (*(p + 2) == '\0')
1990 last_was_slash = FALSE;
1996 last_was_slash = FALSE;
2003 if (q > filename + 1 && *(q - 1) == G_DIR_SEPARATOR)
2010 _resolve_symlink (const char *file)
2018 f = g_strdup (file);
2020 while (g_file_test (f, G_FILE_TEST_IS_SYMLINK)) {
2021 link = g_file_read_link (f, &error);
2023 g_error_free (error);
2029 dir = g_path_get_dirname (f);
2030 f1 = g_strdup_printf ("%s/%s", dir, link);
2039 _canonicalize_filename (f);
2043 #ifdef HAVE_MNTENT_H
2045 _resolve_dev_root (void)
2047 static gboolean have_real_dev_root = FALSE;
2048 static char real_dev_root[256];
2049 struct stat statbuf;
2051 /* see if it's cached already */
2052 if (have_real_dev_root)
2055 /* otherwise we're going to find it right away.. */
2056 have_real_dev_root = TRUE;
2058 if (stat ("/dev/root", &statbuf) == 0) {
2059 if (! S_ISLNK (statbuf.st_mode)) {
2060 dev_t root_dev = statbuf.st_dev;
2064 /* see if device with similar major:minor as /dev/root is mention
2065 * in /etc/mtab (it usually is)
2067 f = fopen ("/etc/mtab", "r");
2069 struct mntent *entp;
2070 #ifdef HAVE_GETMNTENT_R
2072 while ((entp = getmntent_r (f, &ent, buf, sizeof (buf))) != NULL) {
2075 while ((entp = getmntent (f)) != NULL) {
2077 if (stat (entp->mnt_fsname, &statbuf) == 0 &&
2078 statbuf.st_dev == root_dev) {
2079 strncpy (real_dev_root, entp->mnt_fsname, sizeof (real_dev_root) - 1);
2080 real_dev_root[sizeof (real_dev_root) - 1] = '\0';
2088 #ifndef HAVE_GETMNTENT_R
2089 G_UNLOCK (getmntent);
2093 /* no, that didn't work.. next we could scan /dev ... but I digress.. */
2097 resolved = _resolve_symlink ("/dev/root");
2098 if (resolved != NULL) {
2099 strncpy (real_dev_root, resolved, sizeof (real_dev_root) - 1);
2100 real_dev_root[sizeof (real_dev_root) - 1] = '\0';
2108 strcpy (real_dev_root, "/dev/root");
2111 return real_dev_root;
2115 #define __G_UNIX_MOUNTS_C__
2116 #include "gioaliasdef.c"