Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-23 17:05:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

CSRSS code reshuffle

Browse source 
svn path=/trunk/; revision=6845
This commit is contained in:
Gé van Geldorp 2003-12-02 11:38:47 +00:00
parent ea6699f39e
commit 4e366db69f
35 changed files with 1402 additions and 937 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
reactos/bootdata/packages/reactos.dff
View file

@ -71,7 +71,7 @@ lib\ws2help\ws2help.dll 1
lib\wshirda\wshirda.dll 1
lib\wsock32\wsock32.dll 1
subsys\csrss\csrss.exe 1
subsys\csrss\usercsr\usercsr.dll 1
subsys\csrss\win32csr\win32csr.dll 1
subsys\ntvdm\ntvdm.exe 1
subsys\smss\smss.exe 1
subsys\win32k\win32k.sys 1

122
reactos/include/csrss/csrss.h
View file

@ -36,6 +36,14 @@ typedef struct
HANDLE OutputHandle;
} CSRSS_CREATE_PROCESS_REPLY, *PCSRSS_CREATE_PROCESS_REPLY;
typedef struct
{
} CSRSS_TERMINATE_PROCESS_REQUEST, PCSRSS_TERMINATE_PROCESS_REQUEST;
typedef struct
{
} CSRSS_TERMINATE_PROCESS_REPLY, PCSRSS_TERMINATE_PROCESS_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -73,6 +81,14 @@ typedef struct
HANDLE OutputHandle;
} CSRSS_ALLOC_CONSOLE_REPLY, *PCSRSS_ALLOC_CONSOLE_REPLY;
typedef struct
{
} CSRSS_FREE_CONSOLE_REQUEST, *PCSRSS_FREE_CONSOLE_REQUEST;
typedef struct
{
} CSRSS_FREE_CONSOLE_REPLY, *PCSRSS_FREE_CONSOLE_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -89,6 +105,10 @@ typedef struct
COORD Position;
} CSRSS_SET_CURSOR_REQUEST, *PCSRSS_SET_CURSOR_REQUEST;
typedef struct
{
} CSRSS_SET_CURSOR_REPLY, *PCSRSS_SET_CURSOR_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -97,6 +117,10 @@ typedef struct
WORD Length;
} CSRSS_FILL_OUTPUT_REQUEST, *PCSRSS_FILL_OUTPUT_REQUEST;
typedef struct
{
} CSRSS_FILL_OUTPUT_REPLY, *PCSRSS_FILL_OUTPUT_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -105,6 +129,10 @@ typedef struct
WORD Length;
} CSRSS_FILL_OUTPUT_ATTRIB_REQUEST, *PCSRSS_FILL_OUTPUT_ATTRIB_REQUEST;
typedef struct
{
} CSRSS_FILL_OUTPUT_ATTRIB_REPLY, *PCSRSS_FILL_OUTPUT_ATTRIB_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -159,18 +187,30 @@ typedef struct
CONSOLE_CURSOR_INFO Info;
} CSRSS_SET_CURSOR_INFO_REQUEST, *PCSRSS_SET_CURSOR_INFO_REQUEST;
typedef struct
{
} CSRSS_SET_CURSOR_INFO_REPLY, *PCSRSS_SET_CURSOR_INFO_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
CHAR Attrib;
} CSRSS_SET_ATTRIB_REQUEST, *PCSRSS_SET_ATTRIB_REQUEST;
typedef struct
{
} CSRSS_SET_ATTRIB_REPLY, *PCSRSS_SET_ATTRIB_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
DWORD Mode;
} CSRSS_SET_CONSOLE_MODE_REQUEST, *PCSRSS_SET_CONSOLE_MODE_REQUEST;
typedef struct
{
} CSRSS_SET_CONSOLE_MODE_REPLY, *PCSRSS_SET_CONSOLE_MODE_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -194,7 +234,11 @@ typedef struct
typedef struct
{
HANDLE OutputHandle; /* handle to screen buffer to switch to */
} CSRSS_SET_ACTIVE_SCREEN_BUFFER_REQUEST, *PCSRSS_SET_ACTIVE_SCREEN_BUFFER_REQUEST;
} CSRSS_SET_SCREEN_BUFFER_REQUEST, *PCSRSS_SET_SCREEN_BUFFER_REQUEST;
typedef struct
{
} CSRSS_SET_SCREEN_BUFFER_REPLY, *PCSRSS_SET_SCREEN_BUFFER_REPLY;
typedef struct
{
@ -213,6 +257,10 @@ typedef struct
WCHAR Title[1];
} CSRSS_SET_TITLE_REQUEST, *PCSRSS_SET_TITLE_REQUEST;
typedef struct
{
} CSRSS_SET_TITLE_REPLY, *PCSRSS_SET_TITLE_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -244,6 +292,10 @@ typedef struct
HANDLE ConsoleInput;
} CSRSS_FLUSH_INPUT_BUFFER_REQUEST, *PCSRSS_FLUSH_INPUT_BUFFER_REQUEST;
typedef struct
{
} CSRSS_FLUSH_INPUT_BUFFER_REPLY, *PCSRSS_FLUSH_INPUT_BUFFER_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -254,6 +306,10 @@ typedef struct
CHAR_INFO Fill;
} CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER_REQUEST, *PCSRSS_SCROLL_CONSOLE_SCREEN_BUFFER_REQUEST;
typedef struct
{
} CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER_REPLY, *PCSRSS_SCROLL_CONSOLE_SCREEN_BUFFER_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
@ -295,17 +351,39 @@ typedef struct
DWORD ProcessId;
} CSRSS_REGISTER_SERVICES_PROCESS_REQUEST, *PCSRSS_REGISTER_SERVICES_PROCESS_REQUEST;
typedef struct
{
} CSRSS_REGISTER_SERVICES_PROCESS_REPLY, *PCSRSS_REGISTER_SERVICES_PROCESS_REPLY;
typedef struct
{
UINT Flags;
DWORD Reserved;
} CSRSS_EXIT_REACTOS_REQUEST, *PCSRSS_EXIT_REACTOS_REQUEST;
typedef struct
{
} CSRSS_EXIT_REACTOS_REPLY, *PCSRSS_EXIT_REACTOS_REPLY;
typedef struct
{
DWORD Level;
DWORD Flags;
} CSRSS_SHUTDOWN_PARAMETERS, *PCSRSS_SHUTDOWN_PARAMETERS;
} CSRSS_SET_SHUTDOWN_PARAMETERS_REQUEST, *PCSRSS_SET_SHUTDOWN_PARAMETERS_REQUEST;
typedef struct
{
} CSRSS_SET_SHUTDOWN_PARAMETERS_REPLY, *PCSRSS_SET_SHUTDOWN_PARAMETERS_REPLY;
typedef struct
{
} CSRSS_GET_SHUTDOWN_PARAMETERS_REQUEST, *PCSRSS_GET_SHUTDOWN_PARAMETERS_REQUEST;
typedef struct
{
DWORD Level;
DWORD Flags;
} CSRSS_GET_SHUTDOWN_PARAMETERS_REPLY, *PCSRSS_GET_SHUTDOWN_PARAMETERS_REPLY;
typedef struct
{
@ -345,11 +423,19 @@ typedef struct
DWORD Length;
} CSRSS_WRITE_CONSOLE_INPUT_REPLY, *PCSRSS_WRITE_CONSOLE_INPUT_REPLY;
typedef struct
{
} CSRSS_GET_INPUT_HANDLE_REQUEST, *PCSRSS_GET_INPUT_HANDLE_REQUEST;
typedef struct
{
HANDLE InputHandle;
} CSRSS_GET_INPUT_HANDLE_REPLY, *PCSRSS_GET_INPUT_HANDLE_REPLY;
typedef struct
{
} CSRSS_GET_OUTPUT_HANDLE_REQUEST, *PCSRSS_GET_OUTPUT_HANDLE_REQUEST;
typedef struct
{
HANDLE OutputHandle;
@ -360,11 +446,19 @@ typedef struct
HANDLE Handle;
} CSRSS_CLOSE_HANDLE_REQUEST, *PCSRSS_CLOSE_HANDLE_REQUEST;
typedef struct
{
} CSRSS_CLOSE_HANDLE_REPLY, *PCSRSS_CLOSE_HANDLE_REPLY;
typedef struct
{
HANDLE Handle;
} CSRSS_VERIFY_HANDLE_REQUEST, *PCSRSS_VERIFY_HANDLE_REQUEST;
typedef struct
{
} CSRSS_VERIFY_HANDLE_REPLY, *PCSRSS_VERIFY_HANDLE_REPLY;
typedef struct
{
HANDLE Handle;
@ -387,8 +481,14 @@ typedef struct
HANDLE ConsoleHandle;
DWORD SetGet; /* 0=get; 1=set */
DWORD State;
} CSRSS_SETGET_CONSOLE_HW_STATE_REQUEST, *PCSRSS_SETGET_CONSOLE_HW_STATE_REQUEST;
} CSRSS_CONSOLE_HARDWARE_STATE, *PCSRSS_CONSOLE_HARDWARE_STATE;
typedef struct
{
HANDLE ConsoleHandle;
DWORD SetGet; /* 0=get; 1=set */
DWORD State;
} CSRSS_SETGET_CONSOLE_HW_STATE_REPLY, *PCSRSS_SETGET_CONSOLE_HW_STATE_REPLY;
typedef struct
{
@ -431,8 +531,8 @@ typedef struct
#define CSRSS_GET_CURSOR_INFO (0xE)
#define CSRSS_SET_CURSOR_INFO (0xF)
#define CSRSS_SET_ATTRIB (0x10)
#define CSRSS_GET_MODE (0x11)
#define CSRSS_SET_MODE (0x12)
#define CSRSS_GET_CONSOLE_MODE (0x11)
#define CSRSS_SET_CONSOLE_MODE (0x12)
#define CSRSS_CREATE_SCREEN_BUFFER (0x13)
#define CSRSS_SET_SCREEN_BUFFER (0x14)
#define CSRSS_SET_TITLE (0x15)
@ -485,7 +585,7 @@ typedef struct
CSRSS_SET_CONSOLE_MODE_REQUEST SetConsoleModeRequest;
CSRSS_GET_CONSOLE_MODE_REQUEST GetConsoleModeRequest;
CSRSS_CREATE_SCREEN_BUFFER_REQUEST CreateScreenBufferRequest;
CSRSS_SET_ACTIVE_SCREEN_BUFFER_REQUEST SetActiveScreenBufferRequest;
CSRSS_SET_SCREEN_BUFFER_REQUEST SetScreenBufferRequest;
CSRSS_SET_TITLE_REQUEST SetTitleRequest;
CSRSS_GET_TITLE_REQUEST GetTitleRequest;
CSRSS_WRITE_CONSOLE_OUTPUT_REQUEST WriteConsoleOutputRequest;
@ -497,14 +597,15 @@ typedef struct
CSRSS_GET_NUM_INPUT_EVENTS_REQUEST GetNumInputEventsRequest;
CSRSS_REGISTER_SERVICES_PROCESS_REQUEST RegisterServicesProcessRequest;
CSRSS_EXIT_REACTOS_REQUEST ExitReactosRequest;
CSRSS_SHUTDOWN_PARAMETERS SetShutdownParametersRequest;
CSRSS_SET_SHUTDOWN_PARAMETERS_REQUEST SetShutdownParametersRequest;
CSRSS_GET_SHUTDOWN_PARAMETERS_REQUEST GetShutdownParametersRequest;
CSRSS_PEEK_CONSOLE_INPUT_REQUEST PeekConsoleInputRequest;
CSRSS_READ_CONSOLE_OUTPUT_REQUEST ReadConsoleOutputRequest;
CSRSS_WRITE_CONSOLE_INPUT_REQUEST WriteConsoleInputRequest;
CSRSS_CLOSE_HANDLE_REQUEST CloseHandleRequest;
CSRSS_VERIFY_HANDLE_REQUEST VerifyHandleRequest;
CSRSS_DUPLICATE_HANDLE_REQUEST DuplicateHandleRequest;
CSRSS_CONSOLE_HARDWARE_STATE ConsoleHardwareStateRequest;
CSRSS_SETGET_CONSOLE_HW_STATE_REQUEST ConsoleHardwareStateRequest;
CSRSS_CONSOLE_WINDOW ConsoleWindowRequest;
} Data;
} CSRSS_API_REQUEST, *PCSRSS_API_REQUEST;
@ -532,14 +633,15 @@ typedef struct
CSRSS_READ_CONSOLE_OUTPUT_CHAR_REPLY ReadConsoleOutputCharReply;
CSRSS_READ_CONSOLE_OUTPUT_ATTRIB_REPLY ReadConsoleOutputAttribReply;
CSRSS_GET_NUM_INPUT_EVENTS_REPLY GetNumInputEventsReply;
CSRSS_SHUTDOWN_PARAMETERS GetShutdownParametersReply;
CSRSS_SET_SHUTDOWN_PARAMETERS_REPLY SetShutdownParametersReply;
CSRSS_GET_SHUTDOWN_PARAMETERS_REPLY GetShutdownParametersReply;
CSRSS_PEEK_CONSOLE_INPUT_REPLY PeekConsoleInputReply;
CSRSS_READ_CONSOLE_OUTPUT_REPLY ReadConsoleOutputReply;
CSRSS_WRITE_CONSOLE_INPUT_REPLY WriteConsoleInputReply;
CSRSS_GET_INPUT_HANDLE_REPLY GetInputHandleReply;
CSRSS_GET_OUTPUT_HANDLE_REPLY GetOutputHandleReply;
CSRSS_DUPLICATE_HANDLE_REPLY DuplicateHandleReply;
CSRSS_CONSOLE_HARDWARE_STATE ConsoleHardwareStateReply;
CSRSS_SETGET_CONSOLE_HW_STATE_REPLY ConsoleHardwareStateReply;
CSRSS_CONSOLE_WINDOW ConsoleWindowReply;
} Data;
} CSRSS_API_REPLY, *PCSRSS_API_REPLY;

