ReactOS  0.4.15-dev-1049-g1062a29
api.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define CsrAcquireProcessLock()   RtlEnterCriticalSection(&CsrProcessLock);
 
#define CsrReleaseProcessLock()   RtlLeaveCriticalSection(&CsrProcessLock);
 
#define ProcessStructureListLocked()   (CsrProcessLock.OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
 
#define CsrAcquireWaitLock()   RtlEnterCriticalSection(&CsrWaitListsLock);
 
#define CsrReleaseWaitLock()   RtlLeaveCriticalSection(&CsrWaitListsLock);
 
#define CsrAcquireNtSessionLock()   RtlEnterCriticalSection(&CsrNtSessionLock);
 
#define CsrReleaseNtSessionLock()   RtlLeaveCriticalSection(&CsrNtSessionLock);
 
#define CSR_SERVER_DLL_MAX   4
 
#define NUMBER_THREAD_HASH_BUCKETS   257
 

Functions

 CSR_API (CsrSrvClientConnect)
 
 CSR_API (CsrSrvUnusedFunction)
 
 CSR_API (CsrSrvIdentifyAlertableThread)
 
 CSR_API (CsrSrvSetPriorityClass)
 
NTSTATUS NTAPI CsrServerDllInitialization (IN PCSR_SERVER_DLL LoadedServerDll)
 
BOOLEAN NTAPI CsrCaptureArguments (IN PCSR_THREAD CsrThread, IN PCSR_API_MESSAGE ApiMessage)
 
VOID NTAPI CsrReleaseCapturedArguments (IN PCSR_API_MESSAGE ApiMessage)
 
NTSTATUS NTAPI CsrLoadServerDll (IN PCHAR DllString, IN PCHAR EntryPoint OPTIONAL, IN ULONG ServerId)
 
PCSR_THREAD NTAPI CsrAllocateThread (IN PCSR_PROCESS CsrProcess)
 
PCSR_PROCESS NTAPI CsrAllocateProcess (VOID)
 
VOID NTAPI CsrDeallocateProcess (IN PCSR_PROCESS CsrProcess)
 
VOID NTAPI CsrInsertProcess (IN PCSR_PROCESS ParentProcess OPTIONAL, IN PCSR_PROCESS CsrProcess)
 
VOID NTAPI CsrRemoveProcess (IN PCSR_PROCESS CsrProcess)
 
NTSTATUS NTAPI CsrApiRequestThread (IN PVOID Parameter)
 
VOID NTAPI CsrSbApiRequestThread (IN PVOID Parameter)
 
NTSTATUS NTAPI CsrApiPortInitialize (VOID)
 
BOOLEAN NTAPI ProtectHandle (IN HANDLE ObjectHandle)
 
BOOLEAN NTAPI UnProtectHandle (IN HANDLE ObjectHandle)
 
NTSTATUS NTAPI CsrInsertThread (IN PCSR_PROCESS Process, IN PCSR_THREAD Thread)
 
VOID NTAPI CsrDeallocateThread (IN PCSR_THREAD CsrThread)
 
VOID NTAPI CsrLockedReferenceProcess (IN PCSR_PROCESS CsrProcess)
 
VOID NTAPI CsrLockedReferenceThread (IN PCSR_THREAD CsrThread)
 
NTSTATUS NTAPI CsrInitializeProcessStructure (VOID)
 
PCSR_THREAD NTAPI CsrLocateThreadInProcess (IN PCSR_PROCESS CsrProcess OPTIONAL, IN PCLIENT_ID Cid)
 
PCSR_THREAD NTAPI CsrLocateThreadByClientId (OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
 
NTSTATUS NTAPI CsrInitializeNtSessionList (VOID)
 
NTSTATUS NTAPI CsrSrvAttachSharedSection (IN PCSR_PROCESS CsrProcess OPTIONAL, OUT PCSR_API_CONNECTINFO ConnectInfo)
 
NTSTATUS NTAPI CsrSrvCreateSharedSection (IN PCHAR ParameterValue)
 
VOID NTAPI CsrLockedDereferenceProcess (PCSR_PROCESS CsrProcess)
 
VOID NTAPI CsrLockedDereferenceThread (IN PCSR_THREAD CsrThread)
 
BOOLEAN NTAPI CsrNotifyWaitBlock (IN PCSR_WAIT_BLOCK WaitBlock, IN PLIST_ENTRY WaitList, IN PVOID WaitArgument1, IN PVOID WaitArgument2, IN ULONG WaitFlags, IN BOOLEAN DereferenceThread)
 
VOID NTAPI CsrReferenceNtSession (IN PCSR_NT_SESSION Session)
 
VOID NTAPI CsrDereferenceNtSession (IN PCSR_NT_SESSION Session, IN NTSTATUS ExitStatus)
 
NTSTATUS NTAPI CsrCreateSessionObjectDirectory (IN ULONG SessionId)
 
NTSTATUS NTAPI CsrCreateObjectDirectory (IN PCHAR ObjectDirectory)
 
NTSTATUS NTAPI CsrSbApiPortInitialize (VOID)
 
BOOLEAN NTAPI CsrSbCreateSession (IN PSB_API_MSG ApiMessage)
 
BOOLEAN NTAPI CsrSbTerminateSession (IN PSB_API_MSG ApiMessage)
 
BOOLEAN NTAPI CsrSbForeignSessionComplete (IN PSB_API_MSG ApiMessage)
 
BOOLEAN NTAPI CsrSbCreateProcess (IN PSB_API_MSG ApiMessage)
 
NTSTATUS NTAPI CsrSbApiHandleConnectionRequest (IN PSB_API_MSG Message)
 
NTSTATUS NTAPI CsrApiHandleConnectionRequest (IN PCSR_API_MESSAGE ApiMessage)
 
NTSTATUS NTAPI CsrCreateLocalSystemSD (OUT PSECURITY_DESCRIPTOR *LocalSystemSd)
 
NTSTATUS NTAPI CsrSetDirectorySecurity (IN HANDLE ObjectDirectory)
 

Variables

RTL_CRITICAL_SECTION CsrProcessLock
 
RTL_CRITICAL_SECTION CsrWaitListsLock
 
ULONG CsrDebug
 
HANDLE hBootstrapOk
 
HANDLE CsrApiPort
 
HANDLE CsrSmApiPort
 
HANDLE CsrSbApiPort
 
LIST_ENTRY CsrThreadHashTable [NUMBER_THREAD_HASH_BUCKETS]
 
PCSR_PROCESS CsrRootProcess
 
UNICODE_STRING CsrDirectoryName
 
ULONG CsrTotalPerProcessDataLength
 
SYSTEM_BASIC_INFORMATION CsrNtSysInfo
 
HANDLE CsrHeap
 
PVOID CsrSrvSharedSectionHeap
 
PVOIDCsrSrvSharedStaticServerData
 
HANDLE CsrInitializationEvent
 
PCSR_SERVER_DLL CsrLoadedServerDll [CSR_SERVER_DLL_MAX]
 
ULONG CsrMaxApiRequestThreads
 
UNICODE_STRING CsrSbApiPortName
 
UNICODE_STRING CsrApiPortName
 
HANDLE CsrObjectDirectory
 

Macro Definition Documentation

◆ CSR_SERVER_DLL_MAX

#define CSR_SERVER_DLL_MAX   4

Definition at line 34 of file api.h.

◆ CsrAcquireNtSessionLock

#define CsrAcquireNtSessionLock ( )    RtlEnterCriticalSection(&CsrNtSessionLock);

Definition at line 27 of file api.h.

◆ CsrAcquireProcessLock

#define CsrAcquireProcessLock ( )    RtlEnterCriticalSection(&CsrProcessLock);

Definition at line 12 of file api.h.

◆ CsrAcquireWaitLock

#define CsrAcquireWaitLock ( )    RtlEnterCriticalSection(&CsrWaitListsLock);

Definition at line 21 of file api.h.

◆ CsrReleaseNtSessionLock

#define CsrReleaseNtSessionLock ( )    RtlLeaveCriticalSection(&CsrNtSessionLock);

Definition at line 30 of file api.h.

◆ CsrReleaseProcessLock

#define CsrReleaseProcessLock ( )    RtlLeaveCriticalSection(&CsrProcessLock);

Definition at line 15 of file api.h.

◆ CsrReleaseWaitLock

#define CsrReleaseWaitLock ( )    RtlLeaveCriticalSection(&CsrWaitListsLock);

Definition at line 24 of file api.h.

◆ NUMBER_THREAD_HASH_BUCKETS

#define NUMBER_THREAD_HASH_BUCKETS   257

Definition at line 44 of file api.h.

◆ ProcessStructureListLocked

#define ProcessStructureListLocked ( )    (CsrProcessLock.OwningThread == NtCurrentTeb()->ClientId.UniqueThread)

Definition at line 18 of file api.h.

Function Documentation

◆ CSR_API() [1/4]

CSR_API ( CsrSrvClientConnect  )

Definition at line 283 of file server.c.

284 {
286  PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage->Data.CsrClientConnect;
287  PCSR_SERVER_DLL ServerDll;
289 
290  /* Set default reply */
291  *ReplyCode = CsrReplyImmediately;
292 
293  /* Validate the ServerID */
294  if (ClientConnect->ServerId >= CSR_SERVER_DLL_MAX)
295  {
296  return STATUS_TOO_MANY_NAMES;
297  }
298  else if (!CsrLoadedServerDll[ClientConnect->ServerId])
299  {
301  }
302 
303  /* Validate the Message Buffer */
304  if (!(CsrValidateMessageBuffer(ApiMessage,
305  &ClientConnect->ConnectionInfo,
306  ClientConnect->ConnectionInfoSize,
307  sizeof(BYTE))))
308  {
309  /* Fail due to buffer overflow or other invalid buffer */
311  }
312 
313  /* Load the Server DLL */
314  ServerDll = CsrLoadedServerDll[ClientConnect->ServerId];
315 
316  /* Check if it has a Connect Callback */
317  if (ServerDll->ConnectCallback)
318  {
319  /* Call the callback */
321  ClientConnect->ConnectionInfo,
322  &ClientConnect->ConnectionInfoSize);
323  }
324  else
325  {
326  /* Assume success */
328  }
329 
330  /* Return status */
331  return Status;
332 }
#define CsrGetClientThread()
Definition: csrsrv.h:77
PCSR_CONNECT_CALLBACK ConnectCallback
Definition: csrsrv.h:235
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI CsrValidateMessageBuffer(IN PCSR_API_MESSAGE ApiMessage, IN PVOID *Buffer, IN ULONG ElementCount, IN ULONG ElementSize)
Definition: api.c:1426
PVOID ConnectionInfo
Definition: csrmsg.h:88
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
ULONG CurrentProcess
Definition: shell.c:125
ULONG ConnectionInfoSize
Definition: csrmsg.h:89
Status
Definition: gdiplustypes.h:24
unsigned char BYTE
Definition: xxhash.c:193
#define STATUS_TOO_MANY_NAMES
Definition: ntstatus.h:441
return STATUS_SUCCESS
Definition: btrfs.c:3014
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20

◆ CSR_API() [2/4]

CSR_API ( CsrSrvUnusedFunction  )

Definition at line 575 of file server.c.

576 {
577  /* Deprecated */
579 }
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

◆ CSR_API() [3/4]

CSR_API ( CsrSrvIdentifyAlertableThread  )

Definition at line 521 of file server.c.

522 {
523  PCSR_THREAD CsrThread = CsrGetClientThread();
524 
525  /* Set the alertable flag */
526  CsrThread->Flags |= CsrThreadAlertable;
527 
528  /* Return success */
529  return STATUS_SUCCESS;
530 }
#define CsrGetClientThread()
Definition: csrsrv.h:77
ULONG Flags
Definition: csrsrv.h:72
return STATUS_SUCCESS
Definition: btrfs.c:3014

◆ CSR_API() [4/4]

CSR_API ( CsrSrvSetPriorityClass  )

Definition at line 549 of file server.c.

550 {
551  /* Deprecated */
552  return STATUS_SUCCESS;
553 }
return STATUS_SUCCESS
Definition: btrfs.c:3014

◆ CsrAllocateProcess()

PCSR_PROCESS NTAPI CsrAllocateProcess ( VOID  )

Definition at line 188 of file procsup.c.

189 {
191  ULONG TotalSize;
192 
193  /* Calculate the amount of memory this should take */
194  TotalSize = sizeof(CSR_PROCESS) +
195  (CSR_SERVER_DLL_MAX * sizeof(PVOID)) +
197 
198  /* Allocate a Process */
200  if (!CsrProcess) return NULL;
201 
202  /* Handle the Sequence Number and protect against overflow */
203  CsrProcess->SequenceNumber = CsrProcessSequenceCount++;
205 
206  /* Increase the reference count */
208 
209  /* Initialize the Thread List */
210  InitializeListHead(&CsrProcess->ThreadList);
211 
212  /* Return the Process */
213  return CsrProcess;
214 }
PKPROCESS CsrProcess
Definition: videoprt.c:39
ULONG CsrProcessSequenceCount
Definition: procsup.c:30
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
struct _CSR_PROCESS CSR_PROCESS
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:232
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
unsigned int ULONG
Definition: retypes.h:1
HANDLE CsrHeap
Definition: init.c:25
ULONG CsrTotalPerProcessDataLength
Definition: init.c:35

Referenced by CsrCreateProcess(), CsrInitializeProcessStructure(), and CsrSbCreateSession().

◆ CsrAllocateThread()

PCSR_THREAD NTAPI CsrAllocateThread ( IN PCSR_PROCESS  CsrProcess)

Definition at line 119 of file thredsup.c.

120 {
121  PCSR_THREAD CsrThread;
122 
123  /* Allocate the structure */
124  CsrThread = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, sizeof(CSR_THREAD));
125  if (!CsrThread) return NULL;
126 
127  /* Reference the Thread and Process */
128  CsrLockedReferenceThread(CsrThread);
130 
131  /* Set the Parent Process */
132  CsrThread->Process = CsrProcess;
133 
134  /* Return Thread */
135  return CsrThread;
136 }
VOID NTAPI CsrLockedReferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:154
PKPROCESS CsrProcess
Definition: videoprt.c:39
PCSR_PROCESS Process
Definition: csrsrv.h:69
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:232
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().

◆ CsrApiHandleConnectionRequest()

NTSTATUS NTAPI CsrApiHandleConnectionRequest ( IN PCSR_API_MESSAGE  ApiMessage)

Definition at line 140 of file api.c.

