/* 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>

 */

#include "config.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#include <errno.h>

#include <fcntl.h>

#if G_OS_UNIX

#include <dirent.h>

#include <unistd.h>

#endif

#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 "gfileattribute.h"

#include "glocalfile.h"

#include "glocalfileprivate.h"

#include "glocalfileinfo.h"

#include "glocalfileenumerator.h"

#include "glocalfileinputstream.h"

#include "glocalfileoutputstream.h"

#include "glocalfileiostream.h"

#include "glocalfilemonitor.h"

#include "gmountprivate.h"

#include "gunixmounts.h"

#include "gioerror.h"

#include <glib/gstdio.h>

#include <glib/gstdioprivate.h>

#include "glibintl.h"

#ifdef G_OS_UNIX

#include "glib-unix.h"

#endif

#include "glib-private.h"

#ifdef G_OS_WIN32

#include <windows.h>

#include <io.h>

#include <direct.h>

#ifndef FILE_READ_ONLY_VOLUME

#define FILE_READ_ONLY_VOLUME           0x00080000

#endif

#ifndef S_ISDIR

#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)

#endif

#ifndef S_ISLNK

#define S_ISLNK(m) (0)

#endif

#ifndef ECANCELED

#define ECANCELED 105

#endif

#endif

static void g_local_file_file_iface_init (GFileIface *iface);

static GFileAttributeInfoList *local_writable_attributes = NULL;

static /* GFileAttributeInfoList * */ gsize local_writable_namespaces = 0;

struct _GLocalFile

{

  GObject parent_instance;

  char *filename;

};

#define g_local_file_get_type _g_local_file_get_type

G_DEFINE_TYPE_WITH_CODE (GLocalFile, g_local_file, G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (G_TYPE_FILE,

						g_local_file_file_iface_init))

static char *find_mountpoint_for (const char *file, dev_t dev);

static void

g_local_file_finalize (GObject *object)

{

  GLocalFile *local;

  local = G_LOCAL_FILE (object);

  g_free (local->filename);

  G_OBJECT_CLASS (g_local_file_parent_class)->finalize (object);

}

static void

g_local_file_class_init (GLocalFileClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  GFileAttributeInfoList *list;

  gobject_class->finalize = g_local_file_finalize;

  /* Set up attribute lists */

  /* Writable attributes: */

  list = g_file_attribute_info_list_new ();

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_UNIX_MODE,

				  G_FILE_ATTRIBUTE_TYPE_UINT32,

				  G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

#ifdef G_OS_UNIX

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_UNIX_UID,

				  G_FILE_ATTRIBUTE_TYPE_UINT32,

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_UNIX_GID,

				  G_FILE_ATTRIBUTE_TYPE_UINT32,

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

#endif

#ifdef HAVE_SYMLINK

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,

				  G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,

				  0);

#endif

#ifdef HAVE_UTIMES

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_TIME_MODIFIED,

				  G_FILE_ATTRIBUTE_TYPE_UINT64,

				  G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,

				  G_FILE_ATTRIBUTE_TYPE_UINT32,

				  G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE |

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

  /* When copying, the target file is accessed. Replicating

   * the source access time does not make sense in this case.

   */

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_TIME_ACCESS,

				  G_FILE_ATTRIBUTE_TYPE_UINT64,

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

  g_file_attribute_info_list_add (list,

				  G_FILE_ATTRIBUTE_TIME_ACCESS_USEC,

				  G_FILE_ATTRIBUTE_TYPE_UINT32,

				  G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED);

#endif

  local_writable_attributes = list;

}

static void

g_local_file_init (GLocalFile *local)

{

}

const char *

_g_local_file_get_filename (GLocalFile *file)

{

  return file->filename;

}

static char *

canonicalize_filename (const char *filename)

