[ros-diffs] [ion] 55615: [CSRSRV]: Remove the CSRAPI Heap and just use the CSR Heap. In the future there will be separate DLLs each with their own heap, but now it's all one DLL. [CSRSRV]: Port CsrSbApiRequest...

Author: ion
Date: Wed Feb 15 19:53:31 2012
New Revision: 55615

URL: http://svn.reactos.org/svn/reactos?rev=55615&view=rev
Log:
[CSRSRV]: Remove the CSRAPI Heap and just use the CSR Heap. In the future there will be
separate DLLs each with their own heap, but now it's all one DLL.
[CSRSRV]: Port CsrSbApiRequestThread, CsrSbApiHandleConnectionRequest and all the Sb* APIs
from CSRSRV2. Comment out parts that can't work yet.
[CSRSRV]; Port CsrSbApiPortInitialize, CsrSetProcessSecurity, CsrCreateLocalSystemSD, and
almost all of CsrServerInitialization. Initialization is almost identical to CSRSRV2 now.
[CSRSRV]: Kill "Complete" routine support, nobody was using this.

Modified:
    trunk/reactos/subsystems/win32/csrss/csrsrv/api/process.c
    trunk/reactos/subsystems/win32/csrss/csrsrv/api/wapi.c
    trunk/reactos/subsystems/win32/csrss/csrsrv/init.c
    trunk/reactos/subsystems/win32/csrss/include/api.h
    trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c

