reactos/subsys/csrss/api/wapi.c

   1 /* $Id$
   2  *
   3  * reactos/subsys/csrss/api/wapi.c
   4  *
   5  * CSRSS port message processing
   6  *
   7  * ReactOS Operating System
   8  *
   9  */
  10
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <csrss.h>
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* GLOBALS *******************************************************************/
  19
  20 HANDLE CsrssApiHeap = (HANDLE) 0;
  21
  22 static unsigned ApiDefinitionsCount = 0;
  23 static PCSRSS_API_DEFINITION ApiDefinitions = NULL;
  24
  25 /* FUNCTIONS *****************************************************************/
  26
  27 NTSTATUS FASTCALL
  28 CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions)
  29 {
  30   unsigned NewCount;
  31   PCSRSS_API_DEFINITION Scan;
  32   PCSRSS_API_DEFINITION New;
  33
  34         DPRINT("CSR: %s called", __FUNCTION__);
  35
  36   NewCount = 0;
  37   for (Scan = NewDefinitions; 0 != Scan->Handler; Scan++)
  38     {
  39       NewCount++;
  40     }
  41
  42   New = RtlAllocateHeap(CsrssApiHeap, 0,
  43                         (ApiDefinitionsCount + NewCount)
  44                         * sizeof(CSRSS_API_DEFINITION));
  45   if (NULL == New)
  46     {
  47       DPRINT1("Unable to allocate memory\n");
  48       return STATUS_NO_MEMORY;
  49     }
  50   if (0 != ApiDefinitionsCount)
  51     {
  52       RtlCopyMemory(New, ApiDefinitions,
  53                     ApiDefinitionsCount * sizeof(CSRSS_API_DEFINITION));
  54       RtlFreeHeap(CsrssApiHeap, 0, ApiDefinitions);
  55     }
  56   RtlCopyMemory(New + ApiDefinitionsCount, NewDefinitions,
  57                 NewCount * sizeof(CSRSS_API_DEFINITION));
  58   ApiDefinitions = New;
  59   ApiDefinitionsCount += NewCount;
  60
  61   return STATUS_SUCCESS;
  62 }
  63
  64 VOID
  65 FASTCALL
  66 CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
  67                   PCSR_API_MESSAGE Request)
  68 {
  69   BOOL Found = FALSE;
  70   unsigned DefIndex;
  71   ULONG Type;
  72
  73   DPRINT("CSR: Calling handler for type: %x.\n", Request->Type);
  74   Type = Request->Type & 0xFFFF; /* FIXME: USE MACRO */
  75   DPRINT("CSR: API Number: %x ServerID: %x\n",Type, Request->Type >> 16);
  76
  77   /* FIXME: Extract DefIndex instead of looping */
  78   for (DefIndex = 0; ! Found && DefIndex < ApiDefinitionsCount; DefIndex++)
  79     {
  80       if (ApiDefinitions[DefIndex].Type == Type)
  81         {
  82           if (Request->Header.u1.s1.DataLength < ApiDefinitions[DefIndex].MinRequestSize)
  83             {
  84               DPRINT1("Request type %d min request size %d actual %d\n",
  85                       Type, ApiDefinitions[DefIndex].MinRequestSize,
  86                       Request->Header.u1.s1.DataLength);
  87               Request->Status = STATUS_INVALID_PARAMETER;
  88             }
  89           else
  90             {
  91               (ApiDefinitions[DefIndex].Handler)(ProcessData, Request);
  92               Found = TRUE;
  93             }
  94         }
  95     }
  96   if (! Found)
  97     {
  98       DPRINT1("CSR: Unknown request type 0x%x\n", Request->Type);
  99       Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
 100       Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
 101       Request->Status = STATUS_INVALID_SYSTEM_SERVICE;
 102     }
 103 }
 104
 105 STATIC
 106 VOID
 107 STDCALL
 108 ClientConnectionThread(HANDLE ServerPort)
 109 {
 110     NTSTATUS Status;
 111     BYTE RawRequest[LPC_MAX_DATA_LENGTH];
 112     PCSR_API_MESSAGE Request = (PCSR_API_MESSAGE)RawRequest;
 113     PCSR_API_MESSAGE Reply;
 114     PCSRSS_PROCESS_DATA ProcessData;
 115
 116     DPRINT("CSR: %s called", __FUNCTION__);
 117
 118     /* Reply must be NULL at the first call to NtReplyWaitReceivePort */
 119     Reply = NULL;
 120
 121     /* Loop and reply/wait for a new message */
 122     for (;;)
 123     {
 124         /* Send the reply and wait for a new request */
 125         Status = NtReplyWaitReceivePort(ServerPort,
 126                                         0,
 127                                         &Reply->Header,
 128                                         &Request->Header);
 129         if (!NT_SUCCESS(Status))
 130         {
 131             DPRINT1("CSR: NtReplyWaitReceivePort failed\n");
 132             break;
 133         }
 134
 135         /* If the connection was closed, handle that */
 136         if (Request->Header.u2.s2.Type == LPC_PORT_CLOSED)
 137         {
 138             CsrFreeProcessData( Request->Header.ClientId.UniqueProcess );
 139             break;
 140         }
 141
 142         DPRINT("CSR: Got CSR API: %x [Message Origin: %x]\n",
 143                Request->Type,
 144                Request->Header.ClientId.UniqueProcess);
 145
 146         /* Get the Process Data */
 147         ProcessData = CsrGetProcessData(Request->Header.ClientId.UniqueProcess);
 148         if (ProcessData == NULL)
 149         {
 150             DPRINT1("CSR: Message %d: Unable to find data for process 0x%x\n",
 151                     Request->Header.u2.s2.Type,
 152                     Request->Header.ClientId.UniqueProcess);
 153             break;
 154         }
 155
 156         /* Call the Handler */
 157         CsrApiCallHandler(ProcessData, Request);
 158
 159         /* Send back the reply */
 160         Reply = Request;
 161     }
 162
 163     /* Close the port and exit the thread */
 164     NtClose(ServerPort);
 165     RtlExitUserThread(STATUS_SUCCESS);
 166 }
 167
 168 /**********************************************************************
 169  * NAME
 170  *      ServerApiPortThread/1
 171  *
 172  * DESCRIPTION
 173  *      Handle connection requests from clients to the port
 174  *      "\Windows\ApiPort".
 175  */
 176 DWORD STDCALL
 177 ServerApiPortThread (PVOID PortHandle)
 178 {
 179    NTSTATUS Status = STATUS_SUCCESS;
 180    PORT_MESSAGE Request;
 181    HANDLE hApiListenPort = * (PHANDLE) PortHandle;
 182    HANDLE ServerPort = (HANDLE) 0;
 183    HANDLE ServerThread = (HANDLE) 0;
 184    PCSRSS_PROCESS_DATA ProcessData = NULL;
 185
 186    CsrInitProcessData();
 187
 188         DPRINT("CSR: %s called", __FUNCTION__);
 189
 190    for (;;)
 191      {
 192         REMOTE_PORT_VIEW LpcRead;
 193         ServerPort = NULL;
 194
 195         Status = NtListenPort (hApiListenPort, &Request);
 196         if (!NT_SUCCESS(Status))
 197           {
 198              DPRINT1("CSR: NtListenPort() failed\n");
 199              break;
 200           }
 201         Status = NtAcceptConnectPort(& ServerPort,
 202                                      hApiListenPort,
 203                                      NULL,
 204                                      TRUE,
 205                                      0,
 206                                      & LpcRead);
 207         if (!NT_SUCCESS(Status))
 208           {
 209              DPRINT1("CSR: NtAcceptConnectPort() failed\n");
 210              break;
 211           }
 212
 213         ProcessData = CsrCreateProcessData(Request.ClientId.UniqueProcess);
 214         if (ProcessData == NULL)
 215           {
 216              DPRINT1("Unable to allocate or find data for process 0x%x\n",
 217                      Request.ClientId.UniqueProcess);
 218              Status = STATUS_UNSUCCESSFUL;
 219              break;
 220           }
 221
 222
 223         ProcessData->CsrSectionViewBase = LpcRead.ViewBase;
 224         ProcessData->CsrSectionViewSize = LpcRead.ViewSize;
 225
 226         Status = NtCompleteConnectPort(ServerPort);
 227         if (!NT_SUCCESS(Status))
 228           {
 229              DPRINT1("CSR: NtCompleteConnectPort() failed\n");
 230              break;
 231           }
 232
 233         Status = RtlCreateUserThread(NtCurrentProcess(),
 234                                      NULL,
 235                                      FALSE,
 236                                      0,
 237                                      0,
 238                                      0,
 239                                      (PTHREAD_START_ROUTINE)ClientConnectionThread,
 240                                      ServerPort,
 241                                      & ServerThread,
 242                                      NULL);
 243         if (!NT_SUCCESS(Status))
 244           {
 245              DPRINT1("CSR: Unable to create server thread\n");
 246              break;
 247           }
 248         NtClose(ServerThread);
 249      }
 250    if (ServerPort)
 251      {
 252        NtClose(ServerPort);
 253      }
 254    NtClose(PortHandle);
 255    NtTerminateThread(NtCurrentThread(), Status);
 256    return 0;
 257 }
 258
 259 /**********************************************************************
 260  * NAME
 261  *      ServerSbApiPortThread/1
 262  *
 263  * DESCRIPTION
 264  *      Handle connection requests from SM to the port
 265  *      "\Windows\SbApiPort". We will accept only one
 266  *      connection request (from the SM).
 267  */
 268 DWORD STDCALL
 269 ServerSbApiPortThread (PVOID PortHandle)
 270 {
 271         HANDLE          hSbApiPortListen = * (PHANDLE) PortHandle;
 272         HANDLE          hConnectedPort = (HANDLE) 0;
 273         PORT_MESSAGE    Request;
 274         PVOID           Context = NULL;
 275         NTSTATUS        Status = STATUS_SUCCESS;
 276
 277         DPRINT("CSR: %s called\n", __FUNCTION__);
 278
 279     RtlZeroMemory(&Request, sizeof(PORT_MESSAGE));
 280         Status = NtListenPort (hSbApiPortListen, & Request);
 281         if (!NT_SUCCESS(Status))
 282         {
 283                 DPRINT1("CSR: %s: NtListenPort(SB) failed (Status=0x%08lx)\n",
 284                         __FUNCTION__, Status);
 285         } else {
 286 DPRINT("-- 1\n");
 287                 Status = NtAcceptConnectPort (& hConnectedPort,
 288                                                 hSbApiPortListen,
 289                                                 NULL,
 290                                                 TRUE,
 291                                                 NULL,
 292                                                 NULL);
 293                 if(!NT_SUCCESS(Status))
 294                 {
 295                         DPRINT1("CSR: %s: NtAcceptConnectPort() failed (Status=0x%08lx)\n",
 296                                 __FUNCTION__, Status);
 297                 } else {
 298 DPRINT("-- 2\n");
 299                         Status = NtCompleteConnectPort (hConnectedPort);
 300                         if(!NT_SUCCESS(Status))
 301                         {
 302                                 DPRINT1("CSR: %s: NtCompleteConnectPort() failed (Status=0x%08lx)\n",
 303                                         __FUNCTION__, Status);
 304                         } else {
 305 DPRINT("-- 3\n");
 306                                 PPORT_MESSAGE Reply = NULL;
 307                                 /*
 308                                  * Tell the init thread the SM gave the
 309                                  * green light for boostrapping.
 310                                  */
 311                                 Status = NtSetEvent (hBootstrapOk, NULL);
 312                                 if(!NT_SUCCESS(Status))
 313                                 {
 314                                         DPRINT1("CSR: %s: NtSetEvent failed (Status=0x%08lx)\n",
 315                                                 __FUNCTION__, Status);
 316                                 }
 317                                 /* Wait for messages from the SM */
 318 DPRINT("-- 4\n");
 319                                 while (TRUE)
 320                                 {
 321                                         Status = NtReplyWaitReceivePort(hConnectedPort,
 322                                                                         Context,
 323                                                                         Reply,
 324                                                                         & Request);
 325                                         if(!NT_SUCCESS(Status))
 326                                         {
 327                                                 DPRINT1("CSR: %s: NtReplyWaitReceivePort failed (Status=0x%08lx)\n",
 328                                                         __FUNCTION__, Status);
 329                                                 break;
 330                                         }
 331                                         switch (Request.u2.s2.Type)//fix .h PORT_MESSAGE_TYPE(Request))
 332                                         {
 333                                                 /* TODO */
 334                                         default:
 335                                                 DPRINT1("CSR: %s received message (type=%d)\n",
 336                                                         __FUNCTION__, Request.u2.s2.Type);
 337                                         }
 338 DPRINT("-- 5\n");
 339                                 }
 340                         }
 341                 }
 342         }
 343         DPRINT1("CSR: %s: terminating!\n", __FUNCTION__);
 344         if(hConnectedPort) NtClose (hConnectedPort);
 345         NtClose (hSbApiPortListen);
 346         NtTerminateThread (NtCurrentThread(), Status);
 347         return 0;
 348 }
 349
 350 /* EOF */