{

  char *canon, *start, *p, *q;

  char *cwd;

  int i;

  if (!g_path_is_absolute (filename))

    {

      cwd = g_get_current_dir ();

      canon = g_build_filename (cwd, filename, NULL);

      g_free (cwd);

    }

  else

    canon = g_strdup (filename);

  start = (char *)g_path_skip_root (canon);

  if (start == NULL)

    {

      /* This shouldn't really happen, as g_get_current_dir() should

	 return an absolute pathname, but bug 573843 shows this is

	 not always happening */

      g_free (canon);

      return g_build_filename (G_DIR_SEPARATOR_S, filename, NULL);

    }

  /* POSIX allows double slashes at the start to

   * mean something special (as does windows too).

   * So, "//" != "/", but more than two slashes

   * is treated as "/".

   */

  i = 0;

  for (p = start - 1;

       (p >= canon) &&

	 G_IS_DIR_SEPARATOR (*p);

       p--)

    i++;

  if (i > 2)

    {

      i -= 1;

      start -= i;

      memmove (start, start+i, strlen (start+i)+1);

    }

  /* Make sure we're using the canonical dir separator */

  p++;

  while (p < start && G_IS_DIR_SEPARATOR (*p))

    *p++ = G_DIR_SEPARATOR;

  p = start;

  while (*p != 0)

    {

      if (p[0] == '.' && (p[1] == 0 || G_IS_DIR_SEPARATOR (p[1])))

	{

	  memmove (p, p+1, strlen (p+1)+1);

	}

      else if (p[0] == '.' && p[1] == '.' && (p[2] == 0 || G_IS_DIR_SEPARATOR (p[2])))

	{

	  q = p + 2;

	  /* Skip previous separator */

	  p = p - 2;

	  if (p < start)

	    p = start;

	  while (p > start && !G_IS_DIR_SEPARATOR (*p))

	    p--;

	  if (G_IS_DIR_SEPARATOR (*p))

	    *p++ = G_DIR_SEPARATOR;

	  memmove (p, q, strlen (q)+1);

	}

      else

	{

	  /* Skip until next separator */

	  while (*p != 0 && !G_IS_DIR_SEPARATOR (*p))

	    p++;

	  if (*p != 0)

	    {

	      /* Canonicalize one separator */

	      *p++ = G_DIR_SEPARATOR;

	    }

	}

      /* Remove additional separators */

      q = p;

      while (*q && G_IS_DIR_SEPARATOR (*q))

	q++;

      if (p != q)

	memmove (p, q, strlen (q)+1);

    }

  /* Remove trailing slashes */

  if (p > start && G_IS_DIR_SEPARATOR (*(p-1)))

    *(p-1) = 0;

  return canon;

}

GFile *

_g_local_file_new (const char *filename)

{

  GLocalFile *local;

  local = g_object_new (G_TYPE_LOCAL_FILE, NULL);

  local->filename = canonicalize_filename (filename);

  return G_FILE (local);

}

/*< internal >

 * g_local_file_new_from_dirname_and_basename:

 * @dirname: an absolute, canonical directory name

 * @basename: the name of a child inside @dirname

 *

 * Creates a #GFile from @dirname and @basename.

 *

 * This is more efficient than pasting the fields together for yourself

 * and creating a #GFile from the result, and also more efficient than

 * creating a #GFile for the dirname and using g_file_get_child().

 *

 * @dirname must be canonical, as per GLocalFile's opinion of what

 * canonical means.  This means that you should only pass strings that

 * were returned by _g_local_file_get_filename().

 *

 * Returns: a #GFile

 */

GFile *

g_local_file_new_from_dirname_and_basename (const gchar *dirname,

                                            const gchar *basename)

{

  GLocalFile *local;

  g_return_val_if_fail (dirname != NULL, NULL);

  g_return_val_if_fail (basename && basename[0] && !strchr (basename, '/'), NULL);

  local = g_object_new (G_TYPE_LOCAL_FILE, NULL);

  local->filename = g_build_filename (dirname, basename, NULL);

  return G_FILE (local);

}

static gboolean

g_local_file_is_native (GFile *file)

{

  return TRUE;

}

static gboolean

g_local_file_has_uri_scheme (GFile      *file,

			     const char *uri_scheme)

{

  return g_ascii_strcasecmp (uri_scheme, "file") == 0;

}

static char *

g_local_file_get_uri_scheme (GFile *file)

{

  return g_strdup ("file");

}

static char *

g_local_file_get_basename (GFile *file)

{

  return g_path_get_basename (G_LOCAL_FILE (file)->filename);

}

static char *

g_local_file_get_path (GFile *file)

{

  return g_strdup (G_LOCAL_FILE (file)->filename);

}

static char *

g_local_file_get_uri (GFile *file)