4
reactos/include/ntdll/csr.h
View file

@ -1,4 +1,4 @@
/* $Id: csr.h,v 1.7 2001/12/02 23:34:39 dwelch Exp $
/* $Id: csr.h,v 1.8 2003/12/02 11:38:46 gvg Exp $
*
*/
@ -33,6 +33,8 @@ CsrCaptureParameterBuffer(PVOID ParameterBuffer,
NTSTATUS STDCALL
CsrReleaseParameterBuffer(PVOID ClientAddress);
VOID STDCALL CsrIsCsrss(VOID);
#endif /* __INCLUDE_NTDLL_CSR_H */
/* EOF */

2
reactos/install-unix.sh
View file

@ -101,7 +101,7 @@ cp lib/winmm/winmm.dll $ROS_INSTALL/system32
cp lib/ole32/ole32.dll $ROS_INSTALL/system32
cp subsys/smss/smss.exe $ROS_INSTALL/system32
cp subsys/csrss/csrss.exe $ROS_INSTALL/system32
cp subsys/csrss/usercsr/usercsr.dll $ROS_INSTALL/system32
cp subsys/csrss/win32csr/win32csr.dll $ROS_INSTALL/system32
cp subsys/ntvdm/ntvdm.exe $ROS_INSTALL/system32
cp subsys/win32k/win32k.sys $ROS_INSTALL/system32
cp subsys/system/usetup/usetup.exe $ROS_INSTALL/system32

2
reactos/install.bat
View file

@ -107,7 +107,7 @@ copy services\eventlog\eventlog.exe %ROS_INSTALL%\system32
copy services\rpcss\rpcss.exe %ROS_INSTALL%\system32
copy subsys\smss\smss.exe %ROS_INSTALL%\system32
copy subsys\csrss\csrss.exe %ROS_INSTALL%\system32
copy subsys\csrss\usercsr\usercsr.dll %ROS_INSTALL%\system32
copy subsys\csrss\win32csr\win32csr.dll %ROS_INSTALL%\system32
copy subsys\ntvdm\ntvdm.exe %ROS_INSTALL%\system32
copy subsys\win32k\win32k.sys %ROS_INSTALL%\system32
copy subsys\system\usetup\usetup.exe %ROS_INSTALL%\system32

8
reactos/lib/kernel32/misc/console.c
View file

@ -1,4 +1,4 @@
/* $Id: console.c,v 1.69 2003/09/12 17:51:47 vizzini Exp $
/* $Id: console.c,v 1.70 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
@ -2250,7 +2250,7 @@ GetConsoleMode(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
Request.Type = CSRSS_GET_MODE;
Request.Type = CSRSS_GET_CONSOLE_MODE;
Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
@ -2387,7 +2387,7 @@ SetConsoleMode(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
Request.Type = CSRSS_SET_MODE;
Request.Type = CSRSS_SET_CONSOLE_MODE;
Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Request.Data.SetConsoleModeRequest.Mode = dwMode;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
@ -2417,7 +2417,7 @@ SetConsoleActiveScreenBuffer(
NTSTATUS Status;
Request.Type = CSRSS_SET_SCREEN_BUFFER;
Request.Data.SetActiveScreenBufferRequest.OutputHandle = hConsoleOutput;
Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
{

15
reactos/lib/ntdll/csr/lpc.c
View file

@ -1,4 +1,4 @@
/* $Id: lpc.c,v 1.11 2003/11/17 02:12:50 hyperion Exp $
/* $Id: lpc.c,v 1.12 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -30,6 +30,8 @@ static PVOID CsrSectionMapBase = NULL;
static PVOID CsrSectionMapServerBase = NULL;
static HANDLE CsrCommHeap = NULL;
static BOOL IsCsrss = FALSE;
#define CSR_CONTROL_HEAP_SIZE (65536)
/* FUNCTIONS *****************************************************************/
@ -126,6 +128,11 @@ CsrClientConnectToServer(VOID)
HANDLE CsrSectionHandle;
LARGE_INTEGER CsrSectionViewSize;
if (IsCsrss)
{
return STATUS_SUCCESS;
}
CsrSectionViewSize.QuadPart = CSR_CSRSS_SECTION_SIZE;
Status = NtCreateSection(&CsrSectionHandle,
SECTION_ALL_ACCESS,
@ -189,4 +196,10 @@ CsrClientConnectToServer(VOID)
return(STATUS_SUCCESS);
}
void STDCALL
CsrIsCsrss()
{
IsCsrss = TRUE;
}
/* EOF */

3
reactos/lib/ntdll/def/ntdll.def
View file

@ -1,4 +1,4 @@
; $Id: ntdll.def,v 1.112 2003/09/13 06:17:51 vizzini Exp $
; $Id: ntdll.def,v 1.113 2003/12/02 11:38:46 gvg Exp $
;
; ReactOS Operating System
;
@ -1468,3 +1468,4 @@ iswlower
iswxdigit
vDbgPrintEx
vDbgPrintExWithPrefix
CsrIsCsrss@0

3
reactos/lib/ntdll/def/ntdll.edf
View file

@ -1,4 +1,4 @@
; $Id: ntdll.edf,v 1.102 2003/09/13 06:17:51 vizzini Exp $
; $Id: ntdll.edf,v 1.103 2003/12/02 11:38:46 gvg Exp $
;
; ReactOS Operating System
;
@ -1468,3 +1468,4 @@ iswlower
iswxdigit
vDbgPrintEx
vDbgPrintExWithPrefix
CsrIsCsrss=CsrIsCsrss@0

2
reactos/lib/user32/user32.def
View file

@ -520,6 +520,8 @@ PostQuitMessage@4
PostThreadMessageA@16
PostThreadMessageW@16
PrintWindow@12
PrivateCsrssRegisterPrimitive@0
PrivateCsrssAcquireOrReleaseInputOwnership@4
PrivateExtractIconExA@20
PrivateExtractIconExW@20
PrivateExtractIconsA@32

2
reactos/lib/user32/user32.edf
View file

@ -521,6 +521,8 @@ PostQuitMessage=PostQuitMessage@4
PostThreadMessageA=PostThreadMessageA@16
PostThreadMessageW=PostThreadMessageW@16
PrintWindow=PrintWindow@12
PrivateCsrssRegisterPrimitive=PrivateCsrssRegisterPrimitive@0
PrivateCsrssAcquireOrReleaseInputOwnership=PrivateCsrssAcquireOrReleaseInputOwnership@4
PrivateExtractIconExA=PrivateExtractIconExA@20
PrivateExtractIconExW=PrivateExtractIconExW@20
PrivateExtractIconsA=PrivateExtractIconsA@32

24
reactos/lib/user32/windows/input.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: input.c,v 1.20 2003/11/02 16:32:25 ekohl Exp $
/* $Id: input.c,v 1.21 2003/12/02 11:38:47 gvg Exp $
*
* PROJECT: ReactOS user32.dll
* FILE: lib/user32/windows/input.c
@ -539,3 +539,25 @@ SendInput(
UNIMPLEMENTED;
return 0;
}
/*
* Private call for CSRSS
*/
VOID
STDCALL
PrivateCsrssRegisterPrimitive(VOID)
{
NtUserCallNoParam(NOPARAM_ROUTINE_REGISTER_PRIMITIVE);
}
/*
* Another private call for CSRSS
*/
VOID
STDCALL
PrivateCsrssAcquireOrReleaseInputOwnership(BOOL Release)
{
NtUserAcquireOrReleaseInputOwnership(Release);
}
/* EOF */

111
reactos/subsys/csrss/api/handle.c
View file

@ -1,8 +1,8 @@
/* $Id: handle.c,v 1.14 2003/03/09 21:41:00 hbirr Exp $
/* $Id: handle.c,v 1.15 2003/12/02 11:38:47 gvg Exp $
*
* reactos/subsys/csrss/api/handle.c
*
* Console I/O functions
* CSRSS handle functions
*
* ReactOS Operating System
*/
@ -12,14 +12,52 @@
#include <ddk/ntddk.h>
#include <csrss/csrss.h>
#include "api.h"
#include <ntdll/rtl.h>
#include "api.h"
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
static unsigned ObjectDefinitionsCount = 0;
static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL;
NTSTATUS FASTCALL
CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions)
{
unsigned NewCount;
PCSRSS_OBJECT_DEFINITION Scan;
PCSRSS_OBJECT_DEFINITION New;
NewCount = 0;
for (Scan = NewDefinitions; 0 != Scan->Type; Scan++)
{
NewCount++;
}
New = RtlAllocateHeap(CsrssApiHeap, 0,
(ObjectDefinitionsCount + NewCount)
* sizeof(CSRSS_OBJECT_DEFINITION));
if (NULL == New)
{
DPRINT1("Unable to allocate memory\n");
return STATUS_NO_MEMORY;
}
if (0 != ObjectDefinitionsCount)
{
RtlCopyMemory(New, ObjectDefinitions,
ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
RtlFreeHeap(CsrssApiHeap, 0, ObjectDefinitions);
}
RtlCopyMemory(New + ObjectDefinitionsCount, NewDefinitions,
NewCount * sizeof(CSRSS_OBJECT_DEFINITION));
ObjectDefinitions = New;
ObjectDefinitionsCount += NewCount;
return STATUS_SUCCESS;
}
NTSTATUS STDCALL CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object )
{
ULONG h = (((ULONG)Handle) >> 2) - 1;
@ -40,30 +78,55 @@ NTSTATUS STDCALL CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, O
}
NTSTATUS STDCALL CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
NTSTATUS STDCALL
CsrReleaseObjectByPointer(Object_t *Object)
{
Object_t *Object;
ULONG h = (((ULONG)Handle) >> 2) - 1;
if (ProcessData == NULL)
{
BOOL Found;
unsigned DefIndex;
/* dec ref count */
if (InterlockedDecrement(&Object->ReferenceCount) == 0)
{
Found = FALSE;
for (DefIndex = 0; ! Found && DefIndex < ObjectDefinitionsCount; DefIndex++)
{
if (Object->Type == ObjectDefinitions[DefIndex].Type)
{
(ObjectDefinitions[DefIndex].CsrCleanupObjectProc)(Object);
Found = TRUE;
}
}
if (! Found)
{
DPRINT1("CSR: Error: releaseing unknown object type 0x%x", Object->Type);
}
}
return STATUS_SUCCESS;
}
NTSTATUS STDCALL
CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
{
ULONG h = (((ULONG)Handle) >> 2) - 1;
NTSTATUS Status;
if (ProcessData == NULL)
{
return STATUS_INVALID_PARAMETER;
}
if( h >= ProcessData->HandleTableSize || ProcessData->HandleTable[h] == 0 )
}
if (h >= ProcessData->HandleTableSize || ProcessData->HandleTable[h] == NULL)
{
return STATUS_INVALID_HANDLE;
/* dec ref count */
Object = ProcessData->HandleTable[h];
if( InterlockedDecrement( &Object->ReferenceCount ) == 0 )
switch( Object->Type )
{
case CSRSS_CONSOLE_MAGIC: CsrDeleteConsole( (PCSRSS_CONSOLE) Object );
break;
case CSRSS_SCREEN_BUFFER_MAGIC: CsrDeleteScreenBuffer( (PCSRSS_SCREEN_BUFFER) Object );
break;
default: DbgPrint( "CSR: Error: releaseing unknown object type" );
}
ProcessData->HandleTable[h] = 0;
return STATUS_SUCCESS;
}
Status = CsrReleaseObjectByPointer(ProcessData->HandleTable[h]);
ProcessData->HandleTable[h] = 0;
return Status;
}
NTSTATUS STDCALL CsrInsertObject( PCSRSS_PROCESS_DATA ProcessData, PHANDLE Handle, Object_t *Object )

