+2002-11-03 Casper S. Hornstrup <chorns@users.sourceforge.net>\r
+\r
+ * apps/tests/lpc/lpcclt.c: Change LPC_MESSAGE_HEADER to LPC_MESSAGE.\r
+ * include/csrss/csrss.h: Ditto.\r
+ * include/lsass/lsass.h: Ditto.\r
+ * include/napi/dbg.h: Ditto.\r
+ * include/napi/lpc.h: Ditto.\r
+ * lib/kernel32/misc/console.c: Ditto.\r
+ * lib/ntdll/csr/lpc.c: Ditto.\r
+ * lib/ntdll/dbg/debug.c: Ditto.\r
+ * lib/secur32/lsa.c: Ditto.\r
+ * ntoskrnl/dbg/user.c: Ditto.\r
+ * ntoskrnl/include/internal/port.h: Ditto.\r
+ * ntoskrnl/lpc/connect.c: Ditto.\r
+ * ntoskrnl/lpc/reply.c: Ditto.\r
+ * ntoskrnl/ps/process.c: Ditto.\r
+ * subsys/csrss/api/conio.c: Ditto.\r
+ * subsys/csrss/api/process.c: Ditto.\r
+ * subsys/csrss/api/user.c: Ditto.\r
+\r
2002-10-26 Casper S. Hornstrup <chorns@users.sourceforge.net>\r
\r
* lib/msvcrt/except/seh.s: Fix end-of-line formatting.\r
ZeroMemory(& Request, sizeof Request);
strcpy(Request.Data, GetCommandLineA());
Request.Header.DataSize = strlen(Request.Data);
- Request.Header.MessageSize = sizeof(LPC_MESSAGE_HEADER) +
+ Request.Header.MessageSize = sizeof(LPC_MESSAGE) +
Request.Header.DataSize;
printf("%s: Sending to port 0x%x message \"%s\"...\n",
BOOLEAN STDCALL
ps2_mouse_handler(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
- // char tmpstr[100];
PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ServiceContext;
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
-
int state_dx, state_dy, state_buttons;
unsigned scancode;
unsigned status = controller_read_status();
scancode = controller_read_input();
- // Don't handle the mouse event if we aren't connected to the mouse class driver
- if(DeviceExtension->ClassInformation.CallBack == NULL) return FALSE;
+ /*
+ * Don't handle the mouse event if we aren't connected to the mouse class
+ * driver
+ */
+ if (DeviceExtension->ClassInformation.CallBack == NULL)
+ {
+ return FALSE;
+ }
- if((status & CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL) != 0)
- {
- // mouse_handle_event(scancode); proceed to handle it
- }
+ if ((status & CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL) != 0)
+ {
+ // mouse_handle_event(scancode); proceed to handle it
+ }
else
- {
- return FALSE; // keyboard_handle_event(scancode);
- }
+ {
+ return FALSE; // keyboard_handle_event(scancode);
+ }
if (mouse_replies_expected > 0)
- {
- if (scancode == MOUSE_ACK)
{
- mouse_replies_expected--;
- return;
+ if (scancode == MOUSE_ACK)
+ {
+ mouse_replies_expected--;
+ return;
+ }
+
+ mouse_replies_expected = 0;
}
-
- mouse_replies_expected = 0;
- }
/* Add this scancode to the mouse event queue. */
-
mouse_buffer[mouse_buffer_position] = scancode;
mouse_buffer_position++;
-
- // If the buffer is full, parse this event
+
+ /* If the buffer is full, parse this event */
if (mouse_buffer_position == 3)
- {
- mouse_buffer_position = 0;
- // system_call_debug_print_simple ("We got a mouse event");
-
- state_buttons = (mouse_buffer[0] & 1) * GPM_B_LEFT +
- (mouse_buffer[0] & 2) * GPM_B_RIGHT +
- (mouse_buffer[0] & 4) * GPM_B_MIDDLE;
-
- /* Some PS/2 mice send reports with negative bit set in data[0] and zero for movement. I think this is a
- bug in the mouse, but working around it only causes artifacts when the actual report is -256; they'll
- be treated as zero. This should be rare if the mouse sampling rate is set to a reasonable value; the
- default of 100 Hz is plenty. (Stephen Tell) */
-
- if (mouse_buffer[1] == 0)
- {
- state_dx = 0;
- }
- else
- {
- state_dx = (mouse_buffer[0] & 0x10) ?
- mouse_buffer[1] - 256 :
- mouse_buffer[1];
- }
-
- if (mouse_buffer[2] == 0)
- {
- state_dy = 0;
- }
- else
{
- state_dy = -((mouse_buffer[0] & 0x20) ?
- mouse_buffer[2] - 256 :
- mouse_buffer[2]);
- }
-
+ mouse_buffer_position = 0;
+
+ state_buttons = (mouse_buffer[0] & 1) * GPM_B_LEFT +
+ (mouse_buffer[0] & 2) * GPM_B_RIGHT +
+ (mouse_buffer[0] & 4) * GPM_B_MIDDLE;
+
+ /*
+ * Some PS/2 mice send reports with negative bit set in data[0] and zero
+ * for movement. I think this is a bug in the mouse, but working around
+ * it only causes artifacts when the actual report is -256; they'll
+ * be treated as zero. This should be rare if the mouse sampling rate is
+ * set to a reasonable value; the default of 100 Hz is plenty.
+ * (Stephen Tell)
+ */
+ if (mouse_buffer[1] == 0)
+ {
+ state_dx = 0;
+ }
+ else
+ {
+ state_dx = (mouse_buffer[0] & 0x10) ?
+ mouse_buffer[1] - 256 :
+ mouse_buffer[1];
+ }
+
+ if (mouse_buffer[2] == 0)
+ {
+ state_dy = 0;
+ }
+ else
+ {
+ state_dy = -((mouse_buffer[0] & 0x20) ?
+ mouse_buffer[2] - 256 :
+ mouse_buffer[2]);
+ }
+
if (((state_dx!=0) || (state_dy!=0) || (state_buttons!=0)))
- {
- // FIXME: Implement button state, see /include/ntddmous.h
-
- DeviceObject = (PDEVICE_OBJECT)ServiceContext;
- DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
-
- if (DeviceExtension->InputDataCount == MOUSE_BUFFER_SIZE)
- {
- return TRUE;
- }
-
- DeviceExtension->MouseInputData[DeviceExtension->InputDataCount].RawButtons = state_buttons;
- DeviceExtension->MouseInputData[DeviceExtension->InputDataCount].ButtonData = state_buttons;
- DeviceExtension->MouseInputData[DeviceExtension->InputDataCount].LastX = state_dx;
- DeviceExtension->MouseInputData[DeviceExtension->InputDataCount].LastY = state_dy;
- DeviceExtension->InputDataCount++;
-
- KeInsertQueueDpc(&DeviceExtension->IsrDpc, DeviceObject->CurrentIrp, NULL);
-
- return TRUE;
+ {
+ ULONG Queue;
+ PMOUSE_INPUT_DATA Input;
+
+ /* FIXME: Implement button state, see /include/ntddmous.h */
+
+ DeviceObject = (PDEVICE_OBJECT)ServiceContext;
+ DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ Queue = DeviceExtension->ActiveQueue % 2;
+
+ if (DeviceExtension->InputDataCount[Queue] == MOUSE_BUFFER_SIZE)
+ {
+ return TRUE;
+ }
+
+ Input = &DeviceExtension->MouseInputData[Queue]
+ [DeviceExtension->InputDataCount[Queue]];
+ Input->RawButtons = state_buttons;
+ Input->ButtonData = state_buttons;
+ Input->LastX = state_dx;
+ Input->LastY = state_dy;
+ DeviceExtension->InputDataCount[Queue]++;
+
+ KeInsertQueueDpc(&DeviceExtension->IsrDpc, DeviceObject->CurrentIrp,
+ NULL);
+ return TRUE;
}
}
}
has_mouse = TRUE;
- DeviceExtension->InputDataCount = 0;
- DeviceExtension->MouseInputData = ExAllocatePool(NonPagedPool, sizeof(MOUSE_INPUT_DATA) * MOUSE_BUFFER_SIZE);
+ DeviceExtension->InputDataCount[0] = 0;
+ DeviceExtension->InputDataCount[1] = 0;
+ DeviceExtension->ActiveQueue = 0;
// Enable the PS/2 mouse port
controller_write_command_word (CONTROLLER_COMMAND_MOUSE_ENABLE);
VOID PS2MouseInitializeDataQueue(PVOID Context)
{
- ;
-/* PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceExtension;
-
- DeviceExtension->InputDataCount = 0;
- DeviceExtension->MouseInputData = ExAllocatePool(NonPagedPool, sizeof(MOUSE_INPUT_DATA) * MOUSE_BUFFER_SIZE); */
}
NTSTATUS STDCALL
VOID PS2MouseIsrDpc(PKDPC Dpc, PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
+ ULONG Queue;
+ Queue = DeviceExtension->ActiveQueue % 2;
+ InterlockedIncrement(&DeviceExtension->ActiveQueue);
(*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->ClassInformation.CallBack)(
DeviceExtension->ClassInformation.DeviceObject,
- DeviceExtension->MouseInputData,
+ DeviceExtension->MouseInputData[Queue],
NULL,
- &DeviceExtension->InputDataCount);
-
- DeviceExtension->InputDataCount = 0;
+ &DeviceExtension->InputDataCount[Queue]);
+ DeviceExtension->InputDataCount[Queue] = 0;
}
NTSTATUS STDCALL
DeviceExtension = DeviceObject->DeviceExtension;
KeInitializeDpc(&DeviceExtension->IsrDpc, (PKDEFERRED_ROUTINE)PS2MouseIsrDpc, DeviceObject);
- KeInitializeDpc(&DeviceExtension->IsrDpcRetry, (PKDEFERRED_ROUTINE)PS2MouseIsrDpc, DeviceObject);
mouse_init(DeviceObject);
typedef struct _DEVICE_EXTENSION {
- PDEVICE_OBJECT DeviceObject;
- ULONG InputDataCount;
- PMOUSE_INPUT_DATA MouseInputData;
- CLASS_INFORMATION ClassInformation;
+ PDEVICE_OBJECT DeviceObject;
- PKINTERRUPT MouseInterrupt;
+ ULONG ActiveQueue;
+ ULONG InputDataCount[2];
+ MOUSE_INPUT_DATA MouseInputData[2][MOUSE_BUFFER_SIZE];
+
+ CLASS_INFORMATION ClassInformation;
+
+ PKINTERRUPT MouseInterrupt;
KDPC IsrDpc;
- KDPC IsrDpcRetry;
-
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
LONG
STDCALL
RegConnectRegistryA (
- LPSTR lpMachineName,
+ LPCSTR lpMachineName,
HKEY hKey,
PHKEY phkResult
);
STDCALL
RegQueryValueExA (
HKEY hKey,
- LPSTR lpValueName,
+ LPCSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
#define CSRSS_MAX_WRITE_CONSOLE_REQUEST \
(MAX_MESSAGE_DATA - sizeof(ULONG) - sizeof(CSRSS_WRITE_CONSOLE_REQUEST))
-#define CSRSS_MAX_SET_TITLE_REQUEST (MAX_MESSAGE_DATA - sizeof( HANDLE ) - sizeof( DWORD ) - sizeof( ULONG ) - sizeof( LPC_MESSAGE_HEADER ))
+#define CSRSS_MAX_SET_TITLE_REQUEST (MAX_MESSAGE_DATA - sizeof( HANDLE ) - sizeof( DWORD ) - sizeof( ULONG ) - sizeof( LPC_MESSAGE ))
#define CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR (MAX_MESSAGE_DATA - sizeof( ULONG ) - sizeof( CSRSS_WRITE_CONSOLE_OUTPUT_CHAR_REQUEST ))
/* Keep in sync with definition below. */
-#define CSRSS_REQUEST_HEADER_SIZE (sizeof(LPC_MESSAGE_HEADER) + sizeof(ULONG))
+#define CSRSS_REQUEST_HEADER_SIZE (sizeof(LPC_MESSAGE) + sizeof(ULONG))
typedef struct
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
ULONG Type;
union
{
typedef struct
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
NTSTATUS Status;
union
{
typedef struct _LSASS_REQUEST
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
ULONG Type;
union
{
typedef struct _LSASS_REPLY
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
NTSTATUS Status;
union
{
typedef struct _LPC_DBG_MESSAGE
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
ULONG Type;
ULONG Status;
union
CLIENT_ID Cid;
ULONG MessageId;
ULONG SharedSectionSize;
-} LPC_MESSAGE_HEADER, *PLPC_MESSAGE_HEADER;
+} LPC_MESSAGE, *PLPC_MESSAGE;
typedef struct _LPC_TERMINATION_MESSAGE
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
TIME CreationTime;
} LPC_TERMINATION_MESSAGE, *PLPC_TERMINATION_MESSAGE;
typedef struct _LPC_DEBUG_MESSAGE
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
ULONG EventCode;
ULONG Status;
union {
#endif
} LPC_DEBUG_MESSAGE, * PLPC_DEBUG_MESSAGE;
-typedef LPC_MESSAGE_HEADER LPC_MESSAGE, *PLPC_MESSAGE;
-
typedef struct _LPC_MAX_MESSAGE
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
BYTE Data[MAX_MESSAGE_DATA];
} LPC_MAX_MESSAGE, *PLPC_MAX_MESSAGE;
#define KERNEL_VERSION_MAJOR 0
#define KERNEL_VERSION_MINOR 0
-#define KERNEL_VERSION_PATCH_LEVEL 20
+#define KERNEL_VERSION_PATCH_LEVEL 21
/* Edit each time a new release is out: format is YYYYMMDD (UTC) */
-#define KERNEL_RELEASE_DATE 20020805L
+#define KERNEL_RELEASE_DATE 20021031L
#endif
#include <ntos/ps.h>
#include <ntos/disk.h>
#include <ntos/gditypes.h>
-
+/*
typedef struct _VALENT
{
LPTSTR ve_valuename;
DWORD ve_valueptr;
DWORD ve_type;
} VALENT, *PVALENT;
+ */
+typedef struct _VALENT_A {
+ LPSTR ve_valuename;
+ DWORD ve_valuelen;
+ DWORD ve_valueptr;
+ DWORD ve_type;
+} VALENTA, *PVALENTA;
+
+typedef struct _VALENT_W {
+ LPWSTR ve_valuename;
+ DWORD ve_valuelen;
+ DWORD ve_valueptr;
+ DWORD ve_type;
+} VALENTW, *PVALENTW;
+
+#ifdef UNICODE
+typedef VALENTW VALENT;
+typedef PVALENTW PVALENT;
+#else
+typedef VALENTA VALENT;
+typedef PVALENTA PVALENT;
+#endif
#ifndef WIN32_LEAN_AND_MEAN
STDCALL
RegQueryMultipleValuesW (
HKEY hKey,
- PVALENT val_list,
+ PVALENTW val_list,
DWORD num_vals,
LPWSTR lpValueBuf,
LPDWORD ldwTotsize
STDCALL
RegQueryValueExW (
HKEY hKey,
- LPWSTR lpValueName,
+ LPCWSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LONG
STDCALL
RegConnectRegistryW (
- LPWSTR lpMachineName,
+ LPCWSTR lpMachineName,
HKEY hKey,
PHKEY phkResult
);
* RegConnectRegistryA
*/
LONG STDCALL
-RegConnectRegistryA(LPSTR lpMachineName,
+RegConnectRegistryA(LPCSTR lpMachineName,
HKEY hKey,
PHKEY phkResult)
{
* RegConnectRegistryW
*/
LONG STDCALL
-RegConnectRegistryW(LPWSTR lpMachineName,
+RegConnectRegistryW(LPCWSTR lpMachineName,
HKEY hKey,
PHKEY phkResult)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SubKeyStringW;
ANSI_STRING SubKeyStringA;
- HANDLE ParentKey;
+// HANDLE ParentKey;
+ HKEY ParentKey;
HANDLE TargetKey;
NTSTATUS Status;
LONG ErrorCode;
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SubKeyString;
- HANDLE ParentKey;
+ HKEY ParentKey;
HANDLE TargetKey;
NTSTATUS Status;
LONG ErrorCode;
ANSI_STRING ValueNameA;
NTSTATUS Status;
LONG ErrorCode;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
Status = MapDefaultKey(&KeyHandle,
hKey);
UNICODE_STRING ValueName;
NTSTATUS Status;
LONG ErrorCode;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
Status = MapDefaultKey(&KeyHandle,
hKey);
DWORD dwError = ERROR_SUCCESS;
ULONG BufferSize;
ULONG ResultSize;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
Status = MapDefaultKey(&KeyHandle, hKey);
if (!NT_SUCCESS(Status))
BufferSize = sizeof (KEY_NODE_INFORMATION) + *lpcbName * sizeof(WCHAR);
if (lpClass)
BufferSize += *lpcbClass;
- KeyInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
+
+ //
+ // I think this is a memory leak, always allocated again below ???
+ //
+ // KeyInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
+ //
/* We don't know the exact size of the data returned, so call
NtEnumerateKey() with a buffer size determined from parameters
DWORD dwError = ERROR_SUCCESS;
ULONG BufferSize;
ULONG ResultSize;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
Status = MapDefaultKey(&KeyHandle, hKey);
if (!NT_SUCCESS(Status))
if (lpData)
{
memcpy(lpData,
- (PVOID)((ULONG_PTR)ValueInfo->Name + ValueInfo->DataOffset),
+ (PVOID)((ULONG_PTR)ValueInfo + ValueInfo->DataOffset),
ValueInfo->DataLength);
*lpcbData = (DWORD)ValueInfo->DataLength;
}
LONG STDCALL
RegFlushKey(HKEY hKey)
{
- HANDLE KeyHandle;
+ HKEY KeyHandle;
NTSTATUS Status;
LONG ErrorCode;
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SubKeyString;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
LONG ErrorCode;
NTSTATUS Status;
NTSTATUS errCode;
UNICODE_STRING SubKeyString;
OBJECT_ATTRIBUTES ObjectAttributes;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
LONG ErrorCode;
errCode = MapDefaultKey(&KeyHandle,
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SubKeyString;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
LONG ErrorCode;
NTSTATUS Status;
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING SubKeyString;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
LONG ErrorCode;
NTSTATUS Status;
KEY_FULL_INFORMATION FullInfoBuffer;
PKEY_FULL_INFORMATION FullInfo;
ULONG FullInfoSize;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
NTSTATUS Status;
LONG ErrorCode;
ULONG Length;
STDCALL
RegQueryMultipleValuesA(
HKEY hKey,
- PVALENT val_list,
+ PVALENTA val_list,
DWORD num_vals,
LPSTR lpValueBuf,
LPDWORD ldwTotsize
STDCALL
RegQueryMultipleValuesW(
HKEY hKey,
- PVALENT val_list,
+ PVALENTW val_list,
DWORD num_vals,
LPWSTR lpValueBuf,
LPDWORD ldwTotsize
STDCALL
RegQueryValueExA(
HKEY hKey,
- LPSTR lpValueName,
+ LPCSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
STDCALL
RegQueryValueExW(
HKEY hKey,
- LPWSTR lpValueName,
+ LPCWSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
DWORD dwError = ERROR_SUCCESS;
ULONG BufferSize;
ULONG ResultSize;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
DPRINT("hKey 0x%X lpValueName %S lpData 0x%X lpcbData %d\n",
hKey, lpValueName, lpData, lpcbData ? *lpcbData : 0);
NTSTATUS errCode;
UNICODE_STRING SubKeyString;
OBJECT_ATTRIBUTES ObjectAttributes;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
HANDLE RealKey;
LONG ErrorCode;
BOOL CloseRealKey;
UNICODE_STRING NtName;
IO_STATUS_BLOCK IoStatusBlock;
HANDLE FileHandle;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
NTSTATUS Status;
LONG ErrorCode;
{
UNICODE_STRING ValueName;
PUNICODE_STRING pValueName;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
NTSTATUS Status;
LONG ErrorCode;
NTSTATUS errCode;
UNICODE_STRING SubKeyString;
OBJECT_ATTRIBUTES ObjectAttributes;
- HANDLE KeyHandle;
+ HKEY KeyHandle;
HANDLE RealKey;
LONG ErrorCode;
BOOL CloseRealKey;
& Re.quest,
& Re.ply,
(sizeof (CSRSS_GET_TITLE_REQUEST) +
- sizeof (LPC_MESSAGE_HEADER) +
+ sizeof (LPC_MESSAGE) +
sizeof (ULONG)),
sizeof (CSRSS_API_REPLY)
);
&Reply,
sizeof(CSRSS_SET_TITLE_REQUEST) +
c +
- sizeof( LPC_MESSAGE_HEADER ) +
+ sizeof( LPC_MESSAGE ) +
sizeof( ULONG ),
sizeof(CSRSS_API_REPLY));
&Reply,
sizeof(CSRSS_SET_TITLE_REQUEST) +
c +
- sizeof( LPC_MESSAGE_HEADER ) +
+ sizeof( LPC_MESSAGE ) +
sizeof( ULONG ),
sizeof(CSRSS_API_REPLY));
return (STATUS_UNSUCCESSFUL);
}
- Request->Header.DataSize = Length - sizeof(LPC_MESSAGE_HEADER);
+ Request->Header.DataSize = Length - sizeof(LPC_MESSAGE);
Request->Header.MessageSize = Length;
Status = NtRequestWaitReplyPort(WindowsApiPort,
typedef struct _LPC_DBGSS_MESSAGE
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
ULONG Unknown1;
ULONG Unknown2;
ULONG Unknown3;
Reply = (PLSASS_REPLY)RawReply;
Request->Header.DataSize = sizeof(LSASS_REQUEST) + SubmitBufferLength -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Request->Header.MessageSize =
- Request->Header.DataSize + sizeof(LPC_MESSAGE_HEADER);
+ Request->Header.DataSize + sizeof(LPC_MESSAGE);
Request->Type = LSASS_REQUEST_CALL_AUTHENTICATION_PACKAGE;
Request->d.CallAuthenticationPackageRequest.AuthenticationPackage =
AuthenticationPackage;
Request = (PLSASS_REQUEST)RawRequest;
Request->Header.DataSize = sizeof(LSASS_REQUEST) + PackageName->Length -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Request->Header.MessageSize = Request->Header.DataSize +
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Request->Type = LSASS_REQUEST_LOOKUP_AUTHENTICATION_PACKAGE;
Status = NtRequestWaitReplyPort(LsaHandle,
UCHAR RawReply[MAX_MESSAGE_DATA];
NTSTATUS Status;
- RequestLength = sizeof(LSASS_REQUEST) - sizeof(LPC_MESSAGE_HEADER);
+ RequestLength = sizeof(LSASS_REQUEST) - sizeof(LPC_MESSAGE);
RequestLength = RequestLength + (OriginName->Length * sizeof(WCHAR));
RequestLength = RequestLength + AuthenticationInformationLength;
RequestLength = RequestLength +
Request->d.LogonUserRequest.SourceContext = *SourceContext;
Request->Type = LSASS_REQUEST_LOGON_USER;
- Request->Header.DataSize = RequestLength - sizeof(LPC_MESSAGE_HEADER);
- Request->Header.MessageSize = RequestLength + sizeof(LPC_MESSAGE_HEADER);
+ Request->Header.DataSize = RequestLength - sizeof(LPC_MESSAGE);
+ Request->Header.MessageSize = RequestLength + sizeof(LPC_MESSAGE);
Reply = (PLSASS_REPLY)RawReply;
Request.Type = LSASS_REQUEST_REGISTER_LOGON_PROCESS;
Request.Header.DataSize = sizeof(LSASS_REQUEST) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Request.Header.MessageSize = sizeof(LSASS_REQUEST);
Request.d.RegisterLogonProcessRequest.Length = LsaLogonProcessName->Length;
; $Header$
;
; $Log$
-; Revision 1.1 2002/10/31 14:31:06 lace
-; :pserver:cvsanon@mok.lvcm.com:/CVS/ReactOS reactos
+; Revision 1.2 2002/11/04 22:01:07 short
+; update for HEAD-2002110401
;
; Revision 1.4 2000/06/25 03:59:14 dwelch
;
# $Header$
#
# $Log$
-# Revision 1.1 2002/10/31 14:31:06 lace
-# :pserver:cvsanon@mok.lvcm.com:/CVS/ReactOS reactos
+# Revision 1.2 2002/11/04 22:01:07 short
+# update for HEAD-2002110401
#
# Revision 1.4 2000/06/25 03:59:14 dwelch
#
; $Header$
;
; $Log$
-; Revision 1.1 2002/10/31 14:31:06 lace
-; :pserver:cvsanon@mok.lvcm.com:/CVS/ReactOS reactos
+; Revision 1.2 2002/11/04 22:01:07 short
+; update for HEAD-2002110401
;
; Revision 1.4 2000/06/25 03:59:14 dwelch
;
Message.Header.MessageSize = sizeof(LPC_DBG_MESSAGE);
Message.Header.DataSize = sizeof(LPC_DBG_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Message.Type = DBG_EVENT_CREATE_THREAD;
Message.Status = STATUS_SUCCESS;
Message.Data.CreateThread.Reserved = 0;
Message.Header.MessageSize = sizeof(LPC_DBG_MESSAGE);
Message.Header.DataSize = sizeof(LPC_DBG_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Message.Type = DBG_EVENT_EXCEPTION;
Message.Status = STATUS_SUCCESS;
Message.Data.Exception.ExceptionRecord = Er;
typedef struct _EPORT_CONNECT_REQUEST_MESSAGE
{
- LPC_MESSAGE_HEADER MessageHeader;
+ LPC_MESSAGE MessageHeader;
PEPROCESS ConnectingProcess;
struct _SECTION_OBJECT* SendSectionObject;
LARGE_INTEGER SendSectionOffset;
typedef struct _EPORT_CONNECT_REPLY_MESSAGE
{
- LPC_MESSAGE_HEADER MessageHeader;
+ LPC_MESSAGE MessageHeader;
PVOID SendServerViewBase;
ULONG ReceiveClientViewSize;
PVOID ReceiveClientViewBase;
*/
RequestMessage->MessageHeader.DataSize =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
RequestMessage->MessageHeader.MessageSize =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength;
DPRINT("RequestMessageSize %d\n",
*/
if (LpcMessage != NULL)
{
- memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE_HEADER));
+ memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE));
memcpy(&CReply->ConnectData, (PVOID)(LpcMessage + 1),
LpcMessage->DataSize);
CReply->MessageHeader.MessageSize =
sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->DataSize;
CReply->MessageHeader.DataSize = CReply->MessageHeader.MessageSize -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
CReply->ConnectDataLength = LpcMessage->DataSize;
}
else
{
CReply->MessageHeader.MessageSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
CReply->MessageHeader.DataSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
CReply->ConnectDataLength = 0;
}
if (AcceptIt != 1)
if (Request->Message.MessageType == LPC_CONNECTION_REQUEST)
{
- LPC_MESSAGE_HEADER Header;
+ LPC_MESSAGE Header;
PEPORT_CONNECT_REQUEST_MESSAGE CRequest;
CRequest = (PEPORT_CONNECT_REQUEST_MESSAGE)&Request->Message;
- memcpy(&Header, &Request->Message, sizeof(LPC_MESSAGE_HEADER));
+ memcpy(&Header, &Request->Message, sizeof(LPC_MESSAGE));
Header.DataSize = CRequest->ConnectDataLength;
- Header.MessageSize = Header.DataSize + sizeof(LPC_MESSAGE_HEADER);
+ Header.MessageSize = Header.DataSize + sizeof(LPC_MESSAGE);
Status = MmCopyToCaller(LpcMessage, &Header, sizeof(LPC_MESSAGE));
if (!NT_SUCCESS(Status))
{
Message.Header.MessageSize = sizeof(LPC_DBG_MESSAGE);
Message.Header.DataSize = sizeof(LPC_DBG_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Message.Type = DBG_EVENT_CREATE_PROCESS;
Message.Data.CreateProcess.FileHandle = FileHandle;
Message.Data.CreateProcess.Base = ImageBase;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
if( ProcessData->Console )
{
Reply->Status = STATUS_INVALID_PARAMETER;
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Reply->Status = STATUS_NOT_IMPLEMENTED;
nNumberOfCharsToRead = Request->Data.ReadConsoleRequest.NrCharactersToRead > CSRSS_MAX_READ_CONSOLE_REQUEST ? CSRSS_MAX_READ_CONSOLE_REQUEST : Request->Data.ReadConsoleRequest.NrCharactersToRead;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = Reply->Header.MessageSize -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Buffer = Reply->Data.ReadConsoleReply.Buffer;
Reply->Data.ReadConsoleReply.EventHandle = ProcessData->ConsoleEvent;
LOCK;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
if( !NT_SUCCESS( CsrGetObject( ProcessData, Request->Data.WriteConsoleRequest.ConsoleHandle,
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
if( !NT_SUCCESS( CsrGetObject( ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle,
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
if( !NT_SUCCESS( CsrGetObject( ProcessData, Request->Data.SetCursorRequest.ConsoleHandle,
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
if( !NT_SUCCESS( CsrGetObject( ProcessData, Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle, (Object_t **)&Buff ) ) || Buff->Header.Type != CSRSS_SCREEN_BUFFER_MAGIC )
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
if( !NT_SUCCESS( CsrGetObject( ProcessData, Request->Data.FillOutputRequest.ConsoleHandle, (Object_t **)&Buff ) ) || Buff->Header.Type != CSRSS_SCREEN_BUFFER_MAGIC )
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Reply->Data.ReadInputReply.Event = ProcessData->ConsoleEvent;
LOCK;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? 0 : STATUS_INVALID_HANDLE ))
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.FillOutputAttribRequest.ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? 0 : STATUS_INVALID_HANDLE ))
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? 0 : STATUS_INVALID_HANDLE ))
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData,
Request->Data.SetCursorInfoRequest.ConsoleHandle, (Object_t **)&Buff );
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.SetAttribRequest.ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? 0 : STATUS_INVALID_HANDLE ))
PCSRSS_SCREEN_BUFFER Buff;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData,
Request->Data.SetConsoleModeRequest.ConsoleHandle,
PCSRSS_SCREEN_BUFFER Buff; /* gee, I really wish I could use an anonymous union here */
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData,
Request->Data.GetConsoleModeRequest.ConsoleHandle,
NTSTATUS Status;
Reply->Header.MessageSize = sizeof( CSRSS_API_REPLY );
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
if( !Buff )
Reply->Status = STATUS_INSUFFICIENT_RESOURCES;
LOCK;
PCSRSS_SCREEN_BUFFER Buff;
Reply->Header.MessageSize = sizeof( CSRSS_API_REPLY );
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.SetActiveScreenBufferRequest.OutputHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) )
PCSRSS_CONSOLE Console;
Reply->Header.MessageSize = sizeof( CSRSS_API_REPLY );
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.SetTitleRequest.Console, (Object_t **)&Console );
if( !NT_SUCCESS( Status ) )
Reply->Header.MessageSize = sizeof (CSRSS_API_REPLY);
Reply->Header.DataSize =
sizeof (CSRSS_API_REPLY)
- - sizeof(LPC_MESSAGE_HEADER);
+ - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject (
ProcessData,
DWORD PSize;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.WriteConsoleOutputRequest.ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? STATUS_SUCCESS : STATUS_INVALID_HANDLE ))
NTSTATUS Status;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, Request->Data.FlushInputBufferRequest.ConsoleInput, (Object_t **)&Console );
if( !NT_SUCCESS( Status ) || (Status = Console->Header.Type == CSRSS_CONSOLE_MAGIC ? STATUS_SUCCESS : STATUS_INVALID_HANDLE ))
ALIAS(Fill,Request->Data.ScrollConsoleScreenBufferRequest.Fill);
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
Status = CsrGetObject( ProcessData, ConsoleHandle, (Object_t **)&Buff );
if( !NT_SUCCESS( Status ) || (Status = Buff->Header.Type == CSRSS_SCREEN_BUFFER_MAGIC ? STATUS_SUCCESS : STATUS_INVALID_HANDLE ))
DWORD i;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE);
ReadBuffer = Reply->Data.ReadConsoleOutputCharReply.String;
LOCK;
DWORD i;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE);
ReadBuffer = Reply->Data.ReadConsoleOutputAttribReply.String;
LOCK;
DWORD NumEvents;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = Reply->Header.MessageSize - sizeof(LPC_MESSAGE);
LOCK;
UINT NumItems;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
- Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE_HEADER);
+ Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
LOCK;
HANDLE Process;
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
NewProcessData = CsrGetProcessData(Request->Data.CreateProcessRequest.NewProcessId);
NTSTATUS Status;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY)
- - sizeof(LPC_MESSAGE_HEADER);
+ - sizeof(LPC_MESSAGE);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY);
Status = CsrFreeProcessData(ProcessData->ProcessId);
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Reply->Status = STATUS_SUCCESS;
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
Reply->Data.GetShutdownParametersReply.Level = ProcessData->ShutdownLevel;
Reply->Data.GetShutdownParametersReply.Flags = ProcessData->ShutdownFlags;
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
ProcessData->ShutdownLevel = Request->Data.SetShutdownParametersRequest.Level;
ProcessData->ShutdownFlags = Request->Data.SetShutdownParametersRequest.Flags;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
if (ServicesProcessIdValid == TRUE)
{
{
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
va_list ap;
COORD coPos;
-CHECKPOINT1;
va_start(ap, fmt);
vsprintf(buffer, fmt, ap);
va_end(ap);
-CHECKPOINT1;
-DPRINT1("%s\n", buffer);
-CHECKPOINT1;
coPos.X = x;
coPos.Y = y;
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/*
+/* $Id$
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS text-mode setup
* FILE: subsys/system/usetup/drivesup.c
}
-#if 0
CHAR
-GetDriveLetter(IN ULONG DriveNumber,
- IN ULONG PartitionNumber)
+GetDriveLetter(ULONG DriveNumber,
+ ULONG PartitionNumber)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING LinkName;
WCHAR LinkBuffer[8];
- WCHAR Letter;
+ CHAR Letter;
HANDLE LinkHandle;
UNICODE_STRING TargetName;
- WCHAR TargetBuffer[MAX_PATH];
-// WCHAR DeviceBuffer[MAX_PATH];
+ PWCHAR TargetBuffer;
+ PWCHAR DeviceBuffer;
ULONG Length;
+ NTSTATUS Status;
- wcscpy(LinkBuffer,
- L"\\??\\A:");
+ wcscpy(LinkBuffer, L"\\??\\A:");
RtlInitUnicodeString(&LinkName,
LinkBuffer);
NULL,
NULL);
+ TargetBuffer = RtlAllocateHeap(ProcessHeap, 0, MAX_PATH * sizeof(WCHAR));
+ DeviceBuffer = RtlAllocateHeap(ProcessHeap, 0, MAX_PATH * sizeof(WCHAR));
+
TargetName.Length = 0;
TargetName.MaximumLength = MAX_PATH * sizeof(WCHAR);
TargetName.Buffer = TargetBuffer;
- for (Letter = L'C'; Letter <= L'Z'; Letter++)
+ swprintf(DeviceBuffer,
+ L"\\Device\\Harddisk%lu\\Partition%lu",
+ DriveNumber,
+ PartitionNumber);
+
+ for (Letter = 'C'; Letter <= 'Z'; Letter++)
{
- LinkBuffer[4] = Letter;
+ LinkBuffer[4] = (WCHAR)Letter;
TargetName.Length = 0;
Status = NtOpenSymbolicLinkObject(&LinkHandle,
Status = NtQuerySymbolicLinkObject(LinkHandle,
&TargetName,
&Length);
+ NtClose(LinkHandle);
if (NT_SUCCESS(Status))
{
-
-
-
+ if (_wcsicmp(DeviceBuffer, TargetBuffer) == 0)
+ {
+ RtlFreeHeap(ProcessHeap, 0, DeviceBuffer);
+ RtlFreeHeap(ProcessHeap, 0, TargetBuffer);
+ return(Letter);
+ }
}
- NtClose(LinkHandle);
}
}
- return((CHAR)0);
-}
-#endif
-
-#if 0
-STATUS
-GetFileSystem()
-{
+ RtlFreeHeap(ProcessHeap, 0, DeviceBuffer);
+ RtlFreeHeap(ProcessHeap, 0, TargetBuffer);
+ return((CHAR)0);
}
-#endif
/* EOF */
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/*
+/* $Id$
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS text-mode setup
* FILE: subsys/system/usetup/drivesup.h
GetSourcePaths(PUNICODE_STRING SourcePath,
PUNICODE_STRING SourceRootPath);
+CHAR
+GetDriveLetter(ULONG DriveNumber,
+ ULONG PartitionNumber);
+
#endif /* __DRIVESUP_H__ */
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/*
+/* $Id$
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS text-mode setup
* FILE: subsys/system/usetup/partlist.c
#include "usetup.h"
#include "console.h"
#include "partlist.h"
+#include "drivesup.h"
/* FUNCTIONS ****************************************************************/
List->DiskArray[DiskCount].PartArray[i].PartSize = LayoutBuffer->PartitionEntry[i].PartitionLength.QuadPart;
List->DiskArray[DiskCount].PartArray[i].PartNumber = LayoutBuffer->PartitionEntry[i].PartitionNumber,
List->DiskArray[DiskCount].PartArray[i].PartType = LayoutBuffer->PartitionEntry[i].PartitionType;
+
+ List->DiskArray[DiskCount].PartArray[i].DriveLetter = GetDriveLetter(DiskCount,
+ LayoutBuffer->PartitionEntry[i].PartitionNumber);
+
List->DiskArray[DiskCount].PartArray[i].Used = TRUE;
}
else
Unit = "kB";
}
- sprintf(LineBuffer,
- "%d: nr: %d type: %x (%s) %I64u %s",
- PartIndex,
- PartEntry->PartNumber,
- PartEntry->PartType,
- PartType,
- PartSize,
- Unit);
-
+ if (PartEntry->DriveLetter != (CHAR)0)
+ {
+ sprintf(LineBuffer,
+ "%c: %d: nr: %d type: %x (%s) %I64u %s",
+ PartEntry->DriveLetter,
+ PartIndex,
+ PartEntry->PartNumber,
+ PartEntry->PartType,
+ PartType,
+ PartSize,
+ Unit);
+ }
+ else
+ {
+ sprintf(LineBuffer,
+ " %d: nr: %d type: %x (%s) %I64u %s",
+ PartIndex,
+ PartEntry->PartNumber,
+ PartEntry->PartType,
+ PartType,
+ PartSize,
+ Unit);
+ }
Attribute = (List->CurrentDisk == DiskIndex &&
List->CurrentPartition == PartIndex) ? 0x71 : 0x17;
Data->PartNumber = List->DiskArray[List->CurrentDisk].PartArray[List->CurrentPartition].PartNumber;
Data->PartType = List->DiskArray[List->CurrentDisk].PartArray[List->CurrentPartition].PartType;
+ Data->DriveLetter = List->DiskArray[List->CurrentDisk].PartArray[List->CurrentPartition].DriveLetter;
+
return(TRUE);
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/*
+/* $Id$
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS text-mode setup
* FILE: subsys/system/usetup/partlist.h
USHORT Port;
USHORT Bus;
USHORT Id;
+
ULONGLONG PartSize;
ULONG PartNumber;
ULONG PartType;
+
+ CHAR DriveLetter;
} PARTDATA, *PPARTDATA;
ULONGLONG PartSize;
ULONG PartNumber;
ULONG PartType;
+
CHAR DriveLetter;
BOOL Used;
} PARTENTRY, *PPARTENTRY;
ScrollUpPartitionList(PPARTLIST List);
BOOL
-GetPartitionData(PPARTLIST List, PPARTDATA Data);
+GetPartitionData(PPARTLIST List,
+ PPARTDATA Data);
#endif /* __PARTLIST_H__ */
/*
- * First setup page
+ * Start page
* RETURNS
- * TRUE: setup/repair completed successfully
- * FALSE: setup/repair terminated by user
+ * Number of the next page.
*/
static ULONG
StartPage(PINPUT_RECORD Ir)
{
ConInKey(Ir);
- if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
+ if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(REBOOT_PAGE);
}
else if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)) /* ESC */
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)) /* ESC */
{
return(INTRO_PAGE);
}
SetTextXY(8, 15, "\xf9 Press ENTER to install ReactOS.");
- SetTextXY(8, 17, "\xf9 Press R to repair ReactOS.");
+ SetTextXY(8, 17, "\xf9 Press E to start the emergency repair console.");
+
+ SetTextXY(8, 19, "\xf9 Press R to repair ReactOS.");
- SetTextXY(8, 19, "\xf9 Press F3 to quit without installing ReactOS.");
+ SetTextXY(8, 21, "\xf9 Press F3 to quit without installing ReactOS.");
SetStatusText(" ENTER = Continue F3 = Quit");
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
break;
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(INSTALL_INTRO_PAGE);
}
- else if (toupper(Ir->Event.KeyEvent.uChar.AsciiChar) == 'R') /* R */
+#if 0
+ else if (toupper(Ir->Event.KeyEvent.uChar.AsciiChar) == 'E') /* E */
+ {
+ return(RepairConsole());
+ }
+#endif
+ else if (toupper(Ir->Event.KeyEvent.uChar.AsciiChar) == 'R') /* R */
{
return(REPAIR_INTRO_PAGE);
}
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
break;
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(SELECT_PARTITION_PAGE);
}
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
{
break;
}
else if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_DOWN))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_DOWN)) /* DOWN */
{
ScrollDownPartitionList(PartList);
}
else if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_UP))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_UP)) /* UP */
{
ScrollUpPartitionList(PartList);
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
PartDataValid = GetPartitionData(PartList, &PartData);
DestroyPartitionList(PartList);
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
break;
}
else if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)) /* ESC */
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)) /* ESC */
{
return(SELECT_PARTITION_PAGE);
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(CHECK_FILE_SYSTEM_PAGE);
}
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
return(QUIT_PAGE);
break;
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(FILE_COPY_PAGE);
}
return(QUIT_PAGE);
break;
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(INIT_SYSTEM_PAGE);
}
ConInKey(Ir);
if ((Ir->Event.KeyEvent.uChar.AsciiChar == 0x00) &&
- (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3))
+ (Ir->Event.KeyEvent.wVirtualKeyCode == VK_F3)) /* F3 */
{
if (ConfirmQuit(Ir) == TRUE)
return(QUIT_PAGE);
break;
}
- else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ else if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(SUCCESS_PAGE);
}
{
ConInKey(Ir);
- if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(REBOOT_PAGE);
}
{
ConInKey(Ir);
- if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D)
+ if (Ir->Event.KeyEvent.uChar.AsciiChar == 0x0D) /* ENTER */
{
return(REBOOT_PAGE);
}
tmp = HazardY2; HazardY2 = HazardY1; HazardY1 = tmp;
}
- if ((mouse_x + mouse_width >= HazardX1) && (mouse_x <= HazardX2) &&
- (mouse_y + mouse_height >= HazardY1) && (mouse_y <= HazardY2))
+ if (((mouse_x + mouse_width) >= HazardX1) && (mouse_x <= HazardX2) &&
+ ((mouse_y + mouse_height) >= HazardY1) && (mouse_y <= HazardY2))
{
SurfGDI->MovePointer(SurfObj, -1, -1, &MouseRect);
SafetySwitch = TRUE;
*HitTest = WinPosWindowFromPoint(ScopeWin, Message->Msg.pt, &Window);
+ if (Window == NULL)
+ {
+ ExFreePool(Message);
+ return(FALSE);
+ }
if (Window->MessageQueue != PsGetWin32Thread()->MessageQueue)
{
ExAcquireFastMutex(&Window->MessageQueue->Lock);
return(HitTest);
}
+ if ((*Window) == NULL)
+ {
+ return(HTNOWHERE);
+ }
if ((*Window)->MessageQueue == PsGetWin32Thread()->MessageQueue)
{
HitTest = W32kSendMessage((*Window)->Self, WM_NCHITTEST, 0,