JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* path.cc (struct symlink_info): Change size of contents member to

Browse Source 
be able to keep SYMLINK_MAX sized strings.
	(symlink_worker): Rework for long path names.  When writing windows
	shortcuts, store pathname additionally "hidden" after the actual
	shortcut data to workaround size limitations of the description field.
	(symlink_info::check_shortcut): Drop file name parameter.  Drop max
	file size check.  Use NT functions.  Use appended full path if
	available, description otherwise.  Check symlink string length for
	not exceeding SYMLINK_MAX.  Don't close file here.
	(symlink_info::check_sysfile): Drop file name parameter.  Use NT
	functions.  Check symlink string length for not exceeding SYMLINK_MAX.
	Don't close file here.
	(symlink_info::check_reparse_point): Drop file name parameter.  Drop
	useless length checks.  Allow SYMLINK_MAX length symlink strings.
	Don't close file here.
	(symlink_info::posixify): Allow SYMLINK_MAX length symlink strings.
	(symlink_info::check): Turn around checking for symlink file attributes.
	Use NT functions.  Close symlink file here.
	* include/limits.h (PATH_MAX): Define as 32760.  Change comment.
	(SYMLINK_MAX): Define as PATH_MAX - 1.
This commit is contained in:
Corinna Vinschen 2007-10-10 16:54:09 +00:00
parent 4797f5bca3
commit 044b62c767
3 changed files with 304 additions and 233 deletions
winsup/cygwin
ChangeLog
include
limits.h
path.cc

23
winsup/cygwin/ChangeLog

@ -1,3 +1,26 @@
2007-10-10 Corinna Vinschen <corinna@vinschen.de>
* path.cc (struct symlink_info): Change size of contents member to
be able to keep SYMLINK_MAX sized strings.
(symlink_worker): Rework for long path names. When writing windows
shortcuts, store pathname additionally "hidden" after the actual
shortcut data to workaround size limitations of the description field.
(symlink_info::check_shortcut): Drop file name parameter. Drop max
file size check. Use NT functions. Use appended full path if
available, description otherwise. Check symlink string length for
not exceeding SYMLINK_MAX. Don't close file here.
(symlink_info::check_sysfile): Drop file name parameter. Use NT
functions. Check symlink string length for not exceeding SYMLINK_MAX.
Don't close file here.
(symlink_info::check_reparse_point): Drop file name parameter. Drop
useless length checks. Allow SYMLINK_MAX length symlink strings.
Don't close file here.
(symlink_info::posixify): Allow SYMLINK_MAX length symlink strings.
(symlink_info::check): Turn around checking for symlink file attributes.
Use NT functions. Close symlink file here.
* include/limits.h (PATH_MAX): Define as 32760. Change comment.
(SYMLINK_MAX): Define as PATH_MAX - 1.
2007-10-10 Corinna Vinschen <corinna@vinschen.de> 2007-10-10 Corinna Vinschen <corinna@vinschen.de>
* fhandler_socket.cc (fhandler_socket::bind): Open file for deletion, * fhandler_socket.cc (fhandler_socket::bind): Open file for deletion,

7
winsup/cygwin/include/limits.h

@ -318,9 +318,10 @@ details. */
#undef NAME_MAX #undef NAME_MAX
#define NAME_MAX 255 #define NAME_MAX 255
/* Maximum length of a path */ /* Maximum length of a path including trailing NUL.
(32767 - max. native NT path prefix) */
#undef PATH_MAX #undef PATH_MAX
#define PATH_MAX 260 #define PATH_MAX 32760
/* # of bytes in a pipe buf. This is the max # of bytes which can be /* # of bytes in a pipe buf. This is the max # of bytes which can be
written to a pipe in one atomic operation. */ written to a pipe in one atomic operation. */
@ -352,7 +353,7 @@ details. */
/* Maximum number of bytes in a symbolic link. */ /* Maximum number of bytes in a symbolic link. */
#undef SYMLINK_MAX #undef SYMLINK_MAX
#define SYMLINK_MAX PATH_MAX #define SYMLINK_MAX (PATH_MAX - 1)
/* Runtime Increasable Values */ /* Runtime Increasable Values */

505
winsup/cygwin/path.cc