141 {
142  PCSR_THREAD CsrThread = NULL;
145  PCSR_API_CONNECTINFO ConnectInfo = &ApiMessage->ConnectionInfo;
146  BOOLEAN AllowConnection = FALSE;
147  REMOTE_PORT_VIEW RemotePortView;
149 
150  /* Acquire the Process Lock */
152 
153  /* Lookup the CSR Thread */
154  CsrThread = CsrLocateThreadByClientId(NULL, &ApiMessage->Header.ClientId);
155 
156  /* Check if we have a thread */
157  if (CsrThread)
158  {
159  /* Get the Process and make sure we have it as well */
160  CsrProcess = CsrThread->Process;
161  if (CsrProcess)
162  {
163  /* Reference the Process */
165 
166  /* Attach the Shared Section */
168  if (NT_SUCCESS(Status))
169  {
170  /* Allow the connection and return debugging flag */
171  ConnectInfo->DebugFlags = CsrDebug;
172  AllowConnection = TRUE;
173  }
174 
175  /* Dereference the Process */
177  }
178  }
179 
180  /* Release the Process Lock */
182 
183  /* Setup the Port View Structure */
184  RemotePortView.Length = sizeof(REMOTE_PORT_VIEW);
185  RemotePortView.ViewSize = 0;
186  RemotePortView.ViewBase = NULL;
187 
188  /* Save the Process ID */
189  ConnectInfo->ServerProcessId = NtCurrentTeb()->ClientId.UniqueProcess;
190 
191  /* Accept the Connection */
192  ASSERT(!AllowConnection || (AllowConnection && CsrProcess));
194  AllowConnection ? UlongToPtr(CsrProcess->SequenceNumber) : 0,
195  &ApiMessage->Header,
196  AllowConnection,
197  NULL,
198  &RemotePortView);
199  if (!NT_SUCCESS(Status))
200  {
201  DPRINT1("CSRSS: NtAcceptConnectPort - failed. Status == %X\n", Status);
202  }
203  else if (AllowConnection)
204  {
205  if (CsrDebug & 2)
206  {
207  DPRINT1("CSRSS: ClientId: %lx.%lx has ClientView: Base=%p, Size=%lx\n",
208  ApiMessage->Header.ClientId.UniqueProcess,
209  ApiMessage->Header.ClientId.UniqueThread,
210  RemotePortView.ViewBase,
211  RemotePortView.ViewSize);
212  }
213 
214  /* Set some Port Data in the Process */
215  CsrProcess->ClientPort = ServerPort;
216  CsrProcess->ClientViewBase = (ULONG_PTR)RemotePortView.ViewBase;
217  CsrProcess->ClientViewBounds = (ULONG_PTR)((ULONG_PTR)RemotePortView.ViewBase +
218  (ULONG_PTR)RemotePortView.ViewSize);
219 
220  /* Complete the connection */
222  if (!NT_SUCCESS(Status))
223  {
224  DPRINT1("CSRSS: NtCompleteConnectPort - failed. Status == %X\n", Status);
225  }
226  }
227  else
228  {
229  DPRINT1("CSRSS: Rejecting Connection Request from ClientId: %lx.%lx\n",
230  ApiMessage->Header.ClientId.UniqueProcess,
231  ApiMessage->Header.ClientId.UniqueThread);
232  }
233 
234  /* Return status to caller */
235  return Status;
236 }
#define TRUE
Definition: types.h:120
_Must_inspect_result_ _Outptr_ PFLT_PORT * ServerPort
Definition: fltkernel.h:1873
LONG NTSTATUS
Definition: precomp.h:26
ULONG CsrDebug
Definition: init.c:23
PKPROCESS CsrProcess
Definition: videoprt.c:39
#define CsrReleaseProcessLock()
Definition: api.h:15
uint32_t ULONG_PTR
Definition: typedefs.h:65
PCSR_PROCESS Process
Definition: csrsrv.h:69
HANDLE ServerProcessId
Definition: csrmsg.h:57
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
struct _REMOTE_PORT_VIEW REMOTE_PORT_VIEW
#define UlongToPtr(u)
Definition: config.h:106
NTSTATUS NTAPI CsrSrvAttachSharedSection(IN PCSR_PROCESS CsrProcess OPTIONAL, OUT PCSR_API_CONNECTINFO ConnectInfo)
Definition: server.c:472
NTSTATUS NTAPI NtAcceptConnectPort(OUT PHANDLE PortHandle, IN PVOID PortContext OPTIONAL, IN PPORT_MESSAGE ReplyMessage, IN BOOLEAN AcceptConnection, IN OUT PPORT_VIEW ServerView OPTIONAL, OUT PREMOTE_PORT_VIEW ClientView OPTIONAL)
Definition: complete.c:40
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define CsrAcquireProcessLock()
Definition: api.h:12
Status
Definition: gdiplustypes.h:24
PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
Definition: thredsup.c:182
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
#define DPRINT1
Definition: precomp.h:8
NTSTATUS NTAPI NtCompleteConnectPort(IN HANDLE PortHandle)
Definition: complete.c:421
#define ULONG_PTR
Definition: config.h:101
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:232
return STATUS_SUCCESS
Definition: btrfs.c:3014
VOID NTAPI CsrLockedDereferenceProcess(PCSR_PROCESS CsrProcess)
Definition: procsup.c:159

Referenced by CsrApiRequestThread().

◆ CsrApiPortInitialize()

NTSTATUS NTAPI CsrApiPortInitialize ( VOID  )

Definition at line 896 of file api.c.

897 {
898  ULONG Size;
901  HANDLE hRequestEvent, hThread;
903  PLIST_ENTRY ListHead, NextEntry;
905 
906  /* Calculate how much space we'll need for the Port Name */
907  Size = CsrDirectoryName.Length + sizeof(CSR_PORT_NAME) + sizeof(WCHAR);
908 
909  /* Create the buffer for it */
912 
913  /* Setup the rest of the empty string */
919  if (CsrDebug & 1)
920  {
921  DPRINT1("CSRSS: Creating %wZ port and associated threads\n", &CsrApiPortName);
922  DPRINT1("CSRSS: sizeof( CONNECTINFO ) == %ld sizeof( API_MSG ) == %ld\n",
923  sizeof(CSR_API_CONNECTINFO), sizeof(CSR_API_MESSAGE));
924  }
925 
926  /* FIXME: Create a Security Descriptor */
927 
928  /* Initialize the Attributes */
931  0,
932  NULL,
933  NULL /* FIXME: Use the Security Descriptor */);
934 
935  /* Create the Port Object */
938  sizeof(CSR_API_CONNECTINFO),
939  sizeof(CSR_API_MESSAGE),
940  16 * PAGE_SIZE);
941  if (NT_SUCCESS(Status))
942  {
943  /* Create the event the Port Thread will use */
944  Status = NtCreateEvent(&hRequestEvent,
946  NULL,
948  FALSE);
949  if (NT_SUCCESS(Status))
950  {
951  /* Create the Request Thread */
953  NULL,
954  TRUE,
955  0,
956  0,
957  0,
959  (PVOID)hRequestEvent,
960  &hThread,
961  &ClientId);
962  if (NT_SUCCESS(Status))
963  {
964  /* Add this as a static thread to CSRSRV */
966 
967  /* Get the Thread List Pointers */
968  ListHead = &CsrRootProcess->ThreadList;
969  NextEntry = ListHead->Flink;
970 
971  /* Start looping the list */
972  while (NextEntry != ListHead)
973  {
974  /* Get the Thread */
976 
977  /* Start it up */
978  Status = NtResumeThread(ServerThread->ThreadHandle, NULL);
979 
980  /* Is this a Server Thread? */
982  {
983  /* If so, then wait for it to initialize */
984  Status = NtWaitForSingleObject(hRequestEvent, FALSE, NULL);
986  }
987 
988  /* Next thread */
989  NextEntry = NextEntry->Flink;
990  }
991 
992  /* We don't need this anymore */
993  NtClose(hRequestEvent);
994  }
995  }
996  }
997 
998  /* Return */
999  return Status;
1000 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
ULONG CsrDebug
Definition: init.c:23
#define CSR_PORT_NAME
Definition: csrmsg.h:17
static int Link(const char **args)
Definition: vfdcmd.c:2414
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:511
#define FALSE
Definition: types.h:117
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
UINT CALLBACK ServerThread(_Inout_ PVOID Parameter)
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define NtCurrentProcess()
Definition: nt_native.h:1657
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163
NTSTATUS NTAPI NtCreatePort(OUT PHANDLE PortHandle, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG MaxConnectInfoLength, IN ULONG MaxDataLength, IN ULONG MaxPoolUsage)
Definition: create.c:212
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Status
Definition: gdiplustypes.h:24
NTSTATUS NTAPI CsrApiRequestThread(IN PVOID Parameter)
Definition: api.c:332
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Definition: typedefs.h:119
UNICODE_STRING CsrDirectoryName
Definition: init.c:27
NTSYSAPI NTSTATUS NTAPI RtlCreateUserThread(_In_ PVOID ThreadContext, _Out_ HANDLE *OutThreadHandle, _Reserved_ PVOID Reserved1, _Reserved_ PVOID Reserved2, _Reserved_ PVOID Reserved3, _Reserved_ PVOID Reserved4, _Reserved_ PVOID Reserved5, _Reserved_ PVOID Reserved6, _Reserved_ PVOID Reserved7, _Reserved_ PVOID Reserved8)
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
HANDLE CsrApiPort
Definition: connect.c:21
unsigned short USHORT
Definition: pedump.c:61
LIST_ENTRY ThreadList
Definition: csrsrv.h:40
#define UNICODE_PATH_SEP
Definition: connect.c:33
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
HANDLE hThread
Definition: wizard.c:27
#define DPRINT1
Definition: precomp.h:8
UNICODE_STRING CsrApiPortName
Definition: api.c:22
unsigned int ULONG
Definition: retypes.h:1
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
HANDLE CsrHeap
Definition: init.c:25
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)

Referenced by CsrServerInitialization().

◆ CsrApiRequestThread()

NTSTATUS NTAPI CsrApiRequestThread ( IN PVOID  Parameter)

Definition at line 332 of file api.c.

