subsystems/win32/csrss/csrsrv/init.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS CSR Sub System
   4  * FILE:            subsystems/win32/csrss/csrsrv/init.c
   5  * PURPOSE:         CSR Server DLL Initialization
   6  * PROGRAMMERS:     ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include "srv.h"
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* DATA ***********************************************************************/
  16
  17 HANDLE CsrHeap = (HANDLE) 0;
  18 HANDLE CsrObjectDirectory = (HANDLE) 0;
  19 UNICODE_STRING CsrDirectoryName;
  20 extern HANDLE CsrssApiHeap;
  21 static unsigned ServerProcCount;
  22 static CSRPLUGIN_SERVER_PROCS *ServerProcs = NULL;
  23 HANDLE hSbApiPort = (HANDLE) 0;
  24 HANDLE hBootstrapOk = (HANDLE) 0;
  25 HANDLE hSmApiPort = (HANDLE) 0;
  26 HANDLE hApiPort = (HANDLE) 0;
  27
  28 /* PRIVATE FUNCTIONS **********************************************************/
  29
  30 ULONG
  31 InitializeVideoAddressSpace(VOID)
  32 {
  33     OBJECT_ATTRIBUTES ObjectAttributes;
  34     UNICODE_STRING PhysMemName = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
  35     NTSTATUS Status;
  36     HANDLE PhysMemHandle;
  37     PVOID BaseAddress;
  38     LARGE_INTEGER Offset;
  39     SIZE_T ViewSize;
  40     CHAR IVTAndBda[1024+256];
  41
  42     /* Free the 1MB pre-reserved region. In reality, ReactOS should simply support us mapping the view into the reserved area, but it doesn't. */
  43     BaseAddress = 0;
  44     ViewSize = 1024 * 1024;
  45     Status = ZwFreeVirtualMemory(NtCurrentProcess(),
  46                                  &BaseAddress,
  47                                  &ViewSize,
  48                                  MEM_RELEASE);
  49     if (!NT_SUCCESS(Status))
  50     {
  51         DPRINT1("Couldn't unmap reserved memory (%x)\n", Status);
  52         return 0;
  53     }
  54
  55     /* Open the physical memory section */
  56     InitializeObjectAttributes(&ObjectAttributes,
  57                                &PhysMemName,
  58                                0,
  59                                NULL,
  60                                NULL);
  61     Status = ZwOpenSection(&PhysMemHandle,
  62                            SECTION_ALL_ACCESS,
  63                            &ObjectAttributes);
  64     if (!NT_SUCCESS(Status))
  65     {
  66         DPRINT1("Couldn't open \\Device\\PhysicalMemory\n");
  67         return 0;
  68     }
  69
  70     /* Map the BIOS and device registers into the address space */
  71     Offset.QuadPart = 0xa0000;
  72     ViewSize = 0x100000 - 0xa0000;
  73     BaseAddress = (PVOID)0xa0000;
  74     Status = ZwMapViewOfSection(PhysMemHandle,
  75                                 NtCurrentProcess(),
  76                                 &BaseAddress,
  77                                 0,
  78                                 ViewSize,
  79                                 &Offset,
  80                                 &ViewSize,
  81                                 ViewUnmap,
  82                                 0,
  83                                 PAGE_EXECUTE_READWRITE);
  84     if (!NT_SUCCESS(Status))
  85     {
  86         DPRINT1("Couldn't map physical memory (%x)\n", Status);
  87         ZwClose(PhysMemHandle);
  88         return 0;
  89     }
  90
  91     /* Close physical memory section handle */
  92     ZwClose(PhysMemHandle);
  93
  94     if (BaseAddress != (PVOID)0xa0000)
  95     {
  96         DPRINT1("Couldn't map physical memory at the right address (was %x)\n",
  97                 BaseAddress);
  98         return 0;
  99     }
 100
 101     /* Allocate some low memory to use for the non-BIOS
 102      * parts of the v86 mode address space
 103      */
 104     BaseAddress = (PVOID)0x1;
 105     ViewSize = 0xa0000 - 0x1000;
 106     Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
 107                                      &BaseAddress,
 108                                      0,
 109                                      &ViewSize,
 110                                      MEM_RESERVE | MEM_COMMIT,
 111                                      PAGE_EXECUTE_READWRITE);
 112     if (!NT_SUCCESS(Status))
 113     {
 114         DPRINT1("Failed to allocate virtual memory (Status %x)\n", Status);
 115         return 0;
 116     }
 117     if (BaseAddress != (PVOID)0x0)
 118     {
 119         DPRINT1("Failed to allocate virtual memory at right address (was %x)\n",
 120                 BaseAddress);
 121         return 0;
 122     }
 123
 124     /* Get the real mode IVT and BDA from the kernel */
 125     Status = NtVdmControl(VdmInitialize, IVTAndBda);
 126     if (!NT_SUCCESS(Status))
 127     {
 128         DPRINT1("NtVdmControl failed (status %x)\n", Status);
 129         return 0;
 130     }
 131
 132     /* Return success */
 133     return 1;
 134 }
 135
 136
 137 static NTSTATUS FASTCALL
 138 CsrpAddServerProcs(CSRPLUGIN_SERVER_PROCS *Procs)
 139 {
 140   CSRPLUGIN_SERVER_PROCS *NewProcs;
 141
 142   DPRINT("CSR: %s called\n", __FUNCTION__);
 143
 144   NewProcs = RtlAllocateHeap(CsrssApiHeap, 0,
 145                              (ServerProcCount + 1)
 146                              * sizeof(CSRPLUGIN_SERVER_PROCS));
 147   if (NULL == NewProcs)
 148     {
 149       return STATUS_NO_MEMORY;
 150     }
 151   if (0 != ServerProcCount)
 152     {
 153       RtlCopyMemory(NewProcs, ServerProcs,
 154                     ServerProcCount * sizeof(CSRPLUGIN_SERVER_PROCS));
 155       RtlFreeHeap(CsrssApiHeap, 0, ServerProcs);
 156     }
 157   NewProcs[ServerProcCount] = *Procs;
 158   ServerProcs = NewProcs;
 159   ServerProcCount++;
 160
 161   return STATUS_SUCCESS;
 162 }
 163
 164 /**********************************************************************
 165  * CallInitComplete/0
 166  */
 167 static BOOL FASTCALL
 168 CallInitComplete(void)
 169 {
 170   BOOL Ok;
 171   unsigned i;
 172
 173   DPRINT("CSR: %s called\n", __FUNCTION__);
 174
 175   Ok = TRUE;
 176   for (i = 0; i < ServerProcCount && Ok; i++)
 177     {
 178       Ok = (*ServerProcs[i].InitCompleteProc)();
 179     }
 180
 181   return Ok;
 182 }
 183
 184 BOOL
 185 CallHardError(IN PCSRSS_PROCESS_DATA ProcessData,
 186               IN PHARDERROR_MSG HardErrorMessage)
 187 {
 188     BOOL Ok;
 189     unsigned i;
 190
 191     DPRINT("CSR: %s called\n", __FUNCTION__);
 192
 193     Ok = TRUE;
 194     for (i = 0; i < ServerProcCount && Ok; i++)
 195     {
 196         Ok = (*ServerProcs[i].HardErrorProc)(ProcessData, HardErrorMessage);
 197     }
 198
 199     return Ok;
 200 }
 201
 202 NTSTATUS
 203 CallProcessInherit(IN PCSRSS_PROCESS_DATA SourceProcessData,
 204                    IN PCSRSS_PROCESS_DATA TargetProcessData)
 205 {
 206     NTSTATUS Status = STATUS_SUCCESS;
 207     unsigned i;
 208
 209     DPRINT("CSR: %s called\n", __FUNCTION__);
 210
 211     for (i = 0; i < ServerProcCount && NT_SUCCESS(Status); i++)
 212         Status = (*ServerProcs[i].ProcessInheritProc)(SourceProcessData, TargetProcessData);
 213
 214     return Status;
 215 }
 216
 217 NTSTATUS
 218 CallProcessDeleted(IN PCSRSS_PROCESS_DATA ProcessData)
 219 {
 220     NTSTATUS Status = STATUS_SUCCESS;
 221     unsigned i;
 222
 223     DPRINT("CSR: %s called\n", __FUNCTION__);
 224
 225     for (i = 0; i < ServerProcCount && NT_SUCCESS(Status); i++)
 226         Status = (*ServerProcs[i].ProcessDeletedProc)(ProcessData);
 227
 228     return Status;
 229 }
 230
 231
 232 ULONG
 233 InitializeVideoAddressSpace(VOID);
 234
 235 /**********************************************************************
 236  * CsrpCreateObjectDirectory/3
 237  */
 238 static NTSTATUS
 239 CsrpCreateObjectDirectory (int argc, char ** argv, char ** envp)
 240 {
 241    NTSTATUS Status;
 242    OBJECT_ATTRIBUTES Attributes;
 243
 244   DPRINT("CSR: %s called\n", __FUNCTION__);
 245
 246
 247         /* create object directory ('\Windows') */
 248         RtlCreateUnicodeString (&CsrDirectoryName,
 249                                 L"\\Windows");
 250
 251         InitializeObjectAttributes (&Attributes,
 252                                     &CsrDirectoryName,
 253                                     OBJ_OPENIF,
 254                                     NULL,
 255                                     NULL);
 256
 257         Status = NtOpenDirectoryObject(&CsrObjectDirectory,
 258                                        DIRECTORY_ALL_ACCESS,
 259                                        &Attributes);
 260         return Status;
 261 }
 262
 263 /**********************************************************************
 264  * CsrpInitVideo/3
 265  *
 266  * TODO: we need a virtual device for sessions other than
 267  * TODO: the console one
 268  */
 269 static NTSTATUS
 270 CsrpInitVideo (int argc, char ** argv, char ** envp)
 271 {
 272   OBJECT_ATTRIBUTES ObjectAttributes;
 273   UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\??\\DISPLAY1");
 274   IO_STATUS_BLOCK Iosb;
 275   HANDLE VideoHandle = (HANDLE) 0;
 276   NTSTATUS Status = STATUS_SUCCESS;
 277
 278   DPRINT("CSR: %s called\n", __FUNCTION__);
 279
 280   InitializeVideoAddressSpace();
 281
 282   InitializeObjectAttributes(&ObjectAttributes,
 283                              &DeviceName,
 284                              0,
 285                              NULL,
 286                              NULL);
 287   Status = NtOpenFile(&VideoHandle,
 288                       FILE_ALL_ACCESS,
 289                       &ObjectAttributes,
 290                       &Iosb,
 291                       0,
 292                       0);
 293   if (NT_SUCCESS(Status))
 294     {
 295       NtClose(VideoHandle);
 296     }
 297   return Status;
 298 }
 299
 300 /**********************************************************************
 301  * CsrpInitWin32Csr/3
 302  *
 303  * TODO: this function should be turned more general to load an
 304  * TODO: hosted server DLL as received from the command line;
 305  * TODO: for instance: ServerDll=winsrv:ConServerDllInitialization,2
 306  * TODO:               ^method   ^dll   ^api                       ^sid
 307  * TODO:
 308  * TODO: CsrpHostServerDll (LPWSTR DllName,
 309  * TODO:                    LPWSTR ApiName,
 310  * TODO:                    DWORD  ServerId)
 311  */
 312 static NTSTATUS
 313 CsrpInitWin32Csr (int argc, char ** argv, char ** envp)
 314 {
 315   NTSTATUS Status;
 316   UNICODE_STRING DllName;
 317   HINSTANCE hInst;
 318   ANSI_STRING ProcName;
 319   CSRPLUGIN_INITIALIZE_PROC InitProc;
 320   CSRSS_EXPORTED_FUNCS Exports;
 321   PCSRSS_API_DEFINITION ApiDefinitions;
 322   CSRPLUGIN_SERVER_PROCS ServerProcs;
 323
 324   DPRINT("CSR: %s called\n", __FUNCTION__);
 325
 326   RtlInitUnicodeString(&DllName, L"win32csr.dll");
 327   Status = LdrLoadDll(NULL, 0, &DllName, (PVOID *) &hInst);
 328   if (! NT_SUCCESS(Status))
 329     {
 330       return Status;
 331     }
 332   RtlInitAnsiString(&ProcName, "Win32CsrInitialization");
 333   Status = LdrGetProcedureAddress(hInst, &ProcName, 0, (PVOID *) &InitProc);
 334   if (! NT_SUCCESS(Status))
 335     {
 336       return Status;
 337     }
 338   Exports.CsrEnumProcessesProc = CsrEnumProcesses;
 339   if (! (*InitProc)(&ApiDefinitions, &ServerProcs, &Exports, CsrssApiHeap))
 340     {
 341       return STATUS_UNSUCCESSFUL;
 342     }
 343
 344   Status = CsrApiRegisterDefinitions(ApiDefinitions);
 345   if (! NT_SUCCESS(Status))
 346     {
 347       return Status;
 348     }
 349   Status = CsrpAddServerProcs(&ServerProcs);
 350   return Status;
 351 }
 352
 353 CSRSS_API_DEFINITION NativeDefinitions[] =
 354   {
 355     CSRSS_DEFINE_API(CREATE_PROCESS,               CsrCreateProcess),
 356     CSRSS_DEFINE_API(CREATE_THREAD,                CsrSrvCreateThread),
 357     CSRSS_DEFINE_API(TERMINATE_PROCESS,            CsrTerminateProcess),
 358     CSRSS_DEFINE_API(CONNECT_PROCESS,              CsrConnectProcess),
 359     CSRSS_DEFINE_API(REGISTER_SERVICES_PROCESS,    CsrRegisterServicesProcess),
 360     CSRSS_DEFINE_API(GET_SHUTDOWN_PARAMETERS,      CsrGetShutdownParameters),
 361     CSRSS_DEFINE_API(SET_SHUTDOWN_PARAMETERS,      CsrSetShutdownParameters),
 362     { 0, 0, NULL }
 363   };
 364
 365 static NTSTATUS WINAPI
 366 CsrpCreateListenPort (IN     LPWSTR  Name,
 367                       IN OUT PHANDLE Port,
 368                       IN     PTHREAD_START_ROUTINE ListenThread)
 369 {
 370         NTSTATUS           Status = STATUS_SUCCESS;
 371         OBJECT_ATTRIBUTES  PortAttributes;
 372         UNICODE_STRING     PortName;
 373     HANDLE ServerThread;
 374     CLIENT_ID ClientId;
 375
 376         DPRINT("CSR: %s called\n", __FUNCTION__);
 377
 378         RtlInitUnicodeString (& PortName, Name);
 379         InitializeObjectAttributes (& PortAttributes,
 380                                     & PortName,
 381                                     0,
 382                                     NULL,
 383                                     NULL);
 384         Status = NtCreatePort ( Port,
 385                                 & PortAttributes,
 386                                 sizeof(SB_CONNECTION_INFO),
 387                                 sizeof(SB_API_MSG),
 388                                 32 * sizeof(SB_API_MSG));
 389         if(!NT_SUCCESS(Status))
 390         {
 391                 DPRINT1("CSR: %s: NtCreatePort failed (Status=%08lx)\n",
 392                         __FUNCTION__, Status);
 393                 return Status;
 394         }
 395         Status = RtlCreateUserThread(NtCurrentProcess(),
 396                                NULL,
 397                                TRUE,
 398                                0,
 399                                0,
 400                                0,
 401                                (PTHREAD_START_ROUTINE) ListenThread,
 402                                *Port,
 403                                &ServerThread,
 404                                &ClientId);
 405
 406     if (ListenThread == (PVOID)ClientConnectionThread)
 407     {
 408         CsrAddStaticServerThread(ServerThread, &ClientId, 0);
 409     }
 410
 411     NtResumeThread(ServerThread, NULL);
 412     NtClose(ServerThread);
 413         return Status;
 414 }
 415
 416 /* === INIT ROUTINES === */
 417
 418 /**********************************************************************
 419  * CsrpCreateBNODirectory/3
 420  *
 421  * These used to be part of kernel32 startup, but that clearly wasn't a good
 422  * idea, as races were definately possible.  These are moved (as in the
 423  * previous fixmes).
 424  */
 425 static NTSTATUS
 426 CsrpCreateBNODirectory (int argc, char ** argv, char ** envp)
 427 {
 428     NTSTATUS Status;
 429     OBJECT_ATTRIBUTES ObjectAttributes;
 430     UNICODE_STRING Name = RTL_CONSTANT_STRING(L"\\BaseNamedObjects");
 431     UNICODE_STRING SymName = RTL_CONSTANT_STRING(L"Local");
 432     UNICODE_STRING SymName2 = RTL_CONSTANT_STRING(L"Global");
 433     HANDLE DirHandle, SymHandle;
 434
 435     /* Seems like a good place to create these objects which are needed by
 436      * win32 processes */
 437     InitializeObjectAttributes(&ObjectAttributes,
 438                                &Name,
 439                                OBJ_CASE_INSENSITIVE,
 440                                NULL,
 441                                NULL);
 442
 443     Status = NtCreateDirectoryObject(&DirHandle,
 444                                      DIRECTORY_ALL_ACCESS,
 445                                      &ObjectAttributes);
 446     if (!NT_SUCCESS(Status))
 447     {
 448         DPRINT1("NtCreateDirectoryObject() failed %08x\n", Status);
 449     }
 450
 451     /* Create the "local" Symbolic Link.
 452      * FIXME: CSR should do this -- Fixed */
 453     InitializeObjectAttributes(&ObjectAttributes,
 454                                &SymName,
 455                                OBJ_CASE_INSENSITIVE,
 456                                DirHandle,
 457                                NULL);
 458     Status = NtCreateSymbolicLinkObject(&SymHandle,
 459                                         SYMBOLIC_LINK_ALL_ACCESS,
 460                                         &ObjectAttributes,
 461                                         &Name);
 462     if (!NT_SUCCESS(Status))
 463     {
 464         DPRINT1("NtCreateDirectoryObject() failed %08x\n", Status);
 465     }
 466
 467     /* Create the "global" Symbolic Link. */
 468     InitializeObjectAttributes(&ObjectAttributes,
 469                                &SymName2,
 470                                OBJ_CASE_INSENSITIVE,
 471                                DirHandle,
 472                                NULL);
 473     Status = NtCreateSymbolicLinkObject(&SymHandle,
 474                                         SYMBOLIC_LINK_ALL_ACCESS,
 475                                         &ObjectAttributes,
 476                                         &Name);
 477     if (!NT_SUCCESS(Status))
 478     {
 479         DPRINT1("NtCreateDirectoryObject() failed %08x\n", Status);
 480     }
 481
 482     return Status;
 483 }
 484
 485
 486 VOID
 487 WINAPI
 488 BasepFakeStaticServerData(VOID);
 489
 490 NTSTATUS
 491 NTAPI
 492 CsrSrvCreateSharedSection(IN PCHAR ParameterValue);
 493
 494 /**********************************************************************
 495  * CsrpCreateHeap/3
 496  */
 497 static NTSTATUS
 498 CsrpCreateHeap (int argc, char ** argv, char ** envp)
 499 {
 500     CHAR Value[] = "1024,3072,512";
 501     NTSTATUS Status;
 502         DPRINT("CSR: %s called\n", __FUNCTION__);
 503
 504         CsrssApiHeap = RtlCreateHeap(HEAP_GROWABLE,
 505                                        NULL,
 506                                        65536,
 507                                        65536,
 508                                        NULL,
 509                                        NULL);
 510         if (CsrssApiHeap == NULL)
 511         {
 512                 return STATUS_UNSUCCESSFUL;
 513         }
 514
 515
 516     Status = CsrSrvCreateSharedSection(Value);
 517     if (Status != STATUS_SUCCESS)
 518     {
 519         DPRINT1("CsrSrvCreateSharedSection failed with status 0x%08lx\n", Status);
 520         ASSERT(FALSE);
 521     }
 522
 523     BasepFakeStaticServerData();
 524         return STATUS_SUCCESS;
 525 }
 526
 527 /**********************************************************************
 528  * CsrpCreateCallbackPort/3
 529  */
 530 static NTSTATUS
 531 CsrpCreateCallbackPort (int argc, char ** argv, char ** envp)
 532 {
 533         DPRINT("CSR: %s called\n", __FUNCTION__);
 534
 535         return CsrpCreateListenPort (L"\\Windows\\SbApiPort",
 536                                      & hSbApiPort,
 537                                      ServerSbApiPortThread);
 538 }
 539
 540 /**********************************************************************
 541  * CsrpRegisterSubsystem/3
 542  */
 543 BOOLEAN g_ModernSm;
 544 static NTSTATUS
 545 CsrpRegisterSubsystem (int argc, char ** argv, char ** envp)
 546 {
 547         NTSTATUS           Status = STATUS_SUCCESS;
 548         OBJECT_ATTRIBUTES  BootstrapOkAttributes;
 549         UNICODE_STRING     Name;
 550
 551         DPRINT("CSR: %s called\n", __FUNCTION__);
 552
 553         /*
 554          * Create the event object the callback port
 555          * thread will signal *if* the SM will
 556          * authorize us to bootstrap.
 557          */
 558         RtlInitUnicodeString (& Name, L"\\CsrssBooting");
 559         InitializeObjectAttributes(& BootstrapOkAttributes,
 560                                    & Name,
 561                                    0, NULL, NULL);
 562         Status = NtCreateEvent (& hBootstrapOk,
 563                                 EVENT_ALL_ACCESS,
 564                                 & BootstrapOkAttributes,
 565                                 SynchronizationEvent,
 566                                 FALSE);
 567         if(!NT_SUCCESS(Status))
 568         {
 569                 DPRINT("CSR: %s: NtCreateEvent failed (Status=0x%08lx)\n",
 570                         __FUNCTION__, Status);
 571                 return Status;
 572         }
 573         /*
 574          * Let's tell the SM a new environment
 575          * subsystem server is in the system.
 576          */
 577         RtlInitUnicodeString (& Name, L"\\Windows\\SbApiPort");
 578         DPRINT("CSR: %s: registering with SM for\n  IMAGE_SUBSYSTEM_WINDOWS_CUI == 3\n", __FUNCTION__);
 579         Status = SmConnectApiPort (& Name,
 580                                    hSbApiPort,
 581                                    IMAGE_SUBSYSTEM_WINDOWS_CUI,
 582                                    & hSmApiPort);
 583     if (!NT_SUCCESS(Status))
 584     {
 585         Status = SmConnectToSm(&Name, hSbApiPort, IMAGE_SUBSYSTEM_WINDOWS_GUI, &hSmApiPort);
 586         g_ModernSm = TRUE;
 587     }
 588         if(!NT_SUCCESS(Status))
 589         {
 590                 DPRINT("CSR: %s unable to connect to the SM (Status=0x%08lx)\n",
 591                         __FUNCTION__, Status);
 592                 NtClose (hBootstrapOk);
 593                 return Status;
 594         }
 595         /*
 596          *  Wait for SM to reply OK... If the SM
 597          *  won't answer, we hang here forever!
 598          */
 599         DPRINT("CSR: %s: waiting for SM to OK boot...\n", __FUNCTION__);
 600         Status = NtWaitForSingleObject (hBootstrapOk,
 601                                         FALSE,
 602                                         NULL);
 603         NtClose (hBootstrapOk);
 604         return Status;
 605 }
 606
 607 #if 0
 608 /**********************************************************************
 609  *      CsrpLoadKernelModeDriver/3
 610  */
 611 static NTSTATUS
 612 CsrpLoadKernelModeDriver (int argc, char ** argv, char ** envp)
 613 {
 614         NTSTATUS        Status = STATUS_SUCCESS;
 615         WCHAR           Data [MAX_PATH + 1];
 616         ULONG           DataLength = sizeof Data;
 617         ULONG           DataType = 0;
 618         //UNICODE_STRING  Environment;
 619
 620
 621         DPRINT1("SM: %s called\n", __FUNCTION__);
 622
 623
 624         //EnvpToUnicodeString (envp, & Environment);
 625         Status = SmLookupSubsystem (L"Kmode",
 626                                     Data,
 627                                     & DataLength,
 628                                     & DataType,
 629                                     NULL);
 630         //RtlFreeUnicodeString (& Environment);
 631         if((STATUS_SUCCESS == Status) && (DataLength > sizeof Data[0]))
 632         {
 633                 WCHAR                      ImagePath [MAX_PATH + 1] = {0};
 634                 UNICODE_STRING             ModuleName;
 635
 636                 wcscpy (ImagePath, L"\\SYSTEMROOT\\system32\\win32k.sys");
 637 //              wcscat (ImagePath, Data);
 638                 RtlInitUnicodeString (& ModuleName, ImagePath);
 639                 Status = NtSetSystemInformation(/* FIXME: SystemLoadAndCallImage */
 640                                                 SystemExtendServiceTableInformation,
 641                                                 & ModuleName,
 642                                                 sizeof ModuleName);
 643                 if(!NT_SUCCESS(Status))
 644                 {
 645                         DPRINT1("WIN: %s: loading Kmode failed (Status=0x%08lx)\n",
 646                                 __FUNCTION__, Status);
 647                 }
 648         }
 649         return Status;
 650 }
 651 #endif
 652
 653 /**********************************************************************
 654  * CsrpCreateApiPort/2
 655  */
 656 static NTSTATUS
 657 CsrpCreateApiPort (int argc, char ** argv, char ** envp)
 658 {
 659         DPRINT("CSR: %s called\n", __FUNCTION__);
 660
 661         CsrInitProcessData();
 662
 663         return CsrpCreateListenPort(L"\\Windows\\ApiPort", &hApiPort,
 664                 (PTHREAD_START_ROUTINE)ClientConnectionThread);
 665 }
 666
 667 /**********************************************************************
 668  * CsrpApiRegisterDef/0
 669  */
 670 static NTSTATUS
 671 CsrpApiRegisterDef (int argc, char ** argv, char ** envp)
 672 {
 673         return CsrApiRegisterDefinitions(NativeDefinitions);
 674 }
 675
 676 /**********************************************************************
 677  * CsrpCCTS/2
 678  */
 679 static NTSTATUS
 680 CsrpCCTS (int argc, char ** argv, char ** envp)
 681 {
 682     ULONG Dummy;
 683     ULONG DummyLength = sizeof(Dummy);
 684         return CsrClientConnectToServer(L"\\Windows",
 685                         0, &Dummy, &DummyLength, NULL);
 686 }
 687
 688 /**********************************************************************
 689  * CsrpRunWinlogon/0
 690  *
 691  * Start the logon process (winlogon.exe).
 692  *
 693  * TODO: this should be moved in CsrpCreateSession/x (one per session)
 694  * TODO: in its own desktop (one logon desktop per winstation).
 695  */
 696 static NTSTATUS
 697 CsrpRunWinlogon (int argc, char ** argv, char ** envp)
 698 {
 699         NTSTATUS                      Status = STATUS_SUCCESS;
 700         UNICODE_STRING                ImagePath;
 701         UNICODE_STRING                CommandLine;
 702         PRTL_USER_PROCESS_PARAMETERS  ProcessParameters = NULL;
 703         RTL_USER_PROCESS_INFORMATION  ProcessInfo;
 704
 705
 706         DPRINT("CSR: %s called\n", __FUNCTION__);
 707     if (g_ModernSm) return STATUS_SUCCESS;
 708
 709         /* initialize the process parameters */
 710         RtlInitUnicodeString (& ImagePath, L"\\SystemRoot\\system32\\winlogon.exe");
 711         RtlInitUnicodeString (& CommandLine, L"");
 712         RtlCreateProcessParameters(& ProcessParameters,
 713                                    & ImagePath,
 714                                    NULL,
 715                                    NULL,
 716                                    & CommandLine,
 717                                    NULL,
 718                                    NULL,
 719                                    NULL,
 720                                    NULL,
 721                                    NULL);
 722         /* Create the winlogon process */
 723         Status = RtlCreateUserProcess (& ImagePath,
 724                                        OBJ_CASE_INSENSITIVE,
 725                                        ProcessParameters,
 726                                        NULL,
 727                                        NULL,
 728                                        NULL,
 729                                        FALSE,
 730                                        NULL,
 731                                        NULL,
 732                                        & ProcessInfo);
 733         /* Cleanup */
 734         RtlDestroyProcessParameters (ProcessParameters);
 735         if (!NT_SUCCESS(Status))
 736         {
 737                 DPRINT1("SM: %s: loading winlogon.exe failed (Status=%08lx)\n",
 738                                 __FUNCTION__, Status);
 739         }
 740
 741    ZwResumeThread(ProcessInfo.ThreadHandle, NULL);
 742         return Status;
 743 }
 744
 745 static NTSTATUS
 746 CsrpCreateHardErrorPort (int argc, char ** argv, char ** envp)
 747 {
 748     return NtSetDefaultHardErrorPort(hApiPort);
 749 }
 750
 751 typedef NTSTATUS (* CSR_INIT_ROUTINE)(int,char**,char**);
 752
 753 struct {
 754         BOOL Required;
 755         CSR_INIT_ROUTINE EntryPoint;
 756         PCHAR ErrorMessage;
 757 } InitRoutine [] = {
 758         {TRUE, CsrpCreateBNODirectory,   "create base named objects directory"},
 759         {TRUE, CsrpCreateHeap,           "create the CSR heap"},
 760         {TRUE, CsrpCreateApiPort,        "create the api port \\Windows\\ApiPort"},
 761     {TRUE, CsrpCreateHardErrorPort,  "create the hard error port"},
 762         {TRUE, CsrpCreateObjectDirectory,"create the object directory \\Windows"},
 763 //      {TRUE, CsrpLoadKernelModeDriver, "load Kmode driver"},
 764         {TRUE, CsrpInitVideo,            "initialize video"},
 765         {TRUE, CsrpApiRegisterDef,       "initialize api definitions"},
 766         {TRUE, CsrpCCTS,                 "connect client to server"},
 767         {TRUE, CsrpInitWin32Csr,         "load usermode dll"},
 768         {TRUE, CsrpCreateCallbackPort,   "create the callback port \\Windows\\SbApiPort"},
 769         {TRUE, CsrpRegisterSubsystem,    "register with SM"},
 770         {TRUE, CsrpRunWinlogon,          "run WinLogon"},
 771 };
 772
 773 /* PUBLIC FUNCTIONS ***********************************************************/
 774
 775 NTSTATUS
 776 NTAPI
 777 CsrServerInitialization(ULONG ArgumentCount,
 778                         PCHAR Arguments[])
 779 {
 780         UINT       i = 0;
 781         NTSTATUS  Status = STATUS_SUCCESS;
 782
 783         DPRINT("CSR: %s called\n", __FUNCTION__);
 784
 785         for (i=0; i < (sizeof InitRoutine / sizeof InitRoutine[0]); i++)
 786         {
 787                 Status = InitRoutine[i].EntryPoint(ArgumentCount,Arguments,NULL);
 788                 if(!NT_SUCCESS(Status))
 789                 {
 790                         DPRINT1("CSR: %s: failed to %s (Status=%08lx)\n",
 791                                 __FUNCTION__,
 792                                 InitRoutine[i].ErrorMessage,
 793                                 Status);
 794                         if (InitRoutine[i].Required)
 795                         {
 796                                 return FALSE;
 797                         }
 798                 }
 799         }
 800         if (CallInitComplete())
 801         {
 802                 Status = SmCompleteSession (hSmApiPort,hSbApiPort,hApiPort);
 803                 return STATUS_SUCCESS;
 804         }
 805
 806         return STATUS_UNSUCCESSFUL;
 807 }
 808
 809 BOOL
 810 NTAPI
 811 DllMain(HANDLE hDll,
 812         DWORD dwReason,
 813         LPVOID lpReserved)
 814 {
 815     /* We don't do much */
 816     UNREFERENCED_PARAMETER(hDll);
 817     UNREFERENCED_PARAMETER(dwReason);
 818     UNREFERENCED_PARAMETER(lpReserved);
 819     return TRUE;
 820 }
 821
 822 /* EOF */