2008-11-27 01:21:04 +08:00
|
|
|
/* path.cc: path support.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
2009-01-03 13:12:22 +08:00
|
|
|
2006, 2007, 2008, 2009 Red Hat, Inc.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
This file is part of Cygwin.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
|
|
details. */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
/* This module's job is to
|
|
|
|
- convert between POSIX and Win32 style filenames,
|
|
|
|
- support the `mount' functionality,
|
|
|
|
- support symlinks for files and directories
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Pathnames are handled as follows:
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
- A \ or : in a path denotes a pure windows spec.
|
|
|
|
- Paths beginning with // (or \\) are not translated (i.e. looked
|
|
|
|
up in the mount table) and are assumed to be UNC path names.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
The goal in the above set of rules is to allow both POSIX and Win32
|
|
|
|
flavors of pathnames without either interfering. The rules are
|
|
|
|
intended to be as close to a superset of both as possible.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Note that you can have more than one path to a file. The mount
|
|
|
|
table is always prefered when translating Win32 paths to POSIX
|
|
|
|
paths. Win32 paths in mount table entries may be UNC paths or
|
|
|
|
standard Win32 paths starting with <drive-letter>:
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Text vs Binary issues are not considered here in path style
|
|
|
|
decisions, although the appropriate flags are retrieved and
|
|
|
|
stored in various structures.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Removing mounted filesystem support would simplify things greatly,
|
|
|
|
but having it gives us a mechanism of treating disk that lives on a
|
|
|
|
UNIX machine as having UNIX semantics [it allows one to edit a text
|
|
|
|
file on that disk and not have cr's magically appear and perhaps
|
|
|
|
break apps running on UNIX boxes]. It also useful to be able to
|
|
|
|
layout a hierarchy without changing the underlying directories.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
The semantics of mounting file systems is not intended to precisely
|
|
|
|
follow normal UNIX systems.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 15:13:47 +08:00
|
|
|
Each DOS drive is defined to have a current directory. Supporting
|
|
|
|
this would complicate things so for now things are defined so that
|
|
|
|
c: means c:\.
|
|
|
|
*/
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2000-08-03 00:28:18 +08:00
|
|
|
#include "winsup.h"
|
2008-04-08 00:15:45 +08:00
|
|
|
#include "miscfuncs.h"
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <ctype.h>
|
2000-06-08 21:24:52 +08:00
|
|
|
#include <winioctl.h>
|
2001-02-22 05:49:37 +08:00
|
|
|
#include <wingdi.h>
|
|
|
|
#include <winuser.h>
|
|
|
|
#include <winnetwk.h>
|
2005-01-18 21:00:18 +08:00
|
|
|
#include <shlobj.h>
|
2000-09-08 10:56:55 +08:00
|
|
|
#include <sys/cygwin.h>
|
2000-08-22 11:58:47 +08:00
|
|
|
#include "cygerrno.h"
|
2001-07-27 03:22:24 +08:00
|
|
|
#include "security.h"
|
2000-08-22 13:10:20 +08:00
|
|
|
#include "path.h"
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
#include "fhandler.h"
|
2001-04-19 05:10:15 +08:00
|
|
|
#include "dtable.h"
|
2000-09-03 12:16:35 +08:00
|
|
|
#include "cygheap.h"
|
2000-09-08 00:23:51 +08:00
|
|
|
#include "shared_info.h"
|
2003-12-24 00:26:31 +08:00
|
|
|
#include "cygtls.h"
|
2008-03-07 19:24:51 +08:00
|
|
|
#include "tls_pbuf.h"
|
2006-08-02 23:11:48 +08:00
|
|
|
#include "environ.h"
|
2008-05-20 23:11:23 +08:00
|
|
|
#include "nfs.h"
|
2000-10-13 06:15:47 +08:00
|
|
|
#include <assert.h>
|
2007-01-17 02:01:06 +08:00
|
|
|
#include <ntdll.h>
|
2007-07-19 19:41:17 +08:00
|
|
|
#include <wchar.h>
|
2008-07-17 04:20:45 +08:00
|
|
|
#include <wctype.h>
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
bool dos_file_warning = true;
|
|
|
|
|
2009-01-03 13:12:22 +08:00
|
|
|
suffix_info stat_suffixes[] =
|
|
|
|
{
|
|
|
|
suffix_info ("", 1),
|
|
|
|
suffix_info (".exe", 1),
|
|
|
|
suffix_info (NULL)
|
|
|
|
};
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
struct symlink_info
|
|
|
|
{
|
|
|
|
char contents[SYMLINK_MAX + 1];
|
|
|
|
char *ext_here;
|
|
|
|
int extn;
|
|
|
|
unsigned pflags;
|
|
|
|
DWORD fileattr;
|
|
|
|
int issymlink;
|
|
|
|
bool ext_tacked_on;
|
|
|
|
int error;
|
|
|
|
bool isdevice;
|
|
|
|
_major_t major;
|
|
|
|
_minor_t minor;
|
|
|
|
_mode_t mode;
|
|
|
|
int check (char *path, const suffix_info *suffixes, unsigned opt,
|
|
|
|
fs_info &fs);
|
|
|
|
int set (char *path);
|
|
|
|
bool parse_device (const char *);
|
|
|
|
int check_sysfile (HANDLE h);
|
|
|
|
int check_shortcut (HANDLE h);
|
|
|
|
int check_reparse_point (HANDLE h);
|
|
|
|
int check_nfs_symlink (HANDLE h);
|
|
|
|
int posixify (char *srcbuf);
|
|
|
|
bool set_error (int);
|
|
|
|
};
|
|
|
|
|
|
|
|
muto NO_COPY cwdstuff::cwd_lock;
|
|
|
|
|
|
|
|
static const GUID GUID_shortcut
|
2008-09-11 12:34:24 +08:00
|
|
|
= { 0x00021401L, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46}};
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
enum {
|
|
|
|
WSH_FLAG_IDLIST = 0x01, /* Contains an ITEMIDLIST. */
|
|
|
|
WSH_FLAG_FILE = 0x02, /* Contains a file locator element. */
|
|
|
|
WSH_FLAG_DESC = 0x04, /* Contains a description. */
|
|
|
|
WSH_FLAG_RELPATH = 0x08, /* Contains a relative path. */
|
|
|
|
WSH_FLAG_WD = 0x10, /* Contains a working dir. */
|
|
|
|
WSH_FLAG_CMDLINE = 0x20, /* Contains command line args. */
|
|
|
|
WSH_FLAG_ICON = 0x40 /* Contains a custom icon. */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct win_shortcut_hdr
|
|
|
|
{
|
|
|
|
DWORD size; /* Header size in bytes. Must contain 0x4c. */
|
|
|
|
GUID magic; /* GUID of shortcut files. */
|
|
|
|
DWORD flags; /* Content flags. See above. */
|
|
|
|
|
|
|
|
/* The next fields from attr to icon_no are always set to 0 in Cygwin
|
|
|
|
and U/Win shortcuts. */
|
|
|
|
DWORD attr; /* Target file attributes. */
|
|
|
|
FILETIME ctime; /* These filetime items are never touched by the */
|
|
|
|
FILETIME mtime; /* system, apparently. Values don't matter. */
|
|
|
|
FILETIME atime;
|
|
|
|
DWORD filesize; /* Target filesize. */
|
|
|
|
DWORD icon_no; /* Icon number. */
|
|
|
|
|
|
|
|
DWORD run; /* Values defined in winuser.h. Use SW_NORMAL. */
|
|
|
|
DWORD hotkey; /* Hotkey value. Set to 0. */
|
|
|
|
DWORD dummy[2]; /* Future extension probably. Always 0. */
|
2008-05-23 15:13:47 +08:00
|
|
|
};
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Return non-zero if PATH1 is a prefix of PATH2.
|
|
|
|
Both are assumed to be of the same path style and / vs \ usage.
|
|
|
|
Neither may be "".
|
|
|
|
LEN1 = strlen (PATH1). It's passed because often it's already known.
|
|
|
|
|
|
|
|
Examples:
|
|
|
|
/foo/ is a prefix of /foo <-- may seem odd, but desired
|
|
|
|
/foo is a prefix of /foo/
|
|
|
|
/ is a prefix of /foo/bar
|
|
|
|
/ is not a prefix of foo/bar
|
|
|
|
foo/ is a prefix foo/bar
|
|
|
|
/foo is not a prefix of /foobar
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2008-07-17 04:20:45 +08:00
|
|
|
path_prefix_p (const char *path1, const char *path2, int len1,
|
|
|
|
bool caseinsensitive)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
/* Handle case where PATH1 has trailing '/' and when it doesn't. */
|
|
|
|
if (len1 > 0 && isdirsep (path1[len1 - 1]))
|
|
|
|
len1--;
|
|
|
|
|
|
|
|
if (len1 == 0)
|
|
|
|
return isdirsep (path2[0]) && !isdirsep (path2[1]);
|
|
|
|
|
|
|
|
if (isdirsep (path2[len1]) || path2[len1] == 0 || path1[len1 - 1] == ':')
|
2009-01-10 00:20:26 +08:00
|
|
|
return caseinsensitive ? strncasematch (path1, path2, len1)
|
|
|
|
: !strncmp (path1, path2, len1);
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return non-zero if paths match in first len chars.
|
|
|
|
Check is dependent of the case sensitivity setting. */
|
|
|
|
int
|
2008-07-17 04:20:45 +08:00
|
|
|
pathnmatch (const char *path1, const char *path2, int len, bool caseinsensitive)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
return caseinsensitive
|
|
|
|
? strncasematch (path1, path2, len) : !strncmp (path1, path2, len);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return non-zero if paths match. Check is dependent of the case
|
|
|
|
sensitivity setting. */
|
|
|
|
int
|
2008-07-17 04:20:45 +08:00
|
|
|
pathmatch (const char *path1, const char *path2, bool caseinsensitive)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
return caseinsensitive
|
|
|
|
? strcasematch (path1, path2) : !strcmp (path1, path2);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: This function is used in mkdir and rmdir to generate correct
|
|
|
|
error messages in case of paths ending in /. or /.. components.
|
|
|
|
Right now, normalize_posix_path will just normalize
|
|
|
|
those components away, which changes the semantics. */
|
|
|
|
bool
|
|
|
|
has_dot_last_component (const char *dir, bool test_dot_dot)
|
|
|
|
{
|
|
|
|
/* SUSv3: . and .. are not allowed as last components in various system
|
|
|
|
calls. Don't test for backslash path separator since that's a Win32
|
|
|
|
path following Win32 rules. */
|
2009-10-02 14:04:57 +08:00
|
|
|
const char *last_comp = strchr (dir, '\0');
|
|
|
|
|
|
|
|
if (last_comp == dir)
|
|
|
|
return false; /* Empty string. Probably shouldn't happen here? */
|
|
|
|
|
|
|
|
/* Detect run of trailing slashes */
|
|
|
|
while (last_comp > dir && *--last_comp == '/')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Detect just a run of slashes or a path that does not end with a slash. */
|
|
|
|
if (*last_comp != '.')
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* We know we have a trailing dot here. Check that it really is a standalone "."
|
|
|
|
path component by checking that it is at the beginning of the string or is
|
|
|
|
preceded by a "/" */
|
|
|
|
if (last_comp == dir || *--last_comp == '/')
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* If we're not checking for '..' we're done. Ditto if we're now pointing to
|
|
|
|
a non-dot. */
|
|
|
|
if (!test_dot_dot || *last_comp != '.')
|
|
|
|
return false; /* either not testing for .. or this was not '..' */
|
|
|
|
|
|
|
|
/* Repeat previous test for standalone or path component. */
|
|
|
|
return last_comp == dir || last_comp[-1] == '/';
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Normalize a POSIX path.
|
|
|
|
All duplicate /'s, except for 2 leading /'s, are deleted.
|
|
|
|
The result is 0 for success, or an errno error value. */
|
|
|
|
|
|
|
|
int
|
|
|
|
normalize_posix_path (const char *src, char *dst, char *&tail)
|
|
|
|
{
|
|
|
|
const char *in_src = src;
|
|
|
|
char *dst_start = dst;
|
|
|
|
syscall_printf ("src %s", src);
|
|
|
|
|
|
|
|
if ((isdrive (src) && isdirsep (src[2])) || *src == '\\')
|
|
|
|
goto win32_path;
|
|
|
|
|
|
|
|
tail = dst;
|
|
|
|
if (!isslash (src[0]))
|
|
|
|
{
|
|
|
|
if (!cygheap->cwd.get (dst))
|
|
|
|
return get_errno ();
|
|
|
|
tail = strchr (tail, '\0');
|
|
|
|
if (isslash (dst[0]) && isslash (dst[1]))
|
|
|
|
++dst_start;
|
|
|
|
if (*src == '.')
|
|
|
|
{
|
|
|
|
if (tail == dst_start + 1 && *dst_start == '/')
|
|
|
|
tail--;
|
|
|
|
goto sawdot;
|
|
|
|
}
|
|
|
|
if (tail > dst && !isslash (tail[-1]))
|
|
|
|
*tail++ = '/';
|
|
|
|
}
|
|
|
|
/* Two leading /'s? If so, preserve them. */
|
|
|
|
else if (isslash (src[1]) && !isslash (src[2]))
|
|
|
|
{
|
|
|
|
*tail++ = *src++;
|
|
|
|
++dst_start;
|
|
|
|
}
|
2001-04-29 07:48:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
while (*src)
|
|
|
|
{
|
|
|
|
if (*src == '\\')
|
|
|
|
goto win32_path;
|
|
|
|
/* Strip runs of /'s. */
|
|
|
|
if (!isslash (*src))
|
|
|
|
*tail++ = *src++;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while (*++src)
|
|
|
|
{
|
|
|
|
if (isslash (*src))
|
|
|
|
continue;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (*src != '.')
|
|
|
|
break;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
sawdot:
|
|
|
|
if (src[1] != '.')
|
|
|
|
{
|
|
|
|
if (!src[1])
|
|
|
|
{
|
|
|
|
*tail++ = '/';
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (!isslash (src[1]))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (src[2] && !isslash (src[2]))
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while (tail > dst_start && !isslash (*--tail))
|
|
|
|
continue;
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2004-12-19 11:27:09 +08:00
|
|
|
*tail++ = '/';
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
if ((tail - dst) >= NT_MAX_PATH)
|
2001-04-29 07:48:28 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
debug_printf ("ENAMETOOLONG = normalize_posix_path (%s)", src);
|
|
|
|
return ENAMETOOLONG;
|
2001-04-29 07:48:28 +08:00
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
done:
|
|
|
|
*tail = '\0';
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
debug_printf ("%s = normalize_posix_path (%s)", dst, in_src);
|
|
|
|
return 0;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
win32_path:
|
|
|
|
int err = normalize_win32_path (in_src, dst, tail);
|
|
|
|
if (!err)
|
|
|
|
for (char *p = dst; (p = strchr (p, '\\')); p++)
|
|
|
|
*p = '/';
|
|
|
|
return err ?: -1;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
inline void
|
|
|
|
path_conv::add_ext_from_sym (symlink_info &sym)
|
|
|
|
{
|
|
|
|
if (sym.ext_here && *sym.ext_here)
|
|
|
|
{
|
|
|
|
known_suffix = path + sym.extn;
|
|
|
|
if (sym.ext_tacked_on)
|
2009-08-02 03:52:46 +08:00
|
|
|
strcpy ((char *) known_suffix, sym.ext_here);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-02 03:52:46 +08:00
|
|
|
static void __stdcall mkrelpath (char *dst, bool caseinsensitive)
|
|
|
|
__attribute__ ((regparm (2)));
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
static void __stdcall
|
2008-07-17 04:20:45 +08:00
|
|
|
mkrelpath (char *path, bool caseinsensitive)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
char *cwd_win32 = tp.c_get ();
|
|
|
|
if (!cygheap->cwd.get (cwd_win32, 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned cwdlen = strlen (cwd_win32);
|
2008-07-17 04:20:45 +08:00
|
|
|
if (!path_prefix_p (cwd_win32, path, cwdlen, caseinsensitive))
|
2008-05-23 19:00:35 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
size_t n = strlen (path);
|
|
|
|
if (n < cwdlen)
|
|
|
|
return;
|
|
|
|
|
|
|
|
char *tail = path;
|
|
|
|
if (n == cwdlen)
|
|
|
|
tail += cwdlen;
|
|
|
|
else
|
|
|
|
tail += isdirsep (cwd_win32[cwdlen - 1]) ? cwdlen : cwdlen + 1;
|
|
|
|
|
|
|
|
memmove (path, tail, strlen (tail) + 1);
|
|
|
|
if (!*path)
|
|
|
|
strcpy (path, ".");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
path_conv::fillin (HANDLE h)
|
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
FILE_BASIC_INFORMATION fbi;
|
|
|
|
|
|
|
|
if (NT_SUCCESS (NtQueryInformationFile (h, &io, &fbi, sizeof fbi,
|
|
|
|
FileBasicInformation)))
|
|
|
|
fileattr = fbi.FileAttributes;
|
|
|
|
else
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
}
|
2004-12-24 05:37:44 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
void
|
|
|
|
path_conv::set_normalized_path (const char *path_copy)
|
|
|
|
{
|
2009-07-30 16:56:57 +08:00
|
|
|
if (path_copy)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-07-30 16:56:57 +08:00
|
|
|
size_t n = strlen (path_copy) + 1;
|
2009-08-02 03:52:46 +08:00
|
|
|
char *p = (char *) cmalloc_abort (HEAP_STR, n);
|
|
|
|
normalized_path = (const char *) memcpy (p, path_copy, n);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-09 23:08:16 +08:00
|
|
|
static inline void
|
|
|
|
str2uni_cat (UNICODE_STRING &tgt, const char *srcstr)
|
|
|
|
{
|
|
|
|
int len = sys_mbstowcs (tgt.Buffer + tgt.Length / sizeof (WCHAR),
|
|
|
|
(tgt.MaximumLength - tgt.Length) / sizeof (WCHAR),
|
|
|
|
srcstr);
|
|
|
|
if (len)
|
|
|
|
tgt.Length += (len - 1) * sizeof (WCHAR);
|
|
|
|
}
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
PUNICODE_STRING
|
2008-07-17 04:20:45 +08:00
|
|
|
get_nt_native_path (const char *path, UNICODE_STRING& upath)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
upath.Length = 0;
|
|
|
|
if (path[0] == '/') /* special path w/o NT path representation. */
|
|
|
|
str2uni_cat (upath, path);
|
2008-06-11 22:06:05 +08:00
|
|
|
else if (path[0] != '\\') /* X:\... or relative path. */
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-06-11 22:06:05 +08:00
|
|
|
if (path[1] == ':') /* X:\... */
|
2008-07-17 04:20:45 +08:00
|
|
|
{
|
2009-07-15 01:37:42 +08:00
|
|
|
RtlAppendUnicodeStringToString (&upath, &ro_u_natp);
|
2008-07-17 04:20:45 +08:00
|
|
|
str2uni_cat (upath, path);
|
|
|
|
/* The drive letter must be upper case. */
|
|
|
|
upath.Buffer[4] = towupper (upath.Buffer[4]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
str2uni_cat (upath, path);
|
|
|
|
transform_chars (&upath, 7);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
else if (path[1] != '\\') /* \Device\... */
|
|
|
|
str2uni_cat (upath, path);
|
|
|
|
else if ((path[2] != '.' && path[2] != '?')
|
|
|
|
|| path[3] != '\\') /* \\server\share\... */
|
|
|
|
{
|
2009-07-15 01:37:42 +08:00
|
|
|
RtlAppendUnicodeStringToString (&upath, &ro_u_uncp);
|
2008-05-23 19:00:35 +08:00
|
|
|
str2uni_cat (upath, path + 2);
|
2008-07-17 04:20:45 +08:00
|
|
|
transform_chars (&upath, 8);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
else /* \\.\device or \\?\foo */
|
|
|
|
{
|
2009-07-15 01:37:42 +08:00
|
|
|
RtlAppendUnicodeStringToString (&upath, &ro_u_natp);
|
2008-05-23 19:00:35 +08:00
|
|
|
str2uni_cat (upath, path + 4);
|
|
|
|
}
|
|
|
|
return &upath;
|
|
|
|
}
|
2004-05-01 01:36:36 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
PUNICODE_STRING
|
|
|
|
path_conv::get_nt_native_path ()
|
|
|
|
{
|
|
|
|
if (!wide_path)
|
|
|
|
{
|
|
|
|
uni_path.Length = 0;
|
|
|
|
uni_path.MaximumLength = (strlen (path) + 10) * sizeof (WCHAR);
|
|
|
|
wide_path = (PWCHAR) cmalloc_abort (HEAP_STR, uni_path.MaximumLength);
|
|
|
|
uni_path.Buffer = wide_path;
|
2008-07-17 04:20:45 +08:00
|
|
|
::get_nt_native_path (path, uni_path);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
return &uni_path;
|
|
|
|
}
|
2007-07-19 19:41:17 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
POBJECT_ATTRIBUTES
|
|
|
|
path_conv::get_object_attr (OBJECT_ATTRIBUTES &attr, SECURITY_ATTRIBUTES &sa)
|
|
|
|
{
|
|
|
|
if (!get_nt_native_path ())
|
|
|
|
return NULL;
|
|
|
|
InitializeObjectAttributes (&attr, &uni_path,
|
2008-07-17 04:20:45 +08:00
|
|
|
objcaseinsensitive ()
|
2008-05-23 19:00:35 +08:00
|
|
|
| (sa.bInheritHandle ? OBJ_INHERIT : 0),
|
|
|
|
NULL, sa.lpSecurityDescriptor);
|
|
|
|
return &attr;
|
|
|
|
}
|
|
|
|
|
|
|
|
PWCHAR
|
|
|
|
path_conv::get_wide_win32_path (PWCHAR wc)
|
|
|
|
{
|
|
|
|
get_nt_native_path ();
|
2009-04-15 17:58:41 +08:00
|
|
|
if (!wide_path)
|
2008-05-23 19:00:35 +08:00
|
|
|
return NULL;
|
2009-04-15 17:58:41 +08:00
|
|
|
wcpcpy (wc, wide_path);
|
|
|
|
if (wc[1] == L'?')
|
|
|
|
wc[1] = L'\\';
|
2008-05-23 19:00:35 +08:00
|
|
|
return wc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
warn_msdos (const char *src)
|
|
|
|
{
|
2009-03-15 02:35:26 +08:00
|
|
|
if (user_shared->warned_msdos || !dos_file_warning || !cygwin_finished_initializing)
|
2008-05-23 19:00:35 +08:00
|
|
|
return;
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
char *posix_path = tp.c_get ();
|
|
|
|
small_printf ("cygwin warning:\n");
|
|
|
|
if (cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, src,
|
|
|
|
posix_path, NT_MAX_PATH))
|
|
|
|
small_printf (" MS-DOS style path detected: %s\n POSIX equivalent preferred.\n",
|
|
|
|
src);
|
|
|
|
else
|
|
|
|
small_printf (" MS-DOS style path detected: %s\n Preferred POSIX equivalent is: %s\n",
|
|
|
|
src, posix_path);
|
|
|
|
small_printf (" CYGWIN environment variable option \"nodosfilewarning\" turns off this warning.\n"
|
|
|
|
" Consult the user's guide for more details about POSIX paths:\n"
|
|
|
|
" http://cygwin.com/cygwin-ug-net/using.html#using-pathnames\n");
|
|
|
|
user_shared->warned_msdos = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DWORD
|
2008-07-17 04:20:45 +08:00
|
|
|
getfileattr (const char *path, bool caseinsensitive) /* path has to be always absolute. */
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
UNICODE_STRING upath;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
FILE_BASIC_INFORMATION fbi;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
|
|
|
|
tp.u_get (&upath);
|
2008-07-17 04:20:45 +08:00
|
|
|
InitializeObjectAttributes (&attr, &upath,
|
|
|
|
caseinsensitive ? OBJ_CASE_INSENSITIVE : 0,
|
|
|
|
NULL, NULL);
|
|
|
|
get_nt_native_path (path, upath);
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
status = NtQueryAttributesFile (&attr, &fbi);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
return fbi.FileAttributes;
|
|
|
|
|
|
|
|
if (status != STATUS_OBJECT_NAME_NOT_FOUND
|
|
|
|
&& status != STATUS_NO_SUCH_FILE) /* File not found on 9x share */
|
|
|
|
{
|
|
|
|
/* File exists but access denied. Try to get attribute through
|
|
|
|
directory query. */
|
|
|
|
UNICODE_STRING dirname, basename;
|
|
|
|
HANDLE dir;
|
|
|
|
FILE_DIRECTORY_INFORMATION fdi;
|
|
|
|
|
|
|
|
RtlSplitUnicodePath (&upath, &dirname, &basename);
|
|
|
|
InitializeObjectAttributes (&attr, &dirname,
|
2008-07-17 04:20:45 +08:00
|
|
|
caseinsensitive ? OBJ_CASE_INSENSITIVE : 0,
|
|
|
|
NULL, NULL);
|
2008-05-23 19:00:35 +08:00
|
|
|
status = NtOpenFile (&dir, SYNCHRONIZE | FILE_LIST_DIRECTORY,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT
|
|
|
|
| FILE_DIRECTORY_FILE);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
status = NtQueryDirectoryFile (dir, NULL, NULL, 0, &io,
|
|
|
|
&fdi, sizeof fdi,
|
|
|
|
FileDirectoryInformation,
|
|
|
|
TRUE, &basename, TRUE);
|
|
|
|
NtClose (dir);
|
|
|
|
if (NT_SUCCESS (status) || status == STATUS_BUFFER_OVERFLOW)
|
|
|
|
return fdi.FileAttributes;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SetLastError (RtlNtStatusToDosError (status));
|
|
|
|
return INVALID_FILE_ATTRIBUTES;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert an arbitrary path SRC to a pure Win32 path, suitable for
|
|
|
|
passing to Win32 API routines.
|
|
|
|
|
|
|
|
If an error occurs, `error' is set to the errno value.
|
|
|
|
Otherwise it is set to 0.
|
|
|
|
|
|
|
|
follow_mode values:
|
|
|
|
SYMLINK_FOLLOW - convert to PATH symlink points to
|
|
|
|
SYMLINK_NOFOLLOW - convert to PATH of symlink itself
|
|
|
|
SYMLINK_IGNORE - do not check PATH for symlinks
|
|
|
|
SYMLINK_CONTENTS - just return symlink contents
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* TODO: This implementation is only preliminary. For internal
|
|
|
|
purposes it's necessary to have a path_conv::check function which
|
|
|
|
takes a UNICODE_STRING src path, otherwise we waste a lot of time
|
|
|
|
for converting back and forth. The below implementation does
|
|
|
|
realy nothing but converting to char *, until path_conv handles
|
|
|
|
wide-char paths directly. */
|
|
|
|
void
|
|
|
|
path_conv::check (const UNICODE_STRING *src, unsigned opt,
|
|
|
|
const suffix_info *suffixes)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
|
|
|
|
user_shared->warned_msdos = true;
|
|
|
|
sys_wcstombs (path, NT_MAX_PATH, src->Buffer, src->Length / sizeof (WCHAR));
|
|
|
|
path_conv::check (path, opt, suffixes);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
path_conv::check (const char *src, unsigned opt,
|
|
|
|
const suffix_info *suffixes)
|
|
|
|
{
|
|
|
|
/* The tmp_buf array is used when expanding symlinks. It is NT_MAX_PATH * 2
|
|
|
|
in length so that we can hold the expanded symlink plus a trailer. */
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
char *path_copy = tp.c_get ();
|
|
|
|
char *pathbuf = tp.c_get ();
|
|
|
|
char *tmp_buf = tp.t_get ();
|
2009-07-30 16:56:57 +08:00
|
|
|
char *THIS_path = tp.c_get ();
|
2008-05-23 19:00:35 +08:00
|
|
|
symlink_info sym;
|
|
|
|
bool need_directory = 0;
|
|
|
|
bool saw_symlinks = 0;
|
2009-07-30 16:56:57 +08:00
|
|
|
bool add_ext = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
bool is_relpath;
|
|
|
|
char *tail, *path_end;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
#if 0
|
|
|
|
static path_conv last_path_conv;
|
|
|
|
static char last_src[CYG_MAX_PATH];
|
2000-10-23 11:35:50 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (*last_src && strcmp (last_src, src) == 0)
|
|
|
|
{
|
|
|
|
*this = last_path_conv;
|
2000-10-23 11:35:50 +08:00
|
|
|
return;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
#endif
|
2000-10-23 11:35:50 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted ())
|
|
|
|
{
|
|
|
|
error = EFAULT;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
int loop = 0;
|
|
|
|
path_flags = 0;
|
|
|
|
known_suffix = NULL;
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
2008-07-17 04:20:45 +08:00
|
|
|
caseinsensitive = OBJ_CASE_INSENSITIVE;
|
2008-05-23 19:00:35 +08:00
|
|
|
if (wide_path)
|
|
|
|
cfree (wide_path);
|
|
|
|
wide_path = NULL;
|
2009-07-30 16:56:57 +08:00
|
|
|
if (path)
|
2009-08-02 03:52:46 +08:00
|
|
|
{
|
|
|
|
cfree (modifiable_path ());
|
|
|
|
path = NULL;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
memset (&dev, 0, sizeof (dev));
|
|
|
|
fs.clear ();
|
2009-07-30 16:56:57 +08:00
|
|
|
if (normalized_path)
|
2009-08-02 03:52:46 +08:00
|
|
|
{
|
|
|
|
cfree ((void *) normalized_path);
|
|
|
|
normalized_path = NULL;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
int component = 0; // Number of translated components
|
|
|
|
|
|
|
|
if (!(opt & PC_NULLEMPTY))
|
|
|
|
error = 0;
|
|
|
|
else if (!*src)
|
|
|
|
{
|
|
|
|
error = ENOENT;
|
|
|
|
return;
|
|
|
|
}
|
2005-07-03 10:40:30 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
bool is_msdos = false;
|
|
|
|
/* This loop handles symlink expansion. */
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
MALLOC_CHECK;
|
|
|
|
assert (src);
|
2004-12-19 00:41:27 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
is_relpath = !isabspath (src);
|
|
|
|
error = normalize_posix_path (src, path_copy, tail);
|
|
|
|
if (error > 0)
|
|
|
|
return;
|
|
|
|
if (error < 0)
|
|
|
|
{
|
|
|
|
if (component == 0)
|
|
|
|
is_msdos = true;
|
|
|
|
error = 0;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Detect if the user was looking for a directory. We have to strip the
|
|
|
|
trailing slash initially while trying to add extensions but take it
|
|
|
|
into account during processing */
|
|
|
|
if (tail > path_copy + 2 && isslash (tail[-1]))
|
|
|
|
{
|
|
|
|
need_directory = 1;
|
|
|
|
*--tail = '\0';
|
|
|
|
}
|
|
|
|
path_end = tail;
|
|
|
|
|
|
|
|
/* Scan path_copy from right to left looking either for a symlink
|
|
|
|
or an actual existing file. If an existing file is found, just
|
|
|
|
return. If a symlink is found, exit the for loop.
|
|
|
|
Also: be careful to preserve the errno returned from
|
|
|
|
symlink.check as the caller may need it. */
|
|
|
|
/* FIXME: Do we have to worry about multiple \'s here? */
|
|
|
|
component = 0; // Number of translated components
|
|
|
|
sym.contents[0] = '\0';
|
|
|
|
|
|
|
|
int symlen = 0;
|
|
|
|
|
|
|
|
for (unsigned pflags_or = opt & PC_NO_ACCESS_CHECK; ; pflags_or = 0)
|
|
|
|
{
|
|
|
|
const suffix_info *suff;
|
|
|
|
char *full_path;
|
|
|
|
|
|
|
|
/* Don't allow symlink.check to set anything in the path_conv
|
|
|
|
class if we're working on an inner component of the path */
|
|
|
|
if (component)
|
|
|
|
{
|
|
|
|
suff = NULL;
|
|
|
|
sym.pflags = 0;
|
|
|
|
full_path = pathbuf;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
suff = suffixes;
|
|
|
|
sym.pflags = path_flags;
|
2009-07-30 16:56:57 +08:00
|
|
|
full_path = THIS_path;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Convert to native path spec sans symbolic link info. */
|
|
|
|
error = mount_table->conv_to_win32_path (path_copy, full_path, dev,
|
|
|
|
&sym.pflags);
|
2001-06-03 10:31:16 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (error)
|
|
|
|
return;
|
2001-04-30 09:46:31 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
sym.pflags |= pflags_or;
|
2005-03-12 10:33:00 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (dev.major == DEV_CYGDRIVE_MAJOR)
|
|
|
|
{
|
|
|
|
if (!component)
|
|
|
|
fileattr = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY;
|
|
|
|
else
|
|
|
|
{
|
2009-07-30 16:56:57 +08:00
|
|
|
fileattr = getfileattr (THIS_path,
|
2008-07-17 04:20:45 +08:00
|
|
|
sym.pflags & MOUNT_NOPOSIX);
|
2008-05-23 19:00:35 +08:00
|
|
|
dev.devn = FH_FS;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
else if (dev == FH_DEV)
|
|
|
|
{
|
|
|
|
dev.devn = FH_FS;
|
2005-09-13 05:19:07 +08:00
|
|
|
#if 0
|
2009-07-30 16:56:57 +08:00
|
|
|
fileattr = getfileattr (THIS_path, sym.pflags & MOUNT_NOPOSIX);
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!component && fileattr == INVALID_FILE_ATTRIBUTES)
|
|
|
|
{
|
|
|
|
fileattr = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-09-13 05:19:07 +08:00
|
|
|
#endif
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
else if (isvirtual_dev (dev.devn))
|
|
|
|
{
|
|
|
|
/* FIXME: Calling build_fhandler here is not the right way to handle this. */
|
|
|
|
fhandler_virtual *fh = (fhandler_virtual *) build_fh_dev (dev, path_copy);
|
|
|
|
int file_type = fh->exists ();
|
|
|
|
if (file_type == -2)
|
|
|
|
{
|
|
|
|
fh->fill_filebuf ();
|
|
|
|
symlen = sym.set (fh->get_filebuf ());
|
|
|
|
}
|
|
|
|
delete fh;
|
|
|
|
switch (file_type)
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
if (component == 0)
|
|
|
|
fileattr = FILE_ATTRIBUTE_DIRECTORY;
|
|
|
|
break;
|
|
|
|
case -1:
|
|
|
|
if (component == 0)
|
|
|
|
fileattr = 0;
|
|
|
|
break;
|
|
|
|
case -2: /* /proc/self or /proc/<pid>/symlinks */
|
|
|
|
goto is_virtual_symlink;
|
|
|
|
case -3: /* /proc/<pid>/fd/pipe:[] */
|
|
|
|
if (component == 0)
|
|
|
|
{
|
|
|
|
fileattr = 0;
|
|
|
|
dev.parse (FH_PIPE);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case -4: /* /proc/<pid>/fd/socket:[] */
|
|
|
|
if (component == 0)
|
|
|
|
{
|
|
|
|
fileattr = 0;
|
|
|
|
dev.parse (FH_TCP);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (component == 0)
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
goto virtual_component_retry;
|
|
|
|
}
|
|
|
|
if (component == 0 || dev.devn != FH_NETDRIVE)
|
|
|
|
path_flags |= PATH_RO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* devn should not be a device. If it is, then stop parsing now. */
|
|
|
|
else if (dev.devn != FH_FS)
|
|
|
|
{
|
|
|
|
fileattr = 0;
|
|
|
|
path_flags = sym.pflags;
|
|
|
|
if (component)
|
|
|
|
{
|
|
|
|
error = ENOTDIR;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto out; /* Found a device. Stop parsing. */
|
|
|
|
}
|
2001-04-30 09:46:31 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* If path is only a drivename, Windows interprets it as the
|
|
|
|
current working directory on this drive instead of the root
|
|
|
|
dir which is what we want. So we need the trailing backslash
|
|
|
|
in this case. */
|
|
|
|
if (full_path[0] && full_path[1] == ':' && full_path[2] == '\0')
|
|
|
|
{
|
|
|
|
full_path[2] = '\\';
|
|
|
|
full_path[3] = '\0';
|
|
|
|
}
|
2005-01-29 19:23:07 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
symlen = sym.check (full_path, suff, opt, fs);
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
is_virtual_symlink:
|
2000-04-14 06:43:48 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (sym.isdevice)
|
|
|
|
{
|
|
|
|
dev.parse (sym.major, sym.minor);
|
|
|
|
dev.setfs (1);
|
|
|
|
dev.mode = sym.mode;
|
|
|
|
fileattr = sym.fileattr;
|
|
|
|
goto out;
|
|
|
|
}
|
2001-04-13 05:21:37 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (sym.pflags & PATH_SOCKET)
|
|
|
|
{
|
|
|
|
if (component)
|
|
|
|
{
|
|
|
|
error = ENOTDIR;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fileattr = sym.fileattr;
|
|
|
|
dev.parse (FH_UNIX);
|
|
|
|
dev.setfs (1);
|
|
|
|
goto out;
|
|
|
|
}
|
2001-06-11 11:38:32 +08:00
|
|
|
|
2008-07-17 04:20:45 +08:00
|
|
|
if (!component)
|
|
|
|
{
|
|
|
|
fileattr = sym.fileattr;
|
|
|
|
path_flags = sym.pflags;
|
2008-12-19 20:15:33 +08:00
|
|
|
/* If the OS is caseinsensitive or the FS is caseinsensitive or
|
|
|
|
the incoming path was given in DOS notation, don't handle
|
|
|
|
path casesensitive. */
|
|
|
|
if (cygwin_shared->obcaseinsensitive || fs.caseinsensitive ()
|
|
|
|
|| is_msdos)
|
2008-07-17 04:20:45 +08:00
|
|
|
path_flags |= PATH_NOPOSIX;
|
|
|
|
caseinsensitive = (path_flags & PATH_NOPOSIX)
|
|
|
|
? OBJ_CASE_INSENSITIVE : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If symlink.check found an existing non-symlink file, then
|
|
|
|
it sets the appropriate flag. It also sets any suffix found
|
|
|
|
into `ext_here'. */
|
|
|
|
if (!sym.issymlink && sym.fileattr != INVALID_FILE_ATTRIBUTES)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
error = sym.error;
|
|
|
|
if (component == 0)
|
2009-07-30 16:56:57 +08:00
|
|
|
add_ext = true;
|
2008-07-17 04:20:45 +08:00
|
|
|
else if (!(sym.fileattr & FILE_ATTRIBUTE_DIRECTORY))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
error = ENOTDIR;
|
2008-05-23 19:00:35 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2008-07-17 04:20:45 +08:00
|
|
|
goto out; // file found
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-07-17 04:20:45 +08:00
|
|
|
/* Found a symlink if symlen > 0. If component == 0, then the
|
|
|
|
src path itself was a symlink. If !follow_mode then
|
|
|
|
we're done. Otherwise we have to insert the path found
|
|
|
|
into the full path that we are building and perform all of
|
|
|
|
these operations again on the newly derived path. */
|
|
|
|
else if (symlen > 0)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
saw_symlinks = 1;
|
|
|
|
if (component == 0 && !need_directory && !(opt & PC_SYM_FOLLOW))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
set_symlink (symlen); // last component of path is a symlink.
|
|
|
|
if (opt & PC_SYM_CONTENTS)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-07-30 16:56:57 +08:00
|
|
|
strcpy (THIS_path, sym.contents);
|
2008-05-23 19:00:35 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2009-07-30 16:56:57 +08:00
|
|
|
add_ext = true;
|
2008-05-23 19:00:35 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2008-07-17 04:20:45 +08:00
|
|
|
else
|
|
|
|
break;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2009-01-12 00:13:11 +08:00
|
|
|
else if (sym.error && sym.error != ENOENT)
|
2008-07-17 04:20:45 +08:00
|
|
|
{
|
|
|
|
error = sym.error;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* No existing file found. */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
virtual_component_retry:
|
|
|
|
/* Find the new "tail" of the path, e.g. in '/for/bar/baz',
|
|
|
|
/baz is the tail. */
|
|
|
|
if (tail != path_end)
|
|
|
|
*tail = '/';
|
|
|
|
while (--tail > path_copy + 1 && *tail != '/') {}
|
|
|
|
/* Exit loop if there is no tail or we are at the
|
|
|
|
beginning of a UNC path */
|
|
|
|
if (tail <= path_copy + 1)
|
|
|
|
goto out; // all done
|
|
|
|
|
|
|
|
/* Haven't found an existing pathname component yet.
|
|
|
|
Pinch off the tail and try again. */
|
|
|
|
*tail = '\0';
|
|
|
|
component++;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Arrive here if above loop detected a symlink. */
|
|
|
|
if (++loop > SYMLOOP_MAX)
|
|
|
|
{
|
|
|
|
error = ELOOP; // Eep.
|
|
|
|
return;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
MALLOC_CHECK;
|
2008-05-20 23:11:23 +08:00
|
|
|
|
2001-06-03 10:31:16 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Place the link content, possibly with head and/or tail, in tmp_buf */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
char *headptr;
|
|
|
|
if (isabspath (sym.contents))
|
|
|
|
headptr = tmp_buf; /* absolute path */
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Copy the first part of the path (with ending /) and point to the end. */
|
|
|
|
char *prevtail = tail;
|
|
|
|
while (--prevtail > path_copy && *prevtail != '/') {}
|
|
|
|
int headlen = prevtail - path_copy + 1;;
|
|
|
|
memcpy (tmp_buf, path_copy, headlen);
|
|
|
|
headptr = &tmp_buf[headlen];
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Make sure there is enough space */
|
|
|
|
if (headptr + symlen >= tmp_buf + (2 * NT_MAX_PATH))
|
|
|
|
{
|
|
|
|
too_long:
|
|
|
|
error = ENAMETOOLONG;
|
2009-08-05 06:35:35 +08:00
|
|
|
set_path ("::ENAMETOOLONG::");
|
2008-05-23 19:00:35 +08:00
|
|
|
return;
|
|
|
|
}
|
2001-03-02 19:41:09 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Copy the symlink contents to the end of tmp_buf.
|
|
|
|
Convert slashes. */
|
|
|
|
for (char *p = sym.contents; *p; p++)
|
|
|
|
*headptr++ = *p == '\\' ? '/' : *p;
|
|
|
|
*headptr = '\0';
|
|
|
|
|
|
|
|
/* Copy any tail component (with the 0) */
|
|
|
|
if (tail++ < path_end)
|
|
|
|
{
|
|
|
|
/* Add a slash if needed. There is space. */
|
|
|
|
if (*(headptr - 1) != '/')
|
|
|
|
*headptr++ = '/';
|
|
|
|
int taillen = path_end - tail + 1;
|
|
|
|
if (headptr + taillen > tmp_buf + (2 * NT_MAX_PATH))
|
|
|
|
goto too_long;
|
|
|
|
memcpy (headptr, tail, taillen);
|
|
|
|
}
|
2008-02-16 01:53:11 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Evaluate everything all over again. */
|
|
|
|
src = tmp_buf;
|
|
|
|
}
|
2001-03-17 15:09:41 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!(opt & PC_SYM_CONTENTS))
|
2009-07-30 16:56:57 +08:00
|
|
|
add_ext = true;
|
2001-04-12 03:09:53 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
out:
|
2009-08-02 03:52:46 +08:00
|
|
|
set_path (THIS_path);
|
2009-07-30 16:56:57 +08:00
|
|
|
if (add_ext)
|
|
|
|
add_ext_from_sym (sym);
|
2008-05-23 19:00:35 +08:00
|
|
|
if (dev.devn == FH_NETDRIVE && component)
|
|
|
|
{
|
|
|
|
/* This case indicates a non-existant resp. a non-retrievable
|
|
|
|
share. This happens for instance if the share is a printer.
|
|
|
|
In this case the path must not be treated like a FH_NETDRIVE,
|
|
|
|
but like a FH_FS instead, so the usual open call for files
|
|
|
|
is used on it. */
|
|
|
|
dev.parse (FH_FS);
|
|
|
|
}
|
|
|
|
else if (isvirtual_dev (dev.devn) && fileattr == INVALID_FILE_ATTRIBUTES)
|
|
|
|
{
|
2009-01-12 00:13:11 +08:00
|
|
|
error = ENOENT;
|
2008-05-23 19:00:35 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (!need_directory || error)
|
|
|
|
/* nothing to do */;
|
|
|
|
else if (fileattr == INVALID_FILE_ATTRIBUTES)
|
2009-08-02 03:52:46 +08:00
|
|
|
strcat (modifiable_path (), "\\"); /* Reattach trailing dirsep in native path. */
|
2008-05-23 19:00:35 +08:00
|
|
|
else if (fileattr & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
|
path_flags &= ~PATH_SYMLINK;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("%s is a non-directory", path);
|
|
|
|
error = ENOTDIR;
|
|
|
|
return;
|
|
|
|
}
|
2001-03-05 14:28:25 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (dev.isfs ())
|
|
|
|
{
|
|
|
|
if (strncmp (path, "\\\\.\\", 4))
|
|
|
|
{
|
|
|
|
if (!tail || tail == path)
|
|
|
|
/* nothing */;
|
|
|
|
else if (tail[-1] != '\\')
|
|
|
|
*tail = '\0';
|
|
|
|
else
|
|
|
|
{
|
|
|
|
error = ENOENT;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2002-07-06 05:58:49 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* FS has been checked already for existing files. */
|
|
|
|
if (exists () || fs.update (get_nt_native_path (), NULL))
|
|
|
|
{
|
2008-12-19 20:15:33 +08:00
|
|
|
/* Incoming DOS paths are treated like DOS paths in native
|
|
|
|
Windows applications. No ACLs, just default settings. */
|
|
|
|
if (is_msdos)
|
|
|
|
fs.has_acls (false);
|
2008-05-23 19:00:35 +08:00
|
|
|
debug_printf ("this->path(%s), has_acls(%d)", path, fs.has_acls ());
|
2009-06-02 21:29:30 +08:00
|
|
|
/* CV: We could use this->has_acls() but I want to make sure that
|
|
|
|
we don't forget that the PATH_NOACL flag must be taken into
|
|
|
|
account here. */
|
|
|
|
if (!(path_flags & PATH_NOACL) && fs.has_acls ())
|
2008-05-23 19:00:35 +08:00
|
|
|
set_exec (0); /* We really don't know if this is executable or not here
|
|
|
|
but set it to not executable since it will be figured out
|
|
|
|
later by anything which cares about this. */
|
|
|
|
}
|
|
|
|
if (exec_state () != dont_know_if_executable)
|
|
|
|
/* ok */;
|
|
|
|
else if (isdir ())
|
|
|
|
set_exec (1);
|
|
|
|
else if (issymlink () || issocket ())
|
|
|
|
set_exec (0);
|
|
|
|
}
|
2001-03-05 14:28:25 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (opt & PC_NOFULL)
|
|
|
|
{
|
|
|
|
if (is_relpath)
|
2008-11-11 19:45:05 +08:00
|
|
|
{
|
2009-08-02 03:52:46 +08:00
|
|
|
mkrelpath (this->modifiable_path (), !!caseinsensitive);
|
2008-11-11 19:45:05 +08:00
|
|
|
/* Invalidate wide_path so that wide relpath can be created
|
|
|
|
in later calls to get_nt_native_path or get_wide_win32_path. */
|
|
|
|
if (wide_path)
|
|
|
|
cfree (wide_path);
|
|
|
|
wide_path = NULL;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
if (need_directory)
|
|
|
|
{
|
|
|
|
size_t n = strlen (this->path);
|
|
|
|
/* Do not add trailing \ to UNC device names like \\.\a: */
|
|
|
|
if (this->path[n - 1] != '\\' &&
|
|
|
|
(strncmp (this->path, "\\\\.\\", 4) != 0))
|
|
|
|
{
|
2009-08-02 03:52:46 +08:00
|
|
|
this->modifiable_path ()[n] = '\\';
|
|
|
|
this->modifiable_path ()[n + 1] = '\0';
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (saw_symlinks)
|
|
|
|
set_has_symlinks ();
|
2007-08-23 15:43:24 +08:00
|
|
|
|
2009-07-30 16:56:57 +08:00
|
|
|
if ((opt & PC_POSIX))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
if (tail < path_end && tail > path_copy + 1)
|
|
|
|
*tail = '/';
|
|
|
|
set_normalized_path (path_copy);
|
|
|
|
if (is_msdos && !(opt & PC_NOWARN))
|
|
|
|
warn_msdos (src);
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
|
|
|
#if 0
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!error)
|
|
|
|
{
|
|
|
|
last_path_conv = *this;
|
|
|
|
strcpy (last_src, src);
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
#endif
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
path_conv::~path_conv ()
|
|
|
|
{
|
2009-07-30 16:56:57 +08:00
|
|
|
if (normalized_path)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-08-02 03:52:46 +08:00
|
|
|
cfree ((void *) normalized_path);
|
2008-05-23 19:00:35 +08:00
|
|
|
normalized_path = NULL;
|
|
|
|
}
|
2009-07-30 16:56:57 +08:00
|
|
|
if (path)
|
|
|
|
{
|
2009-08-02 03:52:46 +08:00
|
|
|
cfree (modifiable_path ());
|
2009-07-30 16:56:57 +08:00
|
|
|
path = NULL;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
if (wide_path)
|
|
|
|
{
|
|
|
|
cfree (wide_path);
|
|
|
|
wide_path = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
path_conv::is_binary ()
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
PWCHAR bintest = tp.w_get ();
|
|
|
|
DWORD bin;
|
2008-10-09 17:43:02 +08:00
|
|
|
|
2009-01-07 22:12:40 +08:00
|
|
|
return GetBinaryTypeW (get_wide_win32_path (bintest), &bin)
|
|
|
|
&& (bin == SCS_32BIT_BINARY || bin == SCS_64BIT_BINARY);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Normalize a Win32 path.
|
|
|
|
/'s are converted to \'s in the process.
|
|
|
|
All duplicate \'s, except for 2 leading \'s, are deleted.
|
|
|
|
|
|
|
|
The result is 0 for success, or an errno error value.
|
|
|
|
FIXME: A lot of this should be mergeable with the POSIX critter. */
|
|
|
|
int
|
|
|
|
normalize_win32_path (const char *src, char *dst, char *&tail)
|
|
|
|
{
|
|
|
|
const char *src_start = src;
|
|
|
|
bool beg_src_slash = isdirsep (src[0]);
|
|
|
|
|
|
|
|
tail = dst;
|
|
|
|
/* Skip long path name prefixes in Win32 or NT syntax. */
|
|
|
|
if (beg_src_slash && (src[1] == '?' || isdirsep (src[1]))
|
|
|
|
&& src[2] == '?' && isdirsep (src[3]))
|
|
|
|
{
|
|
|
|
src += 4;
|
|
|
|
if (src[1] != ':') /* native UNC path */
|
2008-07-25 23:23:56 +08:00
|
|
|
src += 2; /* Fortunately the first char is not copied... */
|
2008-05-23 19:00:35 +08:00
|
|
|
else
|
2008-07-25 23:23:56 +08:00
|
|
|
beg_src_slash = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
if (beg_src_slash && isdirsep (src[1]))
|
|
|
|
{
|
|
|
|
if (isdirsep (src[2]))
|
|
|
|
{
|
|
|
|
/* More than two slashes are just folded into one. */
|
2008-05-23 15:13:47 +08:00
|
|
|
src += 2;
|
2008-05-23 19:00:35 +08:00
|
|
|
while (isdirsep (src[1]))
|
|
|
|
++src;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Two slashes start a network or device path. */
|
|
|
|
*tail++ = '\\';
|
|
|
|
src++;
|
|
|
|
if (src[1] == '.' && isdirsep (src[2]))
|
|
|
|
{
|
2008-05-23 15:13:47 +08:00
|
|
|
*tail++ = '\\';
|
2008-05-23 19:00:35 +08:00
|
|
|
*tail++ = '.';
|
|
|
|
src += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-01-10 00:20:26 +08:00
|
|
|
if (tail == dst)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-01-10 00:20:26 +08:00
|
|
|
if (isdrive (src))
|
|
|
|
/* Always convert drive letter to uppercase for case sensitivity. */
|
|
|
|
*tail++ = cyg_toupper (*src++);
|
|
|
|
else if (*src != '/')
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-01-10 00:20:26 +08:00
|
|
|
if (beg_src_slash)
|
|
|
|
tail += cygheap->cwd.get_drive (dst);
|
|
|
|
else if (!cygheap->cwd.get (dst, 0))
|
|
|
|
return get_errno ();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tail = strchr (tail, '\0');
|
|
|
|
if (tail[-1] != '\\')
|
|
|
|
*tail++ = '\\';
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
while (*src)
|
|
|
|
{
|
|
|
|
/* Strip duplicate /'s. */
|
|
|
|
if (isdirsep (src[0]) && isdirsep (src[1]))
|
|
|
|
src++;
|
|
|
|
/* Ignore "./". */
|
|
|
|
else if (src[0] == '.' && isdirsep (src[1])
|
|
|
|
&& (src == src_start || isdirsep (src[-1])))
|
|
|
|
src += 2;
|
|
|
|
|
|
|
|
/* Backup if "..". */
|
|
|
|
else if (src[0] == '.' && src[1] == '.'
|
|
|
|
/* dst must be greater than dst_start */
|
|
|
|
&& tail[-1] == '\\')
|
|
|
|
{
|
|
|
|
if (!isdirsep (src[2]) && src[2] != '\0')
|
|
|
|
*tail++ = *src++;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Back up over /, but not if it's the first one. */
|
|
|
|
if (tail > dst + 1)
|
|
|
|
tail--;
|
|
|
|
/* Now back up to the next /. */
|
|
|
|
while (tail > dst + 1 && tail[-1] != '\\' && tail[-2] != ':')
|
|
|
|
tail--;
|
|
|
|
src += 2;
|
|
|
|
if (isdirsep (*src))
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Otherwise, add char to result. */
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (*src == '/')
|
|
|
|
*tail++ = '\\';
|
|
|
|
else
|
|
|
|
*tail++ = *src;
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
if ((tail - dst) >= NT_MAX_PATH)
|
|
|
|
return ENAMETOOLONG;
|
|
|
|
}
|
|
|
|
if (tail > dst + 1 && tail[-1] == '.' && tail[-2] == '\\')
|
|
|
|
tail--;
|
|
|
|
*tail = '\0';
|
|
|
|
debug_printf ("%s = normalize_win32_path (%s)", dst, src_start);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Various utilities. */
|
|
|
|
|
|
|
|
/* nofinalslash: Remove trailing / and \ from SRC (except for the
|
|
|
|
first one). It is ok for src == dst. */
|
|
|
|
|
|
|
|
void __stdcall
|
|
|
|
nofinalslash (const char *src, char *dst)
|
|
|
|
{
|
|
|
|
int len = strlen (src);
|
|
|
|
if (src != dst)
|
|
|
|
memcpy (dst, src, len + 1);
|
|
|
|
while (len > 1 && isdirsep (dst[--len]))
|
|
|
|
dst[len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* conv_path_list: Convert a list of path names to/from Win32/POSIX. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
conv_path_list (const char *src, char *dst, size_t size, int to_posix)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
char src_delim, dst_delim;
|
|
|
|
cygwin_conv_path_t conv_fn;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
if (to_posix)
|
|
|
|
{
|
|
|
|
src_delim = ';';
|
|
|
|
dst_delim = ':';
|
|
|
|
conv_fn = CCP_WIN_A_TO_POSIX | CCP_RELATIVE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
src_delim = ':';
|
|
|
|
dst_delim = ';';
|
|
|
|
conv_fn = CCP_POSIX_TO_WIN_A | CCP_RELATIVE;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
char *srcbuf;
|
|
|
|
len = strlen (src) + 1;
|
|
|
|
if (len <= NT_MAX_PATH * sizeof (WCHAR))
|
|
|
|
srcbuf = (char *) tp.w_get ();
|
|
|
|
else
|
|
|
|
srcbuf = (char *) alloca (len);
|
|
|
|
|
|
|
|
int err = 0;
|
|
|
|
char *d = dst - 1;
|
|
|
|
bool saw_empty = false;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
char *s = strccpy (srcbuf, &src, src_delim);
|
|
|
|
size_t len = s - srcbuf;
|
|
|
|
if (len >= NT_MAX_PATH)
|
|
|
|
{
|
|
|
|
err = ENAMETOOLONG;
|
2008-05-23 15:13:47 +08:00
|
|
|
break;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
if (len)
|
|
|
|
{
|
|
|
|
++d;
|
|
|
|
err = cygwin_conv_path (conv_fn, srcbuf, d, size - (d - dst));
|
|
|
|
}
|
|
|
|
else if (!to_posix)
|
|
|
|
{
|
|
|
|
++d;
|
|
|
|
err = cygwin_conv_path (conv_fn, ".", d, size - (d - dst));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (to_posix == ENV_CVT)
|
|
|
|
saw_empty = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
d = strchr (d, '\0');
|
|
|
|
*d = dst_delim;
|
|
|
|
}
|
|
|
|
while (*src++);
|
|
|
|
|
|
|
|
if (saw_empty)
|
|
|
|
err = EIDRM;
|
|
|
|
|
|
|
|
if (d < dst)
|
|
|
|
d++;
|
|
|
|
*d = '\0';
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/********************** Symbolic Link Support **************************/
|
|
|
|
|
|
|
|
/* Create a symlink from FROMPATH to TOPATH. */
|
|
|
|
|
|
|
|
/* If TRUE create symlinks as Windows shortcuts, if false create symlinks
|
|
|
|
as normal files with magic number and system bit set. */
|
2008-07-17 05:08:22 +08:00
|
|
|
bool allow_winsymlinks = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
symlink (const char *oldpath, const char *newpath)
|
|
|
|
{
|
|
|
|
return symlink_worker (oldpath, newpath, allow_winsymlinks, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_worker (const char *oldpath, const char *newpath, bool use_winsym,
|
|
|
|
bool isdevice)
|
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
size_t len;
|
|
|
|
path_conv win32_newpath, win32_oldpath;
|
|
|
|
char *buf, *cp;
|
|
|
|
SECURITY_ATTRIBUTES sa = sec_none_nih;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
NTSTATUS status;
|
|
|
|
HANDLE fh;
|
|
|
|
tmp_pathbuf tp;
|
2008-11-27 01:21:04 +08:00
|
|
|
unsigned check_opt;
|
2009-07-17 17:00:19 +08:00
|
|
|
bool mk_winsym = use_winsym;
|
2009-09-22 17:24:30 +08:00
|
|
|
bool has_trailing_dirsep = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
/* POSIX says that empty 'newpath' is invalid input while empty
|
|
|
|
'oldpath' is valid -- it's symlink resolver job to verify if
|
|
|
|
symlink contents point to existing filesystem object */
|
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted (EFAULT))
|
|
|
|
goto done;
|
|
|
|
if (!*oldpath || !*newpath)
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
goto done;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (strlen (oldpath) > SYMLINK_MAX)
|
|
|
|
{
|
|
|
|
set_errno (ENAMETOOLONG);
|
|
|
|
goto done;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Trailing dirsep is a no-no. */
|
2009-09-22 17:24:30 +08:00
|
|
|
len = strlen (newpath);
|
|
|
|
has_trailing_dirsep = isdirsep (newpath[len - 1]);
|
|
|
|
if (has_trailing_dirsep)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-09-22 17:24:30 +08:00
|
|
|
newpath = strdup (newpath);
|
|
|
|
((char *) newpath)[len - 1] = '\0';
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-11-27 01:21:04 +08:00
|
|
|
|
|
|
|
check_opt = PC_SYM_NOFOLLOW | PC_POSIX | (isdevice ? PC_NOWARN : 0);
|
2008-05-23 19:00:35 +08:00
|
|
|
/* We need the normalized full path below. */
|
2008-11-27 01:21:04 +08:00
|
|
|
win32_newpath.check (newpath, check_opt, stat_suffixes);
|
2009-07-17 17:00:19 +08:00
|
|
|
/* MVFS doesn't handle the SYSTEM DOS attribute, but it handles the R/O
|
|
|
|
attribute. Therefore we create symlinks on MVFS always as shortcuts. */
|
|
|
|
mk_winsym |= win32_newpath.fs_is_mvfs ();
|
|
|
|
|
|
|
|
if (mk_winsym && !win32_newpath.exists ()
|
2008-05-23 19:00:35 +08:00
|
|
|
&& (isdevice || !win32_newpath.fs_is_nfs ()))
|
|
|
|
{
|
|
|
|
char *newplnk = tp.c_get ();
|
|
|
|
stpcpy (stpcpy (newplnk, newpath), ".lnk");
|
2008-11-27 01:21:04 +08:00
|
|
|
win32_newpath.check (newplnk, check_opt);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (win32_newpath.error)
|
|
|
|
{
|
2008-07-17 04:20:45 +08:00
|
|
|
set_errno (win32_newpath.error);
|
2008-05-23 19:00:35 +08:00
|
|
|
goto done;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
syscall_printf ("symlink (%s, %S)", oldpath,
|
|
|
|
win32_newpath.get_nt_native_path ());
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if ((!isdevice && win32_newpath.exists ())
|
|
|
|
|| win32_newpath.is_auto_device ())
|
|
|
|
{
|
|
|
|
set_errno (EEXIST);
|
|
|
|
goto done;
|
|
|
|
}
|
2009-09-22 17:24:30 +08:00
|
|
|
if (has_trailing_dirsep && !win32_newpath.exists ())
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
goto done;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!isdevice && win32_newpath.fs_is_nfs ())
|
|
|
|
{
|
|
|
|
/* On NFS, create symlinks by calling NtCreateFile with an EA of type
|
|
|
|
NfsSymlinkTargetName containing ... the symlink target name. */
|
|
|
|
PFILE_FULL_EA_INFORMATION pffei = (PFILE_FULL_EA_INFORMATION) tp.w_get ();
|
|
|
|
pffei->NextEntryOffset = 0;
|
|
|
|
pffei->Flags = 0;
|
|
|
|
pffei->EaNameLength = sizeof (NFS_SYML_TARGET) - 1;
|
|
|
|
char *EaValue = stpcpy (pffei->EaName, NFS_SYML_TARGET) + 1;
|
|
|
|
pffei->EaValueLength = sizeof (WCHAR) *
|
|
|
|
(sys_mbstowcs ((PWCHAR) EaValue, NT_MAX_PATH, oldpath) - 1);
|
|
|
|
status = NtCreateFile (&fh, FILE_WRITE_DATA | FILE_WRITE_EA | SYNCHRONIZE,
|
|
|
|
win32_newpath.get_object_attr (attr, sa),
|
|
|
|
&io, NULL, FILE_ATTRIBUTE_SYSTEM,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_CREATE,
|
|
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT,
|
|
|
|
pffei, NT_MAX_PATH * sizeof (WCHAR));
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
NtClose (fh);
|
|
|
|
res = 0;
|
2008-05-23 15:13:47 +08:00
|
|
|
goto done;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2009-07-17 17:00:19 +08:00
|
|
|
if (mk_winsym)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
ITEMIDLIST *pidl = NULL;
|
|
|
|
size_t full_len = 0;
|
|
|
|
unsigned short oldpath_len, desc_len, relpath_len, pidl_len = 0;
|
|
|
|
char desc[MAX_PATH + 1], *relpath;
|
|
|
|
|
|
|
|
if (!isdevice)
|
|
|
|
{
|
|
|
|
/* First create an IDLIST to learn how big our shortcut is
|
|
|
|
going to be. */
|
|
|
|
IShellFolder *psl;
|
|
|
|
|
|
|
|
/* The symlink target is relative to the directory in which
|
|
|
|
the symlink gets created, not relative to the cwd. Therefore
|
|
|
|
we have to mangle the path quite a bit before calling path_conv. */
|
2008-11-27 01:21:04 +08:00
|
|
|
if (isabspath (oldpath))
|
|
|
|
win32_oldpath.check (oldpath,
|
|
|
|
PC_SYM_NOFOLLOW,
|
|
|
|
stat_suffixes);
|
|
|
|
else
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
len = strrchr (win32_newpath.normalized_path, '/')
|
|
|
|
- win32_newpath.normalized_path + 1;
|
|
|
|
char *absoldpath = tp.t_get ();
|
|
|
|
stpcpy (stpncpy (absoldpath, win32_newpath.normalized_path, len),
|
|
|
|
oldpath);
|
|
|
|
win32_oldpath.check (absoldpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
}
|
|
|
|
if (SUCCEEDED (SHGetDesktopFolder (&psl)))
|
|
|
|
{
|
|
|
|
WCHAR wc_path[win32_oldpath.get_wide_win32_path_len () + 1];
|
|
|
|
win32_oldpath.get_wide_win32_path (wc_path);
|
|
|
|
/* Amazing but true: Even though the ParseDisplayName method
|
|
|
|
takes a wide char path name, it does not understand the
|
|
|
|
Win32 prefix for long pathnames! So we have to tack off
|
|
|
|
the prefix and convert the path to the "normal" syntax
|
|
|
|
for ParseDisplayName. */
|
|
|
|
WCHAR *wc = wc_path + 4;
|
|
|
|
if (wc[1] != L':') /* native UNC path */
|
|
|
|
*(wc += 2) = L'\\';
|
|
|
|
HRESULT res;
|
|
|
|
if (SUCCEEDED (res = psl->ParseDisplayName (NULL, NULL, wc, NULL,
|
|
|
|
&pidl, NULL)))
|
|
|
|
{
|
|
|
|
ITEMIDLIST *p;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
for (p = pidl; p->mkid.cb > 0;
|
|
|
|
p = (ITEMIDLIST *)((char *) p + p->mkid.cb))
|
|
|
|
;
|
|
|
|
pidl_len = (char *) p - (char *) pidl + 2;
|
|
|
|
}
|
|
|
|
psl->Release ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Compute size of shortcut file. */
|
|
|
|
full_len = sizeof (win_shortcut_hdr);
|
|
|
|
if (pidl_len)
|
|
|
|
full_len += sizeof (unsigned short) + pidl_len;
|
|
|
|
oldpath_len = strlen (oldpath);
|
|
|
|
/* Unfortunately the length of the description is restricted to a
|
|
|
|
length of MAX_PATH up to NT4, and to a length of 2000 bytes
|
|
|
|
since W2K. We don't want to add considerations for the different
|
|
|
|
lengths and even 2000 bytes is not enough for long path names.
|
|
|
|
So what we do here is to set the description to the POSIX path
|
|
|
|
only if the path is not longer than MAX_PATH characters. We
|
|
|
|
append the full path name after the regular shortcut data
|
|
|
|
(see below), which works fine with Windows Explorer as well
|
|
|
|
as older Cygwin versions (as long as the whole file isn't bigger
|
|
|
|
than 8K). The description field is only used for backward
|
|
|
|
compatibility to older Cygwin versions and those versions are
|
|
|
|
not capable of handling long path names anyway. */
|
|
|
|
desc_len = stpcpy (desc, oldpath_len > MAX_PATH
|
|
|
|
? "[path too long]" : oldpath) - desc;
|
|
|
|
full_len += sizeof (unsigned short) + desc_len;
|
|
|
|
/* Devices get the oldpath string unchanged as relative path. */
|
|
|
|
if (isdevice)
|
|
|
|
{
|
|
|
|
relpath_len = oldpath_len;
|
|
|
|
stpcpy (relpath = tp.c_get (), oldpath);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
relpath_len = strlen (win32_oldpath.get_win32 ());
|
|
|
|
stpcpy (relpath = tp.c_get (), win32_oldpath.get_win32 ());
|
|
|
|
}
|
|
|
|
full_len += sizeof (unsigned short) + relpath_len;
|
|
|
|
full_len += sizeof (unsigned short) + oldpath_len;
|
|
|
|
/* 1 byte more for trailing 0 written by stpcpy. */
|
|
|
|
if (full_len < NT_MAX_PATH * sizeof (WCHAR))
|
|
|
|
buf = (char *) tp.w_get ();
|
|
|
|
else
|
|
|
|
buf = (char *) alloca (full_len + 1);
|
|
|
|
|
|
|
|
/* Create shortcut header */
|
|
|
|
win_shortcut_hdr *shortcut_header = (win_shortcut_hdr *) buf;
|
|
|
|
memset (shortcut_header, 0, sizeof *shortcut_header);
|
|
|
|
shortcut_header->size = sizeof *shortcut_header;
|
|
|
|
shortcut_header->magic = GUID_shortcut;
|
|
|
|
shortcut_header->flags = (WSH_FLAG_DESC | WSH_FLAG_RELPATH);
|
|
|
|
if (pidl)
|
|
|
|
shortcut_header->flags |= WSH_FLAG_IDLIST;
|
|
|
|
shortcut_header->run = SW_NORMAL;
|
|
|
|
cp = buf + sizeof (win_shortcut_hdr);
|
|
|
|
|
|
|
|
/* Create IDLIST */
|
|
|
|
if (pidl)
|
|
|
|
{
|
|
|
|
*(unsigned short *)cp = pidl_len;
|
|
|
|
memcpy (cp += 2, pidl, pidl_len);
|
|
|
|
cp += pidl_len;
|
|
|
|
CoTaskMemFree (pidl);
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Create description */
|
|
|
|
*(unsigned short *)cp = desc_len;
|
|
|
|
cp = stpcpy (cp += 2, desc);
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Create relpath */
|
|
|
|
*(unsigned short *)cp = relpath_len;
|
|
|
|
cp = stpcpy (cp += 2, relpath);
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Append the POSIX path after the regular shortcut data for
|
|
|
|
the long path support. */
|
2009-03-26 20:12:11 +08:00
|
|
|
unsigned short *plen = (unsigned short *) cp;
|
|
|
|
cp += 2;
|
|
|
|
*(PWCHAR) cp = 0xfeff; /* BOM */
|
|
|
|
cp += 2;
|
|
|
|
*plen = sys_mbstowcs ((PWCHAR) cp, NT_MAX_PATH, oldpath) * sizeof (WCHAR);
|
|
|
|
cp += *plen;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-03-26 20:12:11 +08:00
|
|
|
/* Default technique creating a symlink. */
|
|
|
|
buf = (char *) tp.w_get ();
|
|
|
|
cp = stpcpy (buf, SYMLINK_COOKIE);
|
|
|
|
*(PWCHAR) cp = 0xfeff; /* BOM */
|
|
|
|
cp += 2;
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Note that the terminating nul is written. */
|
2009-03-26 20:12:11 +08:00
|
|
|
cp += sys_mbstowcs ((PWCHAR) cp, NT_MAX_PATH, oldpath) * sizeof (WCHAR);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (isdevice && win32_newpath.exists ())
|
|
|
|
{
|
|
|
|
status = NtOpenFile (&fh, FILE_WRITE_ATTRIBUTES,
|
2008-05-23 15:13:47 +08:00
|
|
|
win32_newpath.get_object_attr (attr, sa),
|
2008-05-23 19:00:35 +08:00
|
|
|
&io, 0, FILE_OPEN_FOR_BACKUP_INTENT);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
goto done;
|
|
|
|
}
|
2008-10-21 03:30:06 +08:00
|
|
|
status = NtSetAttributesFile (fh, FILE_ATTRIBUTE_NORMAL);
|
2008-05-23 19:00:35 +08:00
|
|
|
NtClose (fh);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
status = NtCreateFile (&fh, DELETE | FILE_GENERIC_WRITE,
|
|
|
|
win32_newpath.get_object_attr (attr, sa),
|
|
|
|
&io, NULL, FILE_ATTRIBUTE_NORMAL,
|
|
|
|
FILE_SHARE_VALID_FLAGS,
|
|
|
|
isdevice ? FILE_OVERWRITE_IF : FILE_CREATE,
|
|
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_NON_DIRECTORY_FILE
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT,
|
|
|
|
NULL, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
goto done;
|
|
|
|
}
|
2009-10-31 03:58:53 +08:00
|
|
|
if (win32_newpath.has_acls ())
|
2008-08-14 22:05:04 +08:00
|
|
|
set_file_attribute (fh, win32_newpath, ILLEGAL_UID, ILLEGAL_GID,
|
2009-10-31 03:58:53 +08:00
|
|
|
(io.Information == FILE_CREATED ? S_JUSTCREATED : 0)
|
|
|
|
| S_IFLNK | STD_RBITS | STD_WBITS);
|
2008-05-23 19:00:35 +08:00
|
|
|
status = NtWriteFile (fh, NULL, NULL, NULL, &io, buf, cp - buf, NULL, NULL);
|
|
|
|
if (NT_SUCCESS (status) && io.Information == (ULONG) (cp - buf))
|
|
|
|
{
|
2009-07-17 17:00:19 +08:00
|
|
|
status = NtSetAttributesFile (fh, mk_winsym ? FILE_ATTRIBUTE_READONLY
|
|
|
|
: FILE_ATTRIBUTE_SYSTEM);
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("Setting attributes failed, status = %p", status);
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
FILE_DISPOSITION_INFORMATION fdi = { TRUE };
|
|
|
|
status = NtSetInformationFile (fh, &io, &fdi, sizeof fdi,
|
|
|
|
FileDispositionInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("Setting delete dispostion failed, status = %p", status);
|
|
|
|
}
|
|
|
|
NtClose (fh);
|
|
|
|
|
|
|
|
done:
|
|
|
|
syscall_printf ("%d = symlink_worker (%s, %s, %d, %d)", res, oldpath,
|
2009-07-17 17:00:19 +08:00
|
|
|
newpath, mk_winsym, isdevice);
|
2009-09-22 17:24:30 +08:00
|
|
|
if (has_trailing_dirsep)
|
|
|
|
free ((void *) newpath);
|
2008-05-23 19:00:35 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
cmp_shortcut_header (win_shortcut_hdr *file_header)
|
|
|
|
{
|
|
|
|
/* A Cygwin or U/Win shortcut only contains a description and a relpath.
|
|
|
|
Cygwin shortcuts also might contain an ITEMIDLIST. The run type is
|
|
|
|
always set to SW_NORMAL. */
|
|
|
|
return file_header->size == sizeof (win_shortcut_hdr)
|
|
|
|
&& !memcmp (&file_header->magic, &GUID_shortcut, sizeof GUID_shortcut)
|
|
|
|
&& (file_header->flags & ~WSH_FLAG_IDLIST)
|
|
|
|
== (WSH_FLAG_DESC | WSH_FLAG_RELPATH)
|
|
|
|
&& file_header->run == SW_NORMAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::check_shortcut (HANDLE in_h)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
win_shortcut_hdr *file_header;
|
|
|
|
char *buf, *cp;
|
|
|
|
unsigned short len;
|
|
|
|
int res = 0;
|
|
|
|
UNICODE_STRING same = { 0, 0, (PWCHAR) L"" };
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
NTSTATUS status;
|
|
|
|
HANDLE h;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
FILE_STANDARD_INFORMATION fsi;
|
|
|
|
|
|
|
|
InitializeObjectAttributes (&attr, &same, 0, in_h, NULL);
|
|
|
|
status = NtOpenFile (&h, FILE_READ_DATA | SYNCHRONIZE,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT
|
|
|
|
| FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
if (!NT_SUCCESS (status))
|
2008-08-20 18:53:54 +08:00
|
|
|
return 0;
|
2008-05-23 19:00:35 +08:00
|
|
|
status = NtQueryInformationFile (h, &io, &fsi, sizeof fsi,
|
|
|
|
FileStandardInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
set_error (EIO);
|
2008-05-23 15:13:47 +08:00
|
|
|
goto out;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
if (fsi.EndOfFile.QuadPart <= sizeof (win_shortcut_hdr)
|
|
|
|
|| fsi.EndOfFile.QuadPart > 4 * 65536)
|
|
|
|
goto out;
|
|
|
|
if (fsi.EndOfFile.LowPart < NT_MAX_PATH * sizeof (WCHAR))
|
|
|
|
buf = (char *) tp.w_get ();
|
|
|
|
else
|
|
|
|
buf = (char *) alloca (fsi.EndOfFile.LowPart + 1);
|
|
|
|
if (!NT_SUCCESS (NtReadFile (h, NULL, NULL, NULL,
|
|
|
|
&io, buf, fsi.EndOfFile.LowPart, NULL, NULL)))
|
|
|
|
{
|
|
|
|
set_error (EIO);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
file_header = (win_shortcut_hdr *) buf;
|
|
|
|
if (io.Information != fsi.EndOfFile.LowPart
|
|
|
|
|| !cmp_shortcut_header (file_header))
|
2008-10-09 16:56:09 +08:00
|
|
|
goto out;
|
2008-05-23 19:00:35 +08:00
|
|
|
cp = buf + sizeof (win_shortcut_hdr);
|
|
|
|
if (file_header->flags & WSH_FLAG_IDLIST) /* Skip ITEMIDLIST */
|
|
|
|
cp += *(unsigned short *) cp + 2;
|
|
|
|
if (!(len = *(unsigned short *) cp))
|
2008-10-09 16:56:09 +08:00
|
|
|
goto out;
|
2008-05-23 19:00:35 +08:00
|
|
|
cp += 2;
|
|
|
|
/* Check if this is a device file - these start with the sequence :\\ */
|
|
|
|
if (strncmp (cp, ":\\", 2) == 0)
|
|
|
|
res = strlen (strcpy (contents, cp)); /* Don't mess with device files */
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Has appended full path? If so, use it instead of description. */
|
|
|
|
unsigned short relpath_len = *(unsigned short *) (cp + len);
|
|
|
|
if (cp + len + 2 + relpath_len < buf + fsi.EndOfFile.LowPart)
|
|
|
|
{
|
|
|
|
cp += len + 2 + relpath_len;
|
|
|
|
len = *(unsigned short *) cp;
|
|
|
|
cp += 2;
|
|
|
|
}
|
2009-03-26 20:12:11 +08:00
|
|
|
if (*(PWCHAR) cp == 0xfeff) /* BOM */
|
|
|
|
{
|
|
|
|
char *tmpbuf = tp.c_get ();
|
|
|
|
if (sys_wcstombs (tmpbuf, NT_MAX_PATH, (PWCHAR) (cp + 2))
|
|
|
|
> SYMLINK_MAX + 1)
|
|
|
|
goto out;
|
|
|
|
res = posixify (tmpbuf);
|
|
|
|
}
|
|
|
|
else if (len > SYMLINK_MAX)
|
2008-10-09 16:56:09 +08:00
|
|
|
goto out;
|
2009-03-26 20:12:11 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
cp[len] = '\0';
|
|
|
|
res = posixify (cp);
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
if (res) /* It's a symlink. */
|
|
|
|
pflags = PATH_SYMLINK | PATH_LNK;
|
|
|
|
|
|
|
|
out:
|
|
|
|
NtClose (h);
|
2008-12-25 00:34:38 +08:00
|
|
|
return res;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::check_sysfile (HANDLE in_h)
|
|
|
|
{
|
2009-03-26 20:12:11 +08:00
|
|
|
tmp_pathbuf tp;
|
2008-05-23 19:00:35 +08:00
|
|
|
char cookie_buf[sizeof (SYMLINK_COOKIE) - 1];
|
2009-03-26 20:12:11 +08:00
|
|
|
char *srcbuf = tp.c_get ();
|
2008-05-23 19:00:35 +08:00
|
|
|
int res = 0;
|
|
|
|
UNICODE_STRING same = { 0, 0, (PWCHAR) L"" };
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
NTSTATUS status;
|
|
|
|
HANDLE h;
|
|
|
|
IO_STATUS_BLOCK io;
|
2009-08-27 04:32:35 +08:00
|
|
|
bool interix_symlink = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
InitializeObjectAttributes (&attr, &same, 0, in_h, NULL);
|
|
|
|
status = NtOpenFile (&h, FILE_READ_DATA | SYNCHRONIZE,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT
|
|
|
|
| FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
if (!NT_SUCCESS (status))
|
2008-08-20 18:53:54 +08:00
|
|
|
;
|
2008-05-23 19:00:35 +08:00
|
|
|
else if (!NT_SUCCESS (status = NtReadFile (h, NULL, NULL, NULL, &io,
|
|
|
|
cookie_buf, sizeof (cookie_buf),
|
|
|
|
NULL, NULL)))
|
|
|
|
{
|
|
|
|
debug_printf ("ReadFile1 failed");
|
|
|
|
if (status != STATUS_END_OF_FILE)
|
2008-05-23 15:13:47 +08:00
|
|
|
set_error (EIO);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
else if (io.Information == sizeof (cookie_buf)
|
|
|
|
&& memcmp (cookie_buf, SYMLINK_COOKIE, sizeof (cookie_buf)) == 0)
|
|
|
|
{
|
|
|
|
/* It's a symlink. */
|
|
|
|
pflags = PATH_SYMLINK;
|
2009-08-27 04:32:35 +08:00
|
|
|
}
|
|
|
|
else if (io.Information == sizeof (cookie_buf)
|
|
|
|
&& memcmp (cookie_buf, SOCKET_COOKIE, sizeof (cookie_buf)) == 0)
|
|
|
|
pflags |= PATH_SOCKET;
|
|
|
|
else if (io.Information >= sizeof (INTERIX_SYMLINK_COOKIE)
|
|
|
|
&& memcmp (cookie_buf, INTERIX_SYMLINK_COOKIE,
|
|
|
|
sizeof (INTERIX_SYMLINK_COOKIE) - 1) == 0)
|
|
|
|
{
|
|
|
|
/* It's an Interix symlink. */
|
|
|
|
pflags = PATH_SYMLINK;
|
|
|
|
interix_symlink = true;
|
|
|
|
/* Interix symlink cookies are shorter than Cygwin symlink cookies, so
|
|
|
|
in case of an Interix symlink cooky we have read too far into the
|
|
|
|
file. Set file pointer back to the position right after the cookie. */
|
|
|
|
FILE_POSITION_INFORMATION fpi;
|
|
|
|
fpi.CurrentByteOffset.QuadPart = sizeof (INTERIX_SYMLINK_COOKIE) - 1;
|
|
|
|
NtSetInformationFile (h, &io, &fpi, sizeof fpi, FilePositionInformation);
|
|
|
|
}
|
|
|
|
if (pflags == PATH_SYMLINK)
|
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
status = NtReadFile (h, NULL, NULL, NULL, &io, srcbuf,
|
2009-03-26 20:12:11 +08:00
|
|
|
NT_MAX_PATH, NULL, NULL);
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
debug_printf ("ReadFile2 failed");
|
|
|
|
if (status != STATUS_END_OF_FILE)
|
|
|
|
set_error (EIO);
|
|
|
|
}
|
2009-08-27 04:32:35 +08:00
|
|
|
else if (*(PWCHAR) srcbuf == 0xfeff /* BOM */
|
|
|
|
|| interix_symlink)
|
2009-03-26 20:12:11 +08:00
|
|
|
{
|
2009-08-27 04:32:35 +08:00
|
|
|
/* Add trailing 0 to Interix symlink target. Skip BOM in Cygwin
|
|
|
|
symlinks. */
|
|
|
|
if (interix_symlink)
|
|
|
|
((PWCHAR) srcbuf)[io.Information / sizeof (WCHAR)] = L'\0';
|
|
|
|
else
|
|
|
|
srcbuf += 2;
|
2009-03-26 20:12:11 +08:00
|
|
|
char *tmpbuf = tp.c_get ();
|
2009-08-27 04:32:35 +08:00
|
|
|
if (sys_wcstombs (tmpbuf, NT_MAX_PATH, (PWCHAR) srcbuf)
|
2009-03-26 20:12:11 +08:00
|
|
|
> SYMLINK_MAX + 1)
|
|
|
|
debug_printf ("symlink string too long");
|
|
|
|
else
|
|
|
|
res = posixify (tmpbuf);
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
else if (io.Information > SYMLINK_MAX + 1)
|
|
|
|
debug_printf ("symlink string too long");
|
|
|
|
else
|
|
|
|
res = posixify (srcbuf);
|
|
|
|
}
|
|
|
|
NtClose (h);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::check_reparse_point (HANDLE h)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
PREPARSE_DATA_BUFFER rp = (PREPARSE_DATA_BUFFER) tp.c_get ();
|
2009-11-10 16:54:24 +08:00
|
|
|
UNICODE_STRING subst;
|
2008-05-23 19:00:35 +08:00
|
|
|
char srcbuf[SYMLINK_MAX + 7];
|
|
|
|
|
|
|
|
status = NtFsControlFile (h, NULL, NULL, NULL, &io, FSCTL_GET_REPARSE_POINT,
|
|
|
|
NULL, 0, (LPVOID) rp,
|
|
|
|
MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
debug_printf ("NtFsControlFile(FSCTL_GET_REPARSE_POINT) failed, %p",
|
|
|
|
status);
|
|
|
|
set_error (EIO);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (rp->ReparseTag == IO_REPARSE_TAG_SYMLINK)
|
2009-11-10 16:54:24 +08:00
|
|
|
RtlInitCountedUnicodeString (&subst,
|
|
|
|
(WCHAR *)((char *)rp->SymbolicLinkReparseBuffer.PathBuffer
|
|
|
|
+ rp->SymbolicLinkReparseBuffer.SubstituteNameOffset),
|
|
|
|
rp->SymbolicLinkReparseBuffer.SubstituteNameLength);
|
2008-05-23 19:00:35 +08:00
|
|
|
else if (rp->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
|
|
|
|
{
|
2009-08-24 19:14:30 +08:00
|
|
|
RtlInitCountedUnicodeString (&subst,
|
|
|
|
(WCHAR *)((char *)rp->MountPointReparseBuffer.PathBuffer
|
|
|
|
+ rp->MountPointReparseBuffer.SubstituteNameOffset),
|
|
|
|
rp->MountPointReparseBuffer.SubstituteNameLength);
|
2009-11-10 03:46:36 +08:00
|
|
|
if (RtlEqualUnicodePathPrefix (&subst, &ro_u_volume, TRUE))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2009-08-25 19:27:03 +08:00
|
|
|
/* Volume mount point. Not treated as symlink. The return
|
|
|
|
value of -1 is a hint for the caller to treat this as a
|
|
|
|
volume mount point. */
|
|
|
|
return -1;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
2009-11-10 16:54:24 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Maybe it's a reparse point, but it's certainly not one we
|
|
|
|
recognize. Drop the REPARSE file attribute so we don't even
|
|
|
|
try to use the flag for some special handling. It's just some
|
|
|
|
arbitrary file or directory for us. */
|
|
|
|
fileattr &= ~FILE_ATTRIBUTE_REPARSE_POINT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
sys_wcstombs (srcbuf, SYMLINK_MAX + 7, subst.Buffer,
|
|
|
|
subst.Length / sizeof (WCHAR));
|
|
|
|
pflags = PATH_SYMLINK | PATH_REP;
|
|
|
|
fileattr &= ~FILE_ATTRIBUTE_DIRECTORY;
|
2008-05-23 19:00:35 +08:00
|
|
|
return posixify (srcbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::check_nfs_symlink (HANDLE h)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
struct {
|
|
|
|
FILE_GET_EA_INFORMATION fgei;
|
|
|
|
char buf[sizeof (NFS_SYML_TARGET)];
|
|
|
|
} fgei_buf;
|
|
|
|
PFILE_FULL_EA_INFORMATION pffei;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
/* To find out if the file is a symlink and to get the symlink target,
|
|
|
|
try to fetch the NfsSymlinkTargetName EA. */
|
|
|
|
fgei_buf.fgei.NextEntryOffset = 0;
|
|
|
|
fgei_buf.fgei.EaNameLength = sizeof (NFS_SYML_TARGET) - 1;
|
|
|
|
stpcpy (fgei_buf.fgei.EaName, NFS_SYML_TARGET);
|
|
|
|
pffei = (PFILE_FULL_EA_INFORMATION) tp.w_get ();
|
|
|
|
status = NtQueryEaFile (h, &io, pffei, NT_MAX_PATH * sizeof (WCHAR), TRUE,
|
|
|
|
&fgei_buf.fgei, sizeof fgei_buf, NULL, TRUE);
|
|
|
|
if (NT_SUCCESS (status) && pffei->EaValueLength > 0)
|
|
|
|
{
|
|
|
|
PWCHAR spath = (PWCHAR)
|
|
|
|
(pffei->EaName + pffei->EaNameLength + 1);
|
|
|
|
res = sys_wcstombs (contents, SYMLINK_MAX + 1,
|
|
|
|
spath, pffei->EaValueLength);
|
|
|
|
pflags = PATH_SYMLINK;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::posixify (char *srcbuf)
|
|
|
|
{
|
|
|
|
/* The definition for a path in a native symlink is a bit weird. The Flags
|
|
|
|
value seem to contain 0 for absolute paths (stored as NT native path)
|
|
|
|
and 1 for relative paths. Relative paths are paths not starting with a
|
|
|
|
drive letter. These are not converted to NT native, but stored as
|
|
|
|
given. A path starting with a single backslash is relative to the
|
|
|
|
current drive thus a "relative" value (Flags == 1).
|
|
|
|
Funny enough it's possible to store paths with slashes instead of
|
|
|
|
backslashes, but they are evaluated incorrectly by subsequent Windows
|
|
|
|
calls like CreateFile (ERROR_INVALID_NAME). So, what we do here is to
|
|
|
|
take paths starting with slashes at face value, evaluating them as
|
|
|
|
Cygwin specific POSIX paths.
|
|
|
|
A path starting with two slashes(!) or backslashes is converted into an
|
|
|
|
NT UNC path. Unfortunately, in contrast to POSIX rules, paths starting
|
|
|
|
with three or more (back)slashes are also converted into UNC paths,
|
|
|
|
just incorrectly sticking to one redundant leading backslashe. We go
|
|
|
|
along with this behaviour to avoid scenarios in which native tools access
|
|
|
|
other files than Cygwin.
|
|
|
|
The above rules are used exactly the same way on Cygwin specific symlinks
|
|
|
|
(sysfiles and shortcuts) to eliminate non-POSIX paths in the output. */
|
|
|
|
|
|
|
|
/* Eliminate native NT prefixes. */
|
|
|
|
if (srcbuf[0] == '\\' && !strncmp (srcbuf + 1, "??\\", 3))
|
|
|
|
{
|
|
|
|
srcbuf += 4;
|
|
|
|
if (srcbuf[1] != ':') /* native UNC path */
|
|
|
|
*(srcbuf += 2) = '\\';
|
|
|
|
}
|
|
|
|
if (isdrive (srcbuf))
|
|
|
|
mount_table->conv_to_posix_path (srcbuf, contents, 0);
|
|
|
|
else if (srcbuf[0] == '\\')
|
|
|
|
{
|
|
|
|
if (srcbuf[1] == '\\') /* UNC path */
|
|
|
|
slashify (srcbuf, contents, 0);
|
|
|
|
else /* Paths starting with \ are current drive relative. */
|
|
|
|
{
|
|
|
|
char cvtbuf[SYMLINK_MAX + 1];
|
|
|
|
|
|
|
|
stpcpy (cvtbuf + cygheap->cwd.get_drive (cvtbuf), srcbuf);
|
|
|
|
mount_table->conv_to_posix_path (cvtbuf, contents, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* Everything else is taken as is. */
|
|
|
|
slashify (srcbuf, contents, 0);
|
|
|
|
return strlen (contents);
|
|
|
|
}
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
SCAN_BEG,
|
|
|
|
SCAN_LNK,
|
|
|
|
SCAN_HASLNK,
|
|
|
|
SCAN_JUSTCHECK,
|
|
|
|
SCAN_JUSTCHECKTHIS, /* Never try to append a suffix. */
|
|
|
|
SCAN_APPENDLNK,
|
|
|
|
SCAN_EXTRALNK,
|
|
|
|
SCAN_DONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
class suffix_scan
|
|
|
|
{
|
|
|
|
const suffix_info *suffixes, *suffixes_start;
|
|
|
|
int nextstate;
|
|
|
|
char *eopath;
|
|
|
|
public:
|
|
|
|
const char *path;
|
|
|
|
char *has (const char *, const suffix_info *);
|
|
|
|
int next ();
|
|
|
|
int lnk_match () {return nextstate >= SCAN_APPENDLNK;}
|
|
|
|
};
|
|
|
|
|
|
|
|
char *
|
|
|
|
suffix_scan::has (const char *in_path, const suffix_info *in_suffixes)
|
|
|
|
{
|
|
|
|
nextstate = SCAN_BEG;
|
|
|
|
suffixes = suffixes_start = in_suffixes;
|
|
|
|
|
|
|
|
const char *fname = strrchr (in_path, '\\');
|
|
|
|
fname = fname ? fname + 1 : in_path;
|
|
|
|
char *ext_here = strrchr (fname, '.');
|
|
|
|
path = in_path;
|
|
|
|
eopath = strchr (path, '\0');
|
|
|
|
|
|
|
|
if (!ext_here)
|
|
|
|
goto noext;
|
|
|
|
|
|
|
|
if (suffixes)
|
|
|
|
{
|
|
|
|
/* Check if the extension matches a known extension */
|
|
|
|
for (const suffix_info *ex = in_suffixes; ex->name != NULL; ex++)
|
|
|
|
if (ascii_strcasematch (ext_here, ex->name))
|
2008-05-23 15:13:47 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
nextstate = SCAN_JUSTCHECK;
|
|
|
|
suffixes = NULL; /* Has an extension so don't scan for one. */
|
|
|
|
goto done;
|
2008-05-23 15:13:47 +08:00
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Didn't match. Use last resort -- .lnk. */
|
|
|
|
if (ascii_strcasematch (ext_here, ".lnk"))
|
|
|
|
{
|
|
|
|
nextstate = SCAN_HASLNK;
|
|
|
|
suffixes = NULL;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
noext:
|
|
|
|
ext_here = eopath;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
done:
|
|
|
|
/* Avoid attaching suffixes if the resulting filename would be invalid. */
|
|
|
|
if (eopath - fname > NAME_MAX - 4)
|
|
|
|
{
|
|
|
|
nextstate = SCAN_JUSTCHECKTHIS;
|
|
|
|
suffixes = NULL;
|
|
|
|
}
|
|
|
|
return ext_here;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
int
|
|
|
|
suffix_scan::next ()
|
|
|
|
{
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
if (!suffixes)
|
|
|
|
switch (nextstate)
|
2008-05-23 15:13:47 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
case SCAN_BEG:
|
|
|
|
suffixes = suffixes_start;
|
|
|
|
if (!suffixes)
|
|
|
|
{
|
|
|
|
nextstate = SCAN_LNK;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
nextstate = SCAN_EXTRALNK;
|
|
|
|
/* fall through to suffix checking below */
|
|
|
|
break;
|
|
|
|
case SCAN_HASLNK:
|
|
|
|
nextstate = SCAN_APPENDLNK; /* Skip SCAN_BEG */
|
|
|
|
return 1;
|
|
|
|
case SCAN_EXTRALNK:
|
|
|
|
nextstate = SCAN_DONE;
|
|
|
|
*eopath = '\0';
|
|
|
|
return 0;
|
|
|
|
case SCAN_JUSTCHECK:
|
|
|
|
nextstate = SCAN_LNK;
|
|
|
|
return 1;
|
|
|
|
case SCAN_JUSTCHECKTHIS:
|
|
|
|
nextstate = SCAN_DONE;
|
|
|
|
return 1;
|
|
|
|
case SCAN_LNK:
|
|
|
|
case SCAN_APPENDLNK:
|
|
|
|
strcat (eopath, ".lnk");
|
|
|
|
nextstate = SCAN_DONE;
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
*eopath = '\0';
|
2008-05-23 15:13:47 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
while (suffixes && suffixes->name)
|
|
|
|
if (nextstate == SCAN_EXTRALNK && !suffixes->addon)
|
|
|
|
suffixes++;
|
|
|
|
else
|
2008-05-23 15:13:47 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
strcpy (eopath, suffixes->name);
|
|
|
|
if (nextstate == SCAN_EXTRALNK)
|
|
|
|
strcat (eopath, ".lnk");
|
|
|
|
suffixes++;
|
|
|
|
return 1;
|
2008-05-23 15:13:47 +08:00
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
suffixes = NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
bool
|
|
|
|
symlink_info::set_error (int in_errno)
|
|
|
|
{
|
|
|
|
bool res;
|
|
|
|
if (!(pflags & PATH_NO_ACCESS_CHECK) || in_errno == ENAMETOOLONG || in_errno == EIO)
|
|
|
|
{
|
|
|
|
error = in_errno;
|
|
|
|
res = true;
|
|
|
|
}
|
|
|
|
else if (in_errno == ENOENT)
|
|
|
|
res = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fileattr = FILE_ATTRIBUTE_NORMAL;
|
|
|
|
res = false;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
symlink_info::parse_device (const char *contents)
|
|
|
|
{
|
|
|
|
char *endptr;
|
|
|
|
_major_t mymajor;
|
|
|
|
_major_t myminor;
|
|
|
|
_mode_t mymode;
|
|
|
|
|
|
|
|
mymajor = strtol (contents += 2, &endptr, 16);
|
|
|
|
if (endptr == contents)
|
|
|
|
return isdevice = false;
|
|
|
|
|
|
|
|
contents = endptr;
|
|
|
|
myminor = strtol (++contents, &endptr, 16);
|
|
|
|
if (endptr == contents)
|
|
|
|
return isdevice = false;
|
|
|
|
|
|
|
|
contents = endptr;
|
|
|
|
mymode = strtol (++contents, &endptr, 16);
|
|
|
|
if (endptr == contents)
|
|
|
|
return isdevice = false;
|
|
|
|
|
|
|
|
if ((mymode & S_IFMT) == S_IFIFO)
|
|
|
|
{
|
|
|
|
mymajor = _major (FH_FIFO);
|
|
|
|
myminor = _minor (FH_FIFO);
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
major = mymajor;
|
|
|
|
minor = myminor;
|
|
|
|
mode = mymode;
|
|
|
|
return isdevice = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if PATH is a symlink. PATH must be a valid Win32 path name.
|
|
|
|
|
|
|
|
If PATH is a symlink, put the value of the symlink--the file to
|
|
|
|
which it points--into BUF. The value stored in BUF is not
|
|
|
|
necessarily null terminated. BUFLEN is the length of BUF; only up
|
|
|
|
to BUFLEN characters will be stored in BUF. BUF may be NULL, in
|
|
|
|
which case nothing will be stored.
|
|
|
|
|
|
|
|
Set *SYML if PATH is a symlink.
|
|
|
|
|
|
|
|
Set *EXEC if PATH appears to be executable. This is an efficiency
|
|
|
|
hack because we sometimes have to open the file anyhow. *EXEC will
|
|
|
|
not be set for every executable file.
|
|
|
|
|
|
|
|
Return -1 on error, 0 if PATH is not a symlink, or the length
|
|
|
|
stored into BUF if PATH is a symlink. */
|
|
|
|
|
|
|
|
int
|
|
|
|
symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt,
|
|
|
|
fs_info &fs)
|
|
|
|
{
|
|
|
|
HANDLE h = NULL;
|
|
|
|
int res = 0;
|
|
|
|
suffix_scan suffix;
|
|
|
|
contents[0] = '\0';
|
|
|
|
|
|
|
|
issymlink = true;
|
|
|
|
isdevice = false;
|
|
|
|
ext_here = suffix.has (path, suffixes);
|
|
|
|
extn = ext_here - path;
|
|
|
|
major = 0;
|
|
|
|
minor = 0;
|
|
|
|
mode = 0;
|
|
|
|
pflags &= ~(PATH_SYMLINK | PATH_LNK | PATH_REP);
|
2008-07-17 04:20:45 +08:00
|
|
|
ULONG ci_flag = cygwin_shared->obcaseinsensitive || (pflags & PATH_NOPOSIX)
|
|
|
|
? OBJ_CASE_INSENSITIVE : 0;
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
/* TODO: Temporarily do all char->UNICODE conversion here. This should
|
|
|
|
already be slightly faster than using Ascii functions. */
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
UNICODE_STRING upath;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
tp.u_get (&upath);
|
2008-07-17 04:20:45 +08:00
|
|
|
InitializeObjectAttributes (&attr, &upath, ci_flag, NULL, NULL);
|
2008-05-23 19:00:35 +08:00
|
|
|
|
2008-05-24 01:22:18 +08:00
|
|
|
PVOID eabuf = &nfs_aol_ffei;
|
2008-05-23 19:00:35 +08:00
|
|
|
ULONG easize = sizeof nfs_aol_ffei;
|
|
|
|
|
|
|
|
while (suffix.next ())
|
|
|
|
{
|
|
|
|
FILE_BASIC_INFORMATION fbi;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
2008-05-24 01:22:18 +08:00
|
|
|
bool no_ea = false;
|
2009-01-30 04:32:08 +08:00
|
|
|
bool fs_update_called = false;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
error = 0;
|
2008-07-17 04:20:45 +08:00
|
|
|
get_nt_native_path (suffix.path, upath);
|
2008-05-23 19:00:35 +08:00
|
|
|
if (h)
|
|
|
|
{
|
|
|
|
NtClose (h);
|
|
|
|
h = NULL;
|
|
|
|
}
|
|
|
|
/* The EA given to NtCreateFile allows to get a handle to a symlink on
|
|
|
|
an NFS share, rather than getting a handle to the target of the
|
|
|
|
symlink (which would spoil the task of this method quite a bit).
|
|
|
|
Fortunately it's ignored on most other file systems so we don't have
|
|
|
|
to special case NFS too much. */
|
|
|
|
status = NtCreateFile (&h,
|
|
|
|
READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_READ_EA,
|
2008-08-15 18:19:12 +08:00
|
|
|
&attr, &io, NULL, 0, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN,
|
2008-05-23 19:00:35 +08:00
|
|
|
FILE_OPEN_REPARSE_POINT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT,
|
|
|
|
eabuf, easize);
|
|
|
|
/* No right to access EAs or EAs not supported? */
|
2009-01-10 00:20:26 +08:00
|
|
|
if (status == STATUS_ACCESS_DENIED || status == STATUS_EAS_NOT_SUPPORTED
|
2009-07-23 02:21:09 +08:00
|
|
|
|| status == STATUS_NOT_SUPPORTED
|
2009-01-12 00:13:11 +08:00
|
|
|
/* Or a bug in Samba 3.2.x (x <= 7) when accessing a share's root dir
|
|
|
|
which has EAs enabled? */
|
2009-01-10 00:20:26 +08:00
|
|
|
|| status == STATUS_INVALID_PARAMETER)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
2008-05-24 01:22:18 +08:00
|
|
|
no_ea = true;
|
2008-05-23 19:00:35 +08:00
|
|
|
/* If EAs are not supported, there's no sense to check them again
|
2009-07-22 23:55:47 +08:00
|
|
|
with suffixes attached. So we set eabuf/easize to 0 here once. */
|
2009-07-23 02:21:09 +08:00
|
|
|
if (status == STATUS_EAS_NOT_SUPPORTED
|
|
|
|
|| status == STATUS_NOT_SUPPORTED)
|
2005-06-07 00:58:39 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
eabuf = NULL;
|
|
|
|
easize = 0;
|
2007-08-23 15:43:24 +08:00
|
|
|
}
|
2008-08-15 18:19:12 +08:00
|
|
|
status = NtOpenFile (&h, READ_CONTROL | FILE_READ_ATTRIBUTES,
|
2008-12-14 14:01:46 +08:00
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
2008-08-15 18:19:12 +08:00
|
|
|
FILE_OPEN_REPARSE_POINT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2009-01-30 04:32:08 +08:00
|
|
|
if (status == STATUS_OBJECT_NAME_NOT_FOUND && ci_flag == 0
|
|
|
|
&& wincap.has_broken_udf ())
|
|
|
|
{
|
|
|
|
/* On NT 5.x UDF is broken (at least) in terms of case sensitivity.
|
|
|
|
When trying to open a file case sensitive, the file appears to be
|
|
|
|
non-existant. Another bug is described in fs_info::update. */
|
|
|
|
attr.Attributes = OBJ_CASE_INSENSITIVE;
|
|
|
|
status = NtOpenFile (&h, READ_CONTROL | FILE_READ_ATTRIBUTES,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_REPARSE_POINT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT);
|
2009-03-13 06:03:28 +08:00
|
|
|
attr.Attributes = 0;
|
2009-01-30 04:32:08 +08:00
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
fs.update (&upath, h);
|
|
|
|
if (fs.is_udf ())
|
|
|
|
fs_update_called = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
NtClose (h);
|
|
|
|
status = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
if (NT_SUCCESS (status)
|
|
|
|
&& NT_SUCCESS (status
|
|
|
|
= NtQueryInformationFile (h, &io, &fbi, sizeof fbi,
|
|
|
|
FileBasicInformation)))
|
|
|
|
fileattr = fbi.FileAttributes;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("%p = NtQueryInformationFile (%S)", status, &upath);
|
|
|
|
h = NULL;
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
|
|
|
|
/* One of the inner path components is invalid, or the path contains
|
|
|
|
invalid characters. Bail out with ENOENT.
|
|
|
|
|
|
|
|
Note that additional STATUS_OBJECT_PATH_INVALID and
|
|
|
|
STATUS_OBJECT_PATH_SYNTAX_BAD status codes exist. The first one
|
|
|
|
is seemingly not generated by NtQueryAttributesFile, the latter
|
|
|
|
is only generated if the path is no absolute path within the
|
|
|
|
NT name space, which should not happen and would point to an
|
|
|
|
error in get_nt_native_path. Both status codes are deliberately
|
|
|
|
not tested here unless proved necessary. */
|
|
|
|
if (status == STATUS_OBJECT_PATH_NOT_FOUND
|
2009-06-08 23:22:52 +08:00
|
|
|
|| status == STATUS_OBJECT_NAME_INVALID
|
|
|
|
|| status == STATUS_NO_MEDIA_IN_DEVICE)
|
2007-08-23 15:43:24 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
set_error (ENOENT);
|
|
|
|
goto file_not_symlink;
|
2005-06-07 00:58:39 +08:00
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
if (status != STATUS_OBJECT_NAME_NOT_FOUND
|
|
|
|
&& status != STATUS_NO_SUCH_FILE) /* ENOENT on NFS or 9x share */
|
2008-05-23 15:13:47 +08:00
|
|
|
{
|
2008-05-23 19:00:35 +08:00
|
|
|
/* The file exists, but the user can't access it for one reason
|
|
|
|
or the other. To get the file attributes we try to access the
|
|
|
|
information by opening the parent directory and getting the
|
|
|
|
file attributes using a matching NtQueryDirectoryFile call. */
|
|
|
|
UNICODE_STRING dirname, basename;
|
|
|
|
OBJECT_ATTRIBUTES dattr;
|
|
|
|
HANDLE dir;
|
|
|
|
struct {
|
|
|
|
FILE_DIRECTORY_INFORMATION fdi;
|
|
|
|
WCHAR dummy_buf[NAME_MAX + 1];
|
|
|
|
} fdi_buf;
|
|
|
|
|
|
|
|
RtlSplitUnicodePath (&upath, &dirname, &basename);
|
2008-07-17 04:20:45 +08:00
|
|
|
InitializeObjectAttributes (&dattr, &dirname, ci_flag,
|
|
|
|
NULL, NULL);
|
2008-05-23 19:00:35 +08:00
|
|
|
status = NtOpenFile (&dir, SYNCHRONIZE | FILE_LIST_DIRECTORY,
|
|
|
|
&dattr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT
|
|
|
|
| FILE_DIRECTORY_FILE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
debug_printf ("%p = NtOpenFile(%S)", status, &dirname);
|
|
|
|
fileattr = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-12-18 23:37:19 +08:00
|
|
|
status = NtQueryDirectoryFile (dir, NULL, NULL, NULL, &io,
|
2008-05-23 19:00:35 +08:00
|
|
|
&fdi_buf, sizeof fdi_buf,
|
|
|
|
FileDirectoryInformation,
|
|
|
|
TRUE, &basename, TRUE);
|
2009-03-13 06:03:28 +08:00
|
|
|
/* Take the opportunity to check file system while we're
|
|
|
|
having the handle to the parent dir. */
|
|
|
|
fs.update (&upath, h);
|
2008-05-23 19:00:35 +08:00
|
|
|
NtClose (dir);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
debug_printf ("%p = NtQueryDirectoryFile(%S)",
|
|
|
|
status, &dirname);
|
2008-07-31 22:48:28 +08:00
|
|
|
if (status == STATUS_NO_SUCH_FILE)
|
|
|
|
{
|
|
|
|
/* This can happen when trying to access files
|
|
|
|
which match DOS device names on SMB shares.
|
|
|
|
NtOpenFile failed with STATUS_ACCESS_DENIED,
|
|
|
|
but the NtQueryDirectoryFile tells us the
|
|
|
|
file doesn't exist. We're suspicious in this
|
|
|
|
case and retry with the next suffix instead of
|
|
|
|
just giving up. */
|
|
|
|
set_error (ENOENT);
|
|
|
|
continue;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
fileattr = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fileattr = fdi_buf.fdi.FileAttributes;
|
|
|
|
}
|
|
|
|
ext_tacked_on = !!*ext_here;
|
2008-05-23 15:13:47 +08:00
|
|
|
goto file_not_symlink;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
|
|
|
set_error (ENOENT);
|
|
|
|
continue;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Check file system while we're having the file open anyway.
|
|
|
|
This speeds up path_conv noticably (~10%). */
|
2009-01-30 04:32:08 +08:00
|
|
|
if (!fs_update_called)
|
|
|
|
fs.update (&upath, h);
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
ext_tacked_on = !!*ext_here;
|
2008-05-23 15:13:47 +08:00
|
|
|
|
|
|
|
res = -1;
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Windows shortcuts are potentially treated as symlinks. Valid Cygwin
|
|
|
|
& U/WIN shortcuts are R/O, but definitely not directories. */
|
|
|
|
if ((fileattr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY))
|
|
|
|
== FILE_ATTRIBUTE_READONLY && suffix.lnk_match ())
|
|
|
|
{
|
|
|
|
res = check_shortcut (h);
|
|
|
|
if (!res)
|
|
|
|
{
|
|
|
|
/* If searching for `foo' and then finding a `foo.lnk' which is
|
|
|
|
no shortcut, return the same as if file not found. */
|
2008-12-18 23:37:19 +08:00
|
|
|
if (ext_tacked_on)
|
|
|
|
{
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
set_error (ENOENT);
|
|
|
|
continue;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-12-18 23:37:19 +08:00
|
|
|
else if (contents[0] != ':' || contents[1] != '\\'
|
|
|
|
|| !parse_device (contents))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If searching for `foo' and then finding a `foo.lnk' which is
|
|
|
|
no shortcut, return the same as if file not found. */
|
|
|
|
else if (suffix.lnk_match () && ext_tacked_on)
|
|
|
|
{
|
|
|
|
fileattr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
set_error (ENOENT);
|
|
|
|
continue;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-20 23:11:23 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Reparse points are potentially symlinks. This check must be
|
|
|
|
performed before checking the SYSTEM attribute for sysfile
|
|
|
|
symlinks, since reparse points can have this flag set, too.
|
|
|
|
For instance, Vista starts to create a couple of reparse points
|
|
|
|
with SYSTEM and HIDDEN flags set. */
|
|
|
|
else if (fileattr & FILE_ATTRIBUTE_REPARSE_POINT)
|
|
|
|
{
|
|
|
|
res = check_reparse_point (h);
|
2009-08-25 19:27:03 +08:00
|
|
|
if (res == -1)
|
|
|
|
{
|
|
|
|
/* Volume mount point. The filesystem information for the top
|
|
|
|
level directory should be for the volume top level directory
|
|
|
|
itself, rather than for the reparse point itself. So we
|
|
|
|
fetch the filesystem information again, but with a NULL
|
|
|
|
handle. This does what we want because fs_info::update opens
|
|
|
|
the handle without FILE_OPEN_REPARSE_POINT. */
|
|
|
|
fs.update (&upath, NULL);
|
|
|
|
}
|
|
|
|
else if (res)
|
2008-12-18 23:37:19 +08:00
|
|
|
break;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-20 23:11:23 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* This is the old Cygwin method creating symlinks. A symlink will
|
|
|
|
have the `system' file attribute. Only files can be symlinks
|
|
|
|
(which can be symlinks to directories). */
|
|
|
|
else if ((fileattr & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY))
|
|
|
|
== FILE_ATTRIBUTE_SYSTEM)
|
|
|
|
{
|
|
|
|
res = check_sysfile (h);
|
2008-12-18 23:37:19 +08:00
|
|
|
if (res)
|
|
|
|
break;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2008-05-20 23:11:23 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* If the file could be opened with FILE_READ_EA, and if it's on a
|
|
|
|
NFS share, check if it's a symlink. Only files can be symlinks
|
|
|
|
(which can be symlinks to directories). */
|
2008-05-24 17:54:32 +08:00
|
|
|
else if (fs.is_nfs () && !no_ea && !(fileattr & FILE_ATTRIBUTE_DIRECTORY))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
res = check_nfs_symlink (h);
|
2008-12-18 23:37:19 +08:00
|
|
|
if (res)
|
|
|
|
break;
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-12-18 23:37:19 +08:00
|
|
|
/* Normal file. */
|
2008-05-23 19:00:35 +08:00
|
|
|
file_not_symlink:
|
|
|
|
issymlink = false;
|
|
|
|
syscall_printf ("%s", isdevice ? "is a device" : "not a symlink");
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
}
|
2001-04-13 05:21:37 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (h)
|
|
|
|
NtClose (h);
|
2001-04-17 19:47:37 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
syscall_printf ("%d = symlink.check (%s, %p) (%p)",
|
|
|
|
res, suffix.path, contents, pflags);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* "path" is the path in a virtual symlink. Set a symlink_info struct from
|
|
|
|
that and proceed with further path checking afterwards. */
|
|
|
|
int
|
|
|
|
symlink_info::set (char *path)
|
|
|
|
{
|
|
|
|
strcpy (contents, path);
|
|
|
|
pflags = PATH_SYMLINK;
|
|
|
|
fileattr = FILE_ATTRIBUTE_NORMAL;
|
|
|
|
error = 0;
|
|
|
|
issymlink = true;
|
|
|
|
isdevice = false;
|
2008-07-17 04:20:45 +08:00
|
|
|
ext_tacked_on = false;
|
2008-05-23 19:00:35 +08:00
|
|
|
ext_here = NULL;
|
|
|
|
extn = major = minor = mode = 0;
|
|
|
|
return strlen (path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* readlink system call */
|
2000-04-14 06:43:48 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
extern "C" ssize_t
|
|
|
|
readlink (const char *path, char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
if (buflen < 0)
|
|
|
|
{
|
|
|
|
set_errno (ENAMETOOLONG);
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
path_conv pathbuf (path, PC_SYM_CONTENTS, stat_suffixes);
|
2000-11-01 07:01:21 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (pathbuf.error)
|
|
|
|
{
|
|
|
|
set_errno (pathbuf.error);
|
|
|
|
syscall_printf ("-1 = readlink (%s, %p, %d)", path, buf, buflen);
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!pathbuf.exists ())
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!pathbuf.issymlink ())
|
|
|
|
{
|
|
|
|
if (pathbuf.exists ())
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
ssize_t len = min (buflen, strlen (pathbuf.get_win32 ()));
|
|
|
|
memcpy (buf, pathbuf.get_win32 (), len);
|
|
|
|
|
|
|
|
/* errno set by symlink.check if error */
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some programs rely on st_dev/st_ino being unique for each file.
|
|
|
|
Hash the path name and hope for the best. The hash arg is not
|
|
|
|
always initialized to zero since readdir needs to compute the
|
|
|
|
dirent ino_t based on a combination of the hash of the directory
|
|
|
|
done during the opendir call and the hash or the filename within
|
|
|
|
the directory. FIXME: Not bullet-proof. */
|
|
|
|
/* Cygwin internal */
|
|
|
|
__ino64_t __stdcall
|
|
|
|
hash_path_name (__ino64_t hash, PUNICODE_STRING name)
|
|
|
|
{
|
|
|
|
if (name->Length == 0)
|
|
|
|
return hash;
|
|
|
|
|
|
|
|
/* Build up hash. Name is already normalized */
|
|
|
|
USHORT len = name->Length / sizeof (WCHAR);
|
|
|
|
for (USHORT idx = 0; idx < len; ++idx)
|
|
|
|
hash = RtlUpcaseUnicodeChar (name->Buffer[idx])
|
|
|
|
+ (hash << 6) + (hash << 16) - hash;
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
__ino64_t __stdcall
|
|
|
|
hash_path_name (__ino64_t hash, PCWSTR name)
|
|
|
|
{
|
|
|
|
UNICODE_STRING uname;
|
|
|
|
RtlInitUnicodeString (&uname, name);
|
|
|
|
return hash_path_name (hash, &uname);
|
|
|
|
}
|
|
|
|
|
|
|
|
__ino64_t __stdcall
|
|
|
|
hash_path_name (__ino64_t hash, const char *name)
|
|
|
|
{
|
|
|
|
UNICODE_STRING uname;
|
|
|
|
RtlCreateUnicodeStringFromAsciiz (&uname, name);
|
|
|
|
__ino64_t ret = hash_path_name (hash, &uname);
|
|
|
|
RtlFreeUnicodeString (&uname);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" char *
|
|
|
|
getcwd (char *buf, size_t ulen)
|
|
|
|
{
|
|
|
|
char* res = NULL;
|
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted (EFAULT))
|
|
|
|
/* errno set */;
|
|
|
|
else if (ulen == 0 && buf)
|
2001-09-16 22:26:11 +08:00
|
|
|
set_errno (EINVAL);
|
2008-05-23 19:00:35 +08:00
|
|
|
else
|
|
|
|
res = cygheap->cwd.get (buf, 1, 1, ulen);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* getwd: Legacy. */
|
|
|
|
extern "C" char *
|
|
|
|
getwd (char *buf)
|
|
|
|
{
|
|
|
|
return getcwd (buf, PATH_MAX + 1); /*Per SuSv3!*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/* chdir: POSIX 5.2.1.1 */
|
|
|
|
extern "C" int
|
|
|
|
chdir (const char *in_dir)
|
|
|
|
{
|
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted (EFAULT))
|
2001-06-28 10:19:57 +08:00
|
|
|
return -1;
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!*in_dir)
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
return -1;
|
|
|
|
}
|
2001-06-11 08:24:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
syscall_printf ("dir '%s'", in_dir);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Convert path. First argument ensures that we don't check for NULL/empty/invalid
|
|
|
|
again. */
|
|
|
|
path_conv path (PC_NONULLEMPTY, in_dir, PC_SYM_FOLLOW | PC_POSIX);
|
|
|
|
if (path.error)
|
|
|
|
{
|
|
|
|
set_errno (path.error);
|
|
|
|
syscall_printf ("-1 = chdir (%s)", in_dir);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-03-12 20:41:50 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
int res = -1;
|
|
|
|
bool doit = false;
|
|
|
|
const char *posix_cwd = NULL;
|
|
|
|
int devn = path.get_devn ();
|
2009-06-18 17:47:13 +08:00
|
|
|
if (!path.exists ())
|
|
|
|
set_errno (ENOENT);
|
|
|
|
else if (!path.isdir ())
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
else if (!isvirtual_dev (devn))
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
/* The sequence chdir("xx"); chdir(".."); must be a noop if xx
|
|
|
|
is not a symlink. This is exploited by find.exe.
|
|
|
|
The posix_cwd is just path.normalized_path.
|
|
|
|
In other cases we let cwd.set obtain the Posix path through
|
|
|
|
the mount table. */
|
|
|
|
if (!isdrive(path.normalized_path))
|
|
|
|
posix_cwd = path.normalized_path;
|
|
|
|
res = 0;
|
|
|
|
doit = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
posix_cwd = path.normalized_path;
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!res)
|
|
|
|
res = cygheap->cwd.set (path.get_nt_native_path (), posix_cwd, doit);
|
|
|
|
|
|
|
|
/* Note that we're accessing cwd.posix without a lock here. I didn't think
|
|
|
|
it was worth locking just for strace. */
|
|
|
|
syscall_printf ("%d = chdir() cygheap->cwd.posix '%s' native '%S'", res,
|
2009-05-13 23:00:06 +08:00
|
|
|
cygheap->cwd.get_posix (), path.get_nt_native_path ());
|
2008-05-23 19:00:35 +08:00
|
|
|
MALLOC_CHECK;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
fchdir (int fd)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
|
|
|
res = chdir (cfd->get_name ());
|
|
|
|
else
|
|
|
|
res = -1;
|
|
|
|
|
|
|
|
syscall_printf ("%d = fchdir (%d)", res, fd);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************** Exported Path Routines *********************/
|
|
|
|
|
|
|
|
/* Cover functions to the path conversion routines.
|
|
|
|
These are exported to the world as cygwin_foo by cygwin.din. */
|
2008-03-12 20:41:50 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
#define return_with_errno(x) \
|
|
|
|
do {\
|
|
|
|
int err = (x);\
|
|
|
|
if (!err)\
|
|
|
|
return 0;\
|
|
|
|
set_errno (err);\
|
|
|
|
return -1;\
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
extern "C" ssize_t
|
|
|
|
cygwin_conv_path (cygwin_conv_path_t what, const void *from, void *to,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted (EFAULT))
|
|
|
|
return -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
path_conv p;
|
|
|
|
size_t lsiz = 0;
|
|
|
|
char *buf = NULL;
|
|
|
|
int error = 0;
|
|
|
|
bool relative = !!(what & CCP_RELATIVE);
|
|
|
|
what &= ~CCP_RELATIVE;
|
2005-08-26 05:18:26 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
switch (what)
|
|
|
|
{
|
|
|
|
case CCP_POSIX_TO_WIN_A:
|
2008-09-11 12:34:24 +08:00
|
|
|
{
|
|
|
|
p.check ((const char *) from,
|
|
|
|
PC_POSIX | PC_SYM_FOLLOW | PC_NO_ACCESS_CHECK | PC_NOWARN
|
|
|
|
| (relative ? PC_NOFULL : 0));
|
|
|
|
if (p.error)
|
|
|
|
return_with_errno (p.error);
|
|
|
|
PUNICODE_STRING up = p.get_nt_native_path ();
|
|
|
|
buf = tp.c_get ();
|
|
|
|
sys_wcstombs (buf, NT_MAX_PATH, up->Buffer, up->Length / sizeof (WCHAR));
|
|
|
|
/* Convert native path to standard DOS path. */
|
|
|
|
if (!strncmp (buf, "\\??\\", 4))
|
|
|
|
{
|
|
|
|
buf += 4;
|
|
|
|
if (buf[1] != ':') /* native UNC path */
|
|
|
|
*(buf += 2) = '\\';
|
|
|
|
}
|
|
|
|
lsiz = strlen (buf) + 1;
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
break;
|
|
|
|
case CCP_POSIX_TO_WIN_W:
|
2009-04-15 17:58:41 +08:00
|
|
|
p.check ((const char *) from, PC_POSIX | PC_SYM_FOLLOW
|
|
|
|
| PC_NO_ACCESS_CHECK | PC_NOWARN
|
|
|
|
| (relative ? PC_NOFULL : 0));
|
2008-05-23 19:00:35 +08:00
|
|
|
if (p.error)
|
|
|
|
return_with_errno (p.error);
|
2009-04-15 17:58:41 +08:00
|
|
|
/* Relative Windows paths are always restricted to MAX_PATH chars. */
|
|
|
|
if (relative && !isabspath (p.get_win32 ())
|
|
|
|
&& sys_mbstowcs (NULL, 0, p.get_win32 ()) > MAX_PATH)
|
|
|
|
{
|
|
|
|
/* Recreate as absolute path. */
|
|
|
|
p.check ((const char *) from, PC_POSIX | PC_SYM_FOLLOW
|
|
|
|
| PC_NO_ACCESS_CHECK | PC_NOWARN);
|
|
|
|
if (p.error)
|
|
|
|
return_with_errno (p.error);
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
lsiz = (p.get_wide_win32_path_len () + 1) * sizeof (WCHAR);
|
|
|
|
break;
|
|
|
|
case CCP_WIN_A_TO_POSIX:
|
|
|
|
buf = tp.c_get ();
|
|
|
|
error = mount_table->conv_to_posix_path ((const char *) from, buf,
|
|
|
|
relative);
|
|
|
|
if (error)
|
|
|
|
return_with_errno (error);
|
|
|
|
lsiz = strlen (buf) + 1;
|
|
|
|
break;
|
|
|
|
case CCP_WIN_W_TO_POSIX:
|
|
|
|
buf = tp.c_get ();
|
|
|
|
error = mount_table->conv_to_posix_path ((const PWCHAR) from, buf,
|
|
|
|
relative);
|
|
|
|
if (error)
|
|
|
|
return_with_errno (error);
|
|
|
|
lsiz = strlen (buf) + 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!size)
|
|
|
|
return lsiz;
|
|
|
|
if (size < lsiz)
|
|
|
|
{
|
|
|
|
set_errno (ENOSPC);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
switch (what)
|
|
|
|
{
|
|
|
|
case CCP_POSIX_TO_WIN_A:
|
|
|
|
case CCP_WIN_A_TO_POSIX:
|
|
|
|
case CCP_WIN_W_TO_POSIX:
|
|
|
|
strcpy ((char *) to, buf);
|
|
|
|
break;
|
|
|
|
case CCP_POSIX_TO_WIN_W:
|
|
|
|
p.get_wide_win32_path ((PWCHAR) to);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void *
|
|
|
|
cygwin_create_path (cygwin_conv_path_t what, const void *from)
|
|
|
|
{
|
|
|
|
void *to;
|
|
|
|
ssize_t size = cygwin_conv_path (what, from, NULL, 0);
|
|
|
|
if (size <= 0)
|
|
|
|
return NULL;
|
|
|
|
if (!(to = malloc (size)))
|
|
|
|
return NULL;
|
|
|
|
if (cygwin_conv_path (what, from, to, size) == -1)
|
|
|
|
return NULL;
|
|
|
|
return to;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_conv_to_win32_path (const char *path, char *win32_path)
|
|
|
|
{
|
|
|
|
return cygwin_conv_path (CCP_POSIX_TO_WIN_A | CCP_RELATIVE, path, win32_path,
|
|
|
|
MAX_PATH);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_conv_to_full_win32_path (const char *path, char *win32_path)
|
|
|
|
{
|
|
|
|
return cygwin_conv_path (CCP_POSIX_TO_WIN_A | CCP_ABSOLUTE, path, win32_path,
|
|
|
|
MAX_PATH);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is exported to the world as cygwin_foo by cygwin.din. */
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_conv_to_posix_path (const char *path, char *posix_path)
|
|
|
|
{
|
|
|
|
return cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, path, posix_path,
|
|
|
|
MAX_PATH);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_conv_to_full_posix_path (const char *path, char *posix_path)
|
|
|
|
{
|
|
|
|
return cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_ABSOLUTE, path, posix_path,
|
|
|
|
MAX_PATH);
|
|
|
|
}
|
|
|
|
|
2009-09-26 07:55:00 +08:00
|
|
|
/* The realpath function is required by POSIX:2008. */
|
2008-05-23 19:00:35 +08:00
|
|
|
|
|
|
|
extern "C" char *
|
|
|
|
realpath (const char *path, char *resolved)
|
|
|
|
{
|
|
|
|
/* Make sure the right errno is returned if path is NULL. */
|
|
|
|
if (!path)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-08-26 23:11:06 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Guard reading from a potentially invalid path and writing to a
|
|
|
|
potentially invalid resolved. */
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
myfault efault;
|
|
|
|
if (efault.faulted (EFAULT))
|
|
|
|
return NULL;
|
2005-08-26 23:11:06 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
char *tpath;
|
|
|
|
if (isdrive (path))
|
|
|
|
{
|
|
|
|
tpath = tp.c_get ();
|
|
|
|
mount_table->cygdrive_posix_path (path, tpath, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
tpath = (char *) path;
|
2005-08-26 23:11:06 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
path_conv real_path (tpath, PC_SYM_FOLLOW | PC_POSIX, stat_suffixes);
|
2005-08-26 05:18:26 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2009-09-26 07:55:00 +08:00
|
|
|
/* POSIX 2008 requires malloc'ing if resolved is NULL, and states
|
|
|
|
that using non-NULL resolved is asking for portability
|
|
|
|
problems. */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (!real_path.error && real_path.exists ())
|
|
|
|
{
|
|
|
|
if (!resolved)
|
|
|
|
{
|
|
|
|
resolved = (char *) malloc (strlen (real_path.normalized_path) + 1);
|
|
|
|
if (!resolved)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
strcpy (resolved, real_path.normalized_path);
|
|
|
|
return resolved;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2009-09-26 07:55:00 +08:00
|
|
|
/* FIXME: on error, Linux puts the name of the path
|
|
|
|
component which could not be resolved into RESOLVED, but POSIX
|
|
|
|
does not require this. */
|
2008-05-23 19:00:35 +08:00
|
|
|
if (resolved)
|
|
|
|
resolved[0] = '\0';
|
|
|
|
set_errno (real_path.error ?: ENOENT);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-09-26 07:55:00 +08:00
|
|
|
/* Linux provides this extension. Since the only portable use of
|
|
|
|
realpath requires a NULL second argument, we might as well have a
|
|
|
|
one-argument wrapper. */
|
|
|
|
extern "C" char *
|
|
|
|
canonicalize_file_name (const char *path)
|
|
|
|
{
|
|
|
|
return realpath (path, NULL);
|
|
|
|
}
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Return non-zero if path is a POSIX path list.
|
|
|
|
This is exported to the world as cygwin_foo by cygwin.din.
|
|
|
|
|
|
|
|
DOCTOOL-START
|
|
|
|
<sect1 id="add-func-cygwin-posix-path-list-p">
|
|
|
|
<para>Rather than use a mode to say what the "proper" path list
|
|
|
|
format is, we allow any, and give apps the tools they need to
|
|
|
|
convert between the two. If a ';' is present in the path list it's
|
|
|
|
a Win32 path list. Otherwise, if the first path begins with
|
|
|
|
[letter]: (in which case it can be the only element since if it
|
|
|
|
wasn't a ';' would be present) it's a Win32 path list. Otherwise,
|
|
|
|
it's a POSIX path list.</para>
|
|
|
|
</sect1>
|
|
|
|
DOCTOOL-END
|
|
|
|
*/
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
extern "C" int
|
|
|
|
cygwin_posix_path_list_p (const char *path)
|
|
|
|
{
|
|
|
|
int posix_p = !(strchr (path, ';') || isdrive (path));
|
|
|
|
return posix_p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* These are used for apps that need to convert env vars like PATH back and
|
|
|
|
forth. The conversion is a two step process. First, an upper bound on the
|
|
|
|
size of the buffer needed is computed. Then the conversion is done. This
|
|
|
|
allows the caller to use alloca if it wants. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
conv_path_list_buf_size (const char *path_list, bool to_posix)
|
|
|
|
{
|
|
|
|
int i, num_elms, max_mount_path_len, size;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
path_conv pc(".", PC_POSIX);
|
|
|
|
/* The theory is that an upper bound is
|
|
|
|
current_size + (num_elms * max_mount_path_len) */
|
|
|
|
/* FIXME: This method is questionable in the long run. */
|
|
|
|
|
|
|
|
unsigned nrel;
|
|
|
|
char delim = to_posix ? ';' : ':';
|
|
|
|
for (p = path_list, num_elms = nrel = 0; p; num_elms++)
|
|
|
|
{
|
|
|
|
if (!isabspath (p))
|
|
|
|
nrel++;
|
|
|
|
p = strchr (++p, delim);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* 7: strlen ("//c") + slop, a conservative initial value */
|
|
|
|
for (max_mount_path_len = sizeof ("/cygdrive/X"), i = 0;
|
|
|
|
i < mount_table->nmounts; i++)
|
|
|
|
{
|
|
|
|
int mount_len = (to_posix
|
|
|
|
? mount_table->mount[i].posix_pathlen
|
|
|
|
: mount_table->mount[i].native_pathlen);
|
|
|
|
if (max_mount_path_len < mount_len)
|
|
|
|
max_mount_path_len = mount_len;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* 100: slop */
|
|
|
|
size = strlen (path_list)
|
|
|
|
+ (num_elms * max_mount_path_len)
|
|
|
|
+ (nrel * strlen (to_posix ? pc.normalized_path : pc.get_win32 ()))
|
|
|
|
+ 100;
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_win32_to_posix_path_list_buf_size (const char *path_list)
|
|
|
|
{
|
|
|
|
return conv_path_list_buf_size (path_list, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_posix_to_win32_path_list_buf_size (const char *path_list)
|
|
|
|
{
|
|
|
|
return conv_path_list_buf_size (path_list, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" ssize_t
|
|
|
|
env_PATH_to_posix (const void *win32, void *posix, size_t size)
|
|
|
|
{
|
|
|
|
return_with_errno (conv_path_list ((const char *) win32, (char *) posix,
|
|
|
|
size, ENV_CVT));
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_win32_to_posix_path_list (const char *win32, char *posix)
|
|
|
|
{
|
|
|
|
return_with_errno (conv_path_list (win32, posix, MAX_PATH, 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
cygwin_posix_to_win32_path_list (const char *posix, char *win32)
|
|
|
|
{
|
|
|
|
return_with_errno (conv_path_list (posix, win32, MAX_PATH, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" ssize_t
|
|
|
|
cygwin_conv_path_list (cygwin_conv_path_t what, const void *from, void *to,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
/* FIXME: Path lists are (so far) always retaining relative paths. */
|
|
|
|
what &= ~CCP_RELATIVE;
|
|
|
|
switch (what)
|
|
|
|
{
|
|
|
|
case CCP_WIN_W_TO_POSIX:
|
|
|
|
case CCP_POSIX_TO_WIN_W:
|
|
|
|
/*FIXME*/
|
|
|
|
api_fatal ("wide char path lists not yet supported");
|
|
|
|
break;
|
|
|
|
case CCP_WIN_A_TO_POSIX:
|
|
|
|
case CCP_POSIX_TO_WIN_A:
|
|
|
|
if (size == 0)
|
|
|
|
return conv_path_list_buf_size ((const char *) from,
|
|
|
|
what == CCP_WIN_A_TO_POSIX);
|
|
|
|
return_with_errno (conv_path_list ((const char *) from, (char *) to,
|
|
|
|
size, what == CCP_WIN_A_TO_POSIX));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cygwin_split_path: Split a path into directory and file name parts.
|
|
|
|
Buffers DIR and FILE are assumed to be big enough.
|
|
|
|
|
|
|
|
Examples (path -> `dir' / `file'):
|
|
|
|
/ -> `/' / `'
|
|
|
|
"" -> `.' / `'
|
|
|
|
. -> `.' / `.' (FIXME: should this be `.' / `'?)
|
|
|
|
.. -> `.' / `..' (FIXME: should this be `..' / `'?)
|
|
|
|
foo -> `.' / `foo'
|
|
|
|
foo/bar -> `foo' / `bar'
|
|
|
|
foo/bar/ -> `foo' / `bar'
|
|
|
|
/foo -> `/' / `foo'
|
|
|
|
/foo/bar -> `/foo' / `bar'
|
|
|
|
c: -> `c:/' / `'
|
|
|
|
c:/ -> `c:/' / `'
|
|
|
|
c:foo -> `c:/' / `foo'
|
|
|
|
c:/foo -> `c:/' / `foo'
|
|
|
|
*/
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
cygwin_split_path (const char *path, char *dir, char *file)
|
|
|
|
{
|
|
|
|
int dir_started_p = 0;
|
|
|
|
|
|
|
|
/* Deal with drives.
|
|
|
|
Remember that c:foo <==> c:/foo. */
|
|
|
|
if (isdrive (path))
|
|
|
|
{
|
|
|
|
*dir++ = *path++;
|
|
|
|
*dir++ = *path++;
|
|
|
|
*dir++ = '/';
|
|
|
|
if (!*path)
|
|
|
|
{
|
|
|
|
*dir = 0;
|
|
|
|
*file = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (isdirsep (*path))
|
|
|
|
++path;
|
|
|
|
dir_started_p = 1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Determine if there are trailing slashes and "delete" them if present.
|
|
|
|
We pretend as if they don't exist. */
|
|
|
|
const char *end = path + strlen (path);
|
|
|
|
/* path + 1: keep leading slash. */
|
|
|
|
while (end > path + 1 && isdirsep (end[-1]))
|
|
|
|
--end;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* At this point, END points to one beyond the last character
|
|
|
|
(with trailing slashes "deleted"). */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
/* Point LAST_SLASH at the last slash (duh...). */
|
|
|
|
const char *last_slash;
|
|
|
|
for (last_slash = end - 1; last_slash >= path; --last_slash)
|
|
|
|
if (isdirsep (*last_slash))
|
|
|
|
break;
|
2000-09-05 11:16:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (last_slash == path)
|
|
|
|
{
|
|
|
|
*dir++ = '/';
|
|
|
|
*dir = 0;
|
|
|
|
}
|
|
|
|
else if (last_slash > path)
|
|
|
|
{
|
|
|
|
memcpy (dir, path, last_slash - path);
|
|
|
|
dir[last_slash - path] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dir_started_p)
|
|
|
|
; /* nothing to do */
|
|
|
|
else
|
|
|
|
*dir++ = '.';
|
|
|
|
*dir = 0;
|
|
|
|
}
|
2007-10-24 00:26:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
memcpy (file, last_slash + 1, end - last_slash - 1);
|
|
|
|
file[end - last_slash - 1] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
static inline PRTL_USER_PROCESS_PARAMETERS
|
|
|
|
get_user_proc_parms ()
|
|
|
|
{
|
|
|
|
return NtCurrentTeb ()->Peb->ProcessParameters;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize cygcwd 'muto' for serializing access to cwd info. */
|
|
|
|
void
|
|
|
|
cwdstuff::init ()
|
|
|
|
{
|
|
|
|
cwd_lock.init ("cwd_lock");
|
|
|
|
/* Initially re-open the cwd to allow POSIX semantics. */
|
|
|
|
set (NULL, NULL, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Chdir and fill out the elements of a cwdstuff struct. */
|
|
|
|
int
|
|
|
|
cwdstuff::set (PUNICODE_STRING nat_cwd, const char *posix_cwd, bool doit)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
UNICODE_STRING upath;
|
|
|
|
size_t len = 0;
|
|
|
|
|
|
|
|
cwd_lock.acquire ();
|
|
|
|
|
|
|
|
if (nat_cwd)
|
|
|
|
{
|
|
|
|
upath = *nat_cwd;
|
|
|
|
if (upath.Buffer[0] == L'/') /* Virtual path. Never use in PEB. */
|
|
|
|
doit = false;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
len = upath.Length / sizeof (WCHAR) - 4;
|
2009-07-15 01:37:42 +08:00
|
|
|
if (RtlEqualUnicodePathPrefix (&upath, &ro_u_uncp, TRUE))
|
2008-05-23 19:00:35 +08:00
|
|
|
len -= 2;
|
|
|
|
}
|
|
|
|
}
|
2007-10-24 00:26:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (doit)
|
|
|
|
{
|
|
|
|
/* We utilize the user parameter block. The directory is
|
|
|
|
stored manually there. Why the hassle?
|
|
|
|
|
|
|
|
- SetCurrentDirectory fails for directories with strict
|
|
|
|
permissions even for processes with the SE_BACKUP_NAME
|
|
|
|
privilege enabled. The reason is apparently that
|
|
|
|
SetCurrentDirectory calls NtOpenFile without the
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT flag set.
|
|
|
|
|
|
|
|
- Unlinking a cwd fails because SetCurrentDirectory seems to
|
|
|
|
open directories so that deleting the directory is disallowed.
|
|
|
|
The below code opens with *all* sharing flags set. */
|
|
|
|
HANDLE h;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
PHANDLE phdl;
|
|
|
|
|
|
|
|
RtlAcquirePebLock ();
|
|
|
|
phdl = &get_user_proc_parms ()->CurrentDirectoryHandle;
|
|
|
|
if (!nat_cwd) /* On init, just reopen CWD with desired access flags. */
|
|
|
|
RtlInitUnicodeString (&upath, L"");
|
2008-07-17 04:20:45 +08:00
|
|
|
/* This is for Win32 apps only. No case sensitivity here... */
|
2008-05-23 19:00:35 +08:00
|
|
|
InitializeObjectAttributes (&attr, &upath,
|
|
|
|
OBJ_CASE_INSENSITIVE | OBJ_INHERIT,
|
|
|
|
nat_cwd ? NULL : *phdl, NULL);
|
|
|
|
status = NtOpenFile (&h, SYNCHRONIZE | FILE_TRAVERSE, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_DIRECTORY_FILE
|
|
|
|
| FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_OPEN_FOR_BACKUP_INTENT);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
RtlReleasePebLock ();
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
res = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Workaround a problem in Vista/Longhorn which fails in subsequent
|
|
|
|
calls to CreateFile with ERROR_INVALID_HANDLE if the handle in
|
|
|
|
CurrentDirectoryHandle changes without calling SetCurrentDirectory,
|
|
|
|
and the filename given to CreateFile is a relative path. It looks
|
|
|
|
like Vista stores a copy of the CWD handle in some other undocumented
|
|
|
|
place. The NtClose/DuplicateHandle reuses the original handle for
|
|
|
|
the copy of the new handle and the next CreateFile works.
|
|
|
|
Note that this is not thread-safe (yet?) */
|
|
|
|
NtClose (*phdl);
|
|
|
|
if (DuplicateHandle (GetCurrentProcess (), h, GetCurrentProcess (), phdl,
|
|
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
|
|
|
NtClose (h);
|
|
|
|
else
|
|
|
|
*phdl = h;
|
|
|
|
dir = *phdl;
|
|
|
|
|
|
|
|
/* No need to set path on init. */
|
|
|
|
if (nat_cwd
|
|
|
|
/* TODO:
|
|
|
|
Check the length of the new CWD. Windows can only handle
|
|
|
|
CWDs of up to MAX_PATH length, including a trailing backslash.
|
|
|
|
If the path is longer, it's not an error condition for Cygwin,
|
|
|
|
so we don't fail. Windows on the other hand has a problem now.
|
|
|
|
For now, we just don't store the path in the PEB and proceed as
|
|
|
|
usual. */
|
|
|
|
&& len <= MAX_PATH - (nat_cwd->Buffer[len - 1] == L'\\' ? 1 : 2))
|
|
|
|
{
|
|
|
|
/* Convert to a Win32 path. */
|
|
|
|
upath.Buffer += upath.Length / sizeof (WCHAR) - len;
|
|
|
|
if (upath.Buffer[1] == L'\\') /* UNC path */
|
|
|
|
upath.Buffer[0] = L'\\';
|
|
|
|
upath.Length = len * sizeof (WCHAR);
|
|
|
|
/* Append backslash if necessary. */
|
|
|
|
if (upath.Buffer[len - 1] != L'\\')
|
|
|
|
{
|
|
|
|
upath.Buffer[len] = L'\\';
|
|
|
|
upath.Length += sizeof (WCHAR);
|
|
|
|
}
|
|
|
|
RtlCopyUnicodeString (&get_user_proc_parms ()->CurrentDirectoryName,
|
|
|
|
&upath);
|
|
|
|
}
|
2000-09-05 11:16:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
RtlReleasePebLock ();
|
|
|
|
}
|
2000-10-11 03:24:32 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (nat_cwd || !win32.Buffer)
|
|
|
|
{
|
|
|
|
/* If there is no win32 path */
|
|
|
|
if (!nat_cwd)
|
|
|
|
{
|
|
|
|
PUNICODE_STRING pdir;
|
|
|
|
|
|
|
|
RtlAcquirePebLock ();
|
|
|
|
pdir = &get_user_proc_parms ()->CurrentDirectoryName;
|
|
|
|
RtlInitEmptyUnicodeString (&win32,
|
|
|
|
(PWCHAR) crealloc_abort (win32.Buffer,
|
|
|
|
pdir->Length + 2),
|
|
|
|
pdir->Length + 2);
|
|
|
|
RtlCopyUnicodeString (&win32, pdir);
|
|
|
|
RtlReleasePebLock ();
|
2009-05-30 04:18:50 +08:00
|
|
|
|
|
|
|
PWSTR eoBuffer = win32.Buffer + (win32.Length / sizeof (WCHAR));
|
2009-05-28 13:10:03 +08:00
|
|
|
/* Remove trailing slash if one exists. FIXME: Is there a better way to
|
|
|
|
do this? */
|
2009-05-30 04:18:50 +08:00
|
|
|
if ((eoBuffer - win32.Buffer) > 3 && eoBuffer[-1] == L'\\')
|
2008-05-23 19:00:35 +08:00
|
|
|
win32.Length -= sizeof (WCHAR);
|
2009-05-30 04:18:50 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
posix_cwd = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-07-15 21:27:34 +08:00
|
|
|
bool unc = false;
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (upath.Buffer[0] == L'/') /* Virtual path, don't mangle. */
|
|
|
|
;
|
|
|
|
else if (!doit)
|
|
|
|
{
|
|
|
|
/* Convert to a Win32 path. */
|
|
|
|
upath.Buffer += upath.Length / sizeof (WCHAR) - len;
|
|
|
|
if (upath.Buffer[1] == L'\\') /* UNC path */
|
2009-07-15 21:27:34 +08:00
|
|
|
unc = true;
|
2008-05-23 19:00:35 +08:00
|
|
|
upath.Length = len * sizeof (WCHAR);
|
|
|
|
}
|
2009-05-30 04:18:50 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
PWSTR eoBuffer = upath.Buffer + (upath.Length / sizeof (WCHAR));
|
|
|
|
/* Remove trailing slash if one exists. FIXME: Is there a better way to
|
|
|
|
do this? */
|
|
|
|
if ((eoBuffer - upath.Buffer) > 3 && eoBuffer[-1] == L'\\')
|
|
|
|
upath.Length -= sizeof (WCHAR);
|
|
|
|
}
|
2008-05-23 19:00:35 +08:00
|
|
|
RtlInitEmptyUnicodeString (&win32,
|
|
|
|
(PWCHAR) crealloc_abort (win32.Buffer,
|
|
|
|
upath.Length + 2),
|
|
|
|
upath.Length + 2);
|
|
|
|
RtlCopyUnicodeString (&win32, &upath);
|
2009-07-15 21:27:34 +08:00
|
|
|
if (unc)
|
|
|
|
win32.Buffer[0] = L'\\';
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2009-05-28 13:10:03 +08:00
|
|
|
/* Make sure it's NUL-terminated. */
|
2008-05-23 19:00:35 +08:00
|
|
|
win32.Buffer[win32.Length / sizeof (WCHAR)] = L'\0';
|
|
|
|
if (!doit) /* Virtual path */
|
|
|
|
drive_length = 0;
|
|
|
|
else if (win32.Buffer[1] == L':') /* X: */
|
|
|
|
drive_length = 2;
|
|
|
|
else if (win32.Buffer[1] == L'\\') /* UNC path */
|
|
|
|
{
|
|
|
|
PWCHAR ptr = wcschr (win32.Buffer + 2, L'\\');
|
|
|
|
if (ptr)
|
|
|
|
ptr = wcschr (ptr + 1, L'\\');
|
|
|
|
if (ptr)
|
|
|
|
drive_length = ptr - win32.Buffer;
|
|
|
|
else
|
|
|
|
drive_length = win32.Length / sizeof (WCHAR);
|
|
|
|
}
|
|
|
|
else /* Shouldn't happen */
|
|
|
|
drive_length = 0;
|
|
|
|
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
if (!posix_cwd)
|
|
|
|
{
|
|
|
|
posix_cwd = (const char *) tp.c_get ();
|
|
|
|
mount_table->conv_to_posix_path (win32.Buffer, (char *) posix_cwd, 0);
|
|
|
|
}
|
2009-09-22 03:29:16 +08:00
|
|
|
posix = (char *) crealloc_abort (posix, strlen (posix_cwd) + 1);
|
|
|
|
stpcpy (posix, posix_cwd);
|
2008-05-23 19:00:35 +08:00
|
|
|
}
|
2000-09-05 11:16:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
out:
|
|
|
|
cwd_lock.release ();
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2009-09-22 03:29:16 +08:00
|
|
|
/* Store incoming wchar_t path as current posix cwd. This is called from
|
|
|
|
setlocale so that the cwd is always stored in the right charset. */
|
|
|
|
void
|
|
|
|
cwdstuff::reset_posix (wchar_t *w_cwd)
|
2009-05-13 23:00:06 +08:00
|
|
|
{
|
2009-09-22 03:29:16 +08:00
|
|
|
size_t len = sys_wcstombs (NULL, (size_t) -1, w_cwd);
|
|
|
|
posix = (char *) crealloc_abort (posix, len + 1);
|
|
|
|
sys_wcstombs (posix, len + 1, w_cwd);
|
2009-05-13 23:00:06 +08:00
|
|
|
}
|
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
char *
|
|
|
|
cwdstuff::get (char *buf, int need_posix, int with_chroot, unsigned ulen)
|
|
|
|
{
|
|
|
|
MALLOC_CHECK;
|
|
|
|
|
|
|
|
tmp_pathbuf tp;
|
|
|
|
if (ulen)
|
|
|
|
/* nothing */;
|
|
|
|
else if (buf == NULL)
|
|
|
|
ulen = (unsigned) -1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
goto out;
|
|
|
|
}
|
2000-09-05 11:16:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
cwd_lock.acquire ();
|
2000-09-05 11:16:28 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
char *tocopy;
|
|
|
|
if (!need_posix)
|
|
|
|
{
|
|
|
|
tocopy = tp.c_get ();
|
|
|
|
sys_wcstombs (tocopy, NT_MAX_PATH, win32.Buffer,
|
|
|
|
win32.Length / sizeof (WCHAR));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
tocopy = posix;
|
2003-01-20 10:57:54 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
debug_printf ("posix %s", posix);
|
|
|
|
if (strlen (tocopy) >= ulen)
|
|
|
|
{
|
|
|
|
set_errno (ERANGE);
|
|
|
|
buf = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!buf)
|
|
|
|
buf = (char *) malloc (strlen (tocopy) + 1);
|
|
|
|
strcpy (buf, tocopy);
|
|
|
|
if (!buf[0]) /* Should only happen when chroot */
|
|
|
|
strcpy (buf, "/");
|
|
|
|
}
|
2003-01-20 10:57:54 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
cwd_lock.release ();
|
|
|
|
|
|
|
|
out:
|
|
|
|
syscall_printf ("(%s) = cwdstuff::get (%p, %d, %d, %d), errno %d",
|
|
|
|
buf, buf, ulen, need_posix, with_chroot, errno);
|
|
|
|
MALLOC_CHECK;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
int etc::curr_ix = 0;
|
|
|
|
/* Note that the first elements of the below arrays are unused */
|
|
|
|
bool etc::change_possible[MAX_ETC_FILES + 1];
|
|
|
|
OBJECT_ATTRIBUTES etc::fn[MAX_ETC_FILES + 1];
|
|
|
|
LARGE_INTEGER etc::last_modified[MAX_ETC_FILES + 1];
|
|
|
|
|
|
|
|
int
|
2008-07-25 02:25:52 +08:00
|
|
|
etc::init (int n, POBJECT_ATTRIBUTES attr)
|
2008-05-23 19:00:35 +08:00
|
|
|
{
|
|
|
|
if (n > 0)
|
|
|
|
/* ok */;
|
|
|
|
else if (++curr_ix <= MAX_ETC_FILES)
|
|
|
|
n = curr_ix;
|
|
|
|
else
|
|
|
|
api_fatal ("internal error");
|
|
|
|
|
2008-07-25 02:25:52 +08:00
|
|
|
fn[n] = *attr;
|
2008-05-23 19:00:35 +08:00
|
|
|
change_possible[n] = false;
|
|
|
|
test_file_change (n);
|
|
|
|
paranoid_printf ("fn[%d] %S, curr_ix %d", n, fn[n].ObjectName, curr_ix);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
etc::test_file_change (int n)
|
|
|
|
{
|
|
|
|
NTSTATUS status;
|
|
|
|
FILE_NETWORK_OPEN_INFORMATION fnoi;
|
|
|
|
bool res;
|
|
|
|
|
|
|
|
status = NtQueryFullAttributesFile (&fn[n], &fnoi);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
res = true;
|
|
|
|
memset (last_modified + n, 0, sizeof (last_modified[n]));
|
|
|
|
debug_printf ("NtQueryFullAttributesFile (%S) failed, %p",
|
|
|
|
fn[n].ObjectName, status);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
res = CompareFileTime ((FILETIME *) &fnoi.LastWriteTime,
|
|
|
|
(FILETIME *) last_modified + n) > 0;
|
|
|
|
last_modified[n].QuadPart = fnoi.LastWriteTime.QuadPart;
|
|
|
|
}
|
|
|
|
|
|
|
|
paranoid_printf ("fn[%d] %S res %d", n, fn[n].ObjectName, res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
etc::dir_changed (int n)
|
|
|
|
{
|
|
|
|
if (!change_possible[n])
|
|
|
|
{
|
|
|
|
static HANDLE changed_h NO_COPY;
|
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
|
|
|
|
if (!changed_h)
|
|
|
|
{
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
|
|
|
|
path_conv dir ("/etc");
|
|
|
|
status = NtOpenFile (&changed_h, SYNCHRONIZE | FILE_LIST_DIRECTORY,
|
|
|
|
dir.get_object_attr (attr, sec_none_nih), &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_DIRECTORY_FILE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2007-08-21 20:37:40 +08:00
|
|
|
#ifdef DEBUGGING
|
2008-05-23 19:00:35 +08:00
|
|
|
system_printf ("NtOpenFile (%S) failed, %p",
|
|
|
|
dir.get_nt_native_path (), status);
|
2007-08-21 20:37:40 +08:00
|
|
|
#endif
|
2008-05-23 19:00:35 +08:00
|
|
|
changed_h = INVALID_HANDLE_VALUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
status = NtNotifyChangeDirectoryFile (changed_h, NULL, NULL,
|
|
|
|
NULL, &io, NULL, 0,
|
|
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE
|
|
|
|
| FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
|
|
FALSE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2003-01-20 10:57:54 +08:00
|
|
|
#ifdef DEBUGGING
|
2008-05-23 19:00:35 +08:00
|
|
|
system_printf ("NtNotifyChangeDirectoryFile (1) failed, %p",
|
|
|
|
status);
|
2003-01-20 10:57:54 +08:00
|
|
|
#endif
|
2008-05-23 19:00:35 +08:00
|
|
|
NtClose (changed_h);
|
|
|
|
changed_h = INVALID_HANDLE_VALUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
memset (change_possible, true, sizeof (change_possible));
|
|
|
|
}
|
2003-01-20 10:57:54 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
if (changed_h == INVALID_HANDLE_VALUE)
|
|
|
|
change_possible[n] = true;
|
|
|
|
else if (WaitForSingleObject (changed_h, 0) == WAIT_OBJECT_0)
|
|
|
|
{
|
|
|
|
status = NtNotifyChangeDirectoryFile (changed_h, NULL, NULL,
|
|
|
|
NULL, &io, NULL, 0,
|
|
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE
|
|
|
|
| FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
|
|
FALSE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2007-08-21 20:37:40 +08:00
|
|
|
#ifdef DEBUGGING
|
2008-05-23 19:00:35 +08:00
|
|
|
system_printf ("NtNotifyChangeDirectoryFile (2) failed, %p",
|
|
|
|
status);
|
2007-08-21 20:37:40 +08:00
|
|
|
#endif
|
2008-05-23 19:00:35 +08:00
|
|
|
NtClose (changed_h);
|
|
|
|
changed_h = INVALID_HANDLE_VALUE;
|
|
|
|
}
|
|
|
|
memset (change_possible, true, sizeof change_possible);
|
|
|
|
}
|
|
|
|
}
|
2008-05-23 15:13:47 +08:00
|
|
|
|
2008-05-23 19:00:35 +08:00
|
|
|
paranoid_printf ("fn[%d] %S change_possible %d",
|
|
|
|
n, fn[n].ObjectName, change_possible[n]);
|
|
|
|
return change_possible[n];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
etc::file_changed (int n)
|
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
if (dir_changed (n) && test_file_change (n))
|
|
|
|
res = true;
|
|
|
|
change_possible[n] = false; /* Change is no longer possible */
|
|
|
|
paranoid_printf ("fn[%d] %S res %d", n, fn[n].ObjectName, res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No need to be reentrant or thread-safe according to SUSv3.
|
|
|
|
/ and \\ are treated equally. Leading drive specifiers are
|
|
|
|
kept intact as far as it makes sense. Everything else is
|
|
|
|
POSIX compatible. */
|
|
|
|
extern "C" char *
|
|
|
|
basename (char *path)
|
|
|
|
{
|
|
|
|
static char buf[4];
|
|
|
|
char *c, *d, *bs = path;
|
|
|
|
|
|
|
|
if (!path || !*path)
|
|
|
|
return strcpy (buf, ".");
|
|
|
|
if (isalpha (path[0]) && path[1] == ':')
|
|
|
|
bs += 2;
|
|
|
|
else if (strspn (path, "/\\") > 1)
|
|
|
|
++bs;
|
|
|
|
c = strrchr (bs, '/');
|
|
|
|
if ((d = strrchr (c ?: bs, '\\')) > c)
|
|
|
|
c = d;
|
|
|
|
if (c)
|
|
|
|
{
|
|
|
|
/* Trailing (back)slashes are eliminated. */
|
|
|
|
while (c && c > bs && c[1] == '\0')
|
|
|
|
{
|
|
|
|
*c = '\0';
|
|
|
|
c = strrchr (bs, '/');
|
|
|
|
if ((d = strrchr (c ?: bs, '\\')) > c)
|
|
|
|
c = d;
|
|
|
|
}
|
|
|
|
if (c && (c > bs || c[1]))
|
|
|
|
return c + 1;
|
|
|
|
}
|
|
|
|
else if (!bs[0])
|
|
|
|
{
|
|
|
|
stpncpy (buf, path, bs - path);
|
|
|
|
stpcpy (buf + (bs - path), ".");
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No need to be reentrant or thread-safe according to SUSv3.
|
|
|
|
/ and \\ are treated equally. Leading drive specifiers and
|
|
|
|
leading double (back)slashes are kept intact as far as it
|
|
|
|
makes sense. Everything else is POSIX compatible. */
|
|
|
|
extern "C" char *
|
|
|
|
dirname (char *path)
|
|
|
|
{
|
|
|
|
static char buf[4];
|
|
|
|
char *c, *d, *bs = path;
|
|
|
|
|
|
|
|
if (!path || !*path)
|
|
|
|
return strcpy (buf, ".");
|
|
|
|
if (isalpha (path[0]) && path[1] == ':')
|
|
|
|
bs += 2;
|
|
|
|
else if (strspn (path, "/\\") > 1)
|
|
|
|
++bs;
|
|
|
|
c = strrchr (bs, '/');
|
|
|
|
if ((d = strrchr (c ?: bs, '\\')) > c)
|
|
|
|
c = d;
|
|
|
|
if (c)
|
|
|
|
{
|
|
|
|
/* Trailing (back)slashes are eliminated. */
|
|
|
|
while (c && c > bs && c[1] == '\0')
|
|
|
|
{
|
|
|
|
*c = '\0';
|
|
|
|
c = strrchr (bs, '/');
|
|
|
|
if ((d = strrchr (c ?: bs, '\\')) > c)
|
|
|
|
c = d;
|
|
|
|
}
|
|
|
|
if (!c)
|
|
|
|
strcpy (bs, ".");
|
|
|
|
else if (c > bs)
|
|
|
|
{
|
|
|
|
/* More trailing (back)slashes are eliminated. */
|
|
|
|
while (c > bs && (*c == '/' || *c == '\\'))
|
|
|
|
*c-- = '\0';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
c[1] = '\0';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stpncpy (buf, path, bs - path);
|
|
|
|
stpcpy (buf + (bs - path), ".");
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|