/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

/* GIO - GLib Input, Output and Streaming Library

 * 

 * Copyright (C) 2006-2007 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: Alexander Larsson <alexl@redhat.com>

 */

/* Prologue {{{1 */

#include "config.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

#ifndef HAVE_SYSCTLBYNAME

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#endif

#ifdef HAVE_POLL

#include <poll.h>

#endif

#include <stdio.h>

#include <unistd.h>

#include <sys/time.h>

#include <errno.h>

#include <string.h>

#include <signal.h>

#include <gstdio.h>

#include <dirent.h>

#if HAVE_SYS_STATFS_H

#include <sys/statfs.h>

#endif

#if HAVE_SYS_STATVFS_H

#include <sys/statvfs.h>

#endif

#if HAVE_SYS_VFS_H

#include <sys/vfs.h>

#elif HAVE_SYS_MOUNT_H

#if HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#include <sys/mount.h>

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

#include "gunixmounts.h"

#include "glocalfileprivate.h"

#include "gfile.h"

#include "gfilemonitor.h"

#include "glibintl.h"

#include "gthemedicon.h"

#include "gcontextspecificgroup.h"

#ifdef HAVE_MNTENT_H

static const char *_resolve_dev_root (void);

#endif

/**

 * SECTION:gunixmounts

 * @include: gio/gunixmounts.h

 * @short_description: UNIX mounts

 *

 * Routines for managing mounted UNIX mount points and paths.

 *

 * Note that `<gio/gunixmounts.h>` belongs to the UNIX-specific GIO

 * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config

 * file when using it.

 */

/**

 * GUnixMountType:

 * @G_UNIX_MOUNT_TYPE_UNKNOWN: Unknown UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_FLOPPY: Floppy disk UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_CDROM: CDROM UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_NFS: Network File System (NFS) UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_ZIP: ZIP UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_JAZ: JAZZ UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_MEMSTICK: Memory Stick UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_CF: Compact Flash UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_SM: Smart Media UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_SDMMC: SD/MMC UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_IPOD: iPod UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_CAMERA: Digital camera UNIX mount type.

 * @G_UNIX_MOUNT_TYPE_HD: Hard drive UNIX mount type.

 * 

 * Types of UNIX mounts.

 **/

typedef enum {

  G_UNIX_MOUNT_TYPE_UNKNOWN,

  G_UNIX_MOUNT_TYPE_FLOPPY,

  G_UNIX_MOUNT_TYPE_CDROM,

  G_UNIX_MOUNT_TYPE_NFS,

  G_UNIX_MOUNT_TYPE_ZIP,

  G_UNIX_MOUNT_TYPE_JAZ,

  G_UNIX_MOUNT_TYPE_MEMSTICK,

  G_UNIX_MOUNT_TYPE_CF,

  G_UNIX_MOUNT_TYPE_SM,

  G_UNIX_MOUNT_TYPE_SDMMC,

  G_UNIX_MOUNT_TYPE_IPOD,

  G_UNIX_MOUNT_TYPE_CAMERA,

  G_UNIX_MOUNT_TYPE_HD

} GUnixMountType;

struct _GUnixMountEntry {

  char *mount_path;

  char *device_path;

  char *filesystem_type;

  gboolean is_read_only;

  gboolean is_system_internal;

};

G_DEFINE_BOXED_TYPE (GUnixMountEntry, g_unix_mount_entry,

                     g_unix_mount_copy, g_unix_mount_free)

struct _GUnixMountPoint {

  char *mount_path;

  char *device_path;

  char *filesystem_type;

  char *options;

  gboolean is_read_only;

  gboolean is_user_mountable;

  gboolean is_loopback;

};

G_DEFINE_BOXED_TYPE (GUnixMountPoint, g_unix_mount_point,

                     g_unix_mount_point_copy, g_unix_mount_point_free)

static GList *_g_get_unix_mounts (void);

static GList *_g_get_unix_mount_points (void);

static gboolean proc_mounts_watch_is_running (void);

static guint64 mount_poller_time = 0;

#ifdef HAVE_SYS_MNTTAB_H

#define MNTOPT_RO	"ro"

#endif

#ifdef HAVE_MNTENT_H

