newlib/winsup/cygwin/path.h

/* path.h: path data structures

   Copyright 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005,
   2006, 2007 Red Hat, Inc.

This file is part of Cygwin.

This software is a copyrighted work licensed under the terms of the
Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
details. */

#include "devices.h"

#include <sys/ioctl.h>
#include <fcntl.h>
#include <ntdef.h>

#define isproc_dev(devn) \
  (devn == FH_PROC || devn == FH_REGISTRY || devn == FH_PROCESS || \
   devn == FH_PROCNET)

#define isvirtual_dev(devn) \
  (isproc_dev (devn) || devn == FH_CYGDRIVE || devn == FH_NETDRIVE)

extern PUNICODE_STRING get_nt_native_path (const char *, UNICODE_STRING &);

inline bool
has_attribute (DWORD attributes, DWORD attribs_to_test)
{
  return attributes != INVALID_FILE_ATTRIBUTES
	 && (attributes & attribs_to_test);
}

enum executable_states
{
  is_executable,
  dont_care_if_executable,
  not_executable = dont_care_if_executable,
  dont_know_if_executable
};

struct suffix_info
{
  const char *name;
  int addon;
  suffix_info (const char *s, int addit = 0): name (s), addon (addit) {}
};

enum pathconv_arg
{
  PC_SYM_FOLLOW		= 0x0001,
  PC_SYM_NOFOLLOW	= 0x0002,
  PC_SYM_IGNORE		= 0x0004,
  PC_SYM_CONTENTS	= 0x0008,
  PC_NOFULL		= 0x0010,
  PC_NULLEMPTY		= 0x0020,
  PC_CHECK_EA		= 0x0040,
  PC_POSIX		= 0x0080,
  PC_NOWARN		= 0x0100,
  PC_NO_ACCESS_CHECK	= 0x00800000
};

enum case_checking
{
  PCHECK_RELAXED	= 0,
  PCHECK_ADJUST		= 1,
  PCHECK_STRICT		= 2
};

#define PC_NONULLEMPTY -1

#include "sys/mount.h"

enum path_types
{
  PATH_NOTHING		= 0,
  PATH_SYMLINK		= MOUNT_SYMLINK,
  PATH_BINARY		= MOUNT_BINARY,
  PATH_EXEC		= MOUNT_EXEC,
  PATH_NOTEXEC		= MOUNT_NOTEXEC,
  PATH_CYGWIN_EXEC	= MOUNT_CYGWIN_EXEC,
  PATH_ENC		= MOUNT_ENC,
  PATH_RO		= MOUNT_RO,
  PATH_ALL_EXEC		= (PATH_CYGWIN_EXEC | PATH_EXEC),
  PATH_NO_ACCESS_CHECK	= PC_NO_ACCESS_CHECK,
  PATH_LNK		= 0x01000000,
  PATH_TEXT		= 0x02000000,
  PATH_REP		= 0x04000000,
  PATH_HAS_SYMLINKS	= 0x10000000,
  PATH_SOCKET		= 0x40000000
};

class symlink_info;
struct fs_info
{
 private:
  int root_len;
  __ino64_t name_hash;
  struct status_flags
  {
    DWORD flags;  /* Volume flags */
    DWORD serial; /* Volume serial number */
    unsigned is_remote_drive : 1;
    unsigned has_buggy_open  : 1;
    unsigned has_ea	     : 1;
    unsigned has_acls	     : 1;
    unsigned hasgood_inode   : 1;
    unsigned drive_type      : 3;
    unsigned is_fat	     : 1;
    unsigned is_ntfs	     : 1;
    unsigned is_samba	     : 1;
    unsigned is_nfs	     : 1;
    unsigned is_netapp       : 1;
    unsigned is_cdrom	     : 1;
  } status;
 public:
  void clear ()
  {
    name_hash = 0;
    root_len = 0;
    flags () = serial () = 0;
    is_remote_drive (false);
    has_buggy_open (false);
    has_ea (false);
    has_acls (false);
    hasgood_inode (false);
    drive_type (false);
    is_fat (false);
    is_ntfs (false);
    is_samba (false);
    is_nfs (false);
    is_netapp (false);
    is_cdrom (false);
  }
  inline DWORD& flags () {return status.flags;};
  inline DWORD& serial () {return status.serial;};
  inline int length () const {return root_len;}