@ -89,7 +89,7 @@ static void backslashify (const char *, char *, int);
struct symlink_info struct symlink_info
{ {
char contents[CYG_MAX_PATH + 4]; char contents[SYMLINK_MAX + 1];
char *ext_here; char *ext_here;
int extn; int extn;
unsigned pflags; unsigned pflags;
@ -106,9 +106,9 @@ struct symlink_info
int set (char *path); int set (char *path);
bool parse_device (const char *); bool parse_device (const char *);
bool case_check (char *path); bool case_check (char *path);
int check_sysfile (const char *path, HANDLE h); int check_sysfile (HANDLE h);
int check_shortcut (const char *path, HANDLE h); int check_shortcut (HANDLE h);
int check_reparse_point (const char *path, HANDLE h); int check_reparse_point (HANDLE h);
int posixify (char *srcbuf); int posixify (char *srcbuf);
bool set_error (int); bool set_error (int);
}; };
@ -2874,16 +2874,17 @@ int
symlink_worker (const char *oldpath, const char *newpath, bool use_winsym, symlink_worker (const char *oldpath, const char *newpath, bool use_winsym,
bool isdevice) bool isdevice)
{ {
HANDLE h;
int res = -1; int res = -1;
path_conv win32_path, win32_oldpath; size_t len;
char from[CYG_MAX_PATH + 5]; path_conv win32_newpath, win32_oldpath;
char cwd[CYG_MAX_PATH], *cp = NULL, c = 0; char *buf, *cp;
char w32oldpath[CYG_MAX_PATH];
char reloldpath[CYG_MAX_PATH] = { 0 };
DWORD written;
SECURITY_ATTRIBUTES sa = sec_none_nih; SECURITY_ATTRIBUTES sa = sec_none_nih;
security_descriptor sd; security_descriptor sd;
OBJECT_ATTRIBUTES attr;
IO_STATUS_BLOCK io;
NTSTATUS status;
HANDLE fh;
FILE_BASIC_INFORMATION fbi;
/* POSIX says that empty 'newpath' is invalid input while empty /* POSIX says that empty 'newpath' is invalid input while empty
'oldpath' is valid -- it's symlink resolver job to verify if 'oldpath' is valid -- it's symlink resolver job to verify if
@ -2897,192 +2898,239 @@ symlink_worker (const char *oldpath, const char *newpath, bool use_winsym,
goto done; goto done;
} }
if (strlen (oldpath) >= CYG_MAX_PATH) if (strlen (oldpath) > SYMLINK_MAX)
{ {
set_errno (ENAMETOOLONG); set_errno (ENAMETOOLONG);
goto done; goto done;
} }
win32_path.check (newpath, PC_SYM_NOFOLLOW, len = strlen (newpath);
transparent_exe ? stat_suffixes : NULL); /* Trailing dirsep is a no-no. */
if (use_winsym && !win32_path.exists ()) if (isdirsep (newpath[len - 1]))
{ {
strcpy (from, newpath); set_errno (ENOENT);
strcat (from, ".lnk"); goto done;
win32_path.check (from, PC_SYM_NOFOLLOW); }
/* We need the normalized full path below. */
win32_newpath.check (newpath, PC_SYM_NOFOLLOW | PC_POSIX, stat_suffixes);
if (use_winsym && !win32_newpath.exists ())
{
char *newplnk = (char *) alloca (len + 5);
stpcpy (stpcpy (newplnk, newpath), ".lnk");
win32_newpath.check (newplnk, PC_SYM_NOFOLLOW | PC_POSIX);
} }
if (win32_path.error) if (win32_newpath.error)
{ {
set_errno (win32_path.case_clash ? ECASECLASH : win32_path.error); set_errno (win32_newpath.case_clash ? ECASECLASH : win32_newpath.error);
goto done; goto done;
} }
syscall_printf ("symlink (%s, %s)", oldpath, win32_path.get_win32 ()); syscall_printf ("symlink (%s, %S)", oldpath,
win32_newpath.get_nt_native_path ());
if ((!isdevice && win32_path.exists ()) if ((!isdevice && win32_newpath.exists ())
|| win32_path.is_auto_device ()) || win32_newpath.is_auto_device ())
{ {
set_errno (EEXIST); set_errno (EEXIST);
goto done; goto done;
} }
DWORD create_how; if (use_winsym)
if (!use_winsym)
create_how = CREATE_NEW;
else if (isdevice)
{ {
strcpy (w32oldpath, oldpath); ITEMIDLIST *pidl = NULL;
create_how = CREATE_ALWAYS; size_t full_len = 0;
SetFileAttributes (win32_path.get_win32 (), FILE_ATTRIBUTE_NORMAL); unsigned short oldpath_len, desc_len, relpath_len, pidl_len = 0;
} char desc[MAX_PATH + 1], *relpath;
else
{
if (!isabspath (oldpath))
{
getcwd (cwd, CYG_MAX_PATH);
if ((cp = strrchr (from, '/')) || (cp = strrchr (from, '\\')))
{
c = *cp;
*cp = '\0';
chdir (from);
}
backslashify (oldpath, reloldpath, 0);
/* Creating an ITEMIDLIST requires an absolute path. So if we
create a shortcut file, we create relative and absolute Win32
paths, the first for the relpath field and the latter for the
ITEMIDLIST field. */
if (GetFileAttributes (reloldpath) == INVALID_FILE_ATTRIBUTES)
{
win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW,
transparent_exe ? stat_suffixes : NULL);
if (win32_oldpath.error != ENOENT)
strcpy (use_winsym ? reloldpath : w32oldpath,
win32_oldpath.get_win32 ());
}
else if (!use_winsym)
strcpy (w32oldpath, reloldpath);
if (use_winsym)
{
win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW,
transparent_exe ? stat_suffixes : NULL);
strcpy (w32oldpath, win32_oldpath.get_win32 ());
}
if (cp)
{
*cp = c;
chdir (cwd);
}
}
else
{
win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW,
transparent_exe ? stat_suffixes : NULL);
strcpy (w32oldpath, win32_oldpath.get_win32 ());
}
create_how = CREATE_NEW;
}
if (allow_ntsec && win32_path.has_acls ()) if (!isdevice)
set_security_attribute (S_IFLNK | STD_RBITS | STD_WBITS, {
&sa, sd); /* First create an IDLIST to learn how big our shortcut is
going to be. */
h = CreateFile (win32_path.get_win32 (), GENERIC_WRITE, 0, &sa, create_how,
FILE_ATTRIBUTE_NORMAL, 0);
if (h == INVALID_HANDLE_VALUE)
__seterrno ();
else
{
bool success = false;
if (use_winsym)
{
/* A path of 240 chars with 120 one character directories in it
can result in a 6K shortcut. */
char *buf = (char *) alloca (8192);
win_shortcut_hdr *shortcut_header = (win_shortcut_hdr *) buf;
HRESULT hres;
IShellFolder *psl; IShellFolder *psl;
WCHAR wc_path[CYG_MAX_PATH];
ITEMIDLIST *pidl = NULL, *p;
unsigned short len;
memset (shortcut_header, 0, sizeof *shortcut_header); /* The symlink target is relative to the directory in which
shortcut_header->size = sizeof *shortcut_header; the symlink gets created, not relative to the cwd. Therefore
shortcut_header->magic = GUID_shortcut; we have to mangle the path quite a bit before calling path_conv. */
shortcut_header->flags = (WSH_FLAG_DESC | WSH_FLAG_RELPATH); if (!isabspath (oldpath))
shortcut_header->run = SW_NORMAL;
cp = buf + sizeof (win_shortcut_hdr);
/* Creating an IDLIST */
hres = SHGetDesktopFolder (&psl);
if (SUCCEEDED (hres))
{ {
MultiByteToWideChar (CP_ACP, 0, w32oldpath, -1, wc_path, len = strrchr (win32_newpath.normalized_path, '/')
CYG_MAX_PATH); - win32_newpath.normalized_path + 1;
hres = psl->ParseDisplayName (NULL, NULL, wc_path, NULL, char *absoldpath = (char *) alloca (len + strlen (oldpath) + 1);
&pidl, NULL); stpcpy (stpncpy (absoldpath, win32_newpath.normalized_path, len),
if (SUCCEEDED (hres)) oldpath);
win32_oldpath.check (absoldpath, PC_SYM_NOFOLLOW, stat_suffixes);
}
else
win32_oldpath.check (oldpath, 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 tyhe path to the "normal" syntax
for ParseDisplayName. I have no idea if it's able to take
long path names at all since I can't test it right now. */
WCHAR *wc = wc_path + 4;
if (!wcscmp (wc, L"UNC\\"))
*(wc += 2) = L'\\';
HRESULT res;
if (SUCCEEDED (res = psl->ParseDisplayName (NULL, NULL, wc, NULL,
&pidl, NULL)))
{ {
shortcut_header->flags |= WSH_FLAG_IDLIST; ITEMIDLIST *p;
for (p = pidl; p->mkid.cb > 0; for (p = pidl; p->mkid.cb > 0;
p = (ITEMIDLIST *)((char *) p + p->mkid.cb)) p = (ITEMIDLIST *)((char *) p + p->mkid.cb))
; ;
len = (char *) p - (char *) pidl + 2; pidl_len = (char *) p - (char *) pidl + 2;
*(unsigned short *)cp = len;
memcpy (cp += 2, pidl, len);
cp += len;
CoTaskMemFree (pidl);
} }
psl->Release (); psl->Release ();
} }
/* Creating a description */ }
*(unsigned short *)cp = len = strlen (oldpath); /* Compute size of shortcut file. */
memcpy (cp += 2, oldpath, len); full_len = sizeof (win_shortcut_hdr);
cp += len; if (pidl_len)
/* Creating a relpath */ full_len += sizeof (unsigned short) + pidl_len;
if (reloldpath[0]) oldpath_len = strlen (oldpath);
{ /* Unfortunately the length of the description is restricted to a
*(unsigned short *)cp = len = strlen (reloldpath); length of MAX_PATH up to NT4, and to a length of 2000 bytes
memcpy (cp += 2, reloldpath, len); since W2K. We don't want to add considerations for the different
} lengths and even 2000 bytes is not enough for long path names.
else 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
*(unsigned short *)cp = len = strlen (w32oldpath); append the full path name after the regular shortcut data
memcpy (cp += 2, w32oldpath, len); (see below), which works fine with Windows Explorer as well
} as older Cygwin versions (as long as the whole file isn't bigger
cp += len; than 8K). The description field is only used for backward
success = WriteFile (h, buf, cp - buf, &written, NULL) compatibility to older Cygwin versions and those versions are
&& written == (DWORD) (cp - buf); 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 = (char *) alloca (relpath_len + 1), oldpath);
} }
else else
{ {
/* This is the old technique creating a symlink. */ relpath_len = strlen (win32_oldpath.get_win32 ());
char buf[sizeof (SYMLINK_COOKIE) + CYG_MAX_PATH + 10]; stpcpy (relpath = (char *) alloca (relpath_len + 1),
win32_oldpath.get_win32 ());
__small_sprintf (buf, "%s%s", SYMLINK_COOKIE, oldpath);
DWORD len = strlen (buf) + 1;
/* Note that the terminating nul is written. */
success = WriteFile (h, buf, len, &written, NULL)
|| written != len;
} }
if (success) full_len += sizeof (unsigned short) + relpath_len;
{ full_len += sizeof (unsigned short) + oldpath_len;
CloseHandle (h); /* 1 byte more for trailing 0 written by stpcpy. */
DWORD attr = use_winsym ? FILE_ATTRIBUTE_READONLY buf = (char *) alloca (full_len + 1);
: FILE_ATTRIBUTE_SYSTEM;
SetFileAttributes (win32_path.get_win32 (), attr);
res = 0; /* Create shortcut header */
} win_shortcut_hdr *shortcut_header = (win_shortcut_hdr *) buf;
else 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)
{ {
__seterrno (); *(unsigned short *)cp = pidl_len;
CloseHandle (h); memcpy (cp += 2, pidl, pidl_len);
DeleteFileA (win32_path.get_win32 ()); cp += pidl_len;
CoTaskMemFree (pidl);
}
/* Create description */
*(unsigned short *)cp = desc_len;
cp = stpcpy (cp += 2, desc);
/* Create relpath */
*(unsigned short *)cp = relpath_len;
cp = stpcpy (cp += 2, relpath);
/* Append the POSIX path after the regular shortcut data for
the long path support. */
*(unsigned short *)cp = oldpath_len;
cp = stpcpy (cp += 2, oldpath);
}
else
{
/* This is the old technique creating a symlink. */
unsigned short oldpath_len = strlen (oldpath);
buf = (char *) alloca (sizeof (SYMLINK_COOKIE) + oldpath_len + 1);
/* Note that the terminating nul is written. */
cp = stpcpy (stpcpy (buf, SYMLINK_COOKIE), oldpath) + 1;
}
if (isdevice && win32_newpath.exists ())
{
status = NtOpenFile (&fh, FILE_WRITE_ATTRIBUTES,
win32_newpath.get_object_attr (attr, sa),
&io, 0, FILE_OPEN_FOR_BACKUP_INTENT);
if (!NT_SUCCESS (status))
{
__seterrno_from_nt_status (status);
goto done;
}
fbi.CreationTime.QuadPart = fbi.LastAccessTime.QuadPart
= fbi.LastWriteTime.QuadPart = fbi.ChangeTime.QuadPart = 0LL;
fbi.FileAttributes = FILE_ATTRIBUTE_NORMAL;
status = NtSetInformationFile (fh, &io, &fbi, sizeof fbi,
FileBasicInformation);
NtClose (fh);
if (!NT_SUCCESS (status))
{
__seterrno_from_nt_status (status);
goto done;
} }
} }
if (allow_ntsec && win32_newpath.has_acls ())
set_security_attribute (S_IFLNK | STD_RBITS | STD_WBITS,
&sa, sd);
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;
}
status = NtWriteFile (fh, NULL, NULL, NULL, &io, buf, cp - buf, NULL, NULL);
if (NT_SUCCESS (status) && io.Information == (ULONG) (cp - buf))
{
fbi.CreationTime.QuadPart = fbi.LastAccessTime.QuadPart
= fbi.LastWriteTime.QuadPart = fbi.ChangeTime.QuadPart = 0LL;
fbi.FileAttributes = use_winsym ? FILE_ATTRIBUTE_READONLY
: FILE_ATTRIBUTE_SYSTEM;
status = NtSetInformationFile (fh, &io, &fbi, sizeof fbi,
FileBasicInformation);
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: done:
syscall_printf ("%d = symlink_worker (%s, %s, %d, %d)", res, oldpath, syscall_printf ("%d = symlink_worker (%s, %s, %d, %d)", res, oldpath,
@ -3104,80 +3152,98 @@ cmp_shortcut_header (win_shortcut_hdr *file_header)
} }
int int
symlink_info::check_shortcut (const char *path, HANDLE h) symlink_info::check_shortcut (HANDLE h)
{ {
win_shortcut_hdr *file_header; win_shortcut_hdr *file_header;
char *buf, *cp; char *buf, *cp;
unsigned short len; unsigned short len;
int res = 0; int res = 0;
DWORD size, got = 0; DWORD size;
IO_STATUS_BLOCK io;
if ((size = GetFileSize (h, NULL)) > 8192) /* Not a Cygwin symlink. */ size = GetFileSize (h, NULL);
goto file_not_symlink;
buf = (char *) alloca (size + 1); buf = (char *) alloca (size + 1);
if (!ReadFile (h, buf, size, &got, 0)) if (!NT_SUCCESS (NtReadFile (h, NULL, NULL, NULL,
&io, buf, size, NULL, NULL)))
{ {
set_error (EIO); set_error (EIO);
goto close_it; goto close_it;
} }
file_header = (win_shortcut_hdr *) buf; file_header = (win_shortcut_hdr *) buf;
if (got != size || !cmp_shortcut_header (file_header)) if (io.Information != size || !cmp_shortcut_header (file_header))
goto file_not_symlink; goto file_not_symlink;
cp = buf + sizeof (win_shortcut_hdr); cp = buf + sizeof (win_shortcut_hdr);
if (file_header->flags & WSH_FLAG_IDLIST) /* Skip ITEMIDLIST */ if (file_header->flags & WSH_FLAG_IDLIST) /* Skip ITEMIDLIST */
cp += *(unsigned short *) cp + 2; cp += *(unsigned short *) cp + 2;
if ((len = *(unsigned short *) cp) == 0 || len >= CYG_MAX_PATH) if (!(len = *(unsigned short *) cp))
goto file_not_symlink; goto file_not_symlink;
cp += 2; cp += 2;
cp[len] = '\0';
/* Check if this is a device file - these start with the sequence :\\ */ /* Check if this is a device file - these start with the sequence :\\ */
if (strncmp (cp, ":\\", 2) == 0) if (strncmp (cp, ":\\", 2) == 0)
res = strlen (strcpy (contents, cp)); /* Don't try to mess with device files */ res = strlen (strcpy (contents, cp)); /* Don't mess with device files */
else else
res = posixify (cp); {
/* 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 + size)
{
cp += len + 2 + relpath_len;
len = *(unsigned short *) cp;
cp += 2;
}
if (len > SYMLINK_MAX)
goto file_not_symlink;
cp[len] = '\0';
res = posixify (cp);
}
if (res) /* It's a symlink. */ if (res) /* It's a symlink. */
pflags = PATH_SYMLINK | PATH_LNK; pflags = PATH_SYMLINK | PATH_LNK;
goto close_it; goto close_it;
file_not_symlink: file_not_symlink:
/* Not a symlink, see if executable. */ /* Not a symlink, see if executable. */
if (!(pflags & PATH_ALL_EXEC) && has_exec_chars ((const char *) &file_header, got)) if (!(pflags & PATH_ALL_EXEC) && has_exec_chars ((const char *) &file_header, io.Information))
pflags |= PATH_EXEC; pflags |= PATH_EXEC;
close_it: close_it:
CloseHandle (h);
return res; return res;
} }
int int
symlink_info::check_sysfile (const char *path, HANDLE h) symlink_info::check_sysfile (HANDLE h)
{ {
char cookie_buf[sizeof (SYMLINK_COOKIE) - 1]; char cookie_buf[sizeof (SYMLINK_COOKIE) - 1];
char srcbuf[CYG_MAX_PATH]; char srcbuf[SYMLINK_MAX + 2];
DWORD got; IO_STATUS_BLOCK io;
int res = 0; int res = 0;
if (!ReadFile (h, cookie_buf, sizeof (cookie_buf), &got, 0)) if (!NT_SUCCESS (NtReadFile (h, NULL, NULL, NULL, &io,
cookie_buf, sizeof (cookie_buf), NULL, NULL)))
{ {
debug_printf ("ReadFile1 failed"); debug_printf ("ReadFile1 failed");
set_error (EIO); set_error (EIO);
} }
else if (got == sizeof (cookie_buf) else if (io.Information == sizeof (cookie_buf)
&& memcmp (cookie_buf, SYMLINK_COOKIE, sizeof (cookie_buf)) == 0) && memcmp (cookie_buf, SYMLINK_COOKIE, sizeof (cookie_buf)) == 0)
{ {
/* It's a symlink. */ /* It's a symlink. */
pflags = PATH_SYMLINK; pflags = PATH_SYMLINK;
res = ReadFile (h, srcbuf, CYG_MAX_PATH, &got, 0); if (!NT_SUCCESS (NtReadFile (h, NULL, NULL, NULL, &io,
if (!res) srcbuf, SYMLINK_MAX + 2, NULL, NULL)))
{ {
debug_printf ("ReadFile2 failed"); debug_printf ("ReadFile2 failed");
set_error (EIO); set_error (EIO);
} }
else if (io.Information > SYMLINK_MAX + 1)
{
debug_printf ("symlink string too long");
set_error (EIO);
}
else else
res = posixify (srcbuf); res = posixify (srcbuf);
} }
else if (got == sizeof (cookie_buf) else if (io.Information == sizeof (cookie_buf)
&& memcmp (cookie_buf, SOCKET_COOKIE, sizeof (cookie_buf)) == 0) && memcmp (cookie_buf, SOCKET_COOKIE, sizeof (cookie_buf)) == 0)
pflags |= PATH_SOCKET; pflags |= PATH_SOCKET;
else else
@ -3185,44 +3251,32 @@ symlink_info::check_sysfile (const char *path, HANDLE h)
/* Not a symlink, see if executable. */ /* Not a symlink, see if executable. */
if (pflags & PATH_ALL_EXEC) if (pflags & PATH_ALL_EXEC)
/* Nothing to do */; /* Nothing to do */;
else if (has_exec_chars (cookie_buf, got)) else if (has_exec_chars (cookie_buf, io.Information))
pflags |= PATH_EXEC; pflags |= PATH_EXEC;
else else
pflags |= PATH_NOTEXEC; pflags |= PATH_NOTEXEC;
} }
syscall_printf ("%d = symlink.check_sysfile (%s, %s) (%p)",
res, path, contents, pflags);
CloseHandle (h);
return res; return res;
} }
int int
symlink_info::check_reparse_point (const char *path, HANDLE h) symlink_info::check_reparse_point (HANDLE h)
{ {
int res = 0;
PREPARSE_DATA_BUFFER rp = (PREPARSE_DATA_BUFFER) PREPARSE_DATA_BUFFER rp = (PREPARSE_DATA_BUFFER)
alloca (MAXIMUM_REPARSE_DATA_BUFFER_SIZE); alloca (MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
DWORD size; DWORD size;
char srcbuf[CYG_MAX_PATH + 6]; char srcbuf[SYMLINK_MAX + 7];
if (!DeviceIoControl (h, FSCTL_GET_REPARSE_POINT, NULL, 0, (LPVOID) rp, if (!DeviceIoControl (h, FSCTL_GET_REPARSE_POINT, NULL, 0, (LPVOID) rp,
MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &size, NULL)) MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &size, NULL))
{ {
debug_printf ("DeviceIoControl(FSCTL_GET_REPARSE_POINT) failed, %E"); debug_printf ("DeviceIoControl(FSCTL_GET_REPARSE_POINT) failed, %E");
set_error (EIO); set_error (EIO);
goto close_it; return 0;
} }
if (rp->ReparseTag == IO_REPARSE_TAG_SYMLINK) if (rp->ReparseTag == IO_REPARSE_TAG_SYMLINK)
{ {
if (rp->SymbolicLinkReparseBuffer.SubstituteNameLength sys_wcstombs (srcbuf, SYMLINK_MAX + 1,
> 2 * (CYG_MAX_PATH + 6))
{
debug_printf ("Symlink name too long");
set_error (EIO);
goto close_it;
}
sys_wcstombs (srcbuf, CYG_MAX_PATH,
(WCHAR *)((char *)rp->SymbolicLinkReparseBuffer.PathBuffer (WCHAR *)((char *)rp->SymbolicLinkReparseBuffer.PathBuffer
+ rp->SymbolicLinkReparseBuffer.SubstituteNameOffset), + rp->SymbolicLinkReparseBuffer.SubstituteNameOffset),
rp->SymbolicLinkReparseBuffer.SubstituteNameLength / 2); rp->SymbolicLinkReparseBuffer.SubstituteNameLength / 2);
@ -3234,26 +3288,16 @@ symlink_info::check_reparse_point (const char *path, HANDLE h)
if (rp->SymbolicLinkReparseBuffer.PrintNameLength == 0) if (rp->SymbolicLinkReparseBuffer.PrintNameLength == 0)
{ {
/* Likely a volume mount point. Not treated as symlink. */ /* Likely a volume mount point. Not treated as symlink. */
goto close_it; return 0;
} }
if (rp->MountPointReparseBuffer.SubstituteNameLength sys_wcstombs (srcbuf, SYMLINK_MAX + 1,
> 2 * (CYG_MAX_PATH + 6))
{
debug_printf ("Symlink name too long");
set_error (EIO);
goto close_it;
}
sys_wcstombs (srcbuf, CYG_MAX_PATH,
(WCHAR *)((char *)rp->MountPointReparseBuffer.PathBuffer (WCHAR *)((char *)rp->MountPointReparseBuffer.PathBuffer
+ rp->MountPointReparseBuffer.SubstituteNameOffset), + rp->MountPointReparseBuffer.SubstituteNameOffset),
rp->MountPointReparseBuffer.SubstituteNameLength / 2); rp->MountPointReparseBuffer.SubstituteNameLength / 2);
pflags = PATH_SYMLINK | PATH_REP; pflags = PATH_SYMLINK | PATH_REP;
fileattr &= ~FILE_ATTRIBUTE_DIRECTORY; fileattr &= ~FILE_ATTRIBUTE_DIRECTORY;
} }
res = posixify (srcbuf); return posixify (srcbuf);
close_it:
CloseHandle (h);
return res;
} }
int int
@ -3297,7 +3341,7 @@ symlink_info::posixify (char *srcbuf)
slashify (srcbuf, contents, 0); slashify (srcbuf, contents, 0);
else /* Paths starting with \ are current drive relative. */ else /* Paths starting with \ are current drive relative. */
{ {
char cvtbuf[CYG_MAX_PATH + 6]; char cvtbuf[SYMLINK_MAX + 1];
strncpy (cvtbuf, cygheap->cwd.win32, 2); strncpy (cvtbuf, cygheap->cwd.win32, 2);
strcpy (cvtbuf + 2, srcbuf); strcpy (cvtbuf + 2, srcbuf);
@ -3524,6 +3568,7 @@ symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt)
{ {
FILE_BASIC_INFORMATION fbi; FILE_BASIC_INFORMATION fbi;
NTSTATUS status; NTSTATUS status;
IO_STATUS_BLOCK io;
error = 0; error = 0;
get_nt_native_path (suffix.path, upath); get_nt_native_path (suffix.path, upath);
@ -3561,7 +3606,6 @@ symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt)
UNICODE_STRING dirname, basename; UNICODE_STRING dirname, basename;
OBJECT_ATTRIBUTES dattr; OBJECT_ATTRIBUTES dattr;
HANDLE dir; HANDLE dir;
IO_STATUS_BLOCK io;
FILE_DIRECTORY_INFORMATION fdi; FILE_DIRECTORY_INFORMATION fdi;
RtlSplitUnicodePath (&upath, &dirname, &basename); RtlSplitUnicodePath (&upath, &dirname, &basename);
@ -3624,9 +3668,10 @@ symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt)
== FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
goto file_not_symlink; goto file_not_symlink;
/* Reparse points are potentially symlinks. */ /* Windows shortcuts are potentially treated as symlinks. */
if (fileattr & FILE_ATTRIBUTE_REPARSE_POINT) /* Valid Cygwin & U/WIN shortcuts are R/O. */
sym_check = 3; if ((fileattr & FILE_ATTRIBUTE_READONLY) && suffix.lnk_match ())
sym_check = 1;
/* This is the old Cygwin method creating symlinks: */ /* This is the old Cygwin method creating symlinks: */
/* A symlink will have the `system' file attribute. */ /* A symlink will have the `system' file attribute. */
@ -3634,29 +3679,29 @@ symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt)
else if (fileattr & FILE_ATTRIBUTE_SYSTEM) else if (fileattr & FILE_ATTRIBUTE_SYSTEM)
sym_check = 2; sym_check = 2;
/* Windows shortcuts are potentially treated as symlinks. */ /* Reparse points are potentially symlinks. */
/* Valid Cygwin & U/WIN shortcuts are R/O. */ else if (fileattr & FILE_ATTRIBUTE_REPARSE_POINT)
else if ((fileattr & FILE_ATTRIBUTE_READONLY) && suffix.lnk_match ()) sym_check = 3;
sym_check = 1;
if (!sym_check) if (!sym_check)
goto file_not_symlink; goto file_not_symlink;
/* Open the file. */
h = CreateFile (suffix.path, GENERIC_READ, FILE_SHARE_READ,
&sec_none_nih, OPEN_EXISTING,
sym_check == 3 ? FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
: FILE_ATTRIBUTE_NORMAL, 0);
res = -1; res = -1;
if (h == INVALID_HANDLE_VALUE)
/* Open the file. */
status = NtOpenFile (&h, FILE_GENERIC_READ, &attr, &io,
FILE_SHARE_VALID_FLAGS,
FILE_SYNCHRONOUS_IO_NONALERT
| FILE_OPEN_FOR_BACKUP_INTENT
| (sym_check == 3 ? FILE_OPEN_REPARSE_POINT : 0));
if (!NT_SUCCESS (status))
goto file_not_symlink; goto file_not_symlink;
switch (sym_check) switch (sym_check)
{ {
case 1: case 1:
res = check_shortcut (suffix.path, h); res = check_shortcut (h);
NtClose (h);
if (!res) if (!res)
/* check more below */; /* check more below */;
else if (contents[0] == ':' && contents[1] == '\\' && parse_device (contents)) else if (contents[0] == ':' && contents[1] == '\\' && parse_device (contents))
@ -3671,12 +3716,14 @@ symlink_info::check (char *path, const suffix_info *suffixes, unsigned opt)
fileattr = INVALID_FILE_ATTRIBUTES; fileattr = INVALID_FILE_ATTRIBUTES;
continue; /* in case we're going to tack *another* .lnk on this filename. */ continue; /* in case we're going to tack *another* .lnk on this filename. */
case 2: case 2:
res = check_sysfile (suffix.path, h); res = check_sysfile (h);
NtClose (h);
if (!res) if (!res)
goto file_not_symlink; goto file_not_symlink;
break; break;
case 3: case 3:
res = check_reparse_point (suffix.path, h); res = check_reparse_point (h);
NtClose (h);
if (!res) if (!res)
goto file_not_symlink; goto file_not_symlink;
break; break;