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

 */

#include "config.h"

#include <glib.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#ifdef G_OS_UNIX

#include <grp.h>

#include <pwd.h>

#endif

#ifdef HAVE_SELINUX

#include <selinux/selinux.h>

#endif

#ifdef HAVE_XATTR

#if defined HAVE_SYS_XATTR_H

  #include <sys/xattr.h>

#elif defined HAVE_ATTR_XATTR_H

  #include <attr/xattr.h>

#else

  #error "Neither <sys/xattr.h> nor <attr/xattr.h> is present but extended attribute support is enabled."

#endif /* defined HAVE_SYS_XATTR_H || HAVE_ATTR_XATTR_H */

#endif /* HAVE_XATTR */

#include <glib/gstdio.h>

#include <glib/gstdioprivate.h>

#include <gfileattribute-priv.h>

#include <gfileinfo-priv.h>

#include <gvfs.h>

#ifdef G_OS_UNIX

#include <unistd.h>

#include "glib-unix.h"

#endif

#include "glib-private.h"

#include "thumbnail-verify.h"

#ifdef G_OS_WIN32

#include <windows.h>

#include <io.h>

#ifndef W_OK

#define W_OK 2

#endif

#ifndef R_OK

#define R_OK 4

#endif

#ifndef X_OK

#define X_OK 0 /* not really */

#endif

#ifndef S_ISREG

#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)

#endif

#ifndef S_ISDIR

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

#endif

#ifndef S_IXUSR

#define S_IXUSR _S_IEXEC

#endif

#endif

#include "glocalfileinfo.h"

#include "gioerror.h"

#include "gthemedicon.h"

#include "gcontenttypeprivate.h"

#include "glibintl.h"

struct ThumbMD5Context {

	guint32 buf[4];

	guint32 bits[2];

	unsigned char in[64];

};

#ifndef G_OS_WIN32

typedef struct {

  char *user_name;

  char *real_name;

} UidData;

G_LOCK_DEFINE_STATIC (uid_cache);

static GHashTable *uid_cache = NULL;

G_LOCK_DEFINE_STATIC (gid_cache);

static GHashTable *gid_cache = NULL;

#endif  /* !G_OS_WIN32 */

char *

_g_local_file_info_create_etag (GLocalFileStat *statbuf)

{

  glong sec, usec;

  sec = statbuf->st_mtime;

#if defined (HAVE_STRUCT_STAT_ST_MTIMENSEC)

  usec = statbuf->st_mtimensec / 1000;

#elif defined (HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)

  usec = statbuf->st_mtim.tv_nsec / 1000;

#else

  usec = 0;

#endif

  return g_strdup_printf ("%lu:%lu", sec, usec);

}

static char *

_g_local_file_info_create_file_id (GLocalFileStat *statbuf)

{

  guint64 ino;

#ifdef G_OS_WIN32

  ino = statbuf->file_index;

#else

  ino = statbuf->st_ino;

#endif

  return g_strdup_printf ("l%" G_GUINT64_FORMAT ":%" G_GUINT64_FORMAT,

			  (guint64) statbuf->st_dev, 

			  ino);

}

static char *

_g_local_file_info_create_fs_id (GLocalFileStat *statbuf)

{

  return g_strdup_printf ("l%" G_GUINT64_FORMAT,

			  (guint64) statbuf->st_dev);

}

#if defined (S_ISLNK) || defined (G_OS_WIN32)

static gchar *

read_link (const gchar *full_name)

{

#if defined (HAVE_READLINK) || defined (G_OS_WIN32)

  gchar *buffer;

  guint size;

  size = 256;

  buffer = g_malloc (size);

  while (1)

    {

      int read_size;

#ifndef G_OS_WIN32

      read_size = readlink (full_name, buffer, size);

#else

      read_size = GLIB_PRIVATE_CALL (g_win32_readlink_utf8) (full_name, buffer, size);

#endif

      if (read_size < 0)

	{

	  g_free (buffer);

	  return NULL;

	}

      if (read_size < size)

	{

	  buffer[read_size] = 0;

	  return buffer;

	}

      size *= 2;

      buffer = g_realloc (buffer, size);

    }

#else

  return NULL;

#endif

}

#endif  /* S_ISLNK || G_OS_WIN32 */