Modified: trunk/reactos/subsystems/win32/csrss/csrsrv/api/process.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/csr…
==============================================================================
--- trunk/reactos/subsystems/win32/csrss/csrsrv/api/process.c [iso-8859-1] (original)
+++ trunk/reactos/subsystems/win32/csrss/csrsrv/api/process.c [iso-8859-1] Wed Feb 15
19:53:31 2012
@@ -83,7 +83,7 @@
    }
    if (pProcessData == NULL)
    {
-      pProcessData = RtlAllocateHeap(CsrssApiHeap,
+      pProcessData = RtlAllocateHeap(CsrHeap,
 	                             HEAP_ZERO_MEMORY,
 				     sizeof(CSRSS_PROCESS_DATA));
       if (pProcessData)
@@ -109,7 +109,7 @@
          if (!NT_SUCCESS(Status))
          {
             ProcessData[hash] = pProcessData->next;
-	    RtlFreeHeap(CsrssApiHeap, 0, pProcessData);
+	    RtlFreeHeap(CsrHeap, 0, pProcessData);
 	    pProcessData = NULL;
          }
          else
@@ -187,7 +187,7 @@
 
       *pPrevLink = pProcessData->next;
 
-      RtlFreeHeap(CsrssApiHeap, 0, pProcessData);
+      RtlFreeHeap(CsrHeap, 0, pProcessData);
       UNLOCK;
       if (Process)
         {

Modified: trunk/reactos/subsystems/win32/csrss/csrsrv/api/wapi.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/csr…
==============================================================================
--- trunk/reactos/subsystems/win32/csrss/csrsrv/api/wapi.c [iso-8859-1] (original)
+++ trunk/reactos/subsystems/win32/csrss/csrsrv/api/wapi.c [iso-8859-1] Wed Feb 15
19:53:31 2012
@@ -19,10 +19,17 @@
 
 extern HANDLE hApiPort;
 
-HANDLE CsrssApiHeap = (HANDLE) 0;
-
 static unsigned ApiDefinitionsCount = 0;
 static PCSRSS_API_DEFINITION ApiDefinitions = NULL;
+
+PCHAR CsrServerSbApiName[5] =
+{
+    "SbCreateSession",
+    "SbTerminateSession",
+    "SbForeignSessionComplete",
+    "SbCreateProcess",
+    "Unknown Csr Sb Api Number"
+};
 
 /* FUNCTIONS *****************************************************************/
 
@@ -41,7 +48,7 @@
       NewCount++;
     }
 
-  New = RtlAllocateHeap(CsrssApiHeap, 0,
+  New = RtlAllocateHeap(CsrHeap, 0,
                         (ApiDefinitionsCount + NewCount)
                         * sizeof(CSRSS_API_DEFINITION));
   if (NULL == New)
@@ -53,7 +60,7 @@
     {
       RtlCopyMemory(New, ApiDefinitions,
                     ApiDefinitionsCount * sizeof(CSRSS_API_DEFINITION));
-      RtlFreeHeap(CsrssApiHeap, 0, ApiDefinitions);
+      RtlFreeHeap(CsrHeap, 0, ApiDefinitions);
     }
   RtlCopyMemory(New + ApiDefinitionsCount, NewDefinitions,
                 NewCount * sizeof(CSRSS_API_DEFINITION));
@@ -180,7 +187,6 @@
 
     /* Multiply by 1024 entries and round to page size */
     CsrSrvSharedSectionSize = ROUND_UP(Size * 1024, CsrNtSysInfo.PageSize);
-    DPRINT1("Size: %lx\n", CsrSrvSharedSectionSize);
 
     /* Create the Secion */
     SectionSize.LowPart = CsrSrvSharedSectionSize;
@@ -980,115 +986,391 @@
     RtlExitUserThread(STATUS_SUCCESS);
 }
 
-/**********************************************************************
- * NAME
- *	ServerSbApiPortThread/1
- *
- * DESCRIPTION
- * 	Handle connection requests from SM to the port
- * 	"\Windows\SbApiPort". We will accept only one
- * 	connection request (from the SM).
- */
-DWORD WINAPI
-ServerSbApiPortThread (HANDLE hSbApiPortListen)
-{
-    HANDLE          hConnectedPort = (HANDLE) 0;
-    SB_API_MSG    Request;
-    PVOID           Context = NULL;
-    NTSTATUS        Status = STATUS_SUCCESS;
-    PPORT_MESSAGE Reply = NULL;
-
-    DPRINT("CSR: %s called\n", __FUNCTION__);
-
-    RtlZeroMemory(&Request, sizeof(PORT_MESSAGE));
-    Status = NtListenPort (hSbApiPortListen, & Request.h);
-
+/* SESSION MANAGER FUNCTIONS**************************************************/
+
+/*++
+ * @name CsrSbCreateSession
+ *
+ * The CsrSbCreateSession API is called by the Session Manager whenever a new
+ * session is created.
+ *
+ * @param ApiMessage
+ *        Pointer to the Session Manager API Message.
+ *
+ * @return TRUE in case of success, FALSE othwerwise.
+ *
+ * @remarks The CsrSbCreateSession routine will initialize a new CSR NT
+ *          Session and allocate a new CSR Process for the subsystem process.
+ *
+ *--*/
+BOOLEAN
+NTAPI
+CsrSbCreateSession(IN PSB_API_MSG ApiMessage)
+{
+    PSB_CREATE_SESSION_MSG CreateSession = &ApiMessage->CreateSession;
+    HANDLE hProcess, hThread;
+//    PCSR_PROCESS CsrProcess;
+    NTSTATUS Status;
+    KERNEL_USER_TIMES KernelTimes;
+    //PCSR_THREAD CsrThread;
+    //PVOID ProcessData;
+    //ULONG i;
+
+    /* Save the Process and Thread Handles */
+    hProcess = CreateSession->ProcessInfo.ProcessHandle;
+    hThread = CreateSession->ProcessInfo.ThreadHandle;
+
+#if 0
+    /* Lock the Processes */
+    CsrAcquireProcessLock();
+
+    /* Allocate a new process */
+    CsrProcess = CsrAllocateProcess();
+    if (!CsrProcess)
+    {
+        /* Fail */
+        ApiMessage->ReturnValue = STATUS_NO_MEMORY;
+        CsrReleaseProcessLock();
+        return TRUE;
+    }
+#endif
+
+    /* Set the exception port */
+    Status = NtSetInformationProcess(hProcess,
+                                     ProcessExceptionPort,
+                                     &hApiPort,//&CsrApiPort,
+                                     sizeof(HANDLE));
+
+    /* Check for success */
     if (!NT_SUCCESS(Status))
     {
-        DPRINT1("CSR: %s: NtListenPort(SB) failed (Status=0x%08lx)\n",
-                __FUNCTION__, Status);
-    } else {
-        DPRINT("-- 1\n");
-        Status = NtAcceptConnectPort(&hConnectedPort,
-                                     NULL,
-                                     &Request.h,
-                                     TRUE,
-                                     NULL,
-                                     NULL);
-        if(!NT_SUCCESS(Status))
-        {
-            DPRINT1("CSR: %s: NtAcceptConnectPort() failed
(Status=0x%08lx)\n",
-                    __FUNCTION__, Status);
-        } else {
-            DPRINT("-- 2\n");
-            Status = NtCompleteConnectPort (hConnectedPort);
-            if(!NT_SUCCESS(Status))
+        /* Fail the request */
+#if 0
+        CsrDeallocateProcess(CsrProcess);
+        CsrReleaseProcessLock();
+#endif
+        /* Strange as it seems, NTSTATUSes are actually returned */
+        return (BOOLEAN)STATUS_NO_MEMORY;
+    }
+
+    /* Get the Create Time */
+    Status = NtQueryInformationThread(hThread,
+                                      ThreadTimes,
+                                      &KernelTimes,
+                                      sizeof(KERNEL_USER_TIMES),
+                                      NULL);
+
+    /* Check for success */
+    if (!NT_SUCCESS(Status))
+    {
+        /* Fail the request */
+#if 0
+        CsrDeallocateProcess(CsrProcess);
+        CsrReleaseProcessLock();
+#endif
+
+        /* Strange as it seems, NTSTATUSes are actually returned */
+        return (BOOLEAN)Status;
+    }
+
+    /* Allocate a new Thread */
+#if 0
+    CsrThread = CsrAllocateThread(CsrProcess);
+    if (!CsrThread)
+    {
+        /* Fail the request */
+        CsrDeallocateProcess(CsrProcess);
+        CsrReleaseProcessLock();
+
+        ApiMessage->ReturnValue = STATUS_NO_MEMORY;
+        return TRUE;
+    }
+
+    /* Setup the Thread Object */
+    CsrThread->CreateTime = KernelTimes.CreateTime;
+    CsrThread->ClientId = CreateSession->ProcessInfo.ClientId;
+    CsrThread->ThreadHandle = hThread;
+    ProtectHandle(hThread);
+    CsrThread->Flags = 0;
+
+    /* Insert it into the Process List */
+    CsrInsertThread(CsrProcess, CsrThread);
+
+    /* Setup Process Data */
+    CsrProcess->ClientId = CreateSession->ProcessInfo.ClientId;
+    CsrProcess->ProcessHandle = hProcess;
+    CsrProcess->NtSession = CsrAllocateNtSession(CreateSession->SessionId);
+
+    /* Set the Process Priority */
+    CsrSetBackgroundPriority(CsrProcess);
+
+    /* Get the first data location */
+    ProcessData = &CsrProcess->ServerData[CSR_SERVER_DLL_MAX];
+
+    /* Loop every DLL */
+    for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
+    {
+        /* Check if the DLL is loaded and has Process Data */
+        if (CsrLoadedServerDll[i] &&
CsrLoadedServerDll[i]->SizeOfProcessData)
+        {
+            /* Write the pointer to the data */
+            CsrProcess->ServerData[i] = ProcessData;
+
+            /* Move to the next data location */
+            ProcessData = (PVOID)((ULONG_PTR)ProcessData +
+                                  CsrLoadedServerDll[i]->SizeOfProcessData);
+        }
+        else
+        {
+            /* Nothing for this Process */
+            CsrProcess->ServerData[i] = NULL;
+        }
+    }
+
+    /* Insert the Process */
+    CsrInsertProcess(NULL, NULL, CsrProcess);
+#endif
+    /* Activate the Thread */
+    ApiMessage->ReturnValue = NtResumeThread(hThread, NULL);
+
+    /* Release lock and return */
+//    CsrReleaseProcessLock();
+    return TRUE;
+}
+
+/*++
+ * @name CsrSbForeignSessionComplete
+ *
+ * The CsrSbForeignSessionComplete API is called by the Session Manager
+ * whenever a foreign session is completed (ie: terminated).
+ *
+ * @param ApiMessage
+ *        Pointer to the Session Manager API Message.
+ *
+ * @return TRUE in case of success, FALSE othwerwise.
+ *
+ * @remarks The CsrSbForeignSessionComplete API is not yet implemented.
+ *
+ *--*/
+BOOLEAN
+NTAPI
+CsrSbForeignSessionComplete(IN PSB_API_MSG ApiMessage)
+{
+    /* Deprecated/Unimplemented in NT */
+    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
+    return TRUE;
+}
+
+/*++
+ * @name CsrSbTerminateSession
+ *
+ * The CsrSbTerminateSession API is called by the Session Manager
+ * whenever a foreign session should be destroyed.
+ *
+ * @param ApiMessage
+ *        Pointer to the Session Manager API Message.
+ *
+ * @return TRUE in case of success, FALSE othwerwise.
+ *
+ * @remarks The CsrSbTerminateSession API is not yet implemented.
+ *
+ *--*/
+BOOLEAN
+NTAPI
+CsrSbTerminateSession(IN PSB_API_MSG ApiMessage)
+{
+    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
+    return TRUE;
+}
+
+/*++
+ * @name CsrSbCreateProcess
+ *
+ * The CsrSbCreateProcess API is called by the Session Manager
+ * whenever a foreign session is created and a new process should be started.
+ *
+ * @param ApiMessage
+ *        Pointer to the Session Manager API Message.
+ *
+ * @return TRUE in case of success, FALSE othwerwise.
+ *
+ * @remarks The CsrSbCreateProcess API is not yet implemented.
+ *
+ *--*/
+BOOLEAN
+NTAPI
+CsrSbCreateProcess(IN PSB_API_MSG ApiMessage)
+{
+    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
+    return TRUE;
+}
+
+PSB_API_ROUTINE CsrServerSbApiDispatch[5] =
+{
+    CsrSbCreateSession,
+    CsrSbTerminateSession,
+    CsrSbForeignSessionComplete,
+    CsrSbCreateProcess,
+    NULL
+};
+
+/*++
+ * @name CsrSbApiHandleConnectionRequest
+ *
+ * The CsrSbApiHandleConnectionRequest routine handles and accepts a new
+ * connection request to the SM API LPC Port.
+ *
+ * @param ApiMessage
+ *        Pointer to the incoming CSR API Message which contains the
+ *        connection request.
+ *
+ * @return STATUS_SUCCESS in case of success, or status code which caused
+ *         the routine to error.
+ *
+ * @remarks None.
+ *
+ *--*/
+NTSTATUS
+NTAPI
+CsrSbApiHandleConnectionRequest(IN PSB_API_MSG Message)
+{
+    NTSTATUS Status;
+    REMOTE_PORT_VIEW RemotePortView;
+    HANDLE hPort;
+
+    /* Set the Port View Structure Length */
+    RemotePortView.Length = sizeof(REMOTE_PORT_VIEW);
+
+    /* Accept the connection */
+    Status = NtAcceptConnectPort(&hPort,
+                                 NULL,
+                                 (PPORT_MESSAGE)Message,
+                                 TRUE,
+                                 NULL,
+                                 &RemotePortView);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: Sb Accept Connection failed %lx\n", Status);
+        return Status;
+    }
+
+    /* Complete the Connection */
+    Status = NtCompleteConnectPort(hPort);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: Sb Complete Connection failed %lx\n",Status);
+    }
+
+    /* Return status */
+    return Status;
+}
+
+/*++
+ * @name CsrSbApiRequestThread
+ *
+ * The CsrSbApiRequestThread routine handles incoming messages or connection
+ * requests on the SM API LPC Port.
+ *
+ * @param Parameter
+ *        System-default user-defined parameter. Unused.
+ *
+ * @return The thread exit code, if the thread is terminated.
+ *
+ * @remarks Before listening on the port, the routine will first attempt
+ *          to connect to the user subsystem.
+ *
+ *--*/
+VOID
+NTAPI
+CsrSbApiRequestThread(IN PVOID Parameter)
+{
+    NTSTATUS Status;
+    SB_API_MSG ReceiveMsg;
+    PSB_API_MSG ReplyMsg = NULL;
+    PVOID PortContext;
+    ULONG MessageType;
+
+    /* Start the loop */
+    while (TRUE)
+    {
+        /* Wait for a message to come in */
+        Status = NtReplyWaitReceivePort(CsrSbApiPort,
+                                        &PortContext,
+                                        &ReplyMsg->h,
+                                        &ReceiveMsg.h);
+
+        /* Check if we didn't get success */
+        if (Status != STATUS_SUCCESS)
+        {
+            /* If we only got a warning, keep going */
+            if (NT_SUCCESS(Status)) continue;
+
+            /* We failed big time, so start out fresh */
+            ReplyMsg = NULL;
+            DPRINT1("CSRSS: ReceivePort failed - Status == %X\n", Status);
+            continue;
+        }
+
+        /* Save the message type */
+        MessageType = ReceiveMsg.h.u2.s2.Type;
+
+        /* Check if this is a connection request */
+        if (MessageType == LPC_CONNECTION_REQUEST)
+        {
+            /* Handle connection request */
+            CsrSbApiHandleConnectionRequest(&ReceiveMsg);
+
+            /* Start over */
+            ReplyMsg = NULL;
+            continue;
+        }
+
+        /* Check if the port died */
+        if (MessageType == LPC_PORT_CLOSED)
+        {
+            /* Close the handle if we have one */
+            if (PortContext) NtClose((HANDLE)PortContext);
+
+            /* Client died, start over */
+            ReplyMsg = NULL;
+            continue;
+        }
+        else if (MessageType == LPC_CLIENT_DIED)
+        {
+            /* Client died, start over */
+            ReplyMsg = NULL;
+            continue;
+        }
+
+        /*
+         * It's an API Message, check if it's within limits. If it's not,
the
+         * NT Behaviour is to set this to the Maximum API.
+         */
+        if (ReceiveMsg.ApiNumber > SbpMaxApiNumber)
+        {
+            ReceiveMsg.ApiNumber = SbpMaxApiNumber;
+            DPRINT1("CSRSS: %lx is invalid Sb ApiNumber\n",
ReceiveMsg.ApiNumber);
+         }
+
+        /* Reuse the message */
+        ReplyMsg = &ReceiveMsg;
+
+        /* Make sure that the message is supported */
+        if (ReceiveMsg.ApiNumber < SbpMaxApiNumber)
+        {
+            /* Call the API */
+            if (!CsrServerSbApiDispatch[ReceiveMsg.ApiNumber](&ReceiveMsg))
             {
-                DPRINT1("CSR: %s: NtCompleteConnectPort() failed
(Status=0x%08lx)\n",
-                        __FUNCTION__, Status);
-            } else {
-                DPRINT("-- 3\n");
-                /*
-                 * Tell the init thread the SM gave the
-                 * green light for boostrapping.
-                 */
-                Status = NtSetEvent (hBootstrapOk, NULL);
-                if(!NT_SUCCESS(Status))
-                {
-                    DPRINT1("CSR: %s: NtSetEvent failed (Status=0x%08lx)\n",
-                            __FUNCTION__, Status);
-                }
-                /* Wait for messages from the SM */
-                DPRINT("-- 4\n");
-                while (TRUE)
-                {
-                    Status = NtReplyWaitReceivePort(hConnectedPort,
-                                                    Context,
-                                                    Reply,
-                                                    &Request.h);
-                    if(!NT_SUCCESS(Status))
-                    {
-                        DPRINT1("CSR: %s: NtReplyWaitReceivePort failed
(Status=0x%08lx)\n",
-                                __FUNCTION__, Status);
-                        break;
-                    }
-
-                    switch (Request.h.u2.s2.Type) //fix .h PORT_MESSAGE_TYPE(Request))
-                    {
-                        /* TODO */
-                        case LPC_PORT_CLOSED:
-                        case LPC_CLIENT_DIED:
-                            DPRINT1("CSR: SMSS died\n");
-                            Reply = NULL;
-                            break;
-
-                        default:
-                        DPRINT1("CSR: %s received message (type=%d)\n",
-                                __FUNCTION__, Request.h.u2.s2.Type);
-
-                        if (Request.ApiNumber == SbpCreateSession)
-                        {
-                            DPRINT("Session create... legacy CSRSS resuming thread
as minimum work done\n");
-                            Request.ReturnValue =
NtResumeThread(Request.CreateSession.ProcessInfo.ThreadHandle, NULL);
-                        }
-                        else
-                        {
-                            DPRINT1("CSR: %d Not implemented in legacy CSRSS...
faking success\n", Request.ApiNumber);
-                            Request.ReturnValue = STATUS_SUCCESS;
-                        }
-                        Reply = &Request.h;
-                    }
-                    DPRINT("-- 5\n");
-                }
+                /* It failed, so return nothing */
+                ReplyMsg = NULL;
             }
         }
-    }
-
-    DPRINT("CSR: %s: terminating!\n", __FUNCTION__);
-    if(hConnectedPort) NtClose (hConnectedPort);
-    NtClose (hSbApiPortListen);
-    NtTerminateThread (NtCurrentThread(), Status);
-    return 0;
+        else
+        {
+            /* We don't support this API Number */
+            ReplyMsg->ReturnValue = STATUS_NOT_IMPLEMENTED;
+        }
+    }
 }
 
 /* EOF */

Modified: trunk/reactos/subsystems/win32/csrss/csrsrv/init.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/csr…
==============================================================================
--- trunk/reactos/subsystems/win32/csrss/csrsrv/init.c [iso-8859-1] (original)
+++ trunk/reactos/subsystems/win32/csrss/csrsrv/init.c [iso-8859-1] Wed Feb 15 19:53:31
2012
@@ -17,12 +17,13 @@
 HANDLE CsrHeap = (HANDLE) 0;
 HANDLE CsrObjectDirectory = (HANDLE) 0;
 UNICODE_STRING CsrDirectoryName;
-extern HANDLE CsrssApiHeap;
+UNICODE_STRING CsrSbApiPortName;
+HANDLE CsrSbApiPort = 0;
+PCSR_THREAD CsrSbApiRequestThreadPtr;
 static unsigned ServerProcCount;
 static CSRPLUGIN_SERVER_PROCS *ServerProcs = NULL;
+HANDLE CsrSmApiPort;
 HANDLE hSbApiPort = (HANDLE) 0;
-HANDLE hBootstrapOk = (HANDLE) 0;
-HANDLE hSmApiPort = (HANDLE) 0;
 HANDLE hApiPort = (HANDLE) 0;
 ULONG CsrDebug = 0xFFFFFFFF;
 ULONG CsrMaxApiRequestThreads;
@@ -31,6 +32,8 @@
 HANDLE BNOLinksDirectory;
 HANDLE SessionObjectDirectory;
 HANDLE DosDevicesDirectory;
+HANDLE CsrInitializationEvent;
+SYSTEM_BASIC_INFORMATION CsrNtSysInfo;
 
 /* PRIVATE FUNCTIONS **********************************************************/
 
@@ -41,7 +44,7 @@
 
   DPRINT("CSR: %s called\n", __FUNCTION__);
 
-  NewProcs = RtlAllocateHeap(CsrssApiHeap, 0,
+  NewProcs = RtlAllocateHeap(CsrHeap, 0,
                              (ServerProcCount + 1)
                              * sizeof(CSRPLUGIN_SERVER_PROCS));
   if (NULL == NewProcs)
@@ -52,33 +55,13 @@
     {
       RtlCopyMemory(NewProcs, ServerProcs,
                     ServerProcCount * sizeof(CSRPLUGIN_SERVER_PROCS));
-      RtlFreeHeap(CsrssApiHeap, 0, ServerProcs);
+      RtlFreeHeap(CsrHeap, 0, ServerProcs);
     }
   NewProcs[ServerProcCount] = *Procs;
   ServerProcs = NewProcs;
   ServerProcCount++;
 
   return STATUS_SUCCESS;
-}
-
-/**********************************************************************
- * CallInitComplete/0
- */
-static BOOL FASTCALL
-CallInitComplete(void)
-{
-  BOOL Ok;
-  unsigned i;
-
-  DPRINT("CSR: %s called\n", __FUNCTION__);
-
-  Ok = TRUE;
-  for (i = 0; i < ServerProcCount && Ok; i++)
-    {
-      Ok = (*ServerProcs[i].InitCompleteProc)();
-    }
-
-  return Ok;
 }
 
 BOOL
@@ -167,7 +150,7 @@
       return Status;
     }
   Exports.CsrEnumProcessesProc = CsrEnumProcesses;
-  if (! (*InitProc)(&ApiDefinitions, &ServerProcs, &Exports, CsrssApiHeap))
+  if (! (*InitProc)(&ApiDefinitions, &ServerProcs, &Exports, CsrHeap))
     {
       return STATUS_UNSUCCESSFUL;
     }
@@ -233,12 +216,12 @@
                                *Port,
                                &ServerThread,
                                &ClientId);
-    
+
     if (ListenThread == (PVOID)ClientConnectionThread)
     {
         CsrAddStaticServerThread(ServerThread, &ClientId, 0);
     }
-    
+
     NtResumeThread(ServerThread, NULL);
     NtClose(ServerThread);
 	return Status;
@@ -254,94 +237,118 @@
 NTAPI
 CsrSrvCreateSharedSection(IN PCHAR ParameterValue);
 
-/**********************************************************************
- * CsrpCreateHeap/3
- */
-static NTSTATUS
-CsrpCreateHeap (VOID)
-{
-	DPRINT("CSR: %s called\n", __FUNCTION__);
-
-    CsrHeap = RtlGetProcessHeap();
-	CsrssApiHeap = RtlCreateHeap(HEAP_GROWABLE,
-        	                       NULL,
-                	               65536,
-                        	       65536,
-	                               NULL,
-        	                       NULL);
-	if (CsrssApiHeap == NULL)
-	{
-		return STATUS_UNSUCCESSFUL;
-	}
-    
-	return STATUS_SUCCESS;
-}
-
-/**********************************************************************
- * CsrpRegisterSubsystem/3
- */
-BOOLEAN g_ModernSm;
-static NTSTATUS
-CsrpRegisterSubsystem (VOID)
-{
-	NTSTATUS           Status = STATUS_SUCCESS;
-	OBJECT_ATTRIBUTES  BootstrapOkAttributes;
-	UNICODE_STRING     Name;
-
-	DPRINT("CSR: %s called\n", __FUNCTION__);
-
-	/*
-	 * Create the event object the callback port
-	 * thread will signal *if* the SM will
-	 * authorize us to bootstrap.
-	 */
-	RtlInitUnicodeString (& Name, L"\\CsrssBooting");
-	InitializeObjectAttributes(& BootstrapOkAttributes,
-				   & Name,
-				   0, NULL, NULL);
-	Status = NtCreateEvent (& hBootstrapOk,
-				EVENT_ALL_ACCESS,
-				& BootstrapOkAttributes,
-				SynchronizationEvent,
-				FALSE);
-	if(!NT_SUCCESS(Status))
-	{
-		DPRINT("CSR: %s: NtCreateEvent failed (Status=0x%08lx)\n",
-			__FUNCTION__, Status);
-		return Status;
-	}
-	/*
-	 * Let's tell the SM a new environment
-	 * subsystem server is in the system.
-	 */
-	RtlInitUnicodeString (& Name, L"\\Windows\\SbApiPort");
-	DPRINT("CSR: %s: registering with SM for\n  IMAGE_SUBSYSTEM_WINDOWS_CUI ==
3\n", __FUNCTION__);
-	Status = SmConnectApiPort (& Name,
-				   hSbApiPort,
-				   IMAGE_SUBSYSTEM_WINDOWS_CUI,
-				   & hSmApiPort);
-    if (!NT_SUCCESS(Status))
-    {
-        Status = SmConnectToSm(&Name, hSbApiPort, IMAGE_SUBSYSTEM_WINDOWS_GUI,
&hSmApiPort);
-        g_ModernSm = TRUE;
-    }
-	if(!NT_SUCCESS(Status))
-	{
-		DPRINT("CSR: %s unable to connect to the SM (Status=0x%08lx)\n",
-			__FUNCTION__, Status);
-		NtClose (hBootstrapOk);
-		return Status;
-	}
-	/*
-	 *  Wait for SM to reply OK... If the SM
-	 *  won't answer, we hang here forever!
-	 */
-	DPRINT("CSR: %s: waiting for SM to OK boot...\n", __FUNCTION__);
-	Status = NtWaitForSingleObject (hBootstrapOk,
-					FALSE,
-					NULL);
-	NtClose (hBootstrapOk);
-	return Status;
+/*++
+ * @name CsrSetProcessSecurity
+ *
+ * The CsrSetProcessSecurity routine protects access to the CSRSS process
+ * from unauthorized tampering.
+ *
+ * @param None.
+ *
+ * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
+ *         othwerwise.
+ *
+ * @remarks None.
+ *
+ *--*/
+NTSTATUS
+NTAPI
+CsrSetProcessSecurity(VOID)
+{
+    NTSTATUS Status;
+    HANDLE hToken, hProcess = NtCurrentProcess();
+    ULONG Length;
+    PTOKEN_USER TokenInfo = NULL;
+    PSECURITY_DESCRIPTOR ProcSd = NULL;
+    PACL Dacl;
+    PSID UserSid;
+
+    /* Open our token */
+    Status = NtOpenProcessToken(hProcess, TOKEN_QUERY, &hToken);
+    if (!NT_SUCCESS(Status)) goto Quickie;
+
+    /* Get the Token User Length */
+    NtQueryInformationToken(hToken, TokenUser, NULL, 0, &Length);
+
+    /* Allocate space for it */
+    TokenInfo = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, Length);
+    if (!TokenInfo)
+    {
+        Status = STATUS_NO_MEMORY;
+        goto Quickie;
+    }
+
+    /* Now query the data */
+    Status = NtQueryInformationToken(hToken, TokenUser, TokenInfo, Length, &Length);
+    NtClose(hToken);
+    if (!NT_SUCCESS(Status)) goto Quickie;
+
+    /* Now check the SID Length */
+    UserSid = TokenInfo->User.Sid;
+    Length = RtlLengthSid(UserSid) + sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE);
+
+    /* Allocate a buffer for the Security Descriptor, with SID and DACL */
+    ProcSd = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, SECURITY_DESCRIPTOR_MIN_LENGTH +
Length);
+    if (!ProcSd)
+    {
+        Status = STATUS_NO_MEMORY;
+        goto Quickie;
+    }
+
+    /* Set the pointer to the DACL */
+    Dacl = (PACL)((ULONG_PTR)ProcSd + SECURITY_DESCRIPTOR_MIN_LENGTH);
+
+    /* Now create the SD itself */
+    Status = RtlCreateSecurityDescriptor(ProcSd, SECURITY_DESCRIPTOR_REVISION);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: SD creation failed - status = %lx\n", Status);
+        goto Quickie;
+    }
+
+    /* Create the DACL for it*/
+    Status = RtlCreateAcl(Dacl, Length, ACL_REVISION2);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: DACL creation failed - status = %lx\n", Status);
+        goto Quickie;
+    }
+
+    /* Create the ACE */
+    Status = RtlAddAccessAllowedAce(Dacl,
+                                    ACL_REVISION,
+                                    PROCESS_VM_READ | PROCESS_VM_WRITE |
+                                    PROCESS_VM_OPERATION | PROCESS_DUP_HANDLE |
+                                    PROCESS_TERMINATE | PROCESS_SUSPEND_RESUME |
+                                    PROCESS_QUERY_INFORMATION | READ_CONTROL,
+                                    UserSid);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: ACE creation failed - status = %lx\n", Status);
+        goto Quickie;
+    }
+
+    /* Clear the DACL in the SD */
+    Status = RtlSetDaclSecurityDescriptor(ProcSd, TRUE, Dacl, FALSE);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: set DACL failed - status = %lx\n", Status);
+        goto Quickie;
+    }
+
+    /* Write the SD into the Process */
+    Status = NtSetSecurityObject(hProcess, DACL_SECURITY_INFORMATION, ProcSd);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSS: set process DACL failed - status = %lx\n", Status);
+        goto Quickie;
+    }
+
+    /* Free the memory and return */
+Quickie:
+    if (ProcSd) RtlFreeHeap(CsrHeap, 0, ProcSd);
+    RtlFreeHeap(CsrHeap, 0, TokenInfo);
+    return Status;
 }
 
 /*++
@@ -764,11 +771,9 @@
     {
         /* Split Name and Value */
         ParameterName = Arguments[i];