187
reactos/subsys/csrss/api/process.c
View file

@ -1,4 +1,4 @@
/* $Id: process.c,v 1.29 2003/10/20 18:02:04 gvg Exp $
/* $Id: process.c,v 1.30 2003/12/02 11:38:47 gvg Exp $
*
* reactos/subsys/csrss/api/process.c
*
@ -25,7 +25,6 @@
static ULONG NrProcess;
static PCSRSS_PROCESS_DATA ProcessData[256];
extern CRITICAL_SECTION ActiveConsoleLock;
CRITICAL_SECTION ProcessDataLock;
/* FUNCTIONS *****************************************************************/
@ -97,66 +96,64 @@ PCSRSS_PROCESS_DATA STDCALL CsrCreateProcessData(ULONG ProcessId)
NTSTATUS STDCALL CsrFreeProcessData(ULONG Pid)
{
ULONG hash;
int c;
PCSRSS_PROCESS_DATA pProcessData, pPrevProcessData = NULL;
ULONG hash;
int c;
PCSRSS_PROCESS_DATA pProcessData, pPrevProcessData = NULL;
hash = Pid % (sizeof(ProcessData) / sizeof(*ProcessData));
hash = Pid % (sizeof(ProcessData) / sizeof(*ProcessData));
LOCK;
LOCK;
pProcessData = ProcessData[hash];
pProcessData = ProcessData[hash];
while (pProcessData && pProcessData->ProcessId != Pid)
{
while (pProcessData && pProcessData->ProcessId != Pid)
{
pPrevProcessData = pProcessData;
pProcessData = pProcessData->next;
}
}
if (pProcessData)
{
//DbgPrint("CsrFreeProcessData pid: %d\n", Pid);
if (pProcessData)
{
DPRINT("CsrFreeProcessData pid: %d\n", Pid);
if (pProcessData->Console)
{
RtlEnterCriticalSection(&ActiveConsoleLock);
RemoveEntryList(&pProcessData->ProcessEntry);
RtlLeaveCriticalSection(&ActiveConsoleLock);
}
{
RtlEnterCriticalSection(&ProcessDataLock);
RemoveEntryList(&pProcessData->ProcessEntry);
RtlLeaveCriticalSection(&ProcessDataLock);
}
if (pProcessData->HandleTable)
{
for( c = 0; c < pProcessData->HandleTableSize; c++ )
{
if( pProcessData->HandleTable[c] )
{
CsrReleaseObject( pProcessData, (HANDLE)((c + 1) << 2) );
}
}
RtlFreeHeap( CsrssApiHeap, 0, pProcessData->HandleTable );
}
if( pProcessData->Console )
{
if( InterlockedDecrement( &(pProcessData->Console->Header.ReferenceCount) ) == 0 )
{
CsrDeleteConsole( pProcessData->Console );
}
}
{
for (c = 0; c < pProcessData->HandleTableSize; c++)
{
if (pProcessData->HandleTable[c])
{
CsrReleaseObject(pProcessData, (HANDLE)((c + 1) << 2));
}
}
RtlFreeHeap(CsrssApiHeap, 0, pProcessData->HandleTable);
}
if (pProcessData->Console)
{
CsrReleaseObjectByPointer((Object_t *) pProcessData->Console);
}
if (pProcessData->CsrSectionViewBase)
{
NtUnmapViewOfSection(NtCurrentProcess(), pProcessData->CsrSectionViewBase);
}
{
NtUnmapViewOfSection(NtCurrentProcess(), pProcessData->CsrSectionViewBase);
}
if (pPrevProcessData)
{
pPrevProcessData->next = pProcessData->next;
}
{
pPrevProcessData->next = pProcessData->next;
}
else
{
ProcessData[hash] = pProcessData->next;
}
{
ProcessData[hash] = pProcessData->next;
}
RtlFreeHeap( CsrssApiHeap, 0, pProcessData );
RtlFreeHeap(CsrssApiHeap, 0, pProcessData);
UNLOCK;
return STATUS_SUCCESS;
}
UNLOCK;
return STATUS_INVALID_PARAMETER;
}
@ -171,6 +168,8 @@ CSR_API(CsrCreateProcess)
PCSRSS_PROCESS_DATA NewProcessData;
NTSTATUS Status;
HANDLE Process;
CSRSS_API_REQUEST ApiRequest;
CSRSS_API_REPLY ApiReply;
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) -
sizeof(LPC_MESSAGE);
@ -193,39 +192,39 @@ CSR_API(CsrCreateProcess)
}
else if (Request->Data.CreateProcessRequest.Flags & CREATE_NEW_CONSOLE)
{
PCSRSS_CONSOLE Console;
ApiRequest.Type = CSRSS_ALLOC_CONSOLE;
ApiRequest.Header.DataSize = sizeof(CSRSS_ALLOC_CONSOLE_REQUEST);
ApiRequest.Header.MessageSize = sizeof(LPC_MESSAGE) + sizeof(CSRSS_ALLOC_CONSOLE_REQUEST);
ApiRequest.Data.AllocConsoleRequest.CtrlDispatcher = Request->Data.CreateProcessRequest.CtrlDispatcher;
Console = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(CSRSS_CONSOLE));
Status = CsrInitConsole(Console);
if( !NT_SUCCESS( Status ) )
{
CsrFreeProcessData( NewProcessData->ProcessId );
Reply->Status = Status;
return Status;
}
NewProcessData->Console = Console;
Console->Header.ReferenceCount++;
ApiReply.Header.DataSize = sizeof(CSRSS_ALLOC_CONSOLE_REPLY);
ApiReply.Header.MessageSize = sizeof(LPC_MESSAGE) + sizeof(CSRSS_ALLOC_CONSOLE_REPLY);
CsrApiCallHandler(NewProcessData, &ApiRequest, &ApiReply);
Reply->Status = ApiReply.Status;
if (! NT_SUCCESS(Reply->Status))
{
return Reply->Status;
}
Reply->Data.CreateProcessReply.InputHandle = ApiReply.Data.AllocConsoleReply.InputHandle;
Reply->Data.CreateProcessReply.OutputHandle = ApiReply.Data.AllocConsoleReply.OutputHandle;
}
else
{
NewProcessData->Console = ProcessData->Console;
InterlockedIncrement( &(ProcessData->Console->Header.ReferenceCount) );
}
if( NewProcessData->Console )
{
CLIENT_ID ClientId;
NewProcessData->Console = ProcessData->Console;
InterlockedIncrement( &(ProcessData->Console->Header.ReferenceCount) );
CsrInsertObject(NewProcessData,
&Reply->Data.CreateProcessReply.InputHandle,
(Object_t *)NewProcessData->Console);
RtlEnterCriticalSection( &ActiveConsoleLock );
RtlEnterCriticalSection(&ProcessDataLock );
CsrInsertObject( NewProcessData,
&Reply->Data.CreateProcessReply.OutputHandle,
&(NewProcessData->Console->ActiveBuffer->Header) );
RtlLeaveCriticalSection( &ActiveConsoleLock );
RtlLeaveCriticalSection(&ProcessDataLock);
ClientId.UniqueProcess = (HANDLE)NewProcessData->ProcessId;
Status = NtOpenProcess( &Process, PROCESS_DUP_HANDLE, 0, &ClientId );
if( !NT_SUCCESS( Status ) )
@ -248,11 +247,10 @@ CSR_API(CsrCreateProcess)
}
NtClose( Process );
NewProcessData->CtrlDispatcher = Request->Data.CreateProcessRequest.CtrlDispatcher;
RtlEnterCriticalSection( &ActiveConsoleLock );
RtlEnterCriticalSection(&ProcessDataLock );
InsertHeadList(&NewProcessData->Console->ProcessList, &NewProcessData->ProcessEntry);
RtlLeaveCriticalSection( &ActiveConsoleLock );
RtlLeaveCriticalSection(&ProcessDataLock);
}
else Reply->Data.CreateProcessReply.OutputHandle = Reply->Data.CreateProcessReply.InputHandle = INVALID_HANDLE_VALUE;
Reply->Status = STATUS_SUCCESS;
return(STATUS_SUCCESS);
@ -363,11 +361,11 @@ CSR_API(CsrGetOutputHandle)
}
else if (ProcessData->Console)
{
RtlEnterCriticalSection( &ActiveConsoleLock );
RtlEnterCriticalSection(&ProcessDataLock);
Reply->Status = CsrInsertObject(ProcessData,
&Reply->Data.GetOutputHandleReply.OutputHandle,
&(ProcessData->Console->ActiveBuffer->Header));
RtlLeaveCriticalSection( &ActiveConsoleLock );
RtlLeaveCriticalSection(&ProcessDataLock);
}
else
{
@ -410,39 +408,24 @@ CSR_API(CsrVerifyHandle)
CSR_API(CsrDuplicateHandle)
{
Object_t *Object;
Object_t *Object;
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - sizeof(LPC_MESSAGE);
ProcessData = CsrGetProcessData(Request->Data.DuplicateHandleRequest.ProcessId);
Reply->Status = CsrGetObject(ProcessData, Request->Data.DuplicateHandleRequest.Handle, &Object);
if (!NT_SUCCESS(Reply->Status))
{
ProcessData = CsrGetProcessData(Request->Data.DuplicateHandleRequest.ProcessId);
Reply->Status = CsrGetObject(ProcessData, Request->Data.DuplicateHandleRequest.Handle, &Object);
if (! NT_SUCCESS(Reply->Status))
{
DPRINT("CsrGetObject failed, status=%x\n", Reply->Status);
}
else
{
if (Object->Type == CSRSS_CONSOLE_MAGIC)
{
Reply->Status = CsrInsertObject(ProcessData,
&Reply->Data.DuplicateHandleReply.Handle,
(Object_t *)ProcessData->Console);
}
else if (Object->Type == CSRSS_SCREEN_BUFFER_MAGIC)
{
RtlEnterCriticalSection( &ActiveConsoleLock );
Reply->Status = CsrInsertObject(ProcessData,
&Reply->Data.DuplicateHandleReply.Handle,
&(ProcessData->Console->ActiveBuffer->Header));
RtlLeaveCriticalSection( &ActiveConsoleLock );
}
else
{
Reply->Status = STATUS_INVALID_PARAMETER;
}
}
return Reply->Status;
}
else
{
Reply->Status = CsrInsertObject(ProcessData,
&Reply->Data.DuplicateHandleReply.Handle,
Object);
}
return Reply->Status;
}
/* EOF */

206
reactos/subsys/csrss/api/wapi.c
View file

@ -1,4 +1,4 @@
/* $Id: wapi.c,v 1.30 2003/08/07 11:47:33 silverblade Exp $
/* $Id: wapi.c,v 1.31 2003/12/02 11:38:47 gvg Exp $
*
* reactos/subsys/csrss/api/wapi.c
*
@ -22,97 +22,121 @@
HANDLE CsrssApiHeap;
static unsigned ApiDefinitionsCount = 0;
static PCSRSS_API_DEFINITION ApiDefinitions = NULL;
/* FUNCTIONS *****************************************************************/
typedef NTSTATUS (*CsrFunc)( PCSRSS_PROCESS_DATA, PCSRSS_API_REQUEST, PCSRSS_API_REPLY );
static const CsrFunc CsrFuncs[] = {
CsrCreateProcess,
CsrTerminateProcess,
CsrWriteConsole,
CsrReadConsole,
CsrAllocConsole,
CsrFreeConsole,
CsrConnectProcess,
CsrGetScreenBufferInfo,
CsrSetCursor,
CsrFillOutputChar,
CsrReadInputEvent,
CsrWriteConsoleOutputChar,
CsrWriteConsoleOutputAttrib,
CsrFillOutputAttrib,
CsrGetCursorInfo,
CsrSetCursorInfo,
CsrSetTextAttrib,
CsrGetConsoleMode,
CsrSetConsoleMode,
CsrCreateScreenBuffer,
CsrSetScreenBuffer,
CsrSetTitle,
CsrGetTitle,
CsrWriteConsoleOutput,
CsrFlushInputBuffer,
CsrScrollConsoleScreenBuffer,
CsrReadConsoleOutputChar,
CsrReadConsoleOutputAttrib,
CsrGetNumberOfConsoleInputEvents,
CsrRegisterServicesProcess,
CsrExitReactos,
CsrGetShutdownParameters,
CsrSetShutdownParameters,
CsrPeekConsoleInput,
CsrReadConsoleOutput,
CsrWriteConsoleInput,
CsrGetInputHandle,
CsrGetOutputHandle,
CsrCloseHandle,
CsrVerifyHandle,
CsrDuplicateHandle,
CsrHardwareStateProperty,
0 };
static void Thread_Api2(HANDLE ServerPort)
NTSTATUS FASTCALL
CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions)
{
NTSTATUS Status;
LPC_MAX_MESSAGE LpcReply;
LPC_MAX_MESSAGE LpcRequest;
PCSRSS_API_REQUEST Request;
PCSRSS_PROCESS_DATA ProcessData;
PCSRSS_API_REPLY Reply;
Reply = NULL;
for (;;)
{
Status = NtReplyWaitReceivePort(ServerPort,
0,
&Reply->Header,
&LpcRequest.Header);
if ( !NT_SUCCESS( Status ) )
{
DisplayString(L"CSR: NtReplyWaitReceivePort failed\n");
}
if ( LpcRequest.Header.MessageType == LPC_PORT_CLOSED )
unsigned NewCount;
PCSRSS_API_DEFINITION Scan;
PCSRSS_API_DEFINITION New;
{
CsrFreeProcessData( (ULONG)LpcRequest.Header.ClientId.UniqueProcess );
NtClose(ServerPort);
NtTerminateThread(NtCurrentThread(), STATUS_SUCCESS);
continue;
}
NewCount = 0;
for (Scan = NewDefinitions; 0 != Scan->Handler; Scan++)
{
NewCount++;
}
New = RtlAllocateHeap(CsrssApiHeap, 0,
(ApiDefinitionsCount + NewCount)
* sizeof(CSRSS_API_DEFINITION));
if (NULL == New)
{
DPRINT1("Unable to allocate memory\n");
return STATUS_NO_MEMORY;
}
if (0 != ApiDefinitionsCount)
{
RtlCopyMemory(New, ApiDefinitions,
ApiDefinitionsCount * sizeof(CSRSS_API_DEFINITION));
RtlFreeHeap(CsrssApiHeap, 0, ApiDefinitions);
}
RtlCopyMemory(New + ApiDefinitionsCount, NewDefinitions,
NewCount * sizeof(CSRSS_API_DEFINITION));
ApiDefinitions = New;
ApiDefinitionsCount += NewCount;
return STATUS_SUCCESS;
}
VOID FASTCALL
CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Request,
PCSRSS_API_REPLY Reply)
{
BOOL Found;
unsigned DefIndex;
Found = FALSE;
for (DefIndex = 0; ! Found && DefIndex < ApiDefinitionsCount; DefIndex++)
{
if (ApiDefinitions[DefIndex].Type == Request->Type)
{
if (Request->Header.DataSize < ApiDefinitions[DefIndex].MinRequestSize)
{
DPRINT1("Request type %d min request size %d actual %d\n",
Request->Type, ApiDefinitions[DefIndex].MinRequestSize,
Request->Header.DataSize);
Reply->Status = STATUS_INVALID_PARAMETER;
}
else
{
(ApiDefinitions[DefIndex].Handler)(ProcessData, Request, Reply);
Found = TRUE;
}
}
}
if (! Found)
{
DPRINT1("CSR: Unknown request type %d\n", Request->Type);
Reply->Status = STATUS_INVALID_SYSTEM_SERVICE;
}
}
static void
Thread_Api2(HANDLE ServerPort)
{
NTSTATUS Status;
LPC_MAX_MESSAGE LpcReply;
LPC_MAX_MESSAGE LpcRequest;
PCSRSS_API_REQUEST Request;
PCSRSS_PROCESS_DATA ProcessData;
PCSRSS_API_REPLY Reply;
Reply = NULL;
for (;;)
{
Status = NtReplyWaitReceivePort(ServerPort,
0,
&Reply->Header,
&LpcRequest.Header);
if (! NT_SUCCESS(Status))
{
DPRINT1("CSR: NtReplyWaitReceivePort failed\n");
NtClose(ServerPort);
NtTerminateThread(NtCurrentThread(), Status);
continue;
}
Request = (PCSRSS_API_REQUEST)&LpcRequest;
Reply = (PCSRSS_API_REPLY)&LpcReply;
if (LpcRequest.Header.MessageType == LPC_PORT_CLOSED)
{
CsrFreeProcessData( (ULONG)LpcRequest.Header.ClientId.UniqueProcess );
NtClose(ServerPort);
NtTerminateThread(NtCurrentThread(), STATUS_SUCCESS);
continue;
}
Request = (PCSRSS_API_REQUEST)&LpcRequest;
Reply = (PCSRSS_API_REPLY)&LpcReply;
ProcessData = CsrGetProcessData(
(ULONG)LpcRequest.Header.ClientId.UniqueProcess);
// DisplayString(L"CSR: Received request\n");
if( Request->Type >= (sizeof( CsrFuncs ) / sizeof( CsrFunc )) - 1 )
Reply->Status = STATUS_INVALID_SYSTEM_SERVICE;
else CsrFuncs[ Request->Type ]( ProcessData, Request, Reply );
}
ProcessData = CsrGetProcessData((ULONG)LpcRequest.Header.ClientId.UniqueProcess);
CsrApiCallHandler(ProcessData, Request, Reply);
}
}
/**********************************************************************
@ -135,12 +159,12 @@ void Thread_Api(PVOID PortHandle)
for (;;)
{
LPC_SECTION_READ LpcRead;
LPC_SECTION_READ LpcRead;
Status = NtListenPort(PortHandle, &Request.Header);
if (!NT_SUCCESS(Status))
{
DisplayString(L"CSR: NtListenPort() failed\n");
DPRINT1("CSR: NtListenPort() failed\n");
NtTerminateThread(NtCurrentThread(), Status);
}
@ -152,7 +176,7 @@ void Thread_Api(PVOID PortHandle)
&LpcRead);
if (!NT_SUCCESS(Status))
{
DisplayString(L"CSR: NtAcceptConnectPort() failed\n");
DPRINT1("CSR: NtAcceptConnectPort() failed\n");
NtTerminateThread(NtCurrentThread(), Status);
}
@ -163,7 +187,7 @@ void Thread_Api(PVOID PortHandle)
Status = NtCompleteConnectPort(ServerPort);
if (!NT_SUCCESS(Status))
{
DisplayString(L"CSR: NtCompleteConnectPort() failed\n");
DPRINT1("CSR: NtCompleteConnectPort() failed\n");
NtTerminateThread(NtCurrentThread(), Status);
}
@ -179,7 +203,7 @@ void Thread_Api(PVOID PortHandle)
NULL);
if (!NT_SUCCESS(Status))
{
DisplayString(L"CSR: Unable to create server thread\n");
DPRINT1("CSR: Unable to create server thread\n");
NtClose(ServerPort);
NtTerminateThread(NtCurrentThread(), Status);
}

116
reactos/subsys/csrss/include/api.h
View file

@ -1,15 +1,18 @@
#ifndef _CSRSS_API_H
#define _CSRSS_API_H
/* $Id: api.h,v 1.3 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/include/api.h
* PURPOSE: CSRSS API interface
*/
#ifndef API_H_INCLUDED
#define API_H_INCLUDED
#include <ntos.h>
#include <csrss/csrss.h>
/* Object type magic numbers */
#define CSRSS_CONSOLE_MAGIC 1
#define CSRSS_SCREEN_BUFFER_MAGIC 2
typedef struct Object_tt
{
LONG Type;
@ -98,8 +101,38 @@ typedef struct _CSRSS_PROCESS_DATA
LIST_ENTRY ProcessEntry;
PCONTROLDISPATCHER CtrlDispatcher;
} CSRSS_PROCESS_DATA, *PCSRSS_PROCESS_DATA;
typedef VOID (STDCALL *CSR_CLEANUP_OBJECT_PROC)(Object_t *Object);
#define CSR_API(n) NTSTATUS n (\
typedef struct tagCSRSS_OBJECT_DEFINITION
{
LONG Type;
CSR_CLEANUP_OBJECT_PROC CsrCleanupObjectProc;
} CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION;
typedef NTSTATUS (STDCALL *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Request,
PCSRSS_API_REPLY Reply);
typedef struct _CSRSS_API_DEFINITION
{
ULONG Type;
ULONG MinRequestSize;
ULONG MinReplySize;
CSRSS_API_PROC Handler;
} CSRSS_API_DEFINITION, *PCSRSS_API_DEFINITION;
#define CSRSS_DEFINE_API(Func, Handler) \
{ Func, sizeof(Func##_REQUEST), sizeof(Func##_REPLY), Handler }
typedef struct _CSRSS_LISTEN_DATA
{
HANDLE ApiPortHandle;
ULONG ApiDefinitionsCount;
PCSRSS_API_DEFINITION *ApiDefinitions;
} CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA;
#define CSR_API(n) NTSTATUS STDCALL n (\
PCSRSS_PROCESS_DATA ProcessData,\
PCSRSS_API_REQUEST Request,\
PCSRSS_API_REPLY Reply)
@ -109,54 +142,15 @@ CSR_API(CsrConnectProcess);
CSR_API(CsrCreateProcess);
CSR_API(CsrTerminateProcess);
/* api/conio.c */
CSR_API(CsrWriteConsole);
CSR_API(CsrAllocConsole);
CSR_API(CsrFreeConsole);
CSR_API(CsrReadConsole);
CSR_API(CsrConnectProcess);
CSR_API(CsrGetScreenBufferInfo);
CSR_API(CsrSetCursor);
CSR_API(CsrFillOutputChar);
CSR_API(CsrReadInputEvent);
CSR_API(CsrWriteConsoleOutputChar);
CSR_API(CsrWriteConsoleOutputAttrib);
CSR_API(CsrFillOutputAttrib);
CSR_API(CsrGetCursorInfo);
CSR_API(CsrSetCursorInfo);
CSR_API(CsrSetTextAttrib);
CSR_API(CsrSetConsoleMode);
CSR_API(CsrGetConsoleMode);
CSR_API(CsrCreateScreenBuffer);
CSR_API(CsrSetScreenBuffer);
CSR_API(CsrSetTitle);
CSR_API(CsrGetTitle);
CSR_API(CsrWriteConsoleOutput);
CSR_API(CsrFlushInputBuffer);
CSR_API(CsrScrollConsoleScreenBuffer);
CSR_API(CsrReadConsoleOutputChar);
CSR_API(CsrReadConsoleOutputAttrib);
CSR_API(CsrGetNumberOfConsoleInputEvents);
CSR_API(CsrRegisterServicesProcess);
CSR_API(CsrExitReactos);
CSR_API(CsrGetShutdownParameters);
CSR_API(CsrSetShutdownParameters);
CSR_API(CsrPeekConsoleInput);
CSR_API(CsrReadConsoleOutput);
CSR_API(CsrWriteConsoleInput);
CSR_API(CsrGetInputHandle);
CSR_API(CsrGetOutputHandle);
CSR_API(CsrCloseHandle);
CSR_API(CsrVerifyHandle);
CSR_API(CsrDuplicateHandle);
CSR_API(CsrHardwareStateProperty);
CSR_API(CsrGetConsoleWindow);
/* print.c */
VOID STDCALL DisplayString(LPCWSTR lpwString);
VOID STDCALL PrintString (char* fmt, ...);
/* api/wapi.c */
NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Request,
PCSRSS_API_REPLY Reply);
VOID Thread_Api(PVOID PortHandle);
VOID Console_Api( DWORD Ignored );
@ -164,8 +158,6 @@ extern HANDLE CsrssApiHeap;
/* api/conio.c */
NTSTATUS STDCALL CsrInitConsole(PCSRSS_CONSOLE Console);
VOID STDCALL CsrDeleteConsole( PCSRSS_CONSOLE Console );
VOID STDCALL CsrDeleteScreenBuffer( PCSRSS_SCREEN_BUFFER Buffer );
NTSTATUS STDCALL CsrInitConsoleScreenBuffer(PCSRSS_SCREEN_BUFFER Buffer,
PCSRSS_CONSOLE Console,
unsigned Width,
@ -178,14 +170,30 @@ PCSRSS_PROCESS_DATA STDCALL CsrGetProcessData(ULONG ProcessId);
NTSTATUS STDCALL CsrFreeProcessData( ULONG Pid );
/* api/handle.c */
NTSTATUS FASTCALL CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions);
NTSTATUS STDCALL CsrInsertObject( PCSRSS_PROCESS_DATA ProcessData, PHANDLE Handle, Object_t *Object );
NTSTATUS STDCALL CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object );
BOOL STDCALL CsrServerInitialization (ULONG ArgumentCount, PWSTR *ArgumentArray);
NTSTATUS STDCALL CsrReleaseObjectByPointer(Object_t *Object);
NTSTATUS STDCALL CsrReleaseObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
NTSTATUS STDCALL CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
VOID STDCALL CsrDrawConsole(PCSRSS_CONSOLE Console);
NTSTATUS CsrpEchoUnicodeChar( PCSRSS_SCREEN_BUFFER Console,
WCHAR UnicodeChar );
NTSTATUS STDCALL CsrpWriteConsole( PCSRSS_SCREEN_BUFFER Buff, CHAR *Buffer, DWORD Length, BOOL Attrib );
CSR_API(CsrGetInputHandle);
CSR_API(CsrGetOutputHandle);
CSR_API(CsrCloseHandle);
CSR_API(CsrVerifyHandle);
CSR_API(CsrDuplicateHandle);
/* api/user.c */
CSR_API(CsrRegisterServicesProcess);
CSR_API(CsrExitReactos);
CSR_API(CsrGetShutdownParameters);
CSR_API(CsrSetShutdownParameters);
#endif /* ndef API_H_INCLUDED */
/* EOF */
#endif /* ndef _CSRSS_API_H */

