path.c File Reference

#include <k32.h>
#include <debug.h>

Include dependency graph for path.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PWCHAR WINAPI	BasepEndOfDirName (IN PWCHAR FileName)
LPWSTR WINAPI	BasepComputeProcessPath (IN PBASE_SEARCH_PATH_TYPE PathOrder, IN LPWSTR AppName, IN LPVOID Environment)
LPWSTR WINAPI	BaseComputeProcessSearchPath (VOID)
LPWSTR WINAPI	BaseComputeProcessExePath (IN LPWSTR FullPath)
LPWSTR WINAPI	BaseComputeProcessDllPath (IN LPWSTR FullPath, IN PVOID Environment)
BOOLEAN WINAPI	CheckForSameCurdir (IN PUNICODE_STRING DirName)
BOOL WINAPI	IsShortName_U (IN PWCHAR Name, IN ULONG Length)
BOOL WINAPI	IsLongName_U (IN PWCHAR FileName, IN ULONG Length)
BOOL WINAPI	FindLFNorSFN_U (IN PWCHAR Path, OUT PWCHAR *First, OUT PWCHAR *Last, IN BOOL UseShort)
PWCHAR WINAPI	SkipPathTypeIndicator_U (IN LPWSTR Path)
BOOL WINAPI	BasepIsCurDirAllowedForPlainExeNames (VOID)
BOOL WINAPI	SetDllDirectoryW (IN LPCWSTR lpPathName)
BOOL WINAPI	SetDllDirectoryA (IN LPCSTR lpPathName)
DWORD WINAPI	GetDllDirectoryW (IN DWORD nBufferLength, OUT LPWSTR lpBuffer)
DWORD WINAPI	GetDllDirectoryA (IN DWORD nBufferLength, OUT LPSTR lpBuffer)
BOOL WINAPI	NeedCurrentDirectoryForExePathW (IN LPCWSTR ExeName)
BOOL WINAPI	NeedCurrentDirectoryForExePathA (IN LPCSTR ExeName)
DWORD WINAPI	GetFullPathNameA (IN LPCSTR lpFileName, IN DWORD nBufferLength, OUT LPSTR lpBuffer, OUT LPSTR *lpFilePart)
DWORD WINAPI	GetFullPathNameW (IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
BOOL WINAPI	SetSearchPathMode (_In_ DWORD dwFlags)
DWORD WINAPI	SearchPathA (IN LPCSTR lpPath OPTIONAL, IN LPCSTR lpFileName, IN LPCSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPSTR lpBuffer, OUT LPSTR *lpFilePart OPTIONAL)
DWORD WINAPI	SearchPathW (IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
DWORD WINAPI	GetLongPathNameW (IN LPCWSTR lpszShortPath, OUT LPWSTR lpszLongPath, IN DWORD cchBuffer)
DWORD WINAPI	GetLongPathNameA (IN LPCSTR lpszShortPath, OUT LPSTR lpszLongPath, IN DWORD cchBuffer)
DWORD WINAPI	GetShortPathNameW (IN LPCWSTR lpszLongPath, OUT LPWSTR lpszShortPath, IN DWORD cchBuffer)
DWORD WINAPI	GetTempPathA (IN DWORD nBufferLength, OUT LPSTR lpBuffer)
DWORD WINAPI	GetTempPathW (IN DWORD count, OUT LPWSTR path)
DWORD WINAPI	GetCurrentDirectoryA (IN DWORD nBufferLength, OUT LPSTR lpBuffer)
DWORD WINAPI	GetCurrentDirectoryW (IN DWORD nBufferLength, OUT LPWSTR lpBuffer)
BOOL WINAPI	SetCurrentDirectoryA (IN LPCSTR lpPathName)
BOOL WINAPI	SetCurrentDirectoryW (IN LPCWSTR lpPathName)
UINT WINAPI	GetSystemDirectoryA (OUT LPSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetSystemDirectoryW (OUT LPWSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetWindowsDirectoryA (OUT LPSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetWindowsDirectoryW (OUT LPWSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetSystemWindowsDirectoryA (OUT LPSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetSystemWindowsDirectoryW (OUT LPWSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetSystemWow64DirectoryW (OUT LPWSTR lpBuffer, IN UINT uSize)
UINT WINAPI	GetSystemWow64DirectoryA (OUT LPSTR lpBuffer, IN UINT uSize)

Variables
UNICODE_STRING	NoDefaultCurrentDirectoryInExePath = RTL_CONSTANT_STRING(L"NoDefaultCurrentDirectoryInExePath")
UNICODE_STRING	BaseWindowsSystemDirectory
UNICODE_STRING	BaseWindowsDirectory
UNICODE_STRING	BaseDefaultPathAppend
UNICODE_STRING	BaseDefaultPath
UNICODE_STRING	BaseDllDirectory
PVOID	gpTermsrvGetWindowsDirectoryA
PVOID	gpTermsrvGetWindowsDirectoryW
DWORD	IllegalMask [4]
BASE_SEARCH_PATH_TYPE	BaseDllOrderCurrent [BaseCurrentDirPlacementMax][BaseSearchPathMax]
BASE_SEARCH_PATH_TYPE	BaseProcessOrderNoCurrent [BaseSearchPathMax]
BASE_SEARCH_PATH_TYPE	BaseDllOrderNoCurrent [BaseSearchPathMax]
BASE_SEARCH_PATH_TYPE	BaseProcessOrder [BaseSearchPathMax]
BASE_CURRENT_DIR_PLACEMENT	BasepDllCurrentDirPlacement = BaseCurrentDirPlacementInvalid
DWORD	BasepSearchPathModeFlags = BASE_SEARCH_PATH_INVALID_FLAGS
UNICODE_STRING	BasePathVariableName

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file path.c.

Function Documentation

BaseComputeProcessDllPath()

LPWSTR WINAPI BaseComputeProcessDllPath	(	IN LPWSTR	FullPath,
		IN PVOID	Environment
	)

Definition at line 478 of file path.c.

{
    LPWSTR DllPath = NULL;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\MACHINE\\System\\CurrentControlSet\\Control\\Session Manager");
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SafeDllSearchMode");
    OBJECT_ATTRIBUTES ObjectAttributes = RTL_CONSTANT_OBJECT_ATTRIBUTES(&KeyName, OBJ_CASE_INSENSITIVE);
    CHAR PartialInfoBuffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + sizeof(ULONG)];
    HANDLE KeyHandle;
    NTSTATUS Status;
    ULONG ResultLength;
    BASE_CURRENT_DIR_PLACEMENT CurrentDirPlacement, OldCurrentDirPlacement;
 
    /* Acquire DLL directory lock */
    RtlEnterCriticalSection(&BaseDllDirectoryLock);
 
    /* Check if we have a base dll directory */
    if (BaseDllDirectory.Buffer)
    {
        /* Then compute the process path using DLL order (without curdir) */
        DllPath = BasepComputeProcessPath(BaseDllOrderNoCurrent, FullPath, Environment);
 
        /* Release DLL directory lock */
        RtlLeaveCriticalSection(&BaseDllDirectoryLock);
 
        /* Return dll path */
        return DllPath;
    }
 
    /* Release DLL directory lock */
    RtlLeaveCriticalSection(&BaseDllDirectoryLock);
 
    /* Read the current placement */
    CurrentDirPlacement = BasepDllCurrentDirPlacement;
    if (CurrentDirPlacement == BaseCurrentDirPlacementInvalid)
    {
        /* Open the configuration key */
        Status = NtOpenKey(&KeyHandle, KEY_QUERY_VALUE, &ObjectAttributes);
        if (NT_SUCCESS(Status))
        {
            /* Query if safe search is enabled */
            Status = NtQueryValueKey(KeyHandle,
                                     &ValueName,
                                     KeyValuePartialInformation,
                                     PartialInfoBuffer,
                                     sizeof(PartialInfoBuffer),
                                     &ResultLength);
            if (NT_SUCCESS(Status))
            {
                /* Read the value if the size is OK */
                if (ResultLength == sizeof(PartialInfoBuffer))
                {
                    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)PartialInfoBuffer;
                    CurrentDirPlacement = *(PULONG)PartialInfo->Data;
                }
            }
 
            /* Close the handle */
            NtClose(KeyHandle);
 
            /* Validate the registry value */
            if ((CurrentDirPlacement <= BaseCurrentDirPlacementInvalid) ||
                (CurrentDirPlacement >= BaseCurrentDirPlacementMax))
            {
                /* Default to safe search */
                CurrentDirPlacement = BaseCurrentDirPlacementSafe;
            }
        }
 
        /* Update the placement and read the old one */
        OldCurrentDirPlacement = InterlockedCompareExchange((PLONG)&BasepDllCurrentDirPlacement,
                                                            CurrentDirPlacement,
                                                            BaseCurrentDirPlacementInvalid);
        if (OldCurrentDirPlacement != BaseCurrentDirPlacementInvalid)
        {
            /* If there already was a placement, use it */
            CurrentDirPlacement = OldCurrentDirPlacement;
        }
    }
 
    /* Check if the placement is invalid or not set */
    if ((CurrentDirPlacement <= BaseCurrentDirPlacementInvalid) ||
        (CurrentDirPlacement >= BaseCurrentDirPlacementMax))
    {
        /* Default to safe search */
        CurrentDirPlacement = BaseCurrentDirPlacementSafe;
    }
 
    /* Compute the process path using either normal or safe search */
    DllPath = BasepComputeProcessPath(BaseDllOrderCurrent[CurrentDirPlacement],
                                      FullPath,
                                      Environment);
 
    /* Return dll path */
    return DllPath;
}

Referenced by BasePushProcessParameters(), GetModuleHandleForUnicodeString(), and LoadLibraryExW().

BaseComputeProcessExePath()

LPWSTR WINAPI BaseComputeProcessExePath

(

IN LPWSTR

FullPath

)

Definition at line 463 of file path.c.

{
    PBASE_SEARCH_PATH_TYPE PathOrder;
    DPRINT("Computing EXE path: %S\n", FullPath);
 
    /* Check if we should use the current directory */
    PathOrder = NeedCurrentDirectoryForExePathW(FullPath) ?
                BaseProcessOrder : BaseProcessOrderNoCurrent;
 
    /* And now compute the path */
    return BasepComputeProcessPath(PathOrder, NULL, NULL);
}

Referenced by CreateProcessInternalW().

BaseComputeProcessSearchPath()

LPWSTR WINAPI BaseComputeProcessSearchPath

(

VOID

)

Definition at line 397 of file path.c.

{
    BASE_CURRENT_DIR_PLACEMENT CurDirPlacement;
    DWORD CurrentModeFlags, OldCurrentModeFlags;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\MACHINE\\System\\CurrentControlSet\\Control\\Session Manager");
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SafeProcessSearchMode");
    OBJECT_ATTRIBUTES ObjectAttributes = RTL_CONSTANT_OBJECT_ATTRIBUTES(&KeyName, OBJ_CASE_INSENSITIVE);
    CHAR PartialInfoBuffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + sizeof(DWORD)];
    HANDLE KeyHandle;
    NTSTATUS Status;
    ULONG ResultLength;
 
    DPRINT("Computing Process Search path\n");
 
    CurrentModeFlags = BasepSearchPathModeFlags;
    /* No flag is set, read from registry */
    if (CurrentModeFlags == BASE_SEARCH_PATH_INVALID_FLAGS)
    {
        /* Open the configuration key */
        Status = NtOpenKey(&KeyHandle, KEY_QUERY_VALUE, &ObjectAttributes);
        if (NT_SUCCESS(Status))
        {
            /* Query if safe search is enabled */
            Status = NtQueryValueKey(KeyHandle,
                                     &ValueName,
                                     KeyValuePartialInformation,
                                     PartialInfoBuffer,
                                     sizeof(PartialInfoBuffer),
                                     &ResultLength);
            if (NT_SUCCESS(Status))
            {
                /* Read the value if the size is OK */
                if (ResultLength == sizeof(PartialInfoBuffer))
                {
                    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)PartialInfoBuffer;
                    /* 0 means disabled and 1 means enabled */
                    CurrentModeFlags = *(PDWORD)PartialInfo->Data == 1
                                       ? BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE
                                       : BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE;
                }
            }
            /* Close the handle */
            NtClose(KeyHandle);
        }
 
        /* Fallback to default value if couldn't read from registry */
        if (CurrentModeFlags == BASE_SEARCH_PATH_INVALID_FLAGS)
            CurrentModeFlags = BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE;
 
        /* Update the flag and read the old one */
        OldCurrentModeFlags = InterlockedCompareExchange((PLONG)&BasepSearchPathModeFlags,
                                                         CurrentModeFlags,
                                                         BASE_SEARCH_PATH_INVALID_FLAGS);
        if (OldCurrentModeFlags != BASE_SEARCH_PATH_INVALID_FLAGS)
            CurrentModeFlags = OldCurrentModeFlags;
    }
 
    CurDirPlacement = CurrentModeFlags & BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE ?
                      BaseCurrentDirPlacementSafe : BaseCurrentDirPlacementDefault;
 
    /* Compute the path using default process order */
    return BasepComputeProcessPath(BaseDllOrderCurrent[CurDirPlacement], NULL, NULL);
}

Referenced by SearchPathW().

BasepComputeProcessPath()

LPWSTR WINAPI BasepComputeProcessPath	(	IN PBASE_SEARCH_PATH_TYPE	PathOrder,
		IN LPWSTR	AppName,
		IN LPVOID	Environment
	)

Definition at line 118 of file path.c.

{
    PWCHAR PathBuffer, Buffer, AppNameEnd, PathCurrent;
    SIZE_T PathLengthInBytes;
    NTSTATUS Status;
    UNICODE_STRING EnvPath;
    PBASE_SEARCH_PATH_TYPE Order;
 
    /* Initialize state */
    AppNameEnd = Buffer = PathBuffer = NULL;
    Status = STATUS_SUCCESS;
    PathLengthInBytes = 0;
 
    /* Loop the ordering array */
    for (Order = PathOrder; *Order != BaseSearchPathInvalid; Order++) {
    switch (*Order)
    {
        /* Compute the size of the DLL path */
        case BaseSearchPathDll:
 
            /* This path only gets called if SetDllDirectory was called */
            ASSERT(BaseDllDirectory.Buffer != NULL);
 
            /* Make sure there's a DLL directory size */
            if (BaseDllDirectory.Length)
            {
                /* Add it, plus the separator */
                PathLengthInBytes += BaseDllDirectory.Length + sizeof(L';');
            }
            break;
 
        /* Compute the size of the current path */
        case BaseSearchPathCurrent:
 
            /* Add ".;" */
            PathLengthInBytes += (2 * sizeof(WCHAR));
            break;
 
        /* Compute the size of the "PATH" environment variable */
        case BaseSearchPathEnv:
 
            /* Grab PEB lock if one wasn't passed in */
            if (!Environment) RtlAcquirePebLock();
 
            /* Query the size first */
            EnvPath.MaximumLength = 0;
            Status = RtlQueryEnvironmentVariable_U(Environment,
                                                   &BasePathVariableName,
                                                   &EnvPath);
            if (Status == STATUS_BUFFER_TOO_SMALL)
            {
                /* Compute the size we'll need for the environment */
                EnvPath.MaximumLength = EnvPath.Length + sizeof(WCHAR);
                if ((EnvPath.Length + sizeof(WCHAR)) > UNICODE_STRING_MAX_BYTES)
                {
                    /* Don't let it overflow */
                    EnvPath.MaximumLength = EnvPath.Length;
                }
 
                /* Allocate the environment buffer */
                Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                         0,
                                         EnvPath.MaximumLength);
                if (Buffer)
                {
                    /* Now query the PATH environment variable */
                    EnvPath.Buffer = Buffer;
                    Status = RtlQueryEnvironmentVariable_U(Environment,
                                                           &BasePathVariableName,
                                                           &EnvPath);
                }
                else
                {
                    /* Failure case */
                    Status = STATUS_NO_MEMORY;
                }
            }
 
            /* Release the PEB lock from above */
            if (!Environment) RtlReleasePebLock();
 
            /* There might not be a PATH */
            if (Status == STATUS_VARIABLE_NOT_FOUND)
            {
                /* In this case, skip this PathOrder */
                EnvPath.Length = EnvPath.MaximumLength = 0;
                Status = STATUS_SUCCESS;
            }
            else if (!NT_SUCCESS(Status))
            {
                /* An early failure, go to exit code */
                goto Quickie;
            }
            else
            {
                /* Add the length of the PATH variable unless it's empty */
                ASSERT(!(EnvPath.Length & 1));
                if (EnvPath.Length)
                {
                    /* Reserve space for the variable and a semicolon */
                    PathLengthInBytes += (EnvPath.Length + sizeof(L';'));
                }
            }
            break;
 
        /* Compute the size of the default search path */
        case BaseSearchPathDefault:
 
            /* Just add it... it already has a ';' at the end */
            ASSERT(!(BaseDefaultPath.Length & 1));
            PathLengthInBytes += BaseDefaultPath.Length;
            break;
 
        /* Compute the size of the current app directory */
        case BaseSearchPathApp:
            /* Find out where the app name ends, to get only the directory */
            if (AppName) AppNameEnd = BasepEndOfDirName(AppName);
 
            /* Check if there was no application name passed in */
            if (!(AppName) || !(AppNameEnd))
            {
                /* Do we have a per-thread CURDIR to use? */
                if (NtCurrentTeb()->NtTib.SubSystemTib)
                {
                    /* This means someone added RTL_PERTHREAD_CURDIR */
                    UNIMPLEMENTED_DBGBREAK();
                }
 
                /* We do not. Do we have the LDR_ENTRY for the executable? */
                if (!BasepExeLdrEntry)
                {
                    /* We do not. Grab it */
                    LdrEnumerateLoadedModules(0,
                                              BasepLocateExeLdrEntry,
                                              NtCurrentPeb()->ImageBaseAddress);
                }
 
                /* Now do we have it? */
                if (BasepExeLdrEntry)
                {
                    /* Yes, so read the name out of it */
                    AppName = BasepExeLdrEntry->FullDllName.Buffer;
                }
 
                /* Find out where the app name ends, to get only the directory */
                if (AppName) AppNameEnd = BasepEndOfDirName(AppName);
            }
 
            /* So, do we have an application name and its directory? */
            if ((AppName) && (AppNameEnd))
            {
                /* Add the size of the app's directory, plus the separator */
                PathLengthInBytes += ((AppNameEnd - AppName) * sizeof(WCHAR)) + sizeof(L';');
            }
            break;
 
        default:
            break;
        }
    }
 
    /* Bam, all done, we now have the final path size */
    ASSERT(PathLengthInBytes > 0);
    ASSERT(!(PathLengthInBytes & 1));
 
    /* Allocate the buffer to hold it */
    PathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathLengthInBytes);
    if (!PathBuffer)
    {
        /* Failure path */
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Now we loop again, this time to copy the data */
    PathCurrent = PathBuffer;
    for (Order = PathOrder; *Order != BaseSearchPathInvalid; Order++) {
    switch (*Order)
    {
        /* Add the DLL path */
        case BaseSearchPathDll:
            if (BaseDllDirectory.Length)
            {
                /* Copy it in the buffer, ASSERT there's enough space */
                ASSERT((((PathCurrent - PathBuffer + 1) * sizeof(WCHAR)) + BaseDllDirectory.Length) <= PathLengthInBytes);
                RtlCopyMemory(PathCurrent,
                              BaseDllDirectory.Buffer,
                              BaseDllDirectory.Length);
 
                /* Update the current pointer, add a separator */
                PathCurrent += (BaseDllDirectory.Length / sizeof(WCHAR));
                *PathCurrent++ = ';';
            }
            break;
 
        /* Add the current application path */
        case BaseSearchPathApp:
            if ((AppName) && (AppNameEnd))
            {
                /* Copy it in the buffer, ASSERT there's enough space */
                ASSERT(((PathCurrent - PathBuffer + 1 + (AppNameEnd - AppName)) * sizeof(WCHAR)) <= PathLengthInBytes);
                RtlCopyMemory(PathCurrent,
                              AppName,
                              (AppNameEnd - AppName) * sizeof(WCHAR));
 
                /* Update the current pointer, add a separator */
                PathCurrent += AppNameEnd - AppName;
                *PathCurrent++ = ';';
            }
            break;
 
        /* Add the default search path */
        case BaseSearchPathDefault:
            /* Copy it in the buffer, ASSERT there's enough space */
            ASSERT((((PathCurrent - PathBuffer) * sizeof(WCHAR)) + BaseDefaultPath.Length) <= PathLengthInBytes);
            RtlCopyMemory(PathCurrent, BaseDefaultPath.Buffer, BaseDefaultPath.Length);
 
            /* Update the current pointer. The default path already has a ";" */
            PathCurrent += (BaseDefaultPath.Length / sizeof(WCHAR));
            break;
 
        /* Add the path in the PATH environment variable */
        case BaseSearchPathEnv:
            if (EnvPath.Length)
            {
                /* Copy it in the buffer, ASSERT there's enough space */
                ASSERT((((PathCurrent - PathBuffer + 1) * sizeof(WCHAR)) + EnvPath.Length) <= PathLengthInBytes);
                RtlCopyMemory(PathCurrent, EnvPath.Buffer, EnvPath.Length);
 
                /* Update the current pointer, add a separator */
                PathCurrent += (EnvPath.Length / sizeof(WCHAR));
                *PathCurrent++ = ';';
            }
            break;
 
        /* Add the current directory */
        case BaseSearchPathCurrent:
 
            /* Copy it in the buffer, ASSERT there's enough space */
            ASSERT(((PathCurrent - PathBuffer + 2) * sizeof(WCHAR)) <= PathLengthInBytes);
            *PathCurrent++ = '.';
 
            /* Add the path separator */
            *PathCurrent++ = ';';
            break;
 
        default:
            break;
        }
    }
 
    /* Everything should've perfectly fit in there */
    ASSERT((PathCurrent - PathBuffer) * sizeof(WCHAR) == PathLengthInBytes);
    ASSERT(PathCurrent > PathBuffer);
 
    /* Terminate the whole thing */
    PathCurrent[-1] = UNICODE_NULL;
 
Quickie:
    /* Exit path: free our buffers */
    if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    if (PathBuffer)
    {
        /* This only gets freed in the failure path, since caller wants it */
        if (!NT_SUCCESS(Status))
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
            PathBuffer = NULL;
        }
    }
 
    /* Return the path! */
    return PathBuffer;
}

Referenced by BaseComputeProcessDllPath(), BaseComputeProcessExePath(), and BaseComputeProcessSearchPath().

BasepEndOfDirName()

PWCHAR WINAPI BasepEndOfDirName

(

IN PWCHAR

FileName

)

Definition at line 91 of file path.c.

{
    PWCHAR FileNameEnd, FileNameSeparator;
 
    /* Find the first slash */
    FileNameSeparator = wcschr(FileName, OBJ_NAME_PATH_SEPARATOR);
    if (FileNameSeparator)
    {
        /* Find the last one */
        FileNameEnd = wcsrchr(FileNameSeparator, OBJ_NAME_PATH_SEPARATOR);
        ASSERT(FileNameEnd);
 
        /* Handle the case where they are one and the same */
        if (FileNameEnd == FileNameSeparator) FileNameEnd++;
    }
    else
    {
        /* No directory was specified */
        FileNameEnd = NULL;
    }
 
    /* Return where the directory ends and the filename starts */
    return FileNameEnd;
}

Referenced by BasepComputeProcessPath().

BasepIsCurDirAllowedForPlainExeNames()

BOOL WINAPI BasepIsCurDirAllowedForPlainExeNames

(

VOID

)

Definition at line 839 of file path.c.

{
    NTSTATUS Status;
    UNICODE_STRING EmptyString;
 
    RtlInitEmptyUnicodeString(&EmptyString, NULL, 0);
    Status = RtlQueryEnvironmentVariable_U(NULL,
                                           &NoDefaultCurrentDirectoryInExePath,
                                           &EmptyString);
    return !NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL;
}

Referenced by NeedCurrentDirectoryForExePathA(), and NeedCurrentDirectoryForExePathW().

CheckForSameCurdir()

BOOLEAN WINAPI CheckForSameCurdir

(

IN PUNICODE_STRING

DirName

)

Definition at line 577 of file path.c.

{
    PUNICODE_STRING CurDir;
    USHORT CurLength;
    BOOLEAN Result;
    UNICODE_STRING CurDirCopy;
 
    CurDir = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;
 
    CurLength = CurDir->Length;
    if (CurDir->Length <= 6)
    {
        if (CurLength != DirName->Length) return FALSE;
    }
    else
    {
        if ((CurLength - 2) != DirName->Length) return FALSE;
    }
 
    RtlAcquirePebLock();
 
    CurDirCopy = *CurDir;
    if (CurDirCopy.Length > 6) CurDirCopy.Length -= 2;
 
    Result = 0;
 
    if (RtlEqualUnicodeString(&CurDirCopy, DirName, TRUE)) Result = TRUE;
 
    RtlReleasePebLock();
 
    return Result;
}

Referenced by SetCurrentDirectoryA(), and SetCurrentDirectoryW().

FindLFNorSFN_U()

BOOL WINAPI FindLFNorSFN_U	(	IN PWCHAR	Path,
		OUT PWCHAR *	First,
		OUT PWCHAR *	Last,
		IN BOOL	UseShort
	)

Definition at line 740 of file path.c.

{
    PWCHAR p;
    ULONG Length;
    BOOL Found = 0;
    ASSERT(Path);
 
    /* Loop while there is something in the path */
    while (TRUE)
    {
        /* Loop within the path skipping slashes */
        while ((*Path == L'\\') || (*Path == L'/')) Path++;
 
        /* Make sure there's something after the slashes too! */
        if (*Path == UNICODE_NULL) break;
 
        /* Now skip past the file name until we get to the first slash */
        p = Path + 1;
        while ((*p) && ((*p != L'\\') && (*p != L'/'))) p++;
 
        /* Whatever is in between those two is now the file name length */
        Length = p - Path;
 
        /*
         * Check if it is valid
         * Note that !IsShortName != IsLongName, these two functions simply help
         * us determine if a conversion is necessary or not.
         * "Found" really means: "Is a conversion necessary?", hence the "!"
         */
        Found = UseShort ? !IsShortName_U(Path, Length) : !IsLongName_U(Path, Length);
        if (Found)
        {
            /* It is! did the caller request to know the markers? */
            if ((First) && (Last))
            {
                /* Return them */
                *First = Path;
                *Last = p;
            }
            break;
        }
 
        /* Is there anything else following this sub-path/filename? */
        if (*p == UNICODE_NULL) break;
 
        /* Yes, keep going */
        Path = p + 1;
    }
 
    /* Return if anything was found and valid */
    return Found;
}

Referenced by GetLongPathNameW(), and GetShortPathNameW().

GetCurrentDirectoryA()

DWORD WINAPI GetCurrentDirectoryA	(	IN DWORD	nBufferLength,
		OUT LPSTR	lpBuffer
	)

Definition at line 2164 of file path.c.

{
    ANSI_STRING AnsiString;
    NTSTATUS Status;
    PUNICODE_STRING StaticString;
    ULONG MaxLength;
 
    StaticString = &NtCurrentTeb()->StaticUnicodeString;
 
    MaxLength = nBufferLength;
    if (nBufferLength >= UNICODE_STRING_MAX_BYTES)
    {
        MaxLength = UNICODE_STRING_MAX_BYTES - 1;
    }
 
    StaticString->Length = (USHORT)RtlGetCurrentDirectory_U(StaticString->MaximumLength,
                                                            StaticString->Buffer);
    Status = RtlUnicodeToMultiByteSize(&nBufferLength,
                                       StaticString->Buffer,
                                       StaticString->Length);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return 0;
    }
 
    if (MaxLength <= nBufferLength)
    {
        return nBufferLength + 1;
    }
 
    AnsiString.Buffer = lpBuffer;
    AnsiString.MaximumLength = (USHORT)MaxLength;
    Status = BasepUnicodeStringTo8BitString(&AnsiString, StaticString, FALSE);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return 0;
    }
 
    return AnsiString.Length;
}