-        DPRINT1("Name: %s\n", ParameterName);
         ParameterValue = NULL;
         ParameterValue = strchr(ParameterName, '=');
         if (ParameterValue) *ParameterValue++ = ANSI_NULL;
-        DPRINT1("Name=%s, Value=%s\n", ParameterName, ParameterValue);
 
         /* Check for Object Directory */
         if (!_stricmp(ParameterName, "ObjectDirectory"))
@@ -898,21 +903,218 @@
     return Status;
 }
 
-/* PUBLIC FUNCTIONS ***********************************************************/
-
+/*++
+ * @name CsrCreateLocalSystemSD
+ *
+ * The CsrCreateLocalSystemSD routine creates a Security Descriptor for
+ * the local account with PORT_ALL_ACCESS.
+ *
+ * @param LocalSystemSd
+ *        Pointer to a pointer to the security descriptor to create.
+ *
+ * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
+ *         othwerwise.
+ *
+ * @remarks None.
+ *
+ *--*/
 NTSTATUS
 NTAPI
-CsrServerInitialization(ULONG ArgumentCount,
-                        PCHAR Arguments[])
-{
-	NTSTATUS  Status = STATUS_SUCCESS;
-
-	DPRINT("CSR: %s called\n", __FUNCTION__);
-
-    Status = CsrpCreateHeap();
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpCreateHeap", Status);
+CsrCreateLocalSystemSD(OUT PSECURITY_DESCRIPTOR *LocalSystemSd)
+{
+    SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY};
+    PSID SystemSid;
+    ULONG Length;
+    PSECURITY_DESCRIPTOR SystemSd;
+    PACL Dacl;
+    NTSTATUS Status;
+
+    /* Initialize the System SID */
+    RtlAllocateAndInitializeSid(&NtSidAuthority, 1,
+                                SECURITY_LOCAL_SYSTEM_RID,
+                                0, 0, 0, 0, 0, 0, 0,
+                                &SystemSid);
+
+    /* Get the length of the SID */
+    Length = RtlLengthSid(SystemSid) + sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE);
+
+    /* Allocate a buffer for the Security Descriptor, with SID and DACL */
+    SystemSd = RtlAllocateHeap(CsrHeap, 0, SECURITY_DESCRIPTOR_MIN_LENGTH + Length);
+
+    /* Set the pointer to the DACL */
+    Dacl = (PACL)((ULONG_PTR)SystemSd + SECURITY_DESCRIPTOR_MIN_LENGTH);
+
+    /* Now create the SD itself */
+    Status = RtlCreateSecurityDescriptor(SystemSd, SECURITY_DESCRIPTOR_REVISION);
+    if (!NT_SUCCESS(Status))
+    {
+        /* Fail */
+        RtlFreeHeap(CsrHeap, 0, SystemSd);
+        return Status;
+    }
+
+    /* Create the DACL for it*/
+    RtlCreateAcl(Dacl, Length, ACL_REVISION2);
+
+    /* Create the ACE */
+    Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, PORT_ALL_ACCESS, SystemSid);
+    if (!NT_SUCCESS(Status))
+    {
+        /* Fail */
+        RtlFreeHeap(CsrHeap, 0, SystemSd);
+        return Status;
+    }
+
+    /* Clear the DACL in the SD */
+    Status = RtlSetDaclSecurityDescriptor(SystemSd, TRUE, Dacl, FALSE);
+    if (!NT_SUCCESS(Status))
+    {
+        /* Fail */
+        RtlFreeHeap(CsrHeap, 0, SystemSd);
+        return Status;
+    }
+
+    /* Free the SID and return*/
+    RtlFreeSid(SystemSid);
+    *LocalSystemSd = SystemSd;
+    return Status;
+}
+
+/*++
+ * @name CsrSbApiPortInitialize
+ *
+ * The CsrSbApiPortInitialize routine initializes the LPC Port used for
+ * communications with the Session Manager (SM) and initializes the static
+ * thread that will handle connection requests and APIs.
+ *
+ * @param None
+ *
+ * @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
+ *         othwerwise.
+ *
+ * @remarks None.
+ *
+ *--*/
+NTSTATUS
+NTAPI
+CsrSbApiPortInitialize(VOID)
+{
+    ULONG Size;
+    PSECURITY_DESCRIPTOR PortSd;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    NTSTATUS Status;
+    HANDLE hRequestThread;
+    CLIENT_ID ClientId;
+
+    /* Calculate how much space we'll need for the Port Name */
+    Size = CsrDirectoryName.Length + sizeof(SB_PORT_NAME) + sizeof(WCHAR);
+
+    /* Create the buffer for it */
+    CsrSbApiPortName.Buffer = RtlAllocateHeap(CsrHeap, 0, Size);
+    if (!CsrSbApiPortName.Buffer) return STATUS_NO_MEMORY;
+
+    /* Setup the rest of the empty string */
+    CsrSbApiPortName.Length = 0;
+    CsrSbApiPortName.MaximumLength = (USHORT)Size;
+
+    /* Now append the full port name */
+    RtlAppendUnicodeStringToString(&CsrSbApiPortName, &CsrDirectoryName);
+    RtlAppendUnicodeToString(&CsrSbApiPortName, UNICODE_PATH_SEP);
+    RtlAppendUnicodeToString(&CsrSbApiPortName, SB_PORT_NAME);
+    if (CsrDebug & 2) DPRINT1("CSRSS: Creating %wZ port and associated
thread\n", &CsrSbApiPortName);
+
+    /* Create Security Descriptor for this Port */
+    Status = CsrCreateLocalSystemSD(&PortSd);
+    if (!NT_SUCCESS(Status)) return Status;
+
+    /* Initialize the Attributes */
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &CsrSbApiPortName,
+                               0,
+                               NULL,
+                               PortSd);
+
+    /* Create the Port Object */
+    Status = NtCreatePort(&CsrSbApiPort,
+                          &ObjectAttributes,
+                          sizeof(SB_CONNECTION_INFO),
+                          sizeof(SB_API_MSG),
+                          32 * sizeof(SB_API_MSG));
+    if (PortSd) RtlFreeHeap(CsrHeap, 0, PortSd);
+
+    if (NT_SUCCESS(Status))
+    {
+        /* Create the Thread to handle the API Requests */
+        Status = RtlCreateUserThread(NtCurrentProcess(),
+                                     NULL,
+                                     TRUE,
+                                     0,
+                                     0,
+                                     0,
+                                     (PVOID)CsrSbApiRequestThread,
+                                     NULL,
+                                     &hRequestThread,
+                                     &ClientId);
+        if (NT_SUCCESS(Status))
+        {
+            /* Add it as a Static Server Thread */
+            CsrSbApiRequestThreadPtr = CsrAddStaticServerThread(hRequestThread,
+                                                                &ClientId,
+                                                                0);
+
+            /* Activate it */
+            Status = NtResumeThread(hRequestThread, NULL);
+        }
+    }
+
+    return Status;
+}
+
+/* PUBLIC FUNCTIONS ***********************************************************/
+
+NTSTATUS
+NTAPI
+CsrServerInitialization(IN ULONG ArgumentCount,
+                        IN PCHAR Arguments[])
+{
+    NTSTATUS Status = STATUS_SUCCESS;
+    DPRINT("CSRSRV: %s called\n", __FUNCTION__);
+
+    /* Create the Init Event */
+    Status = NtCreateEvent(&CsrInitializationEvent,
+                           EVENT_ALL_ACCESS,
+                           NULL,
+                           SynchronizationEvent,
+                           FALSE);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: NtCreateEvent failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* Cache System Basic Information so we don't always request it */
+    Status = NtQuerySystemInformation(SystemBasicInformation,
+                                      &CsrNtSysInfo,
+                                      sizeof(SYSTEM_BASIC_INFORMATION),
+                                      NULL);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: NtQuerySystemInformation failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* Save our Heap */
+    CsrHeap = RtlGetProcessHeap();
+
+    /* Set our Security Descriptor to protect the process */
+    Status = CsrSetProcessSecurity();
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: CsrSetProcessSecurity failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
     }
 
     /* Parse the command line */
