subsystems/win/basesrv/init.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Base API Server DLL
   4  * FILE:            subsystems/win/basesrv/init.c
   5  * PURPOSE:         Initialization
   6  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include "basesrv.h"
  12 #include "api.h"
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* GLOBALS ********************************************************************/
  18
  19 HANDLE BaseSrvDllInstance = NULL;
  20
  21 /* Memory */
  22 HANDLE BaseSrvHeap = NULL;          // Our own heap.
  23 HANDLE BaseSrvSharedHeap = NULL;    // Shared heap with CSR. (CsrSrvSharedSectionHeap)
  24 PBASE_STATIC_SERVER_DATA BaseStaticServerData = NULL;   // Data that we can share amongst processes. Initialized inside BaseSrvSharedHeap.
  25
  26 // Windows Server 2003 table from http://j00ru.vexillium.org/csrss_list/api_list.html#Windows_2k3
  27 PCSR_API_ROUTINE BaseServerApiDispatchTable[BasepMaxApiNumber - BASESRV_FIRST_API_NUMBER] =
  28 {
  29     BaseSrvCreateProcess,
  30     BaseSrvCreateThread,
  31     BaseSrvGetTempFile,
  32     BaseSrvExitProcess,
  33     // BaseSrvDebugProcess,
  34     // BaseSrvCheckVDM,
  35     // BaseSrvUpdateVDMEntry,
  36     // BaseSrvGetNextVDMCommand,
  37     // BaseSrvExitVDM,
  38     // BaseSrvIsFirstVDM,
  39     // BaseSrvGetVDMExitCode,
  40     // BaseSrvSetReenterCount,
  41     BaseSrvSetProcessShutdownParam,
  42     BaseSrvGetProcessShutdownParam,
  43     // BaseSrvNlsSetUserInfo,
  44     // BaseSrvNlsSetMultipleUserInfo,
  45     // BaseSrvNlsCreateSection,
  46     // BaseSrvSetVDMCurDirs,
  47     // BaseSrvGetVDMCurDirs,
  48     // BaseSrvBatNotification,
  49     // BaseSrvRegisterWowExec,
  50     BaseSrvSoundSentryNotification,
  51     // BaseSrvRefreshIniFileMapping,
  52     BaseSrvDefineDosDevice,
  53     // BaseSrvSetTermsrvAppInstallMode,
  54     // BaseSrvNlsUpdateCacheCount,
  55     // BaseSrvSetTermsrvClientTimeZone,
  56     // BaseSrvSxsCreateActivationContext,
  57     // BaseSrvRegisterThread,
  58     // BaseSrvNlsGetUserInfo,
  59 };
  60
  61 BOOLEAN BaseServerApiServerValidTable[BasepMaxApiNumber - BASESRV_FIRST_API_NUMBER] =
  62 {
  63     TRUE,   // BaseSrvCreateProcess
  64     TRUE,   // BaseSrvCreateThread
  65     TRUE,   // BaseSrvGetTempFile
  66     FALSE,  // BaseSrvExitProcess
  67     // FALSE,  // BaseSrvDebugProcess
  68     // TRUE,   // BaseSrvCheckVDM
  69     // TRUE,   // BaseSrvUpdateVDMEntry
  70     // TRUE,   // BaseSrvGetNextVDMCommand
  71     // TRUE,   // BaseSrvExitVDM
  72     // TRUE,   // BaseSrvIsFirstVDM
  73     // TRUE,   // BaseSrvGetVDMExitCode
  74     // TRUE,   // BaseSrvSetReenterCount
  75     TRUE,   // BaseSrvSetProcessShutdownParam
  76     TRUE,   // BaseSrvGetProcessShutdownParam
  77     // TRUE,   // BaseSrvNlsSetUserInfo
  78     // TRUE,   // BaseSrvNlsSetMultipleUserInfo
  79     // TRUE,   // BaseSrvNlsCreateSection
  80     // TRUE,   // BaseSrvSetVDMCurDirs
  81     // TRUE,   // BaseSrvGetVDMCurDirs
  82     // TRUE,   // BaseSrvBatNotification
  83     // TRUE,   // BaseSrvRegisterWowExec
  84     TRUE,   // BaseSrvSoundSentryNotification
  85     // TRUE,   // BaseSrvRefreshIniFileMapping
  86     TRUE,   // BaseSrvDefineDosDevice
  87     // FALSE,  // BaseSrvSetTermsrvAppInstallMode
  88     // FALSE,  // BaseSrvNlsUpdateCacheCount
  89     // FALSE,  // BaseSrvSetTermsrvClientTimeZone
  90     // FALSE,  // BaseSrvSxsCreateActivationContext
  91     // FALSE,  // BaseSrvRegisterThread
  92     // FALSE,  // BaseSrvNlsGetUserInfo
  93 };
  94
  95 PCHAR BaseServerApiNameTable[BasepMaxApiNumber - BASESRV_FIRST_API_NUMBER] =
  96 {
  97     "BaseCreateProcess",
  98     "BaseCreateThread",
  99     "BaseGetTempFile",
 100     "BaseExitProcess",
 101     // "BaseDebugProcess",
 102     // "BaseCheckVDM",
 103     // "BaseUpdateVDMEntry",
 104     // "BaseGetNextVDMCommand",
 105     // "BaseExitVDM",
 106     // "BaseIsFirstVDM",
 107     // "BaseGetVDMExitCode",
 108     // "BaseSetReenterCount",
 109     "BaseSetProcessShutdownParam",
 110     "BaseGetProcessShutdownParam",
 111     // "BaseNlsSetUserInfo",
 112     // "BaseNlsSetMultipleUserInfo",
 113     // "BaseNlsCreateSection",
 114     // "BaseSetVDMCurDirs",
 115     // "BaseGetVDMCurDirs",
 116     // "BaseBatNotification",
 117     // "BaseRegisterWowExec",
 118     "BaseSoundSentryNotification",
 119     // "BaseRefreshIniFileMapping",
 120     "BaseDefineDosDevice",
 121     // "BaseSetTermsrvAppInstallMode",
 122     // "BaseNlsUpdateCacheCount",
 123     // "BaseSetTermsrvClientTimeZone",
 124     // "BaseSxsCreateActivationContext",
 125     // "BaseRegisterThread",
 126     // "BaseNlsGetUserInfo",
 127 };
 128
 129
 130 /* FUNCTIONS ******************************************************************/
 131
 132 NTSTATUS
 133 NTAPI
 134 CreateBaseAcls(OUT PACL* Dacl,
 135                OUT PACL* RestrictedDacl)
 136 {
 137     PSID SystemSid, WorldSid, RestrictedSid;
 138     SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
 139     SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
 140     NTSTATUS Status;
 141     // UCHAR KeyValueBuffer[0x40];
 142     // PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
 143     // UNICODE_STRING KeyName;
 144     // ULONG ProtectionMode = 0;
 145     ULONG AclLength; // , ResultLength;
 146     // HANDLE hKey;
 147     // OBJECT_ATTRIBUTES ObjectAttributes;
 148
 149     /* Open the Session Manager Key */
 150     /*
 151     RtlInitUnicodeString(&KeyName, SM_REG_KEY);
 152     InitializeObjectAttributes(&ObjectAttributes,
 153                                &KeyName,
 154                                OBJ_CASE_INSENSITIVE,
 155                                NULL,
 156                                NULL);
 157     Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
 158     if (NT_SUCCESS(Status))
 159     {
 160         /\* Read the key value *\/
 161         RtlInitUnicodeString(&KeyName, L"ProtectionMode");
 162         Status = NtQueryValueKey(hKey,
 163                                  &KeyName,
 164                                  KeyValuePartialInformation,
 165                                  KeyValueBuffer,
 166                                  sizeof(KeyValueBuffer),
 167                                  &ResultLength);
 168
 169         /\* Make sure it's what we expect it to be *\/
 170         KeyValuePartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
 171         if ((NT_SUCCESS(Status)) && (KeyValuePartialInfo->Type == REG_DWORD) &&
 172             (*(PULONG)KeyValuePartialInfo->Data))
 173         {
 174             /\* Save the Protection Mode *\/
 175             // ProtectionMode = *(PULONG)KeyValuePartialInfo->Data;
 176         }
 177
 178         /\* Close the handle *\/
 179         NtClose(hKey);
 180     }
 181     */
 182
 183     /* Allocate the System SID */
 184     Status = RtlAllocateAndInitializeSid(&NtAuthority,
 185                                          1, SECURITY_LOCAL_SYSTEM_RID,
 186                                          0, 0, 0, 0, 0, 0, 0,
 187                                          &SystemSid);
 188     ASSERT(NT_SUCCESS(Status));
 189
 190     /* Allocate the World SID */
 191     Status = RtlAllocateAndInitializeSid(&WorldAuthority,
 192                                          1, SECURITY_WORLD_RID,
 193                                          0, 0, 0, 0, 0, 0, 0,
 194                                          &WorldSid);
 195     ASSERT(NT_SUCCESS(Status));
 196
 197     /* Allocate the restricted SID */
 198     Status = RtlAllocateAndInitializeSid(&NtAuthority,
 199                                          1, SECURITY_RESTRICTED_CODE_RID,
 200                                          0, 0, 0, 0, 0, 0, 0,
 201                                          &RestrictedSid);
 202     ASSERT(NT_SUCCESS(Status));
 203
 204     /* Allocate one ACL with 3 ACEs each for one SID */
 205     AclLength = sizeof(ACL) + 3 * sizeof(ACCESS_ALLOWED_ACE) +
 206                     RtlLengthSid(SystemSid) +
 207                     RtlLengthSid(WorldSid)  +
 208                     RtlLengthSid(RestrictedSid);
 209     *Dacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
 210     ASSERT(*Dacl != NULL);
 211
 212     /* Set the correct header fields */
 213     Status = RtlCreateAcl(*Dacl, AclLength, ACL_REVISION2);
 214     ASSERT(NT_SUCCESS(Status));
 215
 216     /* Give the appropriate rights to each SID */
 217     /* FIXME: Should check SessionId/ProtectionMode */
 218     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
 219     ASSERT(NT_SUCCESS(Status));
 220     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
 221     ASSERT(NT_SUCCESS(Status));
 222     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
 223     ASSERT(NT_SUCCESS(Status));
 224
 225     /* Now allocate the restricted DACL */
 226     *RestrictedDacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
 227     ASSERT(*RestrictedDacl != NULL);
 228
 229     /* Initialize it */
 230     Status = RtlCreateAcl(*RestrictedDacl, AclLength, ACL_REVISION2);
 231     ASSERT(NT_SUCCESS(Status));
 232
 233     /* And add the same ACEs as before */
 234     /* FIXME: Not really fully correct */
 235     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
 236     ASSERT(NT_SUCCESS(Status));
 237     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
 238     ASSERT(NT_SUCCESS(Status));
 239     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
 240     ASSERT(NT_SUCCESS(Status));
 241
 242     /* The SIDs are captured, can free them now */
 243     RtlFreeSid(RestrictedSid);
 244     RtlFreeSid(WorldSid);
 245     RtlFreeSid(SystemSid);
 246     return Status;
 247 }
 248
 249 VOID
 250 NTAPI
 251 BaseInitializeStaticServerData(IN PCSR_SERVER_DLL LoadedServerDll)
 252 {
 253     NTSTATUS Status;
 254     WCHAR Buffer[MAX_PATH];
 255     PWCHAR HeapBuffer;
 256     UNICODE_STRING SystemRootString;
 257     UNICODE_STRING UnexpandedSystemRootString = RTL_CONSTANT_STRING(L"%SystemRoot%");
 258     UNICODE_STRING BaseSrvCSDString;
 259     UNICODE_STRING BaseSrvWindowsDirectory;
 260     UNICODE_STRING BaseSrvWindowsSystemDirectory;
 261     UNICODE_STRING BnoString;
 262     OBJECT_ATTRIBUTES ObjectAttributes;
 263     ULONG SessionId;
 264     HANDLE BaseSrvNamedObjectDirectory;
 265     HANDLE BaseSrvRestrictedObjectDirectory;
 266     PACL BnoDacl, BnoRestrictedDacl;
 267     PSECURITY_DESCRIPTOR BnoSd;
 268     HANDLE SymHandle;
 269     UNICODE_STRING DirectoryName, SymlinkName;
 270     ULONG LuidEnabled;
 271     RTL_QUERY_REGISTRY_TABLE BaseServerRegistryConfigurationTable[2] =
 272     {
 273         {
 274             NULL,
 275             RTL_QUERY_REGISTRY_DIRECT,
 276             L"CSDVersion",
 277             &BaseSrvCSDString,
 278             REG_NONE, NULL, 0
 279         },
 280
 281         {0}
 282     };
 283
 284     /* Initialize the memory */
 285     BaseSrvHeap = RtlGetProcessHeap();                  // Initialize our own heap.
 286     BaseSrvSharedHeap = LoadedServerDll->SharedSection; // Get the CSR shared heap.
 287
 288     /* Get the session ID */
 289     SessionId = NtCurrentPeb()->SessionId;
 290
 291     /* Get the Windows directory */
 292     RtlInitEmptyUnicodeString(&SystemRootString, Buffer, sizeof(Buffer));
 293     Status = RtlExpandEnvironmentStrings_U(NULL,
 294                                            &UnexpandedSystemRootString,
 295                                            &SystemRootString,
 296                                            NULL);
 297     ASSERT(NT_SUCCESS(Status));
 298
 299     /* Create the base directory */
 300     Buffer[SystemRootString.Length / sizeof(WCHAR)] = UNICODE_NULL;
 301     Status = RtlCreateUnicodeString(&BaseSrvWindowsDirectory,
 302                                     SystemRootString.Buffer);
 303     ASSERT(NT_SUCCESS(Status));
 304
 305     /* Create the system directory */
 306     wcscat(SystemRootString.Buffer, L"\\System32");
 307     Status = RtlCreateUnicodeString(&BaseSrvWindowsSystemDirectory,
 308                                     SystemRootString.Buffer);
 309     ASSERT(NT_SUCCESS(Status));
 310
 311     /* FIXME: Check Session ID */
 312     wcscpy(Buffer, L"\\BaseNamedObjects");
 313     RtlInitUnicodeString(&BnoString, Buffer);
 314
 315     /* Allocate the server data */
 316     BaseStaticServerData = RtlAllocateHeap(BaseSrvSharedHeap,
 317                                            HEAP_ZERO_MEMORY,
 318                                            sizeof(BASE_STATIC_SERVER_DATA));
 319     ASSERT(BaseStaticServerData != NULL);
 320
 321     /* Process timezone information */
 322     BaseStaticServerData->TermsrvClientTimeZoneId = TIME_ZONE_ID_INVALID;
 323     BaseStaticServerData->TermsrvClientTimeZoneChangeNum = 0;
 324     Status = NtQuerySystemInformation(SystemTimeOfDayInformation,
 325                                       &BaseStaticServerData->TimeOfDay,
 326                                       sizeof(BaseStaticServerData->TimeOfDay),
 327                                       NULL);
 328     ASSERT(NT_SUCCESS(Status));
 329
 330     /* Make a shared heap copy of the Windows directory */
 331     BaseStaticServerData->WindowsDirectory = BaseSrvWindowsDirectory;
 332     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 333                                  0,
 334                                  BaseSrvWindowsDirectory.MaximumLength);
 335     ASSERT(HeapBuffer);
 336     RtlCopyMemory(HeapBuffer,
 337                   BaseStaticServerData->WindowsDirectory.Buffer,
 338                   BaseSrvWindowsDirectory.MaximumLength);
 339     BaseStaticServerData->WindowsDirectory.Buffer = HeapBuffer;
 340
 341     /* Make a shared heap copy of the System directory */
 342     BaseStaticServerData->WindowsSystemDirectory = BaseSrvWindowsSystemDirectory;
 343     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 344                                  0,
 345                                  BaseSrvWindowsSystemDirectory.MaximumLength);
 346     ASSERT(HeapBuffer);
 347     RtlCopyMemory(HeapBuffer,
 348                   BaseStaticServerData->WindowsSystemDirectory.Buffer,
 349                   BaseSrvWindowsSystemDirectory.MaximumLength);
 350     BaseStaticServerData->WindowsSystemDirectory.Buffer = HeapBuffer;
 351
 352     /* This string is not used */
 353     RtlInitEmptyUnicodeString(&BaseStaticServerData->WindowsSys32x86Directory,
 354                               NULL,
 355                               0);
 356
 357     /* Make a shared heap copy of the BNO directory */
 358     BaseStaticServerData->NamedObjectDirectory = BnoString;
 359     BaseStaticServerData->NamedObjectDirectory.MaximumLength = BnoString.Length +
 360                                                                sizeof(UNICODE_NULL);
 361     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 362                                  0,
 363                                  BaseStaticServerData->NamedObjectDirectory.MaximumLength);
 364     ASSERT(HeapBuffer);
 365     RtlCopyMemory(HeapBuffer,
 366                   BaseStaticServerData->NamedObjectDirectory.Buffer,
 367                   BaseStaticServerData->NamedObjectDirectory.MaximumLength);
 368     BaseStaticServerData->NamedObjectDirectory.Buffer = HeapBuffer;
 369
 370     /*
 371      * Confirmed that in Windows, CSDNumber and RCNumber are actually Length
 372      * and MaximumLength of the CSD String, since the same UNICODE_STRING is
 373      * being queried twice, the first time as a ULONG!
 374      *
 375      * Somehow, in Windows this doesn't cause a buffer overflow, but it might
 376      * in ReactOS, so this code is disabled until someone figures out WTF.
 377      */
 378     BaseStaticServerData->CSDNumber = 0;
 379     BaseStaticServerData->RCNumber = 0;
 380
 381     /* Initialize the CSD string and query its value from the registry */
 382     RtlInitEmptyUnicodeString(&BaseSrvCSDString, Buffer, sizeof(Buffer));
 383     Status = RtlQueryRegistryValues(RTL_REGISTRY_WINDOWS_NT,
 384                                     L"",
 385                                     BaseServerRegistryConfigurationTable,
 386                                     NULL,
 387                                     NULL);
 388     if (NT_SUCCESS(Status))
 389     {
 390         /* Copy into the shared buffer */
 391         wcsncpy(BaseStaticServerData->CSDVersion,
 392                 BaseSrvCSDString.Buffer,
 393                 BaseSrvCSDString.Length / sizeof(WCHAR));
 394     }
 395     else
 396     {
 397         /* NULL-terminate to indicate nothing is there */
 398         BaseStaticServerData->CSDVersion[0] = UNICODE_NULL;
 399     }
 400
 401     /* Cache the system information */
 402     Status = NtQuerySystemInformation(SystemBasicInformation,
 403                                       &BaseStaticServerData->SysInfo,
 404                                       sizeof(BaseStaticServerData->SysInfo),
 405                                       NULL);
 406     ASSERT(NT_SUCCESS(Status));
 407
 408     /* FIXME: Should query the registry for these */
 409     BaseStaticServerData->DefaultSeparateVDM = FALSE;
 410     BaseStaticServerData->IsWowTaskReady = FALSE;
 411
 412     /* Allocate a security descriptor and create it */
 413     BnoSd = RtlAllocateHeap(BaseSrvHeap, 0, 1024);
 414     ASSERT(BnoSd);
 415     Status = RtlCreateSecurityDescriptor(BnoSd, SECURITY_DESCRIPTOR_REVISION);
 416     ASSERT(NT_SUCCESS(Status));
 417
 418     /* Create the BNO and \Restricted DACLs */
 419     Status = CreateBaseAcls(&BnoDacl, &BnoRestrictedDacl);
 420     ASSERT(NT_SUCCESS(Status));
 421
 422     /* Set the BNO DACL as active for now */
 423     Status = RtlSetDaclSecurityDescriptor(BnoSd, TRUE, BnoDacl, FALSE);
 424     ASSERT(NT_SUCCESS(Status));
 425
 426     /* Create the BNO directory */
 427     RtlInitUnicodeString(&BnoString, L"\\BaseNamedObjects");
 428     InitializeObjectAttributes(&ObjectAttributes,
 429                                &BnoString,
 430                                OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 431                                NULL,
 432                                BnoSd);
 433     Status = NtCreateDirectoryObject(&BaseSrvNamedObjectDirectory,
 434                                      DIRECTORY_ALL_ACCESS,
 435                                      &ObjectAttributes);
 436     ASSERT(NT_SUCCESS(Status));
 437
 438     /* Check if we are session 0 */
 439     if (SessionId == 0)
 440     {
 441         /* Mark this as a session 0 directory */
 442         Status = NtSetInformationObject(BaseSrvNamedObjectDirectory,
 443                                         ObjectSessionInformation,
 444                                         NULL,
 445                                         0);
 446         ASSERT(NT_SUCCESS(Status));
 447     }
 448
 449     /* Check if LUID device maps are enabled */
 450     Status = NtQueryInformationProcess(NtCurrentProcess(),
 451                                        ProcessLUIDDeviceMapsEnabled,
 452                                        &LuidEnabled,
 453                                        sizeof(LuidEnabled),
 454                                        NULL);
 455     ASSERT(NT_SUCCESS(Status));
 456     BaseStaticServerData->LUIDDeviceMapsEnabled = LuidEnabled;
 457     if (!BaseStaticServerData->LUIDDeviceMapsEnabled)
 458     {
 459         /* Make Global point back to BNO */
 460         RtlInitUnicodeString(&DirectoryName, L"Global");
 461         RtlInitUnicodeString(&SymlinkName, L"\\BaseNamedObjects");
 462         InitializeObjectAttributes(&ObjectAttributes,
 463                                    &DirectoryName,
 464                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 465                                    BaseSrvNamedObjectDirectory,
 466                                    BnoSd);
 467         Status = NtCreateSymbolicLinkObject(&SymHandle,
 468                                             SYMBOLIC_LINK_ALL_ACCESS,
 469                                             &ObjectAttributes,
 470                                             &SymlinkName);
 471         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 472
 473         /* Make local point back to \Sessions\x\BNO */
 474         RtlInitUnicodeString(&DirectoryName, L"Local");
 475         ASSERT(SessionId == 0);
 476         InitializeObjectAttributes(&ObjectAttributes,
 477                                    &DirectoryName,
 478                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 479                                    BaseSrvNamedObjectDirectory,
 480                                    BnoSd);
 481         Status = NtCreateSymbolicLinkObject(&SymHandle,
 482                                             SYMBOLIC_LINK_ALL_ACCESS,
 483                                             &ObjectAttributes,
 484                                             &SymlinkName);
 485         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 486
 487         /* Make Session point back to BNOLINKS */
 488         RtlInitUnicodeString(&DirectoryName, L"Session");
 489         RtlInitUnicodeString(&SymlinkName, L"\\Sessions\\BNOLINKS");
 490         InitializeObjectAttributes(&ObjectAttributes,
 491                                    &DirectoryName,
 492                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 493                                    BaseSrvNamedObjectDirectory,
 494                                    BnoSd);
 495         Status = NtCreateSymbolicLinkObject(&SymHandle,
 496                                             SYMBOLIC_LINK_ALL_ACCESS,
 497                                             &ObjectAttributes,
 498                                             &SymlinkName);
 499         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 500
 501         /* Create the BNO\Restricted directory and set the restricted DACL */
 502         RtlInitUnicodeString(&DirectoryName, L"Restricted");
 503         Status = RtlSetDaclSecurityDescriptor(BnoSd, TRUE, BnoRestrictedDacl, FALSE);
 504         ASSERT(NT_SUCCESS(Status));
 505         InitializeObjectAttributes(&ObjectAttributes,
 506                                    &DirectoryName,
 507                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 508                                    BaseSrvNamedObjectDirectory,
 509                                    BnoSd);
 510         Status = NtCreateDirectoryObject(&BaseSrvRestrictedObjectDirectory,
 511                                          DIRECTORY_ALL_ACCESS,
 512                                          &ObjectAttributes);
 513         ASSERT(NT_SUCCESS(Status));
 514     }
 515
 516     /* Finally, set the pointer */
 517     LoadedServerDll->SharedSection = BaseStaticServerData;
 518 }
 519
 520 CSR_SERVER_DLL_INIT(ServerDllInitialization)
 521 {
 522     /* Setup the DLL Object */
 523     LoadedServerDll->ApiBase = BASESRV_FIRST_API_NUMBER; // ApiNumberBase
 524     LoadedServerDll->HighestApiSupported = BasepMaxApiNumber; // MaxApiNumber
 525     LoadedServerDll->DispatchTable = BaseServerApiDispatchTable;
 526     LoadedServerDll->ValidTable = BaseServerApiServerValidTable;
 527     LoadedServerDll->NameTable = BaseServerApiNameTable;
 528     LoadedServerDll->SizeOfProcessData = 0;
 529     LoadedServerDll->ConnectCallback = NULL;
 530     LoadedServerDll->DisconnectCallback = NULL;
 531     LoadedServerDll->ShutdownProcessCallback = NULL;
 532
 533     BaseSrvDllInstance = LoadedServerDll->ServerHandle;
 534
 535     BaseInitializeStaticServerData(LoadedServerDll);
 536
 537     /* Initialize DOS devices management */
 538     BaseInitDefineDosDevice();
 539
 540     /* All done */
 541     return STATUS_SUCCESS;
 542 }
 543
 544 BOOL
 545 NTAPI
 546 DllMain(IN HINSTANCE hInstanceDll,
 547         IN DWORD dwReason,
 548         IN LPVOID lpReserved)
 549 {
 550     UNREFERENCED_PARAMETER(hInstanceDll);
 551     UNREFERENCED_PARAMETER(dwReason);
 552     UNREFERENCED_PARAMETER(lpReserved);
 553
 554     if (DLL_PROCESS_DETACH == dwReason)
 555     {
 556         BaseCleanupDefineDosDevice();
 557     }
 558
 559     return TRUE;
 560 }
 561
 562 /* EOF */