#include <mntent.h>

#ifdef HAVE_LIBMOUNT

#include <libmount.h>

#endif

#elif defined (HAVE_SYS_MNTTAB_H)

#include <sys/mnttab.h>

#endif

#ifdef HAVE_SYS_VFSTAB_H

#include <sys/vfstab.h>

#endif

#if defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)

#include <sys/mntctl.h>

#include <sys/vfs.h>

#include <sys/vmount.h>

#include <fshelp.h>

#endif

#if (defined(HAVE_GETVFSSTAT) || defined(HAVE_GETFSSTAT)) && defined(HAVE_FSTAB_H) && defined(HAVE_SYS_MOUNT_H)

#include <sys/param.h>

#include <sys/ucred.h>

#include <sys/mount.h>

#include <fstab.h>

#ifdef HAVE_SYS_SYSCTL_H

#include <sys/sysctl.h>

#endif

#endif

#ifndef HAVE_SETMNTENT

#define setmntent(f,m) fopen(f,m)

#endif

#ifndef HAVE_ENDMNTENT

#define endmntent(f) fclose(f)

#endif

static gboolean

is_in (const char *value, const char *set[])

{

  int i;

  for (i = 0; set[i] != NULL; i++)

    {

      if (strcmp (set[i], value) == 0)

	return TRUE;

    }

  return FALSE;

}

/**

 * g_unix_is_mount_path_system_internal:

 * @mount_path: (type filename): a mount path, e.g. `/media/disk` or `/usr`

 *

 * Determines if @mount_path is considered an implementation of the

 * OS. This is primarily used for hiding mountable and mounted volumes

 * that only are used in the OS and has little to no relevance to the

 * casual user.

 *

 * Returns: %TRUE if @mount_path is considered an implementation detail 

 *     of the OS.

 **/

gboolean

g_unix_is_mount_path_system_internal (const char *mount_path)

{

  const char *ignore_mountpoints[] = {

    /* Includes all FHS 2.3 toplevel dirs and other specialized

     * directories that we want to hide from the user.

     */

    "/",              /* we already have "Filesystem root" in Nautilus */ 

    "/bin",

    "/boot",

    "/compat/linux/proc",

    "/compat/linux/sys",

    "/dev",

    "/etc",

    "/home",

    "/lib",

    "/lib64",

    "/libexec",

    "/live/cow",

    "/live/image",

    "/media",

    "/mnt",

    "/opt",

    "/rescue",

    "/root",

    "/sbin",

    "/srv",

    "/tmp",

    "/usr",

    "/usr/X11R6",

    "/usr/local",

    "/usr/obj",

    "/usr/ports",

    "/usr/src",

    "/usr/xobj",

    "/var",

    "/var/crash",

    "/var/local",

    "/var/log",

    "/var/log/audit", /* https://bugzilla.redhat.com/show_bug.cgi?id=333041 */

    "/var/mail",

    "/var/run",

    "/var/tmp",       /* https://bugzilla.redhat.com/show_bug.cgi?id=335241 */

    "/proc",

    "/sbin",

    "/net",

    "/sys",

    NULL

  };

  if (is_in (mount_path, ignore_mountpoints))

    return TRUE;

  if (g_str_has_prefix (mount_path, "/dev/") ||

      g_str_has_prefix (mount_path, "/proc/") ||

      g_str_has_prefix (mount_path, "/sys/"))

    return TRUE;

  if (g_str_has_suffix (mount_path, "/.gvfs"))

    return TRUE;

  return FALSE;

}

/**

 * g_unix_is_system_fs_type:

 * @fs_type: a file system type, e.g. `procfs` or `tmpfs`

 *

 * Determines if @fs_type is considered a type of file system which is only

 * used in implementation of the OS. This is primarily used for hiding

 * mounted volumes that are intended as APIs for programs to read, and system

 * administrators at a shell; rather than something that should, for example,

 * appear in a GUI. For example, the Linux `/proc` filesystem.

 *

 * The list of file system types considered ‘system’ ones may change over time.

 *

 * Returns: %TRUE if @fs_type is considered an implementation detail of the OS.

 * Since: 2.56

 */

