ReactOS  0.4.12-dev-945-g5a2911d
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 */
261  if (!NT_SUCCESS(Status)) return Status;
262 
263  /* Set up the Root Process */
265  if (!CsrRootProcess) return STATUS_NO_MEMORY;
266 
267  /* Set up the minimal information for it */
270  CsrRootProcess->ClientId = NtCurrentTeb()->ClientId;
271 
272  /* Initialize the Thread Hash List */
274 
275  /* Initialize the Wait Lock */
277 }
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 */
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 */
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  */
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 */
523 
524  /* Mask out non-debug flags */
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 */
551  &CsrApiPort,
552  sizeof(CsrApiPort));
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 */
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;
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 */
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 */
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 */
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  {
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 */
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 */
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 */
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 */
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 */
1351  goto Quickie;
1352  }
1353  }
1354  }
1355 
1356  /* No matches during the first try, so loop again */
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 */
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
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PCSR_DISCONNECT_CALLBACK DisconnectCallback
Definition: csrsrv.h:236
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:32
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:3399
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
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
#define __FUNCTION__
Definition: types.h:112
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