#ifdef HAVE_SELINUX

/* Get the SELinux security context */

static void

get_selinux_context (const char            *path,

		     GFileInfo             *info,

		     GFileAttributeMatcher *attribute_matcher,

		     gboolean               follow_symlinks)

{

  char *context;

  if (!_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT))

    return;

  if (is_selinux_enabled ())

    {

      if (follow_symlinks)

	{

	  if (lgetfilecon_raw (path, &context) < 0)

	    return;

	}

      else

	{

	  if (getfilecon_raw (path, &context) < 0)

	    return;

	}

      if (context)

	{

	  _g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT, context);

	  freecon (context);

	}

    }

}

#endif

#ifdef HAVE_XATTR

/* Wrappers to hide away differences between (Linux) getxattr/lgetxattr and

 * (Mac) getxattr(..., XATTR_NOFOLLOW)

 */

#ifdef HAVE_XATTR_NOFOLLOW

#define g_fgetxattr(fd,name,value,size)  fgetxattr(fd,name,value,size,0,0)

#define g_flistxattr(fd,name,size)       flistxattr(fd,name,size,0)

#define g_setxattr(path,name,value,size) setxattr(path,name,value,size,0,0)

#else

#define g_fgetxattr     fgetxattr

#define g_flistxattr    flistxattr

#define g_setxattr(path,name,value,size) setxattr(path,name,value,size,0)

#endif

static gssize

g_getxattr (const char *path, const char *name, void *value, size_t size,

            gboolean follow_symlinks)

{

#ifdef HAVE_XATTR_NOFOLLOW

  return getxattr (path, name, value, size, 0, follow_symlinks ? 0 : XATTR_NOFOLLOW);

#else

  if (follow_symlinks)

    return getxattr (path, name, value, size);

  else

    return lgetxattr (path, name, value, size);

#endif

}

static gssize

g_listxattr(const char *path, char *namebuf, size_t size,

            gboolean follow_symlinks)

{

#ifdef HAVE_XATTR_NOFOLLOW

  return listxattr (path, namebuf, size, follow_symlinks ? 0 : XATTR_NOFOLLOW);

#else

  if (follow_symlinks)

    return listxattr (path, namebuf, size);

  else

    return llistxattr (path, namebuf, size);

#endif

}

static gboolean

valid_char (char c)

{

  return c >= 32 && c <= 126 && c != '\\';

}

static gboolean

name_is_valid (const char *str)

{

  while (*str)

    {

      if (!valid_char (*str++))

	return FALSE;

    }

  return TRUE;

}

static char *

hex_escape_string (const char *str, 

                   gboolean   *free_return)

{

  int num_invalid, i;

  char *escaped_str, *p;

  unsigned char c;

  static char *hex_digits = "0123456789abcdef";

  int len;

  len = strlen (str);

  num_invalid = 0;

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

    {

      if (!valid_char (str[i]))

	num_invalid++;

    }

  if (num_invalid == 0)

    {

      *free_return = FALSE;

      return (char *)str;

    }

  escaped_str = g_malloc (len + num_invalid*3 + 1);

  p = escaped_str;

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

    {

      if (valid_char (str[i]))

	*p++ = str[i];

      else

	{

	  c = str[i];

	  *p++ = '\\';

	  *p++ = 'x';

	  *p++ = hex_digits[(c >> 4) & 0xf];

	  *p++ = hex_digits[c & 0xf];

	}

    }

  *p = 0;

  *free_return = TRUE;

  return escaped_str;

}

static char *

hex_unescape_string (const char *str, 

                     int        *out_len, 

                     gboolean   *free_return)

{

  int i;

  char *unescaped_str, *p;

  unsigned char c;

  int len;

  len = strlen (str);

  if (strchr (str, '\\') == NULL)

    {

      if (out_len)

	*out_len = len;

      *free_return = FALSE;

      return (char *)str;

    }

  unescaped_str = g_malloc (len + 1);

  p = unescaped_str;

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

    {

      if (str[i] == '\\' &&

	  str[i+1] == 'x' &&

	  len - i >= 4)

	{

	  c =

	    (g_ascii_xdigit_value (str[i+2]) << 4) |

	    g_ascii_xdigit_value (str[i+3]);

	  *p++ = c;

	  i += 3;

	}

      else

	*p++ = str[i];

    }

  *p++ = 0;

  if (out_len)

    *out_len = p - unescaped_str;

  *free_return = TRUE;

  return unescaped_str;

}

