#include "tclWinInt.h"
#include <winioctl.h>
#include <sys/stat.h>
#include <shlobj.h>
#include <lmaccess.h>
#ifndef IO_REPARSE_TAG_RESERVED_ONE
# define IO_REPARSE_TAG_RESERVED_ONE 0x000000001
#endif
#ifndef IO_REPARSE_TAG_RESERVED_RANGE
# define IO_REPARSE_TAG_RESERVED_RANGE 0x000000001
#endif
#ifndef IO_REPARSE_TAG_VALID_VALUES
# define IO_REPARSE_TAG_VALID_VALUES 0x0E000FFFF
#endif
#ifndef IO_REPARSE_TAG_HSM
# define IO_REPARSE_TAG_HSM 0x0C0000004
#endif
#ifndef IO_REPARSE_TAG_NSS
# define IO_REPARSE_TAG_NSS 0x080000005
#endif
#ifndef IO_REPARSE_TAG_NSSRECOVER
# define IO_REPARSE_TAG_NSSRECOVER 0x080000006
#endif
#ifndef IO_REPARSE_TAG_SIS
# define IO_REPARSE_TAG_SIS 0x080000007
#endif
#ifndef IO_REPARSE_TAG_DFS
# define IO_REPARSE_TAG_DFS 0x080000008
#endif
#ifndef IO_REPARSE_TAG_RESERVED_ZERO
# define IO_REPARSE_TAG_RESERVED_ZERO 0x00000000
#endif
#ifndef FILE_FLAG_OPEN_REPARSE_POINT
# define FILE_FLAG_OPEN_REPARSE_POINT 0x00200000
#endif
#ifndef IO_REPARSE_TAG_MOUNT_POINT
# define IO_REPARSE_TAG_MOUNT_POINT 0xA0000003
#endif
#ifndef IsReparseTagValid
# define IsReparseTagValid(x) (!((x)&~IO_REPARSE_TAG_VALID_VALUES)&&((x)>IO_REPARSE_TAG_RESERVED_RANGE))
#endif
#ifndef IO_REPARSE_TAG_SYMBOLIC_LINK
# define IO_REPARSE_TAG_SYMBOLIC_LINK IO_REPARSE_TAG_RESERVED_ZERO
#endif
#ifndef FILE_SPECIAL_ACCESS
# define FILE_SPECIAL_ACCESS (FILE_ANY_ACCESS)
#endif
#ifndef FSCTL_SET_REPARSE_POINT
# define FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
# define FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
# define FSCTL_DELETE_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
#endif
#define MAX_REPARSE_SIZE 17000
#define REPARSE_MOUNTPOINT_HEADER_SIZE 8
#ifndef REPARSE_DATA_BUFFER_HEADER_SIZE
typedef struct _REPARSE_DATA_BUFFER {
DWORD ReparseTag;
WORD ReparseDataLength;
WORD Reserved;
union {
struct {
WORD SubstituteNameOffset;
WORD SubstituteNameLength;
WORD PrintNameOffset;
WORD PrintNameLength;
WCHAR PathBuffer[1];
} SymbolicLinkReparseBuffer;
struct {
WORD SubstituteNameOffset;
WORD SubstituteNameLength;
WORD PrintNameOffset;
WORD PrintNameLength;
WCHAR PathBuffer[1];
} MountPointReparseBuffer;
struct {
BYTE DataBuffer[1];
} GenericReparseBuffer;
};
} REPARSE_DATA_BUFFER;
#endif
typedef struct {
REPARSE_DATA_BUFFER dummy;
WCHAR dummyBuf[MAX_PATH*3];
} DUMMY_REPARSE_BUFFER;
static time_t ToCTime(FILETIME fileTime);
typedef NET_API_STATUS NET_API_FUNCTION NETUSERGETINFOPROC
(LPWSTR servername, LPWSTR username, DWORD level, LPBYTE *bufptr);
typedef NET_API_STATUS NET_API_FUNCTION NETAPIBUFFERFREEPROC
(LPVOID Buffer);
typedef NET_API_STATUS NET_API_FUNCTION NETGETDCNAMEPROC
(LPWSTR servername, LPWSTR domainname, LPBYTE *bufptr);
static int NativeAccess(CONST TCHAR *path, int mode);
static int NativeStat(CONST TCHAR *path, Tcl_StatBuf *statPtr, int checkLinks);
static int NativeIsExec(CONST TCHAR *path);
static int NativeReadReparse(CONST TCHAR* LinkDirectory,
REPARSE_DATA_BUFFER* buffer);
static int NativeWriteReparse(CONST TCHAR* LinkDirectory,
REPARSE_DATA_BUFFER* buffer);
static int NativeMatchType(CONST char *name, int nameLen,
CONST TCHAR* nativeName, Tcl_GlobTypeData *types);
static int WinIsDrive(CONST char *name, int nameLen);
static Tcl_Obj* WinReadLink(CONST TCHAR* LinkSource);
static Tcl_Obj* WinReadLinkDirectory(CONST TCHAR* LinkDirectory);
static int WinLink(CONST TCHAR* LinkSource, CONST TCHAR* LinkTarget,
int linkAction);
static int WinSymLinkDirectory(CONST TCHAR* LinkDirectory,
CONST TCHAR* LinkTarget);
static int
WinLink(LinkSource, LinkTarget, linkAction)
CONST TCHAR* LinkSource;
CONST TCHAR* LinkTarget;
int linkAction;
{
WCHAR tempFileName[MAX_PATH];
TCHAR* tempFilePart;
int attr;
if (!(*tclWinProcs->getFullPathNameProc)(LinkTarget,
MAX_PATH, tempFileName, &tempFilePart)) {
TclWinConvertError(GetLastError());
return -1;
}
attr = (*tclWinProcs->getFileAttributesProc)(LinkSource);
if (attr != 0xffffffff) {
Tcl_SetErrno(EEXIST);
return -1;
}
if (!(*tclWinProcs->getFullPathNameProc)(LinkSource,
MAX_PATH, tempFileName, &tempFilePart)) {
TclWinConvertError(GetLastError());
return -1;
}
attr = (*tclWinProcs->getFileAttributesProc)(LinkTarget);
if (attr == 0xffffffff) {
TclWinConvertError(GetLastError());
return -1;
} else if ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
if (tclWinProcs->createHardLinkProc == NULL) {
Tcl_SetErrno(ENOTDIR);
return -1;
}
if (linkAction & TCL_CREATE_HARD_LINK) {
if (!(*tclWinProcs->createHardLinkProc)(LinkSource, LinkTarget, NULL)) {
TclWinConvertError(GetLastError());
return -1;
}
return 0;
} else if (linkAction & TCL_CREATE_SYMBOLIC_LINK) {
Tcl_SetErrno(ENOTDIR);
return -1;
} else {
Tcl_SetErrno(ENODEV);
return -1;
}
} else {
if (linkAction & TCL_CREATE_SYMBOLIC_LINK) {
return WinSymLinkDirectory(LinkSource, LinkTarget);
} else if (linkAction & TCL_CREATE_HARD_LINK) {
Tcl_SetErrno(EISDIR);
return -1;
} else {
Tcl_SetErrno(ENODEV);
return -1;
}
}
}
static Tcl_Obj*
WinReadLink(LinkSource)
CONST TCHAR* LinkSource;
{
WCHAR tempFileName[MAX_PATH];
TCHAR* tempFilePart;
int attr;
if (!(*tclWinProcs->getFullPathNameProc)(LinkSource,
MAX_PATH, tempFileName, &tempFilePart)) {
TclWinConvertError(GetLastError());
return NULL;
}
attr = (*tclWinProcs->getFileAttributesProc)(LinkSource);
if (attr == 0xffffffff) {
TclWinConvertError(GetLastError());
return NULL;
} else if ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
Tcl_SetErrno(ENOTDIR);
return NULL;
} else {
return WinReadLinkDirectory(LinkSource);
}
}
static int
WinSymLinkDirectory(LinkDirectory, LinkTarget)
CONST TCHAR* LinkDirectory;
CONST TCHAR* LinkTarget;
{
DUMMY_REPARSE_BUFFER dummy;
REPARSE_DATA_BUFFER *reparseBuffer = (REPARSE_DATA_BUFFER*)&dummy;
int len;
WCHAR nativeTarget[MAX_PATH];
WCHAR *loop;
memcpy((VOID*)nativeTarget, (VOID*)L"\\??\\", 4*sizeof(WCHAR));
memcpy((VOID*)(nativeTarget + 4), (VOID*)LinkTarget,
sizeof(WCHAR)*(1+wcslen((WCHAR*)LinkTarget)));
len = wcslen(nativeTarget);
for (loop = nativeTarget; *loop != 0; loop++) {
if (*loop == L'/') *loop = L'\\';
}
if ((nativeTarget[len-1] == L'\\') && (nativeTarget[len-2] != L':')) {
nativeTarget[len-1] = 0;
}
memset(reparseBuffer, 0, sizeof(DUMMY_REPARSE_BUFFER));
reparseBuffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
reparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength =
wcslen(nativeTarget) * sizeof(WCHAR);
reparseBuffer->Reserved = 0;
reparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength = 0;
reparseBuffer->SymbolicLinkReparseBuffer.PrintNameOffset =
reparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength
+ sizeof(WCHAR);
memcpy(reparseBuffer->SymbolicLinkReparseBuffer.PathBuffer, nativeTarget,
sizeof(WCHAR)
+ reparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength);
reparseBuffer->ReparseDataLength =
reparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength + 12;
return NativeWriteReparse(LinkDirectory, reparseBuffer);
}
int
TclWinSymLinkCopyDirectory(LinkOriginal, LinkCopy)
CONST TCHAR* LinkOriginal;
CONST TCHAR* LinkCopy;
{
DUMMY_REPARSE_BUFFER dummy;
REPARSE_DATA_BUFFER *reparseBuffer = (REPARSE_DATA_BUFFER*)&dummy;
if (NativeReadReparse(LinkOriginal, reparseBuffer)) {
return -1;
}
return NativeWriteReparse(LinkCopy, reparseBuffer);
}
int
TclWinSymLinkDelete(LinkOriginal, linkOnly)
CONST TCHAR* LinkOriginal;
int linkOnly;
{
DUMMY_REPARSE_BUFFER dummy;
REPARSE_DATA_BUFFER *reparseBuffer = (REPARSE_DATA_BUFFER*)&dummy;
HANDLE hFile;
int returnedLength;
memset(reparseBuffer, 0, sizeof(DUMMY_REPARSE_BUFFER));
reparseBuffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
hFile = (*tclWinProcs->createFileProc)(LinkOriginal, GENERIC_WRITE, 0,
NULL, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile != INVALID_HANDLE_VALUE) {
if (!DeviceIoControl(hFile, FSCTL_DELETE_REPARSE_POINT, reparseBuffer,
REPARSE_MOUNTPOINT_HEADER_SIZE,
NULL, 0, &returnedLength, NULL)) {
TclWinConvertError(GetLastError());
CloseHandle(hFile);
} else {
CloseHandle(hFile);
if (!linkOnly) {
(*tclWinProcs->removeDirectoryProc)(LinkOriginal);
}
return 0;
}
}
return -1;
}
static Tcl_Obj*
WinReadLinkDirectory(LinkDirectory)
CONST TCHAR* LinkDirectory;
{
int attr;
DUMMY_REPARSE_BUFFER dummy;
REPARSE_DATA_BUFFER *reparseBuffer = (REPARSE_DATA_BUFFER*)&dummy;
attr = (*tclWinProcs->getFileAttributesProc)(LinkDirectory);
if (!(attr & FILE_ATTRIBUTE_REPARSE_POINT)) {
Tcl_SetErrno(EINVAL);
return NULL;
}
if (NativeReadReparse(LinkDirectory, reparseBuffer)) {
return NULL;
}
switch (reparseBuffer->ReparseTag) {
case 0x80000000|IO_REPARSE_TAG_SYMBOLIC_LINK:
case IO_REPARSE_TAG_SYMBOLIC_LINK:
case IO_REPARSE_TAG_MOUNT_POINT: {
Tcl_Obj *retVal;
Tcl_DString ds;
CONST char *copy;
int len;
Tcl_WinTCharToUtf(
(CONST char*)reparseBuffer->SymbolicLinkReparseBuffer.PathBuffer,
(int)reparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength,
&ds);
copy = Tcl_DStringValue(&ds);
len = Tcl_DStringLength(&ds);
if (*copy == '\\') {
if (0 == strncmp(copy,"\\??\\",4)) {
copy += 4;
len -= 4;
} else if (0 == strncmp(copy,"\\\\?\\",4)) {
copy += 4;
len -= 4;
}
}
retVal = Tcl_NewStringObj(copy,len);
Tcl_IncrRefCount(retVal);
Tcl_DStringFree(&ds);
return retVal;
}
}
Tcl_SetErrno(EINVAL);
return NULL;
}
static int
NativeReadReparse(LinkDirectory, buffer)
CONST TCHAR* LinkDirectory;
REPARSE_DATA_BUFFER* buffer;
{
HANDLE hFile;
int returnedLength;
hFile = (*tclWinProcs->createFileProc)(LinkDirectory, GENERIC_READ, 0,
NULL, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
TclWinConvertError(GetLastError());
return -1;
}
if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, NULL,
0, buffer, sizeof(DUMMY_REPARSE_BUFFER),
&returnedLength, NULL)) {
TclWinConvertError(GetLastError());
CloseHandle(hFile);
return -1;
}
CloseHandle(hFile);
if (!IsReparseTagValid(buffer->ReparseTag)) {
Tcl_SetErrno(EINVAL);
return -1;
}
return 0;
}
static int
NativeWriteReparse(LinkDirectory, buffer)
CONST TCHAR* LinkDirectory;
REPARSE_DATA_BUFFER* buffer;
{
HANDLE hFile;
int returnedLength;
if ((*tclWinProcs->createDirectoryProc)(LinkDirectory, NULL) == 0) {
TclWinConvertError(GetLastError());
return -1;
}
hFile = (*tclWinProcs->createFileProc)(LinkDirectory, GENERIC_WRITE, 0,
NULL, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
TclWinConvertError(GetLastError());
return -1;
}
if (!DeviceIoControl(hFile, FSCTL_SET_REPARSE_POINT, buffer,
buffer->ReparseDataLength
+ REPARSE_MOUNTPOINT_HEADER_SIZE,
NULL, 0, &returnedLength, NULL)) {
TclWinConvertError(GetLastError());
CloseHandle(hFile);
(*tclWinProcs->removeDirectoryProc)(LinkDirectory);
return -1;
}
CloseHandle(hFile);
return 0;
}
char *
TclpFindExecutable(argv0)
CONST char *argv0;
{
Tcl_DString ds;
WCHAR wName[MAX_PATH];
if (argv0 == NULL) {
return NULL;
}
if (tclNativeExecutableName != NULL) {
return tclNativeExecutableName;
}
(*tclWinProcs->getModuleFileNameProc)(NULL, wName, MAX_PATH);
Tcl_WinTCharToUtf((CONST TCHAR *) wName, -1, &ds);
tclNativeExecutableName = ckalloc((unsigned) (Tcl_DStringLength(&ds) + 1));
strcpy(tclNativeExecutableName, Tcl_DStringValue(&ds));
Tcl_DStringFree(&ds);
TclWinNoBackslash(tclNativeExecutableName);
return tclNativeExecutableName;
}
int
TclpMatchInDirectory(interp, resultPtr, pathPtr, pattern, types)
Tcl_Interp *interp;
Tcl_Obj *resultPtr;
Tcl_Obj *pathPtr;
CONST char *pattern;
Tcl_GlobTypeData *types;
{
CONST TCHAR *nativeName;
if (pattern == NULL || (*pattern == '\0')) {
Tcl_Obj *norm = Tcl_FSGetNormalizedPath(NULL, pathPtr);
if (norm != NULL) {
int len;
char *str = Tcl_GetStringFromObj(norm,&len);
nativeName = (CONST TCHAR*) Tcl_FSGetNativePath(pathPtr);
if (NativeMatchType(str, len, nativeName, types)) {
Tcl_ListObjAppendElement(interp, resultPtr, pathPtr);
}
}
return TCL_OK;
} else {
char drivePat[] = "?:\\";
const char *message;
CONST char *dir;
char *root;
int dirLength;
Tcl_DString dirString;
DWORD attr, volFlags;
HANDLE handle;
WIN32_FIND_DATAT data;
BOOL found;
Tcl_DString ds;
Tcl_DString dsOrig;
Tcl_Obj *fileNamePtr;
int matchSpecialDots;
fileNamePtr = Tcl_FSGetTranslatedPath(interp, pathPtr);
if (fileNamePtr == NULL) {
return TCL_ERROR;
}
Tcl_DStringInit(&dsOrig);
Tcl_DStringAppend(&dsOrig, Tcl_GetString(fileNamePtr), -1);
dirLength = Tcl_DStringLength(&dsOrig);
Tcl_DStringInit(&dirString);
if (dirLength == 0) {
Tcl_DStringAppend(&dirString, ".\\", 2);
} else {
char *p;
Tcl_DStringAppend(&dirString, Tcl_DStringValue(&dsOrig),
Tcl_DStringLength(&dsOrig));
for (p = Tcl_DStringValue(&dirString); *p != '\0'; p++) {
if (*p == '/') {
*p = '\\';
}
}
p--;
if ((*p != '\\') && (*p != ':')) {
Tcl_DStringAppend(&dirString, "\\", 1);
Tcl_DStringAppend(&dsOrig, "/", 1);
dirLength++;
}
}
dir = Tcl_DStringValue(&dirString);
nativeName = Tcl_WinUtfToTChar(dir, Tcl_DStringLength(&dirString), &ds);
attr = (*tclWinProcs->getFileAttributesProc)(nativeName);
Tcl_DStringFree(&ds);
if ((attr == 0xffffffff) || ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0)) {
Tcl_DStringFree(&dirString);
return TCL_OK;
}
switch (Tcl_GetPathType(dir)) {
case TCL_PATH_RELATIVE:
found = GetVolumeInformationA(NULL, NULL, 0, NULL, NULL,
&volFlags, NULL, 0);
break;
case TCL_PATH_VOLUME_RELATIVE:
if (dir[0] == '\\') {
root = NULL;
} else {
root = drivePat;
*root = dir[0];
}
found = GetVolumeInformationA(root, NULL, 0, NULL, NULL,
&volFlags, NULL, 0);
break;
case TCL_PATH_ABSOLUTE:
if (dir[1] == ':') {
root = drivePat;
*root = dir[0];
found = GetVolumeInformationA(root, NULL, 0, NULL, NULL,
&volFlags, NULL, 0);
} else if (dir[1] == '\\') {
char *p;
p = strchr(dir + 2, '\\');
p = strchr(p + 1, '\\');
p++;
nativeName = Tcl_WinUtfToTChar(dir, p - dir, &ds);
found = (*tclWinProcs->getVolumeInformationProc)(nativeName,
NULL, 0, NULL, NULL, &volFlags, NULL, 0);
Tcl_DStringFree(&ds);
}
break;
}
if (found == 0) {
message = "couldn't read volume information for \"";
goto error;
}
if ((pattern[0] == '.')
|| ((pattern[0] == '\\') && (pattern[1] == '.'))) {
matchSpecialDots = 1;
} else {
matchSpecialDots = 0;
}
dir = Tcl_DStringAppend(&dirString, "*.*", 3);
nativeName = Tcl_WinUtfToTChar(dir, -1, &ds);
handle = (*tclWinProcs->findFirstFileProc)(nativeName, &data);
Tcl_DStringFree(&ds);
if (handle == INVALID_HANDLE_VALUE) {
message = "couldn't read directory \"";
goto error;
}
for (found = 1; found != 0;
found = (*tclWinProcs->findNextFileProc)(handle, &data)) {
CONST TCHAR *nativeMatchResult;
CONST char *name, *fname;
if (tclWinProcs->useWide) {
nativeName = (CONST TCHAR *) data.w.cFileName;
} else {
nativeName = (CONST TCHAR *) data.a.cFileName;
}
name = Tcl_WinTCharToUtf(nativeName, -1, &ds);
if (!matchSpecialDots) {
if (name[0] == '.') {
if (name[1] == '\0'
|| (name[1] == '.' && name[2] == '\0')) {
continue;
}
}
}
nativeMatchResult = NULL;
if (Tcl_StringCaseMatch(name, pattern, 1) != 0) {
nativeMatchResult = nativeName;
}
Tcl_DStringFree(&ds);
if (nativeMatchResult == NULL) {
continue;
}
name = Tcl_WinTCharToUtf(nativeMatchResult, -1, &ds);
Tcl_DStringAppend(&dsOrig, name, -1);
Tcl_DStringFree(&ds);
fname = Tcl_DStringValue(&dsOrig);
nativeName = Tcl_WinUtfToTChar(fname, Tcl_DStringLength(&dsOrig),
&ds);
if (NativeMatchType(fname, Tcl_DStringLength(&dsOrig),
nativeName, types)) {
Tcl_ListObjAppendElement(interp, resultPtr,
Tcl_NewStringObj(fname, Tcl_DStringLength(&dsOrig)));
}
Tcl_DStringFree(&ds);
Tcl_DStringSetLength(&dsOrig, dirLength);
}
FindClose(handle);
Tcl_DStringFree(&dirString);
Tcl_DStringFree(&dsOrig);
return TCL_OK;
error:
Tcl_DStringFree(&dirString);
TclWinConvertError(GetLastError());
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, message, Tcl_DStringValue(&dsOrig), "\": ",
Tcl_PosixError(interp), (char *) NULL);
Tcl_DStringFree(&dsOrig);
return TCL_ERROR;
}
}
static int
WinIsDrive(
CONST char *name,
int len)
{
int remove = 0;
while (len > 4) {
if ((name[len-1] != '.' || name[len-2] != '.')
|| (name[len-3] != '/' && name[len-3] != '\\')) {
if (remove == 0) {
break;
}
remove--;
while (len > 0) {
len--;
if (name[len] == '/' || name[len] == '\\') {
break;
}
}
if (len < 4) {
len++;
break;
}
} else {
len -= 3;
remove++;
}
}
if (len < 4) {
if (len == 0) {
} else if (len == 1 && (name[0] == '/' || name[0] == '\\')) {
return 1;
} else if ((name[1] == ':')
&& (len == 2 || (name[2] == '/' || name[2] == '\\'))) {
return 1;
}
}
return 0;
}
static int
NativeMatchType(
CONST char *name,
int nameLen,
CONST TCHAR* nativeName,
Tcl_GlobTypeData *types)
{
DWORD attr = (*tclWinProcs->getFileAttributesProc)(nativeName);
if (attr == 0xffffffff) {
return 0;
}
if (types == NULL) {
if (attr & FILE_ATTRIBUTE_HIDDEN && !WinIsDrive(name, nameLen)) {
return 0;
}
} else {
if (attr & FILE_ATTRIBUTE_HIDDEN && !WinIsDrive(name, nameLen)) {
if ((types->perm == 0) ||
!(types->perm & TCL_GLOB_PERM_HIDDEN)) {
return 0;
}
} else {
if (types->perm & TCL_GLOB_PERM_HIDDEN) {
return 0;
}
}
if (types->perm != 0) {
if (
((types->perm & TCL_GLOB_PERM_RONLY) &&
!(attr & FILE_ATTRIBUTE_READONLY)) ||
((types->perm & TCL_GLOB_PERM_R) &&
(NativeAccess(nativeName, R_OK) != 0)) ||
((types->perm & TCL_GLOB_PERM_W) &&
(NativeAccess(nativeName, W_OK) != 0)) ||
((types->perm & TCL_GLOB_PERM_X) &&
(NativeAccess(nativeName, X_OK) != 0))
) {
return 0;
}
}
if (types->type != 0) {
Tcl_StatBuf buf;
if (NativeStat(nativeName, &buf, 0) != 0) {
return 0;
}
if (
((types->type & TCL_GLOB_TYPE_BLOCK) &&
S_ISBLK(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_CHAR) &&
S_ISCHR(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_DIR) &&
S_ISDIR(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_PIPE) &&
S_ISFIFO(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_FILE) &&
S_ISREG(buf.st_mode))
#ifdef S_ISSOCK
|| ((types->type & TCL_GLOB_TYPE_SOCK) &&
S_ISSOCK(buf.st_mode))
#endif
) {
} else {
#ifdef S_ISLNK
if (types->type & TCL_GLOB_TYPE_LINK) {
if (NativeStat(nativeName, &buf, 1) == 0) {
if (S_ISLNK(buf.st_mode)) {
return 1;
}
}
}
#endif
return 0;
}
}
}
return 1;
}
char *
TclpGetUserHome(name, bufferPtr)
CONST char *name;
Tcl_DString *bufferPtr;
{
char *result;
HINSTANCE netapiInst;
result = NULL;
Tcl_DStringInit(bufferPtr);
netapiInst = LoadLibraryA("netapi32.dll");
if (netapiInst != NULL) {
NETAPIBUFFERFREEPROC *netApiBufferFreeProc;
NETGETDCNAMEPROC *netGetDCNameProc;
NETUSERGETINFOPROC *netUserGetInfoProc;
netApiBufferFreeProc = (NETAPIBUFFERFREEPROC *)
GetProcAddress(netapiInst, "NetApiBufferFree");
netGetDCNameProc = (NETGETDCNAMEPROC *)
GetProcAddress(netapiInst, "NetGetDCName");
netUserGetInfoProc = (NETUSERGETINFOPROC *)
GetProcAddress(netapiInst, "NetUserGetInfo");
if ((netUserGetInfoProc != NULL) && (netGetDCNameProc != NULL)
&& (netApiBufferFreeProc != NULL)) {
USER_INFO_1 *uiPtr;
Tcl_DString ds;
int nameLen, badDomain;
char *domain;
WCHAR *wName, *wHomeDir, *wDomain;
WCHAR buf[MAX_PATH];
badDomain = 0;
nameLen = -1;
wDomain = NULL;
domain = strchr(name, '@');
if (domain != NULL) {
Tcl_DStringInit(&ds);
wName = Tcl_UtfToUniCharDString(domain + 1, -1, &ds);
badDomain = (*netGetDCNameProc)(NULL, wName,
(LPBYTE *) &wDomain);
Tcl_DStringFree(&ds);
nameLen = domain - name;
}
if (badDomain == 0) {
Tcl_DStringInit(&ds);
wName = Tcl_UtfToUniCharDString(name, nameLen, &ds);
if ((*netUserGetInfoProc)(wDomain, wName, 1,
(LPBYTE *) &uiPtr) == 0) {
wHomeDir = uiPtr->usri1_home_dir;
if ((wHomeDir != NULL) && (wHomeDir[0] != L'\0')) {
Tcl_UniCharToUtfDString(wHomeDir, lstrlenW(wHomeDir),
bufferPtr);
} else {
GetWindowsDirectoryW(buf, MAX_PATH);
Tcl_UniCharToUtfDString(buf, 2, bufferPtr);
Tcl_DStringAppend(bufferPtr, "/users/default", -1);
}
result = Tcl_DStringValue(bufferPtr);
(*netApiBufferFreeProc)((void *) uiPtr);
}
Tcl_DStringFree(&ds);
}
if (wDomain != NULL) {
(*netApiBufferFreeProc)((void *) wDomain);
}
}
FreeLibrary(netapiInst);
}
if (result == NULL) {
char buf[MAX_PATH];
if (name[0] != '*') {
if (GetPrivateProfileStringA("Password Lists", name, "", buf,
MAX_PATH, "system.ini") > 0) {
GetWindowsDirectoryA(buf, MAX_PATH);
Tcl_DStringAppend(bufferPtr, buf, 3);
result = Tcl_DStringValue(bufferPtr);
}
}
}
return result;
}
static int
NativeAccess(
CONST TCHAR *nativePath,
int mode)
{
DWORD attr;
attr = (*tclWinProcs->getFileAttributesProc)(nativePath);
if (attr == 0xffffffff) {
TclWinConvertError(GetLastError());
return -1;
}
if ((mode & W_OK) && (attr & FILE_ATTRIBUTE_READONLY)) {
Tcl_SetErrno(EACCES);
return -1;
}
if (mode & X_OK) {
if (attr & FILE_ATTRIBUTE_DIRECTORY) {
return 0;
}
if (NativeIsExec(nativePath)) {
return 0;
}
Tcl_SetErrno(EACCES);
return -1;
}
return 0;
}
static int
NativeIsExec(nativePath)
CONST TCHAR *nativePath;
{
CONST char *p, *path;
Tcl_DString ds;
Tcl_DStringInit(&ds);
path = Tcl_WinTCharToUtf(nativePath, -1, &ds);
p = strrchr(path, '.');
if (p != NULL) {
p++;
if ((stricmp(p, "exe") == 0)
|| (stricmp(p, "com") == 0)
|| (stricmp(p, "bat") == 0)) {
Tcl_DStringFree(&ds);
return 1;
}
}
Tcl_DStringFree(&ds);
return 0;
}
int
TclpObjChdir(pathPtr)
Tcl_Obj *pathPtr;
{
int result;
CONST TCHAR *nativePath;
nativePath = (CONST TCHAR *) Tcl_FSGetNativePath(pathPtr);
result = (*tclWinProcs->setCurrentDirectoryProc)(nativePath);
if (result == 0) {
TclWinConvertError(GetLastError());
return -1;
}
return 0;
}
#ifdef __CYGWIN__
char *
TclpReadlink(path, linkPtr)
CONST char *path;
Tcl_DString *linkPtr;
{
char link[MAXPATHLEN];
int length;
char *native;
Tcl_DString ds;
native = Tcl_UtfToExternalDString(NULL, path, -1, &ds);
length = readlink(native, link, sizeof(link));
Tcl_DStringFree(&ds);
if (length < 0) {
return NULL;
}
Tcl_ExternalToUtfDString(NULL, link, length, linkPtr);
return Tcl_DStringValue(linkPtr);
}
#endif
CONST char *
TclpGetCwd(interp, bufferPtr)
Tcl_Interp *interp;
Tcl_DString *bufferPtr;
{
WCHAR buffer[MAX_PATH];
char *p;
if ((*tclWinProcs->getCurrentDirectoryProc)(MAX_PATH, buffer) == 0) {
TclWinConvertError(GetLastError());
if (interp != NULL) {
Tcl_AppendResult(interp,
"error getting working directory name: ",
Tcl_PosixError(interp), (char *) NULL);
}
return NULL;
}
if (tclWinProcs->useWide) {
WCHAR *native;
native = (WCHAR *) buffer;
if ((native[0] != '\0') && (native[1] == ':')
&& (native[2] == '\\') && (native[3] == '\\')) {
native += 2;
}
Tcl_WinTCharToUtf((TCHAR *) native, -1, bufferPtr);
} else {
char *native;
native = (char *) buffer;
if ((native[0] != '\0') && (native[1] == ':')
&& (native[2] == '\\') && (native[3] == '\\')) {
native += 2;
}
Tcl_WinTCharToUtf((TCHAR *) native, -1, bufferPtr);
}
for (p = Tcl_DStringValue(bufferPtr); *p != '\0'; p++) {
if (*p == '\\') {
*p = '/';
}
}
return Tcl_DStringValue(bufferPtr);
}
int
TclpObjStat(pathPtr, statPtr)
Tcl_Obj *pathPtr;
Tcl_StatBuf *statPtr;
{
#ifdef OLD_API
Tcl_Obj *transPtr;
transPtr = Tcl_FSGetTranslatedPath(NULL, pathPtr);
if (transPtr == NULL || (strpbrk(Tcl_GetString(transPtr), "?*") != NULL)) {
Tcl_SetErrno(ENOENT);
return -1;
}
#endif
TclWinFlushDirtyChannels ();
return NativeStat((CONST TCHAR*) Tcl_FSGetNativePath(pathPtr), statPtr, 0);
}
static int
NativeStat(nativePath, statPtr, checkLinks)
CONST TCHAR *nativePath;
Tcl_StatBuf *statPtr;
int checkLinks;
{
Tcl_DString ds;
DWORD attr;
WCHAR nativeFullPath[MAX_PATH];
TCHAR *nativePart;
CONST char *fullPath;
int dev, mode;
if (tclWinProcs->getFileAttributesExProc == NULL) {
WIN32_FIND_DATAT data;
HANDLE handle;
handle = (*tclWinProcs->findFirstFileProc)(nativePath, &data);
if (handle == INVALID_HANDLE_VALUE) {
attr = (*tclWinProcs->getFileAttributesProc)(nativePath);
if (attr == 0xffffffff) {
Tcl_SetErrno(ENOENT);
return -1;
}
memset(&data, 0, sizeof(data));
data.a.dwFileAttributes = attr;
} else {
FindClose(handle);
}
(*tclWinProcs->getFullPathNameProc)(nativePath, MAX_PATH, nativeFullPath,
&nativePart);
fullPath = Tcl_WinTCharToUtf((TCHAR *) nativeFullPath, -1, &ds);
dev = -1;
if ((fullPath[0] == '\\') && (fullPath[1] == '\\')) {
CONST char *p;
DWORD dw;
CONST TCHAR *nativeVol;
Tcl_DString volString;
p = strchr(fullPath + 2, '\\');
p = strchr(p + 1, '\\');
if (p == NULL) {
fullPath = Tcl_DStringAppend(&ds, "\\", 1);
p = fullPath + Tcl_DStringLength(&ds);
} else {
p++;
}
nativeVol = Tcl_WinUtfToTChar(fullPath, p - fullPath, &volString);
dw = (DWORD) -1;
(*tclWinProcs->getVolumeInformationProc)(nativeVol, NULL, 0, &dw,
NULL, NULL, NULL, 0);
dev = dw;
Tcl_DStringFree(&volString);
} else if ((fullPath[0] != '\0') && (fullPath[1] == ':')) {
dev = Tcl_UniCharToLower(fullPath[0]) - 'a';
}
Tcl_DStringFree(&ds);
attr = data.a.dwFileAttributes;
statPtr->st_size = ((Tcl_WideInt)data.a.nFileSizeLow) |
(((Tcl_WideInt)data.a.nFileSizeHigh) << 32);
statPtr->st_atime = ToCTime(data.a.ftLastAccessTime);
statPtr->st_mtime = ToCTime(data.a.ftLastWriteTime);
statPtr->st_ctime = ToCTime(data.a.ftCreationTime);
} else {
WIN32_FILE_ATTRIBUTE_DATA data;
if((*tclWinProcs->getFileAttributesExProc)(nativePath,
GetFileExInfoStandard,
&data) != TRUE) {
Tcl_SetErrno(ENOENT);
return -1;
}
(*tclWinProcs->getFullPathNameProc)(nativePath, MAX_PATH,
nativeFullPath, &nativePart);
fullPath = Tcl_WinTCharToUtf((TCHAR *) nativeFullPath, -1, &ds);
dev = -1;
if ((fullPath[0] == '\\') && (fullPath[1] == '\\')) {
CONST char *p;
DWORD dw;
CONST TCHAR *nativeVol;
Tcl_DString volString;
p = strchr(fullPath + 2, '\\');
p = strchr(p + 1, '\\');
if (p == NULL) {
fullPath = Tcl_DStringAppend(&ds, "\\", 1);
p = fullPath + Tcl_DStringLength(&ds);
} else {
p++;
}
nativeVol = Tcl_WinUtfToTChar(fullPath, p - fullPath, &volString);
dw = (DWORD) -1;
(*tclWinProcs->getVolumeInformationProc)(nativeVol, NULL, 0, &dw,
NULL, NULL, NULL, 0);
dev = dw;
Tcl_DStringFree(&volString);
} else if ((fullPath[0] != '\0') && (fullPath[1] == ':')) {
dev = Tcl_UniCharToLower(fullPath[0]) - 'a';
}
Tcl_DStringFree(&ds);
attr = data.dwFileAttributes;
statPtr->st_size = ((Tcl_WideInt)data.nFileSizeLow) |
(((Tcl_WideInt)data.nFileSizeHigh) << 32);
statPtr->st_atime = ToCTime(data.ftLastAccessTime);
statPtr->st_mtime = ToCTime(data.ftLastWriteTime);
statPtr->st_ctime = ToCTime(data.ftCreationTime);
}
if (checkLinks && (attr & FILE_ATTRIBUTE_REPARSE_POINT)) {
mode = S_IFLNK;
} else {
mode = (attr & FILE_ATTRIBUTE_DIRECTORY) ? S_IFDIR | S_IEXEC : S_IFREG;
}
mode |= (attr & FILE_ATTRIBUTE_READONLY) ? S_IREAD : S_IREAD | S_IWRITE;
if (NativeIsExec(nativePath)) {
mode |= S_IEXEC;
}
mode |= (mode & 0x0700) >> 3;
mode |= (mode & 0x0700) >> 6;
statPtr->st_dev = (dev_t) dev;
statPtr->st_ino = 0;
statPtr->st_mode = (unsigned short) mode;
statPtr->st_nlink = 1;
statPtr->st_uid = 0;
statPtr->st_gid = 0;
statPtr->st_rdev = (dev_t) dev;
return 0;
}
static time_t
ToCTime(
FILETIME fileTime)
{
FILETIME localFileTime;
SYSTEMTIME systemTime;
struct tm tm;
if (FileTimeToLocalFileTime(&fileTime, &localFileTime) == 0) {
return 0;
}
if (FileTimeToSystemTime(&localFileTime, &systemTime) == 0) {
return 0;
}
tm.tm_sec = systemTime.wSecond;
tm.tm_min = systemTime.wMinute;
tm.tm_hour = systemTime.wHour;
tm.tm_mday = systemTime.wDay;
tm.tm_mon = systemTime.wMonth - 1;
tm.tm_year = systemTime.wYear - 1900;
tm.tm_wday = 0;
tm.tm_yday = 0;
tm.tm_isdst = -1;
return mktime(&tm);
}
#if 0
if ((result == 0) && (buf->st_mtime != 0)) {
TIME_ZONE_INFORMATION tz;
int time, bias;
time = GetTimeZoneInformation(&tz);
bias = tz.Bias;
if (time == TIME_ZONE_ID_DAYLIGHT) {
bias += tz.DaylightBias;
}
bias *= 60;
buf->st_atime -= bias;
buf->st_ctime -= bias;
buf->st_mtime -= bias;
}
#endif
#if 0
int
TclWinResolveShortcut(bufferPtr)
Tcl_DString *bufferPtr;
{
HRESULT hres;
IShellLink *psl;
IPersistFile *ppf;
WIN32_FIND_DATA wfd;
WCHAR wpath[MAX_PATH];
char *path, *ext;
char realFileName[MAX_PATH];
path = Tcl_DStringValue(bufferPtr);
ext = strrchr(path, '.');
if ((ext == NULL) || (stricmp(ext, ".lnk") != 0)) {
return 0;
}
CoInitialize(NULL);
path = Tcl_DStringValue(bufferPtr);
realFileName[0] = '\0';
hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLink, &psl);
if (SUCCEEDED(hres)) {
hres = psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf);
if (SUCCEEDED(hres)) {
MultiByteToWideChar(CP_ACP, 0, path, -1, wpath, sizeof(wpath));
hres = ppf->lpVtbl->Load(ppf, wpath, STGM_READ);
if (SUCCEEDED(hres)) {
hres = psl->lpVtbl->Resolve(psl, NULL,
SLR_ANY_MATCH | SLR_NO_UI);
if (SUCCEEDED(hres)) {
hres = psl->lpVtbl->GetPath(psl, realFileName, MAX_PATH,
&wfd, 0);
}
}
ppf->lpVtbl->Release(ppf);
}
psl->lpVtbl->Release(psl);
}
CoUninitialize();
if (realFileName[0] != '\0') {
Tcl_DStringSetLength(bufferPtr, 0);
Tcl_DStringAppend(bufferPtr, realFileName, -1);
return 1;
}
return 0;
}
#endif
Tcl_Obj*
TclpObjGetCwd(interp)
Tcl_Interp *interp;
{
Tcl_DString ds;
if (TclpGetCwd(interp, &ds) != NULL) {
Tcl_Obj *cwdPtr = Tcl_NewStringObj(Tcl_DStringValue(&ds), -1);
Tcl_IncrRefCount(cwdPtr);
Tcl_DStringFree(&ds);
return cwdPtr;
} else {
return NULL;
}
}
int
TclpObjAccess(pathPtr, mode)
Tcl_Obj *pathPtr;
int mode;
{
return NativeAccess((CONST TCHAR*) Tcl_FSGetNativePath(pathPtr), mode);
}
int
TclpObjLstat(pathPtr, statPtr)
Tcl_Obj *pathPtr;
Tcl_StatBuf *statPtr;
{
TclWinFlushDirtyChannels ();
return NativeStat((CONST TCHAR*) Tcl_FSGetNativePath(pathPtr), statPtr, 1);
}
#ifdef S_IFLNK
Tcl_Obj*
TclpObjLink(pathPtr, toPtr, linkAction)
Tcl_Obj *pathPtr;
Tcl_Obj *toPtr;
int linkAction;
{
if (toPtr != NULL) {
int res;
TCHAR* LinkTarget = (TCHAR*)Tcl_FSGetNativePath(toPtr);
TCHAR* LinkSource = (TCHAR*)Tcl_FSGetNativePath(pathPtr);
if (LinkSource == NULL || LinkTarget == NULL) {
return NULL;
}
res = WinLink(LinkSource, LinkTarget, linkAction);
if (res == 0) {
return toPtr;
} else {
return NULL;
}
} else {
TCHAR* LinkSource = (TCHAR*)Tcl_FSGetNativePath(pathPtr);
if (LinkSource == NULL) {
return NULL;
}
return WinReadLink(LinkSource);
}
}
#endif
Tcl_Obj*
TclpFilesystemPathType(pathObjPtr)
Tcl_Obj* pathObjPtr;
{
#define VOL_BUF_SIZE 32
int found;
char volType[VOL_BUF_SIZE];
char* firstSeparator;
CONST char *path;
Tcl_Obj *normPath = Tcl_FSGetNormalizedPath(NULL, pathObjPtr);
if (normPath == NULL) return NULL;
path = Tcl_GetString(normPath);
if (path == NULL) return NULL;
firstSeparator = strchr(path, '/');
if (firstSeparator == NULL) {
found = tclWinProcs->getVolumeInformationProc(
Tcl_FSGetNativePath(pathObjPtr), NULL, 0, NULL, NULL,
NULL, (WCHAR *)volType, VOL_BUF_SIZE);
} else {
Tcl_Obj *driveName = Tcl_NewStringObj(path, firstSeparator - path+1);
Tcl_IncrRefCount(driveName);
found = tclWinProcs->getVolumeInformationProc(
Tcl_FSGetNativePath(driveName), NULL, 0, NULL, NULL,
NULL, (WCHAR *)volType, VOL_BUF_SIZE);
Tcl_DecrRefCount(driveName);
}
if (found == 0) {
return NULL;
} else {
Tcl_DString ds;
Tcl_Obj *objPtr;
Tcl_WinTCharToUtf(volType, -1, &ds);
objPtr = Tcl_NewStringObj(Tcl_DStringValue(&ds),Tcl_DStringLength(&ds));
Tcl_DStringFree(&ds);
return objPtr;
}
#undef VOL_BUF_SIZE
}
int
TclpObjNormalizePath(interp, pathPtr, nextCheckpoint)
Tcl_Interp *interp;
Tcl_Obj *pathPtr;
int nextCheckpoint;
{
char *lastValidPathEnd = NULL;
Tcl_DString dsNorm;
char *path;
char *currentPathEndPosition;
Tcl_DStringInit(&dsNorm);
path = Tcl_GetString(pathPtr);
if (TclWinGetPlatformId() == VER_PLATFORM_WIN32_WINDOWS) {
Tcl_Obj *temp = NULL;
int isDrive = 1;
Tcl_DString ds;
currentPathEndPosition = path + nextCheckpoint;
while (1) {
char cur = *currentPathEndPosition;
if ((cur == '/' || cur == 0) && (path != currentPathEndPosition)) {
CONST char *nativePath = Tcl_UtfToExternalDString(NULL, path,
currentPathEndPosition - path, &ds);
if (isDrive) {
if (GetFileAttributesA(nativePath)
== 0xffffffff) {
Tcl_DStringFree(&ds);
break;
}
if (nativePath[0] >= 'a') {
((char*)nativePath)[0] -= ('a' - 'A');
}
Tcl_DStringAppend(&dsNorm,nativePath,Tcl_DStringLength(&ds));
} else {
WIN32_FIND_DATA fData;
HANDLE handle;
handle = FindFirstFileA(nativePath, &fData);
if (handle == INVALID_HANDLE_VALUE) {
if (GetFileAttributesA(nativePath)
== 0xffffffff) {
Tcl_DStringFree(&ds);
break;
}
Tcl_DStringAppend(&dsNorm,"/", 1);
} else {
char *nativeName;
if (fData.cFileName[0] != '\0') {
nativeName = fData.cFileName;
} else {
nativeName = fData.cAlternateFileName;
}
FindClose(handle);
Tcl_DStringAppend(&dsNorm,"/", 1);
Tcl_DStringAppend(&dsNorm,nativeName,-1);
}
}
Tcl_DStringFree(&ds);
lastValidPathEnd = currentPathEndPosition;
if (cur == 0) {
break;
}
isDrive = 0;
}
currentPathEndPosition++;
}
} else {
Tcl_Obj *temp = NULL;
int isDrive = 1;
Tcl_DString ds;
currentPathEndPosition = path + nextCheckpoint;
while (1) {
char cur = *currentPathEndPosition;
if ((cur == '/' || cur == 0) && (path != currentPathEndPosition)) {
WIN32_FILE_ATTRIBUTE_DATA data;
CONST char *nativePath = Tcl_WinUtfToTChar(path,
currentPathEndPosition - path, &ds);
if ((*tclWinProcs->getFileAttributesExProc)(nativePath,
GetFileExInfoStandard, &data) != TRUE) {
Tcl_DStringFree(&ds);
break;
}
if (cur != 0 && !isDrive && (data.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT)) {
Tcl_Obj *to = WinReadLinkDirectory(nativePath);
if (to != NULL) {
nextCheckpoint = 0;
Tcl_AppendToObj(to, currentPathEndPosition, -1);
for (path = Tcl_GetString(to); *path != 0; path++) {
if (*path == '\\') *path = '/';
}
path = Tcl_GetString(to);
currentPathEndPosition = path + nextCheckpoint;
if (temp != NULL) {
Tcl_DecrRefCount(temp);
}
temp = to;
isDrive = 1;
Tcl_DStringFree(&dsNorm);
Tcl_DStringInit(&dsNorm);
Tcl_DStringFree(&ds);
continue;
}
}
if (isDrive) {
WCHAR drive = ((WCHAR*)nativePath)[0];
if (drive >= L'a') {
drive -= (L'a' - L'A');
((WCHAR*)nativePath)[0] = drive;
}
Tcl_DStringAppend(&dsNorm,nativePath,Tcl_DStringLength(&ds));
} else {
WIN32_FIND_DATAW fData;
HANDLE handle;
handle = FindFirstFileW((WCHAR*)nativePath, &fData);
if (handle == INVALID_HANDLE_VALUE) {
Tcl_DStringAppend(&dsNorm,(CONST char*)L"/",
sizeof(WCHAR));
} else {
WCHAR *nativeName;
if (fData.cFileName[0] != '\0') {
nativeName = fData.cFileName;
} else {
nativeName = fData.cAlternateFileName;
}
FindClose(handle);
Tcl_DStringAppend(&dsNorm,(CONST char*)L"/",
sizeof(WCHAR));
Tcl_DStringAppend(&dsNorm,(TCHAR*)nativeName,
wcslen(nativeName)*sizeof(WCHAR));
}
}
Tcl_DStringFree(&ds);
lastValidPathEnd = currentPathEndPosition;
if (cur == 0) {
break;
}
isDrive = 0;
}
currentPathEndPosition++;
}
}
nextCheckpoint = currentPathEndPosition - path;
if (lastValidPathEnd != NULL) {
Tcl_DString dsTemp;
Tcl_WinTCharToUtf(Tcl_DStringValue(&dsNorm),
Tcl_DStringLength(&dsNorm), &dsTemp);
nextCheckpoint = Tcl_DStringLength(&dsTemp);
if (*lastValidPathEnd != 0) {
int len;
char *path;
Tcl_Obj *tmpPathPtr;
tmpPathPtr = Tcl_NewStringObj(Tcl_DStringValue(&dsTemp),
nextCheckpoint);
Tcl_AppendToObj(tmpPathPtr, lastValidPathEnd, -1);
path = Tcl_GetStringFromObj(tmpPathPtr, &len);
Tcl_SetStringObj(pathPtr, path, len);
Tcl_DecrRefCount(tmpPathPtr);
} else {
Tcl_SetStringObj(pathPtr, Tcl_DStringValue(&dsTemp),
nextCheckpoint);
}
Tcl_DStringFree(&dsTemp);
}
Tcl_DStringFree(&dsNorm);
return nextCheckpoint;
}