This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Macro Definition Documentation
◆ CSR_SERVER_DLL_MAX
◆ CsrAcquireNtSessionLock
| #define CsrAcquireNtSessionLock | ( | ) | RtlEnterCriticalSection(&CsrNtSessionLock); |
◆ CsrAcquireProcessLock
| #define CsrAcquireProcessLock | ( | ) | RtlEnterCriticalSection(&CsrProcessLock); |
◆ CsrAcquireWaitLock
| #define CsrAcquireWaitLock | ( | ) | RtlEnterCriticalSection(&CsrWaitListsLock); |
◆ CsrReleaseNtSessionLock
| #define CsrReleaseNtSessionLock | ( | ) | RtlLeaveCriticalSection(&CsrNtSessionLock); |
◆ CsrReleaseProcessLock
| #define CsrReleaseProcessLock | ( | ) | RtlLeaveCriticalSection(&CsrProcessLock); |
◆ CsrReleaseWaitLock
| #define CsrReleaseWaitLock | ( | ) | RtlLeaveCriticalSection(&CsrWaitListsLock); |
◆ NUMBER_THREAD_HASH_BUCKETS
◆ ProcessStructureListLocked
| #define ProcessStructureListLocked | ( | ) | (CsrProcessLock.OwningThread == NtCurrentTeb()->ClientId.UniqueThread) |
Function Documentation
◆ CSR_API() [1/2]
| CSR_API | ( | CsrSrvClientConnect | ) |
Definition at line 293 of file server.c.
294{
296 PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage->Data.CsrClientConnect;
297 PCSR_SERVER_DLL ServerDll;
299
300 /* Set default reply */
301 *ReplyCode = CsrReplyImmediately;
302
303 /* Validate the ServerID */
305 {
307 }
309 {
311 }
312
313 /* Validate the Message Buffer */
315 &ClientConnect->ConnectionInfo,
316 ClientConnect->ConnectionInfoSize,
318 {
319 /* Fail due to buffer overflow or other invalid buffer */
321 }
322
323 /* Load the Server DLL */
325
326 /* Check if it has a Connect Callback */
328 {
329 /* Call the callback */
331 ClientConnect->ConnectionInfo,
332 &ClientConnect->ConnectionInfoSize);
333 }
334 else
335 {
336 /* Assume success */
338 }
339
340 /* Return status */
342}
BOOLEAN NTAPI CsrValidateMessageBuffer(IN PCSR_API_MESSAGE ApiMessage, IN PVOID *Buffer, IN ULONG ElementCount, IN ULONG ElementSize)
Definition: api.c:1430
Definition: csrmsg.h:84
Definition: csrsrv.h:37
Definition: csrsrv.h:216
◆ CSR_API() [2/2]
| CSR_API | ( | CsrSrvUnusedFunction | ) |
Definition at line 593 of file server.c.
594{
595 UNREFERENCED_PARAMETER(ApiMessage);
596 UNREFERENCED_PARAMETER(ReplyCode);
597
598 /* Deprecated */
600}
◆ CsrAllocateProcess()
| PCSR_PROCESS NTAPI CsrAllocateProcess | ( | VOID | ) |
Definition at line 189 of file procsup.c.
190{
192 ULONG TotalSize;
193
194 /* Calculate the amount of memory this should take */
198
199 /* Allocate a Process */
202
203 /* Handle the Sequence Number and protect against overflow */
206
207 /* Increase the reference count */
209
210 /* Initialize the Thread List */
212
213 /* Return the Process */
215}
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:590
struct _CSR_PROCESS CSR_PROCESS
Definition: nsiface.idl:2307
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:233
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 */
126
127 /* Reference the Thread and Process */
128 CsrLockedReferenceThread(CsrThread);
130
131 /* Set the Parent Process */
133
134 /* Return Thread */
135 return CsrThread;
136}
Definition: csrsrv.h:64
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:233
VOID NTAPI CsrLockedReferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:154
Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().
◆ CsrApiHandleConnectionRequest()
| NTSTATUS NTAPI CsrApiHandleConnectionRequest | ( | IN PCSR_API_MESSAGE | ApiMessage | ) |
Definition at line 144 of file api.c.
145{
149 PCSR_API_CONNECTINFO ConnectInfo = &ApiMessage->ConnectionInfo;
151 REMOTE_PORT_VIEW RemotePortView;
153
154 /* Acquire the Process Lock */
155 CsrAcquireProcessLock();
156
157 /* Lookup the CSR Thread */
159
160 /* Check if we have a thread */
161 if (CsrThread)
162 {
163 /* Get the Process and make sure we have it as well */
166 {
167 /* Reference the Process */
169
170 /* Attach the Shared Section */
173 {
174 /* Allow the connection and return debugging flag */
176 AllowConnection = TRUE;
177 }
178
179 /* Dereference the Process */
181 }
182 }
183
184 /* Release the Process Lock */
185 CsrReleaseProcessLock();
186
187 /* Setup the Port View Structure */
189 RemotePortView.ViewSize = 0;
191
192 /* Save the Process ID */
194
195 /* Accept the Connection */
199 &ApiMessage->Header,
200 AllowConnection,
201 NULL,
202 &RemotePortView);
204 {
206 }
207 else if (AllowConnection)
208 {
210 {
212 ApiMessage->Header.ClientId.UniqueProcess,
213 ApiMessage->Header.ClientId.UniqueThread,
214 RemotePortView.ViewBase,
215 RemotePortView.ViewSize);
216 }
217
218 /* Set some Port Data in the Process */
223
224 /* Complete the connection */
227 {
229 }
230 }
231 else
232 {
234 ApiMessage->Header.ClientId.UniqueProcess,
235 ApiMessage->Header.ClientId.UniqueThread);
236 }
237
238 /* Return status to caller */
240}
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
NTSTATUS NTAPI NtCompleteConnectPort(IN HANDLE PortHandle)
Definition: complete.c:423
struct _REMOTE_PORT_VIEW REMOTE_PORT_VIEW
Definition: csrmsg.h:48
Definition: ntifs.template.h:1637
NTSTATUS NTAPI CsrSrvAttachSharedSection(IN PCSR_PROCESS CsrProcess OPTIONAL, OUT PCSR_API_CONNECTINFO ConnectInfo)
Definition: server.c:482
PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
Definition: thredsup.c:182
VOID NTAPI CsrLockedDereferenceProcess(PCSR_PROCESS CsrProcess)
Definition: procsup.c:159
Referenced by CsrApiRequestThread().
◆ CsrApiPortInitialize()
Definition at line 900 of file api.c.
901{
907 PLIST_ENTRY ListHead, NextEntry;
909
910 /* Calculate how much space we'll need for the Port Name */
912
913 /* Create the buffer for it */
916
917 /* Setup the rest of the empty string */
924 {
928 }
929
930 /* FIXME: Create a Security Descriptor */
931
932 /* Initialize the Attributes */
934 &CsrApiPortName,
935 0,
936 NULL,
938
939 /* Create the Port Object */
941 &ObjectAttributes,
944 16 * PAGE_SIZE);
946 {
947 /* Create the event the Port Thread will use */
949 EVENT_ALL_ACCESS,
950 NULL,
951 SynchronizationEvent,
952 FALSE);
954 {
955 /* Create the Request Thread */
957 NULL,
958 TRUE,
959 0,
960 0,
961 0,
963 (PVOID)hRequestEvent,
964 &hThread,
965 &ClientId);
967 {
968 /* Add this as a static thread to CSRSRV */
970
971 /* Get the Thread List Pointers */
973 NextEntry = ListHead->Flink;
974
975 /* Start looping the list */
976 while (NextEntry != ListHead)
977 {
978 /* Get the Thread */
980
981 /* Start it up */
983
984 /* Is this a Server Thread? */
986 {
987 /* If so, then wait for it to initialize */
990 }
991
992 /* Next thread */
993 NextEntry = NextEntry->Flink;
994 }
995
996 /* We don't need this anymore */
997 NtClose(hRequestEvent);
998 }
999 }
1000 }
1001
1002 /* Return */
1004}
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:512
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
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)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)
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:96
NTSTATUS NTAPI NtCreatePort(OUT PHANDLE PortHandle, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG MaxConnectInfoLength, IN ULONG MaxDataLength, IN ULONG MaxPoolUsage)
Definition: create.c:222
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
Definition: compat.h:824
Definition: csrmsg.h:101
Definition: typedefs.h:120
Definition: umtypes.h:182
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
Referenced by CsrServerInitialization().
◆ CsrApiRequestThread()
Definition at line 336 of file api.c.
337{
339 LARGE_INTEGER TimeOut;
340 PCSR_THREAD CurrentThread, CsrThread;
342 CSR_REPLY_CODE ReplyCode;
343 PCSR_API_MESSAGE ReplyMsg;
344 CSR_API_MESSAGE ReceiveMsg;
346 PHARDERROR_MSG HardErrorMsg;
347 PVOID PortContext;
348 PCSR_SERVER_DLL ServerDll;
349 PCLIENT_DIED_MSG ClientDiedMsg;
350 PDBGKM_MSG DebugMessage;
352 HANDLE ReplyPort;
353
354 /* Setup LPC loop port and message */
355 ReplyMsg = NULL;
356 ReplyPort = CsrApiPort;
357
358 /* Connect to user32 */
360 {
361 /* Set up the timeout for the connect (30 seconds) */
362 TimeOut.QuadPart = -30 * 1000 * 1000 * 10;
363
364 /* Keep trying until we get a response */
365 Teb->Win32ClientInfo[0] = 0;
367 }
368
369 /* Get our thread */
370 CurrentThread = Teb->CsrClientThread;
371
372 /* If we got an event... */
374 {
375 /* Set it, to let stuff waiting on us load */
378
379 /* Increase the Thread Counts */
382 }
383
384 /* Now start the loop */
386 {
387 /* Make sure the real CID is set */
389
390#ifdef CSR_DBG
391 /* Debug check */
393 {
395 Teb->CountOfOwnedCriticalSections);
397 &ReceiveMsg, ReplyMsg);
398 DbgBreakPoint();
399 }
400#endif
401
402 /* Wait for a message to come through */
404 &PortContext,
405 &ReplyMsg->Header,
406 &ReceiveMsg.Header);
407
408 /* Check if we didn't get success */
410 {
411 /* Was it a failure or another success code? */
413 {
414#ifdef CSR_DBG
415 /* Check for specific status cases */
419 {
420 /* Notify the debugger */
423 }
424#endif
425
426 /* We failed big time, so start out fresh */
427 ReplyMsg = NULL;
428 ReplyPort = CsrApiPort;
429 continue;
430 }
431 else
432 {
433 /* A strange "success" code, just try again */
435 continue;
436 }
437 }
438
439 // ASSERT(ReceiveMsg.Header.u1.s1.TotalLength >= sizeof(PORT_MESSAGE));
440 // ASSERT(ReceiveMsg.Header.u1.s1.TotalLength < sizeof(ReceiveMsg));
441
442 /* Use whatever Client ID we got */
444
445 /* Get the Message Type */
446 MessageType = ReceiveMsg.Header.u2.s2.Type;
447
448 /* Handle connection requests */
450 {
451 /* Handle the Connection Request */
452 CsrApiHandleConnectionRequest(&ReceiveMsg);
453
454 ReplyMsg = NULL;
455 ReplyPort = CsrApiPort;
456 continue;
457 }
458
459 /* It's some other kind of request. Get the lock for the lookup */
460 CsrAcquireProcessLock();
461
462 /* Now do the lookup to get the CSR_THREAD */
465
466 /* Did we find a thread? */
467 if (!CsrThread)
468 {
469 /* This wasn't a CSR Thread, release lock */
470 CsrReleaseProcessLock();
471
472 /* If this was an exception, handle it */
474 {
475 ReplyMsg = &ReceiveMsg;
476 ReplyPort = CsrApiPort;
478 }
480 MessageType == LPC_CLIENT_DIED)
481 {
482 /* The Client or Port are gone, loop again */
483 ReplyMsg = NULL;
484 ReplyPort = CsrApiPort;
485 }
487 {
488 /* If it's a hard error, handle this too */
489 HardErrorMsg = (PHARDERROR_MSG)&ReceiveMsg;
490
491 /* Default it to unhandled */
493
494 /* Check if there are free api threads */
495 CsrpCheckRequestThreads();
497 {
498 /* Loop every Server DLL */
500 {
501 /* Get the Server DLL */
503
504 /* Check if it's valid and if it has a Hard Error Callback */
506 {
507 /* Call it */
509
510 /* If it's handled, get out of here */
512 }
513 }
514 }
515
516 /* Increase the thread count */
518
519 /* If the response was 0xFFFFFFFF, we'll ignore it */
521 {
522 ReplyMsg = NULL;
523 ReplyPort = CsrApiPort;
524 }
525 else
526 {
527 ReplyMsg = &ReceiveMsg;
528 ReplyPort = CsrApiPort;
529 }
530 }
532 {
533 /* This is an API Message coming from a non-CSR Thread */
534 ReplyMsg = &ReceiveMsg;
535 ReplyPort = CsrApiPort;
537 }
539 {
540 /* This is an API call, get the Server ID */
542
543 /* Make sure that the ID is within limits, and the Server DLL loaded */
544 ServerDll = NULL;
546 (!(ServerDll = CsrLoadedServerDll[ServerId])))
547 {
548 /* We are beyond the Maximum Server ID */
549#ifdef CSR_DBG
551 ServerId, ServerDll);
553#endif
554 ReplyMsg = NULL;
555 ReplyPort = CsrApiPort;
556 continue;
557 }
558
559 /* Get the API ID, normalized with our Base ID */
561
562 /* Make sure that the ID is within limits, and the entry exists */
564 {
565 /* We are beyond the Maximum API ID, or it doesn't exist */
566#ifdef CSR_DBG
569 &ServerDll->Name);
570#endif
571 ReplyPort = CsrApiPort;
572 ReplyMsg = NULL;
573 continue;
574 }
575
576#ifdef CSR_DBG
578 {
583 ServerDll->NameTable[ApiId],
584 NULL);
585 }
586#endif
587
588 /* Assume success */
590
591 /* Validation complete, start SEH */
592 _SEH2_TRY
593 {
594 /* Make sure we have enough threads */
595 CsrpCheckRequestThreads();
596
597 /* Call the API and get the reply code */
598 ReplyMsg = NULL;
599 ReplyPort = CsrApiPort;
600 ServerDll->DispatchTable[ApiId](&ReceiveMsg, &ReplyCode);
601
602 /* Increase the static thread count */
604 }
606 {
607 ReplyMsg = NULL;
608 ReplyPort = CsrApiPort;
609 }
610 _SEH2_END;
611 }
612 else
613 {
614 /* Some other ignored message type */
615 ReplyMsg = NULL;
616 ReplyPort = CsrApiPort;
617 }
618
619 /* Keep going */
620 continue;
621 }
622
623 /* We have a valid thread, was this an LPC Request? */
625 {
626 /* It's not an API, check if the client died */
628 {
629 /* Get the information and check if it matches our thread */
630 ClientDiedMsg = (PCLIENT_DIED_MSG)&ReceiveMsg;
632 {
633 /* Now we reply to the dying client */
635
636 /* Reference the thread */
637 CsrLockedReferenceThread(CsrThread);
638
639 /* Destroy the thread in the API Message */
641
642 /* Check if the thread was actually ourselves */
644 {
645 /* Kill the process manually here */
647 }
648
649 /* Remove our extra reference */
650 CsrLockedDereferenceThread(CsrThread);
651 }
652
653 /* Release the lock and keep looping */
654 CsrReleaseProcessLock();
655
656 ReplyMsg = NULL;
657 ReplyPort = CsrApiPort;
658 continue;
659 }
660
661 /* Reference the thread and release the lock */
662 CsrLockedReferenceThread(CsrThread);
663 CsrReleaseProcessLock();
664
665 /* Check if this was an exception */
667 {
668 /* Kill the process */
670
671 /* Destroy it from CSR */
673
674 /* Return a Debug Message */
675 DebugMessage = (PDBGKM_MSG)&ReceiveMsg;
677 ReplyMsg = &ReceiveMsg;
678 ReplyPort = CsrApiPort;
679
680 /* Remove our extra reference */
681 CsrDereferenceThread(CsrThread);
682 }
684 {
685 /* If it's a hard error, handle this too */
686 HardErrorMsg = (PHARDERROR_MSG)&ReceiveMsg;
687
688 /* Default it to unhandled */
690
691 /* Check if there are free api threads */
692 CsrpCheckRequestThreads();
694 {
695 /* Loop every Server DLL */
697 {
698 /* Get the Server DLL */
700
701 /* Check if it's valid and if it has a Hard Error Callback */
703 {
704 /* Call it */
705 ServerDll->HardErrorCallback(CsrThread, HardErrorMsg);
706
707 /* If it's handled, get out of here */
709 }
710 }
711 }
712
713 /* Increase the thread count */
715
716 /* If the response was 0xFFFFFFFF, we'll ignore it */
718 {
719 ReplyMsg = NULL;
720 ReplyPort = CsrApiPort;
721 }
722 else
723 {
724 CsrDereferenceThread(CsrThread);
725 ReplyMsg = &ReceiveMsg;
726 ReplyPort = CsrApiPort;
727 }
728 }
729 else
730 {
731 /* Something else */
732 CsrDereferenceThread(CsrThread);
733 ReplyMsg = NULL;
734 }
735
736 /* Keep looping */
737 continue;
738 }
739
740 /* We got an API Request */
741 CsrLockedReferenceThread(CsrThread);
742 CsrReleaseProcessLock();
743
744 /* This is an API call, get the Server ID */
746
747 /* Make sure that the ID is within limits, and the Server DLL loaded */
748 ServerDll = NULL;
750 (!(ServerDll = CsrLoadedServerDll[ServerId])))
751 {
752 /* We are beyond the Maximum Server ID */
753#ifdef CSR_DBG
755 ServerId, ServerDll);
757#endif
758 ReplyPort = CsrApiPort;
759 ReplyMsg = &ReceiveMsg;
761 CsrDereferenceThread(CsrThread);
762 continue;
763 }
764
765 /* Get the API ID, normalized with our Base ID */
767
768 /* Make sure that the ID is within limits, and the entry exists */
770 {
771#ifdef CSR_DBG
772 /* We are beyond the Maximum API ID, or it doesn't exist */
775 &ServerDll->Name);
776#endif
777 ReplyPort = CsrApiPort;
778 ReplyMsg = &ReceiveMsg;
780 CsrDereferenceThread(CsrThread);
781 continue;
782 }
783
784#ifdef CSR_DBG
786 {
791 ServerDll->NameTable[ApiId],
792 CsrThread,
793 CsrThread->Process,
794 CsrProcess);
795 }
796#endif
797
798 /* Assume success */
799 ReplyMsg = &ReceiveMsg;
801
802 /* Now we reply to a particular client */
804
805 /* Check if there's a capture buffer */
807 {
808 /* Capture the arguments */
810 {
811 /* Ignore this message if we failed to get the arguments */
812 CsrDereferenceThread(CsrThread);
813 continue;
814 }
815 }
816
817 /* Validation complete, start SEH */
818 _SEH2_TRY
819 {
820 /* Make sure we have enough threads */
821 CsrpCheckRequestThreads();
822
823 Teb->CsrClientThread = CsrThread;
824
825 /* Call the API, get the reply code and return the result */
826 ReplyCode = CsrReplyImmediately;
828
829 /* Increase the static thread count */
831
832 Teb->CsrClientThread = CurrentThread;
833
835 {
837 {
838 CsrReleaseCapturedArguments(&ReceiveMsg);
839 }
840 ReplyMsg = NULL;
841 ReplyPort = CsrApiPort;
842 CsrDereferenceThread(CsrThread);
843 }
845 {
846 /* Reply to the death message */
847 NTSTATUS Status2;
851
852 /* Reply back to the API port now */
853 ReplyMsg = NULL;
854 ReplyPort = CsrApiPort;
855 CsrDereferenceThread(CsrThread);
856 }
858 {
859 ReplyMsg = NULL;
860 ReplyPort = CsrApiPort;
861 }
862 else
863 {
865 {
866 CsrReleaseCapturedArguments(&ReceiveMsg);
867 }
868 CsrDereferenceThread(CsrThread);
869 }
870 }
872 {
873 ReplyMsg = NULL;
874 ReplyPort = CsrApiPort;
875 }
876 _SEH2_END;
877 }
878
879 /* We're out of the loop for some reason, terminate! */
882}
EXCEPTION_DISPOSITION NTAPI CsrUnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
Definition: server.c:643
NTSTATUS NTAPI CsrDestroyProcess(IN PCLIENT_ID Cid, IN NTSTATUS ExitStatus)
Definition: procsup.c:735
enum _CSR_REPLY_CODE CSR_REPLY_CODE
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:776
struct _DBGKM_MSG * PDBGKM_MSG
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
NTSYSAPI void WINAPI DbgBreakPoint(void)
struct _CLIENT_DIED_MSG * PCLIENT_DIED_MSG
struct _HARDERROR_MSG * PHARDERROR_MSG
NTSTATUS NtTerminateThread(IN HANDLE ThreadHandle OPTIONAL, IN NTSTATUS ExitStatus)
Definition: kill.c:1279
NTSTATUS NTAPI NtTerminateProcess(HANDLE ProcessHandle, LONG ExitStatus)
NTSTATUS NTAPI NtDelayExecution(IN BOOLEAN Alertable, IN PLARGE_INTEGER DelayInterval)
Definition: wait.c:876
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:455
NTSTATUS NTAPI NtReplyPort(IN HANDLE PortHandle, IN PPORT_MESSAGE ReplyMessage)
Definition: reply.c:190
NTSTATUS NTAPI NtReplyWaitReceivePort(IN HANDLE PortHandle, OUT PVOID *PortContext OPTIONAL, IN PPORT_MESSAGE ReplyMessage OPTIONAL, OUT PPORT_MESSAGE ReceiveMessage)
Definition: reply.c:743
Definition: lpctypes.h:268
Definition: dbgktypes.h:207
Definition: extypes.h:665
Definition: compat.h:836
VOID NTAPI CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:1337
NTSTATUS NTAPI CsrApiHandleConnectionRequest(IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:144
BOOLEAN NTAPI CsrCaptureArguments(IN PCSR_THREAD CsrThread, IN PCSR_API_MESSAGE ApiMessage)
Definition: api.c:1123
VOID NTAPI CsrLockedReferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:154
VOID NTAPI CsrLockedDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:467
Definition: typedefs.h:103
#define NtCurrentThread()
Referenced by CsrApiPortInitialize(), and CsrpCheckRequestThreads().
◆ CsrCaptureArguments()
| BOOLEAN NTAPI CsrCaptureArguments | ( | IN PCSR_THREAD | CsrThread, |
| IN PCSR_API_MESSAGE | ApiMessage | ||
| ) |
Definition at line 1123 of file api.c.
1125{
1128 ULONG_PTR EndOfClientBuffer;
1129 SIZE_T SizeOfBufferThroughOffsetsArray;
1130 SIZE_T BufferDistance;
1132 ULONG PointerCount;
1133 PULONG_PTR OffsetPointer;
1134 ULONG_PTR CurrentOffset;
1135
1136 /* Get the buffer we got from whoever called NTDLL */
1137 ClientCaptureBuffer = ApiMessage->CsrCaptureData;
1138
1139 /* Use SEH to validate and capture the client buffer */
1140 _SEH2_TRY
1141 {
1142 /* Check whether at least the buffer's header is inside our mapped section */
1145 >= CsrProcess->ClientViewBounds) )
1146 {
1147#ifdef CSR_DBG
1150#endif
1151 /* Return failure */
1152 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1154 }
1155
1156 /* Capture the buffer length */
1158
1159 /*
1160 * Now check if the remaining of the buffer is inside our mapped section.
1161 * Take also care for any possible wrap-around of the buffer end-address.
1162 */
1165 (EndOfClientBuffer >= CsrProcess->ClientViewBounds) )
1166 {
1167#ifdef CSR_DBG
1170#endif
1171 /* Return failure */
1172 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1174 }
1175
1176 /* Capture the pointer count */
1178
1179 /*
1180 * Check whether the total buffer size and the pointer count are consistent
1181 * -- the array of offsets must be contained inside the buffer.
1182 */
1183 SizeOfBufferThroughOffsetsArray =
1187 (SizeOfBufferThroughOffsetsArray > Length) )
1188 {
1189#ifdef CSR_DBG
1192#endif
1193 /* Return failure */
1194 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1196 }
1197 }
1199 {
1200#ifdef CSR_DBG
1203#endif
1204 /* Return failure */
1205 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1207 }
1208 _SEH2_END;
1209
1210 /* We validated the client buffer, now allocate the server buffer */
1212 if (!ServerCaptureBuffer)
1213 {
1214 /* We're out of memory */
1215 ApiMessage->Status = STATUS_NO_MEMORY;
1217 }
1218
1219 /*
1220 * Copy the client's buffer and ensure we use the correct buffer length
1221 * and pointer count we captured and used for validation earlier on.
1222 */
1223 _SEH2_TRY
1224 {
1226 }
1228 {
1229#ifdef CSR_DBG
1232#endif
1233 /* Failure, free the buffer and return */
1235 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1237 }
1238 _SEH2_END;
1239
1241 ServerCaptureBuffer->PointerCount = PointerCount;
1242
1243 /* Calculate the difference between our buffer and the client's */
1245
1246 /*
1247 * All the pointer offsets correspond to pointers that point
1248 * to the server data buffer instead of the client one.
1249 */
1250 // PointerCount = ServerCaptureBuffer->PointerCount;
1251 OffsetPointer = ServerCaptureBuffer->PointerOffsetsArray;
1252 while (PointerCount--)
1253 {
1254 CurrentOffset = *OffsetPointer;
1255
1256 if (CurrentOffset != 0)
1257 {
1258 /*
1259 * Check whether the offset is pointer-aligned and whether
1260 * it points inside CSR_API_MESSAGE::Data.ApiMessageData.
1261 */
1265 {
1266#ifdef CSR_DBG
1269#endif
1270 /* Invalid pointer, fail */
1271 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1272 break;
1273 }
1274
1275 /* Get the pointer corresponding to the offset */
1276 CurrentOffset += (ULONG_PTR)ApiMessage;
1277
1278 /* Validate the bounds of the current pointed pointer */
1280 SizeOfBufferThroughOffsetsArray)) &&
1282 {
1283 /* Modify the pointed pointer to take into account its new position */
1284 *(PULONG_PTR)CurrentOffset += BufferDistance;
1285 }
1286 else
1287 {
1288#ifdef CSR_DBG
1291#endif
1292 /* Invalid pointer, fail */
1293 ApiMessage->Status = STATUS_INVALID_PARAMETER;
1294 break;
1295 }
1296 }
1297
1298 ++OffsetPointer;
1299 }
1300
1301 /* Check if we got success */
1303 {
1304 /* Failure, free the buffer and return */
1307 }
1308 else
1309 {
1310 /* Success, save the previous buffer and use the server capture buffer */
1311 ServerCaptureBuffer->PreviousCaptureBuffer = ClientCaptureBuffer;
1312 ApiMessage->CsrCaptureData = ServerCaptureBuffer;
1313 }
1314
1315 /* Success */
1317}
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:608
Definition: sort_test.cpp:77
Definition: csrmsg.h:91
ULONG_PTR PointerOffsetsArray[ANYSIZE_ARRAY]
Definition: csrmsg.h:96
struct _CSR_CAPTURE_BUFFER * PreviousCaptureBuffer
Definition: csrmsg.h:93
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 847 of file init.c.
848{
850 PSID SystemSid;
852 PSECURITY_DESCRIPTOR SystemSd;
855
856 /* Initialize the System SID */
859 0, 0, 0, 0, 0, 0, 0,
860 &SystemSid);
861
862 /* Get the length of the SID */
864
865 /* Allocate a buffer for the Security Descriptor, with SID and DACL */
867
868 /* Set the pointer to the DACL */
870
871 /* Now create the SD itself */
874
875 /* Create the DACL for it */
877
878 /* Create the ACE */
881
882 /* Clear the DACL in the SD */
885
886Quit:
888 {
890 SystemSd = NULL;
891 }
892
893 /* Free the SID and return*/
894 RtlFreeSid(SystemSid);
895 *LocalSystemSd = SystemSd;
897}
NTSYSAPI NTSTATUS WINAPI RtlAddAccessAllowedAce(PACL, DWORD, DWORD, PSID)
NTSYSAPI NTSTATUS WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR, BOOLEAN, PACL, BOOLEAN)
struct _ACL ACL
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1593
NTSYSAPI NTSTATUS NTAPI RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision)
NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor(_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Revision)
NTSYSAPI PVOID NTAPI RtlFreeSid(_In_ _Post_invalid_ PSID Sid)
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
Definition: ms-dtyp.idl:215
Definition: ms-dtyp.idl:293
Definition: ms-dtyp.idl:301
Definition: ms-dtyp.idl:194
Definition: ms-dtyp.idl:198
Referenced by CsrSbApiPortInitialize().
◆ CsrCreateObjectDirectory()
◆ CsrCreateSessionObjectDirectory()
Definition at line 424 of file init.c.
425{
426 WCHAR SessionBuffer[512], BnoBuffer[512];
427 UNICODE_STRING SessionString, BnoString;
429 HANDLE BnoHandle;
430 SECURITY_DESCRIPTOR DosDevicesSd;
432
433 /* Generate the Session BNOLINKS Directory name */
435 RtlInitUnicodeString(&SessionString, SessionBuffer);
436
437 /* Create it */
439 &SessionString,
441 NULL,
442 NULL);
444 DIRECTORY_ALL_ACCESS,
445 &ObjectAttributes);
447 {
451 }
452
453 /* Now add the Session ID */
455 RtlInitUnicodeString(&SessionString, SessionBuffer);
456
457 /* Check if this is the first Session */
458 if (Session)
459 {
460 /* Not the first, so the name will be slighly more complex */
462 RtlInitUnicodeString(&BnoString, BnoBuffer);
463 }
464 else
465 {
466 /* Use the direct name */
468 }
469
470 /* Create the symlink */
472 &SessionString,
474 BNOLinksDirectory,
475 NULL);
478 &ObjectAttributes,
479 &BnoString);
481 {
485 }
486
487 /* Create the \DosDevices Security Descriptor */
490
491 /* Now create a directory for this session */
493 RtlInitUnicodeString(&SessionString, SessionBuffer);
494
495 /* Create the directory */
497 &SessionString,
499 0,
500 &DosDevicesSd);
502 DIRECTORY_ALL_ACCESS,
503 &ObjectAttributes);
505 {
508 FreeDosDevicesProtection(&DosDevicesSd);
510 }
511
512 /* Next, create a directory for this session's DOS Devices */
515 &SessionString,
516 OBJ_CASE_INSENSITIVE,
518 &DosDevicesSd);
520 DIRECTORY_ALL_ACCESS,
521 &ObjectAttributes);
523 {
526 }
527
528 /* Release the Security Descriptor */
529 FreeDosDevicesProtection(&DosDevicesSd);
530
531 /* Return */
533}
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS NTAPI NtCreateDirectoryObject(OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: obdir.c:765
NTSTATUS NTAPI NtCreateSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN PUNICODE_STRING LinkTarget)
Definition: oblink.c:676
Definition: env_spec_w32.h:368
VOID NTAPI FreeDosDevicesProtection(IN PSECURITY_DESCRIPTOR DosDevicesSd)
Definition: init.c:392
NTSTATUS NTAPI GetDosDevicesProtection(OUT PSECURITY_DESCRIPTOR DosDevicesSd)
Definition: init.c:209
Referenced by CsrParseServerCommandLine().
◆ CsrDeallocateProcess()
| VOID NTAPI CsrDeallocateProcess | ( | IN PCSR_PROCESS | CsrProcess | ) |
Definition at line 297 of file procsup.c.
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);
350}
Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), CsrSbCreateSession(), and CsrThreadRefcountZero().
◆ CsrDereferenceNtSession()
Definition at line 156 of file session.c.
158{
159 /* Acquire the lock */
160 CsrAcquireNtSessionLock();
161
162 /* Sanity checks */
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 */
174 CsrReleaseNtSessionLock();
175
176 /* Tell SM that we're done here */
178
179 /* Free the Session Object */
181 }
182 else
183 {
184 /* Release the lock, the Session is still active */
185 CsrReleaseNtSessionLock();
186 }
187}
NTSTATUS NTAPI SmSessionComplete(_In_ HANDLE SmApiPort, _In_ ULONG SessionId, _In_ NTSTATUS SessionStatus)
This function is called by an environment subsystem server to tell the SM it has terminated the sessi...
Definition: smclient.c:220
Referenced by CsrProcessRefcountZero().
◆ CsrInitializeNtSessionList()
Definition at line 53 of file session.c.
54{
55 /* Initialize the Session List */
57
58 /* Initialize the Session Lock */
60}
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
Referenced by CsrServerInitialization().
◆ CsrInitializeProcessStructure()
Definition at line 255 of file procsup.c.
256{
259
260 /* Initialize the Lock */
263
264 /* Set up the Root Process */
267
268 /* Set up the minimal information for it */
272
273 /* Initialize the Thread Hash List */
275
276 /* Initialize the Wait Lock */
278}
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
Referenced by CsrServerInitialization().
◆ CsrInsertProcess()
| VOID NTAPI CsrInsertProcess | ( | IN PCSR_PROCESS ParentProcess | OPTIONAL, |
| IN PCSR_PROCESS | CsrProcess | ||
| ) |
Definition at line 366 of file procsup.c.
368{
369 PCSR_SERVER_DLL ServerDll;
372
373 /* Insert it into the Root List */
375
376 /* Notify the Server DLLs */
378 {
379 /* Get the current Server DLL */
381
382 /* Make sure it's valid and that it has callback */
384 {
386 }
387 }
388}
PCSR_NEWPROCESS_CALLBACK NewProcessCallback
Definition: csrsrv.h:239
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{
303 // ASSERT(ProcessStructureListLocked());
304
305 /* Make sure the thread isn't already dead by the time we got this */
307 ThreadIsTerminated,
308 &ThreadInfo,
310 NULL);
313
314 /* Insert it into the Regular List */
316
317 /* Increase Thread Count */
318 Process->ThreadCount++;
319
320 /* Hash the Thread */
322
323 /* Insert it there too */
326}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
struct _ThreadInfo ThreadInfo
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2624
Definition: mmdrv.h:111
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
Referenced by CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), and CsrSbCreateSession().
◆ CsrLoadServerDll()
| NTSTATUS NTAPI CsrLoadServerDll | ( | IN PCHAR | DllString, |
| IN PCHAR EntryPoint | OPTIONAL, | ||
| IN ULONG | ServerId | ||
| ) |
Definition at line 126 of file server.c.
129{
131 ANSI_STRING DllName;
132 UNICODE_STRING TempString, ErrorString;
136 PCSR_SERVER_DLL ServerDll;
137 STRING EntryPointString;
138 PCSR_SERVER_DLL_INIT_CALLBACK ServerDllInitProcedure;
140
141 /* Check if it's beyond the maximum we support */
143
144 /* Check if it's already been loaded */
146
147 /* Convert the name to Unicode */
149 RtlInitAnsiString(&DllName, DllString);
152
153 /* If we are loading ourselves, don't actually load us */
155 {
156 /* Load the DLL */
159 {
160 /* Setup error parameters */
164
165 /* Send a hard error */
167 2,
168 3,
169 Parameters,
170 OptionOk,
171 &Response);
172 }
173
174 /* Get rid of the string */
175 RtlFreeUnicodeString(&TempString);
177 }
178
179 /* Allocate a CSR DLL Object */
182 if (!ServerDll)
183 {
186 }
187
188 /* Set up the Object */
190 ServerDll->SizeOfProcessData = 0;
191 ServerDll->SharedSection = CsrSrvSharedSectionHeap; // Send to the server dll our shared heap pointer.
196 {
198 }
199 ServerDll->ServerId = ServerId;
200 ServerDll->ServerHandle = hServerDll;
201
202 /* Now get the entrypoint */
203 if (hServerDll)
204 {
205 /* Initialize a string for the entrypoint, or use the default */
206 RtlInitAnsiString(&EntryPointString,
207 EntryPoint ? EntryPoint : "ServerDllInitialization");
208
209 /* Get a pointer to it */
211 &EntryPointString,
212 0,
213 (PVOID)&ServerDllInitProcedure);
214 }
215 else
216 {
217 /* No handle, so we are loading ourselves */
218#ifdef CSR_DBG
220#endif
221 ServerDllInitProcedure = CsrServerDllInitialization;
223 }
224
225 /* Check if we got the pointer, and call it */
227 {
228 /* Call the Server DLL entrypoint */
229 _SEH2_TRY
230 {
231 Status = ServerDllInitProcedure(ServerDll);
232 }
234 {
236#ifdef CSR_DBG
238 Status, &DllName, &EntryPointString);
239#endif
240 }
241 _SEH2_END;
242
244 {
245 /*
246 * Add this Server's Per-Process Data Size to the total that each
247 * process will need.
248 */
250
251 /* Save the pointer in our list */
253
254 /* Does it use our generic heap? */
256 {
257 /* No, save the pointer to its shared section in our list */
259 }
260 }
261 }
262
264 {
265 /* Server Init failed, unload it */
267
268 /* Delete the Object */
270 }
271
272 /* Return to caller */
274}
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
struct _CSR_SERVER_DLL CSR_SERVER_DLL
NTSTATUS(NTAPI * PCSR_SERVER_DLL_INIT_CALLBACK)(IN PCSR_SERVER_DLL LoadedServerDll)
Definition: csrsrv.h:253
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:551
NTSTATUS NTAPI DECLSPEC_HOTPATCH LdrLoadDll(_In_opt_ PWSTR SearchPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_ PVOID *BaseAddress)
Definition: ldrapi.c:312
NTSTATUS NTAPI LdrGetProcedureAddress(_In_ PVOID BaseAddress, _In_opt_ _When_(Ordinal==0, _Notnull_) PANSI_STRING Name, _In_opt_ _When_(Name==NULL, _In_range_(>, 0)) ULONG Ordinal, _Out_ PVOID *ProcedureAddress)
Definition: ldrapi.c:829
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
Definition: ncftp.h:89
Definition: env_spec_w32.h:375
NTSTATUS NTAPI CsrServerDllInitialization(IN PCSR_SERVER_DLL LoadedServerDll)
EXCEPTION_DISPOSITION NTAPI CsrUnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
Definition: server.c:643
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
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{
186 PLIST_ENTRY ListHead, NextEntry;
187 PCSR_THREAD FoundThread;
188 // ASSERT(ProcessStructureListLocked());
189
191
192 /* Hash the Thread */
194
195 /* Set the list pointers */
197 NextEntry = ListHead->Flink;
198
199 /* Star the loop */
200 while (NextEntry != ListHead)
201 {
202 /* Get the thread */
204
205 /* Move to the next entry */
206 NextEntry = NextEntry->Flink;
207
208 /* Compare the CID */
209 // if (*(PULONGLONG)&FoundThread->ClientId == *(PULONGLONG)ClientId)
212 {
213 /* Match found, return the process */
215
216 /* Return thread too */
217 return FoundThread;
218 }
219 }
220
221 /* Nothing found */
223}
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;
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 */
266
267 /* Check for TID Match */
269
270 /* Move to the next entry */
271 NextEntry = NextEntry->Flink;
272 }
273
274 /* Return what we found */
275 return FoundThread;
276}
Referenced by CsrConnectToUser().
◆ CsrLockedDereferenceProcess()
| VOID NTAPI CsrLockedDereferenceProcess | ( | PCSR_PROCESS | CsrProcess | ) |
Definition at line 159 of file procsup.c.
160{
162
163 /* Decrease reference count */
167 {
168 /* Call the generic cleanup code */
171 /* Acquire the lock again, it was released in CsrProcessRefcountZero */
172 CsrAcquireProcessLock();
173 }
174}
VOID NTAPI CsrProcessRefcountZero(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:119
Referenced by CsrApiHandleConnectionRequest(), CsrRemoveThread(), CsrShutdownProcesses(), and CsrUnlockProcess().
◆ CsrLockedDereferenceThread()
| VOID NTAPI CsrLockedDereferenceThread | ( | IN PCSR_THREAD | CsrThread | ) |
Definition at line 467 of file thredsup.c.
468{
470
471 /* Decrease reference count */
472 LockCount = --CsrThread->ReferenceCount;
475 {
476 /* Call the generic cleanup code */
477 CsrThreadRefcountZero(CsrThread);
478 /* Acquire the lock again, it was released by CsrThreadRefcountZero */
479 CsrAcquireProcessLock();
480 }
481}
VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:424
Referenced by CsrApiRequestThread(), CsrDestroyProcess(), CsrDestroyThread(), and CsrUnlockThread().
◆ CsrLockedReferenceProcess()
| VOID NTAPI CsrLockedReferenceProcess | ( | IN PCSR_PROCESS | CsrProcess | ) |
Definition at line 233 of file procsup.c.
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 */
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 */
173 }
174
175 /* The wait failed */
177}
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 */
121 CsrAcquireNtSessionLock();
122
123 /* Sanity checks */
125 ASSERT(Session->SessionId != 0);
126 ASSERT(Session->ReferenceCount != 0);
127
128 /* Increase the reference count */
129 Session->ReferenceCount++;
130
131 /* Release the lock */
132 CsrReleaseNtSessionLock();
133}
Referenced by CsrCreateProcess().
◆ CsrReleaseCapturedArguments()
| VOID NTAPI CsrReleaseCapturedArguments | ( | IN PCSR_API_MESSAGE | ApiMessage | ) |
Definition at line 1337 of file api.c.
1338{
1339 PCSR_CAPTURE_BUFFER ServerCaptureBuffer, ClientCaptureBuffer;
1340 SIZE_T BufferDistance;
1341 ULONG PointerCount;
1342 PULONG_PTR OffsetPointer;
1343 ULONG_PTR CurrentOffset;
1344
1345 /* Get the server capture buffer */
1346 ServerCaptureBuffer = ApiMessage->CsrCaptureData;
1347
1348 /* Do not continue if there is no captured buffer */
1349 if (!ServerCaptureBuffer) return;
1350
1351 /* If there is one, get the corresponding client capture buffer */
1352 ClientCaptureBuffer = ServerCaptureBuffer->PreviousCaptureBuffer;
1353
1354 /* Free the previous one and use again the client capture buffer */
1356 ApiMessage->CsrCaptureData = ClientCaptureBuffer;
1357
1358 /* Calculate the difference between our buffer and the client's */
1360
1361 /*
1362 * All the pointer offsets correspond to pointers that point
1363 * to the client data buffer instead of the server one (reverse
1364 * the logic of CsrCaptureArguments()).
1365 */
1366 PointerCount = ServerCaptureBuffer->PointerCount;
1367 OffsetPointer = ServerCaptureBuffer->PointerOffsetsArray;
1368 while (PointerCount--)
1369 {
1370 CurrentOffset = *OffsetPointer;
1371
1372 if (CurrentOffset != 0)
1373 {
1374 /* Get the pointer corresponding to the offset */
1375 CurrentOffset += (ULONG_PTR)ApiMessage;
1376
1377 /* Modify the pointed pointer to take into account its new position */
1378 *(PULONG_PTR)CurrentOffset -= BufferDistance;
1379 }
1380
1381 ++OffsetPointer;
1382 }
1383
1384 /* Copy the data back into the client buffer */
1385 _SEH2_TRY
1386 {
1388 }
1390 {
1391#ifdef CSR_DBG
1394#endif
1395 /* Return failure */
1396 ApiMessage->Status = _SEH2_GetExceptionCode();
1397 }
1398 _SEH2_END;
1399
1400 /* Free our allocated buffer */
1402}
Referenced by CsrApiRequestThread(), and CsrNotifyWaitBlock().
◆ CsrRemoveProcess()
| VOID NTAPI CsrRemoveProcess | ( | IN PCSR_PROCESS | CsrProcess | ) |
Definition at line 320 of file procsup.c.
321{
322 PCSR_SERVER_DLL ServerDll;
325
326 /* Remove us from the Process List */
328
329 /* Release the lock */
330 CsrReleaseProcessLock();
331
332 /* Loop every Server DLL */
334 {
335 /* Get the Server DLL */
337
338 /* Check if it's valid and if it has a Disconnect Callback */
340 {
341 /* Call it */
343 }
344 }
345}
PCSR_DISCONNECT_CALLBACK DisconnectCallback
Definition: csrsrv.h:236
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 */
442
443 /* Accept the connection */
445 NULL,
446 &Message->h,
447 TRUE,
448 NULL,
449 &RemotePortView);
451 {
454 }
455
456 /* Complete the Connection */
459 {
461 }
462
463 /* Return status */
465}
Referenced by CsrSbApiRequestThread().
◆ CsrSbApiPortInitialize()
Definition at line 915 of file init.c.
916{
918 PSECURITY_DESCRIPTOR PortSd;
921 HANDLE hRequestThread;
923
924 /* Calculate how much space we'll need for the Port Name */
926
927 /* Create the buffer for it */
930
931 /* Setup the rest of the empty string */
934
935 /* Now append the full port name */
939 if (CsrDebug & 2) DPRINT1("CSRSS: Creating %wZ port and associated thread\n", &CsrSbApiPortName);
940
941 /* Create Security Descriptor for this Port */
944
945 /* Initialize the Attributes */
947 &CsrSbApiPortName,
948 0,
949 NULL,
950 PortSd);
951
952 /* Create the Port Object */
954 &ObjectAttributes,
959
961 {
962 /* Create the Thread to handle the API Requests */
964 NULL,
965 TRUE,
966 0,
967 0,
968 0,
970 NULL,
971 &hRequestThread,
972 &ClientId);
974 {
975 /* Add it as a Static Server Thread */
977 &ClientId,
978 0);
979
980 /* Activate it */
982 }
983 }
984
986}
Definition: smmsg.h:231
Definition: smmsg.h:222
NTSTATUS NTAPI CsrCreateLocalSystemSD(OUT PSECURITY_DESCRIPTOR *LocalSystemSd)
Definition: init.c:847
Referenced by CsrServerInitialization().
◆ CsrSbApiRequestThread()
Definition at line 484 of file session.c.
485{
487 SB_API_MSG ReceiveMsg;
489 PVOID PortContext;
490 ULONG MessageType;
491
492 /* Start the loop */
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 */
503 {
504 /* If we only got a warning, keep going */
506
507 /* We failed big time, so start out fresh */
508 ReplyMsg = NULL;
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 */
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 */
529 {
530 /* Close the handle if we have one */
532
533 /* Client died, start over */
534 ReplyMsg = NULL;
535 continue;
536 }
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 */
549 {
552 }
553
554 /* Reuse the message */
555 ReplyMsg = &ReceiveMsg;
556
557 /* Make sure that the message is supported */
559 {
560 /* Call the API */
562 {
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}
NTSTATUS NTAPI CsrSbApiHandleConnectionRequest(IN PSB_API_MSG Message)
Definition: session.c:434
PSB_API_ROUTINE CsrServerSbApiDispatch[SbpMaxApiNumber - SbpCreateSession]
Definition: session.c:21
PCHAR CsrServerSbApiName[SbpMaxApiNumber - SbpCreateSession]
Definition: session.c:29
Referenced by CsrSbApiPortInitialize().
◆ CsrSbCreateProcess()
| BOOLEAN NTAPI CsrSbCreateProcess | ( | IN PSB_API_MSG | ApiMessage | ) |
◆ CsrSbCreateSession()
| BOOLEAN NTAPI CsrSbCreateSession | ( | IN PSB_API_MSG | ApiMessage | ) |
Definition at line 208 of file session.c.
209{
213 PCSR_THREAD CsrThread;
214 PCSR_SERVER_DLL ServerDll;
215 PVOID ProcessData;
217 KERNEL_USER_TIMES KernelTimes;
219
220 /* Save the Process and Thread Handles */
223
224 /* Lock the Processes */
225 CsrAcquireProcessLock();
226
227 /* Allocate a new process */
230 {
231 /* Fail */
232 ApiMessage->ReturnValue = STATUS_NO_MEMORY;
233 CsrReleaseProcessLock();
235 }
236
237 /* Set the Exception Port for us */
239 ProcessExceptionPort,
240 &CsrApiPort,
242
243 /* Check for success */
245 {
246 /* Fail the request */
248 CsrReleaseProcessLock();
249
250 /* Strange as it seems, NTSTATUSes are actually returned */
252 }
253
254 /* Get the Create Time */
256 ThreadTimes,
257 &KernelTimes,
258 sizeof(KernelTimes),
259 NULL);
260
261 /* Check for success */
263 {
264 /* Fail the request */
266 CsrReleaseProcessLock();
267
268 /* Strange as it seems, NTSTATUSes are actually returned */
270 }
271
272 /* Allocate a new Thread */
274 if (!CsrThread)
275 {
276 /* Fail the request */
278 CsrReleaseProcessLock();
279
280 ApiMessage->ReturnValue = STATUS_NO_MEMORY;
282 }
283
284 /* Setup the Thread Object */
289 CsrThread->Flags = 0;
290
291 /* Insert it into the Process List */
294 {
295 /* Bail out */
297 CsrDeallocateThread(CsrThread);
298 CsrReleaseProcessLock();
299
300 /* Strange as it seems, NTSTATUSes are actually returned */
302 }
303
304 /* Setup Process Data */
308
309 /* Set the Process Priority */
311
312 /* Get the first data location */
314
315 /* Loop every DLL */
317 {
318 /* Get the current Server */
320
321 /* Check if the DLL is loaded and has Process Data */
323 {
324 /* Write the pointer to the data */
326
327 /* Move to the next data location */
329 ServerDll->SizeOfProcessData);
330 }
331 else
332 {
333 /* Nothing for this Process */
335 }
336 }
337
338 /* Insert the Process */
340
341 /* Activate the Thread */
343
344 /* Release lock and return */
345 CsrReleaseProcessLock();
347}
VOID NTAPI CsrSetBackgroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1107
MMRESULT CreateSession(DeviceType device_type, UINT device_id, SessionInfo **session_info)
Definition: session.c:63
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1105
Definition: winternl.h:1059
Definition: smmsg.h:159
NTSTATUS NTAPI CsrInsertThread(IN PCSR_PROCESS Process, IN PCSR_THREAD Thread)
Definition: thredsup.c:297
VOID NTAPI CsrInsertProcess(IN PCSR_PROCESS ParentProcess OPTIONAL, IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:366
VOID NTAPI CsrDeallocateProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:297
VOID NTAPI CsrDeallocateThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:345
PCSR_THREAD NTAPI CsrAllocateThread(IN PCSR_PROCESS CsrProcess)
Definition: thredsup.c:119
PCSR_NT_SESSION NTAPI CsrAllocateNtSession(IN ULONG SessionId)
Definition: session.c:77
◆ 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;
370}
◆ CsrSbTerminateSession()
| BOOLEAN NTAPI CsrSbTerminateSession | ( | IN PSB_API_MSG | ApiMessage | ) |
◆ CsrServerDllInitialization()
| NTSTATUS NTAPI CsrServerDllInitialization | ( | IN PCSR_SERVER_DLL | LoadedServerDll | ) |
Referenced by CsrLoadServerDll().
◆ CsrSetDirectorySecurity()
Definition at line 186 of file init.c.
Referenced by CsrParseServerCommandLine().
◆ CsrSrvAttachSharedSection()
| NTSTATUS NTAPI CsrSrvAttachSharedSection | ( | IN PCSR_PROCESS CsrProcess | OPTIONAL, |
| OUT PCSR_API_CONNECTINFO | ConnectInfo | ||
| ) |
Definition at line 482 of file server.c.
484{
487
488 /* Check if we have a process */
490 {
491 /* Map the section into this process */
493 CsrProcess->ProcessHandle,
494 &CsrSrvSharedSectionBase,
495 0,
496 0,
497 NULL,
498 &ViewSize,
499 ViewUnmap,
500 SEC_NO_CHANGE,
501 PAGE_EXECUTE_READ);
503 }
504
505 /* Write the values in the Connection Info structure */
506 ConnectInfo->SharedSectionBase = CsrSrvSharedSectionBase;
507 ConnectInfo->SharedSectionHeap = CsrSrvSharedSectionHeap;
508 ConnectInfo->SharedStaticServerData = CsrSrvSharedStaticServerData;
509
510 /* Return success */
512}
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:3622
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
Referenced by CsrApiHandleConnectionRequest().
◆ CsrSrvCreateSharedSection()
Definition at line 361 of file server.c.
362{
366 LARGE_INTEGER SectionSize;
369
370 /* If there's no parameter, fail */
372
373 /* Find the first comma, and null terminate */
374 while (*SizeValue)
375 {
376 if (*SizeValue == ',')
377 {
378 *SizeValue++ = ANSI_NULL;
379 break;
380 }
381 else
382 {
383 SizeValue++;
384 }
385 }
386
387 /* Make sure it's valid */
389
390 /* Convert it to an integer */
393
394 /* Multiply by 1024 entries and round to page size */
396
397 /* Create the Secion */
399 SectionSize.HighPart = 0;
401 SECTION_ALL_ACCESS,
402 NULL,
403 &SectionSize,
406 NULL);
408
409 /* Map the section */
411 NtCurrentProcess(),
412 &CsrSrvSharedSectionBase,
413 0,
414 0,
415 NULL,
416 &ViewSize,
417 ViewUnmap,
418 MEM_TOP_DOWN,
419 PAGE_EXECUTE_READWRITE);
421 {
422 /* Fail */
425 }
426
427 /* FIXME: Write the value to registry */
428
429 /* The Heap is the same place as the Base */
431
432 /* Create the heap */
436 PAGE_SIZE,
437 0,
438 0)))
439 {
440 /* Failure, unmap section and return */
444 }
445
446 /* Now allocate space from the heap for the Shared Data */
448 HEAP_ZERO_MEMORY,
451
452 /* Write the values to the PEB */
456
457 /* Return */
459}
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3848
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:3441
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)
NTSYSAPI NTSTATUS NTAPI RtlCharToInteger(PCSZ String, ULONG Base, PULONG Value)
Definition: unicode.c:261
#define ANSI_NULL
Definition: btrfs_drv.h:1907
Referenced by CsrParseServerCommandLine().
◆ ProtectHandle()
Definition at line 39 of file thredsup.c.
40{
42 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
43
44 /* Query current state */
46 ObjectHandleFlagInformation,
47 &HandleInfo,
48 sizeof(HandleInfo),
49 NULL);
51 {
52 /* Enable protect from close */
55 ObjectHandleFlagInformation,
56 &HandleInfo,
57 sizeof(HandleInfo));
59 }
60
61 /* We failed to or set the state */
63}
NTSTATUS NtQueryObject(IN HANDLE Handle, IN OBJECT_INFO_CLASS ObjectInformationClass, OUT PVOID ObjectInformation, IN ULONG ObjectInformationLength, OUT PULONG ReturnLength)
NTSTATUS NTAPI NtSetInformationObject(IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, IN PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1824
BOOLEAN ProtectFromClose
Definition: obtypes.h:273
Referenced by CsrAddStaticServerThread(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrExecServerThread(), and CsrSbCreateSession().
◆ UnProtectHandle()
Definition at line 78 of file thredsup.c.
79{
81 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
82
83 /* Query current state */
85 ObjectHandleFlagInformation,
86 &HandleInfo,
87 sizeof(HandleInfo),
88 NULL);
90 {
91 /* Disable protect from close */
94 ObjectHandleFlagInformation,
95 &HandleInfo,
96 sizeof(HandleInfo));
98 }
99
100 /* We failed to or set the state */
102}
Referenced by CsrThreadRefcountZero().
Variable Documentation
◆ CsrApiPort
◆ CsrApiPortName
|
extern |
Definition at line 22 of file api.c.
Referenced by CsrApiPortInitialize().
◆ CsrDebug
|
extern |
Definition at line 23 of file init.c.
Referenced by CsrApiHandleConnectionRequest(), CsrApiPortInitialize(), CsrApiRequestThread(), CsrCallServerFromServer(), CsrParseServerCommandLine(), and CsrSbApiPortInitialize().
◆ CsrDirectoryName
|
extern |
Definition at line 27 of file init.c.
Referenced by CsrApiPortInitialize(), CsrParseServerCommandLine(), and CsrSbApiPortInitialize().
◆ CsrHeap
|
extern |
Definition at line 25 of file init.c.
Referenced by CsrAllocateNtSession(), CsrAllocateProcess(), CsrAllocateThread(), CsrApiPortInitialize(), CsrCaptureArguments(), CsrCreateLocalSystemSD(), CsrCreateWait(), CsrDeallocateProcess(), CsrDeallocateThread(), CsrDereferenceNtSession(), CsrDereferenceWait(), CsrGetProcessLuid(), CsrInitCsrRootProcess(), CsrInitializeWait(), CsrLoadServerDll(), CsrNotifyWaitBlock(), CsrReleaseCapturedArguments(), CsrSbApiPortInitialize(), CsrServerInitialization(), CsrSetProcessSecurity(), FreeDosDevicesProtection(), and GetDosDevicesProtection().
◆ CsrInitializationEvent
|
extern |
◆ CsrLoadedServerDll
|
extern |
Definition at line 20 of file server.c.
Referenced by CSR_API(), CsrApiRequestThread(), CsrCallServerFromServer(), CsrCreateProcess(), CsrInitCsrRootProcess(), CsrInsertProcess(), CsrLoadServerDll(), CsrRemoveProcess(), CsrSbCreateSession(), and CsrShutdownProcesses().
◆ CsrMaxApiRequestThreads
|
extern |
Definition at line 38 of file init.c.
Referenced by CsrParseServerCommandLine().
◆ CsrNtSysInfo
|
extern |
Definition at line 44 of file init.c.
Referenced by CsrServerInitialization(), and CsrSrvCreateSharedSection().
◆ CsrObjectDirectory
|
extern |
Definition at line 26 of file init.c.
Referenced by CsrParseServerCommandLine().
◆ CsrProcessLock
|
extern |
Definition at line 60 of file api.h.
Referenced by CsrInitializeProcessStructure().
◆ CsrRootProcess
|
extern |
Definition at line 22 of file procsup.c.
Referenced by CsrAddStaticServerThread(), CsrApiPortInitialize(), CsrExecServerThread(), CsrInitCsrRootProcess(), CsrInitializeProcessStructure(), CsrInsertProcess(), CsrLocateThreadInProcess(), CsrLockProcessByClientId(), CsrShutdownProcesses(), and FindProcessForShutdown().
◆ CsrSbApiPort
|
extern |
Definition at line 29 of file init.c.
Referenced by CsrSbApiPortInitialize(), CsrSbApiRequestThread(), and CsrServerInitialization().
◆ CsrSbApiPortName
|
extern |
Definition at line 28 of file init.c.
Referenced by CsrSbApiPortInitialize(), and CsrServerInitialization().
◆ CsrSmApiPort
|
extern |
Definition at line 31 of file init.c.
Referenced by CsrDereferenceNtSession(), and CsrServerInitialization().
◆ CsrSrvSharedSectionHeap
|
extern |
Definition at line 21 of file server.c.
Referenced by CsrLoadServerDll(), CsrSrvAttachSharedSection(), and CsrSrvCreateSharedSection().
◆ CsrSrvSharedStaticServerData
|
extern |
Definition at line 23 of file server.c.
Referenced by CsrLoadServerDll(), CsrSrvAttachSharedSection(), and CsrSrvCreateSharedSection().
◆ CsrThreadHashTable
|
extern |
Definition at line 21 of file thredsup.c.
Referenced by CsrInitializeProcessStructure(), CsrInsertThread(), CsrLocateThreadByClientId(), and CsrLockThreadByClientId().
◆ CsrTotalPerProcessDataLength
|
extern |
Definition at line 39 of file init.c.
Referenced by CsrLoadServerDll().
◆ CsrWaitListsLock
| RTL_CRITICAL_SECTION CsrWaitListsLock |
Definition at line 10 of file api.h.
Referenced by CsrInitializeProcessStructure().
◆ hBootstrapOk
|
extern |
