diff options
Diffstat (limited to 'winsup/cygwin/local_includes/path.h')
| -rw-r--r-- | winsup/cygwin/local_includes/path.h | 463 |
1 files changed, 463 insertions, 0 deletions
diff --git a/winsup/cygwin/local_includes/path.h b/winsup/cygwin/local_includes/path.h new file mode 100644 index 000000000..74f831e53 --- /dev/null +++ b/winsup/cygwin/local_includes/path.h @@ -0,0 +1,463 @@ +/* path.h: path data structures + +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 "mount.h" +#include "cygheap_malloc.h" +#include "nfs.h" + +#include <sys/mount.h> +#include <sys/ioctl.h> +#include <fcntl.h> +#include <alloca.h> + +extern 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) {} +}; + +extern suffix_info stat_suffixes[]; + +/* DO NOT copy any of these files into the same set of flags as the + below path_types. Ever. */ +enum pathconv_arg +{ + PC_SYM_FOLLOW = _BIT ( 0), /* follow symlinks */ + PC_SYM_NOFOLLOW = _BIT ( 1), /* don't follow symlinks (but honor + trailing slashes) */ + PC_SYM_NOFOLLOW_REP = _BIT ( 2), /* don't follow dir reparse point */ + PC_SYM_CONTENTS = _BIT ( 3), /* don't follow, return content only */ + PC_NOFULL = _BIT ( 4), /* keep relative path */ + PC_NULLEMPTY = _BIT ( 5), /* empty path is no error */ + PC_NONULLEMPTY = _BIT ( 6), /* override PC_NULLEMPTY default */ + PC_POSIX = _BIT ( 7), /* return normalized posix path */ + PC_OPEN = _BIT ( 9), /* use open semantics */ + PC_CTTY = _BIT (10), /* could later be used as ctty */ + PC_SYM_NOFOLLOW_PROCFD = _BIT (11), /* allow /proc/PID/fd redirection */ + PC_KEEP_HANDLE = _BIT (12), /* keep handle for later stat calls */ + PC_NO_ACCESS_CHECK = _BIT (13), /* helper flag for error check */ + PC_SYM_NOFOLLOW_DIR = _BIT (14), /* don't follow a trailing slash */ + PC_DONT_USE = _BIT (31) /* conversion to signed happens. */ +}; + +enum path_types +{ + PATH_CTTY = _BIT ( 0), /* could later be used as ctty */ + PATH_OPEN = _BIT ( 1), /* use open semantics */ + PATH_LNK = _BIT ( 2), /* *.lnk-type symlink */ + PATH_REP = _BIT ( 3), /* reparse point known to Cygwin */ + PATH_SYMLINK = _BIT ( 4), /* symlink understood by Cygwin */ + PATH_SOCKET = _BIT ( 5), /* AF_UNIX socket file */ + PATH_RESOLVE_PROCFD = _BIT ( 6), /* fd symlink via /proc */ + PATH_REP_NOAPI = _BIT ( 7), /* rep. point unknown to WinAPI */ + PATH_DONT_USE = _BIT (31) /* conversion to signed happens. */ +}; + +enum fetch_fh_flags +{ + FFH_LINKAT = (1 << 0), +}; + +NTSTATUS file_get_fai (HANDLE, PFILE_ALL_INFORMATION); +int check_reparse_point_target (HANDLE, bool, PREPARSE_DATA_BUFFER, + PUNICODE_STRING); + +class symlink_info; + +class path_conv_handle +{ + HANDLE hdl; + union { + FILE_ALL_INFORMATION _fai; + /* For NFS. */ + fattr3 _fattr3; + } attribs; +public: + path_conv_handle () : hdl (NULL) {} + inline void set (HANDLE h) { hdl = h; } + inline void close () + { + if (hdl) + CloseHandle (hdl); + set (NULL); + } + inline void dup (const path_conv_handle &pch) + { + if (pch.handle () + && !DuplicateHandle (GetCurrentProcess (), pch.handle (), + GetCurrentProcess (), &hdl, + 0, TRUE, DUPLICATE_SAME_ACCESS)) + hdl = NULL; + } + inline HANDLE handle () const { return hdl; } + inline PFILE_ALL_INFORMATION fai () const + { return (PFILE_ALL_INFORMATION) &attribs._fai; } + inline struct fattr3 *nfsattr () const + { return (struct fattr3 *) &attribs._fattr3; } + inline NTSTATUS get_finfo (HANDLE h, bool nfs) + { + return nfs ? nfs_fetch_fattr3 (h, nfsattr ()) : file_get_fai (h, fai ()); + } + inline ino_t get_ino (bool nfs) const + { + return nfs ? nfsattr ()->fileid + : fai ()->InternalInformation.IndexNumber.QuadPart; + } + inline DWORD get_dosattr (bool nfs) const + { + if (nfs) + return (nfsattr ()->type & 7) == NF3DIR ? FILE_ATTRIBUTE_DIRECTORY : 0; + return fai ()->BasicInformation.FileAttributes; + } +}; + +class path_conv +{ + DWORD fileattr; + ULONG caseinsensitive; + fs_info fs; + + PWCHAR wide_path; + UNICODE_STRING uni_path; + DWORD symlink_length; + const char *path; + uint32_t mount_flags; + uint32_t path_flags; + const char *suffix; + const char *posix_path; + path_conv_handle conv_handle; + + void add_ext_from_sym (symlink_info&); + char *modifiable_path () {return (char *) path;} + + public: + int error; + device dev; + + void *serialize (HANDLE, unsigned int &) const; + HANDLE deserialize (void *); + + const char *known_suffix () { return suffix; } + bool isremote () const {return fs.is_remote_drive ();} + ULONG objcaseinsensitive () const {return caseinsensitive;} + bool has_acls () const {return !(mount_flags & MOUNT_NOACL) + && fs.has_acls (); } + bool hasgood_inode () const {return !(mount_flags & MOUNT_IHASH); } + bool isgood_inode (ino_t ino) const; + bool support_sparse () const + { + return (mount_flags & MOUNT_SPARSE) + && (fs_flags () & FILE_SUPPORTS_SPARSE_FILES); + } + int has_dos_filenames_only () const {return mount_flags & MOUNT_DOS;} + int has_buggy_reopen () const {return fs.has_buggy_reopen ();} + int has_buggy_fileid_dirinfo () const {return fs.has_buggy_fileid_dirinfo ();} + int has_buggy_basic_info () const {return fs.has_buggy_basic_info ();} + int binmode () const + { + return (mount_flags & MOUNT_TEXT) ? O_TEXT : O_BINARY; + } + int issymlink () const {return path_flags & PATH_SYMLINK;} + int is_lnk_symlink () const {return path_flags & PATH_LNK;} + /* This indicates any known reparse point */ + int is_known_reparse_point () const {return path_flags & PATH_REP;} + /* This indicates any known reparse point, handled sanely by WinAPI. + The difference is crucial: WSL symlinks, for instance, are known + reparse points, so we want to open them as reparse points usually. + However they are foreign to WinAPI and not handled sanely. If one + is part of $PATH, WinAPI functions may fail under the hood with + STATUS_IO_REPARSE_TAG_NOT_HANDLED. */ + int is_winapi_reparse_point () const + { + return (path_flags & (PATH_REP | PATH_REP_NOAPI)) == PATH_REP; + } + int isdevice () const {return dev.not_device (FH_FS) && dev.not_device (FH_FIFO);} + int isfifo () const {return dev.is_device (FH_FIFO);} + int isspecial () const {return dev.not_device (FH_FS);} + int iscygdrive () const {return dev.is_device (FH_CYGDRIVE);} + int is_fs_special () const {return dev.is_fs_special ();} + + int is_lnk_special () const {return (isdevice () && is_fs_special () + && !issocket ()) + || isfifo () || is_lnk_symlink ();} +#ifdef __WITH_AF_UNIX + int issocket () const {return dev.is_device (FH_LOCAL) + || dev.is_device (FH_UNIX);} +#else + int issocket () const {return dev.is_device (FH_LOCAL);} +#endif /* __WITH_AF_UNIX */ + int iscygexec () const {return mount_flags & MOUNT_CYGWIN_EXEC;} + int isopen () const {return path_flags & PATH_OPEN;} + int isctty_capable () const {return path_flags & PATH_CTTY;} + int follow_fd_symlink () const {return path_flags & PATH_RESOLVE_PROCFD;} + void set_cygexec (bool isset) + { + if (isset) + mount_flags |= MOUNT_CYGWIN_EXEC; + else + mount_flags &= ~MOUNT_CYGWIN_EXEC; + } + void set_cygexec (void *target) + { + if (target) + mount_flags |= MOUNT_CYGWIN_EXEC; + else + mount_flags &= ~MOUNT_CYGWIN_EXEC; + } + bool isro () const {return !!(mount_flags & MOUNT_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 (mount_flags & (MOUNT_CYGWIN_EXEC | MOUNT_EXEC)) + return is_executable; + if (mount_flags & MOUNT_NOTEXEC) + return not_executable; + if (!_check_for_executable) + return dont_care_if_executable; + return dont_know_if_executable; + } + + void set_symlink (DWORD n) {path_flags |= PATH_SYMLINK; symlink_length = n;} + void set_exec (int x = 1) {mount_flags |= x ? MOUNT_EXEC : MOUNT_NOTEXEC;} + + void check (const UNICODE_STRING *upath, uint32_t opt = PC_SYM_FOLLOW, + const suffix_info *suffixes = NULL); + void check (const char *src, uint32_t opt = PC_SYM_FOLLOW, + const suffix_info *suffixes = NULL); + + path_conv (const device& in_dev) + : fileattr (INVALID_FILE_ATTRIBUTES), wide_path (NULL), path (NULL), + mount_flags (0), path_flags (0), suffix (NULL), posix_path (NULL), + error (0), dev (in_dev) + { + set_path (in_dev.native ()); + } + + path_conv (const UNICODE_STRING *src, uint32_t opt = PC_SYM_FOLLOW, + const suffix_info *suffixes = NULL) + : fileattr (INVALID_FILE_ATTRIBUTES), wide_path (NULL), path (NULL), + mount_flags (0), path_flags (0), suffix (NULL), posix_path (NULL), error (0) + { + check (src, opt | ((opt & PC_NONULLEMPTY) ? 0 : PC_NULLEMPTY), suffixes); + } + + path_conv (const char *src, uint32_t opt = PC_SYM_FOLLOW, + const suffix_info *suffixes = NULL) + : fileattr (INVALID_FILE_ATTRIBUTES), wide_path (NULL), path (NULL), + mount_flags (0), path_flags (0), suffix (NULL), posix_path (NULL), error (0) + { + check (src, opt | ((opt & PC_NONULLEMPTY) ? 0 : PC_NULLEMPTY), suffixes); + } + + path_conv () + : fileattr (INVALID_FILE_ATTRIBUTES), wide_path (NULL), path (NULL), + mount_flags (0), path_flags (0), suffix (NULL), posix_path (NULL), error (0) + {} + + ~path_conv (); + inline const char *get_win32 () const { return path; } + void set_nt_native_path (PUNICODE_STRING); + PUNICODE_STRING get_nt_native_path (PUNICODE_STRING = NULL); + inline POBJECT_ATTRIBUTES get_object_attr (OBJECT_ATTRIBUTES &attr, + SECURITY_ATTRIBUTES &sa) + { + if (!get_nt_native_path ()) + return NULL; + InitializeObjectAttributes (&attr, &uni_path, + objcaseinsensitive () + | (sa.bInheritHandle ? OBJ_INHERIT : 0), + NULL, sa.lpSecurityDescriptor); + return &attr; + } + inline POBJECT_ATTRIBUTES init_reopen_attr (OBJECT_ATTRIBUTES &attr, HANDLE h) + { + if (has_buggy_reopen ()) + InitializeObjectAttributes (&attr, get_nt_native_path (), + objcaseinsensitive (), NULL, NULL) + else + InitializeObjectAttributes (&attr, &ro_u_empty, objcaseinsensitive (), + h, NULL); + return &attr; + } + inline size_t get_wide_win32_path_len () + { + get_nt_native_path (); + return uni_path.Length / sizeof (WCHAR); + } + + PWCHAR get_wide_win32_path (PWCHAR wc); + operator DWORD &() {return fileattr;} + operator int () {return fileattr; } +# define cfree_and_null(x) \ + if (x) \ + { \ + cfree ((void *) (x)); \ + (x) = NULL; \ + } + void free_strings () + { + cfree_and_null (path); + cfree_and_null (posix_path); + cfree_and_null (wide_path); + } + path_conv& eq_worker (const path_conv& pc, const char *in_path) + { + free_strings (); + memcpy ((void *) this, &pc, sizeof pc); + /* The device info might contain pointers to allocated strings, in + contrast to statically allocated strings. Calling device::dup() + will duplicate the string if the source was allocated. */ + dev.dup (); + if (in_path) + path = cstrdup (in_path); + conv_handle.dup (pc.conv_handle); + if (pc.posix_path) + posix_path = cstrdup(pc.posix_path); + if (pc.wide_path) + { + wide_path = cwcsdup (uni_path.Buffer); + if (!wide_path) + api_fatal ("cwcsdup would have returned NULL"); + uni_path.Buffer = wide_path; + } + return *this; + } + + path_conv &operator << (const path_conv& pc) + { + const char *save_path; + + if (!path) + save_path = pc.path; + else + { + save_path = (char *) alloca (strlen (path) + 1); + strcpy ((char *) save_path, path); + } + return eq_worker (pc, save_path); + } + + path_conv &operator =(const path_conv& pc) + { + return eq_worker (pc, pc.path); + } + dev_t get_device () {return dev.get_device ();} + DWORD file_attributes () const {return fileattr;} + void file_attributes (DWORD new_attr) {fileattr = new_attr;} + DWORD fs_flags () const {return fs.flags ();} + DWORD fs_name_len () const {return fs.name_len ();} + bool fs_got_fs () const { return fs.got_fs (); } + bool fs_is_fat () const {return fs.is_fat ();} + bool fs_is_exfat () const {return fs.is_exfat ();} + bool fs_is_any_fat () const {return fs.is_fat () || fs.is_exfat ();} + bool fs_is_ntfs () const {return fs.is_ntfs ();} + bool fs_is_refs () const {return fs.is_refs ();} + 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 ();} + bool fs_is_mvfs () const {return fs.is_mvfs ();} + bool fs_is_cifs () const {return fs.is_cifs ();} + bool fs_is_nwfs () const {return fs.is_nwfs ();} + bool fs_is_ncfsd () const {return fs.is_ncfsd ();} + bool fs_is_afs () const {return fs.is_afs ();} + bool fs_is_prlfs () const {return fs.is_prlfs ();} + fs_info_type fs_type () const {return fs.what_fs ();} + ULONG fs_serial_number () const {return fs.serial_number ();} + inline const char *set_path (const char *p) + { + if (path) + cfree (modifiable_path ()); + char *new_path = (char *) cmalloc_abort (HEAP_STR, strlen (p) + 7); + strcpy (new_path, p); + return path = new_path; + } + bool is_binary (); + + HANDLE handle () const { return conv_handle.handle (); } + PFILE_ALL_INFORMATION fai () { return conv_handle.fai (); } + struct fattr3 *nfsattr () { return conv_handle.nfsattr (); } + inline NTSTATUS get_finfo (HANDLE h) + { + return conv_handle.get_finfo (h, fs.is_nfs ()); + } + inline ino_t get_ino () const { return conv_handle.get_ino (fs.is_nfs ()); } + void close_conv_handle () { conv_handle.close (); } + + ino_t get_ino_by_handle (HANDLE h); + inline const char *get_posix () const { return posix_path; } + void set_posix (const char *); + DWORD get_symlink_length () { return symlink_length; }; +}; + +/* Symlink marker */ +#define SYMLINK_COOKIE "!<symlink>" + +/* Socket marker */ +#define SOCKET_COOKIE "!<socket >" + +/* Interix symlink marker */ +#define INTERIX_SYMLINK_COOKIE "IntxLNK\1" + +enum fe_types +{ + FE_NADA = 0, /* Nothing special */ + FE_NNF = 1, /* Return NULL if not found */ + FE_CWD = 4, /* Search CWD for program */ + FE_DLL = 8 /* Search for DLLs, not executables. */ +}; +const char *find_exec (const char *name, path_conv& buf, + const char *search = "PATH", + unsigned opt = FE_NADA, + const char **known_suffix = NULL); + +/* Common macros for checking for invalid path names */ +#define isdrive(s) (isalpha (*(s)) && (s)[1] == ':') +#define iswdrive(s) (iswalpha (*(s)) && (s)[1] == L':') + +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, bool caseinsensitive); +int pathnmatch (const char *path1, const char *path2, int len, bool caseinsensitive); +bool has_dot_last_component (const char *dir, bool test_dot_dot); + +int path_prefix_p (const char *path1, const char *path2, int len1, + bool caseinsensitive); + +int normalize_win32_path (const char *, char *, char *&); +int normalize_posix_path (const char *, char *, char *&); +PUNICODE_STRING get_nt_native_path (const char *, UNICODE_STRING&, bool); + +int symlink_worker (const char *, path_conv &, bool); |