ReactOS  0.4.12-dev-90-g2e2e63e
procsup.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS Client/Server Runtime SubSystem
4  * FILE: subsystems/win32/csrsrv/procsup.c
5  * PURPOSE: CSR Server DLL Process Management
6  * PROGRAMMERS: ReactOS Portable Systems Group
7  * Alex Ionescu (alex@relsoft.net)
8  */
9 
10 /* INCLUDES *******************************************************************/
11 
12 #include <srv.h>
13 
14 #include <winuser.h>
15 
16 #define NDEBUG
17 #include <debug.h>
18 
19 /* GLOBALS ********************************************************************/
20 
24 {
28  FALSE
29 };
32 
33 
34 /* PRIVATE FUNCTIONS **********************************************************/
35 
36 /*++
37  * @name CsrSetToNormalPriority
38  *
39  * The CsrSetToNormalPriority routine sets the current NT Process'
40  * priority to the normal priority for CSR Processes.
41  *
42  * @param None.
43  *
44  * @return None.
45  *
46  * @remarks The "Normal" Priority corresponds to the Normal Foreground
47  * Priority (9) plus a boost of 4.
48  *
49  *--*/
50 VOID
51 NTAPI
53 {
54  KPRIORITY BasePriority = (8 + 1) + 4;
55 
56  /* Set the Priority */
59  &BasePriority,
60  sizeof(BasePriority));
61 }
62 
63 /*++
64  * @name CsrSetToShutdownPriority
65  *
66  * The CsrSetToShutdownPriority routine sets the current NT Process'
67  * priority to the boosted priority for CSR Processes doing shutdown.
68  * Additonally, it acquires the Shutdown Privilege required for shutdown.
69  *
70  * @param None.
71  *
72  * @return None.
73  *
74  * @remarks The "Shutdown" Priority corresponds to the Normal Foreground
75  * Priority (9) plus a boost of 6.
76  *
77  *--*/
78 VOID
79 NTAPI
81 {
82  KPRIORITY BasePriority = (8 + 1) + 6;
83  BOOLEAN Old;
84 
85  /* Get the shutdown privilege */
87  TRUE,
88  FALSE,
89  &Old)))
90  {
91  /* Set the Priority */
94  &BasePriority,
95  sizeof(BasePriority));
96  }
97 }
98 
99 /*++
100  * @name CsrProcessRefcountZero
101  *
102  * The CsrProcessRefcountZero routine is executed when a CSR Process has lost
103  * all its active references. It removes and de-allocates the CSR Process.
104  *
105  * @param CsrProcess
106  * Pointer to the CSR Process that is to be deleted.
107  *
108  * @return None.
109  *
110  * @remarks Do not call this routine. It is reserved for the internal
111  * thread management routines when a CSR Process has lost all
112  * its references.
113  *
114  * This routine is called with the Process Lock held.
115  *
116  *--*/
117 VOID
118 NTAPI
120 {
122 
123  /* Remove the Process from the list */
124  CsrRemoveProcess(CsrProcess);
125 
126  /* Check if there's a session */
127  if (CsrProcess->NtSession)
128  {
129  /* Dereference the Session */
130  CsrDereferenceNtSession(CsrProcess->NtSession, 0);
131  }
132 
133  /* Close the Client Port if there is one */
134  if (CsrProcess->ClientPort) NtClose(CsrProcess->ClientPort);
135 
136  /* Close the process handle */
137  NtClose(CsrProcess->ProcessHandle);
138 
139  /* Free the Proces Object */
140  CsrDeallocateProcess(CsrProcess);
141 }
142 
143 /*++
144  * @name CsrLockedDereferenceProcess
145  *
146  * The CsrLockedDereferenceProcess dereferences a CSR Process while the
147  * Process Lock is already being held.
148  *
149  * @param CsrProcess
150  * Pointer to the CSR Process to be dereferenced.
151  *
152  * @return None.
153  *
154  * @remarks This routine will return with the Process Lock held.
155  *
156  *--*/
157 VOID
158 NTAPI
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);
171  CsrProcessRefcountZero(CsrProcess);
172  }
173 }
174 
175 /*++
176  * @name CsrAllocateProcess
177  * @implemented NT4
178  *
179  * The CsrAllocateProcess routine allocates a new CSR Process object.
180  *
181  * @return Pointer to the newly allocated CSR Process.
182  *
183  * @remarks None.
184  *
185  *--*/
187 NTAPI
189 {
190  PCSR_PROCESS CsrProcess;
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 */
199  CsrProcess = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, TotalSize);
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 */
207  CsrLockedReferenceProcess(CsrProcess);
208 
209  /* Initialize the Thread List */
210  InitializeListHead(&CsrProcess->ThreadList);
211 
212  /* Return the Process */
213  return CsrProcess;
214 }
215 
216 /*++
217  * @name CsrLockedReferenceProcess
218  *
219  * The CsrLockedReferenceProcess references a CSR Process while the
220  * Process Lock is already being held.
221  *
222  * @param CsrProcess
223  * Pointer to the CSR Process to be referenced.
224  *
225  * @return None.
226  *
227  * @remarks This routine will return with the Process Lock held.
228  *
229  *--*/
230 VOID
231 NTAPI
233 {
234  /* Increment the reference count */
235  ++CsrProcess->ReferenceCount;
236 }
237 
238 /*++
239  * @name CsrInitializeProcessStructure
240  * @implemented NT4
241  *
242  * The CsrInitializeProcessStructure routine sets up support for CSR Processes
243  * and CSR Threads by initializing our own CSR Root Process.
244  *
245  * @param None.
246  *
247  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
248  *
249  * @remarks None.
250  *
251  *--*/
252 NTSTATUS
253 NTAPI
255 {
257  ULONG i;
258 
259  /* Initialize the Lock */
260  Status = RtlInitializeCriticalSection(&CsrProcessLock);
261  if (!NT_SUCCESS(Status)) return Status;
262 
263  /* Set up the Root Process */
264  CsrRootProcess = CsrAllocateProcess();
265  if (!CsrRootProcess) return STATUS_NO_MEMORY;
266 
267  /* Set up the minimal information for it */
268  InitializeListHead(&CsrRootProcess->ListLink);
269  CsrRootProcess->ProcessHandle = (HANDLE)-1;
270  CsrRootProcess->ClientId = NtCurrentTeb()->ClientId;
271 
272  /* Initialize the Thread Hash List */
274 
275  /* Initialize the Wait Lock */
277 }
278 
279 /*++
280  * @name CsrDeallocateProcess
281  *
282  * The CsrDeallocateProcess frees the memory associated with a CSR Process.
283  *
284  * @param CsrProcess
285  * Pointer to the CSR Process to be freed.
286  *
287  * @return None.
288  *
289  * @remarks Do not call this routine. It is reserved for the internal
290  * thread management routines when a CSR Process has been cleanly
291  * dereferenced and killed.
292  *
293  *--*/
294 VOID
295 NTAPI
297 {
298  /* Free the process object from the heap */
299  RtlFreeHeap(CsrHeap, 0, CsrProcess);
300 }
301 
302 /*++
303  * @name CsrRemoveProcess
304  *
305  * The CsrRemoveProcess function undoes a CsrInsertProcess operation and
306  * removes the CSR Process from the Process List and notifies Server DLLs
307  * of this removal.
308  *
309  * @param CsrProcess
310  * Pointer to the CSR Process to remove.
311  *
312  * @return None.
313  *
314  * @remarks None.
315  *
316  *--*/
317 VOID
318 NTAPI
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 }
345 
346 /*++
347  * @name CsrInsertProcess
348  *
349  * The CsrInsertProcess routine inserts a CSR Process into the Process List
350  * and notifies Server DLLs of the creation of a new CSR Process.
351  *
352  * @param ParentProcess
353  * Optional pointer to the Parent Process creating this CSR Process.
354  *
355  * @param CsrProcess
356  * Pointer to the CSR Process which is to be inserted.
357  *
358  * @return None.
359  *
360  * @remarks None.
361  *
362  *--*/
363 VOID
364 NTAPI
366  IN PCSR_PROCESS CsrProcess)
367 {
368  PCSR_SERVER_DLL ServerDll;
369  ULONG i;
371 
372  /* Insert it into the Root List */
373  InsertTailList(&CsrRootProcess->ListLink, &CsrProcess->ListLink);
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 }
388 
389 
390 /* PUBLIC FUNCTIONS ***********************************************************/
391 
392 /*++
393  * @name CsrCreateProcess
394  * @implemented NT4
395  *
396  * The CsrCreateProcess routine creates a CSR Process object for an NT Process.
397  *
398  * @param hProcess
399  * Handle to an existing NT Process to which to associate this
400  * CSR Process.
401  *
402  * @param hThread
403  * Handle to an existing NT Thread to which to create its
404  * corresponding CSR Thread for this CSR Process.
405  *
406  * @param ClientId
407  * Pointer to the Client ID structure of the NT Process to associate
408  * with this CSR Process.
409  *
410  * @param NtSession
411  * @param Flags
412  * @param DebugCid
413  *
414  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
415  *
416  * @remarks None.
417  *
418  *--*/
419 NTSTATUS
420 NTAPI
422  IN HANDLE hThread,
424  IN PCSR_NT_SESSION NtSession,
425  IN ULONG Flags,
426  IN PCLIENT_ID DebugCid)
427 {
428  PCSR_THREAD CurrentThread = CsrGetClientThread();
429  CLIENT_ID CurrentCid;
431  PCSR_SERVER_DLL ServerDll;
432  PVOID ProcessData;
433  ULONG i;
434  PCSR_PROCESS CsrProcess;
436  PCSR_THREAD CsrThread;
437  KERNEL_USER_TIMES KernelTimes;
438 
439  /* Get the current CID and lock Processes */
440  CurrentCid = CurrentThread->ClientId;
442 
443  /* Get the current CSR Thread */
444  CurrentThread = CsrLocateThreadByClientId(&CurrentProcess, &CurrentCid);
445  if (!CurrentThread)
446  {
447  /* We've failed to locate the thread */
450  }
451 
452  /* Allocate a new Process Object */
453  CsrProcess = CsrAllocateProcess();
454  if (!CsrProcess)
455  {
456  /* Couldn't allocate Process */
458  return STATUS_NO_MEMORY;
459  }
460 
461  /* Inherit the Process Data */
462  CurrentProcess = CurrentThread->Process;
463  ProcessData = &CsrProcess->ServerData[CSR_SERVER_DLL_MAX];
464  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
465  {
466  /* Get the current Server */
467  ServerDll = CsrLoadedServerDll[i];
468 
469  /* Check if the DLL is Loaded and has Per Process Data */
470  if (ServerDll && ServerDll->SizeOfProcessData)
471  {
472  /* Set the pointer */
473  CsrProcess->ServerData[i] = ProcessData;
474 
475  /* Copy the Data */
476  RtlMoveMemory(ProcessData,
477  CurrentProcess->ServerData[i],
478  ServerDll->SizeOfProcessData);
479 
480  /* Update next data pointer */
481  ProcessData = (PVOID)((ULONG_PTR)ProcessData +
482  ServerDll->SizeOfProcessData);
483  }
484  else
485  {
486  /* No data for this Server */
487  CsrProcess->ServerData[i] = NULL;
488  }
489  }
490 
491  /* Set the Exception Port for us */
492  Status = NtSetInformationProcess(hProcess,
494  &CsrApiPort,
495  sizeof(CsrApiPort));
496  if (!NT_SUCCESS(Status))
497  {
498  /* Failed */
499  CsrDeallocateProcess(CsrProcess);
501  return STATUS_NO_MEMORY;
502  }
503 
504  /* Check if CreateProcess got CREATE_NEW_PROCESS_GROUP */
505  if (Flags & CsrProcessCreateNewGroup)
506  {
507  /*
508  * We create the process group leader of a new process group, therefore
509  * its process group ID and sequence number are its own ones.
510  */
511  CsrProcess->ProcessGroupId = HandleToUlong(ClientId->UniqueProcess);
512  CsrProcess->ProcessGroupSequence = CsrProcess->SequenceNumber;
513  }
514  else
515  {
516  /* Inherit the process group ID and sequence number from the current process */
517  CsrProcess->ProcessGroupId = CurrentProcess->ProcessGroupId;
518  CsrProcess->ProcessGroupSequence = CurrentProcess->ProcessGroupSequence;
519  }
520 
521  /* Check if this is a console process */
522  if (Flags & CsrProcessIsConsoleApp) CsrProcess->Flags |= CsrProcessIsConsoleApp;
523 
524  /* Mask out non-debug flags */
525  Flags &= ~(CsrProcessIsConsoleApp | CsrProcessCreateNewGroup | CsrProcessPriorityFlags);
526 
527  /* Check if every process will be debugged */
528  if (!(Flags) && (CurrentProcess->DebugFlags & CsrDebugProcessChildren))
529  {
530  /* Pass it on to the current process */
531  CsrProcess->DebugFlags = CsrDebugProcessChildren;
532  CsrProcess->DebugCid = CurrentProcess->DebugCid;
533  }
534 
535  /* Check if Debugging was used on this process */
536  if ((Flags & (CsrDebugOnlyThisProcess | CsrDebugProcessChildren)) && (DebugCid))
537  {
538  /* Save the debug flag used */
539  CsrProcess->DebugFlags = Flags;
540 
541  /* Save the CID */
542  CsrProcess->DebugCid = *DebugCid;
543  }
544 
545  /* Check if Debugging is enabled */
546  if (CsrProcess->DebugFlags)
547  {
548  /* Set the Debug Port for us */
549  Status = NtSetInformationProcess(hProcess,
551  &CsrApiPort,
552  sizeof(CsrApiPort));
553  ASSERT(NT_SUCCESS(Status));
554  if (!NT_SUCCESS(Status))
555  {
556  /* Failed */
557  CsrDeallocateProcess(CsrProcess);
559  return STATUS_NO_MEMORY;
560  }
561  }
562 
563  /* Get the Thread Create Time */
564  Status = NtQueryInformationThread(hThread,
565  ThreadTimes,
566  &KernelTimes,
567  sizeof(KernelTimes),
568  NULL);
569  if (!NT_SUCCESS(Status))
570  {
571  /* Failed */
572  CsrDeallocateProcess(CsrProcess);
574  return STATUS_NO_MEMORY;
575  }
576 
577  /* Allocate a CSR Thread Structure */
578  CsrThread = CsrAllocateThread(CsrProcess);
579  if (!CsrThread)
580  {
581  /* Failed */
582  CsrDeallocateProcess(CsrProcess);
584  return STATUS_NO_MEMORY;
585  }
586 
587  /* Save the data we have */
588  CsrThread->CreateTime = KernelTimes.CreateTime;
589  CsrThread->ClientId = *ClientId;
590  CsrThread->ThreadHandle = hThread;
591  ProtectHandle(hThread);
592  CsrThread->Flags = 0;
593 
594  /* Insert the Thread into the Process */
595  Status = CsrInsertThread(CsrProcess, CsrThread);
596  if (!NT_SUCCESS(Status))
597  {
598  /* Bail out */
599  CsrDeallocateProcess(CsrProcess);
600  CsrDeallocateThread(CsrThread);
602  return Status;
603  }
604 
605  /* Reference the session */
606  CsrReferenceNtSession(NtSession);
607  CsrProcess->NtSession = NtSession;
608 
609  /* Setup Process Data */
610  CsrProcess->ClientId = *ClientId;
611  CsrProcess->ProcessHandle = hProcess;
612  CsrProcess->ShutdownLevel = 0x280;
613 
614  /* Set the Priority to Background */
615  CsrSetBackgroundPriority(CsrProcess);
616 
617  /* Insert the Process */
618  CsrInsertProcess(CurrentProcess, CsrProcess);
619 
620  /* Release lock and return */
622  return Status;
623 }
624 
625 /*++
626  * @name CsrDebugProcess
627  * @implemented NT4
628  *
629  * The CsrDebugProcess routine is deprecated in NT 5.1 and higher. It is
630  * exported only for compatibility with older CSR Server DLLs.
631  *
632  * @param CsrProcess
633  * Deprecated.
634  *
635  * @return Deprecated
636  *
637  * @remarks Deprecated.
638  *
639  *--*/
640 NTSTATUS
641 NTAPI
643 {
644  /* CSR does not handle debugging anymore */
645  DPRINT("CSRSRV: %s(0x%p) called\n", __FUNCTION__, CsrProcess);
646  return STATUS_UNSUCCESSFUL;
647 }
648 
649 /*++
650  * @name CsrDebugProcessStop
651  * @implemented NT4
652  *
653  * The CsrDebugProcessStop routine is deprecated in NT 5.1 and higher. It is
654  * exported only for compatibility with older CSR Server DLLs.
655  *
656  * @param CsrProcess
657  * Deprecated.
658  *
659  * @return Deprecated
660  *
661  * @remarks Deprecated.
662  *
663  *--*/
664 NTSTATUS
665 NTAPI
667 {
668  /* CSR does not handle debugging anymore */
669  DPRINT("CSRSRV: %s(0x%p) called\n", __FUNCTION__, CsrProcess);
670  return STATUS_UNSUCCESSFUL;
671 }
672 
673 /*++
674  * @name CsrDereferenceProcess
675  * @implemented NT4
676  *
677  * The CsrDereferenceProcess routine removes a reference from a CSR Process.
678  *
679  * @param CsrThread
680  * Pointer to the CSR Process to dereference.
681  *
682  * @return None.
683  *
684  * @remarks If the reference count has reached zero (ie: the CSR Process has
685  * no more active references), it will be deleted.
686  *
687  *--*/
688 VOID
689 NTAPI
691 {
692  LONG LockCount;
693 
694  /* Acquire process lock */
696 
697  /* Decrease reference count */
698  LockCount = --CsrProcess->ReferenceCount;
699  ASSERT(LockCount >= 0);
700  if (LockCount == 0)
701  {
702  /* Call the generic cleanup code */
703  CsrProcessRefcountZero(CsrProcess);
704  }
705  else
706  {
707  /* Just release the lock */
709  }
710 }
711 
712 /*++
713  * @name CsrDestroyProcess
714  * @implemented NT4
715  *
716  * The CsrDestroyProcess routine destroys the CSR Process corresponding to
717  * a given Client ID.
718  *
719  * @param Cid
720  * Pointer to the Client ID Structure corresponding to the CSR
721  * Process which is about to be destroyed.
722  *
723  * @param ExitStatus
724  * Unused.
725  *
726  * @return STATUS_SUCCESS in case of success, STATUS_THREAD_IS_TERMINATING
727  * if the CSR Process is already terminating.
728  *
729  * @remarks None.
730  *
731  *--*/
732 NTSTATUS
733 NTAPI
736 {
737  PCSR_THREAD CsrThread;
738  PCSR_PROCESS CsrProcess;
739  CLIENT_ID ClientId = *Cid;
740  PLIST_ENTRY NextEntry;
741 
742  /* Acquire lock */
744 
745  /* Find the thread */
746  CsrThread = CsrLocateThreadByClientId(&CsrProcess, &ClientId);
747 
748  /* Make sure we got one back, and that it's not already gone */
749  if (!(CsrThread) || (CsrProcess->Flags & CsrProcessTerminating))
750  {
751  /* Release the lock and return failure */
754  }
755 
756  /* Set the terminated flag */
757  CsrProcess->Flags |= CsrProcessTerminating;
758 
759  /* Get the List Pointers */
760  NextEntry = CsrProcess->ThreadList.Flink;
761  while (NextEntry != &CsrProcess->ThreadList)
762  {
763  /* Get the current thread entry */
764  CsrThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
765 
766  /* Move to the next entry */
767  NextEntry = NextEntry->Flink;
768 
769  /* Make sure the thread isn't already dead */
770  if (CsrThread->Flags & CsrThreadTerminated)
771  {
772  /* Go the the next thread */
773  continue;
774  }
775 
776  /* Set the Terminated flag */
777  CsrThread->Flags |= CsrThreadTerminated;
778 
779  /* Acquire the Wait Lock */
781 
782  /* Do we have an active wait block? */
783  if (CsrThread->WaitBlock)
784  {
785  /* Notify waiters of termination */
786  CsrNotifyWaitBlock(CsrThread->WaitBlock,
787  NULL,
788  NULL,
789  NULL,
791  TRUE);
792  }
793 
794  /* Release the Wait Lock */
796 
797  /* Dereference the thread */
798  CsrLockedDereferenceThread(CsrThread);
799  }
800 
801  /* Release the Process Lock and return success */
803  return STATUS_SUCCESS;
804 }
805 
806 /*++
807  * @name CsrGetProcessLuid
808  * @implemented NT4
809  *
810  * The CsrGetProcessLuid routine gets the LUID of the given process.
811  *
812  * @param hProcess
813  * Optional handle to the process whose LUID should be returned.
814  *
815  * @param Luid
816  * Pointer to a LUID Pointer which will receive the CSR Process' LUID.
817  *
818  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
819  *
820  * @remarks If hProcess is not supplied, then the current thread's token will
821  * be used. If that too is missing, then the current process' token
822  * will be used.
823  *
824  *--*/
825 NTSTATUS
826 NTAPI
828  OUT PLUID Luid)
829 {
830  HANDLE hToken = NULL;
832  ULONG Length;
833  PTOKEN_STATISTICS TokenStats;
834 
835  /* Check if we have a handle to a CSR Process */
836  if (!hProcess)
837  {
838  /* We don't, so try opening the Thread's Token */
840  TOKEN_QUERY,
841  FALSE,
842  &hToken);
843 
844  /* Check for success */
845  if (!NT_SUCCESS(Status))
846  {
847  /* If we got some other failure, then return and quit */
848  if (Status != STATUS_NO_TOKEN) return Status;
849 
850  /* We don't have a Thread Token, use a Process Token */
852  hToken = NULL;
853  }
854  }
855 
856  /* Check if we have a token by now */
857  if (!hToken)
858  {
859  /* No token yet, so open the Process Token */
860  Status = NtOpenProcessToken(hProcess,
861  TOKEN_QUERY,
862  &hToken);
863  if (!NT_SUCCESS(Status))
864  {
865  /* Still no token, return the error */
866  return Status;
867  }
868  }
869 
870  /* Now get the size we'll need for the Token Information */
871  Status = NtQueryInformationToken(hToken,
873  NULL,
874  0,
875  &Length);
876 
877  /* Allocate memory for the Token Info */
878  if (!(TokenStats = RtlAllocateHeap(CsrHeap, 0, Length)))
879  {
880  /* Fail and close the token */
881  NtClose(hToken);
882  return STATUS_NO_MEMORY;
883  }
884 
885  /* Now query the information */
886  Status = NtQueryInformationToken(hToken,
888  TokenStats,
889  Length,
890  &Length);
891 
892  /* Close the handle */
893  NtClose(hToken);
894 
895  /* Check for success */
896  if (NT_SUCCESS(Status))
897  {
898  /* Return the LUID */
899  *Luid = TokenStats->AuthenticationId;
900  }
901 
902  /* Free the query information */
903  RtlFreeHeap(CsrHeap, 0, TokenStats);
904 
905  /* Return the Status */
906  return Status;
907 }
908 
909 /*++
910  * @name CsrImpersonateClient
911  * @implemented NT4
912  *
913  * The CsrImpersonateClient will impersonate the given CSR Thread.
914  *
915  * @param CsrThread
916  * Pointer to the CSR Thread to impersonate.
917  *
918  * @return TRUE if impersonation succeeded, FALSE otherwise.
919  *
920  * @remarks Impersonation can be recursive.
921  *
922  *--*/
923 BOOLEAN
924 NTAPI
926 {
928  PCSR_THREAD CurrentThread = CsrGetClientThread();
929 
930  /* Use the current thread if none given */
931  if (!CsrThread) CsrThread = CurrentThread;
932 
933  /* Still no thread, something is wrong */
934  if (!CsrThread)
935  {
936  /* Failure */
937  return FALSE;
938  }
939 
940  /* Make the call */
942  CsrThread->ThreadHandle,
943  &CsrSecurityQos);
944 
945  if (!NT_SUCCESS(Status))
946  {
947  /* Failure */
948  DPRINT1("CSRSS: Can't impersonate client thread - Status = %lx\n", Status);
949  // if (Status != STATUS_BAD_IMPERSONATION_LEVEL) DbgBreakPoint();
950  return FALSE;
951  }
952 
953  /* Increase the impersonation count for the current thread */
954  if (CurrentThread) ++CurrentThread->ImpersonationCount;
955 
956  /* Return Success */
957  return TRUE;
958 }
959 
960 /*++
961  * @name CsrLockProcessByClientId
962  * @implemented NT4
963  *
964  * The CsrLockProcessByClientId routine locks the CSR Process corresponding
965  * to the given Process ID and optionally returns it.
966  *
967  * @param Pid
968  * Process ID corresponding to the CSR Process which will be locked.
969  *
970  * @param CsrProcess
971  * Optional pointer to a CSR Process pointer which will hold the
972  * CSR Process corresponding to the given Process ID.
973  *
974  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
975  *
976  * @remarks Locking a CSR Process is defined as acquiring an extra
977  * reference to it and returning with the Process Lock held.
978  *
979  *--*/
980 NTSTATUS
981 NTAPI
983  OUT PCSR_PROCESS *CsrProcess)
984 {
985  PLIST_ENTRY NextEntry;
988 
989  /* Acquire the lock */
991 
992  /* Assume failure */
993  ASSERT(CsrProcess != NULL);
994  *CsrProcess = NULL;
995 
996  /* Setup the List Pointers */
997  NextEntry = &CsrRootProcess->ListLink;
998  do
999  {
1000  /* Get the Process */
1001  CurrentProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1002 
1003  /* Check for PID Match */
1004  if (CurrentProcess->ClientId.UniqueProcess == Pid)
1005  {
1006  Status = STATUS_SUCCESS;
1007  break;
1008  }
1009 
1010  /* Move to the next entry */
1011  NextEntry = NextEntry->Flink;
1012  } while (NextEntry != &CsrRootProcess->ListLink);
1013 
1014  /* Check if we didn't find it in the list */
1015  if (!NT_SUCCESS(Status))
1016  {
1017  /* Nothing found, release the lock */
1019  }
1020  else
1021  {
1022  /* Lock the found process and return it */
1023  CsrLockedReferenceProcess(CurrentProcess);
1024  *CsrProcess = CurrentProcess;
1025  }
1026 
1027  /* Return the result */
1028  return Status;
1029 }
1030 
1031 /*++
1032  * @name CsrRevertToSelf
1033  * @implemented NT4
1034  *
1035  * The CsrRevertToSelf routine will attempt to remove an active impersonation.
1036  *
1037  * @param None.
1038  *
1039  * @return TRUE if the reversion was succesful, FALSE otherwise.
1040  *
1041  * @remarks Impersonation can be recursive; as such, the impersonation token
1042  * will only be deleted once the CSR Thread's impersonaton count
1043  * has reached zero.
1044  *
1045  *--*/
1046 BOOLEAN
1047 NTAPI
1049 {
1050  NTSTATUS Status;
1051  PCSR_THREAD CurrentThread = CsrGetClientThread();
1052  HANDLE ImpersonationToken = NULL;
1053 
1054  /* Check if we have a Current Thread */
1055  if (CurrentThread)
1056  {
1057  /* Make sure impersonation is on */
1058  if (!CurrentThread->ImpersonationCount)
1059  {
1060  DPRINT1("CSRSS: CsrRevertToSelf called while not impersonating\n");
1061  // DbgBreakPoint();
1062  return FALSE;
1063  }
1064  else if ((--CurrentThread->ImpersonationCount) > 0)
1065  {
1066  /* Success; impersonation count decreased but still not zero */
1067  return TRUE;
1068  }
1069  }
1070 
1071  /* Impersonation has been totally removed, revert to ourselves */
1074  &ImpersonationToken,
1075  sizeof(ImpersonationToken));
1076 
1077  /* Return TRUE or FALSE */
1078  return NT_SUCCESS(Status);
1079 }
1080 
1081 /*++
1082  * @name CsrSetBackgroundPriority
1083  * @implemented NT4
1084  *
1085  * The CsrSetBackgroundPriority routine sets the priority for the given CSR
1086  * Process as a Background priority.
1087  *
1088  * @param CsrProcess
1089  * Pointer to the CSR Process whose priority will be modified.
1090  *
1091  * @return None.
1092  *
1093  * @remarks None.
1094  *
1095  *--*/
1096 VOID
1097 NTAPI
1099 {
1100  PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
1101 
1102  /* Set the Foreground bit off */
1103  ProcessPriority.Foreground = FALSE;
1104 
1105  /* Set the new priority */
1106  NtSetInformationProcess(CsrProcess->ProcessHandle,
1108  &ProcessPriority,
1109  sizeof(ProcessPriority));
1110 }
1111 
1112 /*++
1113  * @name CsrSetForegroundPriority
1114  * @implemented NT4
1115  *
1116  * The CsrSetForegroundPriority routine sets the priority for the given CSR
1117  * Process as a Foreground priority.
1118  *
1119  * @param CsrProcess
1120  * Pointer to the CSR Process whose priority will be modified.
1121  *
1122  * @return None.
1123  *
1124  * @remarks None.
1125  *
1126  *--*/
1127 VOID
1128 NTAPI
1130 {
1131  PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
1132 
1133  /* Set the Foreground bit on */
1134  ProcessPriority.Foreground = TRUE;
1135 
1136  /* Set the new priority */
1137  NtSetInformationProcess(CsrProcess->ProcessHandle,
1139  &ProcessPriority,
1140  sizeof(ProcessPriority));
1141 }
1142 
1143 /*++
1144  * @name FindProcessForShutdown
1145  *
1146  * The FindProcessForShutdown routine returns a CSR Process which is ready
1147  * to be shutdown, and sets the appropriate shutdown flags for it.
1148  *
1149  * @param CallerLuid
1150  * Pointer to the LUID of the CSR Process calling this routine.
1151  *
1152  * @return Pointer to a CSR Process which is ready to be shutdown.
1153  *
1154  * @remarks None.
1155  *
1156  *--*/
1158 NTAPI
1160 {
1161  PCSR_PROCESS CsrProcess, ReturnCsrProcess = NULL;
1162  PCSR_THREAD CsrThread;
1163  NTSTATUS Status;
1164  ULONG Level = 0;
1165  LUID ProcessLuid;
1166  LUID SystemLuid = SYSTEM_LUID;
1167  PLIST_ENTRY NextEntry;
1168 
1169  /* Set the List Pointers */
1170  NextEntry = CsrRootProcess->ListLink.Flink;
1171  while (NextEntry != &CsrRootProcess->ListLink)
1172  {
1173  /* Get the process */
1174  CsrProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1175 
1176  /* Move to the next entry */
1177  NextEntry = NextEntry->Flink;
1178 
1179  /* Skip this process if it's already been processed */
1180  if (CsrProcess->Flags & CsrProcessSkipShutdown) continue;
1181 
1182  /* Get the LUID of this process */
1183  Status = CsrGetProcessLuid(CsrProcess->ProcessHandle, &ProcessLuid);
1184 
1185  /* Check if we didn't get access to the LUID */
1186  if (Status == STATUS_ACCESS_DENIED)
1187  {
1188  /* Check if we have any threads */
1189  if (CsrProcess->ThreadCount)
1190  {
1191  /* Impersonate one of the threads and retry */
1192  CsrThread = CONTAINING_RECORD(CsrProcess->ThreadList.Flink,
1193  CSR_THREAD,
1194  Link);
1195  if (CsrImpersonateClient(CsrThread))
1196  {
1197  Status = CsrGetProcessLuid(NULL, &ProcessLuid);
1198  CsrRevertToSelf();
1199  }
1200  else
1201  {
1203  }
1204  }
1205  }
1206 
1207  if (!NT_SUCCESS(Status))
1208  {
1209  /* We didn't have access, so skip it */
1210  CsrProcess->Flags |= CsrProcessSkipShutdown;
1211  continue;
1212  }
1213 
1214  /* Check if this is the System LUID */
1215  if (RtlEqualLuid(&ProcessLuid, &SystemLuid))
1216  {
1217  /* Mark this process */
1218  CsrProcess->ShutdownFlags |= CsrShutdownSystem;
1219  }
1220  else if (!RtlEqualLuid(&ProcessLuid, CallerLuid))
1221  {
1222  /* Our LUID doesn't match with the caller's */
1223  CsrProcess->ShutdownFlags |= CsrShutdownOther;
1224  }
1225 
1226  /* Check if we're past the previous level */
1227  if ((CsrProcess->ShutdownLevel > Level) || !ReturnCsrProcess)
1228  {
1229  /* Update the level */
1230  Level = CsrProcess->ShutdownLevel;
1231 
1232  /* Set the final process */
1233  ReturnCsrProcess = CsrProcess;
1234  }
1235  }
1236 
1237  /* Check if we found a process */
1238  if (ReturnCsrProcess)
1239  {
1240  /* Skip this one next time */
1241  ReturnCsrProcess->Flags |= CsrProcessSkipShutdown;
1242  }
1243 
1244  return ReturnCsrProcess;
1245 }
1246 
1247 /*++
1248  * @name CsrShutdownProcesses
1249  * @implemented NT4
1250  *
1251  * The CsrShutdownProcesses routine shuts down every CSR Process possible
1252  * and calls each Server DLL's shutdown notification.
1253  *
1254  * @param CallerLuid
1255  * Pointer to the LUID of the CSR Process that is ordering the
1256  * shutdown.
1257  *
1258  * @param Flags
1259  * Flags to send to the shutdown notification routine.
1260  *
1261  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
1262  *
1263  * @remarks None.
1264  *
1265  *--*/
1266 NTSTATUS
1267 NTAPI
1269  IN ULONG Flags)
1270 {
1271  PLIST_ENTRY NextEntry;
1272  PCSR_PROCESS CsrProcess;
1273  NTSTATUS Status;
1274  BOOLEAN FirstTry;
1275  ULONG i;
1276  PCSR_SERVER_DLL ServerDll;
1277  ULONG Result = 0;
1278 
1279  /* Acquire process lock */
1281 
1282  /* Add shutdown flag */
1283  CsrRootProcess->ShutdownFlags |= CsrShutdownSystem;
1284 
1285  /* Get the list pointers */
1286  NextEntry = CsrRootProcess->ListLink.Flink;
1287  while (NextEntry != &CsrRootProcess->ListLink)
1288  {
1289  /* Get the Process */
1290  CsrProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1291 
1292  /* Move to the next entry */
1293  NextEntry = NextEntry->Flink;
1294 
1295  /* Remove the skip flag, set shutdown flags to 0 */
1296  CsrProcess->Flags &= ~CsrProcessSkipShutdown;
1297  CsrProcess->ShutdownFlags = 0;
1298  }
1299 
1300  /* Set shutdown Priority */
1302 
1303  /* Start looping */
1304  while (TRUE)
1305  {
1306  /* Find the next process to shutdown */
1307  CsrProcess = FindProcessForShutdown(CallerLuid);
1308  if (!CsrProcess) break;
1309 
1310  /* Increase reference to process */
1311  CsrLockedReferenceProcess(CsrProcess);
1312 
1313  FirstTry = TRUE;
1314  while (TRUE)
1315  {
1316  /* Loop all the servers */
1317  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
1318  {
1319  /* Get the current server */
1320  ServerDll = CsrLoadedServerDll[i];
1321 
1322  /* Check if it's valid and if it has a Shutdown Process Callback */
1323  if (ServerDll && ServerDll->ShutdownProcessCallback)
1324  {
1325  /* Release the lock, make the callback, and acquire it back */
1327  Result = ServerDll->ShutdownProcessCallback(CsrProcess,
1328  Flags,
1329  FirstTry);
1331 
1332  /* Check the result */
1333  if (Result == CsrShutdownCsrProcess)
1334  {
1335  /* The callback unlocked the process */
1336  break;
1337  }
1338  else if (Result == CsrShutdownCancelled)
1339  {
1340  /* Check if this was a forced shutdown */
1341  if (Flags & EWX_FORCE)
1342  {
1343  DPRINT1("Process %x cancelled forced shutdown (Dll = %d)\n",
1344  CsrProcess->ClientId.UniqueProcess, i);
1345  DbgBreakPoint();
1346  }
1347 
1348  /* Shutdown was cancelled, unlock and exit */
1350  Status = STATUS_CANCELLED;
1351  goto Quickie;
1352  }
1353  }
1354  }
1355 
1356  /* No matches during the first try, so loop again */
1357  if (FirstTry && (Result == CsrShutdownNonCsrProcess))
1358  {
1359  FirstTry = FALSE;
1360  continue;
1361  }
1362 
1363  /* Second try, break out */
1364  break;
1365  }
1366 
1367  /* We've reached the final loop here, so dereference */
1368  if (i == CSR_SERVER_DLL_MAX) CsrLockedDereferenceProcess(CsrProcess);
1369  }
1370 
1371  /* Success path */
1373  Status = STATUS_SUCCESS;
1374 
1375 Quickie:
1376  /* Return to normal priority */
1378 
1379  return Status;
1380 }
1381 
1382 /*++
1383  * @name CsrUnlockProcess
1384  * @implemented NT4
1385  *
1386  * The CsrUnlockProcess undoes a previous CsrLockProcessByClientId operation.
1387  *
1388  * @param CsrProcess
1389  * Pointer to a previously locked CSR Process.
1390  *
1391  * @return STATUS_SUCCESS.
1392  *
1393  * @remarks This routine must be called with the Process Lock held.
1394  *
1395  *--*/
1396 NTSTATUS
1397 NTAPI
1399 {
1400  /* Dereference the process */
1401  CsrLockedDereferenceProcess(CsrProcess);
1402 
1403  /* Release the lock and return */
1405  return STATUS_SUCCESS;
1406 }
1407 
1408 /* EOF */
LUID AuthenticationId
Definition: setypes.h:1033
ULONG DebugFlags
Definition: csrsrv.h:49
NTSTATUS NTAPI NtImpersonateThread(IN HANDLE ThreadHandle, IN HANDLE ThreadToImpersonateHandle, IN PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService)
Definition: security.c:939
#define EWX_FORCE
Definition: winuser.h:630
#define IN
Definition: typedefs.h:38
#define CsrGetClientThread()
Definition: csrsrv.h:77
NTSTATUS NTAPI CsrCreateProcess(IN HANDLE hProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId, IN PCSR_NT_SESSION NtSession, IN ULONG Flags, IN PCLIENT_ID DebugCid)
Definition: procsup.c:421
#define TRUE
Definition: types.h:120
#define STATUS_BAD_IMPERSONATION_LEVEL
Definition: ntstatus.h:387
BOOLEAN NTAPI CsrRevertToSelf(VOID)
Definition: procsup.c:1048
ULONG SizeOfProcessData
Definition: csrsrv.h:234
NTSTATUS NTAPI CsrGetProcessLuid(IN HANDLE hProcess OPTIONAL, OUT PLUID Luid)
Definition: procsup.c:827
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: wait.c:120
PCSR_THREAD NTAPI CsrAllocateThread(IN PCSR_PROCESS CsrProcess)
Definition: thredsup.c:119
RTL_CRITICAL_SECTION CsrProcessLock
Definition: procsup.c:21
#define STATUS_THREAD_IS_TERMINATING
Definition: ntstatus.h:297
NTSTATUS NTAPI CsrInitializeProcessStructure(VOID)
Definition: procsup.c:254
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:603
#define HandleToUlong(h)
Definition: basetsd.h:79
#define NtCurrentThread()
ULONG ShutdownFlags
Definition: csrsrv.h:59
NTSTATUS NTAPI CsrLockProcessByClientId(IN HANDLE Pid, OUT PCSR_PROCESS *CsrProcess)
Definition: procsup.c:982
NTSYSAPI NTSTATUS NTAPI RtlAdjustPrivilege(_In_ ULONG Privilege, _In_ BOOLEAN NewValue, _In_ BOOLEAN ForThread, _Out_ PBOOLEAN OldValue)
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
NTSTATUS NTAPI NtOpenProcessToken(IN HANDLE ProcessHandle, IN ACCESS_MASK DesiredAccess, OUT PHANDLE TokenHandle)
Definition: security.c:342
#define InsertTailList(ListHead, Entry)
ULONG CsrProcessSequenceCount
Definition: procsup.c:30
HANDLE UniqueProcess
Definition: compat.h:474
void DbgBreakPoint()
Definition: mach.c:558
#define CsrReleaseWaitLock()
Definition: api.h:24
#define CSR_SERVER_DLL_MAX
Definition: api.h:34
#define CsrReleaseProcessLock()
Definition: api.h:15
NTSTATUS NTAPI CsrDestroyProcess(IN PCLIENT_ID Cid, IN NTSTATUS ExitStatus)
Definition: procsup.c:734
static int Link(const char **args)
Definition: vfdcmd.c:2414
LONG KPRIORITY
Definition: compat.h:454
struct _CSR_PROCESS CSR_PROCESS
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
LONG LockCount
Definition: comsup.c:6
uint32_t ULONG_PTR
Definition: typedefs.h:63
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
PCSR_PROCESS Process
Definition: csrsrv.h:69
#define ProcessStructureListLocked()
Definition: api.h:18
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
GLenum GLclampf GLint i
Definition: glfuncs.h:14
PCSR_DISCONNECT_CALLBACK DisconnectCallback
Definition: csrsrv.h:236
VOID NTAPI CsrLockedReferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:232
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
BOOLEAN NTAPI CsrImpersonateClient(IN PCSR_THREAD CsrThread)
Definition: procsup.c:925
VOID NTAPI CsrDeallocateThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:345
#define RtlEqualLuid(Luid1, Luid2)
Definition: rtlfuncs.h:301
long LONG
Definition: pedump.c:60
ULONG ReferenceCount
Definition: csrsrv.h:51
NTSTATUS NTAPI CsrDebugProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:642
VOID NTAPI CsrDereferenceNtSession(IN PCSR_NT_SESSION Session, IN NTSTATUS ExitStatus)
Definition: session.c:156
ULONG ImpersonationCount
Definition: csrsrv.h:74
VOID NTAPI CsrLockedDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:467
CLIENT_ID DebugCid
Definition: csrsrv.h:50
HANDLE ProcessHandle
Definition: csrsrv.h:46
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
_Must_inspect_result_ __kernel_entry NTSTATUS NTAPI NtQueryInformationToken(_In_ HANDLE TokenHandle, _In_ TOKEN_INFORMATION_CLASS TokenInformationClass, _Out_writes_bytes_to_opt_(TokenInformationLength, *ReturnLength) PVOID TokenInformation, _In_ ULONG TokenInformationLength, _Out_ PULONG ReturnLength)
Definition: token.c:1839
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
void DPRINT(...)
Definition: polytest.cpp:61
NTSTATUS NTAPI CsrDebugProcessStop(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:666
CLIENT_ID ClientId
Definition: csrsrv.h:38
NTSTATUS NTAPI NtSetInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength)
Definition: query.c:1967
NTSTATUS NTAPI CsrInsertThread(IN PCSR_PROCESS Process, IN PCSR_THREAD Thread)
Definition: thredsup.c:297
void * PVOID
Definition: retypes.h:9
#define SE_SHUTDOWN_PRIVILEGE
Definition: security.c:673
ULONG ThreadCount
Definition: csrsrv.h:55
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:585
SECURITY_QUALITY_OF_SERVICE CsrSecurityQos
Definition: procsup.c:23
LIST_ENTRY ListLink
Definition: csrsrv.h:39
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
ULONG CurrentProcess
Definition: shell.c:125
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
BOOLEAN NTAPI ProtectHandle(IN HANDLE ObjectHandle)
Definition: thredsup.c:39
PVOID ServerData[ANYSIZE_ARRAY]
Definition: csrsrv.h:60
#define TOKEN_QUERY
Definition: setypes.h:874
LARGE_INTEGER CreateTime
Definition: csrsrv.h:65
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
CLIENT_ID ClientId
Definition: csrsrv.h:68
ULONG SequenceNumber
Definition: csrsrv.h:47
LARGE_INTEGER CreateTime
Definition: winternl.h:1060
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
ULONG ProcessGroupSequence
Definition: csrsrv.h:53
VOID NTAPI CsrDeallocateProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:296
PVOID HANDLE
Definition: typedefs.h:71
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
PCSR_PROCESS NTAPI FindProcessForShutdown(IN PLUID CallerLuid)
Definition: procsup.c:1159
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define STATUS_NO_TOKEN
Definition: ntstatus.h:346
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2450
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3393
HANDLE ThreadHandle
Definition: csrsrv.h:71
VOID NTAPI CsrProcessRefcountZero(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:119
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define CsrAcquireProcessLock()
Definition: api.h:12
VOID NTAPI CsrSetBackgroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1098
VOID NTAPI CsrRemoveProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:319
VOID NTAPI CsrDereferenceProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:690
PCSR_PROCESS NTAPI CsrAllocateProcess(VOID)
Definition: procsup.c:188
Definition: typedefs.h:117
NTSTATUS NTAPI CsrUnlockProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1398
Definition: copy.c:32
VOID NTAPI CsrReferenceNtSession(IN PCSR_NT_SESSION Session)
Definition: session.c:118
PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId)
Definition: thredsup.c:182
#define SYSTEM_LUID
Definition: setypes.h:672
PCSR_NT_SESSION NtSession
Definition: csrsrv.h:41
PCSR_SHUTDOWNPROCESS_CALLBACK ShutdownProcessCallback
Definition: csrsrv.h:240
Status
Definition: gdiplustypes.h:24
HANDLE CsrApiPort
Definition: connect.c:21
RTL_CRITICAL_SECTION CsrWaitListsLock
Definition: api.h:61
#define NUMBER_THREAD_HASH_BUCKETS
Definition: api.h:44
#define CsrAcquireWaitLock()
Definition: api.h:21
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1089
struct _CSR_WAIT_BLOCK * WaitBlock
Definition: csrsrv.h:70
LIST_ENTRY ThreadList
Definition: csrsrv.h:40
NTSTATUS NTAPI CsrShutdownProcesses(IN PLUID CallerLuid, IN ULONG Flags)
Definition: procsup.c:1268
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
#define SECURITY_STATIC_TRACKING
Definition: setypes.h:104
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:861
ULONG ProcessGroupId
Definition: csrsrv.h:52
VOID NTAPI CsrSetToNormalPriority(VOID)
Definition: procsup.c:52
struct _SECURITY_QUALITY_OF_SERVICE SECURITY_QUALITY_OF_SERVICE
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
HANDLE hThread
Definition: wizard.c:27
VOID NTAPI CsrSetToShutdownPriority(VOID)
Definition: procsup.c:80
#define DPRINT1
Definition: precomp.h:8
NTSTATUS NTAPI NtOpenThreadToken(IN HANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN BOOLEAN OpenAsSelf, OUT PHANDLE TokenHandle)
Definition: token.c:3858
#define OUT
Definition: typedefs.h:39
unsigned int ULONG
Definition: retypes.h:1
ULONG Flags
Definition: csrsrv.h:48
#define __FUNCTION__
Definition: compiler.h:205
VOID NTAPI CsrLockedDereferenceProcess(PCSR_PROCESS CsrProcess)
Definition: procsup.c:159
ULONG Flags
Definition: csrsrv.h:72
HANDLE CsrHeap
Definition: init.c:25
VOID NTAPI CsrInsertProcess(IN PCSR_PROCESS ParentProcess OPTIONAL, IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:365
ULONG ShutdownLevel
Definition: csrsrv.h:58
PCSR_NEWPROCESS_CALLBACK NewProcessCallback
Definition: csrsrv.h:239
ULONG CsrTotalPerProcessDataLength
Definition: init.c:35
return STATUS_SUCCESS
Definition: btrfs.c:2725
#define CsrProcessPriorityFlags
Definition: csrsrv.h:97
VOID NTAPI CsrSetForegroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1129
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68