Referenced by create_cache_file(), create_file(), create_test_files(), d3dcompiler_include_from_file_open(), delnode_test(), doChild(), DosChangeDirectory(), DosKRNLInitialize(), FD31_WMInitDialog(), full_file_path_name_in_a_CWD(), get_directories(), get_temp_filename(), init(), init_shfo_tests(), LoadModuleWithSymbols(), make_tmp_file(), SheGetDirA(), START_TEST(), Test_AddFontResourceA(), test_binary_import(), test_BindToObject(), test_click_make_new_folder_button(), test_CreateDirectory_root(), test_CurrentDirectoryA(), test_dbmerge(), Test_DelNodeA(), test_directory(), test_drive_letter_case(), test_embedded_nulls(), test_EnumObjects_and_CompareIDs(), Test_FindFirstFileA(), Test_FindFirstFileExA(), test_forcecodepage(), test_formatrecord_tables(), test_fullpath(), test_GetAttributesOf(), test_GetVolumeInformationA(), test_GetVolumePathNameA(), test_InitPathA(), test_invalid_functions(), test_listbox_dlgdir(), test_listbox_LB_DIR(), test_LoadImage_working_directory(), test_LoadLibraryEx_search_flags(), test_LocalizedNames(), test_mhtml_protocol_binding(), test_msiexport(), test_MsiGetProductProperty(), test_msiimport(), test_MsiOpenProduct(), test_MsiProvideQualifiedComponentEx(), test_ok(), test_PathNameA(), test_RemoveDirectoryA(), test_RtlDosPathNameToNtPathName_U(), test_RtlGetFullPathName_U(), test_SearchPathA(), test_setdir(), test_SetSearchPathMode(), test_SHCreateShellItem(), test_suminfo_import(), test_toplevel_stat(), TestGetCurrentDirectoryA(), testLoadLibraryEx(), TestSetCurrentDirectoryA(), and WINHELP_GetOpenFileName().