333 {
334  PTEB Teb = NtCurrentTeb();
335  LARGE_INTEGER TimeOut;
336  PCSR_THREAD CurrentThread, CsrThread;
338  CSR_REPLY_CODE ReplyCode;
339  PCSR_API_MESSAGE ReplyMsg;
340  CSR_API_MESSAGE ReceiveMsg;
342  PHARDERROR_MSG HardErrorMsg;
343  PVOID PortContext;
344  PCSR_SERVER_DLL ServerDll;
345  PCLIENT_DIED_MSG ClientDiedMsg;
346  PDBGKM_MSG DebugMessage;
347  ULONG ServerId, ApiId, MessageType, i;
348  HANDLE ReplyPort;
349 
350  /* Setup LPC loop port and message */
351  ReplyMsg = NULL;
352  ReplyPort = CsrApiPort;
353 
354  /* Connect to user32 */
355  while (!CsrConnectToUser())
356  {
357  /* Set up the timeout for the connect (30 seconds) */
358  TimeOut.QuadPart = -30 * 1000 * 1000 * 10;
359 
360  /* Keep trying until we get a response */
361  Teb->Win32ClientInfo[0] = 0;
362  NtDelayExecution(FALSE, &TimeOut);
363  }
364 
365  /* Get our thread */
366  CurrentThread = Teb->CsrClientThread;
367 
368  /* If we got an event... */
369  if (Parameter)
370  {
371  /* Set it, to let stuff waiting on us load */
374 
375  /* Increase the Thread Counts */
378  }
379 
380  /* Now start the loop */
381  while (TRUE)
382  {
383  /* Make sure the real CID is set */
384  Teb->RealClientId = Teb->ClientId;
385 
386 #ifdef CSR_DBG
387  /* Debug check */
389  {
390  DPRINT1("CSRSRV: FATAL ERROR. CsrThread is Idle while holding %lu critical sections\n",
392  DPRINT1("CSRSRV: Last Receive Message %lx ReplyMessage %lx\n",
393  &ReceiveMsg, ReplyMsg);
394  DbgBreakPoint();
395  }
396 #endif
397 
398  /* Wait for a message to come through */
399  Status = NtReplyWaitReceivePort(ReplyPort,
400  &PortContext,
401  &ReplyMsg->Header,
402  &ReceiveMsg.Header);
403 
404  /* Check if we didn't get success */
405  if (Status != STATUS_SUCCESS)
406  {
407  /* Was it a failure or another success code? */
408  if (!NT_SUCCESS(Status))
409  {
410 #ifdef CSR_DBG
411  /* Check for specific status cases */
412  if ((Status != STATUS_INVALID_CID) &&
414  ((Status != STATUS_INVALID_HANDLE) || (ReplyPort == CsrApiPort)))
415  {
416  /* Notify the debugger */
417  DPRINT1("CSRSS: ReceivePort failed - Status == %X\n", Status);
418  DPRINT1("CSRSS: ReplyPortHandle %lx CsrApiPort %lx\n", ReplyPort, CsrApiPort);
419  }
420 #endif
421 
422  /* We failed big time, so start out fresh */
423  ReplyMsg = NULL;
424  ReplyPort = CsrApiPort;
425  continue;
426  }
427  else
428  {
429  /* A strange "success" code, just try again */
430  DPRINT1("NtReplyWaitReceivePort returned \"success\" status 0x%x\n", Status);
431  continue;
432  }
433  }
434 
435  // ASSERT(ReceiveMsg.Header.u1.s1.TotalLength >= sizeof(PORT_MESSAGE));
436  // ASSERT(ReceiveMsg.Header.u1.s1.TotalLength < sizeof(ReceiveMsg));
437 
438  /* Use whatever Client ID we got */
439  Teb->RealClientId = ReceiveMsg.Header.ClientId;
440 
441  /* Get the Message Type */
442  MessageType = ReceiveMsg.Header.u2.s2.Type;
443 
444  /* Handle connection requests */
445  if (MessageType == LPC_CONNECTION_REQUEST)
446  {
447  /* Handle the Connection Request */
448  CsrApiHandleConnectionRequest(&ReceiveMsg);
449 
450  ReplyMsg = NULL;
451  ReplyPort = CsrApiPort;
452  continue;
453  }
454 
455  /* It's some other kind of request. Get the lock for the lookup */
457 
458  /* Now do the lookup to get the CSR_THREAD */
460  &ReceiveMsg.Header.ClientId);
461 
462  /* Did we find a thread? */
463  if (!CsrThread)
464  {
465  /* This wasn't a CSR Thread, release lock */
467 
468  /* If this was an exception, handle it */
469  if (MessageType == LPC_EXCEPTION)
470  {
471  ReplyMsg = &ReceiveMsg;
472  ReplyPort = CsrApiPort;
473  ReplyMsg->Status = DBG_CONTINUE;
474  }
475  else if (MessageType == LPC_PORT_CLOSED ||
476  MessageType == LPC_CLIENT_DIED)
477  {
478  /* The Client or Port are gone, loop again */
479  ReplyMsg = NULL;
480  ReplyPort = CsrApiPort;
481  }
482  else if (MessageType == LPC_ERROR_EVENT)
483  {
484  /* If it's a hard error, handle this too */
485  HardErrorMsg = (PHARDERROR_MSG)&ReceiveMsg;
486 
487  /* Default it to unhandled */
488  HardErrorMsg->Response = ResponseNotHandled;
489 
490  /* Check if there are free api threads */
493  {
494  /* Loop every Server DLL */
495  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
496  {
497  /* Get the Server DLL */
498  ServerDll = CsrLoadedServerDll[i];
499 
500  /* Check if it's valid and if it has a Hard Error Callback */
501  if ((ServerDll) && (ServerDll->HardErrorCallback))
502  {
503  /* Call it */
504  ServerDll->HardErrorCallback(NULL /* == CsrThread */, HardErrorMsg);
505 
506  /* If it's handled, get out of here */
507  if (HardErrorMsg->Response != ResponseNotHandled) break;
508  }
509  }
510  }
511 
512  /* Increase the thread count */
514 
515  /* If the response was 0xFFFFFFFF, we'll ignore it */
516  if (HardErrorMsg->Response == 0xFFFFFFFF)
517  {
518  ReplyMsg = NULL;
519  ReplyPort = CsrApiPort;
520  }
521  else
522  {
523  ReplyMsg = &ReceiveMsg;
524  ReplyPort = CsrApiPort;
525  }
526  }
527  else if (MessageType == LPC_REQUEST)
528  {
529  /* This is an API Message coming from a non-CSR Thread */
530  ReplyMsg = &ReceiveMsg;
531  ReplyPort = CsrApiPort;
532  ReplyMsg->Status = STATUS_ILLEGAL_FUNCTION;
533  }
534  else if (MessageType == LPC_DATAGRAM)
535  {
536  /* This is an API call, get the Server ID */
537  ServerId = CSR_API_NUMBER_TO_SERVER_ID(ReceiveMsg.ApiNumber);
538 
539  /* Make sure that the ID is within limits, and the Server DLL loaded */
540  ServerDll = NULL;
541  if ((ServerId >= CSR_SERVER_DLL_MAX) ||
542  (!(ServerDll = CsrLoadedServerDll[ServerId])))
543  {
544  /* We are beyond the Maximum Server ID */
545 #ifdef CSR_DBG
546  DPRINT1("CSRSS: %lx is invalid ServerDllIndex (%08x)\n",
547  ServerId, ServerDll);
548  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
549 #endif
550 
551  ReplyMsg = NULL;
552  ReplyPort = CsrApiPort;
553  continue;
554  }
555 
556  /* Get the API ID, normalized with our Base ID */
557  ApiId = CSR_API_NUMBER_TO_API_ID(ReceiveMsg.ApiNumber) - ServerDll->ApiBase;
558 
559  /* Make sure that the ID is within limits, and the entry exists */
560  if (ApiId >= ServerDll->HighestApiSupported)
561  {
562  /* We are beyond the Maximum API ID, or it doesn't exist */
563  DPRINT1("CSRSS: %lx is invalid ApiTableIndex for %Z\n",
565  &ServerDll->Name);
566 
567  ReplyPort = CsrApiPort;
568  ReplyMsg = NULL;
569  continue;
570  }
571 
572 #ifdef CSR_DBG
573  if (CsrDebug & 2)
574  {
575  DPRINT1("[%02x] CSRSS: [%02x,%02x] - %s Api called from %08x\n",
576  Teb->ClientId.UniqueThread,
577  ReceiveMsg.Header.ClientId.UniqueProcess,
578  ReceiveMsg.Header.ClientId.UniqueThread,
579  ServerDll->NameTable[ApiId],
580  NULL);
581  }
582 #endif
583 
584  /* Assume success */
585  ReceiveMsg.Status = STATUS_SUCCESS;
586 
587  /* Validation complete, start SEH */
588  _SEH2_TRY
589  {
590  /* Make sure we have enough threads */
592 
593  /* Call the API and get the reply code */
594  ReplyMsg = NULL;
595  ReplyPort = CsrApiPort;
596  ServerDll->DispatchTable[ApiId](&ReceiveMsg, &ReplyCode);
597 
598  /* Increase the static thread count */
600  }
602  {
603  ReplyMsg = NULL;
604  ReplyPort = CsrApiPort;
605  }
606  _SEH2_END;
607  }
608  else
609  {
610  /* Some other ignored message type */
611  ReplyMsg = NULL;
612  ReplyPort = CsrApiPort;
613  }
614 
615  /* Keep going */
616  continue;
617  }
618 
619  /* We have a valid thread, was this an LPC Request? */
620  if (MessageType != LPC_REQUEST)
621  {
622  /* It's not an API, check if the client died */
623  if (MessageType == LPC_CLIENT_DIED)
624  {
625  /* Get the information and check if it matches our thread */
626  ClientDiedMsg = (PCLIENT_DIED_MSG)&ReceiveMsg;
627  if (ClientDiedMsg->CreateTime.QuadPart == CsrThread->CreateTime.QuadPart)
628  {
629  /* Now we reply to the dying client */
630  ReplyPort = CsrThread->Process->ClientPort;
631 
632  /* Reference the thread */
633  CsrLockedReferenceThread(CsrThread);
634 
635  /* Destroy the thread in the API Message */
636  CsrDestroyThread(&ReceiveMsg.Header.ClientId);
637 
638  /* Check if the thread was actually ourselves */
639  if (CsrProcess->ThreadCount == 1)
640  {
641  /* Kill the process manually here */
642  CsrDestroyProcess(&CsrThread->ClientId, 0);
643  }
644 
645  /* Remove our extra reference */
646  CsrLockedDereferenceThread(CsrThread);
647  }
648 
649  /* Release the lock and keep looping */
651 
652  ReplyMsg = NULL;
653  ReplyPort = CsrApiPort;
654  continue;
655  }
656 
657  /* Reference the thread and release the lock */
658  CsrLockedReferenceThread(CsrThread);
660 
661  /* Check if this was an exception */
662  if (MessageType == LPC_EXCEPTION)
663  {
664  /* Kill the process */
666 
667  /* Destroy it from CSR */
669 
670  /* Return a Debug Message */
671  DebugMessage = (PDBGKM_MSG)&ReceiveMsg;
672  DebugMessage->ReturnedStatus = DBG_CONTINUE;
673  ReplyMsg = &ReceiveMsg;
674  ReplyPort = CsrApiPort;
675 
676  /* Remove our extra reference */
677  CsrDereferenceThread(CsrThread);
678  }
679  else if (MessageType == LPC_ERROR_EVENT)
680  {
681  /* If it's a hard error, handle this too */
682  HardErrorMsg = (PHARDERROR_MSG)&ReceiveMsg;
683 
684  /* Default it to unhandled */
685  HardErrorMsg->Response = ResponseNotHandled;
686 
687  /* Check if there are free api threads */
690  {
691  /* Loop every Server DLL */
692  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
693  {
694  /* Get the Server DLL */
695  ServerDll = CsrLoadedServerDll[i];
696 
697  /* Check if it's valid and if it has a Hard Error Callback */
698  if ((ServerDll) && (ServerDll->HardErrorCallback))
699  {
700  /* Call it */
701  ServerDll->HardErrorCallback(CsrThread, HardErrorMsg);
702 
703  /* If it's handled, get out of here */
704  if (HardErrorMsg->Response != ResponseNotHandled) break;
705  }
706  }
707  }
708 
709  /* Increase the thread count */
711 
712  /* If the response was 0xFFFFFFFF, we'll ignore it */
713  if (HardErrorMsg->Response == 0xFFFFFFFF)
714  {
715  ReplyMsg = NULL;
716  ReplyPort = CsrApiPort;
717  }
718  else
719  {
720  CsrDereferenceThread(CsrThread);
721  ReplyMsg = &ReceiveMsg;
722  ReplyPort = CsrApiPort;
723  }
724  }
725  else
726  {
727  /* Something else */
728  CsrDereferenceThread(CsrThread);
729  ReplyMsg = NULL;
730  }
731 
732  /* Keep looping */
733  continue;
734  }
735 
736  /* We got an API Request */
737  CsrLockedReferenceThread(CsrThread);
739 
740  /* This is an API call, get the Server ID */
741  ServerId = CSR_API_NUMBER_TO_SERVER_ID(ReceiveMsg.ApiNumber);
742 
743  /* Make sure that the ID is within limits, and the Server DLL loaded */
744  ServerDll = NULL;
745  if ((ServerId >= CSR_SERVER_DLL_MAX) ||
746  (!(ServerDll = CsrLoadedServerDll[ServerId])))
747  {
748  /* We are beyond the Maximum Server ID */
749 #ifdef CSR_DBG
750  DPRINT1("CSRSS: %lx is invalid ServerDllIndex (%08x)\n",
751  ServerId, ServerDll);
752  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
753 #endif
754 
755  ReplyPort = CsrApiPort;
756  ReplyMsg = &ReceiveMsg;
757  ReplyMsg->Status = STATUS_ILLEGAL_FUNCTION;
758  CsrDereferenceThread(CsrThread);
759  continue;
760  }
761 
762  /* Get the API ID, normalized with our Base ID */
763  ApiId = CSR_API_NUMBER_TO_API_ID(ReceiveMsg.ApiNumber) - ServerDll->ApiBase;
764 
765  /* Make sure that the ID is within limits, and the entry exists */
766  if (ApiId >= ServerDll->HighestApiSupported)
767  {
768  /* We are beyond the Maximum API ID, or it doesn't exist */
769  DPRINT1("CSRSS: %lx is invalid ApiTableIndex for %Z\n",
771  &ServerDll->Name);
772 
773  ReplyPort = CsrApiPort;
774  ReplyMsg = &ReceiveMsg;
775  ReplyMsg->Status = STATUS_ILLEGAL_FUNCTION;
776  CsrDereferenceThread(CsrThread);
777  continue;
778  }
779 
780 #ifdef CSR_DBG
781  if (CsrDebug & 2)
782  {
783  DPRINT1("[%02x] CSRSS: [%02x,%02x] - %s Api called from %08x, Process %08x - %08x\n",
784  Teb->ClientId.UniqueThread,
785  ReceiveMsg.Header.ClientId.UniqueProcess,
786  ReceiveMsg.Header.ClientId.UniqueThread,
787  ServerDll->NameTable[ApiId],
788  CsrThread,
789  CsrThread->Process,
790  CsrProcess);
791  }
792 #endif
793 
794  /* Assume success */
795  ReplyMsg = &ReceiveMsg;
796  ReceiveMsg.Status = STATUS_SUCCESS;
797 
798  /* Now we reply to a particular client */
799  ReplyPort = CsrThread->Process->ClientPort;
800 
801  /* Check if there's a capture buffer */
802  if (ReceiveMsg.CsrCaptureData)
803  {
804  /* Capture the arguments */
805  if (!CsrCaptureArguments(CsrThread, &ReceiveMsg))
806  {
807  /* Ignore this message if we failed to get the arguments */
808  CsrDereferenceThread(CsrThread);
809  continue;
810  }
811  }
812 
813  /* Validation complete, start SEH */
814  _SEH2_TRY
815  {
816  /* Make sure we have enough threads */
818 
819  Teb->CsrClientThread = CsrThread;
820 
821  /* Call the API, get the reply code and return the result */
822  ReplyCode = CsrReplyImmediately;
823  ReplyMsg->Status = ServerDll->DispatchTable[ApiId](&ReceiveMsg, &ReplyCode);
824 
825  /* Increase the static thread count */
827 
828  Teb->CsrClientThread = CurrentThread;
829 
830  if (ReplyCode == CsrReplyAlreadySent)
831  {
832  if (ReceiveMsg.CsrCaptureData)
833  {
834  CsrReleaseCapturedArguments(&ReceiveMsg);
835  }
836  ReplyMsg = NULL;
837  ReplyPort = CsrApiPort;
838  CsrDereferenceThread(CsrThread);
839  }
840  else if (ReplyCode == CsrReplyDeadClient)
841  {
842  /* Reply to the death message */
843  NTSTATUS Status2;
844  Status2 = NtReplyPort(ReplyPort, &ReplyMsg->Header);
845  if (!NT_SUCCESS(Status2))
846  DPRINT1("CSRSS: Error while replying to the death message, Status 0x%lx\n", Status2);
847 
848  /* Reply back to the API port now */
849  ReplyMsg = NULL;
850  ReplyPort = CsrApiPort;
851  CsrDereferenceThread(CsrThread);
852  }
853  else if (ReplyCode == CsrReplyPending)
854  {
855  ReplyMsg = NULL;
856  ReplyPort = CsrApiPort;
857  }
858  else
859  {
860  if (ReceiveMsg.CsrCaptureData)
861  {
862  CsrReleaseCapturedArguments(&ReceiveMsg);
863  }
864  CsrDereferenceThread(CsrThread);
865  }
866  }
868  {
869  ReplyMsg = NULL;
870  ReplyPort = CsrApiPort;
871  }
872  _SEH2_END;
873  }
874 
875  /* We're out of the loop for some reason, terminate! */
877  return Status;
878 }
ULONG HighestApiSupported
Definition: csrsrv.h:223
VOID NTAPI CsrLockedReferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:154
ULONG Win32ClientInfo[31]
Definition: compat.h:595
ULONG Response
Definition: extypes.h:670
BOOLEAN NTAPI CsrCaptureArguments(IN PCSR_THREAD CsrThread, IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:1119
LARGE_INTEGER CreateTime
Definition: lpctypes.h:270
#define TRUE
Definition: types.h:120
NTSTATUS ReturnedStatus
Definition: dbgktypes.h:210
PVOID CsrClientThread
Definition: compat.h:593
LONG NTSTATUS
Definition: precomp.h:26
#define NtCurrentThread()
ULONG CsrDebug
Definition: init.c:23
NTSTATUS NTAPI CsrDestroyProcess(IN PCLIENT_ID Cid, IN NTSTATUS ExitStatus)
Definition: procsup.c:734
ANSI_STRING Name
Definition: csrsrv.h:218
PKPROCESS CsrProcess
Definition: videoprt.c:39
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:775
PCSR_CAPTURE_BUFFER CsrCaptureData
Definition: csrmsg.h:110
_In_ PVOID Parameter
Definition: ldrtypes.h:241
HANDLE UniqueProcess
Definition: compat.h:573
void DbgBreakPoint()
Definition: mach.c:553
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define CsrReleaseProcessLock()
Definition: api.h:15
PCSR_THREAD NTAPI CsrConnectToUser(VOID)
Definition: api.c:1017
#define DBG_CONTINUE
Definition: ntstatus.h:47
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
_SEH2_TRY
Definition: create.c:4226
NTSTATUS NTAPI NtReplyPort(IN HANDLE PortHandle, IN PPORT_MESSAGE ReplyMessage)
Definition: reply.c:190
CLIENT_ID ClientId
Definition: compat.h:587
EXCEPTION_DISPOSITION NTAPI CsrUnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
Definition: server.c:622
PCSR_PROCESS Process
Definition: csrsrv.h:69
struct _CLIENT_DIED_MSG * PCLIENT_DIED_MSG
NTSTATUS NTAPI CsrApiHandleConnectionRequest(IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:140
NTSTATUS Status
Definition: csrmsg.h:112
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
VOID NTAPI CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:1333
#define STATUS_INVALID_CID
Definition: ntstatus.h:248
ULONG CountOfOwnedCriticalSections
Definition: compat.h:592
VOID NTAPI CsrLockedDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:467
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:11
smooth NULL
Definition: ftsmooth.c:416
CSR_API_NUMBER ApiNumber
Definition: csrmsg.h:111
NTSTATUS NTAPI NtDelayExecution(IN BOOLEAN Alertable, IN PLARGE_INTEGER DelayInterval)
Definition: wait.c:879
NTSTATUS NtTerminateThread(IN HANDLE ThreadHandle OPTIONAL, IN NTSTATUS ExitStatus)
Definition: kill.c:1278
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:458
LARGE_INTEGER CreateTime
Definition: csrsrv.h:65
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
CLIENT_ID ClientId
Definition: csrsrv.h:68
CLIENT_ID RealClientId
Definition: compat.h:609
#define CSR_API_NUMBER_TO_SERVER_ID(ApiNumber)
Definition: csrmsg.h:40
HANDLE UniqueThread
Definition: compat.h:574
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
PCSR_HARDERROR_CALLBACK HardErrorCallback
Definition: csrsrv.h:237
#define CsrAcquireProcessLock()
Definition: api.h:12
NTSTATUS NTAPI NtReplyWaitReceivePort(IN HANDLE PortHandle, OUT PVOID *PortContext OPTIONAL, IN PPORT_MESSAGE ReplyMessage OPTIONAL, OUT PPORT_MESSAGE ReceiveMessage)
Definition: reply.c:743
Status
Definition: gdiplustypes.h:24
#define CSR_API_NUMBER_TO_API_ID(ApiNumber)
Definition: csrmsg.h:43
NTSTATUS NTAPI CsrDestroyThread(IN PCLIENT_ID Cid)
Definition: thredsup.c:813
volatile ULONG CsrpStaticThreadCount
Definition: api.c:23
PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
Definition: thredsup.c:182
HANDLE CsrApiPort
Definition: connect.c:21
ULONG ApiBase
Definition: csrsrv.h:222
Definition: compat.h:583
HANDLE ClientPort
Definition: csrsrv.h:43
_SEH2_END
Definition: create.c:4400
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
struct _HARDERROR_MSG * PHARDERROR_MSG
#define NtCurrentPeb()
Definition: FLS.c:20
#define InterlockedIncrementUL(Addend)
Definition: ex.h:1513
struct _DBGKM_MSG * PDBGKM_MSG
volatile ULONG CsrpDynamicThreadTotal
Definition: api.c:24
enum _CSR_REPLY_CODE CSR_REPLY_CODE
CLIENT_ID ClientId
Definition: winternl.h:1751
#define DPRINT1
Definition: precomp.h:8
PCSR_API_ROUTINE * DispatchTable
Definition: csrsrv.h:224
unsigned int ULONG
Definition: retypes.h:1
NTSTATUS NTAPI CsrpCheckRequestThreads(VOID)
Definition: api.c:255
NTSTATUS NTAPI NtTerminateProcess(HANDLE ProcessHandle, LONG ExitStatus)
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
return STATUS_SUCCESS
Definition: btrfs.c:3014
PORT_MESSAGE Header
Definition: csrmsg.h:104
#define STATUS_ILLEGAL_FUNCTION
Definition: ntstatus.h:411
#define STATUS_ABANDONED
Definition: ntstatus.h:75
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20
LONGLONG QuadPart
Definition: typedefs.h:114

Referenced by CsrApiPortInitialize(), and CsrpCheckRequestThreads().

◆ CsrCaptureArguments()

BOOLEAN NTAPI CsrCaptureArguments ( IN PCSR_THREAD  CsrThread,
IN PCSR_API_MESSAGE  ApiMessage 
)

Definition at line 1119 of file api.c.

1121 {
1122  PCSR_PROCESS CsrProcess = CsrThread->Process;
1123  PCSR_CAPTURE_BUFFER ClientCaptureBuffer, ServerCaptureBuffer = NULL;
1124  ULONG_PTR EndOfClientBuffer;
1125  SIZE_T SizeOfBufferThroughOffsetsArray;
1126  SIZE_T BufferDistance;
1127  ULONG Length;
1128  ULONG PointerCount;
1129  PULONG_PTR OffsetPointer;
1130  ULONG_PTR CurrentOffset;
1131 
1132  /* Get the buffer we got from whoever called NTDLL */
1133  ClientCaptureBuffer = ApiMessage->CsrCaptureData;
1134 
1135  /* Use SEH to validate and capture the client buffer */
1136  _SEH2_TRY
1137  {
1138  /* Check whether at least the buffer's header is inside our mapped section */
1139  if ( ((ULONG_PTR)ClientCaptureBuffer < CsrProcess->ClientViewBase) ||
1140  (((ULONG_PTR)ClientCaptureBuffer + FIELD_OFFSET(CSR_CAPTURE_BUFFER, PointerOffsetsArray))
1141  >= CsrProcess->ClientViewBounds) )
1142  {
1143 #ifdef CSR_DBG
1144  DPRINT1("*** CSRSS: CaptureBuffer outside of ClientView 1\n");
1145  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1146 #endif
1147  /* Return failure */
1148  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1149  _SEH2_YIELD(return FALSE);
1150  }
1151 
1152  /* Capture the buffer length */
1153  Length = ((volatile CSR_CAPTURE_BUFFER*)ClientCaptureBuffer)->Size;
1154 
1155  /*
1156  * Now check if the remaining of the buffer is inside our mapped section.
1157  * Take also care for any possible wrap-around of the buffer end-address.
1158  */
1159  EndOfClientBuffer = (ULONG_PTR)ClientCaptureBuffer + Length;
1160  if ( (EndOfClientBuffer < (ULONG_PTR)ClientCaptureBuffer) ||
1161  (EndOfClientBuffer >= CsrProcess->ClientViewBounds) )
1162  {
1163 #ifdef CSR_DBG
1164  DPRINT1("*** CSRSS: CaptureBuffer outside of ClientView 2\n");
1165  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1166 #endif
1167  /* Return failure */
1168  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1169  _SEH2_YIELD(return FALSE);
1170  }
1171 
1172  /* Capture the pointer count */
1173  PointerCount = ((volatile CSR_CAPTURE_BUFFER*)ClientCaptureBuffer)->PointerCount;
1174 
1175  /*
1176  * Check whether the total buffer size and the pointer count are consistent
1177  * -- the array of offsets must be contained inside the buffer.
1178  */
1179  SizeOfBufferThroughOffsetsArray =
1180  FIELD_OFFSET(CSR_CAPTURE_BUFFER, PointerOffsetsArray) +
1181  (PointerCount * sizeof(PVOID));
1182  if ( (PointerCount > MAXUSHORT) ||
1183  (SizeOfBufferThroughOffsetsArray > Length) )
1184  {
1185 #ifdef CSR_DBG
1186  DPRINT1("*** CSRSS: CaptureBuffer %p has bad length\n", ClientCaptureBuffer);
1187  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1188 #endif
1189  /* Return failure */
1190  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1191  _SEH2_YIELD(return FALSE);
1192  }
1193  }
1195  {
1196 #ifdef CSR_DBG
1197  DPRINT1("*** CSRSS: Took exception during capture %x\n", _SEH2_GetExceptionCode());
1198  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1199 #endif
1200  /* Return failure */
1201  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1202  _SEH2_YIELD(return FALSE);
1203  }
1204  _SEH2_END;
1205 
1206  /* We validated the client buffer, now allocate the server buffer */
1207  ServerCaptureBuffer = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, Length);
1208  if (!ServerCaptureBuffer)
1209  {
1210  /* We're out of memory */
1211  ApiMessage->Status = STATUS_NO_MEMORY;
1212  return FALSE;
1213  }
1214 
1215  /*
1216  * Copy the client's buffer and ensure we use the correct buffer length
1217  * and pointer count we captured and used for validation earlier on.
1218  */
1219  _SEH2_TRY
1220  {
1221  RtlMoveMemory(ServerCaptureBuffer, ClientCaptureBuffer, Length);
1222  }
1224  {
1225 #ifdef CSR_DBG
1226  DPRINT1("*** CSRSS: Took exception during capture %x\n", _SEH2_GetExceptionCode());
1227  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1228 #endif
1229  /* Failure, free the buffer and return */
1230  RtlFreeHeap(CsrHeap, 0, ServerCaptureBuffer);
1231  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1232  _SEH2_YIELD(return FALSE);
1233  }
1234  _SEH2_END;
1235 
1236  ServerCaptureBuffer->Size = Length;
1237  ServerCaptureBuffer->PointerCount = PointerCount;
1238 
1239  /* Calculate the difference between our buffer and the client's */
1240  BufferDistance = (ULONG_PTR)ServerCaptureBuffer - (ULONG_PTR)ClientCaptureBuffer;
1241 
1242  /*
1243  * All the pointer offsets correspond to pointers which point
1244  * to the server data buffer instead of the client one.
1245  */
1246  // PointerCount = ServerCaptureBuffer->PointerCount;
1247  OffsetPointer = ServerCaptureBuffer->PointerOffsetsArray;
1248  while (PointerCount--)
1249  {
1250  CurrentOffset = *OffsetPointer;
1251 
1252  if (CurrentOffset != 0)
1253  {
1254  /*
1255  * Check whether the offset is pointer-aligned and whether
1256  * it points inside CSR_API_MESSAGE::Data.ApiMessageData.
1257  */
1258  if ( ((CurrentOffset & (sizeof(PVOID)-1)) != 0) ||
1259  (CurrentOffset < FIELD_OFFSET(CSR_API_MESSAGE, Data.ApiMessageData)) ||
1260  (CurrentOffset >= sizeof(CSR_API_MESSAGE)) )
1261  {
1262 #ifdef CSR_DBG
1263  DPRINT1("*** CSRSS: CaptureBuffer MessagePointer outside of message\n");
1264  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1265 #endif
1266  /* Invalid pointer, fail */
1267  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1268  break;
1269  }
1270 
1271  /* Get the pointer corresponding to the offset */
1272  CurrentOffset += (ULONG_PTR)ApiMessage;
1273 
1274  /* Validate the bounds of the current pointed pointer */
1275  if ( (*(PULONG_PTR)CurrentOffset >= ((ULONG_PTR)ClientCaptureBuffer +
1276  SizeOfBufferThroughOffsetsArray)) &&
1277  (*(PULONG_PTR)CurrentOffset <= (EndOfClientBuffer - sizeof(PVOID))) )
1278  {
1279  /* Modify the pointed pointer to take into account its new position */
1280  *(PULONG_PTR)CurrentOffset += BufferDistance;
1281  }
1282  else
1283  {
1284 #ifdef CSR_DBG
1285  DPRINT1("*** CSRSS: CaptureBuffer MessagePointer outside of ClientView\n");
1286  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1287 #endif
1288  /* Invalid pointer, fail */
1289  ApiMessage->Status = STATUS_INVALID_PARAMETER;
1290  break;
1291  }
1292  }
1293 
1294  ++OffsetPointer;
1295  }
1296 
1297  /* Check if we got success */
1298  if (ApiMessage->Status != STATUS_SUCCESS)
1299  {
1300  /* Failure, free the buffer and return */
1301  RtlFreeHeap(CsrHeap, 0, ServerCaptureBuffer);
1302  return FALSE;
1303  }
1304  else
1305  {
1306  /* Success, save the previous buffer and use the server capture buffer */
1307  ServerCaptureBuffer->PreviousCaptureBuffer = ClientCaptureBuffer;
1308  ApiMessage->CsrCaptureData = ServerCaptureBuffer;
1309  }
1310 
1311  /* Success */
1312  return TRUE;
1313 }
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
PKPROCESS CsrProcess
Definition: videoprt.c:39
void DbgBreakPoint()
Definition: mach.c:553
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define FALSE
Definition: types.h:117
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
void * PVOID
Definition: retypes.h:9
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
struct _CSR_CAPTURE_BUFFER * PreviousCaptureBuffer
Definition: csrmsg.h:95
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ULONG PointerCount
Definition: csrmsg.h:96
ULONG_PTR SIZE_T
Definition: typedefs.h:80
_SEH2_END
Definition: create.c:4400
#define NtCurrentPeb()
Definition: FLS.c:20
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define MAXUSHORT
Definition: typedefs.h:83
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:65
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
HANDLE CsrHeap
Definition: init.c:25
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
return STATUS_SUCCESS
Definition: btrfs.c:3014
ULONG_PTR PointerOffsetsArray[ANYSIZE_ARRAY]
Definition: csrmsg.h:98

Referenced by CsrApiRequestThread().

◆ CsrCreateLocalSystemSD()

NTSTATUS NTAPI CsrCreateLocalSystemSD ( OUT PSECURITY_DESCRIPTOR LocalSystemSd)

this API is used with CsrPopulateDosDevices, deprecated in r55585. NTSTATUS NTAPI CsrPopulateDosDevicesDirectory(IN HANDLE DosDevicesDirectory, IN PPROCESS_DEVICEMAP_INFORMATION DeviceMap);

Definition at line 807 of file init.c.

808 {
810  PSID SystemSid;
811  ULONG Length;
812  PSECURITY_DESCRIPTOR SystemSd;
813  PACL Dacl;
815 
816  /* Initialize the System SID */
819  0, 0, 0, 0, 0, 0, 0,
820  &SystemSid);
821 
822  /* Get the length of the SID */
823  Length = RtlLengthSid(SystemSid) + sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE);
824 
825  /* Allocate a buffer for the Security Descriptor, with SID and DACL */
827 
828  /* Set the pointer to the DACL */
830 
831  /* Now create the SD itself */
833  if (!NT_SUCCESS(Status)) goto Quit;
834 
835  /* Create the DACL for it */
837 
838  /* Create the ACE */
840  if (!NT_SUCCESS(Status)) goto Quit;
841 
842  /* Clear the DACL in the SD */
844  if (!NT_SUCCESS(Status)) goto Quit;
845 
846 Quit:
847  if (!NT_SUCCESS(Status))
848  {
849  RtlFreeHeap(CsrHeap, 0, SystemSd);
850  SystemSd = NULL;
851  }
852 
853  /* Free the SID and return*/
854  RtlFreeSid(SystemSid);
855  *LocalSystemSd = SystemSd;
856  return Status;
857 }
#define SECURITY_LOCAL_SYSTEM_RID
Definition: setypes.h:546
#define SECURITY_DESCRIPTOR_MIN_LENGTH
Definition: setypes.h:761
#define TRUE
Definition: types.h:120
NTSYSAPI PVOID NTAPI RtlFreeSid(_In_ _Post_invalid_ PSID Sid)
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor(_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Revision)
NTSYSAPI NTSTATUS WINAPI RtlAddAccessAllowedAce(PACL, DWORD, DWORD, PSID)
NTSYSAPI NTSTATUS WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR, BOOLEAN, PACL, BOOLEAN)
NTSYSAPI NTSTATUS NTAPI RtlAllocateAndInitializeSid(IN PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, IN UCHAR SubAuthorityCount, IN ULONG SubAuthority0, IN ULONG SubAuthority1, IN ULONG SubAuthority2, IN ULONG SubAuthority3, IN ULONG SubAuthority4, IN ULONG SubAuthority5, IN ULONG SubAuthority6, IN ULONG SubAuthority7, OUT PSID *Sid)
Definition: sid.c:290
NTSYSAPI NTSTATUS NTAPI RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision)
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define SECURITY_DESCRIPTOR_REVISION
Definition: setypes.h:58
#define FALSE
Definition: types.h:117
#define ACL_REVISION2
Definition: setypes.h:43
struct _ACL ACL
smooth NULL
Definition: ftsmooth.c:416
static SID_IDENTIFIER_AUTHORITY NtSidAuthority
Definition: samrpc.c:14
NTSYSAPI ULONG NTAPI RtlLengthSid(IN PSID Sid)
Definition: sid.c:150
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:526
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
struct _ACL * PACL
Definition: security.c:104
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1552
Status
Definition: gdiplustypes.h:24
#define ACL_REVISION
Definition: setypes.h:39
#define PORT_ALL_ACCESS
Definition: lpctypes.h:47
unsigned int ULONG
Definition: retypes.h:1
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrSbApiPortInitialize().