gboolean

g_unix_is_system_fs_type (const char *fs_type)

{

  const char *ignore_fs[] = {

    "adfs",

    "afs",

    "auto",

    "autofs",

    "autofs4",

    "cgroup",

    "cifs",

    "configfs",

    "cxfs",

    "debugfs",

    "devfs",

    "devpts",

    "devtmpfs",

    "ecryptfs",

    "fdescfs",

    "fusectl",

    "gfs",

    "gfs2",

    "gpfs",

    "hugetlbfs",

    "kernfs",

    "linprocfs",

    "linsysfs",

    "lustre",

    "lustre_lite",

    "mfs",

    "mqueue",

    "ncpfs",

    "nfs",

    "nfs4",

    "nfsd",

    "nullfs",

    "ocfs2",

    "overlay",

    "proc",

    "procfs",

    "pstore",

    "ptyfs",

    "rootfs",

    "rpc_pipefs",

    "securityfs",

    "selinuxfs",

    "smbfs",

    "sysfs",

    "tmpfs",

    "usbfs",

    "zfs",

    NULL

  };

  g_return_val_if_fail (fs_type != NULL && *fs_type != '\0', FALSE);

  return is_in (fs_type, ignore_fs);

}

/**

 * g_unix_is_system_device_path:

 * @device_path: a device path, e.g. `/dev/loop0` or `nfsd`

 *

 * Determines if @device_path is considered a block device path which is only

 * used in implementation of the OS. This is primarily used for hiding

 * mounted volumes that are intended as APIs for programs to read, and system

 * administrators at a shell; rather than something that should, for example,

 * appear in a GUI. For example, the Linux `/proc` filesystem.

 *

 * The list of device paths considered ‘system’ ones may change over time.

 *

 * Returns: %TRUE if @device_path is considered an implementation detail of

 *    the OS.

 * Since: 2.56

 */

gboolean

g_unix_is_system_device_path (const char *device_path)

{

  const char *ignore_devices[] = {

    "none",

    "sunrpc",

    "devpts",

    "nfsd",

    "/dev/loop",

    "/dev/vn",

    NULL

  };

  g_return_val_if_fail (device_path != NULL && *device_path != '\0', FALSE);

  return is_in (device_path, ignore_devices);

}

static gboolean

guess_system_internal (const char *mountpoint,

		       const char *fs,

		       const char *device)

{

  if (g_unix_is_system_fs_type (fs))

    return TRUE;

  if (g_unix_is_system_device_path (device))

    return TRUE;

  if (g_unix_is_mount_path_system_internal (mountpoint))

    return TRUE;

  return FALSE;

}

/* GUnixMounts (ie: mtab) implementations {{{1 */

static GUnixMountEntry *

create_unix_mount_entry (const char *device_path,

                         const char *mount_path,

                         const char *filesystem_type,

                         gboolean    is_read_only)

{

  GUnixMountEntry *mount_entry = NULL;

  mount_entry = g_new0 (GUnixMountEntry, 1);

  mount_entry->device_path = g_strdup (device_path);

  mount_entry->mount_path = g_strdup (mount_path);

  mount_entry->filesystem_type = g_strdup (filesystem_type);

  mount_entry->is_read_only = is_read_only;

  mount_entry->is_system_internal =

    guess_system_internal (mount_entry->mount_path,

                           mount_entry->filesystem_type,

                           mount_entry->device_path);

  return mount_entry;

}

static GUnixMountPoint *

create_unix_mount_point (const char *device_path,

                         const char *mount_path,

                         const char *filesystem_type,

                         const char *options,

                         gboolean    is_read_only,

                         gboolean    is_user_mountable,

                         gboolean    is_loopback)

{

  GUnixMountPoint *mount_point = NULL;

  mount_point = g_new0 (GUnixMountPoint, 1);

  mount_point->device_path = g_strdup (device_path);

  mount_point->mount_path = g_strdup (mount_path);

  mount_point->filesystem_type = g_strdup (filesystem_type);

  mount_point->options = g_strdup (options);

  mount_point->is_read_only = is_read_only;

  mount_point->is_user_mountable = is_user_mountable;

  mount_point->is_loopback = is_loopback;

  return mount_point;

}