60
reactos/subsys/csrss/include/conio.h Normal file
View file

@ -0,0 +1,60 @@
/* $Id: conio.h,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/include/conio.h
* PURPOSE: CSRSS internal console I/O interface
*/
#ifndef CONIO_H_INCLUDED
#define CONIO_H_INCLUDED
#include "api.h"
/* Object type magic numbers */
#define CONIO_CONSOLE_MAGIC 0x00000001
#define CONIO_SCREEN_BUFFER_MAGIC 0x00000002
VOID STDCALL ConioDeleteConsole(Object_t *Object);
VOID STDCALL ConioDeleteScreenBuffer(Object_t *Buffer);
void STDCALL CsrProcessKey(MSG *msg, PCSRSS_CONSOLE Console);
/* api/conio.c */
CSR_API(CsrWriteConsole);
CSR_API(CsrAllocConsole);
CSR_API(CsrFreeConsole);
CSR_API(CsrReadConsole);
CSR_API(CsrConnectProcess);
CSR_API(CsrGetScreenBufferInfo);
CSR_API(CsrSetCursor);
CSR_API(CsrFillOutputChar);
CSR_API(CsrReadInputEvent);
CSR_API(CsrWriteConsoleOutputChar);
CSR_API(CsrWriteConsoleOutputAttrib);
CSR_API(CsrFillOutputAttrib);
CSR_API(CsrGetCursorInfo);
CSR_API(CsrSetCursorInfo);
CSR_API(CsrSetTextAttrib);
CSR_API(CsrSetConsoleMode);
CSR_API(CsrGetConsoleMode);
CSR_API(CsrCreateScreenBuffer);
CSR_API(CsrSetScreenBuffer);
CSR_API(CsrSetTitle);
CSR_API(CsrGetTitle);
CSR_API(CsrWriteConsoleOutput);
CSR_API(CsrFlushInputBuffer);
CSR_API(CsrScrollConsoleScreenBuffer);
CSR_API(CsrReadConsoleOutputChar);
CSR_API(CsrReadConsoleOutputAttrib);
CSR_API(CsrGetNumberOfConsoleInputEvents);
CSR_API(CsrPeekConsoleInput);
CSR_API(CsrReadConsoleOutput);
CSR_API(CsrWriteConsoleInput);
CSR_API(CsrHardwareStateProperty);
CSR_API(CsrGetConsoleWindow);
#endif /* CONIO_H_INCLUDED */
/* EOF */