◆ CsrCreateObjectDirectory()

NTSTATUS NTAPI CsrCreateObjectDirectory ( IN PCHAR  ObjectDirectory)

◆ CsrCreateSessionObjectDirectory()

NTSTATUS NTAPI CsrCreateSessionObjectDirectory ( IN ULONG  SessionId)

Definition at line 420 of file init.c.

421 {
422  WCHAR SessionBuffer[512], BnoBuffer[512];
423  UNICODE_STRING SessionString, BnoString;
425  HANDLE BnoHandle;
426  SECURITY_DESCRIPTOR DosDevicesSd;
428 
429  /* Generate the Session BNOLINKS Directory name */
430  swprintf(SessionBuffer, L"%ws\\BNOLINKS", SESSION_ROOT);
431  RtlInitUnicodeString(&SessionString, SessionBuffer);
432 
433  /* Create it */
435  &SessionString,
437  NULL,
438  NULL);
442  if (!NT_SUCCESS(Status))
443  {
444  DPRINT1("CSRSS: NtCreateDirectoryObject failed in "
445  "CsrCreateSessionObjectDirectory - status = %lx\n", Status);
446  return Status;
447  }
448 
449  /* Now add the Session ID */
450  swprintf(SessionBuffer, L"%ld", Session);
451  RtlInitUnicodeString(&SessionString, SessionBuffer);
452 
453  /* Check if this is the first Session */
454  if (Session)
455  {
456  /* Not the first, so the name will be slighly more complex */
457  swprintf(BnoBuffer, L"%ws\\%ld\\BaseNamedObjects", SESSION_ROOT, Session);
458  RtlInitUnicodeString(&BnoString, BnoBuffer);
459  }
460  else
461  {
462  /* Use the direct name */
463  RtlInitUnicodeString(&BnoString, L"\\BaseNamedObjects");
464  }
465 
466  /* Create the symlink */
468  &SessionString,
471  NULL);
472  Status = NtCreateSymbolicLinkObject(&BnoHandle,
475  &BnoString);
476  if (!NT_SUCCESS(Status))
477  {
478  DPRINT1("CSRSS: NtCreateSymbolicLinkObject failed in "
479  "CsrCreateSessionObjectDirectory - status = %lx\n", Status);
480  return Status;
481  }
482 
483  /* Create the \DosDevices Security Descriptor */
484  Status = GetDosDevicesProtection(&DosDevicesSd);
485  if (!NT_SUCCESS(Status)) return Status;
486 
487  /* Now create a directory for this session */
488  swprintf(SessionBuffer, L"%ws\\%ld", SESSION_ROOT, Session);
489  RtlInitUnicodeString(&SessionString, SessionBuffer);
490 
491  /* Create the directory */
493  &SessionString,
495  0,
496  &DosDevicesSd);
500  if (!NT_SUCCESS(Status))
501  {
502  DPRINT1("CSRSS: NtCreateDirectoryObject failed in "
503  "CsrCreateSessionObjectDirectory - status = %lx\n", Status);
504  FreeDosDevicesProtection(&DosDevicesSd);
505  return Status;
506  }
507 
508  /* Next, create a directory for this session's DOS Devices */
509  RtlInitUnicodeString(&SessionString, L"DosDevices");
511  &SessionString,
514  &DosDevicesSd);
518  if (!NT_SUCCESS(Status))
519  {
520  DPRINT1("CSRSS: NtCreateDirectoryObject failed in "
521  "CsrCreateSessionObjectDirectory - status = %lx\n", Status);
522  }
523 
524  /* Release the Security Descriptor */
525  FreeDosDevicesProtection(&DosDevicesSd);
526 
527  /* Return */
528  return Status;
529 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSTATUS NTAPI GetDosDevicesProtection(OUT PSECURITY_DESCRIPTOR DosDevicesSd)
Definition: init.c:205
LONG NTSTATUS
Definition: precomp.h:26
#define SYMBOLIC_LINK_ALL_ACCESS
Definition: nt_native.h:1267
#define OBJ_OPENIF
Definition: winternl.h:229
VOID NTAPI FreeDosDevicesProtection(IN PSECURITY_DESCRIPTOR DosDevicesSd)
Definition: init.c:388
HANDLE DosDevicesDirectory
Definition: init.c:39
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define swprintf(buf, format,...)
Definition: sprintf.c:56
Status
Definition: gdiplustypes.h:24
static const WCHAR L[]
Definition: oid.c:1250
HANDLE SessionObjectDirectory
Definition: init.c:38
NTSTATUS NTAPI NtCreateDirectoryObject(OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: obdir.c:773
#define DIRECTORY_ALL_ACCESS
Definition: nt_native.h:1259
#define DPRINT1
Definition: precomp.h:8
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
HANDLE BNOLinksDirectory
Definition: init.c:37
#define SESSION_ROOT
Definition: srv.h:44

Referenced by CsrParseServerCommandLine().

◆ CsrDeallocateProcess()

VOID NTAPI CsrDeallocateProcess ( IN PCSR_PROCESS  CsrProcess)

Definition at line 296 of file procsup.c.

297 {
298  /* Free the process object from the heap */
300 }
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
PKPROCESS CsrProcess
Definition: videoprt.c:39
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrCreateProcess(), CsrProcessRefcountZero(), and CsrSbCreateSession().

◆ CsrDeallocateThread()

VOID NTAPI CsrDeallocateThread ( IN PCSR_THREAD  CsrThread)

Definition at line 345 of file thredsup.c.

346 {
347  /* Free the process object from the heap */
348  // ASSERT(CsrThread->WaitBlock == NULL);
349  RtlFreeHeap(CsrHeap, 0, CsrThread);
350 }
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), CsrSbCreateSession(), and CsrThreadRefcountZero().