/* mntent.h (Linux, GNU, NSS) {{{2 */

#ifdef HAVE_MNTENT_H

#ifdef HAVE_LIBMOUNT

/* For documentation on /proc/self/mountinfo see

 * http://www.kernel.org/doc/Documentation/filesystems/proc.txt

 */

#define PROC_MOUNTINFO_PATH "/proc/self/mountinfo"

static GList *

_g_get_unix_mounts (void)

{

  struct libmnt_table *table = NULL;

  struct libmnt_iter* iter = NULL;

  struct libmnt_fs *fs = NULL;

  GUnixMountEntry *mount_entry = NULL;

  GList *return_list = NULL;

  table = mnt_new_table ();

  if (mnt_table_parse_mtab (table, NULL) < 0)

    goto out;

  iter = mnt_new_iter (MNT_ITER_FORWARD);

  while (mnt_table_next_fs (table, iter, &fs) == 0)

    {

      const char *device_path = NULL;

      char *mount_options = NULL;

      unsigned long mount_flags = 0;

      gboolean is_read_only = FALSE;

      device_path = mnt_fs_get_source (fs);

      if (g_strcmp0 (device_path, "/dev/root") == 0)

        device_path = _resolve_dev_root ();

      mount_options = mnt_fs_strdup_options (fs);

      if (mount_options)

        {

          mnt_optstr_get_flags (mount_options, &mount_flags, mnt_get_builtin_optmap (MNT_LINUX_MAP));

          g_free (mount_options);

        }

      is_read_only = (mount_flags & MS_RDONLY) ? TRUE : FALSE;

      mount_entry = create_unix_mount_entry (device_path,

                                             mnt_fs_get_target (fs),

                                             mnt_fs_get_fstype (fs),

                                             is_read_only);

      return_list = g_list_prepend (return_list, mount_entry);

    }

  mnt_free_iter (iter);

 out:

  mnt_free_table (table);

  return g_list_reverse (return_list);

}

#else

static const char *

get_mtab_read_file (void)

{

#ifdef _PATH_MOUNTED

# ifdef __linux__

  return "/proc/mounts";

# else

  return _PATH_MOUNTED;

# endif

#else

  return "/etc/mtab";

#endif

}

#ifndef HAVE_GETMNTENT_R

G_LOCK_DEFINE_STATIC(getmntent);

#endif

static GList *

_g_get_unix_mounts (void)

{

#ifdef HAVE_GETMNTENT_R

  struct mntent ent;

  char buf[1024];

#endif

  struct mntent *mntent;

  FILE *file;

  const char *read_file;

  GUnixMountEntry *mount_entry;

  GHashTable *mounts_hash;

  GList *return_list;

  read_file = get_mtab_read_file ();

  file = setmntent (read_file, "r");

  if (file == NULL)

    return NULL;

  return_list = NULL;

  mounts_hash = g_hash_table_new (g_str_hash, g_str_equal);

#ifdef HAVE_GETMNTENT_R

  while ((mntent = getmntent_r (file, &ent, buf, sizeof (buf))) != NULL)

#else

  G_LOCK (getmntent);

  while ((mntent = getmntent (file)) != NULL)

#endif

    {

      const char *device_path = NULL;

      gboolean is_read_only = FALSE;

      /* ignore any mnt_fsname that is repeated and begins with a '/'

       *

       * We do this to avoid being fooled by --bind mounts, since

       * these have the same device as the location they bind to.

       * It's not an ideal solution to the problem, but it's likely that

       * the most important mountpoint is first and the --bind ones after

       * that aren't as important. So it should work.

       *

       * The '/' is to handle procfs, tmpfs and other no device mounts.

       */

      if (mntent->mnt_fsname != NULL &&

	  mntent->mnt_fsname[0] == '/' &&

	  g_hash_table_lookup (mounts_hash, mntent->mnt_fsname))

        continue;

      if (g_strcmp0 (mntent->mnt_fsname, "/dev/root") == 0)

        device_path = _resolve_dev_root ();

      else

        device_path = mntent->mnt_fsname;

#if defined (HAVE_HASMNTOPT)

      if (hasmntopt (mntent, MNTOPT_RO) != NULL)

	is_read_only = TRUE;

#endif

      mount_entry = create_unix_mount_entry (device_path,

                                             mntent->mnt_dir,

                                             mntent->mnt_type,

                                             is_read_only);

      g_hash_table_insert (mounts_hash,

			   mount_entry->device_path,

			   mount_entry->device_path);

      return_list = g_list_prepend (return_list, mount_entry);

    }

  g_hash_table_destroy (mounts_hash);

  endmntent (file);

#ifndef HAVE_GETMNTENT_R

  G_UNLOCK (getmntent);

#endif

  return g_list_reverse (return_list);

}