48
reactos/subsys/csrss/include/csrplugin.h Normal file
View file

@ -0,0 +1,48 @@
/* $Id: csrplugin.h,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/include/csrplugin.h
* PURPOSE: CSRSS plugin interface
*/
/*
* CSRSS is a native application and can only implicitly link against native
* DLLs. Since e.g. user32.dll and gdi32.dll are win32 DLLs and not native
* DLLs it is not possible to call functions in those DLLs directly from
* CSRSS.
* However, it is possible to explicitly load a non-native DLL. Such a DLL
* can then in turn be implicitly linked against other DLLs in its own
* subsystem.
*/
#ifndef CSRPLUGIN_H_INCLUDED
#define CSRPLUGIN_H_INCLUDED
#include <windows.h>
#include "api.h"
typedef NTSTATUS (STDCALL *CSRSS_INSERT_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object);
typedef NTSTATUS (STDCALL *CSRSS_GET_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object);
typedef NTSTATUS (STDCALL *CSRSS_RELEASE_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object );
typedef struct tagCSRSS_EXPORTED_FUNCS
{
CSRSS_INSERT_OBJECT_PROC CsrInsertObjectProc;
CSRSS_GET_OBJECT_PROC CsrGetObjectProc;
CSRSS_RELEASE_OBJECT_PROC CsrReleaseObjectProc;
} CSRSS_EXPORTED_FUNCS, *PCSRSS_EXPORTED_FUNCS;
typedef BOOL STDCALL (*CSRPLUGIN_INITIALIZE_PROC)(PCSRSS_API_DEFINITION *ApiDefinitions,
PCSRSS_OBJECT_DEFINITION *ObjectDefinitions,
PCSRSS_EXPORTED_FUNCS Exports,
HANDLE CsrssApiHeap);
#endif /* CSRPLUGIN_H_INCLUDED */
/* EOF */

