vdm.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BOOL NTAPI	BaseCreateVDMEnvironment (IN PWCHAR lpEnvironment, OUT PANSI_STRING AnsiEnv, OUT PUNICODE_STRING UnicodeEnv)
BOOL NTAPI	BaseDestroyVDMEnvironment (IN PANSI_STRING AnsiEnv, IN PUNICODE_STRING UnicodeEnv)
BOOL WINAPI	BaseGetVdmConfigInfo (IN LPCWSTR CommandLineReserved, IN ULONG DosSeqId, IN ULONG BinaryType, IN PUNICODE_STRING CmdLineString, OUT PULONG VdmSize)
BOOL WINAPI	BaseUpdateVDMEntry (IN ULONG UpdateIndex, IN OUT PHANDLE WaitHandle, IN ULONG IndexInfo, IN ULONG BinaryType)
BOOL WINAPI	BaseCheckForVDM (IN HANDLE ProcessHandle, OUT LPDWORD ExitCode)
NTSTATUS WINAPI	BaseCheckVDM (IN ULONG BinaryType, IN PCWCH ApplicationName, IN PCWCH CommandLine, IN PCWCH CurrentDirectory, IN PANSI_STRING AnsiEnvironment, IN PBASE_API_MESSAGE ApiMessage, IN OUT PULONG iTask, IN DWORD CreationFlags, IN LPSTARTUPINFOW StartupInfo, IN HANDLE hUserToken OPTIONAL)

Function Documentation

BaseCheckForVDM()

BOOL WINAPI BaseCheckForVDM	(	IN HANDLE	ProcessHandle,
		OUT LPDWORD	ExitCode
	)

Definition at line 618 of file vdm.c.

{
    NTSTATUS Status;
    EVENT_BASIC_INFORMATION EventBasicInfo;
    BASE_API_MESSAGE ApiMessage;
    PBASE_GET_VDM_EXIT_CODE GetVdmExitCode = &ApiMessage.Data.GetVDMExitCodeRequest;
 
    /* It's VDM if the process is actually a wait handle (an event) */
    Status = NtQueryEvent(ProcessHandle,
                          EventBasicInformation,
                          &EventBasicInfo,
                          sizeof(EventBasicInfo),
                          NULL);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Setup the input parameters */
    GetVdmExitCode->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
    GetVdmExitCode->hParent = ProcessHandle;
 
    /* Call CSRSS */
    Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                                 NULL,
                                 CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepGetVDMExitCode),
                                 sizeof(*GetVdmExitCode));
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Get the exit code from the reply */
    *ExitCode = GetVdmExitCode->ExitCode;
    return TRUE;
}

Referenced by GetExitCodeProcess().

BaseCheckVDM()

NTSTATUS WINAPI BaseCheckVDM	(	IN ULONG	BinaryType,
		IN PCWCH	ApplicationName,
		IN PCWCH	CommandLine,
		IN PCWCH	CurrentDirectory,
		IN PANSI_STRING	AnsiEnvironment,
		IN PBASE_API_MESSAGE	ApiMessage,
		IN OUT PULONG	iTask,
		IN DWORD	CreationFlags,
		IN LPSTARTUPINFOW	StartupInfo,
		IN HANDLE hUserToken	OPTIONAL
	)