@@ -923,51 +1125,71 @@
                 __FUNCTION__, Status);
         return Status;
     }
-    
+
     CsrInitProcessData();
 
+    Status = CsrApiRegisterDefinitions(NativeDefinitions);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrApiRegisterDefinitions", Status);
+    }
+
     Status = CsrpCreateListenPort(L"\\Windows\\ApiPort", &hApiPort,
(PTHREAD_START_ROUTINE)ClientConnectionThread);
     if (!NT_SUCCESS(Status))
     {
         DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpCreateApiPort", Status);
     }
 
-    Status = CsrApiRegisterDefinitions(NativeDefinitions);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrApiRegisterDefinitions", Status);
-    }
-
     Status = CsrpInitWin32Csr();
     if (!NT_SUCCESS(Status))
     {
         DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpInitWin32Csr", Status);
     }
 
-    Status = CsrpCreateListenPort(L"\\Windows\\SbApiPort", &hSbApiPort,
ServerSbApiPortThread);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpCreateCallbackPort", Status);
-    }
-
-    Status = CsrpRegisterSubsystem();
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpRegisterSubsystem", Status);
-    }
-
+    /* Initialize the API Port for SM communication */
+    Status = CsrSbApiPortInitialize();
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: CsrSbApiPortInitialize failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* We're all set! Connect to SM! */
+    Status = SmConnectToSm(&CsrSbApiPortName,
+                           CsrSbApiPort,
+                           IMAGE_SUBSYSTEM_WINDOWS_GUI,
+                           &CsrSmApiPort);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: SmConnectToSm failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* Finito! Signal the event */
+    Status = NtSetEvent(CsrInitializationEvent, NULL);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("CSRSRV:%s: NtSetEvent failed (Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* Close the event handle now */
+    NtClose(CsrInitializationEvent);
+
+    /* Have us handle Hard Errors */
     Status = NtSetDefaultHardErrorPort(hApiPort);
     if (!NT_SUCCESS(Status))
     {
-        DPRINT1("CSRSRV failed in %s with status %lx\n",
"CsrpCreateHardErrorPort", Status);
-    }
-    
-	if (CallInitComplete())
-	{
-		return STATUS_SUCCESS;
-	}
-    
-	return STATUS_UNSUCCESSFUL;
+        DPRINT1("CSRSRV:%s: NtSetDefaultHardErrorPort failed
(Status=%08lx)\n",
+                __FUNCTION__, Status);
+        return Status;
+    }
+
+    /* Return status */
+    return Status;
 }
 
 BOOL