◆ CsrDereferenceNtSession()

VOID NTAPI CsrDereferenceNtSession ( IN PCSR_NT_SESSION  Session,
IN NTSTATUS  ExitStatus 
)

Definition at line 156 of file session.c.

158 {
159  /* Acquire the lock */
161 
162  /* Sanity checks */
163  ASSERT(!IsListEmpty(&Session->SessionLink));
164  ASSERT(Session->SessionId != 0);
165  ASSERT(Session->ReferenceCount != 0);
166 
167  /* Dereference the Session Object */
168  if ((--Session->ReferenceCount) == 0)
169  {
170  /* Remove it from the list */
171  RemoveEntryList(&Session->SessionLink);
172 
173  /* Release the lock */
175 
176  /* Tell SM that we're done here */
177  SmSessionComplete(CsrSmApiPort, Session->SessionId, ExitStatus);
178 
179  /* Free the Session Object */
180  RtlFreeHeap(CsrHeap, 0, Session);
181  }
182  else
183  {
184  /* Release the lock, the Session is still active */
186  }
187 }
NTSTATUS NTAPI SmSessionComplete(IN HANDLE SmApiPort, IN ULONG SessionId, IN NTSTATUS SessionStatus)
Definition: smclient.c:135
#define CsrAcquireNtSessionLock()
Definition: api.h:27
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define CsrReleaseNtSessionLock()
Definition: api.h:30
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:859
HANDLE CsrSmApiPort
Definition: init.c:31
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrProcessRefcountZero().

◆ CsrInitializeNtSessionList()

NTSTATUS NTAPI CsrInitializeNtSessionList ( VOID  )

Definition at line 53 of file session.c.

54 {
55  /* Initialize the Session List */
57 
58  /* Initialize the Session Lock */
60 }
RTL_CRITICAL_SECTION CsrNtSessionLock
Definition: session.c:18
LIST_ENTRY CsrNtSessionList
Definition: session.c:19
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944

Referenced by CsrServerInitialization().

◆ CsrInitializeProcessStructure()

NTSTATUS NTAPI CsrInitializeProcessStructure ( VOID  )

Definition at line 254 of file procsup.c.

255 {
257  ULONG i;
258 
259  /* Initialize the Lock */
261  if (!NT_SUCCESS(Status)) return Status;
262 
263  /* Set up the Root Process */
265  if (!CsrRootProcess) return STATUS_NO_MEMORY;
266 
267  /* Set up the minimal information for it */
270  CsrRootProcess->ClientId = NtCurrentTeb()->ClientId;
271 
272  /* Initialize the Thread Hash List */
274 
275  /* Initialize the Wait Lock */
277 }
RTL_CRITICAL_SECTION CsrProcessLock
Definition: procsup.c:21
LONG NTSTATUS
Definition: precomp.h:26
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
HANDLE ProcessHandle
Definition: csrsrv.h:46
CLIENT_ID ClientId
Definition: csrsrv.h:38
LIST_ENTRY ListLink
Definition: csrsrv.h:39
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
PVOID HANDLE
Definition: typedefs.h:73
Status
Definition: gdiplustypes.h:24
PCSR_PROCESS NTAPI CsrAllocateProcess(VOID)
Definition: procsup.c:188
RTL_CRITICAL_SECTION CsrWaitListsLock
Definition: api.h:61
#define NUMBER_THREAD_HASH_BUCKETS
Definition: api.h:44
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
unsigned int ULONG
Definition: retypes.h:1

Referenced by CsrServerInitialization().

◆ CsrInsertProcess()

VOID NTAPI CsrInsertProcess ( IN PCSR_PROCESS ParentProcess  OPTIONAL,
IN PCSR_PROCESS  CsrProcess 
)

Definition at line 365 of file procsup.c.

367 {
368  PCSR_SERVER_DLL ServerDll;
369  ULONG i;
371 
372  /* Insert it into the Root List */
374 
375  /* Notify the Server DLLs */
376  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
377  {
378  /* Get the current Server DLL */
379  ServerDll = CsrLoadedServerDll[i];
380 
381  /* Make sure it's valid and that it has callback */
382  if (ServerDll && ServerDll->NewProcessCallback)
383  {
384  ServerDll->NewProcessCallback(ParentProcess, CsrProcess);
385  }
386  }
387 }
PKPROCESS CsrProcess
Definition: videoprt.c:39
#define InsertTailList(ListHead, Entry)
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define ProcessStructureListLocked()
Definition: api.h:18
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LIST_ENTRY ListLink
Definition: csrsrv.h:39
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
unsigned int ULONG
Definition: retypes.h:1
PCSR_NEWPROCESS_CALLBACK NewProcessCallback
Definition: csrsrv.h:239
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20

Referenced by CsrCreateProcess(), and CsrSbCreateSession().

◆ CsrInsertThread()

NTSTATUS NTAPI CsrInsertThread ( IN PCSR_PROCESS  Process,
IN PCSR_THREAD  Thread 
)

Definition at line 297 of file thredsup.c.

299 {
300  ULONG i;
303  // ASSERT(ProcessStructureListLocked());
304 
305  /* Make sure the thread isn't already dead by the time we got this */
306  Status = NtQueryInformationThread(Thread->ThreadHandle,
308  &ThreadInfo,
309  sizeof(ThreadInfo),
310  NULL);
311  if (!NT_SUCCESS(Status)) return Status;
313 
314  /* Insert it into the Regular List */
315  InsertTailList(&Process->ThreadList, &Thread->Link);
316 
317  /* Increase Thread Count */
318  Process->ThreadCount++;
319 
320  /* Hash the Thread */
321  i = CsrHashThread(Thread->ClientId.UniqueThread);
322 
323  /* Insert it there too */
324  InsertHeadList(&CsrThreadHashTable[i], &Thread->HashLinks);
325  return STATUS_SUCCESS;
326 }
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
#define STATUS_THREAD_IS_TERMINATING
Definition: ntstatus.h:311
LONG NTSTATUS
Definition: precomp.h:26
struct _ThreadInfo ThreadInfo
#define InsertTailList(ListHead, Entry)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define CsrHashThread(t)
Definition: thredsup.c:17
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2506
Status
Definition: gdiplustypes.h:24
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), and CsrSbCreateSession().

◆ CsrLoadServerDll()

NTSTATUS NTAPI CsrLoadServerDll ( IN PCHAR  DllString,
IN PCHAR EntryPoint  OPTIONAL,
IN ULONG  ServerId 
)

Definition at line 116 of file server.c.

119 {
121  ANSI_STRING DllName;
122  UNICODE_STRING TempString, ErrorString;
124  HANDLE hServerDll = NULL;
125  ULONG Size;
126  PCSR_SERVER_DLL ServerDll;
127  STRING EntryPointString;
128  PCSR_SERVER_DLL_INIT_CALLBACK ServerDllInitProcedure;
129  ULONG Response;
130 
131  /* Check if it's beyond the maximum we support */
132  if (ServerId >= CSR_SERVER_DLL_MAX) return STATUS_TOO_MANY_NAMES;
133 
134  /* Check if it's already been loaded */
135  if (CsrLoadedServerDll[ServerId]) return STATUS_INVALID_PARAMETER;
136 
137  /* Convert the name to Unicode */
138  ASSERT(DllString != NULL);
139  RtlInitAnsiString(&DllName, DllString);
140  Status = RtlAnsiStringToUnicodeString(&TempString, &DllName, TRUE);
141  if (!NT_SUCCESS(Status)) return Status;
142 
143  /* If we are loading ourselves, don't actually load us */
144  if (ServerId != CSRSRV_SERVERDLL_INDEX)
145  {
146  /* Load the DLL */
147  Status = LdrLoadDll(NULL, 0, &TempString, &hServerDll);
148  if (!NT_SUCCESS(Status))
149  {
150  /* Setup error parameters */
151  Parameters[0] = (ULONG_PTR)&TempString;
152  Parameters[1] = (ULONG_PTR)&ErrorString;
153  RtlInitUnicodeString(&ErrorString, L"Default Load Path");
154 
155  /* Send a hard error */
157  2,
158  3,
159  Parameters,
160  OptionOk,
161  &Response);
162  }
163 
164  /* Get rid of the string */
165  RtlFreeUnicodeString(&TempString);
166  if (!NT_SUCCESS(Status)) return Status;
167  }
168 
169  /* Allocate a CSR DLL Object */
170  Size = sizeof(CSR_SERVER_DLL) + DllName.MaximumLength;
172  if (!ServerDll)
173  {
174  if (hServerDll) LdrUnloadDll(hServerDll);
175  return STATUS_NO_MEMORY;
176  }
177 
178  /* Set up the Object */
179  ServerDll->Length = Size;
180  ServerDll->SizeOfProcessData = 0;
181  ServerDll->SharedSection = CsrSrvSharedSectionHeap; // Send to the server dll our shared heap pointer.
182  ServerDll->Name.Length = DllName.Length;
183  ServerDll->Name.MaximumLength = DllName.MaximumLength;
184  ServerDll->Name.Buffer = (PCHAR)(ServerDll + 1);
185  if (DllName.Length)
186  {
187  strncpy(ServerDll->Name.Buffer, DllName.Buffer, DllName.Length);
188  }
189  ServerDll->ServerId = ServerId;
190  ServerDll->ServerHandle = hServerDll;
191 
192  /* Now get the entrypoint */
193  if (hServerDll)
194  {
195  /* Initialize a string for the entrypoint, or use the default */
196  RtlInitAnsiString(&EntryPointString,
197  EntryPoint ? EntryPoint : "ServerDllInitialization");
198 
199  /* Get a pointer to it */
200  Status = LdrGetProcedureAddress(hServerDll,
201  &EntryPointString,
202  0,
203  (PVOID)&ServerDllInitProcedure);
204  }
205  else
206  {
207  /* No handle, so we are loading ourselves */
208 #ifdef CSR_DBG
209  RtlInitAnsiString(&EntryPointString, "CsrServerDllInitialization");
210 #endif
211  ServerDllInitProcedure = CsrServerDllInitialization;
213  }
214 
215  /* Check if we got the pointer, and call it */
216  if (NT_SUCCESS(Status))
217  {
218  /* Call the Server DLL entrypoint */
219  _SEH2_TRY
220  {
221  Status = ServerDllInitProcedure(ServerDll);
222  }
224  {
226 #ifdef CSR_DBG
227  DPRINT1("CSRSS: Exception 0x%lx while calling Server DLL entrypoint %Z!%Z()\n",
228  Status, &DllName, &EntryPointString);
229 #endif
230  }
231  _SEH2_END;
232 
233  if (NT_SUCCESS(Status))
234  {
235  /*
236  * Add this Server's Per-Process Data Size to the total that each
237  * process will need.
238  */
240 
241  /* Save the pointer in our list */
242  CsrLoadedServerDll[ServerDll->ServerId] = ServerDll;
243 
244  /* Does it use our generic heap? */
245  if (ServerDll->SharedSection != CsrSrvSharedSectionHeap)
246  {
247  /* No, save the pointer to its shared section in our list */
248  CsrSrvSharedStaticServerData[ServerDll->ServerId] = ServerDll->SharedSection;
249  }
250  }
251  }
252 
253  if (!NT_SUCCESS(Status))
254  {
255  /* Server Init failed, unload it */
256  if (hServerDll) LdrUnloadDll(hServerDll);
257 
258  /* Delete the Object */
259  RtlFreeHeap(CsrHeap, 0, ServerDll);
260  }
261 
262  /* Return to caller */
263  return Status;
264 }
ULONG SizeOfProcessData
Definition: csrsrv.h:234
NTSTATUS NTAPI NtRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, IN PULONG_PTR Parameters, IN ULONG ValidResponseOptions, OUT PULONG Response)
Definition: harderr.c:553
PVOID CsrSrvSharedSectionHeap
Definition: server.c:21
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
ANSI_STRING Name
Definition: csrsrv.h:218
EXCEPTION_DISPOSITION NTAPI CsrUnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
Definition: server.c:622
ULONG CsrTotalPerProcessDataLength
Definition: init.c:35
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
_SEH2_TRY
Definition: create.c:4226
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
uint32_t ULONG_PTR
Definition: typedefs.h:65
NTSTATUS NTAPI CsrServerDllInitialization(IN PCSR_SERVER_DLL LoadedServerDll)
PVOID * CsrSrvSharedStaticServerData
Definition: server.c:23
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:11
NTSTATUS NTAPI LdrGetProcedureAddress(IN PVOID BaseAddress, IN PANSI_STRING Name, IN ULONG Ordinal, OUT PVOID *ProcedureAddress)
Definition: ldrapi.c:823
smooth NULL
Definition: ftsmooth.c:416
ULONG ServerId
Definition: csrsrv.h:220
#define PCHAR
Definition: match.c:90
HANDLE ServerHandle
Definition: csrsrv.h:219
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
USHORT MaximumLength
Definition: env_spec_w32.h:377
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
Definition: ncftp.h:89
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
std::wstring STRING
Definition: fontsub.cpp:33
Status
Definition: gdiplustypes.h:24
_In_ PPCI_DEVICE_PRESENCE_PARAMETERS Parameters
Definition: iotypes.h:887
static const WCHAR L[]
Definition: oid.c:1250
PVOID SharedSection
Definition: csrsrv.h:238
NTSTATUS NTAPI DECLSPEC_HOTPATCH LdrLoadDll(IN PWSTR SearchPath OPTIONAL, IN PULONG DllCharacteristics OPTIONAL, IN PUNICODE_STRING DllName, OUT PVOID *BaseAddress)
Definition: ldrapi.c:310
ULONG Length
Definition: csrsrv.h:217
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
struct _CSR_SERVER_DLL CSR_SERVER_DLL
NTSTATUS NTAPI LdrUnloadDll(IN PVOID BaseAddress)
Definition: ldrapi.c:1322
_SEH2_END
Definition: create.c:4400
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
#define CSRSRV_SERVERDLL_INDEX
Definition: csrmsg.h:20
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
struct Response Response
#define ULONG_PTR
Definition: config.h:101
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
HANDLE CsrHeap
Definition: init.c:25
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
#define STATUS_TOO_MANY_NAMES
Definition: ntstatus.h:441
NTSTATUS(NTAPI * PCSR_SERVER_DLL_INIT_CALLBACK)(IN PCSR_SERVER_DLL LoadedServerDll)
Definition: csrsrv.h:253
return STATUS_SUCCESS
Definition: btrfs.c:3014
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20