GetCurrentDirectoryW()

DWORD WINAPI GetCurrentDirectoryW	(	IN DWORD	nBufferLength,
		OUT LPWSTR	lpBuffer
	)

Definition at line 2213 of file path.c.

{
    return RtlGetCurrentDirectory_U(nBufferLength * sizeof(WCHAR), lpBuffer) / sizeof(WCHAR);
}

GetDllDirectoryA()

DWORD WINAPI GetDllDirectoryA	(	IN DWORD	nBufferLength,
		OUT LPSTR	lpBuffer
	)

Definition at line 973 of file path.c.

{
    NTSTATUS Status;
    ANSI_STRING AnsiDllDirectory;
    ULONG Length;
 
    RtlInitEmptyAnsiString(&AnsiDllDirectory, lpBuffer, (USHORT)nBufferLength);
 
    RtlEnterCriticalSection(&BaseDllDirectoryLock);
 
    Length = BasepUnicodeStringTo8BitSize(&BaseDllDirectory);
    if (Length > nBufferLength)
    {
        Status = STATUS_SUCCESS;
        if (lpBuffer) *lpBuffer = ANSI_NULL;
    }
    else
    {
        --Length;
        Status = BasepUnicodeStringTo8BitString(&AnsiDllDirectory,
                                                &BaseDllDirectory,
                                                FALSE);
    }
 
    RtlLeaveCriticalSection(&BaseDllDirectoryLock);
 
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        Length = 0;
        if (lpBuffer) *lpBuffer = ANSI_NULL;
    }
 
    return Length;
}

Referenced by init_pointers().

GetDllDirectoryW()

DWORD WINAPI GetDllDirectoryW	(	IN DWORD	nBufferLength,
		OUT LPWSTR	lpBuffer
	)

Definition at line 945 of file path.c.

{
    ULONG Length;
 
    RtlEnterCriticalSection(&BaseDllDirectoryLock);
 
    if ((nBufferLength * sizeof(WCHAR)) > BaseDllDirectory.Length)
    {
        RtlCopyMemory(lpBuffer, BaseDllDirectory.Buffer, BaseDllDirectory.Length);
        Length = BaseDllDirectory.Length / sizeof(WCHAR);
        lpBuffer[Length] = UNICODE_NULL;
    }
    else
    {
        Length = (BaseDllDirectory.Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR);
        if (lpBuffer) *lpBuffer = UNICODE_NULL;
    }
 
    RtlLeaveCriticalSection(&BaseDllDirectoryLock);
    return Length;
}

Referenced by init_pointers().

GetFullPathNameA()

DWORD WINAPI GetFullPathNameA	(	IN LPCSTR	lpFileName,
		IN DWORD	nBufferLength,
		OUT LPSTR	lpBuffer,
		OUT LPSTR *	lpFilePart
	)

Definition at line 1051 of file path.c.

{
    NTSTATUS Status;
    PWCHAR Buffer = NULL;
    ULONG PathSize, FilePartSize;
    ANSI_STRING AnsiString;
    UNICODE_STRING FileNameString, UniString;
    PWCHAR LocalFilePart;
    PWCHAR* FilePart;
 
    /* If the caller wants filepart, use a local wide buffer since this is A */
    FilePart = lpFilePart != NULL ? &LocalFilePart : NULL;
 
    /* Initialize for Quickie */
    FilePartSize = PathSize = 0;
    FileNameString.Buffer = NULL;
 
    /* First get our string in Unicode */
    Status = Basep8BitStringToDynamicUnicodeString(&FileNameString, lpFileName);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Allocate a buffer to hold teh path name */
    Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
                             0,
                             MAX_PATH * sizeof(WCHAR) + sizeof(UNICODE_NULL));
    if (!Buffer)
    {
        BaseSetLastNTError(STATUS_INSUFFICIENT_RESOURCES);
        goto Quickie;
    }
 
    /* Call into RTL to get the full Unicode path name */
    PathSize = RtlGetFullPathName_U(FileNameString.Buffer,
                                    MAX_PATH * sizeof(WCHAR),
                                    Buffer,
                                    FilePart);
    if (PathSize <= (MAX_PATH * sizeof(WCHAR)))
    {
        /* The buffer will fit, get the real ANSI string size now */
        Status = RtlUnicodeToMultiByteSize(&PathSize, Buffer, PathSize);
        if (NT_SUCCESS(Status))
        {
            /* Now check if the user wanted file part size as well */
            if ((PathSize) && (lpFilePart) && (LocalFilePart))
            {
                /* Yep, so in this case get the length of the file part too */
                Status = RtlUnicodeToMultiByteSize(&FilePartSize,
                                                   Buffer,
                                                   (ULONG)(LocalFilePart - Buffer) *
                                                   sizeof(WCHAR));
                if (!NT_SUCCESS(Status))
                {
                    /* We failed to do that, so fail the whole call */
                    BaseSetLastNTError(Status);
                    PathSize = 0;
                }
            }
        }
    }
    else
    {
        /* Reset the path size since the buffer is not large enough */
        PathSize = 0;
    }
 
    /* Either no path, or local buffer was too small, enter failure code */
    if (!PathSize) goto Quickie;
 
    /* If the *caller's* buffer was too small, fail, but add in space for NULL */
    if (PathSize >= nBufferLength)
    {
        PathSize++;
        goto Quickie;
    }
 
    /* So far so good, initialize a unicode string to convert back to ANSI/OEM */
    RtlInitUnicodeString(&UniString, Buffer);
    Status = BasepUnicodeStringTo8BitString(&AnsiString, &UniString, TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* Final conversion failed, fail the call */
        BaseSetLastNTError(Status);
        PathSize = 0;
    }
    else
    {
        /* Conversion worked, now copy the ANSI/OEM buffer into the buffer */
        RtlCopyMemory(lpBuffer, AnsiString.Buffer, PathSize + 1);
        RtlFreeAnsiString(&AnsiString);
 
        /* And finally, did the caller request file part information? */
        if (lpFilePart)
        {
            /* Use the size we computed earlier and add it to the buffer */
            *lpFilePart = LocalFilePart ? &lpBuffer[FilePartSize] : 0;
        }
    }
 
Quickie:
    /* Cleanup and return the path size */
    if (FileNameString.Buffer) RtlFreeUnicodeString(&FileNameString);
    if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    return PathSize;
}

Referenced by Dispatch_Invoke(), DosInt21h(), DosLoadExecutable(), main(), MMIO_Open(), OpenFile(), PathSearchAndQualifyA(), real_path(), set_outfile(), SetupIterateCabinetA(), START_TEST(), test_CommandLine(), test_drive_letter_case(), test_GetFullPathNameA(), test_PathNameA(), test_persiststreaminit(), test_top_level_action(), test_toplevel_stat(), test_ValidPathA(), test_xmldoc(), and test_xmlelem_collection().

GetFullPathNameW()

DWORD WINAPI GetFullPathNameW	(	IN LPCWSTR	lpFileName,
		IN DWORD	nBufferLength,
		OUT LPWSTR	lpBuffer,
		OUT LPWSTR *	lpFilePart
	)

Definition at line 1164 of file path.c.

{
    /* Call Rtl to do the work */
    return RtlGetFullPathName_U(lpFileName,
                                nBufferLength * sizeof(WCHAR),
                                lpBuffer,
                                lpFilePart) / sizeof(WCHAR);
}

Referenced by CFSDropTarget::_CopyItems(), _wfullpath(), _wgetdcwd(), AppendFullPathURL(), BasePushProcessParameters(), CDirectoryWatcher::CDirectoryWatcher(), create_file(), create_folder(), create_manifest_file(), create_process_params(), CreateDirectoryExW(), CreateDirectoryW(), CreateInternetShortcut(), CreateProcessInternalW(), CreateShortcut(), CreateSymbolicLinkW(), RecycleBin5::DeleteFile(), RecycleBinGeneric::DeleteFile(), CZipCreator::DoAddItem(), CACListISF::Expand(), FILEDLG95_InitControls(), FileLockBytesImpl_Construct(), FileMoniker_CreateFromDisplayName(), filesys_GetAbsolutePathName(), fw_app_put_ProcessImageFileName(), getIconLocationForDrive(), getIconLocationForFolder(), GetTempPathW(), GetVolumePathNameW(), Imm32IsRunningInMsoobe(), ImmInstallIMEW(), InstallScreenSaverW(), CZipCreatorImpl::JustDoIt(), load_mui_string(), MainWnd_OnInstall(), msi_set_original_database_property(), MSSTYLES_OpenThemeFile(), CAddressEditBox::ParseNow(), PathSearchAndQualifyW(), Preview_Delete(), Preview_pLoadImage(), PROFILE_Open(), resolve_filename(), CShellLink::Save(), SetFileInfo(), SetupCopyOEMInfW(), SetupDiBuildDriverInfoList(), SetupIterateCabinetW(), SetupOpenInfFileW(), SHAddToRecentDocs(), shellex_get_dataobj(), ShellExecCmdLine(), ShellLink_UpdatePath(), SHExplorerParseCmdLine(), SIC_GetIconIndex(), SIC_IconAppend(), StartDocDlgW(), test_createconfigstream(), test_GetAbsolutePathName(), test_GetFullPathNameW(), test_items(), test_namespace(), test_NetFwAuthorizedApplication(), Test_PathProcessCommand(), test_PathSearchAndQualify(), TestCommandLine(), WelcomeDlgProc(), WhereDoPattern(), wmain(), wWinMain(), XCOPY_ProcessDestParm(), and XCOPY_ProcessSourceParm().

GetLongPathNameA()

DWORD WINAPI GetLongPathNameA	(	IN LPCSTR	lpszShortPath,
		OUT LPSTR	lpszLongPath,
		IN DWORD	cchBuffer
	)

Definition at line 1770 of file path.c.