Definition at line 91 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_CHECK_VDM CheckVdm = &ApiMessage->Data.CheckVDMRequest;
    PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
    PWCHAR CurrentDir = NULL;
    PWCHAR ShortAppName = NULL;
    PWCHAR ShortCurrentDir = NULL;
    SIZE_T Length;
    PCHAR AnsiCmdLine = NULL;
    PCHAR AnsiAppName = NULL;
    PCHAR AnsiCurDirectory = NULL;
    PCHAR AnsiDesktop = NULL;
    PCHAR AnsiTitle = NULL;
    PCHAR AnsiReserved = NULL;
    STARTUPINFOA AnsiStartupInfo;
    ULONG NumStrings = 5;
 
    /* Parameters validation */
    if (ApplicationName == NULL || CommandLine == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Trim leading whitespace from ApplicationName */
    while (*ApplicationName == L' ' || *ApplicationName == L'\t')
        ++ApplicationName;
 
    /* Calculate the size of the short application name */
    Length = GetShortPathNameW(ApplicationName, NULL, 0);
    if (Length == 0)
    {
        Status = STATUS_OBJECT_PATH_INVALID;
        goto Cleanup;
    }
 
    /* Allocate memory for the short application name */
    ShortAppName = (PWCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           Length * sizeof(WCHAR));
    if (!ShortAppName)
    {
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Get the short application name */
    if (GetShortPathNameW(ApplicationName, ShortAppName, Length) == 0)
    {
        /* Try to determine which error occurred */
        switch (GetLastError())
        {
            case ERROR_NOT_ENOUGH_MEMORY:
            {
                Status = STATUS_NO_MEMORY;
                break;
            }
 
            case ERROR_INVALID_PARAMETER:
            {
                Status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            default:
            {
                Status = STATUS_OBJECT_PATH_INVALID;
            }
        }
 
        goto Cleanup;
    }
 
    /* Trim leading whitespace from CommandLine */
    while (*CommandLine == L' ' || *CommandLine == L'\t')
        ++CommandLine;
 
    /*
     * CommandLine is usually formatted as: 'ApplicationName param0 ...'.
     * So we want to strip the first token (ApplicationName) from it.
     * Two cases are in fact possible:
     * - either the first token is indeed ApplicationName, so we just skip it;
     * - or the first token is not exactly ApplicationName, because it happened
     *   that somebody else already preprocessed CommandLine. Therefore we
     *   suppose that the first token corresponds to an application name and
     *   we skip it. Care should be taken when quotes are present in this token.
     */
     if (*CommandLine)
     {
        /* The first part of CommandLine should be the ApplicationName... */
        Length = wcslen(ApplicationName);
        if (Length <= wcslen(CommandLine) &&
            _wcsnicmp(ApplicationName, CommandLine, Length) == 0)
        {
            /* Skip it */
            CommandLine += Length;
        }
        /*
         * ... but it is not, however we still have a token. We suppose that
         * it corresponds to some sort of application name, so we skip it too.
         */
        else
        {
            /* Get rid of the first token. We stop when we see whitespace. */
            while (*CommandLine && !(*CommandLine == L' ' || *CommandLine == L'\t'))
            {
                if (*CommandLine == L'\"')
                {
                    /* We enter a quoted part, skip it */
                    ++CommandLine;
                    while (*CommandLine && *CommandLine++ != L'\"') ;
                }
                else
                {
                    /* Go to the next character */
                    ++CommandLine;
                }
            }
        }
    }
 
    /*
     * Trim remaining whitespace from CommandLine that may be
     * present between the application name and the parameters.
     */
    while (*CommandLine == L' ' || *CommandLine == L'\t')
        ++CommandLine;
 
    /* Get the current directory */
    if (CurrentDirectory == NULL)
    {
        /* Allocate memory for the current directory path */
        Length = GetCurrentDirectoryW(0, NULL);
        CurrentDir = (PWCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                             HEAP_ZERO_MEMORY,
                                             Length * sizeof(WCHAR));
        if (CurrentDir == NULL)
        {
            Status = STATUS_NO_MEMORY;
            goto Cleanup;
        }
 
        /* Get the current directory */
        GetCurrentDirectoryW(Length, CurrentDir);
        CurrentDirectory = CurrentDir;
    }
 
    /* Calculate the size of the short current directory path */
    Length = GetShortPathNameW(CurrentDirectory, NULL, 0);
 
    /* Allocate memory for the short current directory path */
    ShortCurrentDir = (PWCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                              HEAP_ZERO_MEMORY,
                                              Length * sizeof(WCHAR));
    if (!ShortCurrentDir)
    {
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Get the short current directory path */
    if (!GetShortPathNameW(CurrentDirectory, ShortCurrentDir, Length))
    {
        /* Try to determine which error occurred */
        switch (GetLastError())
        {
            case ERROR_NOT_ENOUGH_MEMORY:
            {
                Status = STATUS_NO_MEMORY;
                break;
            }
 
            case ERROR_INVALID_PARAMETER:
            {
                Status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            default:
            {
                Status = STATUS_OBJECT_PATH_INVALID;
            }
        }
        goto Cleanup;
    }
 
    /* Make sure that the command line isn't too long */
    Length = wcslen(CommandLine);
    if (Length > UNICODE_STRING_MAX_CHARS - 1)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    /* Setup the input parameters */
    CheckVdm->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
    CheckVdm->BinaryType = BinaryType;
    CheckVdm->CodePage = CP_ACP;
    CheckVdm->dwCreationFlags = CreationFlags;
    CheckVdm->CurDrive = CurrentDirectory[0] - L'A';
    CheckVdm->CmdLen = (USHORT)Length + 1;
    CheckVdm->AppLen = (USHORT)wcslen(ShortAppName) + 1;
    CheckVdm->PifLen = 0; // TODO: PIF file support!
    CheckVdm->CurDirectoryLen = (USHORT)wcslen(ShortCurrentDir) + 1;
    CheckVdm->EnvLen = AnsiEnvironment->Length;
    CheckVdm->DesktopLen = (StartupInfo->lpDesktop != NULL) ? (wcslen(StartupInfo->lpDesktop) + 1) : 0;
    CheckVdm->TitleLen = (StartupInfo->lpTitle != NULL) ? (wcslen(StartupInfo->lpTitle) + 1) : 0;
    CheckVdm->ReservedLen = (StartupInfo->lpReserved != NULL) ? (wcslen(StartupInfo->lpReserved) + 1) : 0;
 
    if (StartupInfo->dwFlags & STARTF_USESTDHANDLES)
    {
        /* Set the standard handles */
        CheckVdm->StdIn  = StartupInfo->hStdInput;
        CheckVdm->StdOut = StartupInfo->hStdOutput;
        CheckVdm->StdErr = StartupInfo->hStdError;
    }
 
    /* Allocate memory for the ANSI strings */
    // We need to add the newline characters '\r\n' to the command line
    AnsiCmdLine = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, CheckVdm->CmdLen + 2);
    AnsiAppName = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, CheckVdm->AppLen);
    AnsiCurDirectory = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, CheckVdm->CurDirectoryLen);
    if (StartupInfo->lpDesktop)
        AnsiDesktop = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                             HEAP_ZERO_MEMORY,
                                             CheckVdm->DesktopLen);
    if (StartupInfo->lpTitle)
        AnsiTitle = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           CheckVdm->TitleLen);
    if (StartupInfo->lpReserved)
        AnsiReserved = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
                                              HEAP_ZERO_MEMORY,
                                              CheckVdm->ReservedLen);
 
    if (!AnsiCmdLine
        || !AnsiAppName
        || !AnsiCurDirectory
        || (StartupInfo->lpDesktop && !AnsiDesktop)
        || (StartupInfo->lpTitle && !AnsiTitle)
        || (StartupInfo->lpReserved && !AnsiReserved))
    {
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Convert the command line into an ANSI string */
    WideCharToMultiByte(CP_ACP,
                        0,
                        CommandLine,
                        CheckVdm->CmdLen,
                        AnsiCmdLine,
                        CheckVdm->CmdLen,
                        NULL,
                        NULL);
    /* Add the needed newline and NULL-terminate */
    CheckVdm->CmdLen--; // Rewind back to the NULL character
    AnsiCmdLine[CheckVdm->CmdLen++] = '\r';
    AnsiCmdLine[CheckVdm->CmdLen++] = '\n';
    AnsiCmdLine[CheckVdm->CmdLen++] = 0;
 
    /* Convert the short application name into an ANSI string */
    WideCharToMultiByte(CP_ACP,
                        0,
                        ShortAppName,
                        CheckVdm->AppLen,
                        AnsiAppName,
                        CheckVdm->AppLen,
                        NULL,
                        NULL);
 
    /* Convert the short current directory path into an ANSI string */
    WideCharToMultiByte(CP_ACP,
                        0,
                        ShortCurrentDir,
                        CheckVdm->CurDirectoryLen,
                        AnsiCurDirectory,
                        CheckVdm->CurDirectoryLen,
                        NULL,
                        NULL);
 
    if (StartupInfo->lpDesktop)
    {
        /* Convert the desktop name into an ANSI string */
        WideCharToMultiByte(CP_ACP,
                            0,
                            StartupInfo->lpDesktop,
                            CheckVdm->DesktopLen,
                            AnsiDesktop,
                            CheckVdm->DesktopLen,
                            NULL,
                            NULL);
        NumStrings++;
    }
 
    if (StartupInfo->lpTitle)
    {
        /* Convert the title into an ANSI string */
        WideCharToMultiByte(CP_ACP,
                            0,
                            StartupInfo->lpTitle,
                            CheckVdm->TitleLen,
                            AnsiTitle,
                            CheckVdm->TitleLen,
                            NULL,
                            NULL);
        NumStrings++;
    }
 
    if (StartupInfo->lpReserved)
    {
        /* Convert the reserved value into an ANSI string */
        WideCharToMultiByte(CP_ACP,
                            0,
                            StartupInfo->lpReserved,
                            CheckVdm->ReservedLen,
                            AnsiReserved,
                            CheckVdm->ReservedLen,
                            NULL,
                            NULL);
        NumStrings++;
    }
 
    /* Fill the ANSI startup info structure */
    RtlCopyMemory(&AnsiStartupInfo, StartupInfo, sizeof(AnsiStartupInfo));
    AnsiStartupInfo.lpReserved = AnsiReserved;
    AnsiStartupInfo.lpDesktop = AnsiDesktop;
    AnsiStartupInfo.lpTitle = AnsiTitle;
 
    /* Allocate the capture buffer */
    CaptureBuffer = CsrAllocateCaptureBuffer(NumStrings,
                                             CheckVdm->CmdLen
                                             + CheckVdm->AppLen
                                             + CheckVdm->PifLen
                                             + CheckVdm->CurDirectoryLen
                                             + CheckVdm->DesktopLen
                                             + CheckVdm->TitleLen
                                             + CheckVdm->ReservedLen
                                             + CheckVdm->EnvLen
                                             + sizeof(*CheckVdm->StartupInfo));
    if (CaptureBuffer == NULL)
    {
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Capture the command line */
    CsrCaptureMessageBuffer(CaptureBuffer,
                            AnsiCmdLine,
                            CheckVdm->CmdLen,
                            (PVOID*)&CheckVdm->CmdLine);
 
    /* Capture the application name */
    CsrCaptureMessageBuffer(CaptureBuffer,
                            AnsiAppName,
                            CheckVdm->AppLen,
                            (PVOID*)&CheckVdm->AppName);
 
    CheckVdm->PifFile = NULL; // TODO: PIF file support!
 
    /* Capture the current directory */
    CsrCaptureMessageBuffer(CaptureBuffer,
                            AnsiCurDirectory,
                            CheckVdm->CurDirectoryLen,
                            (PVOID*)&CheckVdm->CurDirectory);
 
    /* Capture the environment */
    CsrCaptureMessageBuffer(CaptureBuffer,
                            AnsiEnvironment->Buffer,
                            CheckVdm->EnvLen,
                            (PVOID*)&CheckVdm->Env);
 
    /* Capture the startup info structure */
    CsrCaptureMessageBuffer(CaptureBuffer,
                            &AnsiStartupInfo,
                            sizeof(*CheckVdm->StartupInfo),
                            (PVOID*)&CheckVdm->StartupInfo);
 
    if (StartupInfo->lpDesktop)
    {
        /* Capture the desktop name */
        CsrCaptureMessageBuffer(CaptureBuffer,
                                AnsiDesktop,
                                CheckVdm->DesktopLen,
                                (PVOID*)&CheckVdm->Desktop);
    }
    else CheckVdm->Desktop = NULL;
 
    if (StartupInfo->lpTitle)
    {
        /* Capture the title */
        CsrCaptureMessageBuffer(CaptureBuffer,
                                AnsiTitle,
                                CheckVdm->TitleLen,
                                (PVOID*)&CheckVdm->Title);
    }
    else CheckVdm->Title = NULL;
 
    if (StartupInfo->lpReserved)
    {
        /* Capture the reserved parameter */
        CsrCaptureMessageBuffer(CaptureBuffer,
                                AnsiReserved,
                                CheckVdm->ReservedLen,
                                (PVOID*)&CheckVdm->Reserved);
    }
    else CheckVdm->Reserved = NULL;
 
    /* Send the message to CSRSS */
    Status = CsrClientCallServer((PCSR_API_MESSAGE)ApiMessage,
                                 CaptureBuffer,
                                 CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepCheckVDM),
                                 sizeof(*CheckVdm));
 
    /* Write back the task ID */
    *iTask = CheckVdm->iTask;
 
Cleanup:
 
    /* Free the ANSI strings */
    if (AnsiCmdLine) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiCmdLine);
    if (AnsiAppName) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiAppName);
    if (AnsiCurDirectory) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiCurDirectory);
    if (AnsiDesktop) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiDesktop);
    if (AnsiTitle) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiTitle);
    if (AnsiReserved) RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiReserved);
 
    /* Free the capture buffer */
    if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
 
    /* Free the current directory, if it was allocated here, and its short path */
    if (ShortCurrentDir) RtlFreeHeap(RtlGetProcessHeap(), 0, ShortCurrentDir);
    if (CurrentDir) RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDir);
 
    /* Free the short app name */
    if (ShortAppName) RtlFreeHeap(RtlGetProcessHeap(), 0, ShortAppName);
 
    return Status;
}