Referenced by CsrParseServerCommandLine().

◆ CsrLocateThreadByClientId()

PCSR_THREAD NTAPI CsrLocateThreadByClientId ( OUT PCSR_PROCESS *Process  OPTIONAL,
IN PCLIENT_ID  ClientId 
)

Definition at line 182 of file thredsup.c.

184 {
185  ULONG i;
186  PLIST_ENTRY ListHead, NextEntry;
187  PCSR_THREAD FoundThread;
188  // ASSERT(ProcessStructureListLocked());
189 
190  if (Process) *Process = NULL;
191 
192  /* Hash the Thread */
194 
195  /* Set the list pointers */
196  ListHead = &CsrThreadHashTable[i];
197  NextEntry = ListHead->Flink;
198 
199  /* Star the loop */
200  while (NextEntry != ListHead)
201  {
202  /* Get the thread */
203  FoundThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, HashLinks);
204 
205  /* Move to the next entry */
206  NextEntry = NextEntry->Flink;
207 
208  /* Compare the CID */
209  // if (*(PULONGLONG)&FoundThread->ClientId == *(PULONGLONG)ClientId)
210  if ( FoundThread->ClientId.UniqueProcess == ClientId->UniqueProcess &&
211  FoundThread->ClientId.UniqueThread == ClientId->UniqueThread )
212  {
213  /* Match found, return the process */
214  if (Process) *Process = FoundThread->Process;
215 
216  /* Return thread too */
217  return FoundThread;
218  }
219  }
220 
221  /* Nothing found */
222  return NULL;
223 }
HANDLE UniqueProcess
Definition: compat.h:573
PCSR_PROCESS Process
Definition: csrsrv.h:69
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163
CLIENT_ID ClientId
Definition: csrsrv.h:68
#define CsrHashThread(t)
Definition: thredsup.c:17
HANDLE UniqueThread
Definition: compat.h:574
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
Definition: typedefs.h:119
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
unsigned int ULONG
Definition: retypes.h:1

Referenced by CsrApiHandleConnectionRequest(), CsrApiRequestThread(), CsrCreateProcess(), CsrCreateThread(), CsrDestroyProcess(), and CsrDestroyThread().

◆ CsrLocateThreadInProcess()

PCSR_THREAD NTAPI CsrLocateThreadInProcess ( IN PCSR_PROCESS CsrProcess  OPTIONAL,
IN PCLIENT_ID  Cid 
)

Definition at line 248 of file thredsup.c.

250 {
251  PLIST_ENTRY ListHead, NextEntry;
252  PCSR_THREAD FoundThread = NULL;
253 
254  /* Use the Root Process if none was specified */
256 
257  /* Save the List pointers */
258  ListHead = &CsrProcess->ThreadList;
259  NextEntry = ListHead->Flink;
260 
261  /* Start the Loop */
262  while (NextEntry != ListHead)
263  {
264  /* Get Thread Entry */
265  FoundThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
266 
267  /* Check for TID Match */
268  if (FoundThread->ClientId.UniqueThread == Cid->UniqueThread) break;
269 
270  /* Move to the next entry */
271  NextEntry = NextEntry->Flink;
272  }
273 
274  /* Return what we found */
275  return FoundThread;
276 }
PKPROCESS CsrProcess
Definition: videoprt.c:39
static int Link(const char **args)
Definition: vfdcmd.c:2414
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
CLIENT_ID ClientId
Definition: csrsrv.h:68
HANDLE UniqueThread
Definition: compat.h:574
Definition: typedefs.h:119

Referenced by CsrConnectToUser().

◆ CsrLockedDereferenceProcess()

VOID NTAPI CsrLockedDereferenceProcess ( PCSR_PROCESS  CsrProcess)

Definition at line 159 of file procsup.c.

160 {
161  LONG LockCount;
162 
163  /* Decrease reference count */
164  LockCount = --CsrProcess->ReferenceCount;
165  ASSERT(LockCount >= 0);
166  if (LockCount == 0)
167  {
168  /* Call the generic cleanup code */
169  DPRINT1("Should kill process: %p\n", CsrProcess);
172  }
173 }
PKPROCESS CsrProcess
Definition: videoprt.c:39
LONG LockCount
Definition: comsup.c:6
long LONG
Definition: pedump.c:60
VOID NTAPI CsrProcessRefcountZero(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:119
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define CsrAcquireProcessLock()
Definition: api.h:12
#define DPRINT1
Definition: precomp.h:8

Referenced by CsrApiHandleConnectionRequest(), CsrRemoveThread(), CsrShutdownProcesses(), and CsrUnlockProcess().

◆ CsrLockedDereferenceThread()

VOID NTAPI CsrLockedDereferenceThread ( IN PCSR_THREAD  CsrThread)

Definition at line 467 of file thredsup.c.

468 {
469  LONG LockCount;
470 
471  /* Decrease reference count */
472  LockCount = --CsrThread->ReferenceCount;
473  ASSERT(LockCount >= 0);
474  if (LockCount == 0)
475  {
476  /* Call the generic cleanup code */
478  CsrThreadRefcountZero(CsrThread);
479  }
480 }
LONG LockCount
Definition: comsup.c:6
long LONG
Definition: pedump.c:60
VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:424
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define CsrAcquireProcessLock()
Definition: api.h:12

Referenced by CsrApiRequestThread(), CsrDestroyProcess(), CsrDestroyThread(), and CsrUnlockThread().

◆ CsrLockedReferenceProcess()

VOID NTAPI CsrLockedReferenceProcess ( IN PCSR_PROCESS  CsrProcess)

Definition at line 232 of file procsup.c.

233 {
234  /* Increment the reference count */
235  ++CsrProcess->ReferenceCount;
236 }
PKPROCESS CsrProcess
Definition: videoprt.c:39

Referenced by CsrAllocateProcess(), CsrAllocateThread(), CsrApiHandleConnectionRequest(), CsrLockProcessByClientId(), and CsrShutdownProcesses().

◆ CsrLockedReferenceThread()

VOID NTAPI CsrLockedReferenceThread ( IN PCSR_THREAD  CsrThread)

Definition at line 154 of file thredsup.c.

155 {
156  /* Increment the reference count */
157  ++CsrThread->ReferenceCount;
158 }

Referenced by CsrAllocateThread(), CsrApiRequestThread(), and CsrLockThreadByClientId().

◆ CsrNotifyWaitBlock()

BOOLEAN NTAPI CsrNotifyWaitBlock ( IN PCSR_WAIT_BLOCK  WaitBlock,
IN PLIST_ENTRY  WaitList,
IN PVOID  WaitArgument1,
IN PVOID  WaitArgument2,
IN ULONG  WaitFlags,
IN BOOLEAN  DereferenceThread 
)

Definition at line 120 of file wait.c.

126 {
127  /* Call the wait function */
128  if (WaitBlock->WaitFunction(WaitList,
129  WaitBlock->WaitThread,
130  &WaitBlock->WaitApiMessage,
131  WaitBlock->WaitContext,
132  WaitArgument1,
133  WaitArgument2,
134  WaitFlags))
135  {
136  /* The wait is done, clear the block */
137  WaitBlock->WaitThread->WaitBlock = NULL;
138 
139  /* Check for captured arguments */
140  if (WaitBlock->WaitApiMessage.CsrCaptureData)
141  {
142  /* Release them */
143  CsrReleaseCapturedArguments(&WaitBlock->WaitApiMessage);
144  }
145 
146  /* Reply to the port */
147  NtReplyPort(WaitBlock->WaitThread->Process->ClientPort,
148  &WaitBlock->WaitApiMessage.Header);
149 
150  /* Check if we should dereference the thread */
151  if (DereferenceThread)
152  {
153  /* Remove it from the Wait List */
154  if (WaitBlock->WaitList.Flink)
155  {
156  RemoveEntryList(&WaitBlock->WaitList);
157  }
158 
159  /* Dereference the thread */
160  CsrDereferenceThread(WaitBlock->WaitThread);
161 
162  /* Free the wait block */
163  RtlFreeHeap(CsrHeap, 0, WaitBlock);
164  }
165  else
166  {
167  /* The wait is complete, but the thread is being kept alive */
168  WaitBlock->WaitFunction = NULL;
169  }
170 
171  /* The wait succeeded */
172  return TRUE;
173  }
174 
175  /* The wait failed */
176  return FALSE;
177 }
#define TRUE
Definition: types.h:120
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:775
NTSTATUS NTAPI NtReplyPort(IN HANDLE PortHandle, IN PPORT_MESSAGE ReplyMessage)
Definition: reply.c:190
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define FALSE
Definition: types.h:117
VOID NTAPI CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:1333
smooth NULL
Definition: ftsmooth.c:416
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrDestroyProcess(), CsrDestroyThread(), and CsrNotifyWait().

◆ CsrReferenceNtSession()

VOID NTAPI CsrReferenceNtSession ( IN PCSR_NT_SESSION  Session)

Definition at line 118 of file session.c.

119 {
120  /* Acquire the lock */
122 
123  /* Sanity checks */
124  ASSERT(!IsListEmpty(&Session->SessionLink));
125  ASSERT(Session->SessionId != 0);
126  ASSERT(Session->ReferenceCount != 0);
127 
128  /* Increase the reference count */
129  Session->ReferenceCount++;
130 
131  /* Release the lock */
133 }
#define CsrAcquireNtSessionLock()
Definition: api.h:27
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define CsrReleaseNtSessionLock()
Definition: api.h:30
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)

Referenced by CsrCreateProcess().

◆ CsrReleaseCapturedArguments()

VOID NTAPI CsrReleaseCapturedArguments ( IN PCSR_API_MESSAGE  ApiMessage)

Definition at line 1333 of file api.c.

1334 {
1335  PCSR_CAPTURE_BUFFER ServerCaptureBuffer, ClientCaptureBuffer;
1336  SIZE_T BufferDistance;
1337  ULONG PointerCount;
1338  PULONG_PTR OffsetPointer;
1339  ULONG_PTR CurrentOffset;
1340 
1341  /* Get the server capture buffer */
1342  ServerCaptureBuffer = ApiMessage->CsrCaptureData;
1343 
1344  /* Do not continue if there is no captured buffer */
1345  if (!ServerCaptureBuffer) return;
1346 
1347  /* If there is one, get the corresponding client capture buffer */
1348  ClientCaptureBuffer = ServerCaptureBuffer->PreviousCaptureBuffer;
1349 
1350  /* Free the previous one and use again the client capture buffer */
1351  ServerCaptureBuffer->PreviousCaptureBuffer = NULL;
1352  ApiMessage->CsrCaptureData = ClientCaptureBuffer;
1353 
1354  /* Calculate the difference between our buffer and the client's */
1355  BufferDistance = (ULONG_PTR)ServerCaptureBuffer - (ULONG_PTR)ClientCaptureBuffer;
1356 
1357  /*
1358  * All the pointer offsets correspond to pointers which point
1359  * to the client data buffer instead of the server one (reverse
1360  * the logic of CsrCaptureArguments()).
1361  */
1362  PointerCount = ServerCaptureBuffer->PointerCount;
1363  OffsetPointer = ServerCaptureBuffer->PointerOffsetsArray;
1364  while (PointerCount--)
1365  {
1366  CurrentOffset = *OffsetPointer;
1367 
1368  if (CurrentOffset != 0)
1369  {
1370  /* Get the pointer corresponding to the offset */
1371  CurrentOffset += (ULONG_PTR)ApiMessage;
1372 
1373  /* Modify the pointed pointer to take into account its new position */
1374  *(PULONG_PTR)CurrentOffset -= BufferDistance;
1375  }
1376 
1377  ++OffsetPointer;
1378  }
1379 
1380  /* Copy the data back into the client buffer */
1381  _SEH2_TRY
1382  {
1383  RtlMoveMemory(ClientCaptureBuffer, ServerCaptureBuffer, ServerCaptureBuffer->Size);
1384  }
1386  {
1387 #ifdef CSR_DBG
1388  DPRINT1("*** CSRSS: Took exception during release %x\n", _SEH2_GetExceptionCode());
1389  if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
1390 #endif
1391  /* Return failure */
1392  ApiMessage->Status = _SEH2_GetExceptionCode();
1393  }
1394  _SEH2_END;
1395 
1396  /* Free our allocated buffer */
1397  RtlFreeHeap(CsrHeap, 0, ServerCaptureBuffer);
1398 }
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
void DbgBreakPoint()
Definition: mach.c:553
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
struct _CSR_CAPTURE_BUFFER * PreviousCaptureBuffer
Definition: csrmsg.h:95
ULONG PointerCount
Definition: csrmsg.h:96
ULONG_PTR SIZE_T
Definition: typedefs.h:80
_SEH2_END
Definition: create.c:4400
#define NtCurrentPeb()
Definition: FLS.c:20
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:65
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
HANDLE CsrHeap
Definition: init.c:25
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
ULONG_PTR PointerOffsetsArray[ANYSIZE_ARRAY]
Definition: csrmsg.h:98