34
reactos/subsys/csrss/include/usercsr.h
View file

@ -1,34 +0,0 @@
/* $Id: usercsr.h,v 1.1 2003/10/20 18:02:04 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/usercsr/usercsr.h
* PURPOSE: Interface to usercsr.dll
*/
#include <windows.h>
typedef BOOL STDCALL (*USERCSRINITCONSOLEPROC)(PCSRSS_CONSOLE Console);
typedef VOID STDCALL (*USERCSRDRAWREGIONPROC)(PCSRSS_CONSOLE Console, SMALL_RECT Region);
typedef VOID STDCALL (*USERCSRCOPYREGIONPROC)(PCSRSS_CONSOLE Console,
RECT *Source,
RECT *Dest);
typedef VOID STDCALL (*USERCSRCHANGETITLEPROC)(PCSRSS_CONSOLE Console);
typedef VOID STDCALL (*USERCSRDELETECONSOLEPROC)(PCSRSS_CONSOLE Console);
typedef VOID STDCALL (*USERCSRPROCESSKEYCALLBACK)(MSG *msg, PCSRSS_CONSOLE Console);
typedef struct
{
USERCSRINITCONSOLEPROC InitConsole;
USERCSRDRAWREGIONPROC DrawRegion;
USERCSRCOPYREGIONPROC CopyRegion;
USERCSRCHANGETITLEPROC ChangeTitle;
USERCSRDELETECONSOLEPROC DeleteConsole;
} USERCSRFUNCS, *PUSERCSRFUNCS;
typedef BOOL STDCALL (*USERCSRINITIALIZEPROC)(PUSERCSRFUNCS Funcs,
HANDLE CsrssApiHeap,
USERCSRPROCESSKEYCALLBACK ProcessKey);
extern HANDLE UserCsrApiHeap;
extern USERCSRPROCESSKEYCALLBACK UserCsrProcessKey;

20
reactos/subsys/csrss/include/win32csr.h Normal file
View file

@ -0,0 +1,20 @@
/* $Id: win32csr.h,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/win32csr/win32csr.h
* PURPOSE: Interface to win32csr.dll
*/
#include <windows.h>
extern HANDLE Win32CsrApiHeap;
NTSTATUS FASTCALL Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object);
NTSTATUS FASTCALL Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object);
NTSTATUS FASTCALL Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object);

222
reactos/subsys/csrss/init.c
View file

@ -1,4 +1,4 @@
/* $Id: init.c,v 1.23 2003/11/17 02:12:51 hyperion Exp $
/* $Id: init.c,v 1.24 2003/12/02 11:38:47 gvg Exp $
*
* reactos/subsys/csrss/init.c
*
@ -11,30 +11,25 @@
/* INCLUDES ******************************************************************/
#include <ddk/ntddk.h>
#include <ntdll/csr.h>
#include <ntdll/rtl.h>
#include <ntdll/ldr.h>
#include <csrss/csrss.h>
#include <win32k/win32k.h>
#include <rosrtl/string.h>
#include "api.h"
#include "csrplugin.h"
#define NDEBUG
#include <debug.h>
/* GLOBALS ******************************************************************/
/*
* Server's named ports.
*/
static HANDLE ApiPortHandle;
HANDLE CsrInitEvent = INVALID_HANDLE_VALUE;
HANDLE CsrHeap = INVALID_HANDLE_VALUE;
HANDLE CsrObjectDirectory = INVALID_HANDLE_VALUE;
HANDLE CsrApiPort = INVALID_HANDLE_VALUE;
HANDLE CsrSbApiPort = INVALID_HANDLE_VALUE;
UNICODE_STRING CsrDirectoryName;
@ -107,16 +102,73 @@ CsrInitVideo(VOID)
}
}
static NTSTATUS FASTCALL
InitWin32Csr()
{
NTSTATUS Status;
UNICODE_STRING DllName;
HINSTANCE hInst;
ANSI_STRING ProcName;
CSRPLUGIN_INITIALIZE_PROC InitProc;
CSRSS_EXPORTED_FUNCS Exports;
PCSRSS_API_DEFINITION ApiDefinitions;
PCSRSS_OBJECT_DEFINITION ObjectDefinitions;
RtlInitUnicodeString(&DllName, L"win32csr.dll");
Status = LdrLoadDll(NULL, 0, &DllName, (PVOID *) &hInst);
if (! NT_SUCCESS(Status))
{
return Status;
}
RtlInitAnsiString(&ProcName, "Win32CsrInitialization");
Status = LdrGetProcedureAddress(hInst, &ProcName, 0, (PVOID *) &InitProc);
if (! NT_SUCCESS(Status))
{
return Status;
}
Exports.CsrInsertObjectProc = CsrInsertObject;
Exports.CsrGetObjectProc = CsrGetObject;
Exports.CsrReleaseObjectProc = CsrReleaseObject;
if (! (*InitProc)(&ApiDefinitions, &ObjectDefinitions, &Exports, CsrssApiHeap))
{
return STATUS_UNSUCCESSFUL;
}
Status = CsrApiRegisterDefinitions(ApiDefinitions);
if (! NT_SUCCESS(Status))
{
return Status;
}
Status = CsrRegisterObjectDefinitions(ObjectDefinitions);
return Status;
}
CSRSS_API_DEFINITION NativeDefinitions[] =
{
CSRSS_DEFINE_API(CSRSS_CREATE_PROCESS, CsrCreateProcess),
CSRSS_DEFINE_API(CSRSS_TERMINATE_PROCESS, CsrTerminateProcess),
CSRSS_DEFINE_API(CSRSS_CONNECT_PROCESS, CsrConnectProcess),
CSRSS_DEFINE_API(CSRSS_REGISTER_SERVICES_PROCESS, CsrRegisterServicesProcess),
CSRSS_DEFINE_API(CSRSS_EXIT_REACTOS, CsrExitReactos),
CSRSS_DEFINE_API(CSRSS_GET_SHUTDOWN_PARAMETERS, CsrGetShutdownParameters),
CSRSS_DEFINE_API(CSRSS_SET_SHUTDOWN_PARAMETERS, CsrSetShutdownParameters),
CSRSS_DEFINE_API(CSRSS_GET_INPUT_HANDLE, CsrGetInputHandle),
CSRSS_DEFINE_API(CSRSS_GET_OUTPUT_HANDLE, CsrGetOutputHandle),
CSRSS_DEFINE_API(CSRSS_CLOSE_HANDLE, CsrCloseHandle),
CSRSS_DEFINE_API(CSRSS_VERIFY_HANDLE, CsrVerifyHandle),
CSRSS_DEFINE_API(CSRSS_DUPLICATE_HANDLE, CsrDuplicateHandle),
{ 0, 0, 0, NULL }
};
/**********************************************************************
* NAME
* CsrServerInitialization
*
* DESCRIPTION
* Create a directory object (\windows) and two named LPC ports:
*
* 1. \windows\ApiPort
* 2. \windows\SbApiPort
* Create a directory object (\windows) and a named LPC port
* (\windows\ApiPort)
*
* RETURN VALUE
* TRUE: Initialization OK; otherwise FALSE.
@ -128,87 +180,83 @@ CsrServerInitialization (
PWSTR *ArgumentArray
)
{
NTSTATUS Status;
OBJECT_ATTRIBUTES ObAttributes;
UNICODE_STRING PortName;
OBJECT_ATTRIBUTES RefreshEventAttr;
UNICODE_STRING RefreshEventName;
HANDLE RefreshEventHandle;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObAttributes;
UNICODE_STRING PortName;
HANDLE ApiPortHandle;
Status = CsrParseCommandLine (ArgumentCount, ArgumentArray);
if (!NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to parse the command line (Status: %x)\n", Status);
return(FALSE);
}
Status = CsrParseCommandLine (ArgumentCount, ArgumentArray);
if (! NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to parse the command line (Status: %x)\n", Status);
return FALSE;
}
CsrInitVideo();
CsrIsCsrss( );
CsrInitVideo();
/* NEW NAMED PORT: \ApiPort */
RtlRosInitUnicodeStringFromLiteral(&PortName, L"\\Windows\\ApiPort");
InitializeObjectAttributes(&ObAttributes,
&PortName,
0,
NULL,
NULL);
Win32kInitialize();
Status = NtCreatePort(&ApiPortHandle,
&ObAttributes,
260,
328,
0);
if (!NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to create \\ApiPort (Status %x)\n", Status);
return(FALSE);
}
CsrssApiHeap = RtlCreateHeap(HEAP_GROWABLE,
NULL,
65536,
65536,
NULL,
NULL);
if (CsrssApiHeap == NULL)
{
DPRINT1("CSR: Failed to create private heap, aborting\n");
return FALSE;
}
CsrssApiHeap = RtlCreateHeap(HEAP_GROWABLE,
NULL,
65536,
65536,
NULL,
NULL);
if (CsrssApiHeap == NULL)
{
DPRINT1("CSR: Failed to create private heap, aborting\n");
return FALSE;
}
CsrInitConsoleSupport();
Status = RtlCreateUserThread(NtCurrentProcess(),
NULL,
FALSE,
0,
NULL,
NULL,
(PTHREAD_START_ROUTINE)Thread_Api,
ApiPortHandle,
NULL,
NULL);
if (!NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to create server thread\n");
NtClose(ApiPortHandle);
return FALSE;
}
RtlRosInitUnicodeStringFromLiteral( &RefreshEventName, L"\\TextConsoleRefreshEvent" );
InitializeObjectAttributes( &RefreshEventAttr, &RefreshEventName, 0, NULL, NULL );
Status = NtCreateEvent( &RefreshEventHandle, STANDARD_RIGHTS_ALL, &RefreshEventAttr, FALSE, FALSE );
if( !NT_SUCCESS( Status ) )
{
DPRINT1( "CSR: Unable to create refresh event!\n" );
return FALSE;
}
Status = RtlCreateUserThread( NtCurrentProcess(), NULL, FALSE, 0, NULL, NULL, (PTHREAD_START_ROUTINE)Console_Api, (PVOID) RefreshEventHandle, NULL, NULL );
if( !NT_SUCCESS( Status ) )
{
DPRINT1( "CSR: Unable to create console thread\n" );
return FALSE;
}
Status = CsrApiRegisterDefinitions(NativeDefinitions);
if (! NT_SUCCESS(Status))
{
return Status;
}
Win32kInitialize();
Status = InitWin32Csr();
if (! NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to load usermode dll (Status %x)\n", Status);
return FALSE;
}
return TRUE;
/* NEW NAMED PORT: \ApiPort */
RtlRosInitUnicodeStringFromLiteral(&PortName, L"\\Windows\\ApiPort");
InitializeObjectAttributes(&ObAttributes,
&PortName,
0,
NULL,
NULL);
Status = NtCreatePort(&ApiPortHandle,
&ObAttributes,
260,
328,
0);
if (! NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to create \\ApiPort (Status %x)\n", Status);
return FALSE;
}
Status = RtlCreateUserThread(NtCurrentProcess(),
NULL,
FALSE,
0,
NULL,
NULL,
(PTHREAD_START_ROUTINE)Thread_Api,
ApiPortHandle,
NULL,
NULL);
if (! NT_SUCCESS(Status))
{
DPRINT1("CSR: Unable to create server thread\n");
NtClose(ApiPortHandle);
return FALSE;
}
return TRUE;
}
/* EOF */