Modified: trunk/reactos/subsystems/win32/csrss/include/api.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/csrss/include/api.h [iso-8859-1] (original)
+++ trunk/reactos/subsystems/win32/csrss/include/api.h [iso-8859-1] Wed Feb 15 19:53:31
2012
@@ -121,14 +121,18 @@
 CSR_API(CsrGetShutdownParameters);
 CSR_API(CsrSetShutdownParameters);
 
+PCSR_THREAD
+NTAPI
+CsrAllocateThread(IN PCSRSS_PROCESS_DATA CsrProcess);
+
 /* api/wapi.c */
 NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
 VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
                                 PCSR_API_MESSAGE Request);
-DWORD WINAPI ServerSbApiPortThread (PVOID PortHandle);
+VOID WINAPI CsrSbApiRequestThread (PVOID PortHandle);
 VOID NTAPI ClientConnectionThread(HANDLE ServerPort);
 
-extern HANDLE CsrssApiHeap;
+extern HANDLE CsrSbApiPort;
 
 /* api/process.c */
 typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData,

Modified: trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/win…
==============================================================================
--- trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c [iso-8859-1] (original)
+++ trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c [iso-8859-1] Wed Feb 15
19:53:31 2012
@@ -335,14 +335,14 @@
 Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
                        PCSRPLUGIN_SERVER_PROCS ServerProcs,
                        PCSRSS_EXPORTED_FUNCS Exports,
-                       HANDLE CsrssApiHeap)
+                       HANDLE CsrHeap)
 {
     HANDLE ServerThread;
     CLIENT_ID ClientId;
     NTSTATUS Status;
 
     CsrExports = *Exports;
-    Win32CsrApiHeap = CsrssApiHeap;
+    Win32CsrApiHeap = CsrHeap;
     
     CsrpInitVideo();