Referenced by CsrApiRequestThread(), and CsrNotifyWaitBlock().

◆ CsrRemoveProcess()

VOID NTAPI CsrRemoveProcess ( IN PCSR_PROCESS  CsrProcess)

Definition at line 319 of file procsup.c.

320 {
321  PCSR_SERVER_DLL ServerDll;
322  ULONG i;
324 
325  /* Remove us from the Process List */
326  RemoveEntryList(&CsrProcess->ListLink);
327 
328  /* Release the lock */
330 
331  /* Loop every Server DLL */
332  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
333  {
334  /* Get the Server DLL */
335  ServerDll = CsrLoadedServerDll[i];
336 
337  /* Check if it's valid and if it has a Disconnect Callback */
338  if (ServerDll && ServerDll->DisconnectCallback)
339  {
340  /* Call it */
341  ServerDll->DisconnectCallback(CsrProcess);
342  }
343  }
344 }
PKPROCESS CsrProcess
Definition: videoprt.c:39
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define CsrReleaseProcessLock()
Definition: api.h:15
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define ProcessStructureListLocked()
Definition: api.h:18
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PCSR_DISCONNECT_CALLBACK DisconnectCallback
Definition: csrsrv.h:236
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
unsigned int ULONG
Definition: retypes.h:1
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20

Referenced by CsrProcessRefcountZero().

◆ CsrSbApiHandleConnectionRequest()

NTSTATUS NTAPI CsrSbApiHandleConnectionRequest ( IN PSB_API_MSG  Message)

Definition at line 434 of file session.c.

435 {
437  REMOTE_PORT_VIEW RemotePortView;
438  HANDLE hPort;
439 
440  /* Set the Port View Structure Length */
441  RemotePortView.Length = sizeof(REMOTE_PORT_VIEW);
442 
443  /* Accept the connection */
444  Status = NtAcceptConnectPort(&hPort,
445  NULL,
446  &Message->h,
447  TRUE,
448  NULL,
449  &RemotePortView);
450  if (!NT_SUCCESS(Status))
451  {
452  DPRINT1("CSRSS: Sb Accept Connection failed %lx\n", Status);
453  return Status;
454  }
455 
456  /* Complete the Connection */
457  Status = NtCompleteConnectPort(hPort);
458  if (!NT_SUCCESS(Status))
459  {
460  DPRINT1("CSRSS: Sb Complete Connection failed %lx\n",Status);
461  }
462 
463  /* Return status */
464  return Status;
465 }
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
smooth NULL
Definition: ftsmooth.c:416
struct _REMOTE_PORT_VIEW REMOTE_PORT_VIEW
NTSTATUS NTAPI NtAcceptConnectPort(OUT PHANDLE PortHandle, IN PVOID PortContext OPTIONAL, IN PPORT_MESSAGE ReplyMessage, IN BOOLEAN AcceptConnection, IN OUT PPORT_VIEW ServerView OPTIONAL, OUT PREMOTE_PORT_VIEW ClientView OPTIONAL)
Definition: complete.c:40
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
CHAR Message[80]
Definition: alive.c:5
Status
Definition: gdiplustypes.h:24
#define DPRINT1
Definition: precomp.h:8
NTSTATUS NTAPI NtCompleteConnectPort(IN HANDLE PortHandle)
Definition: complete.c:421

Referenced by CsrSbApiRequestThread().

◆ CsrSbApiPortInitialize()

NTSTATUS NTAPI CsrSbApiPortInitialize ( VOID  )

Definition at line 875 of file init.c.

876 {
877  ULONG Size;
878  PSECURITY_DESCRIPTOR PortSd;
881  HANDLE hRequestThread;
883 
884  /* Calculate how much space we'll need for the Port Name */
885  Size = CsrDirectoryName.Length + sizeof(SB_PORT_NAME) + sizeof(WCHAR);
886 
887  /* Create the buffer for it */
890 
891  /* Setup the rest of the empty string */
894 
895  /* Now append the full port name */
899  if (CsrDebug & 2) DPRINT1("CSRSS: Creating %wZ port and associated thread\n", &CsrSbApiPortName);
900 
901  /* Create Security Descriptor for this Port */
902  Status = CsrCreateLocalSystemSD(&PortSd);
903  if (!NT_SUCCESS(Status)) return Status;
904 
905  /* Initialize the Attributes */
908  0,
909  NULL,
910  PortSd);
911 
912  /* Create the Port Object */
915  sizeof(SB_CONNECTION_INFO),
916  sizeof(SB_API_MSG),
917  32 * sizeof(SB_API_MSG));
918  if (PortSd) RtlFreeHeap(CsrHeap, 0, PortSd);
919 
920  if (NT_SUCCESS(Status))
921  {
922  /* Create the Thread to handle the API Requests */
924  NULL,
925  TRUE,
926  0,
927  0,
928  0,
930  NULL,
931  &hRequestThread,
932  &ClientId);
933  if (NT_SUCCESS(Status))
934  {
935  /* Add it as a Static Server Thread */
937  &ClientId,
938  0);
939 
940  /* Activate it */
941  Status = NtResumeThread(hRequestThread, NULL);
942  }
943  }
944 
945  return Status;
946 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define TRUE
Definition: types.h:120
#define SB_PORT_NAME
Definition: srv.h:47
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
PCSR_THREAD CsrSbApiRequestThreadPtr
Definition: init.c:30
VOID NTAPI CsrSbApiRequestThread(IN PVOID Parameter)
Definition: session.c:484
UNICODE_STRING CsrSbApiPortName
Definition: init.c:28
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:511
smooth NULL
Definition: ftsmooth.c:416
#define NtCurrentProcess()
Definition: nt_native.h:1657
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163
NTSTATUS NTAPI NtCreatePort(OUT PHANDLE PortHandle, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG MaxConnectInfoLength, IN ULONG MaxDataLength, IN ULONG MaxPoolUsage)
Definition: create.c:212
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI CsrCreateLocalSystemSD(OUT PSECURITY_DESCRIPTOR *LocalSystemSd)
Definition: init.c:807
Status
Definition: gdiplustypes.h:24
NTSYSAPI NTSTATUS NTAPI RtlCreateUserThread(_In_ PVOID ThreadContext, _Out_ HANDLE *OutThreadHandle, _Reserved_ PVOID Reserved1, _Reserved_ PVOID Reserved2, _Reserved_ PVOID Reserved3, _Reserved_ PVOID Reserved4, _Reserved_ PVOID Reserved5, _Reserved_ PVOID Reserved6, _Reserved_ PVOID Reserved7, _Reserved_ PVOID Reserved8)
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
HANDLE CsrSbApiPort
Definition: init.c:29
unsigned short USHORT
Definition: pedump.c:61
#define UNICODE_PATH_SEP
Definition: connect.c:33
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define DPRINT1
Definition: precomp.h:8
UNICODE_STRING CsrDirectoryName
Definition: init.c:27
unsigned int ULONG
Definition: retypes.h:1
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
ULONG CsrDebug
Definition: init.c:23
HANDLE CsrHeap
Definition: init.c:25

Referenced by CsrServerInitialization().

◆ CsrSbApiRequestThread()

VOID NTAPI CsrSbApiRequestThread ( IN PVOID  Parameter)

Definition at line 484 of file session.c.

485 {
487  SB_API_MSG ReceiveMsg;
488  PSB_API_MSG ReplyMsg = NULL;
489  PVOID PortContext;
490  ULONG MessageType;
491 
492  /* Start the loop */
493  while (TRUE)
494  {
495  /* Wait for a message to come in */
497  &PortContext,
498  &ReplyMsg->h,
499  &ReceiveMsg.h);
500 
501  /* Check if we didn't get success */
502  if (Status != STATUS_SUCCESS)
503  {
504  /* If we only got a warning, keep going */
505  if (NT_SUCCESS(Status)) continue;
506 
507  /* We failed big time, so start out fresh */
508  ReplyMsg = NULL;
509  DPRINT1("CSRSS: ReceivePort failed - Status == %X\n", Status);
510  continue;
511  }
512 
513  /* Save the message type */
514  MessageType = ReceiveMsg.h.u2.s2.Type;
515 
516  /* Check if this is a connection request */
517  if (MessageType == LPC_CONNECTION_REQUEST)
518  {
519  /* Handle connection request */
520  CsrSbApiHandleConnectionRequest(&ReceiveMsg);
521 
522  /* Start over */
523  ReplyMsg = NULL;
524  continue;
525  }
526 
527  /* Check if the port died */
528  if (MessageType == LPC_PORT_CLOSED)
529  {
530  /* Close the handle if we have one */
531  if (PortContext) NtClose((HANDLE)PortContext);
532 
533  /* Client died, start over */
534  ReplyMsg = NULL;
535  continue;
536  }
537  else if (MessageType == LPC_CLIENT_DIED)
538  {
539  /* Client died, start over */
540  ReplyMsg = NULL;
541  continue;
542  }
543 
544  /*
545  * It's an API Message, check if it's within limits. If it's not,
546  * the NT Behaviour is to set this to the Maximum API.
547  */
548  if (ReceiveMsg.ApiNumber > SbpMaxApiNumber)
549  {
550  ReceiveMsg.ApiNumber = SbpMaxApiNumber;
551  DPRINT1("CSRSS: %lx is invalid Sb ApiNumber\n", ReceiveMsg.ApiNumber);
552  }
553 
554  /* Reuse the message */
555  ReplyMsg = &ReceiveMsg;
556 
557  /* Make sure that the message is supported */
558  if (ReceiveMsg.ApiNumber < SbpMaxApiNumber)
559  {
560  /* Call the API */
561  if (!CsrServerSbApiDispatch[ReceiveMsg.ApiNumber](&ReceiveMsg))
562  {
563  DPRINT1("CSRSS: %s Session Api called and failed\n",
564  CsrServerSbApiName[ReceiveMsg.ApiNumber]);
565 
566  /* It failed, so return nothing */
567  ReplyMsg = NULL;
568  }
569  }
570  else
571  {
572  /* We don't support this API Number */
574  }
575  }
576 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
PORT_MESSAGE h
Definition: smmsg.h:202
#define TRUE
Definition: types.h:120
NTSTATUS NTAPI CsrSbApiHandleConnectionRequest(IN PSB_API_MSG Message)
Definition: session.c:434
LONG NTSTATUS
Definition: precomp.h:26
PSB_API_ROUTINE CsrServerSbApiDispatch[SbpMaxApiNumber - SbpCreateSession]
Definition: session.c:21
SB_API_NUMBER ApiNumber
Definition: smmsg.h:208
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS ReturnValue
Definition: smmsg.h:209
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
PCHAR CsrServerSbApiName[SbpMaxApiNumber - SbpCreateSession]
Definition: session.c:29
NTSTATUS NTAPI NtReplyWaitReceivePort(IN HANDLE PortHandle, OUT PVOID *PortContext OPTIONAL, IN PPORT_MESSAGE ReplyMessage OPTIONAL, OUT PPORT_MESSAGE ReceiveMessage)
Definition: reply.c:743
Status
Definition: gdiplustypes.h:24
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
HANDLE CsrSbApiPort
Definition: init.c:29

Referenced by CsrSbApiPortInitialize().

◆ CsrSbCreateProcess()

BOOLEAN NTAPI CsrSbCreateProcess ( IN PSB_API_MSG  ApiMessage)

Definition at line 410 of file session.c.