Referenced by CreateProcessInternalW().

BaseCreateVDMEnvironment()

BOOL NTAPI BaseCreateVDMEnvironment	(	IN PWCHAR	lpEnvironment,
		OUT PANSI_STRING	AnsiEnv,
		OUT PUNICODE_STRING	UnicodeEnv
	)

Definition at line 744 of file vdm.c.

{
#define IS_ALPHA(x)   \
    ( ((x) >= L'A' && (x) <= L'Z') || ((x) >= L'a' && (x) <= L'z') )
 
// From lib/rtl/path.c :
// Can be put in some .h ??
#define IS_PATH_SEPARATOR(x)    ((x) == L'\\' || (x) == L'/')
 
    BOOL Success = FALSE;
    NTSTATUS Status;
    ULONG EnvironmentSize = 0;
    SIZE_T RegionSize;
    PWCHAR Environment, NewEnvironment = NULL;
    ENV_NAME_TYPE NameType;
    ULONG NameLength, NumChars, Remaining;
    PWCHAR SourcePtr, DestPtr, StartPtr;
 
    /* Make sure we have both strings */
    if (!AnsiEnv || !UnicodeEnv)
    {
        /* Fail */
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Check if an environment was passed in */
    if (!lpEnvironment)
    {
        /* Nope, create one */
        Status = RtlCreateEnvironment(TRUE, &Environment);
        if (!NT_SUCCESS(Status)) goto Cleanup;
    }
    else
    {
        /* Use the one we got */
        Environment = lpEnvironment;
    }
 
    /* Do we have something now ? */
    if (!Environment)
    {
        /* Still not, bail out */
        SetLastError(ERROR_BAD_ENVIRONMENT);
        goto Cleanup;
    }
 
    /*
     * Count how much space the whole environment takes. The environment block is
     * doubly NULL-terminated (NULL from last string and final NULL terminator).
     */
    SourcePtr = Environment;
    while (!(*SourcePtr++ == UNICODE_NULL && *SourcePtr == UNICODE_NULL))
        ++EnvironmentSize;
    EnvironmentSize += 2; // Add the two terminating NULLs
 
    /*
     * Allocate a new copy large enough to hold all the environment with paths
     * in their short form. Since the short form of a path can be a bit longer
     * than its long form, for example in the case where characters that are
     * invalid in the 8.3 representation are present in the long path name:
     *   'C:\\a+b' --> 'C:\\A_B~1', or:
     *   'C:\\a b' --> 'C:\\AB2761~1' (with checksum inserted),
     * we suppose that the possible total number of extra characters needed to
     * convert the long paths into their short form is at most equal to MAX_PATH.
     */
    RegionSize = (EnvironmentSize + MAX_PATH) * sizeof(WCHAR);
    Status = NtAllocateVirtualMemory(NtCurrentProcess(),
                                     (PVOID*)&NewEnvironment,
                                     0,
                                     &RegionSize,
                                     MEM_COMMIT,
                                     PAGE_READWRITE);
    if (!NT_SUCCESS(Status))
    {
        /* We failed, bail out */
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        NewEnvironment = NULL;
        goto Cleanup;
    }
 
    /* Parse the environment block */
    Remaining = MAX_PATH - 2; // '-2': remove the last two NULLs. FIXME: is it really needed??
    SourcePtr = Environment;
    DestPtr   = NewEnvironment;
 
    /* Loop through all the environment strings */
    while (*SourcePtr != UNICODE_NULL)
    {
        /*
         * 1. Check the type of the environment variable and copy its name.
         */
 
        /* Regular environment variable */
        if (*SourcePtr != L'=')
        {
            StartPtr = SourcePtr;
 
            /* Copy the environment variable name, including the '=' */
            while (*SourcePtr != UNICODE_NULL)
            {
                *DestPtr++ = *SourcePtr;
                if (*SourcePtr++ == L'=') break;
            }
 
            /* Guess the type of the environment variable */
            NameType = BaseGetEnvNameType_U(StartPtr, SourcePtr - StartPtr - 1);
        }
        /* 'Current directory' environment variable (i.e. of '=X:=' form) */
        else // if (*SourcePtr == L'=')
        {
            /* First assume we have a possibly malformed environment variable */
            NameType = EnvNameNotAPath;
 
            /* Check for a valid 'Current directory' environment variable */
            if (IS_ALPHA(SourcePtr[1]) && SourcePtr[2] == L':' && SourcePtr[3] == L'=')
            {
                /*
                 * Small optimization: convert the path to short form only if
                 * the current directory is not the root directory (i.e. not
                 * of the '=X:=Y:\' form), otherwise just do a simple copy.
                 */
                if ( wcslen(SourcePtr) >= ARRAYSIZE("=X:=Y:\\")-1 &&
                     !( IS_ALPHA(SourcePtr[4]) && SourcePtr[5] == L':' &&
                        IS_PATH_SEPARATOR(SourcePtr[6]) && SourcePtr[7] == UNICODE_NULL ) )
                {
                    NameType = EnvNameSinglePath;
 
                    /* Copy the '=X:=' prefix */
                    *DestPtr++ = SourcePtr[0];
                    *DestPtr++ = SourcePtr[1];
                    *DestPtr++ = SourcePtr[2];
                    *DestPtr++ = SourcePtr[3];
                    SourcePtr += 4;
                }
            }
            else
            {
                /*
                 * Invalid stuff starting with '=', i.e.:
                 * =? (with '?' not being a letter)
                 * =X??? (with '?' not being ":=" and not followed by something longer than 3 characters)
                 * =X:=??? (with '?' not being "X:\\")
                 *
                 * 'NameType' is already set to 'EnvNameNotAPath'.
                 */
            }
        }
 
 
        /*
         * 2. Copy the environment value and perform conversions accordingly.
         */
 
        if (NameType == EnvNameNotAPath)
        {
            /* Copy everything, including the NULL terminator */
            do
            {
                *DestPtr++ = *SourcePtr;
            } while (*SourcePtr++ != UNICODE_NULL);
        }
        else if (NameType == EnvNameSinglePath)
        {
            /* Convert the path to its short form */
            NameLength = wcslen(SourcePtr);
            NumChars = GetShortPathNameW(SourcePtr, DestPtr, NameLength + 1 + Remaining);
            if (NumChars == 0 || NumChars > NameLength + Remaining)
            {
                /* If the conversion failed, just copy the original value */
                RtlCopyMemory(DestPtr, SourcePtr, NameLength * sizeof(WCHAR));
                NumChars = NameLength;
            }
            DestPtr += NumChars;
            if (NumChars > NameLength)
                Remaining -= (NumChars - NameLength);
 
            SourcePtr += NameLength;
 
            /* Copy the NULL terminator */
            *DestPtr++ = *SourcePtr++;
        }
        else // if (NameType == EnvNameMultiplePath)
        {
            WCHAR Delimiter;
 
            /* Loop through the list of paths (delimited by ';') and convert each path to its short form */
            do
            {
                /* Copy any trailing ';' before going to the next path */
                while (*SourcePtr == L';')
                {
                    *DestPtr++ = *SourcePtr++;
                }
 
                StartPtr = SourcePtr;
 
                /* Find the next path list delimiter or the NULL terminator */
                while (*SourcePtr != UNICODE_NULL && *SourcePtr != L';')
                {
                    ++SourcePtr;
                }
                Delimiter = *SourcePtr;
 
                NameLength = SourcePtr - StartPtr;
                if (NameLength)
                {
                    /*
                     * Temporarily replace the possible path list delimiter by NULL.
                     * 'lpEnvironment' must point to a read+write memory buffer!
                     */
                    *SourcePtr = UNICODE_NULL;
 
                    NumChars = GetShortPathNameW(StartPtr, DestPtr, NameLength + 1 + Remaining);
                    if ( NumChars == 0 ||
                        (Delimiter == L';' ? NumChars > NameLength + Remaining
                                           : NumChars > NameLength /* + Remaining ?? */) )
                    {
                        /* If the conversion failed, just copy the original value */
                        RtlCopyMemory(DestPtr, StartPtr, NameLength * sizeof(WCHAR));
                        NumChars = NameLength;
                    }
                    DestPtr += NumChars;
                    if (NumChars > NameLength)
                        Remaining -= (NumChars - NameLength);
 
                    /* If removed, restore the path list delimiter in the source environment value and copy it */
                    if (Delimiter != UNICODE_NULL)
                    {
                        *SourcePtr = Delimiter;
                        *DestPtr++ = *SourcePtr++;
                    }
                }
            } while (*SourcePtr != UNICODE_NULL);
 
            /* Copy the NULL terminator */
            *DestPtr++ = *SourcePtr++;
        }
    }
 
    /* NULL-terminate the environment block */
    *DestPtr++ = UNICODE_NULL;
 
    /* Initialize the Unicode string to hold it */
    RtlInitEmptyUnicodeString(UnicodeEnv, NewEnvironment,
                              (DestPtr - NewEnvironment) * sizeof(WCHAR));
    UnicodeEnv->Length = UnicodeEnv->MaximumLength;
 
    /* Create its ANSI version */
    Status = RtlUnicodeStringToAnsiString(AnsiEnv, UnicodeEnv, TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* Set last error if conversion failure */
        BaseSetLastNTError(Status);
    }
    else
    {
        /* Everything went okay, so return success */
        Success = TRUE;
        NewEnvironment = NULL;
    }
 
Cleanup:
    /* Cleanup path starts here, start by destroying the environment copy */
    if (!lpEnvironment && Environment) RtlDestroyEnvironment(Environment);
 
    /* See if we are here due to failure */
    if (NewEnvironment)
    {
        /* Initialize the paths to be empty */
        RtlInitEmptyUnicodeString(UnicodeEnv, NULL, 0);
        RtlInitEmptyAnsiString(AnsiEnv, NULL, 0);
 
        /* Free the environment copy */
        RegionSize = 0;
        Status = NtFreeVirtualMemory(NtCurrentProcess(),
                                     (PVOID*)&NewEnvironment,
                                     &RegionSize,
                                     MEM_RELEASE);
        ASSERT(NT_SUCCESS(Status));
    }
 
    /* Return the result */
    return Success;
}

Referenced by CreateProcessInternalW().

BaseDestroyVDMEnvironment()

BOOL NTAPI BaseDestroyVDMEnvironment	(	IN PANSI_STRING	AnsiEnv,
		IN PUNICODE_STRING	UnicodeEnv
	)

Definition at line 1034 of file vdm.c.

{
    SIZE_T Dummy = 0;
 
    /* Clear the ANSI buffer since Rtl creates this for us */
    if (AnsiEnv->Buffer) RtlFreeAnsiString(AnsiEnv);
 
    /* The Unicode buffer is build by hand, though */
    if (UnicodeEnv->Buffer)
    {
        /* So clear it through the API */
        NtFreeVirtualMemory(NtCurrentProcess(),
                            (PVOID*)&UnicodeEnv->Buffer,
                            &Dummy,
                            MEM_RELEASE);
    }
 
    /* All done */
    return TRUE;
}

Referenced by CreateProcessInternalW().

BaseGetVdmConfigInfo()

BOOL WINAPI BaseGetVdmConfigInfo	(	IN LPCWSTR	CommandLineReserved,
		IN ULONG	DosSeqId,
		IN ULONG	BinaryType,
		IN PUNICODE_STRING	CmdLineString,
		OUT PULONG	VdmSize
	)

Definition at line 652 of file vdm.c.

{
    WCHAR Buffer[MAX_PATH];
    WCHAR CommandLine[MAX_PATH * 2];
    ULONG Length;
 
    /* Clear the buffer in case we fail */
    CmdLineString->Buffer = 0;
 
    /* Always return the same size: 16 Mb */
    *VdmSize = 0x1000000;
 
    /* Get the system directory */
    Length = GetSystemDirectoryW(Buffer, MAX_PATH);
    if (!(Length) || (Length >= MAX_PATH))
    {
        /* Eliminate no path or path too big */
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }
 
    /* Check if this is VDM with a DOS Sequence ID */
    if (DosSeqId)
    {
        /*
         * Build the VDM string for it:
         * -i%lx : Gives the DOS Sequence ID;
         * %s%c  : Nothing if DOS VDM, -w if WoW VDM, -ws if separate WoW VDM.
         */
        _snwprintf(CommandLine,
                   ARRAYSIZE(CommandLine),
                   L"\"%s\\ntvdm.exe\" -i%lx %s%c",
                   Buffer,
                   DosSeqId,
                   (BinaryType == BINARY_TYPE_DOS) ? L" " : L"-w",
                   (BinaryType == BINARY_TYPE_SEPARATE_WOW) ? L's' : L' ');
    }
    else
    {
        /*
         * Build the string for it without the DOS Sequence ID:
         * %s%c  : Nothing if DOS VDM, -w if WoW VDM, -ws if separate WoW VDM.
         */
        _snwprintf(CommandLine,
                   ARRAYSIZE(CommandLine),
                   L"\"%s\\ntvdm.exe\" %s%c",
                   Buffer,
                   (BinaryType == BINARY_TYPE_DOS) ? L" " : L"-w",
                   (BinaryType == BINARY_TYPE_SEPARATE_WOW) ? L's' : L' ');
    }
 
    /* Create the actual string */
    return RtlCreateUnicodeString(CmdLineString, CommandLine);
}

Referenced by CreateProcessInternalW().

BaseUpdateVDMEntry()

BOOL WINAPI BaseUpdateVDMEntry	(	IN ULONG	UpdateIndex,
		IN OUT PHANDLE	WaitHandle,
		IN ULONG	IndexInfo,
		IN ULONG	BinaryType
	)

Definition at line 542 of file vdm.c.

{
    BASE_API_MESSAGE ApiMessage;
    PBASE_UPDATE_VDM_ENTRY UpdateVdmEntry = &ApiMessage.Data.UpdateVDMEntryRequest;
 
    /* Check what update is being sent */
    switch (UpdateIndex)
    {
        /* VDM is being undone */
        case VdmEntryUndo:
        {
            /* Tell the server how far we had gotten along */
            UpdateVdmEntry->iTask = HandleToUlong(*WaitHandle);
            UpdateVdmEntry->VDMCreationState = IndexInfo;
            break;
        }
 
        /* VDM is ready with a new process handle */
        case VdmEntryUpdateProcess:
        {
            /* Send it the process handle */
            UpdateVdmEntry->VDMProcessHandle = *WaitHandle;
            UpdateVdmEntry->iTask = IndexInfo;
            break;
        }
    }
 
    /* Also check what kind of binary this is for the console handle */
    if (BinaryType == BINARY_TYPE_WOW)
    {
        /* Magic value for 16-bit apps */
        UpdateVdmEntry->ConsoleHandle = (HANDLE)-1;
    }
    else if (UpdateVdmEntry->iTask)
    {
        /* No handle for true VDM */
        UpdateVdmEntry->ConsoleHandle = NULL;
    }
    else
    {
        /* Otherwise, use the regular console handle */
        UpdateVdmEntry->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
    }
 
    /* Finally write the index and binary type */
    UpdateVdmEntry->EntryIndex = UpdateIndex;
    UpdateVdmEntry->BinaryType = BinaryType;
 
    /* Send the message to CSRSS */
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepUpdateVDMEntry),
                        sizeof(*UpdateVdmEntry));
    if (!NT_SUCCESS(ApiMessage.Status))
    {
        /* Handle failure */
        BaseSetLastNTError(ApiMessage.Status);
        return FALSE;
    }
 
    /* If this was an update, CSRSS returns a new wait handle */
    if (UpdateIndex == VdmEntryUpdateProcess)
    {
        /* Return it to the caller */
        *WaitHandle = UpdateVdmEntry->WaitObjectForParent;
    }
 
    /* We made it */
    return TRUE;
}

Referenced by CreateProcessInternalW(), and VDMOperationStarted().