{

  return g_filename_to_uri (G_LOCAL_FILE (file)->filename, NULL, NULL);

}

static gboolean

get_filename_charset (const gchar **filename_charset)

{

  const gchar **charsets;

  gboolean is_utf8;

  is_utf8 = g_get_filename_charsets (&charsets);

  if (filename_charset)

    *filename_charset = charsets[0];

  return is_utf8;

}

static gboolean

name_is_valid_for_display (const char *string,

			   gboolean    is_valid_utf8)

{

  char c;

  if (!is_valid_utf8 &&

      !g_utf8_validate (string, -1, NULL))

    return FALSE;

  while ((c = *string++) != 0)

    {

      if (g_ascii_iscntrl (c))

	return FALSE;

    }

  return TRUE;

}

static char *

g_local_file_get_parse_name (GFile *file)

{

  const char *filename;

  char *parse_name;

  const gchar *charset;

  char *utf8_filename;

  char *roundtripped_filename;

  gboolean free_utf8_filename;

  gboolean is_valid_utf8;

  char *escaped_path;

  filename = G_LOCAL_FILE (file)->filename;

  if (get_filename_charset (&charset))

    {

      utf8_filename = (char *)filename;

      free_utf8_filename = FALSE;

      is_valid_utf8 = FALSE; /* Can't guarantee this */

    }

  else

    {

      utf8_filename = g_convert (filename, -1, 

				 "UTF-8", charset, NULL, NULL, NULL);

      free_utf8_filename = TRUE;

      is_valid_utf8 = TRUE;

      if (utf8_filename != NULL)

	{

	  /* Make sure we can roundtrip: */

	  roundtripped_filename = g_convert (utf8_filename, -1,

					     charset, "UTF-8", NULL, NULL, NULL);

	  if (roundtripped_filename == NULL ||

	      strcmp (filename, roundtripped_filename) != 0)

	    {

	      g_free (utf8_filename);

	      utf8_filename = NULL;

	    }

	  g_free (roundtripped_filename);

	}

    }

  if (utf8_filename != NULL &&

      name_is_valid_for_display (utf8_filename, is_valid_utf8))

    {

      if (free_utf8_filename)

	parse_name = utf8_filename;

      else

	parse_name = g_strdup (utf8_filename);

    }

  else

    {

#ifdef G_OS_WIN32

      char *dup_filename, *p, *backslash;

      /* Turn backslashes into forward slashes like

       * g_filename_to_uri() would do (but we can't use that because

       * it doesn't output IRIs).

       */

      dup_filename = g_strdup (filename);

      filename = p = dup_filename;

      while ((backslash = strchr (p, '\\')) != NULL)

	{

	  *backslash = '/';

	  p = backslash + 1;

	}

#endif

      escaped_path = g_uri_escape_string (filename,

					  G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT "/",

					  TRUE);

      parse_name = g_strconcat ("file://",

				(*escaped_path != '/') ? "/" : "",

				escaped_path,

				NULL);

      g_free (escaped_path);

#ifdef G_OS_WIN32

      g_free (dup_filename);

#endif

      if (free_utf8_filename)

	g_free (utf8_filename);

    }

  return parse_name;

}

static GFile *

g_local_file_get_parent (GFile *file)

{

  GLocalFile *local = G_LOCAL_FILE (file);

  const char *non_root;

  char *dirname;

  GFile *parent;

  /* Check for root; local->filename is guaranteed to be absolute, so

   * g_path_skip_root() should never return NULL. */

  non_root = g_path_skip_root (local->filename);

  g_assert (non_root != NULL);

  if (*non_root == 0)

    return NULL;

  dirname = g_path_get_dirname (local->filename);

  parent = _g_local_file_new (dirname);

  g_free (dirname);

  return parent;

}

static GFile *

g_local_file_dup (GFile *file)

{

  GLocalFile *local = G_LOCAL_FILE (file);

  return _g_local_file_new (local->filename);

}

static guint

g_local_file_hash (GFile *file)

{

  GLocalFile *local = G_LOCAL_FILE (file);

  return g_str_hash (local->filename);

}

static gboolean

g_local_file_equal (GFile *file1,

		    GFile *file2)

{

  GLocalFile *local1 = G_LOCAL_FILE (file1);

  GLocalFile *local2 = G_LOCAL_FILE (file2);

  return g_str_equal (local1->filename, local2->filename);

}