  IMPLEMENT_STATUS_FLAG (bool, is_remote_drive)
  IMPLEMENT_STATUS_FLAG (bool, has_buggy_open)
  IMPLEMENT_STATUS_FLAG (bool, has_ea)
  IMPLEMENT_STATUS_FLAG (bool, has_acls)
  IMPLEMENT_STATUS_FLAG (bool, hasgood_inode)
  IMPLEMENT_STATUS_FLAG (DWORD, drive_type)
  IMPLEMENT_STATUS_FLAG (bool, is_fat)
  IMPLEMENT_STATUS_FLAG (bool, is_ntfs)
  IMPLEMENT_STATUS_FLAG (bool, is_samba)
  IMPLEMENT_STATUS_FLAG (bool, is_nfs)
  IMPLEMENT_STATUS_FLAG (bool, is_netapp)
  IMPLEMENT_STATUS_FLAG (bool, is_cdrom)

  bool update (const char *);
};

class path_conv
{
  DWORD fileattr;
  fs_info fs;
  void add_ext_from_sym (symlink_info&);
 public:

  unsigned path_flags;
  char *known_suffix;
  int error;
  device dev;
  bool case_clash;

  int rootdir (char *buf) const
  {
    if (!fs.length ())
      return fs.length ();
    strncpy (buf, path, fs.length ());
    /* The length is always stored with trailing backslash.  Make sure the
       backslash is actually present in the returned path. */
    buf[fs.length () - 1] = '\\';
    buf[fs.length ()] = '\0';
    return fs.length ();
  }
  bool isremote () const {return fs.is_remote_drive ();}
  bool has_acls () const {return fs.has_acls (); }
  bool hasgood_inode () const {return fs.hasgood_inode (); }
  bool isgood_inode (__ino64_t ino) const;
  int has_symlinks () const {return path_flags & PATH_HAS_SYMLINKS;}
  int has_buggy_open () const {return fs.has_buggy_open ();}
  bool isencoded () const {return path_flags & PATH_ENC;}
  int binmode () const
  {
    if (path_flags & PATH_BINARY)
      return O_BINARY;
    if (path_flags & PATH_TEXT)
      return O_TEXT;
    return 0;
  }
  int issymlink () const {return path_flags & PATH_SYMLINK;}
  int is_lnk_symlink () const {return path_flags & PATH_LNK;}
  int is_rep_symlink () const {return path_flags & PATH_REP;}
  int isdevice () const {return dev.devn && dev.devn != FH_FS && dev.devn != FH_FIFO;}
  int isfifo () const {return dev == FH_FIFO;}
  int isspecial () const {return dev.devn && dev.devn != FH_FS;}
  int iscygdrive () const {return dev.devn == FH_CYGDRIVE;}
  int is_auto_device () const {return isdevice () && !is_fs_special ();}
  int is_fs_device () const {return isdevice () && is_fs_special ();}
  int is_fs_special () const {return dev.is_fs_special ();}
  int is_lnk_special () const {return is_fs_device () || isfifo () || is_lnk_symlink ();}
  int issocket () const {return dev.devn == FH_UNIX;}
  int iscygexec () const {return path_flags & PATH_CYGWIN_EXEC;}
  void set_cygexec (bool isset)
  {
    if (isset)
      path_flags |= PATH_CYGWIN_EXEC;
    else
      path_flags &= ~PATH_CYGWIN_EXEC;
  }
  bool isro () const {return !!(path_flags & PATH_RO);}
  bool exists () const {return fileattr != INVALID_FILE_ATTRIBUTES;}
  bool has_attribute (DWORD x) const {return exists () && (fileattr & x);}
  int isdir () const {return has_attribute (FILE_ATTRIBUTE_DIRECTORY);}
  executable_states exec_state ()
  {
    extern int _check_for_executable;
    if (path_flags & PATH_ALL_EXEC)
      return is_executable;
    if (path_flags & PATH_NOTEXEC)
      return not_executable;
    if (!_check_for_executable)
      return dont_care_if_executable;
    return dont_know_if_executable;
  }

  void set_binary () {path_flags |= PATH_BINARY;}
  void set_symlink (DWORD n) {path_flags |= PATH_SYMLINK; symlink_length = n;}
  void set_has_symlinks () {path_flags |= PATH_HAS_SYMLINKS;}
  void set_exec (int x = 1) {path_flags |= x ? PATH_EXEC : PATH_NOTEXEC;}

  void check (const char *src, unsigned opt = PC_SYM_FOLLOW,
	      const suffix_info *suffixes = NULL)  __attribute__ ((regparm(3)));

  path_conv (const device& in_dev): fileattr (INVALID_FILE_ATTRIBUTES),
     path_flags (0), known_suffix (NULL), error (0), dev (in_dev)
    {
      strcpy (path, in_dev.native);
    }

