ReactOS  0.4.15-dev-1389-g828d5fa
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 */
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 */
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);
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 {
191  ULONG TotalSize;
192 
193  /* Calculate the amount of memory this should take */
194  TotalSize = sizeof(CSR_PROCESS) +
195  (CSR_SERVER_DLL_MAX * sizeof(PVOID)) +
197 
198  /* Allocate a Process */
200  if (!CsrProcess) return NULL;
201 
202  /* Handle the Sequence Number and protect against overflow */
203  CsrProcess->SequenceNumber = CsrProcessSequenceCount++;
205 
206  /* Increase the reference count */
208 
209  /* Initialize the Thread List */
210  InitializeListHead(&CsrProcess->ThreadList);
211 
212  /* Return the Process */
213  return CsrProcess;
214 }
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 */
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
367 {
368  PCSR_SERVER_DLL ServerDll;
369  ULONG i;
371 
372  /* Insert it into the Root List */
374 
375  /* Notify the Server DLLs */
376  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
377  {
378  /* Get the current Server DLL */
379  ServerDll = CsrLoadedServerDll[i];
380 
381  /* Make sure it's valid and that it has callback */
382  if (ServerDll && ServerDll->NewProcessCallback)
383  {
384  ServerDll->NewProcessCallback(ParentProcess, CsrProcess);
385  }
386  }
387 }
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;
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 */
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 */
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  */
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 */
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 */
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 */
574  return STATUS_NO_MEMORY;
575  }
576 
577  /* Allocate a CSR Thread Structure */
578  CsrThread = CsrAllocateThread(CsrProcess);
579  if (!CsrThread)
580  {
581  /* Failed */
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 */
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 */
616 
617  /* Insert the Process */
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 */
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;
739  CLIENT_ID ClientId = *Cid;
740  PLIST_ENTRY NextEntry;
741 
742  /* Acquire lock */
744 
745  /* Find the thread */
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 */
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);
877  {
878  /* Close the token and fail */
879  NtClose(hToken);
880  return Status;
881  }
882 
883  /* Allocate memory for the Token Info */
884  if (!(TokenStats = RtlAllocateHeap(CsrHeap, 0, Length)))
885  {
886  /* Fail and close the token */
887  NtClose(hToken);
888  return STATUS_NO_MEMORY;
889  }
890 
891  /* Now query the information */
894  TokenStats,
895  Length,
896  &Length);
897 
898  /* Close the handle */
899  NtClose(hToken);
900 
901  /* Check for success */
902  if (NT_SUCCESS(Status))
903  {
904  /* Return the LUID */
905  *Luid = TokenStats->AuthenticationId;
906  }
907 
908  /* Free the query information */
909  RtlFreeHeap(CsrHeap, 0, TokenStats);
910 
911  /* Return the Status */
912  return Status;
913 }
914 
915 /*++
916  * @name CsrImpersonateClient
917  * @implemented NT4
918  *
919  * The CsrImpersonateClient will impersonate the given CSR Thread.
920  *
921  * @param CsrThread
922  * Pointer to the CSR Thread to impersonate.
923  *
924  * @return TRUE if impersonation succeeded, FALSE otherwise.
925  *
926  * @remarks Impersonation can be recursive.
927  *
928  *--*/
929 BOOLEAN
930 NTAPI
932 {
934  PCSR_THREAD CurrentThread = CsrGetClientThread();
935 
936  /* Use the current thread if none given */
937  if (!CsrThread) CsrThread = CurrentThread;
938 
939  /* Still no thread, something is wrong */
940  if (!CsrThread)
941  {
942  /* Failure */
943  return FALSE;
944  }
945 
946  /* Make the call */
948  CsrThread->ThreadHandle,
949  &CsrSecurityQos);
950 
951  if (!NT_SUCCESS(Status))
952  {
953  /* Failure */
954 #ifdef CSR_DBG
955  DPRINT1("CSRSS: Can't impersonate client thread - Status = %lx\n", Status);
956  // if (Status != STATUS_BAD_IMPERSONATION_LEVEL) DbgBreakPoint();
957 #endif
958  return FALSE;
959  }
960 
961  /* Increase the impersonation count for the current thread */
962  if (CurrentThread) ++CurrentThread->ImpersonationCount;
963 
964  /* Return Success */
965  return TRUE;
966 }
967 
968 /*++
969  * @name CsrLockProcessByClientId
970  * @implemented NT4
971  *
972  * The CsrLockProcessByClientId routine locks the CSR Process corresponding
973  * to the given Process ID and optionally returns it.
974  *
975  * @param Pid
976  * Process ID corresponding to the CSR Process which will be locked.
977  *
978  * @param CsrProcess
979  * Optional pointer to a CSR Process pointer which will hold the
980  * CSR Process corresponding to the given Process ID.
981  *
982  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
983  *
984  * @remarks Locking a CSR Process is defined as acquiring an extra
985  * reference to it and returning with the Process Lock held.
986  *
987  *--*/
988 NTSTATUS
989 NTAPI
992 {
993  PLIST_ENTRY NextEntry;
996 
997  /* Acquire the lock */
999 
1000  /* Assume failure */
1001  ASSERT(CsrProcess != NULL);
1002  *CsrProcess = NULL;
1003 
1004  /* Setup the List Pointers */
1005  NextEntry = &CsrRootProcess->ListLink;
1006  do
1007  {
1008  /* Get the Process */
1009  CurrentProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1010 
1011  /* Check for PID Match */
1012  if (CurrentProcess->ClientId.UniqueProcess == Pid)
1013  {
1015  break;
1016  }
1017 
1018  /* Move to the next entry */
1019  NextEntry = NextEntry->Flink;
1020  } while (NextEntry != &CsrRootProcess->ListLink);
1021 
1022  /* Check if we didn't find it in the list */
1023  if (!NT_SUCCESS(Status))
1024  {
1025  /* Nothing found, release the lock */
1027  }
1028  else
1029  {
1030  /* Lock the found process and return it */
1033  }
1034 
1035  /* Return the result */
1036  return Status;
1037 }
1038 
1039 /*++
1040  * @name CsrRevertToSelf
1041  * @implemented NT4
1042  *
1043  * The CsrRevertToSelf routine will attempt to remove an active impersonation.
1044  *
1045  * @param None.
1046  *
1047  * @return TRUE if the reversion was succesful, FALSE otherwise.
1048  *
1049  * @remarks Impersonation can be recursive; as such, the impersonation token
1050  * will only be deleted once the CSR Thread's impersonaton count
1051  * has reached zero.
1052  *
1053  *--*/
1054 BOOLEAN
1055 NTAPI
1057 {
1058  NTSTATUS Status;
1059  PCSR_THREAD CurrentThread = CsrGetClientThread();
1060  HANDLE ImpersonationToken = NULL;
1061 
1062  /* Check if we have a Current Thread */
1063  if (CurrentThread)
1064  {
1065  /* Make sure impersonation is on */
1066  if (!CurrentThread->ImpersonationCount)
1067  {
1068  DPRINT1("CSRSS: CsrRevertToSelf called while not impersonating\n");
1069  // DbgBreakPoint();
1070  return FALSE;
1071  }
1072  else if ((--CurrentThread->ImpersonationCount) > 0)
1073  {
1074  /* Success; impersonation count decreased but still not zero */
1075  return TRUE;
1076  }
1077  }
1078 
1079  /* Impersonation has been totally removed, revert to ourselves */
1082  &ImpersonationToken,
1083  sizeof(ImpersonationToken));
1084 
1085  /* Return TRUE or FALSE */
1086  return NT_SUCCESS(Status);
1087 }
1088 
1089 /*++
1090  * @name CsrSetBackgroundPriority
1091  * @implemented NT4
1092  *
1093  * The CsrSetBackgroundPriority routine sets the priority for the given CSR
1094  * Process as a Background priority.
1095  *
1096  * @param CsrProcess
1097  * Pointer to the CSR Process whose priority will be modified.
1098  *
1099  * @return None.
1100  *
1101  * @remarks None.
1102  *
1103  *--*/
1104 VOID
1105 NTAPI
1107 {
1108  PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
1109 
1110  /* Set the Foreground bit off */
1111  ProcessPriority.Foreground = FALSE;
1112 
1113  /* Set the new priority */
1114  NtSetInformationProcess(CsrProcess->ProcessHandle,
1116  &ProcessPriority,
1117  sizeof(ProcessPriority));
1118 }
1119 
1120 /*++
1121  * @name CsrSetForegroundPriority
1122  * @implemented NT4
1123  *
1124  * The CsrSetForegroundPriority routine sets the priority for the given CSR
1125  * Process as a Foreground priority.
1126  *
1127  * @param CsrProcess
1128  * Pointer to the CSR Process whose priority will be modified.
1129  *
1130  * @return None.
1131  *
1132  * @remarks None.
1133  *
1134  *--*/
1135 VOID
1136 NTAPI
1138 {
1139  PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
1140 
1141  /* Set the Foreground bit on */
1142  ProcessPriority.Foreground = TRUE;
1143 
1144  /* Set the new priority */
1145  NtSetInformationProcess(CsrProcess->ProcessHandle,
1147  &ProcessPriority,
1148  sizeof(ProcessPriority));
1149 }
1150 
1151 /*++
1152  * @name FindProcessForShutdown
1153  *
1154  * The FindProcessForShutdown routine returns a CSR Process which is ready
1155  * to be shutdown, and sets the appropriate shutdown flags for it.
1156  *
1157  * @param CallerLuid
1158  * Pointer to the LUID of the CSR Process calling this routine.
1159  *
1160  * @return Pointer to a CSR Process which is ready to be shutdown.
1161  *
1162  * @remarks None.
1163  *
1164  *--*/
1166 NTAPI
1168 {
1169  PCSR_PROCESS CsrProcess, ReturnCsrProcess = NULL;
1170  PCSR_THREAD CsrThread;
1171  NTSTATUS Status;
1172  ULONG Level = 0;
1173  LUID ProcessLuid;
1174  LUID SystemLuid = SYSTEM_LUID;
1175  PLIST_ENTRY NextEntry;
1176 
1177  /* Set the List Pointers */
1178  NextEntry = CsrRootProcess->ListLink.Flink;
1179  while (NextEntry != &CsrRootProcess->ListLink)
1180  {
1181  /* Get the process */
1182  CsrProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1183 
1184  /* Move to the next entry */
1185  NextEntry = NextEntry->Flink;
1186 
1187  /* Skip this process if it's already been processed */
1188  if (CsrProcess->Flags & CsrProcessSkipShutdown) continue;
1189 
1190  /* Get the LUID of this process */
1191  Status = CsrGetProcessLuid(CsrProcess->ProcessHandle, &ProcessLuid);
1192 
1193  /* Check if we didn't get access to the LUID */
1195  {
1196  /* Check if we have any threads */
1197  if (CsrProcess->ThreadCount)
1198  {
1199  /* Impersonate one of the threads and retry */
1200  CsrThread = CONTAINING_RECORD(CsrProcess->ThreadList.Flink,
1201  CSR_THREAD,
1202  Link);
1203  if (CsrImpersonateClient(CsrThread))
1204  {
1205  Status = CsrGetProcessLuid(NULL, &ProcessLuid);
1206  CsrRevertToSelf();
1207  }
1208  else
1209  {
1211  }
1212  }
1213  }
1214 
1215  if (!NT_SUCCESS(Status))
1216  {
1217  /* We didn't have access, so skip it */
1219  continue;
1220  }
1221 
1222  /* Check if this is the System LUID */
1223  if (RtlEqualLuid(&ProcessLuid, &SystemLuid))
1224  {
1225  /* Mark this process */
1226  CsrProcess->ShutdownFlags |= CsrShutdownSystem;
1227  }
1228  else if (!RtlEqualLuid(&ProcessLuid, CallerLuid))
1229  {
1230  /* Our LUID doesn't match with the caller's */
1231  CsrProcess->ShutdownFlags |= CsrShutdownOther;
1232  }
1233 
1234  /* Check if we're past the previous level */
1235  if ((CsrProcess->ShutdownLevel > Level) || !ReturnCsrProcess)
1236  {
1237  /* Update the level */
1238  Level = CsrProcess->ShutdownLevel;
1239 
1240  /* Set the final process */
1241  ReturnCsrProcess = CsrProcess;
1242  }
1243  }
1244 
1245  /* Check if we found a process */
1246  if (ReturnCsrProcess)
1247  {
1248  /* Skip this one next time */
1249  ReturnCsrProcess->Flags |= CsrProcessSkipShutdown;
1250  }
1251 
1252  return ReturnCsrProcess;
1253 }
1254 
1255 /*++
1256  * @name CsrShutdownProcesses
1257  * @implemented NT4
1258  *
1259  * The CsrShutdownProcesses routine shuts down every CSR Process possible
1260  * and calls each Server DLL's shutdown notification.
1261  *
1262  * @param CallerLuid
1263  * Pointer to the LUID of the CSR Process that is ordering the
1264  * shutdown.
1265  *
1266  * @param Flags
1267  * Flags to send to the shutdown notification routine.
1268  *
1269  * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
1270  *
1271  * @remarks None.
1272  *
1273  *--*/
1274 NTSTATUS
1275 NTAPI
1277  IN ULONG Flags)
1278 {
1279  PLIST_ENTRY NextEntry;
1281  NTSTATUS Status;
1282  BOOLEAN FirstTry;
1283  ULONG i;
1284  PCSR_SERVER_DLL ServerDll;
1285  ULONG Result = 0;
1286 
1287  /* Acquire process lock */
1289 
1290  /* Add shutdown flag */
1292 
1293  /* Get the list pointers */
1294  NextEntry = CsrRootProcess->ListLink.Flink;
1295  while (NextEntry != &CsrRootProcess->ListLink)
1296  {
1297  /* Get the Process */
1298  CsrProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
1299 
1300  /* Move to the next entry */
1301  NextEntry = NextEntry->Flink;
1302 
1303  /* Remove the skip flag, set shutdown flags to 0 */
1305  CsrProcess->ShutdownFlags = 0;
1306  }
1307 
1308  /* Set shutdown Priority */
1310 
1311  /* Start looping */
1312  while (TRUE)
1313  {
1314  /* Find the next process to shutdown */
1315  CsrProcess = FindProcessForShutdown(CallerLuid);
1316  if (!CsrProcess) break;
1317 
1318  /* Increase reference to process */
1320 
1321  FirstTry = TRUE;
1322  while (TRUE)
1323  {
1324  /* Loop all the servers */
1325  for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
1326  {
1327  /* Get the current server */
1328  ServerDll = CsrLoadedServerDll[i];
1329 
1330  /* Check if it's valid and if it has a Shutdown Process Callback */
1331  if (ServerDll && ServerDll->ShutdownProcessCallback)
1332  {
1333  /* Release the lock, make the callback, and acquire it back */
1336  Flags,
1337  FirstTry);
1339 
1340  /* Check the result */
1342  {
1343  /* The callback unlocked the process */
1344  break;
1345  }
1346  else if (Result == CsrShutdownCancelled)
1347  {
1348 #ifdef CSR_DBG
1349  /* Check if this was a forced shutdown */
1350  if (Flags & EWX_FORCE)
1351  {
1352  DPRINT1("Process %x cancelled forced shutdown (Dll = %d)\n",
1353  CsrProcess->ClientId.UniqueProcess, i);
1354  DbgBreakPoint();
1355  }
1356 #endif
1357 
1358  /* Shutdown was cancelled, unlock and exit */
1361  goto Quickie;
1362  }
1363  }
1364  }
1365 
1366  /* No matches during the first try, so loop again */
1368  {
1369  FirstTry = FALSE;
1370  continue;
1371  }
1372 
1373  /* Second try, break out */
1374  break;
1375  }
1376 
1377  /* We've reached the final loop here, so dereference */
1378  if (i == CSR_SERVER_DLL_MAX)
1380  }
1381 
1382  /* Success path */
1385 
1386 Quickie:
1387  /* Return to normal priority */
1389 
1390  return Status;
1391 }
1392 
1393 /*++
1394  * @name CsrUnlockProcess
1395  * @implemented NT4
1396  *
1397  * The CsrUnlockProcess undoes a previous CsrLockProcessByClientId operation.
1398  *
1399  * @param CsrProcess
1400  * Pointer to a previously locked CSR Process.
1401  *
1402  * @return STATUS_SUCCESS.
1403  *
1404  * @remarks This routine must be called with the Process Lock held.
1405  *
1406  *--*/
1407 NTSTATUS
1408 NTAPI
1410 {
1411  /* Dereference the process */
1413 
1414  /* Release the lock and return */
1416  return STATUS_SUCCESS;
1417 }
1418 
1419 /* EOF */
LUID AuthenticationId
Definition: setypes.h:1033
NTSTATUS NTAPI NtImpersonateThread(IN HANDLE ThreadHandle, IN HANDLE ThreadToImpersonateHandle, IN PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService)
Definition: security.c:973
#define EWX_FORCE
Definition: winuser.h:630
#define IN
Definition: typedefs.h:39
#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 STATUS_BAD_IMPERSONATION_LEVEL
Definition: ntstatus.h:401
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
BOOLEAN NTAPI CsrRevertToSelf(VOID)
Definition: procsup.c:1056
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
#define TRUE
Definition: types.h:120
RTL_CRITICAL_SECTION CsrProcessLock
Definition: procsup.c:21
#define STATUS_THREAD_IS_TERMINATING
Definition: ntstatus.h:311
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:606
#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:990
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:350
PKPROCESS CsrProcess
Definition: videoprt.c:39
#define InsertTailList(ListHead, Entry)
ULONG CsrProcessSequenceCount
Definition: procsup.c:30
HANDLE UniqueProcess
Definition: compat.h:684
void DbgBreakPoint()
Definition: mach.c:553
#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:662
struct _CSR_PROCESS CSR_PROCESS
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
LIST_ENTRY CsrThreadHashTable[NUMBER_THREAD_HASH_BUCKETS]
Definition: thredsup.c:21
LONG LockCount
Definition: comsup.c:6
uint32_t ULONG_PTR
Definition: typedefs.h:65
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
PCSR_PROCESS Process
Definition: csrsrv.h:69
#define ProcessStructureListLocked()
Definition: api.h:18
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:931
VOID NTAPI CsrDeallocateThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:345
#define FALSE
Definition: types.h:117
#define RtlEqualLuid(Luid1, Luid2)
Definition: rtlfuncs.h:301
long LONG
Definition: pedump.c:60
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
HANDLE ProcessHandle
Definition: csrsrv.h:46
unsigned char BOOLEAN
_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:1834
_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:2018
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
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define NtCurrentProcess()
Definition: nt_native.h:1657
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
SECURITY_QUALITY_OF_SERVICE CsrSecurityQos
Definition: procsup.c:23
Status
Definition: gdiplustypes.h:24
LIST_ENTRY ListLink
Definition: csrsrv.h:39
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
ULONG CurrentProcess
Definition: shell.c:125
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163
BOOLEAN NTAPI ProtectHandle(IN HANDLE ObjectHandle)
Definition: thredsup.c:39
#define TOKEN_QUERY
Definition: setypes.h:874
#define ASSERT(a)
Definition: mode.c:45
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
LARGE_INTEGER CreateTime
Definition: winternl.h:1060
PCSR_PROCESS CsrRootProcess
Definition: procsup.c:22
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
VOID NTAPI CsrDeallocateProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:296
PVOID HANDLE
Definition: typedefs.h:73
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
PCSR_PROCESS NTAPI FindProcessForShutdown(IN PLUID CallerLuid)
Definition: procsup.c:1167
#define STATUS_NO_TOKEN
Definition: ntstatus.h:360
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2501
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
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define CsrAcquireProcessLock()
Definition: api.h:12
VOID NTAPI CsrSetBackgroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1106
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:119
NTSTATUS NTAPI CsrUnlockProcess(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1409
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_SHUTDOWNPROCESS_CALLBACK ShutdownProcessCallback
Definition: csrsrv.h:240
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:1107
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
struct _CSR_WAIT_BLOCK * WaitBlock
Definition: csrsrv.h:70
NTSTATUS NTAPI CsrShutdownProcesses(IN PLUID CallerLuid, IN ULONG Flags)
Definition: procsup.c:1276
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define SECURITY_STATIC_TRACKING
Definition: setypes.h:104
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:859
VOID NTAPI CsrSetToNormalPriority(VOID)
Definition: procsup.c:52
struct _SECURITY_QUALITY_OF_SERVICE SECURITY_QUALITY_OF_SERVICE
#define NULL
Definition: types.h:112
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
HANDLE hThread
Definition: wizard.c:27
VOID NTAPI CsrSetToShutdownPriority(VOID)
Definition: procsup.c:80
#define DPRINT1
Definition: precomp.h:8
KEXECUTE_OPTIONS Flags
Definition: ketypes.h:2062
NTSTATUS NTAPI NtOpenThreadToken(IN HANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN BOOLEAN OpenAsSelf, OUT PHANDLE TokenHandle)
Definition: token.c:3853
#define OUT
Definition: typedefs.h:40
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
#define STATUS_SUCCESS
Definition: shellext.h:65
HANDLE CsrHeap
Definition: init.c:25
VOID NTAPI CsrInsertProcess(IN PCSR_PROCESS ParentProcess OPTIONAL, IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:365
PCSR_NEWPROCESS_CALLBACK NewProcessCallback
Definition: csrsrv.h:239
ULONG CsrTotalPerProcessDataLength
Definition: init.c:35
#define CsrProcessPriorityFlags
Definition: csrsrv.h:97
#define __FUNCTION__
Definition: types.h:112
VOID NTAPI CsrSetForegroundPriority(IN PCSR_PROCESS CsrProcess)
Definition: procsup.c:1137
PCSR_SERVER_DLL CsrLoadedServerDll[CSR_SERVER_DLL_MAX]
Definition: server.c:20
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68