static void

escape_xattr (GFileInfo  *info,

	      const char *gio_attr, /* gio attribute name */

	      const char *value, /* Is zero terminated */

	      size_t      len /* not including zero termination */)

{

  char *escaped_val;

  gboolean free_escaped_val;

  escaped_val = hex_escape_string (value, &free_escaped_val);

  g_file_info_set_attribute_string (info, gio_attr, escaped_val);

  if (free_escaped_val)

    g_free (escaped_val);

}

static void

get_one_xattr (const char *path,

	       GFileInfo  *info,

	       const char *gio_attr,

	       const char *xattr,

	       gboolean    follow_symlinks)

{

  char value[64];

  char *value_p;

  gssize len;

  int errsv;

  len = g_getxattr (path, xattr, value, sizeof (value)-1, follow_symlinks);

  errsv = errno;

  value_p = NULL;

  if (len >= 0)

    value_p = value;

  else if (len == -1 && errsv == ERANGE)

    {

      len = g_getxattr (path, xattr, NULL, 0, follow_symlinks);

      if (len < 0)

	return;

      value_p = g_malloc (len+1);

      len = g_getxattr (path, xattr, value_p, len, follow_symlinks);

      if (len < 0)

	{

	  g_free (value_p);

	  return;

	}

    }

  else

    return;

  /* Null terminate */

  value_p[len] = 0;

  escape_xattr (info, gio_attr, value_p, len);

  if (value_p != value)

    g_free (value_p);

}

#endif /* defined HAVE_XATTR */

static void

get_xattrs (const char            *path,

	    gboolean               user,

	    GFileInfo             *info,

	    GFileAttributeMatcher *matcher,

	    gboolean               follow_symlinks)

{

#ifdef HAVE_XATTR

  gboolean all;

  gsize list_size;

  gssize list_res_size;

  size_t len;

  char *list;

  const char *attr, *attr2;

  if (user)

    all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr");

  else

    all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr-sys");

  if (all)

    {

      int errsv;

      list_res_size = g_listxattr (path, NULL, 0, follow_symlinks);

      if (list_res_size == -1 ||

	  list_res_size == 0)

	return;

      list_size = list_res_size;

      list = g_malloc (list_size);

    retry:

      list_res_size = g_listxattr (path, list, list_size, follow_symlinks);

      errsv = errno;

      if (list_res_size == -1 && errsv == ERANGE)

	{

	  list_size = list_size * 2;

	  list = g_realloc (list, list_size);

	  goto retry;

	}

      if (list_res_size == -1)

	return;

      attr = list;

      while (list_res_size > 0)

	{

	  if ((user && g_str_has_prefix (attr, "user.")) ||

	      (!user && !g_str_has_prefix (attr, "user.")))

	    {

	      char *escaped_attr, *gio_attr;

	      gboolean free_escaped_attr;

	      if (user)

		{

		  escaped_attr = hex_escape_string (attr + 5, &free_escaped_attr);

		  gio_attr = g_strconcat ("xattr::", escaped_attr, NULL);

		}

	      else

		{

		  escaped_attr = hex_escape_string (attr, &free_escaped_attr);

		  gio_attr = g_strconcat ("xattr-sys::", escaped_attr, NULL);

		}

	      if (free_escaped_attr)

		g_free (escaped_attr);

	      get_one_xattr (path, info, gio_attr, attr, follow_symlinks);

	      g_free (gio_attr);

	    }

	  len = strlen (attr) + 1;

	  attr += len;

	  list_res_size -= len;

	}

      g_free (list);

    }

  else

    {

      while ((attr = g_file_attribute_matcher_enumerate_next (matcher)) != NULL)

	{

	  char *unescaped_attribute, *a;

	  gboolean free_unescaped_attribute;

	  attr2 = strchr (attr, ':');

	  if (attr2)

	    {

	      attr2 += 2; /* Skip '::' */

	      unescaped_attribute = hex_unescape_string (attr2, NULL, &free_unescaped_attribute);

	      if (user)

		a = g_strconcat ("user.", unescaped_attribute, NULL);

	      else

		a = unescaped_attribute;

	      get_one_xattr (path, info, attr, a, follow_symlinks);

	      if (user)

		g_free (a);

	      if (free_unescaped_attribute)

		g_free (unescaped_attribute);

	    }

	}

    }

#endif /* defined HAVE_XATTR */

}