#endif /* HAVE_LIBMOUNT */

static const char *

get_mtab_monitor_file (void)

{

  static const char *mountinfo_path = NULL;

#ifdef HAVE_LIBMOUNT

  struct stat buf;

#endif

  if (mountinfo_path != NULL)

    return mountinfo_path;

#ifdef HAVE_LIBMOUNT

  /* The mtab file is still used by some distros, so it has to be monitored in

   * order to avoid races between g_unix_mounts_get and "mounts-changed" signal:

   * https://bugzilla.gnome.org/show_bug.cgi?id=782814

   */

  if (mnt_has_regular_mtab (&mountinfo_path, NULL))

    {

      return mountinfo_path;

    }

  if (stat (PROC_MOUNTINFO_PATH, &buf) == 0)

    {

      mountinfo_path = PROC_MOUNTINFO_PATH;

      return mountinfo_path;

    }

#endif

#ifdef _PATH_MOUNTED

# ifdef __linux__

  mountinfo_path = "/proc/mounts";

# else

  mountinfo_path = _PATH_MOUNTED;

# endif

#else

  mountinfo_path = "/etc/mtab";

#endif

  return mountinfo_path;

}

/* mnttab.h {{{2 */

#elif defined (HAVE_SYS_MNTTAB_H)

G_LOCK_DEFINE_STATIC(getmntent);

static const char *

get_mtab_read_file (void)

{

#ifdef _PATH_MOUNTED

  return _PATH_MOUNTED;

#else	

  return "/etc/mnttab";

#endif

}

static const char *

get_mtab_monitor_file (void)

{

  return get_mtab_read_file ();

}

static GList *

_g_get_unix_mounts (void)

{

  struct mnttab mntent;

  FILE *file;

  const char *read_file;

  GUnixMountEntry *mount_entry;

  GList *return_list;

  read_file = get_mtab_read_file ();

  file = setmntent (read_file, "r");

  if (file == NULL)

    return NULL;

  return_list = NULL;

  G_LOCK (getmntent);

  while (! getmntent (file, &mntent))

    {

      gboolean is_read_only = FALSE;

#if defined (HAVE_HASMNTOPT)

      if (hasmntopt (&mntent, MNTOPT_RO) != NULL)

	is_read_only = TRUE;

#endif

      mount_entry = create_unix_mount_entry (mntent.mnt_special,

                                             mntent.mnt_mountp,

                                             mntent.mnt_fstype,

                                             is_read_only);

      return_list = g_list_prepend (return_list, mount_entry);

    }

  endmntent (file);

  G_UNLOCK (getmntent);

  return g_list_reverse (return_list);

}

/* mntctl.h (AIX) {{{2 */

#elif defined(HAVE_SYS_MNTCTL_H) && defined(HAVE_SYS_VMOUNT_H) && defined(HAVE_SYS_VFS_H)

static const char *

get_mtab_monitor_file (void)

{

  return NULL;

}

static GList *

_g_get_unix_mounts (void)

