a858a5e3f3fcb7dc6140756cb39f538c080ca977
[reactos.git] / subsystems / win32 / csrsrv / server.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Client/Server Runtime SubSystem
4 * FILE: subsystems/win32/csrsrv/server.c
5 * PURPOSE: CSR Server DLL Server Functions
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include "srv.h"
12
13 #define NDEBUG
14 #include <debug.h>
15
16 /* DATA ***********************************************************************/
17
18 PCSR_API_ROUTINE CsrServerApiDispatchTable[CsrpMaxApiNumber] =
19 {
20 CsrSrvClientConnect,
21 CsrSrvUnusedFunction,
22 CsrSrvUnusedFunction,
23 CsrSrvIdentifyAlertableThread,
24 CsrSrvSetPriorityClass
25 };
26
27 BOOLEAN CsrServerApiServerValidTable[CsrpMaxApiNumber] =
28 {
29 TRUE,
30 FALSE,
31 TRUE,
32 TRUE,
33 TRUE
34 };
35
36 PCHAR CsrServerApiNameTable[CsrpMaxApiNumber] =
37 {
38 "ClientConnect",
39 "ThreadConnect",
40 "ProfileControl",
41 "IdentifyAlertableThread",
42 "SetPriorityClass"
43 };
44
45 PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX];
46 PVOID CsrSrvSharedSectionHeap = NULL;
47 PVOID CsrSrvSharedSectionBase = NULL;
48 PVOID *CsrSrvSharedStaticServerData = NULL;
49 ULONG CsrSrvSharedSectionSize = 0;
50 HANDLE CsrSrvSharedSection = NULL;
51
52 /* PRIVATE FUNCTIONS **********************************************************/
53
54 /*++
55 * @name CsrServerDllInitialization
56 * @implemented NT4
57 *
58 * The CsrServerDllInitialization is the initialization routine for
59 * the this Server DLL.
60 *
61 * @param LoadedServerDll
62 * Pointer to the CSR Server DLL structure representing this Server DLL.
63 *
64 * @return STATUS_SUCCESS.
65 *
66 * @remarks None.
67 *
68 *--*/
69 CSR_SERVER_DLL_INIT(CsrServerDllInitialization)
70 {
71 /* Setup the DLL Object */
72 LoadedServerDll->ApiBase = 0;
73 LoadedServerDll->HighestApiSupported = CsrpMaxApiNumber;
74 LoadedServerDll->DispatchTable = CsrServerApiDispatchTable;
75 LoadedServerDll->ValidTable = CsrServerApiServerValidTable;
76 LoadedServerDll->NameTable = CsrServerApiNameTable;
77 LoadedServerDll->SizeOfProcessData = 0;
78 LoadedServerDll->ConnectCallback = NULL;
79 LoadedServerDll->DisconnectCallback = NULL;
80
81 /* All done */
82 return STATUS_SUCCESS;
83 }
84
85 /*++
86 * @name CsrLoadServerDll
87 * @implemented NT4
88 *
89 * The CsrLoadServerDll routine loads a CSR Server DLL and calls its entrypoint
90 *
91 * @param DllString
92 * Pointer to the CSR Server DLL to load and call.
93 *
94 * @param EntryPoint
95 * Pointer to the name of the server's initialization function. If
96 * this parameter is NULL, the default ServerDllInitialize will be
97 * assumed.
98 *
99 * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
100 * otherwise.
101 *
102 * @remarks None.
103 *
104 *--*/
105 NTSTATUS
106 NTAPI
107 CsrLoadServerDll(IN PCHAR DllString,
108 IN PCHAR EntryPoint OPTIONAL,
109 IN ULONG ServerId)
110 {
111 NTSTATUS Status;
112 ANSI_STRING DllName;
113 UNICODE_STRING TempString, ErrorString;
114 ULONG_PTR Parameters[2];
115 HANDLE hServerDll = NULL;
116 ULONG Size;
117 PCSR_SERVER_DLL ServerDll;
118 STRING EntryPointString;
119 PCSR_SERVER_DLL_INIT_CALLBACK ServerDllInitProcedure;
120 ULONG Response;
121
122 DPRINT1("CsrLoadServerDll(%s, 0x%p, %lu)\n", DllString, EntryPoint, ServerId);
123
124 /* Check if it's beyond the maximum we support */
125 if (ServerId >= CSR_SERVER_DLL_MAX) return STATUS_TOO_MANY_NAMES;
126
127 /* Check if it's already been loaded */
128 if (CsrLoadedServerDll[ServerId]) return STATUS_INVALID_PARAMETER;
129
130 /* Convert the name to Unicode */
131 ASSERT(DllString != NULL);
132 RtlInitAnsiString(&DllName, DllString);
133 Status = RtlAnsiStringToUnicodeString(&TempString, &DllName, TRUE);
134 if (!NT_SUCCESS(Status)) return Status;
135
136 /* If we are loading ourselves, don't actually load us */
137 if (ServerId != CSRSRV_SERVERDLL_INDEX)
138 {
139 /* Load the DLL */
140 Status = LdrLoadDll(NULL, 0, &TempString, &hServerDll);
141 if (!NT_SUCCESS(Status))
142 {
143 /* Setup error parameters */
144 Parameters[0] = (ULONG_PTR)&TempString;
145 Parameters[1] = (ULONG_PTR)&ErrorString;
146 RtlInitUnicodeString(&ErrorString, L"Default Load Path");
147
148 /* Send a hard error */
149 NtRaiseHardError(Status,
150 2,
151 3,
152 Parameters,
153 OptionOk,
154 &Response);
155 }
156
157 /* Get rid of the string */
158 RtlFreeUnicodeString(&TempString);
159 if (!NT_SUCCESS(Status)) return Status;
160 }
161
162 /* Allocate a CSR DLL Object */
163 Size = sizeof(CSR_SERVER_DLL) + DllName.MaximumLength;
164 ServerDll = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, Size);
165 if (!ServerDll)
166 {
167 if (hServerDll) LdrUnloadDll(hServerDll);
168 return STATUS_NO_MEMORY;
169 }
170
171 /* Set up the Object */
172 ServerDll->Length = Size;
173 ServerDll->SharedSection = CsrSrvSharedSectionHeap; // Send to the server dll our shared heap pointer.
174 ServerDll->Event = CsrInitializationEvent;
175 ServerDll->Name.Length = DllName.Length;
176 ServerDll->Name.MaximumLength = DllName.MaximumLength;
177 ServerDll->Name.Buffer = (PCHAR)(ServerDll + 1);
178 if (DllName.Length)
179 {
180 strncpy(ServerDll->Name.Buffer, DllName.Buffer, DllName.Length);
181 }
182 ServerDll->ServerId = ServerId;
183 ServerDll->ServerHandle = hServerDll;
184
185 /* Now get the entrypoint */
186 if (hServerDll)
187 {
188 /* Initialize a string for the entrypoint, or use the default */
189 RtlInitAnsiString(&EntryPointString,
190 EntryPoint ? EntryPoint : "ServerDllInitialization");
191
192 /* Get a pointer to it */
193 Status = LdrGetProcedureAddress(hServerDll,
194 &EntryPointString,
195 0,
196 (PVOID)&ServerDllInitProcedure);
197 }
198 else
199 {
200 /* No handle, so we are loading ourselves */
201 ServerDllInitProcedure = CsrServerDllInitialization;
202 Status = STATUS_SUCCESS;
203 }
204
205 /* Check if we got the pointer, and call it */
206 if (NT_SUCCESS(Status))
207 {
208 /* Get the result from the Server DLL */
209 Status = ServerDllInitProcedure(ServerDll);
210 if (NT_SUCCESS(Status))
211 {
212 /*
213 * Add this Server's Per-Process Data Size to the total that each
214 * process will need.
215 */
216 CsrTotalPerProcessDataLength += ServerDll->SizeOfProcessData;
217
218 /* Save the pointer in our list */
219 CsrLoadedServerDll[ServerDll->ServerId] = ServerDll;
220
221 /* Does it use our generic heap? */
222 if (ServerDll->SharedSection != CsrSrvSharedSectionHeap)
223 {
224 /* No, save the pointer to its shared section in our list */
225 CsrSrvSharedStaticServerData[ServerDll->ServerId] = ServerDll->SharedSection;
226 }
227 }
228 else
229 {
230 /* Use shared failure code */
231 goto LoadFailed;
232 }
233 }
234 else
235 {
236 LoadFailed:
237 /* Server Init failed, unload it */
238 if (hServerDll) LdrUnloadDll(hServerDll);
239
240 /* Delete the Object */
241 RtlFreeHeap(CsrHeap, 0, ServerDll);
242 }
243
244 /* Return to caller */
245 return Status;
246 }
247
248 /*++
249 * @name CsrSrvClientConnect
250 *
251 * The CsrSrvClientConnect CSR API handles a new connection to a server DLL.
252 *
253 * @param ApiMessage
254 * Pointer to the CSR API Message for this request.
255 *
256 * @param ReplyCode
257 * Optional reply to this request.
258 *
259 * @return STATUS_SUCCESS in case of success, STATUS_INVALID_PARAMETER
260 * or STATUS_TOO_MANY_NAMES in case of failure.
261 *
262 * @remarks None.
263 *
264 *--*/
265 CSR_API(CsrSrvClientConnect)
266 {
267 NTSTATUS Status;
268 PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage->Data.CsrClientConnect;
269 PCSR_SERVER_DLL ServerDll;
270 PCSR_PROCESS CurrentProcess = CsrGetClientThread()->Process;
271
272 /* Set default reply */
273 *ReplyCode = CsrReplyImmediately;
274
275 /* Validate the ServerID */
276 if (ClientConnect->ServerId >= CSR_SERVER_DLL_MAX)
277 {
278 return STATUS_TOO_MANY_NAMES;
279 }
280 else if (!CsrLoadedServerDll[ClientConnect->ServerId])
281 {
282 return STATUS_INVALID_PARAMETER;
283 }
284
285 /* Validate the Message Buffer */
286 if (!(CsrValidateMessageBuffer(ApiMessage,
287 &ClientConnect->ConnectionInfo,
288 ClientConnect->ConnectionInfoSize,
289 sizeof(BYTE))))
290 {
291 /* Fail due to buffer overflow or other invalid buffer */
292 return STATUS_INVALID_PARAMETER;
293 }
294
295 /* Load the Server DLL */
296 ServerDll = CsrLoadedServerDll[ClientConnect->ServerId];
297
298 /* Check if it has a Connect Callback */
299 if (ServerDll->ConnectCallback)
300 {
301 /* Call the callback */
302 Status = ServerDll->ConnectCallback(CurrentProcess,
303 ClientConnect->ConnectionInfo,
304 &ClientConnect->ConnectionInfoSize);
305 }
306 else
307 {
308 /* Assume success */
309 Status = STATUS_SUCCESS;
310 }
311
312 /* Return status */
313 return Status;
314 }
315
316 /*++
317 * @name CsrSrvCreateSharedSection
318 *
319 * The CsrSrvCreateSharedSection creates the Shared Section that all CSR Server
320 * DLLs and Clients can use to share data.
321 *
322 * @param ParameterValue
323 * Specially formatted string from our registry command-line which
324 * specifies various arguments for the shared section.
325 *
326 * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
327 * otherwise.
328 *
329 * @remarks None.
330 *
331 *--*/
332 NTSTATUS
333 NTAPI
334 CsrSrvCreateSharedSection(IN PCHAR ParameterValue)
335 {
336 PCHAR SizeValue = ParameterValue;
337 ULONG Size;
338 NTSTATUS Status;
339 LARGE_INTEGER SectionSize;
340 ULONG ViewSize = 0;
341 PPEB Peb = NtCurrentPeb();
342
343 /* If there's no parameter, fail */
344 if (!ParameterValue) return STATUS_INVALID_PARAMETER;
345
346 /* Find the first comma, and null terminate */
347 while (*SizeValue)
348 {
349 if (*SizeValue == ',')
350 {
351 *SizeValue++ = ANSI_NULL;
352 break;
353 }
354 else
355 {
356 SizeValue++;
357 }
358 }
359
360 /* Make sure it's valid */
361 if (!*SizeValue) return STATUS_INVALID_PARAMETER;
362
363 /* Convert it to an integer */
364 Status = RtlCharToInteger(SizeValue, 0, &Size);
365 if (!NT_SUCCESS(Status)) return Status;
366
367 /* Multiply by 1024 entries and round to page size */
368 CsrSrvSharedSectionSize = ROUND_UP(Size * 1024, CsrNtSysInfo.PageSize);
369
370 /* Create the Secion */
371 SectionSize.LowPart = CsrSrvSharedSectionSize;
372 SectionSize.HighPart = 0;
373 Status = NtCreateSection(&CsrSrvSharedSection,
374 SECTION_ALL_ACCESS,
375 NULL,
376 &SectionSize,
377 PAGE_EXECUTE_READWRITE,
378 SEC_BASED | SEC_RESERVE,
379 NULL);
380 if (!NT_SUCCESS(Status)) return Status;
381
382 /* Map the section */
383 Status = NtMapViewOfSection(CsrSrvSharedSection,
384 NtCurrentProcess(),
385 &CsrSrvSharedSectionBase,
386 0,
387 0,
388 NULL,
389 &ViewSize,
390 ViewUnmap,
391 MEM_TOP_DOWN,
392 PAGE_EXECUTE_READWRITE);
393 if (!NT_SUCCESS(Status))
394 {
395 /* Fail */
396 NtClose(CsrSrvSharedSection);
397 return Status;
398 }
399
400 /* FIXME: Write the value to registry */
401
402 /* The Heap is the same place as the Base */
403 CsrSrvSharedSectionHeap = CsrSrvSharedSectionBase;
404
405 /* Create the heap */
406 if (!(RtlCreateHeap(HEAP_ZERO_MEMORY | HEAP_CLASS_7,
407 CsrSrvSharedSectionHeap,
408 CsrSrvSharedSectionSize,
409 PAGE_SIZE,
410 0,
411 0)))
412 {
413 /* Failure, unmap section and return */
414 NtUnmapViewOfSection(NtCurrentProcess(), CsrSrvSharedSectionBase);
415 NtClose(CsrSrvSharedSection);
416 return STATUS_NO_MEMORY;
417 }
418
419 /* Now allocate space from the heap for the Shared Data */
420 CsrSrvSharedStaticServerData = RtlAllocateHeap(CsrSrvSharedSectionHeap,
421 HEAP_ZERO_MEMORY,
422 CSR_SERVER_DLL_MAX * sizeof(PVOID));
423 if (!CsrSrvSharedStaticServerData) return STATUS_NO_MEMORY;
424
425 /* Write the values to the PEB */
426 Peb->ReadOnlySharedMemoryBase = CsrSrvSharedSectionBase;
427 Peb->ReadOnlySharedMemoryHeap = CsrSrvSharedSectionHeap;
428 Peb->ReadOnlyStaticServerData = CsrSrvSharedStaticServerData;
429
430 /* Return */
431 return STATUS_SUCCESS;
432 }
433
434 /*++
435 * @name CsrSrvAttachSharedSection
436 *
437 * The CsrSrvAttachSharedSection maps the CSR Shared Section into a new
438 * CSR Process' address space, and returns the pointers to the section
439 * through the Connection Info structure.
440 *
441 * @param CsrProcess
442 * Pointer to the CSR Process that is attempting a connection.
443 *
444 * @param ConnectInfo
445 * Pointer to the CSR Connection Info structure for the incoming
446 * connection.
447 *
448 * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
449 * otherwise.
450 *
451 * @remarks None.
452 *
453 *--*/
454 NTSTATUS
455 NTAPI
456 CsrSrvAttachSharedSection(IN PCSR_PROCESS CsrProcess OPTIONAL,
457 OUT PCSR_CONNECTION_INFO ConnectInfo)
458 {
459 NTSTATUS Status;
460 ULONG ViewSize = 0;
461
462 /* Check if we have a process */
463 if (CsrProcess)
464 {
465 /* Map the section into this process */
466 DPRINT("CSR Process Handle: %p. CSR Process: %p\n", CsrProcess->ProcessHandle, CsrProcess);
467 Status = NtMapViewOfSection(CsrSrvSharedSection,
468 CsrProcess->ProcessHandle,
469 &CsrSrvSharedSectionBase,
470 0,
471 0,
472 NULL,
473 &ViewSize,
474 ViewUnmap,
475 SEC_NO_CHANGE,
476 PAGE_EXECUTE_READ);
477 if (!NT_SUCCESS(Status)) return Status;
478 }
479
480 /* Write the values in the Connection Info structure */
481 ConnectInfo->SharedSectionBase = CsrSrvSharedSectionBase;
482 ConnectInfo->SharedSectionHeap = CsrSrvSharedSectionHeap;
483 ConnectInfo->SharedSectionData = CsrSrvSharedStaticServerData;
484
485 /* Return success */
486 return STATUS_SUCCESS;
487 }
488
489 /*++
490 * @name CsrSrvIdentifyAlertableThread
491 * @implemented NT4
492 *
493 * The CsrSrvIdentifyAlertableThread CSR API marks a CSR Thread as alertable.
494 *
495 * @param ApiMessage
496 * Pointer to the CSR API Message for this request.
497 *
498 * @param ReplyCode
499 * Pointer to an optional reply to this request.
500 *
501 * @return STATUS_SUCCESS.
502 *
503 * @remarks None.
504 *
505 *--*/
506 CSR_API(CsrSrvIdentifyAlertableThread)
507 {
508 PCSR_THREAD CsrThread = CsrGetClientThread();
509
510 /* Set the alertable flag */
511 CsrThread->Flags |= CsrThreadAlertable;
512
513 /* Return success */
514 return STATUS_SUCCESS;
515 }
516
517 /*++
518 * @name CsrSrvSetPriorityClass
519 * @implemented NT4
520 *
521 * The CsrSrvSetPriorityClass CSR API is deprecated.
522 *
523 * @param ApiMessage
524 * Pointer to the CSR API Message for this request.
525 *
526 * @param ReplyCode
527 * Pointer to an optional reply to this request.
528 *
529 * @return STATUS_SUCCESS.
530 *
531 * @remarks None.
532 *
533 *--*/
534 CSR_API(CsrSrvSetPriorityClass)
535 {
536 /* Deprecated */
537 return STATUS_SUCCESS;
538 }
539
540 /*++
541 * @name CsrSrvUnusedFunction
542 * @implemented NT4
543 *
544 * The CsrSrvUnusedFunction CSR API is a stub for deprecated APIs.
545 *
546 * The CsrSrvSetPriorityClass CSR API is deprecated.
547 *
548 * @param ApiMessage
549 * Pointer to the CSR API Message for this request.
550 *
551 * @param ReplyCode
552 * Pointer to an optional reply to this request.
553 *
554 * @return STATUS_INVALID_PARAMETER.
555 *
556 * @remarks CsrSrvSetPriorityClass does not use this stub because it must
557 * return success.
558 *
559 *--*/
560 CSR_API(CsrSrvUnusedFunction)
561 {
562 /* Deprecated */
563 return STATUS_INVALID_PARAMETER;
564 }
565
566 /* PUBLIC FUNCTIONS ***********************************************************/
567
568 /*++
569 * @name CsrSetCallingSpooler
570 * @implemented NT4
571 *
572 * the CsrSetCallingSpooler routine is deprecated.
573 *
574 * @param Reserved
575 * Deprecated
576 *
577 * @return None.
578 *
579 * @remarks This routine was used in archaic versions of NT for Printer Drivers.
580 *
581 *--*/
582 VOID
583 NTAPI
584 CsrSetCallingSpooler(ULONG Reserved)
585 {
586 /* Deprecated */
587 return;
588 }
589
590 /*++
591 * @name CsrUnhandledExceptionFilter
592 * @implemented NT5
593 *
594 * The CsrUnhandledExceptionFilter routine handles all exceptions
595 * within SEH-protected blocks.
596 *
597 * @param ExceptionPointers
598 * System-defined Argument.
599 *
600 * @return EXCEPTION_EXECUTE_HANDLER.
601 *
602 * @remarks None.
603 *
604 *--*/
605 EXCEPTION_DISPOSITION
606 NTAPI
607 CsrUnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
608 {
609 SYSTEM_KERNEL_DEBUGGER_INFORMATION DebuggerInfo;
610 EXCEPTION_DISPOSITION Result = EXCEPTION_EXECUTE_HANDLER;
611 BOOLEAN OldValue;
612 NTSTATUS Status;
613 UNICODE_STRING ErrorSource;
614 ULONG_PTR ErrorParameters[4];
615 ULONG Response;
616
617 /* Check if a debugger is installed */
618 Status = NtQuerySystemInformation(SystemKernelDebuggerInformation,
619 &DebuggerInfo,
620 sizeof(DebuggerInfo),
621 NULL);
622
623 /* Check if this is Session 0, and the Debugger is Enabled */
624 if ((NtCurrentPeb()->SessionId) && (NT_SUCCESS(Status)) &&
625 (DebuggerInfo.KernelDebuggerEnabled))
626 {
627 /* Call the Unhandled Exception Filter */
628 if ((Result = RtlUnhandledExceptionFilter(ExceptionInfo)) !=
629 EXCEPTION_CONTINUE_EXECUTION)
630 {
631 /* We're going to raise an error. Get Shutdown Privilege first */
632 Status = RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,
633 TRUE,
634 TRUE,
635 &OldValue);
636
637 /* Use the Process token if that failed */
638 if (Status == STATUS_NO_TOKEN)
639 {
640 Status = RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,
641 TRUE,
642 FALSE,
643 &OldValue);
644 }
645
646 /* Initialize our Name String */
647 RtlInitUnicodeString(&ErrorSource, L"Windows SubSystem");
648
649 /* Set the parameters */
650 ErrorParameters[0] = (ULONG_PTR)&ErrorSource;
651 ErrorParameters[1] = ExceptionInfo->ExceptionRecord->ExceptionCode;
652 ErrorParameters[2] = (ULONG_PTR)ExceptionInfo->ExceptionRecord->ExceptionAddress;
653 ErrorParameters[3] = (ULONG_PTR)ExceptionInfo->ContextRecord;
654
655 /* Bugcheck */
656 Status = NtRaiseHardError(STATUS_SYSTEM_PROCESS_TERMINATED,
657 4,
658 1,
659 ErrorParameters,
660 OptionShutdownSystem,
661 &Response);
662 }
663
664 /* Just terminate us */
665 NtTerminateProcess(NtCurrentProcess(),
666 ExceptionInfo->ExceptionRecord->ExceptionCode);
667 }
668
669 return Result;
670 }
671
672 /* EOF */