#ifdef HAVE_XATTR

static void

get_one_xattr_from_fd (int         fd,

		       GFileInfo  *info,

		       const char *gio_attr,

		       const char *xattr)

{

  char value[64];

  char *value_p;

  gssize len;

  int errsv;

  len = g_fgetxattr (fd, xattr, value, sizeof (value) - 1);

  errsv = errno;

  value_p = NULL;

  if (len >= 0)

    value_p = value;

  else if (len == -1 && errsv == ERANGE)

    {

      len = g_fgetxattr (fd, xattr, NULL, 0);

      if (len < 0)

	return;

      value_p = g_malloc (len + 1);

      len = g_fgetxattr (fd, xattr, value_p, len);

      if (len < 0)

	{

	  g_free (value_p);

	  return;

	}

    }

  else

    return;

  /* Null terminate */

  value_p[len] = 0;

  escape_xattr (info, gio_attr, value_p, len);

  if (value_p != value)

    g_free (value_p);

}

#endif /* defined HAVE_XATTR */

static void

get_xattrs_from_fd (int                    fd,

		    gboolean               user,

		    GFileInfo             *info,

		    GFileAttributeMatcher *matcher)

{

#ifdef HAVE_XATTR

  gboolean all;

  gsize list_size;

  gssize list_res_size;

  size_t len;

  char *list;

  const char *attr, *attr2;

  if (user)

    all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr");

  else

    all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr-sys");

  if (all)

    {

      int errsv;

      list_res_size = g_flistxattr (fd, NULL, 0);

      if (list_res_size == -1 ||

	  list_res_size == 0)

	return;

      list_size = list_res_size;

      list = g_malloc (list_size);

    retry:

      list_res_size = g_flistxattr (fd, list, list_size);

      errsv = errno;

      if (list_res_size == -1 && errsv == ERANGE)

	{

	  list_size = list_size * 2;

	  list = g_realloc (list, list_size);

	  goto retry;

	}

      if (list_res_size == -1)

        {

          g_free (list);

          return;

        }

      attr = list;

      while (list_res_size > 0)

	{

	  if ((user && g_str_has_prefix (attr, "user.")) ||

	      (!user && !g_str_has_prefix (attr, "user.")))

	    {

	      char *escaped_attr, *gio_attr;

	      gboolean free_escaped_attr;

	      if (user)

		{

		  escaped_attr = hex_escape_string (attr + 5, &free_escaped_attr);

		  gio_attr = g_strconcat ("xattr::", escaped_attr, NULL);

		}

	      else

		{

		  escaped_attr = hex_escape_string (attr, &free_escaped_attr);

		  gio_attr = g_strconcat ("xattr-sys::", escaped_attr, NULL);

		}

	      if (free_escaped_attr)

		g_free (escaped_attr);

	      get_one_xattr_from_fd (fd, info, gio_attr, attr);

	      g_free (gio_attr);

	    }

	  len = strlen (attr) + 1;

	  attr += len;

	  list_res_size -= len;

	}

      g_free (list);

    }

  else

    {

      while ((attr = g_file_attribute_matcher_enumerate_next (matcher)) != NULL)

	{

	  char *unescaped_attribute, *a;

	  gboolean free_unescaped_attribute;

	  attr2 = strchr (attr, ':');

	  if (attr2)

	    {

	      attr2++; /* Skip ':' */

	      unescaped_attribute = hex_unescape_string (attr2, NULL, &free_unescaped_attribute);

	      if (user)

		a = g_strconcat ("user.", unescaped_attribute, NULL);

	      else

		a = unescaped_attribute;

	      get_one_xattr_from_fd (fd, info, attr, a);

	      if (user)

		g_free (a);

	      if (free_unescaped_attribute)

		g_free (unescaped_attribute);

	    }

	}

    }

#endif /* defined HAVE_XATTR */

}

#ifdef HAVE_XATTR

static gboolean