static const char *

match_prefix (const char *path, 

              const char *prefix)

{

  int prefix_len;

  prefix_len = strlen (prefix);

  if (strncmp (path, prefix, prefix_len) != 0)

    return NULL;

  /* Handle the case where prefix is the root, so that

   * the IS_DIR_SEPRARATOR check below works */

  if (prefix_len > 0 &&

      G_IS_DIR_SEPARATOR (prefix[prefix_len-1]))

    prefix_len--;

  return path + prefix_len;

}

static gboolean

g_local_file_prefix_matches (GFile *parent,

			     GFile *descendant)

{

  GLocalFile *parent_local = G_LOCAL_FILE (parent);

  GLocalFile *descendant_local = G_LOCAL_FILE (descendant);

  const char *remainder;

  remainder = match_prefix (descendant_local->filename, parent_local->filename);

  if (remainder != NULL && G_IS_DIR_SEPARATOR (*remainder))

    return TRUE;

  return FALSE;

}

static char *

g_local_file_get_relative_path (GFile *parent,

				GFile *descendant)

{

  GLocalFile *parent_local = G_LOCAL_FILE (parent);

  GLocalFile *descendant_local = G_LOCAL_FILE (descendant);

  const char *remainder;

  remainder = match_prefix (descendant_local->filename, parent_local->filename);

  if (remainder != NULL && G_IS_DIR_SEPARATOR (*remainder))

    return g_strdup (remainder + 1);

  return NULL;

}

static GFile *

g_local_file_resolve_relative_path (GFile      *file,

				    const char *relative_path)

{

  GLocalFile *local = G_LOCAL_FILE (file);

  char *filename;

  GFile *child;

  if (g_path_is_absolute (relative_path))

    return _g_local_file_new (relative_path);

  filename = g_build_filename (local->filename, relative_path, NULL);

  child = _g_local_file_new (filename);

  g_free (filename);

  return child;

}

static GFileEnumerator *

g_local_file_enumerate_children (GFile                *file,

				 const char           *attributes,

				 GFileQueryInfoFlags   flags,

				 GCancellable         *cancellable,

				 GError              **error)

{

  GLocalFile *local = G_LOCAL_FILE (file);

  return _g_local_file_enumerator_new (local,

				       attributes, flags,

				       cancellable, error);

}

static GFile *

g_local_file_get_child_for_display_name (GFile        *file,

					 const char   *display_name,

					 GError      **error)

{

  GFile *new_file;

  char *basename;

  basename = g_filename_from_utf8 (display_name, -1, NULL, NULL, NULL);

  if (basename == NULL)

    {

      g_set_error (error, G_IO_ERROR,

		   G_IO_ERROR_INVALID_FILENAME,

		   _("Invalid filename %s"), display_name);

      return NULL;

    }

  new_file = g_file_get_child (file, basename);

  g_free (basename);

  return new_file;

}

#if defined(USE_STATFS) && !defined(HAVE_STRUCT_STATFS_F_FSTYPENAME)

static const char *

get_fs_type (long f_type)