{
    ULONG Result, PathLength;
    PWCHAR LongPath;
    NTSTATUS Status;
    UNICODE_STRING LongPathUni, ShortPathUni;
    ANSI_STRING LongPathAnsi;
    WCHAR LongPathBuffer[MAX_PATH];
 
    LongPath = NULL;
    LongPathAnsi.Buffer = NULL;
    ShortPathUni.Buffer = NULL;
    Result = 0;
 
    if (!lpszShortPath)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    Status = Basep8BitStringToDynamicUnicodeString(&ShortPathUni, lpszShortPath);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    LongPath = LongPathBuffer;
 
    PathLength = GetLongPathNameW(ShortPathUni.Buffer, LongPathBuffer, MAX_PATH);
    if (PathLength >= MAX_PATH)
    {
        LongPath = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathLength * sizeof(WCHAR));
        if (!LongPath)
        {
            PathLength = 0;
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        }
        else
        {
            PathLength = GetLongPathNameW(ShortPathUni.Buffer, LongPath, PathLength);
        }
    }
 
    if (!PathLength) goto Quickie;
 
    ShortPathUni.MaximumLength = (USHORT)PathLength * sizeof(WCHAR) + sizeof(UNICODE_NULL);
    LongPathUni.Buffer = LongPath;
    LongPathUni.Length = (USHORT)PathLength * sizeof(WCHAR);
 
    Status = BasepUnicodeStringTo8BitString(&LongPathAnsi, &LongPathUni, TRUE);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        Result = 0;
    }
 
    Result = LongPathAnsi.Length;
    if ((lpszLongPath) && (cchBuffer > LongPathAnsi.Length))
    {
        RtlMoveMemory(lpszLongPath, LongPathAnsi.Buffer, LongPathAnsi.Length);
        lpszLongPath[Result] = ANSI_NULL;
    }
    else
    {
        Result = LongPathAnsi.Length + sizeof(ANSI_NULL);
    }
 
Quickie:
    if (ShortPathUni.Buffer) RtlFreeUnicodeString(&ShortPathUni);
    if (LongPathAnsi.Buffer) RtlFreeAnsiString(&LongPathAnsi);
    if ((LongPath) && (LongPath != LongPathBuffer))
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, LongPath);
    }
    return Result;
}

Referenced by DoTestEntry(), init_test(), okChildPath_(), test_drive_letter_case(), test_GetLongPathNameA(), test_PathNameA(), test_relative_path(), test_SdbGetPermLayerKeys(), test_SetPermLayer(), and test_ValidPathA().

GetLongPathNameW()

DWORD WINAPI GetLongPathNameW	(	IN LPCWSTR	lpszShortPath,
		OUT LPWSTR	lpszLongPath,
		IN DWORD	cchBuffer
	)

Definition at line 1555 of file path.c.

{
    PWCHAR Path, Original, First, Last, Buffer, Src, Dst;
    SIZE_T Length, ReturnLength;
    WCHAR LastChar;
    HANDLE FindHandle;
    ULONG ErrorMode;
    BOOLEAN Found = FALSE;
    WIN32_FIND_DATAW FindFileData;
 
    /* Initialize so Quickie knows there's nothing to do */
    Buffer = Original = NULL;
    ReturnLength = 0;
 
    /* First check if the input path was obviously NULL */
    if (!lpszShortPath)
    {
        /* Fail the request */
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    /* We will be touching removed, removable drives -- don't warn the user */
    ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
 
    /* Do a simple check to see if the path exists */
    if (GetFileAttributesW(lpszShortPath) == INVALID_FILE_ATTRIBUTES)
    {
        /* It doesn't, so fail */
        ReturnLength = 0;
        goto Quickie;
    }
 
    /* Now get a pointer to the actual path, skipping indicators */
    Path = SkipPathTypeIndicator_U((LPWSTR)lpszShortPath);
 
    /* Is there any path or filename in there? */
    if (!(Path) ||
        (*Path == UNICODE_NULL) ||
        !(FindLFNorSFN_U(Path, &First, &Last, FALSE)))
    {
        /* There isn't, so the long path is simply the short path */
        ReturnLength = wcslen(lpszShortPath);
 
        /* Is there space for it? */
        if ((cchBuffer > ReturnLength) && (lpszLongPath))
        {
            /* Make sure the pointers aren't already the same */
            if (lpszLongPath != lpszShortPath)
            {
                /* They're not -- copy the short path into the long path */
                RtlMoveMemory(lpszLongPath,
                              lpszShortPath,
                              ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
            }
        }
        else
        {
            /* Otherwise, let caller know we need a bigger buffer, include NULL */
            ReturnLength++;
        }
        goto Quickie;
    }
 
    /* We are still in the game -- compute the current size */
    Length = wcslen(lpszShortPath) + sizeof(ANSI_NULL);
    Original = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
    if (!Original) goto ErrorQuickie;
 
    /* Make a copy of it */
    RtlMoveMemory(Original, lpszShortPath, Length * sizeof(WCHAR));
 
    /* Compute the new first and last markers */
    First = &Original[First - lpszShortPath];
    Last = &Original[Last - lpszShortPath];
 
    /* Set the current destination pointer for a copy */
    Dst = lpszLongPath;
 
    /*
     * Windows allows the paths to overlap -- we have to be careful with this and
     * see if it's same to do so, and if not, allocate our own internal buffer
     * that we'll return at the end.
     *
     * This is also why we use RtlMoveMemory everywhere. Don't use RtlCopyMemory!
     */
    if ((cchBuffer) && (lpszLongPath) &&
        (((lpszLongPath >= lpszShortPath) && (lpszLongPath < &lpszShortPath[Length])) ||
         ((lpszLongPath < lpszShortPath) && (&lpszLongPath[cchBuffer] >= lpszShortPath))))
    {
        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchBuffer * sizeof(WCHAR));
        if (!Buffer) goto ErrorQuickie;
 
        /* New destination */
        Dst = Buffer;
    }
 
    /* Prepare for the loop */
    Src = Original;
    ReturnLength = 0;
    while (TRUE)
    {
        /* Current delta in the loop */
        Length = First - Src;
 
        /* Update the return length by it */
        ReturnLength += Length;
 
        /* Is there a delta? If so, is there space and buffer for it? */
        if ((Length) && (cchBuffer > ReturnLength) && (lpszLongPath))
        {
            RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR));
            Dst += Length;
        }
 
        /* "Terminate" this portion of the path's substring so we can do a find */
        LastChar = *Last;
        *Last = UNICODE_NULL;
        FindHandle = FindFirstFileW(Original, &FindFileData);
        *Last = LastChar;
 
        /* This portion wasn't found, so fail */
        if (FindHandle == INVALID_HANDLE_VALUE)
        {
            ReturnLength = 0;
            break;
        }
 
        /* Close the find handle */
        FindClose(FindHandle);
 
        /* Now check the length of the long name */
        Length = wcslen(FindFileData.cFileName);
        if (Length)
        {
            /* This is our new first marker */
            First = FindFileData.cFileName;
        }
        else
        {
            /* Otherwise, the name is the delta between our current markers */
            Length = Last - First;
        }
 
        /* Update the return length with the short name length, if any */
        ReturnLength += Length;
 
        /* Once again check for appropriate space and buffer */
        if ((cchBuffer > ReturnLength) && (lpszLongPath))
        {
            /* And do the copy if there is */
            RtlMoveMemory(Dst, First, Length * sizeof(WCHAR));
            Dst += Length;
        }
 
        /* Now update the source pointer */
        Src = Last;
        if (*Src == UNICODE_NULL) break;
 
        /* Are there more names in there? */
        Found = FindLFNorSFN_U(Src, &First, &Last, FALSE);
        if (!Found) break;
    }
 
    /* The loop is done, is there anything left? */
    if (ReturnLength)
    {
        /* Get the length of the straggling path */
        Length = wcslen(Src);
        ReturnLength += Length;
 
        /* Once again check for appropriate space and buffer */
        if ((cchBuffer > ReturnLength) && (lpszLongPath))
        {
            /* And do the copy if there is -- accounting for NULL here */
            RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR) + sizeof(UNICODE_NULL));
 
            /* What about our buffer? */
            if (Buffer)
            {
                /* Copy it into the caller's long path */
                RtlMoveMemory(lpszLongPath,
                              Buffer,
                              ReturnLength * sizeof(WCHAR)  + sizeof(UNICODE_NULL));
            }
        }
        else
        {
            /* Buffer is too small, let the caller know, making space for NULL */
            ReturnLength++;
        }
    }
 
    /* We're all done */
    goto Quickie;
 
ErrorQuickie:
    /* This is the goto for memory failures */
    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 
Quickie:
    /* General function end: free memory, restore error mode, return length */
    if (Original) RtlFreeHeap(RtlGetProcessHeap(), 0, Original);
    if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    SetErrorMode(ErrorMode);
    return ReturnLength;
}

Referenced by ConvertPath(), create_process_params(), fw_app_put_ProcessImageFileName(), GetLongPathNameA(), PathIsTemporaryW(), CDirectoryWatcher::ProcessNotification(), SdbpGetLongPathName(), test_GetLongPathNameW(), test_items(), test_namespace(), test_NetFwAuthorizedApplication(), and test_ParseDisplayName().

GetShortPathNameW()

DWORD WINAPI GetShortPathNameW	(	IN LPCWSTR	lpszLongPath,
		OUT LPWSTR	lpszShortPath,
		IN DWORD	cchBuffer
	)

Definition at line 1851 of file path.c.

{
    PWCHAR Path, Original, First, Last, Buffer, Src, Dst;
    SIZE_T Length, ReturnLength;
    WCHAR LastChar;
    HANDLE FindHandle;
    ULONG ErrorMode;
    BOOLEAN Found = FALSE;
    WIN32_FIND_DATAW FindFileData;
 
    /* Initialize so Quickie knows there's nothing to do */
    Buffer = Original = NULL;
    ReturnLength = 0;
 
    /* First check if the input path was obviously NULL */
    if (!lpszLongPath)
    {
        /* Fail the request */
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    /* We will be touching removed, removable drives -- don't warn the user */
    ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
 
    /* Do a simple check to see if the path exists */
    if (GetFileAttributesW(lpszLongPath) == INVALID_FILE_ATTRIBUTES)
    {
        /* Windows checks for an application compatibility flag to allow this */
        if (!(NtCurrentPeb()) || !(NtCurrentPeb()->AppCompatFlags.LowPart & GetShortPathNameNT4))
        {
            /* It doesn't, so fail */
            ReturnLength = 0;
            goto Quickie;
        }
    }
 
    /* Now get a pointer to the actual path, skipping indicators */
    Path = SkipPathTypeIndicator_U((LPWSTR)lpszLongPath);
 
    /* Is there any path or filename in there? */
    if (!(Path) ||
        (*Path == UNICODE_NULL) ||
        !(FindLFNorSFN_U(Path, &First, &Last, TRUE)))
    {
        /* There isn't, so the long path is simply the short path */
        ReturnLength = wcslen(lpszLongPath);
 
        /* Is there space for it? */
        if ((cchBuffer > ReturnLength) && (lpszShortPath))
        {
            /* Make sure the pointers aren't already the same */
            if (lpszLongPath != lpszShortPath)
            {
                /* They're not -- copy the short path into the long path */
                RtlMoveMemory(lpszShortPath,
                              lpszLongPath,
                              ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
            }
        }
        else
        {
            /* Otherwise, let caller know we need a bigger buffer, include NULL */
            ReturnLength++;
        }
        goto Quickie;
    }
 
    /* We are still in the game -- compute the current size */
    Length = wcslen(lpszLongPath) + sizeof(ANSI_NULL);
    Original = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
    if (!Original) goto ErrorQuickie;
 
    /* Make a copy of it */
    wcsncpy(Original, lpszLongPath, Length);
 
    /* Compute the new first and last markers */
    First = &Original[First - lpszLongPath];
    Last = &Original[Last - lpszLongPath];
 
    /* Set the current destination pointer for a copy */
    Dst = lpszShortPath;
 
    /*
     * Windows allows the paths to overlap -- we have to be careful with this and
     * see if it's same to do so, and if not, allocate our own internal buffer
     * that we'll return at the end.
     *
     * This is also why we use RtlMoveMemory everywhere. Don't use RtlCopyMemory!
     */
    if ((cchBuffer) && (lpszShortPath) &&
        (((lpszShortPath >= lpszLongPath) && (lpszShortPath < &lpszLongPath[Length])) ||
         ((lpszShortPath < lpszLongPath) && (&lpszShortPath[cchBuffer] >= lpszLongPath))))
    {
        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchBuffer * sizeof(WCHAR));
        if (!Buffer) goto ErrorQuickie;
 
        /* New destination */
        Dst = Buffer;
    }
 
    /* Prepare for the loop */
    Src = Original;
    ReturnLength = 0;
    while (TRUE)
    {
        /* Current delta in the loop */
        Length = First - Src;
 
        /* Update the return length by it */
        ReturnLength += Length;
 
        /* Is there a delta? If so, is there space and buffer for it? */
        if ((Length) && (cchBuffer > ReturnLength) && (lpszShortPath))
        {
            RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR));
            Dst += Length;
        }
 
        /* "Terminate" this portion of the path's substring so we can do a find */
        LastChar = *Last;
        *Last = UNICODE_NULL;
        FindHandle = FindFirstFileW(Original, &FindFileData);
        *Last = LastChar;
 
        /* This portion wasn't found, so fail */
        if (FindHandle == INVALID_HANDLE_VALUE)
        {
            ReturnLength = 0;
            break;
        }
 
        /* Close the find handle */
        FindClose(FindHandle);
 
        /* Now check the length of the short name */
        Length = wcslen(FindFileData.cAlternateFileName);
        if (Length)
        {
            /* This is our new first marker */
            First = FindFileData.cAlternateFileName;
        }
        else
        {
            /* Otherwise, the name is the delta between our current markers */
            Length = Last - First;
        }
 
        /* Update the return length with the short name length, if any */
        ReturnLength += Length;
 
        /* Once again check for appropriate space and buffer */
        if ((cchBuffer > ReturnLength) && (lpszShortPath))
        {
            /* And do the copy if there is */
            RtlMoveMemory(Dst, First, Length * sizeof(WCHAR));
            Dst += Length;
        }
 
        /* Now update the source pointer */
        Src = Last;
        if (*Src == UNICODE_NULL) break;
 
        /* Are there more names in there? */
        Found = FindLFNorSFN_U(Src, &First, &Last, TRUE);
        if (!Found) break;
    }
 
    /* The loop is done, is there anything left? */
    if (ReturnLength)
    {
        /* Get the length of the straggling path */
        Length = wcslen(Src);
        ReturnLength += Length;
 
        /* Once again check for appropriate space and buffer */
        if ((cchBuffer > ReturnLength) && (lpszShortPath))
        {
            /* And do the copy if there is -- accounting for NULL here */
            RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR) + sizeof(UNICODE_NULL));
 
            /* What about our buffer? */
            if (Buffer)
            {
                /* Copy it into the caller's long path */
                RtlMoveMemory(lpszShortPath,
                              Buffer,
                              ReturnLength * sizeof(WCHAR)  + sizeof(UNICODE_NULL));
            }
        }
        else
        {
            /* Buffer is too small, let the caller know, making space for NULL */
            ReturnLength++;
        }
    }
 
    /* We're all done */
    goto Quickie;
 