set_xattr (char                       *filename,

	   const char                 *escaped_attribute,

	   const GFileAttributeValue  *attr_value,

	   GError                    **error)

{

  char *attribute, *value;

  gboolean free_attribute, free_value;

  int val_len, res, errsv;

  gboolean is_user;

  char *a;

  if (attr_value == NULL)

    {

      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,

                           _("Attribute value must be non-NULL"));

      return FALSE;

    }

  if (attr_value->type != G_FILE_ATTRIBUTE_TYPE_STRING)

    {

      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,

                           _("Invalid attribute type (string expected)"));

      return FALSE;

    }

  if (!name_is_valid (escaped_attribute))

    {

      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,

                           _("Invalid extended attribute name"));

      return FALSE;

    }

  if (g_str_has_prefix (escaped_attribute, "xattr::"))

    {

      escaped_attribute += strlen ("xattr::");

      is_user = TRUE;

    }

  else

    {

      g_warn_if_fail (g_str_has_prefix (escaped_attribute, "xattr-sys::"));

      escaped_attribute += strlen ("xattr-sys::");

      is_user = FALSE;

    }

  attribute = hex_unescape_string (escaped_attribute, NULL, &free_attribute);

  value = hex_unescape_string (attr_value->u.string, &val_len, &free_value);

  if (is_user)

    a = g_strconcat ("user.", attribute, NULL);

  else

    a = attribute;

  res = g_setxattr (filename, a, value, val_len);

  errsv = errno;

  if (is_user)

    g_free (a);

  if (free_attribute)

    g_free (attribute);

  if (free_value)

    g_free (value);

  if (res == -1)

    {

      g_set_error (error, G_IO_ERROR,

		   g_io_error_from_errno (errsv),

		   _("Error setting extended attribute “%s”: %s"),

		   escaped_attribute, g_strerror (errsv));

      return FALSE;

    }

  return TRUE;

}

#endif

void

_g_local_file_info_get_parent_info (const char            *dir,

				    GFileAttributeMatcher *attribute_matcher,

				    GLocalParentFileInfo  *parent_info)

{

  GStatBuf statbuf;

  int res;

  parent_info->extra_data = NULL;

  parent_info->free_extra_data = NULL;

  parent_info->writable = FALSE;

  parent_info->is_sticky = FALSE;

  parent_info->has_trash_dir = FALSE;

  parent_info->device = 0;

  if (_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME) ||

      _g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE) ||

      _g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH) ||

      _g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_UNIX_IS_MOUNTPOINT))

    {

      /* FIXME: Windows: The underlying _waccess() call in the C

       * library is mostly pointless as it only looks at the READONLY

       * FAT-style attribute of the file, it doesn't check the ACL at

       * all.

       */

      parent_info->writable = (g_access (dir, W_OK) == 0);

      res = g_stat (dir, &statbuf);

      /*

       * The sticky bit (S_ISVTX) on a directory means that a file in that directory can be

       * renamed or deleted only by the owner of the file, by the owner of the directory, and

       * by a privileged process.

       */

      if (res == 0)

	{

#ifdef S_ISVTX

	  parent_info->is_sticky = (statbuf.st_mode & S_ISVTX) != 0;

#else

	  parent_info->is_sticky = FALSE;

#endif

	  parent_info->owner = statbuf.st_uid;

	  parent_info->device = statbuf.st_dev;

          /* No need to find trash dir if it's not writable anyway */

          if (parent_info->writable &&

              _g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH))

            parent_info->has_trash_dir = _g_local_file_has_trash_dir (dir, statbuf.st_dev);

	}

    }

}

void

_g_local_file_info_free_parent_info (GLocalParentFileInfo *parent_info)

{

  if (parent_info->extra_data &&

      parent_info->free_extra_data)

    parent_info->free_extra_data (parent_info->extra_data);

}

static void

get_access_rights (GFileAttributeMatcher *attribute_matcher,

		   GFileInfo             *info,

		   const gchar           *path,

		   GLocalFileStat        *statbuf,

		   GLocalParentFileInfo  *parent_info)

{

  /* FIXME: Windows: The underlyin _waccess() is mostly pointless */

  if (_g_file_attribute_matcher_matches_id (attribute_matcher,

					    G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ))

    _g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ,

				             g_access (path, R_OK) == 0);