17
reactos/subsys/csrss/makefile
View file

@ -1,4 +1,4 @@
# $Id: makefile,v 1.24 2003/11/24 16:42:53 ekohl Exp $
# $Id: makefile,v 1.25 2003/12/02 11:38:47 gvg Exp $
PATH_TO_TOP = ../..
@ -20,12 +20,11 @@ TARGET_LFLAGS = -nostdlib
# require os code to explicitly request A/W version of structs/functions
TARGET_CFLAGS += -D_DISABLE_TIDENTS
SUBDIRS = usercsr
SUBDIRS = win32csr
OBJECTS_API = \
api/process.o \
api/wapi.o \
api/conio.o \
api/handle.o \
api/user.o
@ -48,16 +47,4 @@ include $(TOOLS_PATH)/helper.mk
include $(TOOLS_PATH)/depend.mk
#all::
# $(MAKE) -C usercsr all
#
#clean::
# $(MAKE) -C usercsr clean
#
#install::
# $(MAKE) -C usercsr install
#
#bootcd::
# $(MAKE) -C usercsr bootcd
# EOF

7
reactos/subsys/csrss/usercsr/.cvsignore
View file

@ -1,7 +0,0 @@
usercsr.coff
usercsr.dll
usercsr.nostrip.dll
*.d
*.o
*.sym
*.map

49
reactos/subsys/csrss/usercsr/dllmain.c
View file

@ -1,49 +0,0 @@
/* $Id: dllmain.c,v 1.1 2003/10/20 18:02:04 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/usercsr/dllmain.c
* PURPOSE: Initialization
*/
/* INCLUDES ******************************************************************/
#include <windows.h>
#include "guiconsole.h"
#include "usercsr.h"
/* GLOBALS *******************************************************************/
HANDLE UserCsrApiHeap;
USERCSRPROCESSKEYCALLBACK UserCsrProcessKey;
/* FUNCTIONS *****************************************************************/
BOOL STDCALL
DllMain(HANDLE hDll,
DWORD dwReason,
LPVOID lpReserved)
{
return TRUE;
}
BOOL STDCALL
UserCsrInitialization(PUSERCSRFUNCS Funcs,
HANDLE CsrssApiHeap,
USERCSRPROCESSKEYCALLBACK ProcessKey)
{
UserCsrApiHeap = CsrssApiHeap;
UserCsrProcessKey = ProcessKey;
GuiConsoleInitConsoleSupport();
Funcs->InitConsole = GuiConsoleInitConsole;
Funcs->DrawRegion = GuiConsoleDrawRegion;
Funcs->CopyRegion = GuiConsoleCopyRegion;
Funcs->ChangeTitle = GuiConsoleChangeTitle;
Funcs->DeleteConsole = GuiConsoleDeleteConsole;
return TRUE;
}
/* EOF */

8
reactos/subsys/csrss/usercsr/usercsr.def
View file

@ -1,8 +0,0 @@
; $Id: usercsr.def,v 1.1 2003/10/20 18:02:04 gvg Exp $
;
LIBRARY usercsr.exe
EXPORTS
UserCsrInitialization

9
reactos/subsys/csrss/usercsr/usercsr.edf
View file

@ -1,9 +0,0 @@
; $Id: usercsr.edf,v 1.1 2003/10/20 18:02:04 gvg Exp $
;
;
LIBRARY usercsr.dll
EXPORTS
UserCsrInitialization=UserCsrInitialization@12

6
reactos/subsys/csrss/usercsr/makefile → reactos/subsys/csrss/win32csr/Makefile
View file

@ -1,10 +1,10 @@
# $Id: makefile,v 1.1 2003/10/20 18:02:04 gvg Exp $
# $Id: Makefile,v 1.1 2003/12/02 11:38:46 gvg Exp $
PATH_TO_TOP = ../../..
TARGET_TYPE = dynlink
TARGET_NAME = usercsr
TARGET_NAME = win32csr
TARGET_BASE = 0x5ffb0000
@ -15,7 +15,7 @@ TARGET_LFLAGS = -nostartfiles -nostdlib
TARGET_SDKLIBS = ntdll.a kernel32.a user32.a gdi32.a
TARGET_OBJECTS = dllmain.o guiconsole.o
TARGET_OBJECTS = dllmain.o conio.o guiconsole.o
TARGET_ENTRY = _DllMain@12

848
reactos/subsys/csrss/api/conio.c → reactos/subsys/csrss/win32csr/conio.c
View file

File diff suppressed because it is too large Load diff

126
reactos/subsys/csrss/win32csr/dllmain.c Normal file
View file

@ -0,0 +1,126 @@
/* $Id: dllmain.c,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/win32csr/dllmain.c
* PURPOSE: Initialization
*/
/* INCLUDES ******************************************************************/
#include <windows.h>
#include "csrplugin.h"
#include "conio.h"
#include "guiconsole.h"
#define NDEBUG
#include <debug.h>
/* GLOBALS *******************************************************************/
HANDLE Win32CsrApiHeap;
static CSRSS_EXPORTED_FUNCS CsrExports;
static CSRSS_API_DEFINITION Win32CsrApiDefinitions[] =
{
CSRSS_DEFINE_API(CSRSS_WRITE_CONSOLE, CsrWriteConsole),
CSRSS_DEFINE_API(CSRSS_READ_CONSOLE, CsrReadConsole),
CSRSS_DEFINE_API(CSRSS_ALLOC_CONSOLE, CsrAllocConsole),
CSRSS_DEFINE_API(CSRSS_FREE_CONSOLE, CsrFreeConsole),
CSRSS_DEFINE_API(CSRSS_SCREEN_BUFFER_INFO, CsrGetScreenBufferInfo),
CSRSS_DEFINE_API(CSRSS_SET_CURSOR, CsrSetCursor),
CSRSS_DEFINE_API(CSRSS_FILL_OUTPUT, CsrFillOutputChar),
CSRSS_DEFINE_API(CSRSS_READ_INPUT, CsrReadInputEvent),
CSRSS_DEFINE_API(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR, CsrWriteConsoleOutputChar),
CSRSS_DEFINE_API(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB, CsrWriteConsoleOutputAttrib),
CSRSS_DEFINE_API(CSRSS_FILL_OUTPUT_ATTRIB, CsrFillOutputAttrib),
CSRSS_DEFINE_API(CSRSS_GET_CURSOR_INFO, CsrGetCursorInfo),
CSRSS_DEFINE_API(CSRSS_SET_CURSOR_INFO, CsrSetCursorInfo),
CSRSS_DEFINE_API(CSRSS_SET_ATTRIB, CsrSetTextAttrib),
CSRSS_DEFINE_API(CSRSS_GET_CONSOLE_MODE, CsrGetConsoleMode),
CSRSS_DEFINE_API(CSRSS_SET_CONSOLE_MODE, CsrSetConsoleMode),
CSRSS_DEFINE_API(CSRSS_CREATE_SCREEN_BUFFER, CsrCreateScreenBuffer),
CSRSS_DEFINE_API(CSRSS_SET_SCREEN_BUFFER, CsrSetScreenBuffer),
CSRSS_DEFINE_API(CSRSS_SET_TITLE, CsrSetTitle),
CSRSS_DEFINE_API(CSRSS_GET_TITLE, CsrGetTitle),
CSRSS_DEFINE_API(CSRSS_WRITE_CONSOLE_OUTPUT, CsrWriteConsoleOutput),
CSRSS_DEFINE_API(CSRSS_FLUSH_INPUT_BUFFER, CsrFlushInputBuffer),
CSRSS_DEFINE_API(CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER, CsrScrollConsoleScreenBuffer),
CSRSS_DEFINE_API(CSRSS_READ_CONSOLE_OUTPUT_CHAR, CsrReadConsoleOutputChar),
CSRSS_DEFINE_API(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB, CsrReadConsoleOutputAttrib),
CSRSS_DEFINE_API(CSRSS_GET_NUM_INPUT_EVENTS, CsrGetNumberOfConsoleInputEvents),
CSRSS_DEFINE_API(CSRSS_PEEK_CONSOLE_INPUT, CsrPeekConsoleInput),
CSRSS_DEFINE_API(CSRSS_READ_CONSOLE_OUTPUT, CsrReadConsoleOutput),
CSRSS_DEFINE_API(CSRSS_WRITE_CONSOLE_INPUT, CsrWriteConsoleInput),
CSRSS_DEFINE_API(CSRSS_SETGET_CONSOLE_HW_STATE, CsrHardwareStateProperty),
{ 0, 0, 0, NULL }
};
static CSRSS_OBJECT_DEFINITION Win32CsrObjectDefinitions[] =
{
{ CONIO_CONSOLE_MAGIC, ConioDeleteConsole },
{ CONIO_SCREEN_BUFFER_MAGIC, ConioDeleteScreenBuffer },
{ 0, NULL }
};
/* FUNCTIONS *****************************************************************/
BOOL STDCALL
DllMain(HANDLE hDll,
DWORD dwReason,
LPVOID lpReserved)
{
return TRUE;
}
NTSTATUS FASTCALL
Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object)
{
return (CsrExports.CsrInsertObjectProc)(ProcessData, Handle, Object);
}
NTSTATUS FASTCALL
Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object)
{
return (CsrExports.CsrGetObjectProc)(ProcessData, Handle, Object);
}
NTSTATUS FASTCALL
Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object)
{
return (CsrExports.CsrReleaseObjectProc)(ProcessData, Object);
}
BOOL STDCALL
Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
PCSRSS_OBJECT_DEFINITION *ObjectDefinitions,
PCSRSS_EXPORTED_FUNCS Exports,
HANDLE CsrssApiHeap)
{
HANDLE ThreadHandle;
CsrExports = *Exports;
Win32CsrApiHeap = CsrssApiHeap;
CsrInitConsoleSupport();
ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) Console_Api, NULL, 0, NULL);
if (NULL == ThreadHandle)
{
DPRINT1("CSR: Unable to create console thread\n");
return FALSE;
}
CloseHandle(ThreadHandle);
*ApiDefinitions = Win32CsrApiDefinitions;
*ObjectDefinitions = Win32CsrObjectDefinitions;
return TRUE;
}
/* EOF */