{

  /* filesystem ids taken from linux manpage */

  switch (f_type) 

    {

    case 0xadf5:

      return "adfs";

    case 0x5346414f:

      return "afs";

    case 0x0187:

      return "autofs";

    case 0xADFF:

      return "affs";

    case 0x62646576:

      return "bdevfs";

    case 0x42465331:

      return "befs";

    case 0x1BADFACE:

      return "bfs";

    case 0x42494e4d:

      return "binfmt_misc";

    case 0x9123683E:

      return "btrfs";

    case 0x73727279:

      return "btrfs_test_fs";

    case 0x27e0eb:

      return "cgroup";

    case 0x63677270:

      return "cgroup2";

    case 0xFF534D42:

      return "cifs";

    case 0x73757245:

      return "coda";

    case 0x012FF7B7:

      return "coh";

    case 0x62656570:

      return "configfs";

    case 0x28cd3d45:

      return "cramfs";

    case 0x64626720:

      return "debugfs";

    case 0x1373:

      return "devfs";

    case 0x1cd1:

      return "devpts";

    case 0xf15f:

      return "ecryptfs";

    case 0xde5e81e4:

      return "efivarfs";

    case 0x00414A53:

      return "efs";

    case 0x137D:

      return "ext";

    case 0xEF51:

      return "ext2";

    case 0xEF53:

      return "ext3/ext4";

    case 0xF2F52010:

      return "f2fs";

    case 0x65735546:

      return "fuse";

    case 0x65735543:

      return "fusectl";

    case 0xBAD1DEA:

      return "futexfs";

    case 0x4244:

      return "hfs";

    case 0x00c0ffee:

      return "hostfs";

    case 0xF995E849:

      return "hpfs";

    case 0x958458f6:

      return "hugetlbfs";

    case 0x9660:

      return "isofs";

    case 0x72b6:

      return "jffs2";

    case 0x3153464a:

      return "jfs";

    case 0x137F:

      return "minix";

    case 0x138F:

      return "minix2";

    case 0x2468:

      return "minix2";

    case 0x2478:

      return "minix22";

    case 0x4d5a:

      return "minix3";

    case 0x19800202:

      return "mqueue";

    case 0x4d44:

      return "msdos";

    case 0x564c:

      return "ncp";

    case 0x6969:

      return "nfs";

    case 0x3434:

      return "nilfs";

    case 0x6e736673:

      return "nsfs";

    case 0x5346544e:

      return "ntfs";

    case 0x7461636f:

      return "ocfs2";

    case 0x9fa1:

      return "openprom";

    case 0x794c7630:

      return "overlay";

    case 0x50495045:

      return "pipefs";

    case 0x9fa0:

      return "proc";

    case 0x6165676C:

      return "pstore";

    case 0x002f:

      return "qnx4";

    case 0x68191122:

      return "qnx6";

    case 0x858458f6:

      return "ramfs";

    case 0x52654973:

      return "reiserfs";

    case 0x7275:

      return "romfs";

    case 0x67596969:

      return "rpc_pipefs";

    case 0x73636673:

      return "securityfs";

    case 0xf97cff8c:

      return "selinuxfs";

    case 0x43415d53:

      return "smackfs";

    case 0x517B:

      return "smb";

    case 0x534F434B:

      return "sockfs";

    case 0x73717368:

      return "squashfs";

    case 0x62656572:

      return "sysfs";

    case 0x012FF7B6:

      return "sysv2";

    case 0x012FF7B5:

      return "sysv4";

    case 0x01021994:

      return "tmpfs";

    case 0x74726163:

      return "tracefs";

    case 0x15013346:

      return "udf";

    case 0x00011954:

      return "ufs";

    case 0x9fa2:

      return "usbdevice";

    case 0x01021997:

      return "v9fs";

    case 0xa501FCF5:

      return "vxfs";

    case 0xabba1974:

      return "xenfs";

    case 0x012FF7B4:

      return "xenix";

    case 0x58465342:

      return "xfs";

    case 0x012FD16D:

      return "xiafs";

    case 0x52345362:

      return "reiser4";

    default:

      return NULL;

    }

}

#endif

#ifndef G_OS_WIN32

G_LOCK_DEFINE_STATIC(mount_info_hash);

static GHashTable *mount_info_hash = NULL;

static guint64 mount_info_hash_cache_time = 0;

typedef enum {

  MOUNT_INFO_READONLY = 1<<0

} MountInfo;

static gboolean

device_equal (gconstpointer v1,

              gconstpointer v2)

{

  return *(dev_t *)v1 == *(dev_t *)v2;

}

static guint

device_hash (gconstpointer v)

{

  return (guint) *(dev_t *)v;

}

static void

get_mount_info (GFileInfo             *fs_info,

		const char            *path,

		GFileAttributeMatcher *matcher)

{

  GStatBuf buf;

  gboolean got_info;

  gpointer info_as_ptr;

  guint mount_info;

  char *mountpoint;

  dev_t *dev;

  GUnixMountEntry *mount;

  guint64 cache_time;

  if (g_lstat (path, &buf) != 0)

    return;

  G_LOCK (mount_info_hash);

  if (mount_info_hash == NULL)

    mount_info_hash = g_hash_table_new_full (device_hash, device_equal,

					     g_free, NULL);

  if (g_unix_mounts_changed_since (mount_info_hash_cache_time))

    g_hash_table_remove_all (mount_info_hash);

  got_info = g_hash_table_lookup_extended (mount_info_hash,