{

  struct vfs_ent *fs_info;

  struct vmount *vmount_info;

  int vmount_number;

  unsigned int vmount_size;

  int current;

  GList *return_list;

  if (mntctl (MCTL_QUERY, sizeof (vmount_size), &vmount_size) != 0)

    {

      g_warning ("Unable to know the number of mounted volumes\n");

      return NULL;

    }

  vmount_info = (struct vmount*)g_malloc (vmount_size);

  vmount_number = mntctl (MCTL_QUERY, vmount_size, vmount_info);

  if (vmount_info->vmt_revision != VMT_REVISION)

    g_warning ("Bad vmount structure revision number, want %d, got %d\n", VMT_REVISION, vmount_info->vmt_revision);

  if (vmount_number < 0)

    {

      g_warning ("Unable to recover mounted volumes information\n");

      g_free (vmount_info);

      return NULL;

    }

  return_list = NULL;

  while (vmount_number > 0)

    {

      gboolean is_read_only = FALSE;

      fs_info = getvfsbytype (vmount_info->vmt_gfstype);

      /* is_removable = (vmount_info->vmt_flags & MNT_REMOVABLE) ? 1 : 0; */

      is_read_only = (vmount_info->vmt_flags & MNT_READONLY) ? 1 : 0;

      mount_entry = create_unix_mount_entry (vmt2dataptr (vmount_info, VMT_OBJECT),

                                             vmt2dataptr (vmount_info, VMT_STUB),

                                             fs_info == NULL ? "unknown" : fs_info->vfsent_name,

                                             is_read_only);

      return_list = g_list_prepend (return_list, mount_entry);

      vmount_info = (struct vmount *)( (char*)vmount_info 

				       + vmount_info->vmt_length);

      vmount_number--;

    }

  g_free (vmount_info);

  return g_list_reverse (return_list);

}

/* sys/mount.h {{{2 */

#elif (defined(HAVE_GETVFSSTAT) || defined(HAVE_GETFSSTAT)) && defined(HAVE_FSTAB_H) && defined(HAVE_SYS_MOUNT_H)

static const char *

get_mtab_monitor_file (void)

{

  return NULL;

}

static GList *

_g_get_unix_mounts (void)

{

#if defined(USE_STATVFS)

  struct statvfs *mntent = NULL;

#elif defined(USE_STATFS)

  struct statfs *mntent = NULL;

#else

  #error statfs juggling failed

#endif

  size_t bufsize;

  int num_mounts, i;

  GUnixMountEntry *mount_entry;

  GList *return_list;

  /* Pass NOWAIT to avoid blocking trying to update NFS mounts. */

#if defined(USE_STATVFS) && defined(HAVE_GETVFSSTAT)

  num_mounts = getvfsstat (NULL, 0, ST_NOWAIT);

#elif defined(USE_STATFS) && defined(HAVE_GETFSSTAT)

  num_mounts = getfsstat (NULL, 0, MNT_NOWAIT);

#endif

  if (num_mounts == -1)

    return NULL;

  bufsize = num_mounts * sizeof (*mntent);

  mntent = g_malloc (bufsize);

#if defined(USE_STATVFS) && defined(HAVE_GETVFSSTAT)

  num_mounts = getvfsstat (mntent, bufsize, ST_NOWAIT);

#elif defined(USE_STATFS) && defined(HAVE_GETFSSTAT)

  num_mounts = getfsstat (mntent, bufsize, MNT_NOWAIT);

#endif

  if (num_mounts == -1)

    return NULL;

  return_list = NULL;

  for (i = 0; i < num_mounts; i++)

    {

      gboolean is_read_only = FALSE;

#if defined(USE_STATVFS)

      if (mntent[i].f_flag & ST_RDONLY)

#elif defined(USE_STATFS)

      if (mntent[i].f_flags & MNT_RDONLY)

#else

      #error statfs juggling failed

#endif

        is_read_only = TRUE;

      mount_entry = create_unix_mount_entry (mntent[i].f_mntfromname,

                                             mntent[i].f_mntonname,

                                             mntent[i].f_fstypename,

                                             is_read_only);

      return_list = g_list_prepend (return_list, mount_entry);

    }

  g_free (mntent);

  return g_list_reverse (return_list);

}

/* Interix {{{2 */

#elif defined(__INTERIX)

static const char *

get_mtab_monitor_file (void)

{

  return NULL;

}

static GList *

_g_get_unix_mounts (void)

{

  DIR *dirp;

  GList* return_list = NULL;

  char filename[9 + NAME_MAX];

  dirp = opendir ("/dev/fs");

  if (!dirp)

    {

      g_warning ("unable to read /dev/fs!");

      return NULL;

    }