411 {
412  ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
413  return TRUE;
414 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define TRUE
Definition: types.h:120

◆ CsrSbCreateSession()

BOOLEAN NTAPI CsrSbCreateSession ( IN PSB_API_MSG  ApiMessage)

Definition at line 208 of file session.c.

209 {
210  PSB_CREATE_SESSION_MSG CreateSession = &ApiMessage->CreateSession;
213  PCSR_THREAD CsrThread;
214  PCSR_SERVER_DLL ServerDll;
215  PVOID ProcessData;
217  KERNEL_USER_TIMES KernelTimes;
218  ULONG i;
219 
220  /* Save the Process and Thread Handles */
221  hProcess = CreateSession->ProcessInfo.ProcessHandle;
222  hThread = CreateSession->ProcessInfo.ThreadHandle;
223 
224  /* Lock the Processes */
226 
227  /* Allocate a new process */
229  if (!CsrProcess)
230  {
231  /* Fail */
232  ApiMessage->ReturnValue = STATUS_NO_MEMORY;
234  return TRUE;
235  }
236 
237  /* Set the Exception Port for us */
240  &CsrApiPort,
241  sizeof(CsrApiPort));
242 
243  /* Check for success */
244  if (!NT_SUCCESS(Status))
245  {
246  /* Fail the request */
249 
250  /* Strange as it seems, NTSTATUSes are actually returned */
251  return (BOOLEAN)STATUS_NO_MEMORY;
252  }
253 
254  /* Get the Create Time */
256  ThreadTimes,
257  &KernelTimes,
258  sizeof(KernelTimes),
259  NULL);
260 
261  /* Check for success */
262  if (!NT_SUCCESS(Status))
263  {
264  /* Fail the request */
267 
268  /* Strange as it seems, NTSTATUSes are actually returned */
269  return (BOOLEAN)Status;
270  }
271 
272  /* Allocate a new Thread */
273  CsrThread = CsrAllocateThread(CsrProcess);
274  if (!CsrThread)
275  {
276  /* Fail the request */
279 
280  ApiMessage->ReturnValue = STATUS_NO_MEMORY;
281  return TRUE;
282  }
283 
284  /* Setup the Thread Object */
285  CsrThread->CreateTime = KernelTimes.CreateTime;
286  CsrThread->ClientId = CreateSession->ProcessInfo.ClientId;
287  CsrThread->ThreadHandle = hThread;
289  CsrThread->Flags = 0;
290 
291  /* Insert it into the Process List */
292  Status = CsrInsertThread(CsrProcess, CsrThread);
293  if (!NT_SUCCESS(Status))
294  {
295  /* Bail out */
297  CsrDeallocateThread(CsrThread);
299 
300  /* Strange as it seems, NTSTATUSes are actually returned */
301  return (BOOLEAN)Status;
302  }
303 
304  /* Setup Process Data */
305  CsrProcess->ClientId = CreateSession->ProcessInfo.ClientId;
306  CsrProcess->ProcessHandle = hProcess;
307  CsrProcess->NtSession = CsrAllocateNtSession(CreateSession->SessionId);
308 
309  /* Set the Process Priority */
311 
312  /* Get the first data location */
313  ProcessData = &CsrProcess->ServerData[CSR_SERVER_DLL_MAX];
314 
315  /* Loop every DLL */
316  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
317  {
318  /* Get the current Server */
319  ServerDll = CsrLoadedServerDll[i];
320 
321  /* Check if the DLL is loaded and has Process Data */
322  if (ServerDll && ServerDll->SizeOfProcessData)
323  {
324  /* Write the pointer to the data */
325  CsrProcess->ServerData[i] = ProcessData;
326 
327  /* Move to the next data location */
328  ProcessData = (PVOID)((ULONG_PTR)ProcessData +
329  ServerDll->SizeOfProcessData);
330  }
331  else
332  {
333  /* Nothing for this Process */
334  CsrProcess->ServerData[i] = NULL;
335  }
336  }
337 
338  /* Insert the Process */
340 
341  /* Activate the Thread */
342  ApiMessage->ReturnValue = NtResumeThread(hThread, NULL);
343 
344  /* Release lock and return */
346  return TRUE;
347 }
PCSR_PROCESS NTAPI CsrAllocateProcess(VOID)
Definition: procsup.c:188
ULONG SizeOfProcessData
Definition: csrsrv.h:234
PCSR_THREAD NTAPI CsrAllocateThread(IN PCSR_PROCESS CsrProcess)
Definition: thredsup.c:119
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
PKPROCESS CsrProcess
Definition: videoprt.c:39
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define CsrReleaseProcessLock()
Definition: api.h:15
uint32_t ULONG_PTR
Definition: typedefs.h:65
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID NTAPI CsrDeallocateThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:345
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS NTAPI CsrInsertThread(IN PCSR_PROCESS Process, IN PCSR_THREAD Thread)
Definition: thredsup.c:297
void * PVOID
Definition: retypes.h:9
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
BOOLEAN NTAPI ProtectHandle(IN HANDLE ObjectHandle)
Definition: thredsup.c:39
LARGE_INTEGER CreateTime
Definition: csrsrv.h:65
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
CLIENT_ID ClientId
Definition: csrsrv.h:68
VOID NTAPI CsrDeallocateProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:296
LARGE_INTEGER CreateTime
Definition: winternl.h:1060
PCSR_NT_SESSION NTAPI CsrAllocateNtSession(IN ULONG SessionId)
Definition: session.c:77
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2506
HANDLE ThreadHandle
Definition: csrsrv.h:71
#define CsrAcquireProcessLock()
Definition: api.h:12
Status
Definition: gdiplustypes.h:24
HANDLE CsrApiPort
Definition: connect.c:21
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1112
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
HANDLE hThread
Definition: wizard.c:27
VOID NTAPI CsrSetBackgroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1106
unsigned int ULONG
Definition: retypes.h:1
VOID NTAPI CsrInsertProcess(IN PCSR_PROCESS ParentProcess OPTIONAL, IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:365
ULONG Flags
Definition: csrsrv.h:72
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20
MMRESULT CreateSession(DeviceType device_type, UINT device_id, SessionInfo **session_info)
Definition: session.c:63

◆ CsrSbForeignSessionComplete()

BOOLEAN NTAPI CsrSbForeignSessionComplete ( IN PSB_API_MSG  ApiMessage)

Definition at line 365 of file session.c.

366 {
367  /* Deprecated/Unimplemented in NT */
368  ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
369  return TRUE;
370 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define TRUE
Definition: types.h:120

◆ CsrSbTerminateSession()

BOOLEAN NTAPI CsrSbTerminateSession ( IN PSB_API_MSG  ApiMessage)

Definition at line 388 of file session.c.

389 {
390  ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
391  return TRUE;
392 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define TRUE
Definition: types.h:120

◆ CsrServerDllInitialization()

NTSTATUS NTAPI CsrServerDllInitialization ( IN PCSR_SERVER_DLL  LoadedServerDll)

Referenced by CsrLoadServerDll().

◆ CsrSetDirectorySecurity()

NTSTATUS NTAPI CsrSetDirectorySecurity ( IN HANDLE  ObjectDirectory)

Definition at line 182 of file init.c.

183 {
184  /* FIXME: Implement */
185  return STATUS_SUCCESS;
186 }
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by CsrParseServerCommandLine().

◆ CsrSrvAttachSharedSection()

NTSTATUS NTAPI CsrSrvAttachSharedSection ( IN PCSR_PROCESS CsrProcess  OPTIONAL,
OUT PCSR_API_CONNECTINFO  ConnectInfo 
)

Definition at line 472 of file server.c.

474 {
476  SIZE_T ViewSize = 0;
477 
478  /* Check if we have a process */
479  if (CsrProcess)
480  {
481  /* Map the section into this process */
483  CsrProcess->ProcessHandle,
485  0,
486  0,
487  NULL,
488  &ViewSize,
489  ViewUnmap,
492  if (!NT_SUCCESS(Status)) return Status;
493  }
494 
495  /* Write the values in the Connection Info structure */
496  ConnectInfo->SharedSectionBase = CsrSrvSharedSectionBase;
497  ConnectInfo->SharedSectionHeap = CsrSrvSharedSectionHeap;
498  ConnectInfo->SharedStaticServerData = CsrSrvSharedStaticServerData;
499 
500  /* Return success */
501  return STATUS_SUCCESS;
502 }
PVOID CsrSrvSharedSectionHeap
Definition: server.c:21
LONG NTSTATUS
Definition: precomp.h:26
PKPROCESS CsrProcess
Definition: videoprt.c:39
PVOID * CsrSrvSharedStaticServerData
Definition: server.c:23
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3554
PVOID CsrSrvSharedSectionBase
Definition: server.c:22
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:24
ULONG_PTR SIZE_T
Definition: typedefs.h:80
HANDLE CsrSrvSharedSection
Definition: server.c:25
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:404
#define PAGE_EXECUTE_READ
Definition: nt_native.h:1307
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define SEC_NO_CHANGE
Definition: mmtypes.h:94

Referenced by CsrApiHandleConnectionRequest().

◆ CsrSrvCreateSharedSection()

NTSTATUS NTAPI CsrSrvCreateSharedSection ( IN PCHAR  ParameterValue)

Definition at line 351 of file server.c.

352 {
353  PCHAR SizeValue = ParameterValue;
354  ULONG Size;
356  LARGE_INTEGER SectionSize;
357  SIZE_T ViewSize = 0;
358  PPEB Peb = NtCurrentPeb();
359 
360  /* If there's no parameter, fail */
362 
363  /* Find the first comma, and null terminate */
364  while (*SizeValue)
365  {
366  if (*SizeValue == ',')
367  {
368  *SizeValue++ = ANSI_NULL;
369  break;
370  }
371  else
372  {
373  SizeValue++;
374  }
375  }
376 
377  /* Make sure it's valid */
378  if (!*SizeValue) return STATUS_INVALID_PARAMETER;
379 
380  /* Convert it to an integer */
381  Status = RtlCharToInteger(SizeValue, 0, &Size);
382  if (!NT_SUCCESS(Status)) return Status;
383 
384  /* Multiply by 1024 entries and round to page size */
386 
387  /* Create the Secion */
388  SectionSize.LowPart = CsrSrvSharedSectionSize;
389  SectionSize.HighPart = 0;
392  NULL,
393  &SectionSize,
396  NULL);
397  if (!NT_SUCCESS(Status)) return Status;
398 
399  /* Map the section */
403  0,
404  0,
405  NULL,
406  &ViewSize,
407  ViewUnmap,
408  MEM_TOP_DOWN,
410  if (!NT_SUCCESS(Status))
411  {
412  /* Fail */
414  return Status;
415  }
416 
417  /* FIXME: Write the value to registry */
418 
419  /* The Heap is the same place as the Base */
421 
422  /* Create the heap */
426  PAGE_SIZE,
427  0,
428  0)))
429  {
430  /* Failure, unmap section and return */
433  return STATUS_NO_MEMORY;
434  }
435 
436  /* Now allocate space from the heap for the Shared Data */
439  CSR_SERVER_DLL_MAX * sizeof(PVOID));
441 
442  /* Write the values to the PEB */
446 
447  /* Return */
448  return STATUS_SUCCESS;
449 }
signed char * PCHAR
Definition: retypes.h:7
NTSYSAPI NTSTATUS NTAPI RtlCharToInteger(PCSZ String, ULONG Base, PULONG Value)
Definition: unicode.c:261
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3782
PPEB Peb
Definition: dllmain.c:27
#define ROUND_UP(n, align)
Definition: eventvwr.h:31
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3373
PVOID CsrSrvSharedSectionHeap
Definition: server.c:21
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
ULONG CsrSrvSharedSectionSize
Definition: server.c:24
LONG NTSTATUS
Definition: precomp.h:26
PVOID ReadOnlySharedMemoryHeap
Definition: ntddk_ex.h:262
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define SEC_BASED
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
PVOID * CsrSrvSharedStaticServerData
Definition: server.c:23
#define ANSI_NULL
#define SEC_RESERVE
Definition: nt_native.h:1323
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3554
PVOID CsrSrvSharedSectionBase
Definition: server.c:22
smooth NULL
Definition: ftsmooth.c:416
#define NtCurrentProcess()
Definition: nt_native.h:1657
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define HEAP_CLASS_7
Definition: nt_native.h:1717
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
SYSTEM_BASIC_INFORMATION CsrNtSysInfo
Definition: init.c:40
_In_opt_ PWSTR _In_ PWSTR _Inout_ PULONG ParameterValue
Definition: classpnp.h:1402
Status
Definition: gdiplustypes.h:24
ULONG LowPart
Definition: typedefs.h:106
NTSYSAPI PVOID NTAPI RtlCreateHeap(IN ULONG Flags, IN PVOID HeapBase OPTIONAL, IN ULONG ReserveSize OPTIONAL, IN ULONG CommitSize OPTIONAL, IN PVOID Lock OPTIONAL, IN PRTL_HEAP_PARAMETERS Parameters OPTIONAL)
#define PAGE_SIZE
Definition: env_spec_w32.h:49
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
ULONG_PTR SIZE_T
Definition: typedefs.h:80
HANDLE CsrSrvSharedSection
Definition: server.c:25
#define NtCurrentPeb()
Definition: FLS.c:20
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:404
unsigned int ULONG
Definition: retypes.h:1
PVOID ReadOnlySharedMemoryBase
Definition: ntddk_ex.h:261
PVOID * ReadOnlyStaticServerData
Definition: ntddk_ex.h:263
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1308
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by CsrParseServerCommandLine().

◆ ProtectHandle()

BOOLEAN NTAPI ProtectHandle ( IN HANDLE  ObjectHandle)

Definition at line 39 of file thredsup.c.

40 {
43 
44  /* Query current state */
45  Status = NtQueryObject(ObjectHandle,
46  ObjectHandleFlagInformation,
47  &HandleInfo,
48  sizeof(HandleInfo),
49  NULL);
50  if (NT_SUCCESS(Status))
51  {
52  /* Enable protect from close */
53  HandleInfo.ProtectFromClose = TRUE;
54  Status = NtSetInformationObject(ObjectHandle,
55  ObjectHandleFlagInformation,
56  &HandleInfo,
57  sizeof(HandleInfo));
58  if (NT_SUCCESS(Status)) return TRUE;
59  }
60 
61  /* We failed to or set the state */
62  return FALSE;
63 }
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
#define FALSE
Definition: types.h:117
NTSTATUS NTAPI NtSetInformationObject(IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, IN PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1735
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NtQueryObject(IN HANDLE Handle, IN OBJECT_INFO_CLASS ObjectInformationClass, OUT PVOID ObjectInformation, IN ULONG ObjectInformationLength, OUT PULONG ReturnLength)
Status
Definition: gdiplustypes.h:24

Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().

◆ UnProtectHandle()

BOOLEAN NTAPI UnProtectHandle ( IN HANDLE  ObjectHandle)

Definition at line 78 of file thredsup.c.

79 {
82 
83  /* Query current state */
84  Status = NtQueryObject(ObjectHandle,
85  ObjectHandleFlagInformation,
86  &HandleInfo,
87  sizeof(HandleInfo),
88  NULL);
89  if (NT_SUCCESS(Status))
90  {
91  /* Disable protect from close */
92  HandleInfo.ProtectFromClose = FALSE;
93  Status = NtSetInformationObject(ObjectHandle,
94  ObjectHandleFlagInformation,
95  &HandleInfo,
96  sizeof(HandleInfo));
97  if (NT_SUCCESS(Status)) return TRUE;
98  }
99 
100  /* We failed to or set the state */
101  return FALSE;
102 }
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
#define FALSE
Definition: types.h:117
NTSTATUS NTAPI NtSetInformationObject(IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, IN PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1735
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NtQueryObject(IN HANDLE Handle, IN OBJECT_INFO_CLASS ObjectInformationClass, OUT PVOID ObjectInformation, IN ULONG ObjectInformationLength, OUT PULONG ReturnLength)
Status
Definition: gdiplustypes.h:24

Referenced by CsrThreadRefcountZero().

Variable Documentation

◆ CsrApiPort

HANDLE CsrApiPort

Definition at line 21 of file connect.c.

◆ CsrApiPortName

UNICODE_STRING CsrApiPortName

Definition at line 22 of file api.c.

Referenced by CsrApiPortInitialize().

◆ CsrDebug

◆ CsrDirectoryName

UNICODE_STRING CsrDirectoryName

Definition at line 27 of file init.c.

Referenced by CsrApiPortInitialize(), CsrParseServerCommandLine(), and CsrSbApiPortInitialize().

◆ CsrHeap

◆ CsrInitializationEvent

HANDLE CsrInitializationEvent

◆ CsrLoadedServerDll

◆ CsrMaxApiRequestThreads

ULONG CsrMaxApiRequestThreads

Definition at line 34 of file init.c.

Referenced by CsrParseServerCommandLine().

◆ CsrNtSysInfo

Definition at line 40 of file init.c.

Referenced by CsrServerInitialization(), and CsrSrvCreateSharedSection().

◆ CsrObjectDirectory

HANDLE CsrObjectDirectory

Definition at line 26 of file init.c.

Referenced by CsrParseServerCommandLine().

◆ CsrProcessLock

RTL_CRITICAL_SECTION CsrProcessLock

Definition at line 60 of file api.h.

Referenced by CsrInitializeProcessStructure().

◆ CsrRootProcess

◆ CsrSbApiPort

HANDLE CsrSbApiPort

Definition at line 29 of file init.c.

Referenced by CsrSbApiPortInitialize(), CsrSbApiRequestThread(), and CsrServerInitialization().

◆ CsrSbApiPortName

UNICODE_STRING CsrSbApiPortName

Definition at line 28 of file init.c.

Referenced by CsrSbApiPortInitialize(), and CsrServerInitialization().

◆ CsrSmApiPort

HANDLE CsrSmApiPort

Definition at line 31 of file init.c.

Referenced by CsrDereferenceNtSession(), and CsrServerInitialization().

◆ CsrSrvSharedSectionHeap

PVOID CsrSrvSharedSectionHeap

Definition at line 21 of file server.c.

Referenced by CsrLoadServerDll(), CsrSrvAttachSharedSection(), and CsrSrvCreateSharedSection().

◆ CsrSrvSharedStaticServerData

PVOID* CsrSrvSharedStaticServerData

Definition at line 23 of file server.c.

Referenced by CsrLoadServerDll(), CsrSrvAttachSharedSection(), and CsrSrvCreateSharedSection().

◆ CsrThreadHashTable

◆ CsrTotalPerProcessDataLength

ULONG CsrTotalPerProcessDataLength

Definition at line 35 of file init.c.

Referenced by CsrLoadServerDll().

◆ CsrWaitListsLock

RTL_CRITICAL_SECTION CsrWaitListsLock

Definition at line 61 of file api.h.

Referenced by CsrInitializeProcessStructure().

◆ hBootstrapOk

HANDLE hBootstrapOk