43
reactos/subsys/csrss/usercsr/guiconsole.c → reactos/subsys/csrss/win32csr/guiconsole.c
View file

@ -1,16 +1,17 @@
/* $Id: guiconsole.c,v 1.2 2003/11/24 00:22:53 arty Exp $
/* $Id: guiconsole.c,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/usercsr/dllmain.c
* FILE: subsys/csrss/win32csr/dllmain.c
* PURPOSE: Initialization
*/
/* INCLUDES ******************************************************************/
#include <windows.h>
#include "conio.h"
#include "guiconsole.h"
#include "usercsr.h"
#include "win32csr.h"
/* GLOBALS *******************************************************************/
@ -55,7 +56,7 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
HFONT OldFont;
TEXTMETRICW Metrics;
GuiData = HeapAlloc(UserCsrApiHeap, 0,
GuiData = HeapAlloc(Win32CsrApiHeap, 0,
sizeof(GUI_CONSOLE_DATA) +
(Console->Size.X + 1) * sizeof(WCHAR));
if (NULL == GuiData)
@ -73,14 +74,14 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
if (NULL == GuiData->Font)
{
DbgPrint("GuiConsoleNcCreate: CreateFont failed\n");
HeapFree(UserCsrApiHeap, 0, GuiData);
HeapFree(Win32CsrApiHeap, 0, GuiData);
return FALSE;
}
Dc = GetDC(hWnd);
if (NULL == Dc)
{
DbgPrint("GuiConsoleNcCreate: GetDC failed\n");
HeapFree(UserCsrApiHeap, 0, GuiData);
HeapFree(Win32CsrApiHeap, 0, GuiData);
return FALSE;
}
OldFont = SelectObject(Dc, GuiData->Font);
@ -88,7 +89,7 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
{
DbgPrint("GuiConsoleNcCreate: SelectObject failed\n");
ReleaseDC(hWnd, Dc);
HeapFree(UserCsrApiHeap, 0, GuiData);
HeapFree(Win32CsrApiHeap, 0, GuiData);
return FALSE;
}
if (! GetTextMetricsW(Dc, &Metrics))
@ -96,7 +97,7 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
DbgPrint("GuiConsoleNcCreate: GetTextMetrics failed\n");
SelectObject(Dc, OldFont);
ReleaseDC(hWnd, Dc);
HeapFree(UserCsrApiHeap, 0, GuiData);
HeapFree(Win32CsrApiHeap, 0, GuiData);
return FALSE;
}
GuiData->CharWidth = Metrics.tmMaxCharWidth;
@ -275,7 +276,7 @@ GuiConsoleHandleKey(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
Message.wParam = wParam;
Message.lParam = lParam;
(*UserCsrProcessKey)(&Message, Console);
CsrProcessKey(&Message, Console);
}
static VOID FASTCALL
@ -406,7 +407,7 @@ GuiConsoleHandleNcDestroy(HWND hWnd)
GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
KillTimer(hWnd, 1);
Console->GuiConsoleData = NULL;
HeapFree(UserCsrApiHeap, 0, GuiData);
HeapFree(Win32CsrApiHeap, 0, GuiData);
}
static LRESULT CALLBACK
@ -467,7 +468,7 @@ GuiConsoleNotifyWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
SetWindowLongW(hWnd, GWL_USERDATA, 0);
return 0;
case PM_CREATE_CONSOLE:
NewWindow = CreateWindowW(L"UserCsrConsole",
NewWindow = CreateWindowW(L"Win32CsrConsole",
Console->Title.Buffer,
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
CW_USEDEFAULT,
@ -507,7 +508,7 @@ GuiConsoleGuiThread(PVOID Data)
MSG msg;
PHANDLE GraphicsStartupEvent = (PHANDLE) Data;
wc.lpszClassName = L"UserCsrCreateNotify";
wc.lpszClassName = L"Win32CsrCreateNotify";
wc.lpfnWndProc = GuiConsoleNotifyWndProc;
wc.style = 0;
wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
@ -523,7 +524,7 @@ GuiConsoleGuiThread(PVOID Data)
return 1;
}
wc.lpszClassName = L"UserCsrConsole";
wc.lpszClassName = L"Win32CsrConsole";
wc.lpfnWndProc = GuiConsoleWndProc;
wc.style = 0;
wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
@ -539,7 +540,7 @@ GuiConsoleGuiThread(PVOID Data)
return 1;
}
NotifyWnd = CreateWindowW(L"UserCsrCreateNotify",
NotifyWnd = CreateWindowW(L"Win32CsrCreateNotify",
L"",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
@ -580,18 +581,18 @@ GuiConsoleInitConsoleSupport(VOID)
WindowStation = OpenWindowStationW(L"WinSta0", FALSE, GENERIC_ALL);
if (NULL == WindowStation)
{
DbgPrint("UserCsr: failed to open window station\n");
DbgPrint("Win32Csr: failed to open window station\n");
return;
}
if (! SetProcessWindowStation(WindowStation))
{
DbgPrint("UserCsr: failed to set process window station\n");
DbgPrint("Win32Csr: failed to set process window station\n");
return;
}
Desktop = OpenDesktopW(L"Default", 0, FALSE, GENERIC_ALL);
if (NULL == Desktop)
{
DbgPrint("UserCsr: failed to open desktop\n");
DbgPrint("Win32Csr: failed to open desktop\n");
return;
}
Status = NtSetInformationProcess(NtCurrentProcess(),
@ -600,12 +601,12 @@ GuiConsoleInitConsoleSupport(VOID)
sizeof(Desktop));
if (!NT_SUCCESS(Status))
{
DbgPrint("UserCsr: cannot set default desktop.\n");
DbgPrint("Win32Csr: cannot set default desktop.\n");
return;
}
if (! SetThreadDesktop(Desktop))
{
DbgPrint("UserCsr: failed to set thread desktop\n");
DbgPrint("Win32Csr: failed to set thread desktop\n");
return;
}
@ -626,7 +627,7 @@ GuiConsoleInitConsoleSupport(VOID)
if (NULL == ThreadHandle)
{
NtClose(GraphicsStartupEvent);
DbgPrint("UserCsr: Failed to create graphics console thread. Expect problems\n");
DbgPrint("Win32Csr: Failed to create graphics console thread. Expect problems\n");
return;
}
CloseHandle(ThreadHandle);
@ -636,7 +637,7 @@ GuiConsoleInitConsoleSupport(VOID)
if (NULL == NotifyWnd)
{
DbgPrint("UserCsr: Failed to create notification window.\n");
DbgPrint("Win32Csr: Failed to create notification window.\n");
return;
}
}

6
reactos/subsys/csrss/usercsr/guiconsole.h → reactos/subsys/csrss/win32csr/guiconsole.h
View file

@ -1,9 +1,9 @@
/* $Id: guiconsole.h,v 1.1 2003/10/20 18:02:04 gvg Exp $
/* $Id: guiconsole.h,v 1.1 2003/12/02 11:38:46 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: subsys/csrss/usercsr/usercsr.h
* PURPOSE: Interface to usercsr.dll
* FILE: subsys/csrss/win32csr/guiconsole.h
* PURPOSE: Interface to GUI consoles
*/
#include "api.h"

8
reactos/subsys/csrss/win32csr/win32csr.def Normal file
View file

@ -0,0 +1,8 @@
; $Id: win32csr.def,v 1.1 2003/12/02 11:38:46 gvg Exp $
;
LIBRARY win32csr.dll
EXPORTS
Win32CsrInitialization

9
reactos/subsys/csrss/win32csr/win32csr.edf Normal file
View file

@ -0,0 +1,9 @@
; $Id: win32csr.edf,v 1.1 2003/12/02 11:38:46 gvg Exp $
;
;
LIBRARY win32csr.dll
EXPORTS
Win32CsrInitialization=Win32CsrInitialization@16

4
reactos/subsys/csrss/usercsr/usercsr.rc → reactos/subsys/csrss/win32csr/win32csr.rc
View file

@ -24,9 +24,9 @@ BEGIN
VALUE "CompanyName", RES_STR_COMPANY_NAME
VALUE "FileDescription", "CSRSS subsystem usermode code\0"
VALUE "FileVersion", RES_STR_FILE_VERSION
VALUE "InternalName", "usercsr\0"
VALUE "InternalName", "win32csr\0"
VALUE "LegalCopyright", RES_STR_LEGAL_COPYRIGHT
VALUE "OriginalFilename", "usercsr.dll\0"
VALUE "OriginalFilename", "win32csr.dll\0"
VALUE "ProductName", RES_STR_PRODUCT_NAME
VALUE "ProductVersion", RES_STR_PRODUCT_VERSION
END

6
reactos/tools/helper.mk
View file

@ -1,4 +1,4 @@
# $Id: helper.mk,v 1.45 2003/11/24 14:41:29 ekohl Exp $
# $Id: helper.mk,v 1.46 2003/12/02 11:38:47 gvg Exp $
#
# Helper makefile for ReactOS modules
# Variables this makefile accepts:
@ -825,13 +825,13 @@ else # MK_MODE
ifeq ($(INSTALL_SYMBOLS),yes)
install:
install: $(SUBDIRS:%=%_install)
-$(CP) $(MK_FULLNAME) $(INSTALL_DIR)/$(MK_INSTALLDIR)/$(MK_FULLNAME)
-$(CP) $(MK_BASENAME).sym $(INSTALL_DIR)/symbols/$(MK_BASENAME).sym
else # INSTALL_SYMBOLS
install:
install: $(SUBDIRS:%=%_install)
-$(CP) $(MK_FULLNAME) $(INSTALL_DIR)/$(MK_INSTALLDIR)/$(MK_FULLNAME)
endif # INSTALL_SYMBOLS