  path_conv (int, const char *src, unsigned opt = PC_SYM_FOLLOW,
	     const suffix_info *suffixes = NULL)
  {
    check (src, opt, suffixes);
  }

  path_conv (const char *src, unsigned opt = PC_SYM_FOLLOW,
	     const suffix_info *suffixes = NULL)
  {
    check (src, opt | PC_NULLEMPTY, suffixes);
  }

  path_conv (): fileattr (INVALID_FILE_ATTRIBUTES), path_flags (0),
  		known_suffix (NULL), error (0), normalized_path (NULL)
    {path[0] = '\0';}

  ~path_conv ();
  void set_name (const char *win32, const char *posix);
  inline char *get_win32 () { return path; }
  PUNICODE_STRING get_nt_native_path (UNICODE_STRING &upath);
  operator char *() {return path;}
  operator const char *() {return path;}
  operator DWORD &() {return fileattr;}
  operator int () {return fileattr; }
  char operator [](int i) const {return path[i];}
  DWORD get_devn () const {return dev.devn;}
  short get_unitn () const {return dev.minor;}
  DWORD file_attributes () const {return fileattr;}
  void file_attributes (DWORD new_attr) {fileattr = new_attr;}
  DWORD drive_type () const {return fs.drive_type ();}
  DWORD fs_flags () {return fs.flags ();}
  bool fs_has_ea () const {return fs.has_ea ();}
  bool fs_is_fat () const {return fs.is_fat ();}
  bool fs_is_ntfs () const {return fs.is_ntfs ();}
  bool fs_is_samba () const {return fs.is_samba ();}
  bool fs_is_nfs () const {return fs.is_nfs ();}
  bool fs_is_netapp () const {return fs.is_netapp ();}
  bool fs_is_cdrom () const {return fs.is_cdrom ();}
  void set_path (const char *p) {strcpy (path, p);}
  DWORD volser () { return fs.serial (); }
  void fillin (HANDLE h);
  inline size_t size ()
  {
    return (sizeof (*this) - sizeof (path)) + strlen (path) + 1 + normalized_path_size;
  }

  unsigned __stdcall ndisk_links (DWORD);
  char *normalized_path;
  size_t normalized_path_size;
  void set_normalized_path (const char *, bool) __attribute__ ((regparm (3)));
  DWORD get_symlink_length () { return symlink_length; };
 private:
  DWORD symlink_length;
  char path[CYG_MAX_PATH];
};

/* Symlink marker */
#define SYMLINK_COOKIE "!<symlink>"

/* Socket marker */
#define SOCKET_COOKIE  "!<socket >"

int __stdcall slash_unc_prefix_p (const char *path) __attribute__ ((regparm(1)));

enum fe_types
{
  FE_NADA = 0,		/* Nothing special */
  FE_NNF = 1,		/* Return NULL if not found */
  FE_NATIVE = 2,	/* Return native path in path_conv struct */
  FE_CWD = 4,		/* Search CWD for program */
  FE_DLL = 8		/* Search for DLLs, not executables. */
};
const char * __stdcall find_exec (const char *name, path_conv& buf,
				  const char *winenv = "PATH=",
				  unsigned opt = FE_NADA,
				  const char **known_suffix = NULL)
  __attribute__ ((regparm(3)));

/* Common macros for checking for invalid path names */
#define isdrive(s) (isalpha (*(s)) && (s)[1] == ':')

static inline bool
has_exec_chars (const char *buf, int len)
{
  return len >= 2 &&
	 ((buf[0] == '#' && buf[1] == '!') ||
	  (buf[0] == ':' && buf[1] == '\n') ||
	  (buf[0] == 'M' && buf[1] == 'Z'));
}

int pathmatch (const char *path1, const char *path2) __attribute__ ((regparm (2)));
int pathnmatch (const char *path1, const char *path2, int len) __attribute__ ((regparm (2)));
bool has_dot_last_component (const char *dir, bool test_dot_dot) __attribute__ ((regparm (2)));

bool fnunmunge (char *, const char *) __attribute__ ((regparm (2)));

int path_prefix_p (const char *path1, const char *path2, int len1) __attribute__ ((regparm (3)));

bool is_floppy (const char *);

/* FIXME: Move to own include file eventually */

#define MAX_ETC_FILES 2
class etc
{
  friend class dtable;
  static int curr_ix;
  static bool change_possible[MAX_ETC_FILES + 1];
  static const char *fn[MAX_ETC_FILES + 1];
  static FILETIME last_modified[MAX_ETC_FILES + 1];
  static bool dir_changed (int);
  static int init (int, const char *);
  static bool file_changed (int);
  static bool test_file_change (int);
  friend class pwdgrp;
};