ErrorQuickie:
    /* This is the goto for memory failures */
    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 
Quickie:
    /* General function end: free memory, restore error mode, return length */
    if (Original) RtlFreeHeap(RtlGetProcessHeap(), 0, Original);
    if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    SetErrorMode(ErrorMode);
    return ReturnLength;
}

Referenced by BaseCheckVDM(), BaseCreateVDMEnvironment(), cache_containers_init(), deformat_file(), FindExecutableW(), CShellLink::GetPath(), GetShortPathNameA(), PathGetShortPathW(), readdir_copy_shortname(), SetUserEnvironmentVariable(), SHSetLocalizedName(), test_GetShortPathNameW(), Test_PathProcessCommand(), and TestNameSpaceFolder().

GetSystemDirectoryA()

UINT WINAPI GetSystemDirectoryA	(	OUT LPSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2301 of file path.c.

{
    ANSI_STRING AnsiString;
    NTSTATUS Status;
    ULONG AnsiLength;
 
    /* Get the correct size of the Unicode Base directory */
    Status = RtlUnicodeToMultiByteSize(&AnsiLength,
                                       BaseWindowsSystemDirectory.Buffer,
                                       BaseWindowsSystemDirectory.MaximumLength);
    if (!NT_SUCCESS(Status)) return 0;
 
    if (uSize < AnsiLength) return AnsiLength;
 
    RtlInitEmptyAnsiString(&AnsiString, lpBuffer, uSize);
 
    Status = BasepUnicodeStringTo8BitString(&AnsiString,
                                            &BaseWindowsSystemDirectory,
                                            FALSE);
    if (!NT_SUCCESS(Status)) return 0;
 
    return AnsiString.Length;
}

Referenced by check_for_files(), config_init(), copy_dll_file(), create_file_with_version(), DllMain(), get_dll_path_for_run(), InitSystemDir(), LoadCodePageData(), RunShell(), START_TEST(), test_autocreation(), test_BindToObject(), test_CreateDirectoryA(), test_CreateFileMapping(), test_data_cache(), test_dirid(), test_drive_letter_case(), test_find_executable(), test_find_file(), test_GetDiskInfoA(), test_getfolderpath(), test_GetSystemDirectory(), test_GetSystemDirectoryA(), test_info_size(), test_installprops(), test_mappings(), test_MkParseDisplayName(), test_MsiGetFileVersion(), test_NtAreMappedFilesTheSame(), Test_PathIsSlowA(), test_PathUnExpandEnvStrings(), test_RegLoadMUIString(), test_RunSetupCommand(), test_SetSearchPathMode(), test_SetupGetTargetPath(), test_SetupPromptForDiskA(), test_SQLInstallDriverEx(), test_SQLInstallTranslatorEx(), testLoadLibraryEx(), testSystemDir(), VerFindFileA(), and WspiapiLoad().

GetSystemDirectoryW()

UINT WINAPI GetSystemDirectoryW	(	OUT LPWSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2331 of file path.c.

{
    ULONG ReturnLength;
 
    ReturnLength = BaseWindowsSystemDirectory.MaximumLength;
    if ((uSize * sizeof(WCHAR)) >= ReturnLength)
    {
        RtlCopyMemory(lpBuffer,
                      BaseWindowsSystemDirectory.Buffer,
                      BaseWindowsSystemDirectory.Length);
        lpBuffer[BaseWindowsSystemDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
        ReturnLength = BaseWindowsSystemDirectory.Length;
    }
 
    return ReturnLength / sizeof(WCHAR);
}

Referenced by _InitializeLocalSpooler(), _SHExpandEnvironmentStrings(), ACTION_ForceReboot(), AllSysInfo(), BaseGetVdmConfigInfo(), BasepIsProcessAllowed(), build_directxfiles_tree(), build_search_path(), CRecentFileEntry::BuildDisplayName(), BuildSystemPaths(), Control_DoWindow(), CookupNodeId(), create_surrogate_server(), create_system_dirid(), CControlPanelEnum::CreateCPanelEnumList(), CryptCATAdminAcquireContext2(), custom_start_server(), doChild(), DoEntry(), DoHtmlHelpW(), DoRegServer(), filesys_GetSpecialFolder(), get_systemdirectory(), get_unknown_dirid(), GetColorDirectoryW(), GetConsoleIMECommandLine(), GetMonitorUIFullName(), GetOwnerModuleFromTagEntry(), GetProcessExecutablePathById(), GetSetupInfPath(), GetSystemLibraryPath(), Imm32GetSystemLibraryPath(), InitializePrinterDrivers(), install_wine_gecko(), IntGetCodePageEntry(), invoke_appwiz(), IsVolumeBoot(), LayoutList_Create(), load_fusion_dlls(), LoadIMEIcon(), LocalGetPrinterDriverDirectory(), MMSYS_InstallDevice(), nsDirectoryServiceProvider2_GetFiles(), COpenControlPanel::Open(), OpenHostsFile(), OpenUserAccounts(), PathMakeSystemFolderW(), PropDialogHandler(), RetrieveQuote(), run_winemenubuilder(), set_firewall(), set_installer_properties(), SetupGetTargetPathW(), SHGetFolderPathAndSubDirW(), SHLWAPI_PathFindInOtherDirs(), SQLInstallDriverManagerW(), START_TEST(), StartShell(), TEST_ByExeName(), test_CreateDirectoryW(), TEST_DirectoryPath(), test_EnumDynamicTimeZoneInformation(), test_GetFileVersion(), test_GetSpecialFolder(), test_GetSystemDirectoryW(), test_interfaces(), Test_InvokeIdList(), test_LdrGetDllFullName(), test_LdrGetDllPath(), TEST_notepad(), Test_PathIsSlowW(), Test_PathProcessCommand(), test_PathUnExpandEnvStrings(), test_RegLoadMUIString(), test_SearchPathW(), test_sei_lpIDList(), test_SetupPromptForDiskW(), test_SHParseDisplayName(), TEST_Start(), test_wshshell(), testKeyboardLayouts(), TestRedirection(), TLB_ReadTypeLib(), User32GetSystemFilePath(), VerFindFileW(), wmain(), write_registry_values(), and wWinMain().

GetSystemWindowsDirectoryA()

UINT WINAPI GetSystemWindowsDirectoryA	(	OUT LPSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2385 of file path.c.

{
    ANSI_STRING AnsiString;
    NTSTATUS Status;
    ULONG AnsiLength;
 
    /* Get the correct size of the Unicode Base directory */
    Status = RtlUnicodeToMultiByteSize(&AnsiLength,
                                       BaseWindowsDirectory.Buffer,
                                       BaseWindowsDirectory.MaximumLength);
    if (!NT_SUCCESS(Status)) return 0;
 
    if (uSize < AnsiLength) return AnsiLength;
 
    RtlInitEmptyAnsiString(&AnsiString, lpBuffer, uSize);
 
    Status = BasepUnicodeStringTo8BitString(&AnsiString,
                                            &BaseWindowsDirectory,
                                            FALSE);
    if (!NT_SUCCESS(Status)) return 0;
 
    return AnsiString.Length;
}

Referenced by GetWindowsDirectoryA(), test_DefineDosDeviceA(), and test_QueryDosDeviceA().

GetSystemWindowsDirectoryW()

UINT WINAPI GetSystemWindowsDirectoryW	(	OUT LPWSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2415 of file path.c.

{
    ULONG ReturnLength;
 
    ReturnLength = BaseWindowsDirectory.MaximumLength;
    if ((uSize * sizeof(WCHAR)) >= ReturnLength)
    {
        RtlCopyMemory(lpBuffer,
                      BaseWindowsDirectory.Buffer,
                      BaseWindowsDirectory.Length);
        lpBuffer[BaseWindowsDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
        ReturnLength = BaseWindowsDirectory.Length;
    }
 
    return ReturnLength / sizeof(WCHAR);
}

Referenced by ExpandInstallerPath(), GetWindowsDirectoryW(), InfIsFromOEMLocation(), InstallEventSource(), LoadShimDLL(), SdbGetAppPatchDir(), SdbPackAppCompatData(), SetupCopyOEMInfW(), SetupDiBuildDriverInfoList(), SetupGetInfFileListW(), SetupInitializeFileLogW(), SHGetWebFolderFilePathW(), StartShell(), test_ACListISF_CURRENTDIR(), test_ACListISF_FILESYSDIRS(), test_ACListISF_FILESYSONLY(), test_ACListISF_MYCOMPUTER(), test_ACListISF_NONE(), TranslateConsoleName(), and wmain().

GetSystemWow64DirectoryA()

UINT WINAPI GetSystemWow64DirectoryA	(	OUT LPSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2456 of file path.c.

{
#ifdef _WIN64
    UNIMPLEMENTED;
    return 0;
#else
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
#endif
}

Referenced by START_TEST(), and test_installprops().

GetSystemWow64DirectoryW()

UINT WINAPI GetSystemWow64DirectoryW	(	OUT LPWSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2439 of file path.c.

{
#ifdef _WIN64
    UNIMPLEMENTED;
    return 0;
#else
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
#endif
}

Referenced by create_surrogate_server(), custom_start_server(), doChild(), set_installer_properties(), SHGetFolderPathAndSubDirW(), test_debug_loop(), test_debug_loop_wow64(), and test_SHParseDisplayName().

GetTempPathA()

DWORD WINAPI GetTempPathA	(	IN DWORD	nBufferLength,
		OUT LPSTR	lpBuffer
	)

Definition at line 2072 of file path.c.

{
   WCHAR BufferW[MAX_PATH];
   DWORD ret;
 
   ret = GetTempPathW(MAX_PATH, BufferW);
 
   if (!ret) return 0;
 
   if (ret > MAX_PATH)
   {
      SetLastError(ERROR_FILENAME_EXCED_RANGE);
      return 0;
   }
 
   return FilenameW2A_FitOrFail(lpBuffer, nBufferLength, BufferW, ret+1);
}

Referenced by compile_cs_to_dll(), copy_dll_file(), create_avi_file(), create_bitmap(), create_file(), create_temp_file(), create_test_dll(), create_test_dll_sections(), create_test_file(), delete_manifest_file(), fill_sxs_info(), find_tempfile(), gen_forward_chain_testdll(), get_dll_path_for_run(), get_file_name(), get_test_dll_path(), get_thread_dll_path(), init_test(), load_resource(), prepare_and_run_test(), print_something(), START_TEST(), subtest_manifest_res_(), test___getmainargs(), test___getmainargs_parent(), test__stat32(), test_actctx_classes(), test_amh_corruption(), test_ash1_corruption(), test_ash1_corruption2(), test_builtin_sxs(), test_comctl32_class(), test_CopyMetaFile(), test_CreateActCtx(), test_CreateDirectoryA(), test_CreateFileMapping(), test_CreateFileMapping_protection(), test_CreateProcessCUI(), test_CreateScalableFontResource(), test_CtrlHandlerSubsystem(), test_default_data(), test_deferred_action(), test_domdoc(), test_drive_letter_case(), test_DuplicateHandle(), test_enhmetafile_file(), test_ExitProcess(), test_extension(), test_ExtractIcon(), test_ffcn_directory_overlap(), test_ffcnMultipleThreads(), test_file_security(), test_filemap_security(), test_FileSecurity(), test_find_file(), test_FindFirstChangeNotification(), test_fopen_exclusive(), test_fullpath(), test_get_inf_class(), test_GetLongPathNameA(), test_GetMappedFileName(), test_GetTempPathA(), test_GetVolumeNameForVolumeMountPointA(), test_group_as_file_owner(), test_import_resolution(), test_InitPathA(), test_invalid_callbackA(), test_invalid_parametersA(), test_iocp_callback(), test_listbox_LB_DIR(), test_load(), test_load_save(), test_load_with_site(), test_LoadImage_working_directory(), test_LoadLibraryEx_search_flags(), test_mappings(), test_metafile_file(), test_NtQueryDirectoryFile(), test_NtQueryDirectoryFile_case(), test_OleLoadPicturePath(), test_one_with_sxs_and_GetModuleHandleA(), Test_PathIsSlowA(), Test_PathIsTemporaryA(), test_PlaySound(), test_profile_directory_readonly(), test_publish(), test_publish_product(), test_query_object(), test_query_recyclebin(), test_reg_load_app_key(), test_reg_load_key(), test_register_product(), test_RegLoadMUIString(), test_relative_path(), test_RemoveDirectoryA(), test_ResolveDelayLoadedAPI(), test_SdbGetPermLayerKeys(), test_searchenv(), test_SearchPathA(), test_section_access(), test_SetPermLayer(), test_SetSearchPathMode(), test_SetupAddInstallSectionToDiskSpaceListA(), test_SetupAddSectionToDiskSpaceListA(), test_SetupDecompressOrCopyFile(), test_SetupDiGetActualModelsSectionA(), test_SetupDiGetActualModelsSectionW(), test_SetupGetFileCompressionInfo(), test_SetupGetFileCompressionInfoEx(), test_SHCreateStreamOnFileA(), test_SHCreateStreamOnFileEx(), test_SHCreateStreamOnFileW(), test_Sign_Media(), test_simple_enumerationA(), test_SIPRetrieveSubjectGUID(), test_StdHandleInheritance(), test_toplevel_stat(), test_TransformWithLoadingLocalFile(), test_write_watch(), test_WritePrivateProfileString(), tmpdir(), write_manifest(), and write_tmp_file().

GetTempPathW()

DWORD WINAPI GetTempPathW	(	IN DWORD	count,
		OUT LPWSTR	path
	)

Definition at line 2098 of file path.c.

{
    static const WCHAR tmp[]  = { 'T', 'M', 'P', 0 };
    static const WCHAR temp[] = { 'T', 'E', 'M', 'P', 0 };
    static const WCHAR userprofile[] = { 'U','S','E','R','P','R','O','F','I','L','E',0 };
    WCHAR tmp_path[MAX_PATH];
    WCHAR full_tmp_path[MAX_PATH];
    UINT ret;
 
    DPRINT("%u,%p\n", count, path);
 
    if (!(ret = GetEnvironmentVariableW( tmp, tmp_path, MAX_PATH )) &&
        !(ret = GetEnvironmentVariableW( temp, tmp_path, MAX_PATH )) &&
        !(ret = GetEnvironmentVariableW( userprofile, tmp_path, MAX_PATH )) &&
        !(ret = GetWindowsDirectoryW( tmp_path, MAX_PATH )))
    {
        return 0;
    }
 
    if (ret > MAX_PATH)
    {
        SetLastError(ERROR_FILENAME_EXCED_RANGE);
        return 0;
    }
 
    ret = GetFullPathNameW(tmp_path, MAX_PATH, full_tmp_path, NULL);
    if (!ret) return 0;
 
    if (ret > MAX_PATH - 2)
    {
        SetLastError(ERROR_FILENAME_EXCED_RANGE);
        return 0;
    }
 
    if (full_tmp_path[ret-1] != '\\')
    {
        full_tmp_path[ret++] = '\\';
        full_tmp_path[ret]   = '\0';
    }
 
    ret++; /* add space for terminating 0 */
 
    if (count >= ret)
    {
        lstrcpynW(path, full_tmp_path, count);
        /* the remaining buffer must be zeroed up to 32766 bytes in XP or 32767
         * bytes after it, we will assume the > XP behavior for now */
        memset(path + ret, 0, (min(count, 32767) - ret) * sizeof(WCHAR));
        ret--; /* return length without 0 */
    }
    else if (count)
    {
        /* the buffer must be cleared if contents will not fit */
        memset(path, 0, count * sizeof(WCHAR));
    }
 
    DPRINT("GetTempPathW returning %u, %S\n", ret, path);
    return ret;
}

Referenced by __acrt_GetTempPath2W(), ACTION_InstallAdminPackage(), create_file(), create_manifest_file(), create_new_dir(), create_storagefile(), create_temp_dir(), create_temp_file(), create_temp_manifest_file(), create_testfontfile(), create_tmp_file(), CRYPT_QueryEmbeddedMessageObject(), CZipFolder::DeleteItems(), do_file_copyW(), DoEntry(), download_proc(), extract_resource(), ExtractArchiveForExecution(), ExtractTTFFile(), filesys_GetSpecialFolder(), get_temp_filepath(), get_temp_ini_path(), get_temp_path(), GetTempPathA(), init_load_path(), init_paths(), install_cab_file(), load_resource(), makestringfile(), msi_create_temp_file(), OLECONVERT_GetOLE20FromOLE10(), OLECONVERT_WriteOLE20ToBuffer(), OpenMailer(), PathIsTemporaryW(), save_profile(), set_installer_properties(), START_TEST(), test_AddDllDirectory(), test_async_reader(), test_AtlAxCreateControl(), test_ax_win(), test_create(), test_CreateActCtx(), test_CreateDirectoryW(), test_CryptCATOpen(), test_Data(), test_DeleteFuncDesc(), Test_EmptyFile(), test_ExtractIcon(), test_ffcn(), test_file_monikers(), test_file_source_filter(), test_GetFolder(), test_GetLongPathNameW(), test_GetShortPathNameW(), test_GetSpecialFolder(), test_GetTempPathW(), test_int_widths(), test_invalid_callbackW(), test_invalid_parametersW(), test_items(), test_knownFolders(), test_large_file(), test_LoadIconWithScaleDown(), test_MatchApplications(), test_MatchApplicationsEx(), test_MultipleFiles(), test_namespace(), test_ntncdf(), test_ntncdf_async(), test_NtRegLoadKeyEx(), test_ParseDisplayName(), test_ParseName(), Test_PathIsSlowW(), Test_PathIsTemporaryW(), test_PathYetAnotherMakeUniqueName(), Test_RawSize(), test_readdirectorychanges(), test_readdirectorychanges_cr(), test_readdirectorychanges_filedir(), test_readdirectorychanges_null(), test_RemoveDirectoryW(), test_SearchPathW(), Test_SectionContents(), test_SHCreateStreamOnFileEx_CopyTo(), test_ShellFolderViewDual(), test_SHGetSetFolderCustomSettings(), test_simple_enumerationW(), test_TagRef(), Test_Truncate(), test_unknownfontdecode(), test_Verbs(), test_wshshell(), unpack_avi_file(), wmain(), and write_raw_resources().

GetWindowsDirectoryA()

UINT WINAPI GetWindowsDirectoryA	(	OUT LPSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2355 of file path.c.

{
    /* Is this a TS installation? */
    if (gpTermsrvGetWindowsDirectoryA) UNIMPLEMENTED;
 
    /* Otherwise, call the System API */
    return GetSystemWindowsDirectoryA(lpBuffer, uSize);
}

Referenced by check_format(), delete_win_ini(), get_directories(), get_system_dirs(), getNotepadPath(), init(), load_font(), LoadLibraryA(), START_TEST(), test_AddDelBackupEntry(), test_builtin_sxs(), test_CreateActCtx(), test_DialogCancel(), test_Directory(), test_directory_filename(), test_dirid(), test_dos_devices(), test_drive_letter_case(), test_driver_install(), test_enum_vols(), test_ExpandEnvironmentStringsA(), test_find_file(), test_get_set(), test_GetCachePath(), test_GetIconLocation(), test_GetNamedSecurityInfoA(), test_GetPrivateProfileString(), test_GetTempPath(), test_GetVolumeInformationA(), test_GetVolumeInformationByHandle(), test_GetVolumePathNameA(), test_GetWindowsDirectory(), test_GetWindowsDirectoryA(), test_InstallAssembly(), test_LoadLibraryEx_search_flags(), test_mounted_folder(), Test_PathIsSlowA(), Test_PathIsTemporaryA(), test_query_object(), test_QueryAssemblyInfo(), test_registry_mapping(), test_SearchPathA(), test_SetupQuerySpaceRequiredOnDriveA(), test_WritePrivateProfileString(), testNestedLoadLibraryA(), testWinDir(), and VerFindFileA().

GetWindowsDirectoryW()

UINT WINAPI GetWindowsDirectoryW	(	OUT LPWSTR	lpBuffer,
		IN UINT	uSize
	)

Definition at line 2370 of file path.c.

{
    /* Is this a TS installation? */
    if (gpTermsrvGetWindowsDirectoryW) UNIMPLEMENTED;
 
    /* Otherwise, call the System API */
    return GetSystemWindowsDirectoryW(lpBuffer, uSize);
}

Referenced by _SHRegisterFolders(), AddDelBackupEntryW(), AllSysInfo(), build_search_path(), build_sxs_path(), build_systeminfo_tree(), create_local_file_reference(), create_system_dirid(), create_system_path_list(), CWineTest::CWineTest(), doChild(), DoEntry(), EditTypeDlg_OnChangeIcon(), File_RetrieveEncodedObjectW(), filesys_GetSpecialFolder(), FixupServiceBinaryPath(), get_assembly_directory(), get_fusion_filename(), get_mono_path_local(), get_working_dir(), GetCachePath(), GetDefaultRecycleDriveNumber(), GetLocalizedSMFolderName(), GetSystemDrive(), GetSystemFontDirectory(), GetTempPathW(), GetVersionFromFileExW(), InitializeFreeLDRDialog(), InitializeSetupActionLog(), InitializeSystemDialog(), InstallInfSections(), InstallReactOS(), IntConvertFontPaths(), IsLFNDriveW(), LoadSoundFiles(), MAIN_LoadSettings(), MainWnd_OnInstall(), MMSYS_InstallDevice(), msi_create_empty_local_file(), MsiCreateAndVerifyInstallerDirectory(), MsiEnumComponentCostsW(), PathMakeSystemFolderW(), PathQualifyExW(), PreprocessUnattend(), ProcessStartupItems(), PROFILE_Open(), resolve_filename(), RouteTheCallW(), RunLiveCD(), ScanForInfFile(), search_for_inf(), SetUnrelatedDirectory(), SetupCopyOEMInfW(), SetupOpenInfFileW(), SetupOpenLog(), SetupOpenMasterInf(), SetupUninstallOEMInfW(), SHELL_execute(), SHExplorerParseCmdLine(), SHGetFolderPathAndSubDirW(), SHLWAPI_PathFindInOtherDirs(), START_TEST(), test_AddDllDirectory(), test_directory_filename(), test_GetFolder(), test_GetSpecialFolder(), test_GetWindowsDirectoryW(), test_knownFolders(), test_LdrGetDllPath(), Test_NtGdiAddFontResourceW(), Test_PathIsSlowW(), Test_PathIsTemporaryW(), test_RtlGetExePath(), test_RtlGetSearchPath(), test_SearchPathW(), test_SHParseDisplayName(), TEST_Start(), VerFindFileW(), WlxStartApplication(), and wmain().

IsLongName_U()

BOOL WINAPI IsLongName_U	(	IN PWCHAR	FileName,
		IN ULONG	Length
	)

Definition at line 706 of file path.c.

{
    BOOLEAN HasExtension;
    ULONG i, Dots;
 
    /* More than 8.3, any combination of dots, and NULL names are all long */
    if (!(Length) || (Length > 12) || (*FileName == L'.')) return TRUE;
 
    /* Otherwise, initialize our scanning loop */
    HasExtension = FALSE;
    for (i = 0, Dots = Length - 1; i < Length; i++, Dots--)
    {
        /* Check if this could be an extension */
        if (FileName[i] == L'.')
        {
            /* Unlike the short case, we WANT more than one extension, or a long one */
            if ((HasExtension) || (Dots > 3))
            {
                return TRUE;
            }
            HasExtension = TRUE;
        }
 
        /* Check if this would violate the "8" in 8.3, ie. 9.2 */
        if ((i >= 8) && (!HasExtension)) return TRUE;
    }
 
    /* The name *seems* to conform to 8.3 */
    return FALSE;
}

Referenced by FindLFNorSFN_U().

IsShortName_U()

BOOL WINAPI IsShortName_U	(	IN PWCHAR	Name,
		IN ULONG	Length
	)

Definition at line 619 of file path.c.

{
    BOOLEAN HasExtension;
    UCHAR c;
    NTSTATUS Status;
    UNICODE_STRING UnicodeName;
    ANSI_STRING AnsiName;
    ULONG i, Dots;
    CHAR AnsiBuffer[MAX_PATH];
    ASSERT(Name);
 
    /* What do you think 8.3 means? */
    if (Length > 12) return FALSE;
 
    /* Sure, any empty name is a short name */
    if (!Length) return TRUE;
 
    /* This could be . or .. or something else */
    if (*Name == L'.')
    {
        /* Which one is it */
        if ((Length == 1) || ((Length == 2) && *(Name + 1) == L'.'))
        {
            /* . or .., this is good */
            return TRUE;
        }
 
        /* Some other bizare dot-based name, not good */
        return FALSE;
    }
 
    /* Initialize our two strings */
    RtlInitEmptyAnsiString(&AnsiName, AnsiBuffer, MAX_PATH);
    RtlInitEmptyUnicodeString(&UnicodeName, Name, (USHORT)Length * sizeof(WCHAR));
    UnicodeName.Length = UnicodeName.MaximumLength;
 
    /* Now do the conversion */
    Status = BasepUnicodeStringTo8BitString(&AnsiName, &UnicodeName, FALSE);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Now we loop the name */
    HasExtension = FALSE;
    for (i = 0, Dots = Length - 1; i < AnsiName.Length; i++, Dots--)
    {
        /* Read the current byte */
        c = AnsiName.Buffer[i];
 
        /* Is it DBCS? */
        if (IsDBCSLeadByte(c))
        {
            /* If we're near the end of the string, we can't allow a DBCS */
            if ((!(HasExtension) && (i >= 7)) || (i == AnsiName.Length - 1))
            {
                return FALSE;
            }
 
            /* Otherwise we skip over it */
            continue;
        }
 
        /* Check for illegal characters */
        if ((c > 0x7F) || (IllegalMask[c / 32] & (1 << (c % 32))))
        {
            return FALSE;
        }
 
        /* Check if this is perhaps an extension? */
        if (c == '.')
        {
            /* Unless the extension is too large or there's more than one */
            if ((HasExtension) || (Dots > 3)) return FALSE;
 
            /* This looks like an extension */
            HasExtension = TRUE;
        }
 
        /* 8.3 length was validated, but now we must guard against 9.2 or similar */
        if ((i >= 8) && !(HasExtension)) return FALSE;
    }
 
    /* You survived the loop, this is a good short name */
    return TRUE;
}

Referenced by FindLFNorSFN_U().

NeedCurrentDirectoryForExePathA()

BOOL WINAPI NeedCurrentDirectoryForExePathA

(

IN LPCSTR

ExeName

)

Definition at line 1027 of file path.c.

{
    if (strchr(ExeName, '\\')) return TRUE;
 
    return BasepIsCurDirAllowedForPlainExeNames();
}

Referenced by init_pointers().

NeedCurrentDirectoryForExePathW()

BOOL WINAPI NeedCurrentDirectoryForExePathW

(

IN LPCWSTR

ExeName

)

Definition at line 1015 of file path.c.

{
    if (wcschr(ExeName, L'\\')) return TRUE;
 
    return BasepIsCurDirAllowedForPlainExeNames();
}

Referenced by BaseComputeProcessExePath(), and init_pointers().

SearchPathA()

DWORD WINAPI SearchPathA	(	IN LPCSTR lpPath	OPTIONAL,
		IN LPCSTR	lpFileName,
		IN LPCSTR lpExtension	OPTIONAL,
		IN DWORD	nBufferLength,
		OUT LPSTR	lpBuffer,
		OUT LPSTR *lpFilePart	OPTIONAL
	)

Definition at line 1222 of file path.c.

{
    PUNICODE_STRING FileNameString;
    UNICODE_STRING PathString, ExtensionString;
    NTSTATUS Status;
    ULONG PathSize, FilePartSize, AnsiLength;
    PWCHAR LocalFilePart, Buffer;
    PWCHAR* FilePart;
 
    /* If the caller wants filepart, use a local wide buffer since this is A */
    FilePart = lpFilePart != NULL ? &LocalFilePart : NULL;
 
    /* Initialize stuff for Quickie */
    PathSize = 0;
    Buffer = NULL;
    ExtensionString.Buffer = PathString.Buffer = NULL;
 
    /* Get the UNICODE_STRING file name */
    FileNameString = Basep8BitStringToStaticUnicodeString(lpFileName);
    if (!FileNameString) return 0;
 
    /* Did the caller specify an extension */
    if (lpExtension)
    {
        /* Yup, convert it into UNICODE_STRING */
        Status = Basep8BitStringToDynamicUnicodeString(&ExtensionString,
                                                       lpExtension);
        if (!NT_SUCCESS(Status)) goto Quickie;
    }
 
    /* Did the caller specify a path */
    if (lpPath)
    {
        /* Yup, convert it into UNICODE_STRING */
        Status = Basep8BitStringToDynamicUnicodeString(&PathString, lpPath);
        if (!NT_SUCCESS(Status)) goto Quickie;
    }
 
    /* Allocate our output buffer */
    Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength * sizeof(WCHAR));
    if (!Buffer)
    {
        /* It failed, bail out */
        BaseSetLastNTError(STATUS_NO_MEMORY);
        goto Quickie;
    }
 
    /* Now run the Wide search with the input buffer lengths */
    PathSize = SearchPathW(PathString.Buffer,
                           FileNameString->Buffer,
                           ExtensionString.Buffer,
                           nBufferLength,
                           Buffer,
                           FilePart);
    if (PathSize <= nBufferLength)
    {
        /* It fits, but is it empty? If so, bail out */
        if (!PathSize) goto Quickie;
 
        /* The length above is inexact, we need it in ANSI */
        Status = RtlUnicodeToMultiByteSize(&AnsiLength, Buffer, PathSize * sizeof(WCHAR));
        if (!NT_SUCCESS(Status))
        {
            /* Conversion failed, fail the call */
            PathSize = 0;
            BaseSetLastNTError(Status);
            goto Quickie;
        }
 
        /* If the correct ANSI size is too big, return required length plus a NULL */
        if (AnsiLength >= nBufferLength)
        {
            PathSize = AnsiLength + 1;
            goto Quickie;
        }
 
        /* Now apply the final conversion to ANSI */
        Status = RtlUnicodeToMultiByteN(lpBuffer,
                                        nBufferLength - 1,
                                        &AnsiLength,
                                        Buffer,
                                        PathSize * sizeof(WCHAR));
        if (!NT_SUCCESS(Status))
        {
            /* Conversion failed, fail the whole call */
            PathSize = 0;
            BaseSetLastNTError(STATUS_NO_MEMORY);
            goto Quickie;
        }
 
        /* NULL-terminate and return the real ANSI length */
        lpBuffer[AnsiLength] = ANSI_NULL;
        PathSize = AnsiLength;
 
        /* Now check if the user wanted file part size as well */
        if (lpFilePart)
        {
            /* If we didn't get a file part, clear the caller's */
            if (!LocalFilePart)
            {
                *lpFilePart = NULL;
            }
            else
            {
                /* Yep, so in this case get the length of the file part too */
                Status = RtlUnicodeToMultiByteSize(&FilePartSize,
                                                   Buffer,
                                                   (ULONG)(LocalFilePart - Buffer) *
                                                   sizeof(WCHAR));
                if (!NT_SUCCESS(Status))
                {
                    /* We failed to do that, so fail the whole call */
                    BaseSetLastNTError(Status);
                    PathSize = 0;
                }
 
                /* Return the file part buffer */
                *lpFilePart = lpBuffer + FilePartSize;
            }
        }
    }
    else
    {
        /* Our initial buffer guess was too small, allocate a bigger one */
        RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathSize * sizeof(WCHAR));
        if (!Buffer)
        {
            /* Out of memory, fail everything */
            BaseSetLastNTError(STATUS_NO_MEMORY);
            goto Quickie;
        }
 
        /* Do the search again -- it will fail, we just want the path size */
        PathSize = SearchPathW(PathString.Buffer,
                               FileNameString->Buffer,
                               ExtensionString.Buffer,
                               PathSize,
                               Buffer,
                               FilePart);
        if (!PathSize) goto Quickie;
 
        /* Convert it to a correct size */
        Status = RtlUnicodeToMultiByteSize(&PathSize, Buffer, PathSize * sizeof(WCHAR));
        if (NT_SUCCESS(Status))
        {
            /* Make space for the NULL-char */
            PathSize++;
        }
        else
        {
            /* Conversion failed for some reason, fail the call */
            BaseSetLastNTError(Status);
            PathSize = 0;
        }
    }
 
Quickie:
    /* Cleanup/complete path */
    if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    if (ExtensionString.Buffer) RtlFreeUnicodeString(&ExtensionString);
    if (PathString.Buffer) RtlFreeUnicodeString(&PathString);
    return PathSize;
}

Referenced by bind_image_cb(), BindImageEx(), file_existsA(), FindDebugInfoFile(), FindExecutableImageEx(), LoadModule(), MapAndLoad(), PathSearchAndQualifyA(), test_get_file_info(), test_load_save(), test_SearchPathA(), test_SetSearchPathMode(), and WINHELP_LookupHelpFile().

SearchPathW()

DWORD WINAPI SearchPathW	(	IN LPCWSTR lpPath	OPTIONAL,
		IN LPCWSTR	lpFileName,
		IN LPCWSTR lpExtension	OPTIONAL,
		IN DWORD	nBufferLength,
		OUT LPWSTR	lpBuffer,
		OUT LPWSTR *lpFilePart	OPTIONAL
	)

Definition at line 1397 of file path.c.

{
    UNICODE_STRING FileNameString, ExtensionString, PathString, CallerBuffer;
    ULONG Flags;
    SIZE_T LengthNeeded, FilePartSize;
    NTSTATUS Status;
    DWORD Result = 0;
 
    /* Default flags for RtlDosSearchPath_Ustr */
    Flags = 6;
 
    /* Clear file part in case we fail */
    if (lpFilePart) *lpFilePart = NULL;
 
    /* Initialize path buffer for free later */
    PathString.Buffer = NULL;
 
    /* Convert filename to a unicode string and eliminate trailing spaces */
    RtlInitUnicodeString(&FileNameString, lpFileName);
    while ((FileNameString.Length >= sizeof(WCHAR)) &&
           (FileNameString.Buffer[(FileNameString.Length / sizeof(WCHAR)) - 1] == L' '))
    {
        FileNameString.Length -= sizeof(WCHAR);
    }
 
    /* Was it all just spaces? */
    if (!FileNameString.Length)
    {
        /* Fail out */
        BaseSetLastNTError(STATUS_INVALID_PARAMETER);
        goto Quickie;
    }
 
    /* Convert extension to a unicode string */
    RtlInitUnicodeString(&ExtensionString, lpExtension);
 
    /* Check if the user sent a path */
    if (lpPath)
    {
        /* Convert it to a unicode string too */
        Status = RtlInitUnicodeStringEx(&PathString, lpPath);
        if (NT_ERROR(Status))
        {
            /* Fail if it was too long */
            BaseSetLastNTError(Status);
            goto Quickie;
        }
    }
    else
    {
        /* A path wasn't sent, so compute it ourselves */
        PathString.Buffer = BaseComputeProcessSearchPath();
        if (!PathString.Buffer)
        {
            /* Fail if we couldn't compute it */
            BaseSetLastNTError(STATUS_NO_MEMORY);
            goto Quickie;
        }
 
        /* See how big the computed path is */
        LengthNeeded = lstrlenW(PathString.Buffer);
        if (LengthNeeded > UNICODE_STRING_MAX_CHARS)
        {
            /* Fail if it's too long */
            BaseSetLastNTError(STATUS_NAME_TOO_LONG);
            goto Quickie;
        }
 
        /* Set the path size now that we have it */
        PathString.MaximumLength = PathString.Length = (USHORT)LengthNeeded * sizeof(WCHAR);
 
        /* Request SxS isolation from RtlDosSearchPath_Ustr */
        Flags |= 1;
    }
 
    /* Create the string that describes the output buffer from the caller */
    CallerBuffer.Length = 0;
    CallerBuffer.Buffer = lpBuffer;
 
    /* How much space does the caller have? */
    if (nBufferLength <= UNICODE_STRING_MAX_CHARS)
    {
        /* Add it into the string */
        CallerBuffer.MaximumLength = (USHORT)nBufferLength * sizeof(WCHAR);
    }
    else
    {
        /* Caller wants too much, limit it to the maximum length of a string */
        CallerBuffer.MaximumLength = UNICODE_STRING_MAX_BYTES;
    }
 
    /* Call Rtl to do the work */
    Status = RtlDosSearchPath_Ustr(Flags,
                                   &PathString,
                                   &FileNameString,
                                   &ExtensionString,
                                   &CallerBuffer,
                                   NULL,
                                   NULL,
                                   &FilePartSize,
                                   &LengthNeeded);
    if (NT_ERROR(Status))
    {
        /* Check for unusual status codes */
        if ((Status != STATUS_NO_SUCH_FILE) && (Status != STATUS_BUFFER_TOO_SMALL))
        {
            /* Print them out since maybe an app needs fixing */
            DbgPrint("%s on file %wZ failed; NTSTATUS = %08lx\n",
                     __FUNCTION__,
                     &FileNameString,
                     Status);
            DbgPrint("    Path = %wZ\n", &PathString);
        }
 
        /* Check if the failure was due to a small buffer */
        if (Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* Check if the length was actually too big for Rtl to work with */
            Result = LengthNeeded / sizeof(WCHAR);
            if (Result > 0xFFFFFFFF) BaseSetLastNTError(STATUS_NAME_TOO_LONG);
        }
        else
        {
            /* Some other error, set the error code */
            BaseSetLastNTError(Status);
        }
    }
    else
    {
        /* It worked! Write the file part now */
        if (lpFilePart) *lpFilePart = &lpBuffer[FilePartSize];
 
        /* Convert the final result length */
        Result = CallerBuffer.Length / sizeof(WCHAR);
    }
 
Quickie:
    /* Check if there was a dynamic path string to free */
    if ((PathString.Buffer != lpPath) && (PathString.Buffer))
    {
        /* And free it */
        RtlFreeHeap(RtlGetProcessHeap(), 0, PathString.Buffer);
    }
 
    /* Return the final result length */
    return Result;
}

Referenced by _tWinMain(), BasepLoadLibraryAsDatafile(), CreateProcessInternalW(), dde_connect(), execute_command(), file_existsW(), find_exe_file(), FindExecutableImageExW(), get_mmioFromFile(), get_object_dll_path(), CQueryAssociations::GetExecutable(), COpenWithList::GetPathFromCmd(), ICO_ExtractIconExW(), IntConvertFontPaths(), load_library_as_datafile(), loader_LoadObjectFromFile(), MSTASK_ITask_SetApplicationName(), OpenFile(), path_resolve_name(), PathSearchAndQualifyW(), PerformRegAction(), query_typelib_path(), res_sec_url_cmp(), ResProtocolInfo_ParseUrl(), SearchPathA(), SHELL_execute(), ShellExecCmdLine(), START_TEST(), test_PathSearchAndQualify(), test_SearchPathW(), TLB_ReadTypeLib(), and wmain().

SetCurrentDirectoryA()

BOOL WINAPI SetCurrentDirectoryA

(

IN LPCSTR

lpPathName

)

Definition at line 2224 of file path.c.

{
    PUNICODE_STRING DirName;
    NTSTATUS Status;
 
    if (!lpPathName)
    {
        BaseSetLastNTError(STATUS_INVALID_PARAMETER);
        return FALSE;
    }
 
    DirName = Basep8BitStringToStaticUnicodeString(lpPathName);
    if (!DirName) return FALSE;
 
    if (CheckForSameCurdir(DirName)) return TRUE;
 
    Status = RtlSetCurrentDirectory_U(DirName);
    if (NT_SUCCESS(Status)) return TRUE;
 
    if ((*DirName->Buffer != L'"') || (DirName->Length <= 2))
    {
        BaseSetLastNTError(Status);
        return 0;
    }
 
    DirName = Basep8BitStringToStaticUnicodeString(lpPathName + 1);
    if (!DirName) return FALSE;
 
    Status = RtlSetCurrentDirectory_U(DirName);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DosChangeDirectory(), DosChangeDrive(), prepare_and_run_test(), SheChangeDirA(), SheGetDirA(), SheGetDirW(), START_TEST(), test_CleanupPathA(), test_CommandLine(), test_CreateActCtx(), test_CreateDirectory_root(), test_CreateDirectoryA(), test_CurrentDirectoryA(), test_currentworkingdir(), test_directory(), test_find_file(), Test_FindFirstFileA(), Test_FindFirstFileExA(), test_fullpath(), test_GetTempPath(), test_GetVolumeInformationA(), test_inffilelist(), test_inffilelistA(), test_listbox_LB_DIR(), test_LoadImage_working_directory(), test_LoadLibraryEx_search_flags(), test_ok(), test_RegLoadMUIString(), test_relative_path(), test_RemoveDirectoryA(), test_RtlDosPathNameToNtPathName_U(), test_RtlGetFullPathName_U(), test_SearchPathA(), test_SetCurrentDirectoryA(), test_setdir(), test_SetSearchPathMode(), test_toplevel_stat(), TestGetCurrentDirectoryA(), and TestSetCurrentDirectoryA().

SetCurrentDirectoryW()

BOOL WINAPI SetCurrentDirectoryW

(

IN LPCWSTR

lpPathName

)

Definition at line 2267 of file path.c.

{
    NTSTATUS Status;
    UNICODE_STRING UnicodeString;
 
    if (!lpPathName)
    {
        BaseSetLastNTError(STATUS_INVALID_PARAMETER);
        return FALSE;
    }
 
    Status = RtlInitUnicodeStringEx(&UnicodeString, lpPathName);
    if (NT_SUCCESS(Status))
    {
        if (!CheckForSameCurdir(&UnicodeString))
        {
            Status = RtlSetCurrentDirectory_U(&UnicodeString);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _chdrive(), _wchdir(), COMDLG32_UpdateCurrentDir(), DIALOG_DlgDirListW(), FD31_ScanDir(), FindExecutableW(), GetFileDialog95(), IsValidPathName(), ProcessStartupItems(), CWineTest::RunTest(), SetUnrelatedDirectory(), SheChangeDirW(), SheGetDirA(), SheGetDirW(), SHELL_ExecuteW(), ShellExecCmdLine(), START_TEST(), StartChild(), test_actctx(), test_CreateActCtx(), test_CreateDirectoryA(), test_CreateDirectoryW(), TEST_DoTestEntries(), Test_FindFirstFileExW(), Test_FindFirstFileW(), test_GetFolder(), test_GetTempPath(), test_include(), test_ITEMIDLIST_format(), test_items(), TEST_LocaleTests(), test_namespace(), test_ParseDisplayName(), test_RegLoadMUIString(), test_relative_path(), test_RemoveDirectoryW(), TestGetCurrentDirectoryW(), TestSetCurrentDirectoryW(), wmain(), WshShell3_put_CurrentDirectory(), and wWinMain().

SetDllDirectoryA()

BOOL WINAPI SetDllDirectoryA

(

IN LPCSTR

lpPathName

)

Definition at line 896 of file path.c.

{
    ANSI_STRING AnsiDllDirectory;
    UNICODE_STRING OldDirectory, DllDirectory;
    NTSTATUS Status;
 
    if (lpPathName)
    {
        if (strchr(lpPathName, ';'))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        Status = RtlInitAnsiStringEx(&AnsiDllDirectory, lpPathName);
        if (NT_SUCCESS(Status))
        {
            Status = Basep8BitStringToUnicodeString(&DllDirectory,
                                                    &AnsiDllDirectory,
                                                    TRUE);
        }
 
        if (!NT_SUCCESS(Status))
        {
            BaseSetLastNTError(Status);
            return FALSE;
        }
    }
    else
    {
        RtlInitUnicodeString(&DllDirectory, NULL);
    }
 
    RtlEnterCriticalSection(&BaseDllDirectoryLock);
 
    OldDirectory = BaseDllDirectory;
    BaseDllDirectory = DllDirectory;
 
    RtlLeaveCriticalSection(&BaseDllDirectoryLock);
 
    RtlFreeUnicodeString(&OldDirectory);
    return TRUE;
}

Referenced by init_pointers().

SetDllDirectoryW()

BOOL WINAPI SetDllDirectoryW

(

IN LPCWSTR

lpPathName

)

Definition at line 858 of file path.c.

{
    UNICODE_STRING OldDirectory, DllDirectory;
 
    if (lpPathName)
    {
        if (wcschr(lpPathName, L';'))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        if (!RtlCreateUnicodeString(&DllDirectory, lpPathName))
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }
    else
    {
        RtlInitUnicodeString(&DllDirectory, NULL);
    }
 
    RtlEnterCriticalSection(&BaseDllDirectoryLock);
 
    OldDirectory = BaseDllDirectory;
    BaseDllDirectory = DllDirectory;
 
    RtlLeaveCriticalSection(&BaseDllDirectoryLock);
 
    RtlFreeUnicodeString(&OldDirectory);
    return TRUE;
}

Referenced by init_pointers().

SetSearchPathMode()

BOOL WINAPI SetSearchPathMode

(

_In_ DWORD

dwFlags

)

Definition at line 1181 of file path.c.

{
    LONG OldFlags, CurrentFlags;
 
    switch (dwFlags)
    {
        /* There are only 3 valid parameters */
        case BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE:
        case BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE:
        case BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE | BASE_SEARCH_PATH_PERMANENT:
            CurrentFlags = InterlockedCompareExchange((PLONG)&BasepSearchPathModeFlags, 0, 0);
            do
            {
                if ((CurrentFlags & BASE_SEARCH_PATH_PERMANENT) &&
                    dwFlags != CurrentFlags)
                {
                    /* Return with ERROR_ACCESS_DENIED if permanent flag is set */
                    SetLastError(ERROR_ACCESS_DENIED);
                    return FALSE;
                }
 
                OldFlags = CurrentFlags;
                CurrentFlags = InterlockedCompareExchange((PLONG)&BasepSearchPathModeFlags,
                                                          (LONG)dwFlags,
                                                          OldFlags);
            } while (CurrentFlags != OldFlags);
 
            return TRUE;
 
        default:
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
    }
}

Referenced by init_pointers(), and START_TEST().

SkipPathTypeIndicator_U()

PWCHAR WINAPI SkipPathTypeIndicator_U

(

IN LPWSTR

Path

)

Definition at line 798 of file path.c.

{
    PWCHAR ReturnPath;
    ULONG i;
 
    /* Check what kind of path this is and how many slashes to skip */
    switch (RtlDetermineDosPathNameType_U(Path))
    {
        case RtlPathTypeUncAbsolute:
        case RtlPathTypeLocalDevice:
        {
            /* Keep going until we bypass the path indicators */
            for (ReturnPath = Path + 2, i = 2; (i > 0) && (*ReturnPath); ReturnPath++)
            {
                /* We look for 2 slashes, so keep at it until we find them */
                if ((*ReturnPath == L'\\') || (*ReturnPath == L'/')) i--;
            }
 
            return ReturnPath;
        }
 
        case RtlPathTypeDriveAbsolute:
            return Path + 3;
 
        case RtlPathTypeDriveRelative:
            return Path + 2;
 
        case RtlPathTypeRooted:
            return Path + 1;
 
        case RtlPathTypeRelative:
            return Path;
 
        case RtlPathTypeRootLocalDevice:
        default:
            return NULL;
    }
}

Referenced by GetLongPathNameW(), and GetShortPathNameW().

Variable Documentation

BaseDefaultPath

UNICODE_STRING BaseDefaultPath

Definition at line 21 of file path.c.

Referenced by BasepComputeProcessPath(), and DllMain().

BaseDefaultPathAppend

UNICODE_STRING BaseDefaultPathAppend

Definition at line 21 of file path.c.

Referenced by DllMain().

BaseDllDirectory

UNICODE_STRING BaseDllDirectory

Definition at line 21 of file path.c.

Referenced by BaseComputeProcessDllPath(), BasepComputeProcessPath(), GetDllDirectoryA(), GetDllDirectoryW(), SetDllDirectoryA(), and SetDllDirectoryW().

BaseDllOrderCurrent

BASE_SEARCH_PATH_TYPE BaseDllOrderCurrent[BaseCurrentDirPlacementMax][BaseSearchPathMax]

Initial value:

=
{
    {
        BaseSearchPathApp,
        BaseSearchPathCurrent,
        BaseSearchPathDefault,
        BaseSearchPathEnv,
        BaseSearchPathInvalid
    },
    {
        BaseSearchPathApp,
        BaseSearchPathDefault,
        BaseSearchPathCurrent,
        BaseSearchPathEnv,
        BaseSearchPathInvalid
    }
}

Definition at line 36 of file path.c.

Referenced by BaseComputeProcessDllPath(), and BaseComputeProcessSearchPath().

BaseDllOrderNoCurrent

BASE_SEARCH_PATH_TYPE BaseDllOrderNoCurrent[BaseSearchPathMax]

Initial value:

=
{
    BaseSearchPathApp,
    BaseSearchPathDll,
    BaseSearchPathDefault,
    BaseSearchPathEnv,
    BaseSearchPathInvalid
}

Definition at line 63 of file path.c.

Referenced by BaseComputeProcessDllPath().

BasePathVariableName

UNICODE_STRING BasePathVariableName

extern

Definition at line 22 of file proc.c.

Referenced by BasepComputeProcessPath().

BasepDllCurrentDirPlacement

BASE_CURRENT_DIR_PLACEMENT BasepDllCurrentDirPlacement = BaseCurrentDirPlacementInvalid

Definition at line 81 of file path.c.

Referenced by BaseComputeProcessDllPath().

BaseProcessOrder

BASE_SEARCH_PATH_TYPE BaseProcessOrder[BaseSearchPathMax]

Initial value:

=
{
    BaseSearchPathApp,
    BaseSearchPathCurrent,
    BaseSearchPathDefault,
    BaseSearchPathEnv,
    BaseSearchPathInvalid
}

Definition at line 72 of file path.c.

Referenced by BaseComputeProcessExePath().

BaseProcessOrderNoCurrent

BASE_SEARCH_PATH_TYPE BaseProcessOrderNoCurrent[BaseSearchPathMax]

Initial value:

=
{
    BaseSearchPathApp,
    BaseSearchPathDefault,
    BaseSearchPathEnv,
    BaseSearchPathInvalid,
    BaseSearchPathInvalid
}

Definition at line 54 of file path.c.

Referenced by BaseComputeProcessExePath().

BasepSearchPathModeFlags

DWORD BasepSearchPathModeFlags = BASE_SEARCH_PATH_INVALID_FLAGS

Definition at line 83 of file path.c.

Referenced by BaseComputeProcessSearchPath(), and SetSearchPathMode().

BaseWindowsDirectory

UNICODE_STRING BaseWindowsDirectory

Definition at line 20 of file path.c.

Referenced by BaseInitApphelp(), DllMain(), GetSystemWindowsDirectoryA(), and GetSystemWindowsDirectoryW().

BaseWindowsSystemDirectory

UNICODE_STRING BaseWindowsSystemDirectory

Definition at line 20 of file path.c.

Referenced by DllMain(), GetSystemDirectoryA(), and GetSystemDirectoryW().

gpTermsrvGetWindowsDirectoryA

PVOID gpTermsrvGetWindowsDirectoryA

Definition at line 23 of file path.c.

Referenced by GetWindowsDirectoryA().

gpTermsrvGetWindowsDirectoryW

PVOID gpTermsrvGetWindowsDirectoryW

Definition at line 24 of file path.c.

Referenced by GetWindowsDirectoryW().

IllegalMask

DWORD IllegalMask[4]

Initial value:

=
{
    0xFFFFFFFF, 
    0xFC009C05, 
    0x38000000, 
    0x10000000  
}

Definition at line 28 of file path.c.

Referenced by IsShortName_U().

NoDefaultCurrentDirectoryInExePath

UNICODE_STRING NoDefaultCurrentDirectoryInExePath = RTL_CONSTANT_STRING(L"NoDefaultCurrentDirectoryInExePath")

Definition at line 18 of file path.c.

Referenced by BasepIsCurDirAllowedForPlainExeNames().