Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 10:45:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/dll/win32/kernel32/client/vdm.c

2008 lines
62 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS Win32 Base API
* LICENSE: GPL - See COPYING in the top level directory
* FILE: dll/win32/kernel32/client/vdm.c
* PURPOSE: Virtual DOS Machines (VDM) Support
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
*/
/* INCLUDES *******************************************************************/
#include <k32.h>
#define NDEBUG
#include <debug.h>
/* TYPES **********************************************************************/
#define BINARY_UNKNOWN (0)
#define BINARY_PE_EXE32 (1)
#define BINARY_PE_DLL32 (2)
#define BINARY_PE_EXE64 (3)
#define BINARY_PE_DLL64 (4)
#define BINARY_WIN16 (5)
#define BINARY_OS216 (6)
#define BINARY_DOS (7)
#define BINARY_UNIX_EXE (8)
#define BINARY_UNIX_LIB (9)
typedef enum _ENV_NAME_TYPE
{
EnvNameNotAPath = 1,
EnvNameSinglePath ,
EnvNameMultiplePath
} ENV_NAME_TYPE;
typedef struct _ENV_INFO
{
ENV_NAME_TYPE NameType;
ULONG NameLength;
PWCHAR Name;
} ENV_INFO, *PENV_INFO;
/* GLOBALS ********************************************************************/
#define ENV_NAME_ENTRY(type, name) \
{(type), _ARRAYSIZE(name) - 1, (name)}
static ENV_INFO BasepEnvNameType[] =
{
ENV_NAME_ENTRY(EnvNameMultiplePath, L"PATH"),
ENV_NAME_ENTRY(EnvNameSinglePath , L"WINDIR"),
ENV_NAME_ENTRY(EnvNameSinglePath , L"SYSTEMROOT"),
ENV_NAME_ENTRY(EnvNameMultiplePath, L"TEMP"),
ENV_NAME_ENTRY(EnvNameMultiplePath, L"TMP"),
};
static UNICODE_STRING BaseDotComSuffixName = RTL_CONSTANT_STRING(L".com");
static UNICODE_STRING BaseDotPifSuffixName = RTL_CONSTANT_STRING(L".pif");
static UNICODE_STRING BaseDotExeSuffixName = RTL_CONSTANT_STRING(L".exe");
/* FUNCTIONS ******************************************************************/
ULONG
WINAPI
BaseIsDosApplication(IN PUNICODE_STRING PathName,
IN NTSTATUS Status)
{
UNICODE_STRING String;
/* Is it a .com? */
String.Length = BaseDotComSuffixName.Length;
String.Buffer = &PathName->Buffer[(PathName->Length - String.Length) / sizeof(WCHAR)];
if (RtlEqualUnicodeString(&String, &BaseDotComSuffixName, TRUE)) return BINARY_TYPE_COM;
/* Is it a .pif? */
String.Length = BaseDotPifSuffixName.Length;
String.Buffer = &PathName->Buffer[(PathName->Length - String.Length) / sizeof(WCHAR)];
if (RtlEqualUnicodeString(&String, &BaseDotPifSuffixName, TRUE)) return BINARY_TYPE_PIF;
/* Is it an exe? */
String.Length = BaseDotExeSuffixName.Length;
String.Buffer = &PathName->Buffer[(PathName->Length - String.Length) / sizeof(WCHAR)];
if (RtlEqualUnicodeString(&String, &BaseDotExeSuffixName, TRUE)) return BINARY_TYPE_EXE;
return 0;
}
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)
{
NTSTATUS Status;
PBASE_CHECK_VDM CheckVdm = &ApiMessage->Data.CheckVDMRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
PWCHAR CurrentDir = NULL;
PWCHAR ShortAppName = NULL;
PWCHAR ShortCurrentDir = NULL;
ULONG 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;
}
/* 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 = wcslen(CommandLine) + 1;
CheckVdm->AppLen = wcslen(ShortAppName) + 1;
CheckVdm->PifLen = 0; // TODO: PIF file support!
CheckVdm->CurDirectoryLen = 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;
}
BOOL
WINAPI
BaseUpdateVDMEntry(IN ULONG UpdateIndex,
IN OUT PHANDLE WaitHandle,
IN ULONG IndexInfo,
IN ULONG BinaryType)
{
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;
}
BOOL
WINAPI
BaseCheckForVDM(IN HANDLE ProcessHandle,
OUT LPDWORD ExitCode)
{
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;
}
BOOL
WINAPI
BaseGetVdmConfigInfo(IN LPCWSTR CommandLineReserved,
IN ULONG DosSeqId,
IN ULONG BinaryType,
IN PUNICODE_STRING CmdLineString,
OUT PULONG VdmSize)
{
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);
}
ENV_NAME_TYPE
WINAPI
BaseGetEnvNameType_U(IN PWCHAR Name,
IN ULONG NameLength)
{
PENV_INFO EnvInfo;
ENV_NAME_TYPE NameType;
ULONG i;
/* Start by assuming the environment variable doesn't describe paths */
NameType = EnvNameNotAPath;
/* Loop all the environment names */
for (i = 0; i < ARRAYSIZE(BasepEnvNameType); i++)
{
/* Get this entry */
EnvInfo = &BasepEnvNameType[i];
/* Check if it matches the name */
if ((EnvInfo->NameLength == NameLength) &&
(_wcsnicmp(EnvInfo->Name, Name, NameLength) == 0))
{
/* It does, return the type */
NameType = EnvInfo->NameType;
break;
}
}
return NameType;
}
BOOL
NTAPI
BaseCreateVDMEnvironment(IN PWCHAR lpEnvironment,
OUT PANSI_STRING AnsiEnv,
OUT PUNICODE_STRING UnicodeEnv)
{
#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 RegionSize, EnvironmentSize = 0;
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;
}
BOOL
NTAPI
BaseDestroyVDMEnvironment(IN PANSI_STRING AnsiEnv,
IN PUNICODE_STRING UnicodeEnv)
{
ULONG 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;
}
/* Check whether a file is an OS/2 or a very old Windows executable
* by testing on import of KERNEL.
*
* FIXME: is reading the module imports the only way of discerning
* old Windows binaries from OS/2 ones ? At least it seems so...
*/
static DWORD WINAPI
InternalIsOS2OrOldWin(HANDLE hFile, IMAGE_DOS_HEADER *mz, IMAGE_OS2_HEADER *ne)
{
DWORD CurPos;
LPWORD modtab = NULL;
LPSTR nametab = NULL;
DWORD Read, Ret;
int i;
Ret = BINARY_OS216;
CurPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
/* read modref table */
if((SetFilePointer(hFile, mz->e_lfanew + ne->ne_modtab, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) ||
(!(modtab = HeapAlloc(GetProcessHeap(), 0, ne->ne_cmod * sizeof(WORD)))) ||
(!(ReadFile(hFile, modtab, ne->ne_cmod * sizeof(WORD), &Read, NULL))) ||
(Read != (DWORD)ne->ne_cmod * sizeof(WORD)))
{
goto broken;
}
/* read imported names table */
if((SetFilePointer(hFile, mz->e_lfanew + ne->ne_imptab, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) ||
(!(nametab = HeapAlloc(GetProcessHeap(), 0, ne->ne_enttab - ne->ne_imptab))) ||
(!(ReadFile(hFile, nametab, ne->ne_enttab - ne->ne_imptab, &Read, NULL))) ||
(Read != (DWORD)ne->ne_enttab - ne->ne_imptab))
{
goto broken;
}
for(i = 0; i < ne->ne_cmod; i++)
{
LPSTR module;
module = &nametab[modtab[i]];
if(!strncmp(&module[1], "KERNEL", module[0]))
{
/* very old windows file */
Ret = BINARY_WIN16;
goto done;
}
}
broken:
DPRINT1("InternalIsOS2OrOldWin(): Binary file seems to be broken\n");
done:
HeapFree(GetProcessHeap(), 0, modtab);
HeapFree(GetProcessHeap(), 0, nametab);
SetFilePointer(hFile, CurPos, NULL, FILE_BEGIN);
return Ret;
}
static DWORD WINAPI
InternalGetBinaryType(HANDLE hFile)
{
union
{
struct
{
unsigned char magic[4];
unsigned char ignored[12];
unsigned short type;
} elf;
struct
{
unsigned long magic;
unsigned long cputype;
unsigned long cpusubtype;
unsigned long filetype;
} macho;
IMAGE_DOS_HEADER mz;
} Header;
char magic[4];
DWORD Read;
if((SetFilePointer(hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) ||
(!ReadFile(hFile, &Header, sizeof(Header), &Read, NULL) ||
(Read != sizeof(Header))))
{
return BINARY_UNKNOWN;
}
if(!memcmp(Header.elf.magic, "\177ELF", sizeof(Header.elf.magic)))
{
/* FIXME: we don't bother to check byte order, architecture, etc. */
switch(Header.elf.type)
{
case 2:
return BINARY_UNIX_EXE;
case 3:
return BINARY_UNIX_LIB;
}
return BINARY_UNKNOWN;
}
/* Mach-o File with Endian set to Big Endian or Little Endian*/
if(Header.macho.magic == 0xFEEDFACE ||
Header.macho.magic == 0xCEFAEDFE)
{
switch(Header.macho.filetype)
{
case 0x8:
/* MH_BUNDLE */
return BINARY_UNIX_LIB;
}
return BINARY_UNKNOWN;
}
/* Not ELF, try DOS */
if(Header.mz.e_magic == IMAGE_DOS_SIGNATURE)
{
/* We do have a DOS image so we will now try to seek into
* the file by the amount indicated by the field
* "Offset to extended header" and read in the
* "magic" field information at that location.
* This will tell us if there is more header information
* to read or not.
*/
if((SetFilePointer(hFile, Header.mz.e_lfanew, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) ||
(!ReadFile(hFile, magic, sizeof(magic), &Read, NULL) ||
(Read != sizeof(magic))))
{
return BINARY_DOS;
}
/* Reading the magic field succeeded so
* we will try to determine what type it is.
*/
if(!memcmp(magic, "PE\0\0", sizeof(magic)))
{
IMAGE_FILE_HEADER FileHeader;
if(!ReadFile(hFile, &FileHeader, sizeof(IMAGE_FILE_HEADER), &Read, NULL) ||
(Read != sizeof(IMAGE_FILE_HEADER)))
{
return BINARY_DOS;
}
/* FIXME - detect 32/64 bit */
if(FileHeader.Characteristics & IMAGE_FILE_DLL)
return BINARY_PE_DLL32;
return BINARY_PE_EXE32;
}
if(!memcmp(magic, "NE", 2))
{
/* This is a Windows executable (NE) header. This can
* mean either a 16-bit OS/2 or a 16-bit Windows or even a
* DOS program (running under a DOS extender). To decide
* which, we'll have to read the NE header.
*/
IMAGE_OS2_HEADER ne;
if((SetFilePointer(hFile, Header.mz.e_lfanew, NULL, FILE_BEGIN) == 1) ||
!ReadFile(hFile, &ne, sizeof(IMAGE_OS2_HEADER), &Read, NULL) ||
(Read != sizeof(IMAGE_OS2_HEADER)))
{
/* Couldn't read header, so abort. */
return BINARY_DOS;
}
switch(ne.ne_exetyp)
{
case 2:
return BINARY_WIN16;
case 5:
return BINARY_DOS;
default:
return InternalIsOS2OrOldWin(hFile, &Header.mz, &ne);
}
}
return BINARY_DOS;
}
return BINARY_UNKNOWN;
}
/*
* @implemented
*/
BOOL
WINAPI
GetBinaryTypeW (
LPCWSTR lpApplicationName,
LPDWORD lpBinaryType
)
{
HANDLE hFile;
DWORD BinType;
if(!lpApplicationName || !lpBinaryType)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
hFile = CreateFileW(lpApplicationName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, 0);
if(hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
BinType = InternalGetBinaryType(hFile);
CloseHandle(hFile);
switch(BinType)
{
case BINARY_UNKNOWN:
{
WCHAR *dot;
/*
* guess from filename
*/
if(!(dot = wcsrchr(lpApplicationName, L'.')))
{
return FALSE;
}
if(!lstrcmpiW(dot, L".COM"))
{
*lpBinaryType = SCS_DOS_BINARY;
return TRUE;
}
if(!lstrcmpiW(dot, L".PIF"))
{
*lpBinaryType = SCS_PIF_BINARY;
return TRUE;
}
return FALSE;
}
case BINARY_PE_EXE32:
case BINARY_PE_DLL32:
{
*lpBinaryType = SCS_32BIT_BINARY;
return TRUE;
}
case BINARY_PE_EXE64:
case BINARY_PE_DLL64:
{
*lpBinaryType = SCS_64BIT_BINARY;
return TRUE;
}
case BINARY_WIN16:
{
*lpBinaryType = SCS_WOW_BINARY;
return TRUE;
}
case BINARY_OS216:
{
*lpBinaryType = SCS_OS216_BINARY;
return TRUE;
}
case BINARY_DOS:
{
*lpBinaryType = SCS_DOS_BINARY;
return TRUE;
}
case BINARY_UNIX_EXE:
case BINARY_UNIX_LIB:
{
return FALSE;
}
}
DPRINT1("Invalid binary type %lu returned!\n", BinType);
return FALSE;
}
/*
* @implemented
*/
BOOL
WINAPI
GetBinaryTypeA(IN LPCSTR lpApplicationName,
OUT LPDWORD lpBinaryType)
{
ANSI_STRING ApplicationNameString;
UNICODE_STRING ApplicationNameW;
BOOL StringAllocated = FALSE, Result;
NTSTATUS Status;
RtlInitAnsiString(&ApplicationNameString, lpApplicationName);
if (ApplicationNameString.Length * sizeof(WCHAR) >= NtCurrentTeb()->StaticUnicodeString.MaximumLength)
{
StringAllocated = TRUE;
Status = RtlAnsiStringToUnicodeString(&ApplicationNameW, &ApplicationNameString, TRUE);
}
else
{
Status = RtlAnsiStringToUnicodeString(&(NtCurrentTeb()->StaticUnicodeString), &ApplicationNameString, FALSE);
}
if (!NT_SUCCESS(Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
if (StringAllocated)
{
Result = GetBinaryTypeW(ApplicationNameW.Buffer, lpBinaryType);
RtlFreeUnicodeString(&ApplicationNameW);
}
else
{
Result = GetBinaryTypeW(NtCurrentTeb()->StaticUnicodeString.Buffer, lpBinaryType);
}
return Result;
}
/*
* @unimplemented
*/
BOOL
WINAPI
CmdBatNotification (
DWORD Unknown
)
{
STUB;
return FALSE;
}
/*
* @implemented
*/
VOID
WINAPI
ExitVDM(BOOL IsWow, ULONG iWowTask)
{
BASE_API_MESSAGE ApiMessage;
PBASE_EXIT_VDM ExitVdm = &ApiMessage.Data.ExitVDMRequest;
/* Setup the input parameters */
ExitVdm->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ExitVdm->iWowTask = IsWow ? iWowTask : 0; /* Always zero for DOS tasks */
ExitVdm->WaitObjectForVDM = NULL;
/* Call CSRSS */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
NULL,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepExitVDM),
sizeof(*ExitVdm));
/* Close the returned wait object handle, if any */
if (NT_SUCCESS(ApiMessage.Status) && (ExitVdm->WaitObjectForVDM != NULL))
{
CloseHandle(ExitVdm->WaitObjectForVDM);
}
}
/*
* @implemented
*/
BOOL
WINAPI
GetNextVDMCommand(PVDM_COMMAND_INFO CommandData)
{
BOOL Success = FALSE;
NTSTATUS Status;
BASE_API_MESSAGE ApiMessage;
PBASE_GET_NEXT_VDM_COMMAND GetNextVdmCommand = &ApiMessage.Data.GetNextVDMCommandRequest;
PBASE_IS_FIRST_VDM IsFirstVdm = &ApiMessage.Data.IsFirstVDMRequest;
PBASE_SET_REENTER_COUNT SetReenterCount = &ApiMessage.Data.SetReenterCountRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
ULONG NumStrings = 0;
/*
* Special case to test whether the VDM is the first one.
*/
if (CommandData == NULL)
{
/* Call CSRSS */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
NULL,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepIsFirstVDM),
sizeof(*IsFirstVdm));
if (!NT_SUCCESS(ApiMessage.Status))
{
BaseSetLastNTError(ApiMessage.Status);
return FALSE;
}
/* Return TRUE if this is the first VDM */
return IsFirstVdm->FirstVDM;
}
/* CommandData != NULL */
/*
* Special case to increment or decrement the reentrancy count.
*/
if ((CommandData->VDMState == VDM_INC_REENTER_COUNT) ||
(CommandData->VDMState == VDM_DEC_REENTER_COUNT))
{
/* Setup the input parameters */
SetReenterCount->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
SetReenterCount->fIncDec = CommandData->VDMState;
/* Call CSRSS */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
NULL,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepSetReenterCount),
sizeof(*SetReenterCount));
if (!NT_SUCCESS(ApiMessage.Status))
{
BaseSetLastNTError(ApiMessage.Status);
return FALSE;
}
return TRUE;
}
/*
* TODO!
* Special case to retrieve or set WOW information.
*/
// TODO: if CommandData->VDMState & (VDM_LIST_WOW_PROCESSES | VDM_LIST_WOW_TASKS | VDM_ADD_WOW_TASK)
// then call BasepGetNextVDMCommand in a simpler way!
/*
* Regular case.
*/
/* Clear the structure */
RtlZeroMemory(GetNextVdmCommand, sizeof(*GetNextVdmCommand));
/* Setup the input parameters */
GetNextVdmCommand->iTask = CommandData->TaskId;
GetNextVdmCommand->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
GetNextVdmCommand->CmdLen = CommandData->CmdLen;
GetNextVdmCommand->AppLen = CommandData->AppLen;
GetNextVdmCommand->PifLen = CommandData->PifLen;
GetNextVdmCommand->CurDirectoryLen = CommandData->CurDirectoryLen;
GetNextVdmCommand->EnvLen = CommandData->EnvLen;
GetNextVdmCommand->DesktopLen = CommandData->DesktopLen;
GetNextVdmCommand->TitleLen = CommandData->TitleLen;
GetNextVdmCommand->ReservedLen = CommandData->ReservedLen;
GetNextVdmCommand->VDMState = CommandData->VDMState;
/* Count the number of strings */
if (CommandData->CmdLen) NumStrings++;
if (CommandData->AppLen) NumStrings++;
if (CommandData->PifLen) NumStrings++;
if (CommandData->CurDirectoryLen) NumStrings++;
if (CommandData->EnvLen) NumStrings++;
if (CommandData->DesktopLen) NumStrings++;
if (CommandData->TitleLen) NumStrings++;
if (CommandData->ReservedLen) NumStrings++;
/* Allocate the capture buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(NumStrings + 1,
GetNextVdmCommand->CmdLen
+ GetNextVdmCommand->AppLen
+ GetNextVdmCommand->PifLen
+ GetNextVdmCommand->CurDirectoryLen
+ GetNextVdmCommand->EnvLen
+ GetNextVdmCommand->DesktopLen
+ GetNextVdmCommand->TitleLen
+ GetNextVdmCommand->ReservedLen
+ sizeof(*GetNextVdmCommand->StartupInfo));
if (CaptureBuffer == NULL)
{
BaseSetLastNTError(STATUS_NO_MEMORY);
goto Cleanup;
}
/* Capture the data */
CsrAllocateMessagePointer(CaptureBuffer,
sizeof(*GetNextVdmCommand->StartupInfo),
(PVOID*)&GetNextVdmCommand->StartupInfo);
if (CommandData->CmdLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->CmdLen,
(PVOID*)&GetNextVdmCommand->CmdLine);
}
if (CommandData->AppLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->AppLen,
(PVOID*)&GetNextVdmCommand->AppName);
}
if (CommandData->PifLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->PifLen,
(PVOID*)&GetNextVdmCommand->PifFile);
}
if (CommandData->CurDirectoryLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->CurDirectoryLen,
(PVOID*)&GetNextVdmCommand->CurDirectory);
}
if (CommandData->EnvLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->EnvLen,
(PVOID*)&GetNextVdmCommand->Env);
}
if (CommandData->DesktopLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->DesktopLen,
(PVOID*)&GetNextVdmCommand->Desktop);
}
if (CommandData->TitleLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->TitleLen,
(PVOID*)&GetNextVdmCommand->Title);
}
if (CommandData->ReservedLen)
{
CsrAllocateMessagePointer(CaptureBuffer,
CommandData->ReservedLen,
(PVOID*)&GetNextVdmCommand->Reserved);
}
while (TRUE)
{
/* Call CSRSS */
Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepGetNextVDMCommand),
sizeof(*GetNextVdmCommand));
/* Exit the waiting loop if we did not receive any event handle */
if (GetNextVdmCommand->WaitObjectForVDM == NULL)
break;
/* Wait for the event to become signaled and try again */
Status = NtWaitForSingleObject(GetNextVdmCommand->WaitObjectForVDM,
FALSE, NULL);
if (Status != STATUS_SUCCESS)
{
/* Fail if we timed out, or if some other error happened */
BaseSetLastNTError(Status);
goto Cleanup;
}
/* Set the retry flag, clear the exit code, and retry a query */
GetNextVdmCommand->VDMState |= VDM_FLAG_RETRY;
GetNextVdmCommand->ExitCode = 0;
}
if (!NT_SUCCESS(Status))
{
if (Status == STATUS_INVALID_PARAMETER)
{
/*
* One of the buffer lengths was less than required. Store the correct ones.
* Note that the status code is not STATUS_BUFFER_TOO_SMALL as one would expect,
* in order to keep compatibility with Windows 2003 BASESRV.DLL.
*/
CommandData->CmdLen = GetNextVdmCommand->CmdLen;
CommandData->AppLen = GetNextVdmCommand->AppLen;
CommandData->PifLen = GetNextVdmCommand->PifLen;
CommandData->CurDirectoryLen = GetNextVdmCommand->CurDirectoryLen;
CommandData->EnvLen = GetNextVdmCommand->EnvLen;
CommandData->DesktopLen = GetNextVdmCommand->DesktopLen;
CommandData->TitleLen = GetNextVdmCommand->TitleLen;
CommandData->ReservedLen = GetNextVdmCommand->ReservedLen;
}
else
{
/* Any other failure */
CommandData->CmdLen = 0;
CommandData->AppLen = 0;
CommandData->PifLen = 0;
CommandData->CurDirectoryLen = 0;
CommandData->EnvLen = 0;
CommandData->DesktopLen = 0;
CommandData->TitleLen = 0;
CommandData->ReservedLen = 0;
}
BaseSetLastNTError(Status);
goto Cleanup;
}
/* Write back the standard handles */
CommandData->StdIn = GetNextVdmCommand->StdIn;
CommandData->StdOut = GetNextVdmCommand->StdOut;
CommandData->StdErr = GetNextVdmCommand->StdErr;
/* Write back the startup info */
RtlMoveMemory(&CommandData->StartupInfo,
GetNextVdmCommand->StartupInfo,
sizeof(*GetNextVdmCommand->StartupInfo));
if (CommandData->CmdLen)
{
/* Write back the command line */
RtlMoveMemory(CommandData->CmdLine,
GetNextVdmCommand->CmdLine,
GetNextVdmCommand->CmdLen);
/* Set the actual length */
CommandData->CmdLen = GetNextVdmCommand->CmdLen;
}
if (CommandData->AppLen)
{
/* Write back the application name */
RtlMoveMemory(CommandData->AppName,
GetNextVdmCommand->AppName,
GetNextVdmCommand->AppLen);
/* Set the actual length */
CommandData->AppLen = GetNextVdmCommand->AppLen;
}
if (CommandData->PifLen)
{
/* Write back the PIF file name */
RtlMoveMemory(CommandData->PifFile,
GetNextVdmCommand->PifFile,
GetNextVdmCommand->PifLen);
/* Set the actual length */
CommandData->PifLen = GetNextVdmCommand->PifLen;
}
if (CommandData->CurDirectoryLen)
{
/* Write back the current directory */
RtlMoveMemory(CommandData->CurDirectory,
GetNextVdmCommand->CurDirectory,
GetNextVdmCommand->CurDirectoryLen);
/* Set the actual length */
CommandData->CurDirectoryLen = GetNextVdmCommand->CurDirectoryLen;
}
if (CommandData->EnvLen)
{
/* Write back the environment */
RtlMoveMemory(CommandData->Env,
GetNextVdmCommand->Env,
GetNextVdmCommand->EnvLen);
/* Set the actual length */
CommandData->EnvLen = GetNextVdmCommand->EnvLen;
}
if (CommandData->DesktopLen)
{
/* Write back the desktop name */
RtlMoveMemory(CommandData->Desktop,
GetNextVdmCommand->Desktop,
GetNextVdmCommand->DesktopLen);
/* Set the actual length */
CommandData->DesktopLen = GetNextVdmCommand->DesktopLen;
}
if (CommandData->TitleLen)
{
/* Write back the title */
RtlMoveMemory(CommandData->Title,
GetNextVdmCommand->Title,
GetNextVdmCommand->TitleLen);
/* Set the actual length */
CommandData->TitleLen = GetNextVdmCommand->TitleLen;
}
if (CommandData->ReservedLen)
{
/* Write back the reserved parameter */
RtlMoveMemory(CommandData->Reserved,
GetNextVdmCommand->Reserved,
GetNextVdmCommand->ReservedLen);
/* Set the actual length */
CommandData->ReservedLen = GetNextVdmCommand->ReservedLen;
}
/* Write the remaining output parameters */
CommandData->TaskId = GetNextVdmCommand->iTask;
CommandData->CreationFlags = GetNextVdmCommand->dwCreationFlags;
CommandData->CodePage = GetNextVdmCommand->CodePage;
CommandData->ExitCode = GetNextVdmCommand->ExitCode;
CommandData->CurrentDrive = GetNextVdmCommand->CurrentDrive;
CommandData->VDMState = GetNextVdmCommand->VDMState;
CommandData->ComingFromBat = GetNextVdmCommand->fComingFromBat;
/* It was successful */
Success = TRUE;
Cleanup:
if (CaptureBuffer != NULL) CsrFreeCaptureBuffer(CaptureBuffer);
return Success;
}
/*
* @implemented
*/
DWORD
WINAPI
GetVDMCurrentDirectories(DWORD cchCurDirs, PCHAR lpszzCurDirs)
{
BASE_API_MESSAGE ApiMessage;
PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &ApiMessage.Data.VDMCurrentDirsRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
/* Allocate the capture buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, cchCurDirs);
if (CaptureBuffer == NULL)
{
BaseSetLastNTError(STATUS_NO_MEMORY);
return 0;
}
/* Setup the input parameters */
VDMCurrentDirsRequest->cchCurDirs = cchCurDirs;
CsrAllocateMessagePointer(CaptureBuffer,
cchCurDirs,
(PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs);
/* Call CSRSS */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepGetVDMCurDirs),
sizeof(*VDMCurrentDirsRequest));
/* Set the last error */
BaseSetLastNTError(ApiMessage.Status);
if (NT_SUCCESS(ApiMessage.Status))
{
/* Copy the result */
RtlMoveMemory(lpszzCurDirs, VDMCurrentDirsRequest->lpszzCurDirs, cchCurDirs);
}
/* Free the capture buffer */
CsrFreeCaptureBuffer(CaptureBuffer);
/* Return the size if it was successful, or if the buffer was too small */
return (NT_SUCCESS(ApiMessage.Status) || (ApiMessage.Status == STATUS_BUFFER_TOO_SMALL))
? VDMCurrentDirsRequest->cchCurDirs : 0;
}
/*
* @implemented (undocumented)
*/
BOOL
WINAPI
RegisterConsoleVDM(IN DWORD dwRegisterFlags,
IN HANDLE hStartHardwareEvent,
IN HANDLE hEndHardwareEvent,
IN HANDLE hErrorHardwareEvent,
IN DWORD dwUnusedVar,
OUT LPDWORD lpVideoStateLength,
OUT PVOID* lpVideoState, // PVIDEO_HARDWARE_STATE_HEADER*
IN PVOID lpUnusedBuffer,
IN DWORD dwUnusedBufferLength,
IN COORD dwVDMBufferSize,
OUT PVOID* lpVDMBuffer)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_REGISTERVDM RegisterVDMRequest = &ApiMessage.Data.RegisterVDMRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
/* Set up the data to send to the Console Server */
RegisterVDMRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
RegisterVDMRequest->RegisterFlags = dwRegisterFlags;
if (dwRegisterFlags != 0)
{
RegisterVDMRequest->StartHardwareEvent = hStartHardwareEvent;
RegisterVDMRequest->EndHardwareEvent = hEndHardwareEvent;
RegisterVDMRequest->ErrorHardwareEvent = hErrorHardwareEvent;
RegisterVDMRequest->VDMBufferSize = dwVDMBufferSize;
#if 0
RegisterVDMRequest->UnusedBufferLength = dwUnusedBufferLength;
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, dwUnusedBufferLength);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Capture the buffer to write */
CsrCaptureMessageBuffer(CaptureBuffer,
(PVOID)lpUnusedBuffer,
dwUnusedBufferLength,
(PVOID*)&RegisterVDMRequest->UnusedBuffer);
#endif
}
else
{
// CaptureBuffer = NULL;
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepRegisterVDM),
sizeof(*RegisterVDMRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Retrieve the results */
if (Success)
{
if (dwRegisterFlags != 0)
{
_SEH2_TRY
{
*lpVideoStateLength = RegisterVDMRequest->VideoStateLength;
*lpVideoState = RegisterVDMRequest->VideoState;
*lpVDMBuffer = RegisterVDMRequest->VDMBuffer;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
}
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
/* Return success status */
return Success;
}
/*
* @unimplemented
*/
BOOL
WINAPI
RegisterWowBaseHandlers (
DWORD Unknown0
)
{
STUB;
return FALSE;
}
/*
* @unimplemented
*/
BOOL
WINAPI
RegisterWowExec (
DWORD Unknown0
)
{
STUB;
return FALSE;
}
/*
* @implemented
*/
BOOL
WINAPI
SetVDMCurrentDirectories(DWORD cchCurDirs, PCHAR lpszzCurDirs)
{
BASE_API_MESSAGE ApiMessage;
PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &ApiMessage.Data.VDMCurrentDirsRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
/* Allocate the capture buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, cchCurDirs);
if (CaptureBuffer == NULL)
{
BaseSetLastNTError(STATUS_NO_MEMORY);
return FALSE;
}
/* Setup the input parameters */
VDMCurrentDirsRequest->cchCurDirs = cchCurDirs;
CsrCaptureMessageBuffer(CaptureBuffer,
lpszzCurDirs,
cchCurDirs,
(PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs);
/* Call CSRSS */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepSetVDMCurDirs),
sizeof(*VDMCurrentDirsRequest));
/* Free the capture buffer */
CsrFreeCaptureBuffer(CaptureBuffer);
/* Set the last error */
BaseSetLastNTError(ApiMessage.Status);
return NT_SUCCESS(ApiMessage.Status) ? TRUE : FALSE;
}
/*
* @unimplemented
*/
DWORD
WINAPI
VDMConsoleOperation (
DWORD Unknown0,
DWORD Unknown1
)
{
STUB;
return 0;
}
/*
* @unimplemented
*/
BOOL
WINAPI
VDMOperationStarted(IN ULONG Unknown0)
{
DPRINT1("VDMOperationStarted(%d)\n", Unknown0);
return BaseUpdateVDMEntry(VdmEntryUpdateControlCHandler,
NULL,
0,
Unknown0);
}
Reference in a new issue View git blame Copy permalink