reactos/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 #if 0 // Unused code
 142     UCHAR KeyValueBuffer[0x40];
 143     PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
 144     UNICODE_STRING KeyName;
 145     ULONG ProtectionMode = 0;
 146 #endif
 147     ULONG AclLength;
 148 #if 0 // Unused code
 149     ULONG ResultLength;
 150     HANDLE hKey;
 151     OBJECT_ATTRIBUTES ObjectAttributes;
 152
 153     /* Open the Session Manager Key */
 154     RtlInitUnicodeString(&KeyName, SM_REG_KEY);
 155     InitializeObjectAttributes(&ObjectAttributes,
 156                                &KeyName,
 157                                OBJ_CASE_INSENSITIVE,
 158                                NULL,
 159                                NULL);
 160     Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
 161     if (NT_SUCCESS(Status))
 162     {
 163         /* Read the key value */
 164         RtlInitUnicodeString(&KeyName, L"ProtectionMode");
 165         Status = NtQueryValueKey(hKey,
 166                                  &KeyName,
 167                                  KeyValuePartialInformation,
 168                                  KeyValueBuffer,
 169                                  sizeof(KeyValueBuffer),
 170                                  &ResultLength);
 171
 172         /* Make sure it's what we expect it to be */
 173         KeyValuePartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
 174         if ((NT_SUCCESS(Status)) && (KeyValuePartialInfo->Type == REG_DWORD) &&
 175             (*(PULONG)KeyValuePartialInfo->Data))
 176         {
 177             /* Save the Protection Mode */
 178             ProtectionMode = *(PULONG)KeyValuePartialInfo->Data;
 179         }
 180
 181         /* Close the handle */
 182         NtClose(hKey);
 183     }
 184 #endif
 185
 186     /* Allocate the System SID */
 187     Status = RtlAllocateAndInitializeSid(&NtAuthority,
 188                                          1, SECURITY_LOCAL_SYSTEM_RID,
 189                                          0, 0, 0, 0, 0, 0, 0,
 190                                          &SystemSid);
 191     ASSERT(NT_SUCCESS(Status));
 192
 193     /* Allocate the World SID */
 194     Status = RtlAllocateAndInitializeSid(&WorldAuthority,
 195                                          1, SECURITY_WORLD_RID,
 196                                          0, 0, 0, 0, 0, 0, 0,
 197                                          &WorldSid);
 198     ASSERT(NT_SUCCESS(Status));
 199
 200     /* Allocate the restricted SID */
 201     Status = RtlAllocateAndInitializeSid(&NtAuthority,
 202                                          1, SECURITY_RESTRICTED_CODE_RID,
 203                                          0, 0, 0, 0, 0, 0, 0,
 204                                          &RestrictedSid);
 205     ASSERT(NT_SUCCESS(Status));
 206
 207     /* Allocate one ACL with 3 ACEs each for one SID */
 208     AclLength = sizeof(ACL) + 3 * sizeof(ACCESS_ALLOWED_ACE) +
 209                     RtlLengthSid(SystemSid) +
 210                     RtlLengthSid(WorldSid)  +
 211                     RtlLengthSid(RestrictedSid);
 212     *Dacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
 213     ASSERT(*Dacl != NULL);
 214
 215     /* Set the correct header fields */
 216     Status = RtlCreateAcl(*Dacl, AclLength, ACL_REVISION2);
 217     ASSERT(NT_SUCCESS(Status));
 218
 219     /* Give the appropriate rights to each SID */
 220     /* FIXME: Should check SessionId/ProtectionMode */
 221     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
 222     ASSERT(NT_SUCCESS(Status));
 223     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
 224     ASSERT(NT_SUCCESS(Status));
 225     Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
 226     ASSERT(NT_SUCCESS(Status));
 227
 228     /* Now allocate the restricted DACL */
 229     *RestrictedDacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
 230     ASSERT(*RestrictedDacl != NULL);
 231
 232     /* Initialize it */
 233     Status = RtlCreateAcl(*RestrictedDacl, AclLength, ACL_REVISION2);
 234     ASSERT(NT_SUCCESS(Status));
 235
 236     /* And add the same ACEs as before */
 237     /* FIXME: Not really fully correct */
 238     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
 239     ASSERT(NT_SUCCESS(Status));
 240     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
 241     ASSERT(NT_SUCCESS(Status));
 242     Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
 243     ASSERT(NT_SUCCESS(Status));
 244
 245     /* The SIDs are captured, can free them now */
 246     RtlFreeSid(RestrictedSid);
 247     RtlFreeSid(WorldSid);
 248     RtlFreeSid(SystemSid);
 249     return Status;
 250 }
 251
 252 VOID
 253 NTAPI
 254 BaseInitializeStaticServerData(IN PCSR_SERVER_DLL LoadedServerDll)
 255 {
 256     NTSTATUS Status;
 257     WCHAR Buffer[MAX_PATH];
 258     PWCHAR HeapBuffer;
 259     UNICODE_STRING SystemRootString;
 260     UNICODE_STRING UnexpandedSystemRootString = RTL_CONSTANT_STRING(L"%SystemRoot%");
 261     UNICODE_STRING BaseSrvCSDString;
 262     UNICODE_STRING BaseSrvWindowsDirectory;
 263     UNICODE_STRING BaseSrvWindowsSystemDirectory;
 264     UNICODE_STRING BnoString;
 265     OBJECT_ATTRIBUTES ObjectAttributes;
 266     ULONG SessionId;
 267     HANDLE BaseSrvNamedObjectDirectory;
 268     HANDLE BaseSrvRestrictedObjectDirectory;
 269     PACL BnoDacl, BnoRestrictedDacl;
 270     PSECURITY_DESCRIPTOR BnoSd;
 271     HANDLE SymHandle;
 272     UNICODE_STRING DirectoryName, SymlinkName;
 273     ULONG LuidEnabled;
 274     RTL_QUERY_REGISTRY_TABLE BaseServerRegistryConfigurationTable[2] =
 275     {
 276         {
 277             NULL,
 278             RTL_QUERY_REGISTRY_DIRECT,
 279             L"CSDVersion",
 280             &BaseSrvCSDString,
 281             REG_NONE, NULL, 0
 282         },
 283
 284         {0}
 285     };
 286
 287     /* Initialize the memory */
 288     BaseSrvHeap = RtlGetProcessHeap();                  // Initialize our own heap.
 289     BaseSrvSharedHeap = LoadedServerDll->SharedSection; // Get the CSR shared heap.
 290
 291     /* Get the session ID */
 292     SessionId = NtCurrentPeb()->SessionId;
 293
 294     /* Get the Windows directory */
 295     RtlInitEmptyUnicodeString(&SystemRootString, Buffer, sizeof(Buffer));
 296     Status = RtlExpandEnvironmentStrings_U(NULL,
 297                                            &UnexpandedSystemRootString,
 298                                            &SystemRootString,
 299                                            NULL);
 300     ASSERT(NT_SUCCESS(Status));
 301
 302     /* Create the base directory */
 303     Buffer[SystemRootString.Length / sizeof(WCHAR)] = UNICODE_NULL;
 304     Status = RtlCreateUnicodeString(&BaseSrvWindowsDirectory,
 305                                     SystemRootString.Buffer);
 306     ASSERT(NT_SUCCESS(Status));
 307
 308     /* Create the system directory */
 309     wcscat(SystemRootString.Buffer, L"\\System32");
 310     Status = RtlCreateUnicodeString(&BaseSrvWindowsSystemDirectory,
 311                                     SystemRootString.Buffer);
 312     ASSERT(NT_SUCCESS(Status));
 313
 314     /* FIXME: Check Session ID */
 315     wcscpy(Buffer, L"\\BaseNamedObjects");
 316     RtlInitUnicodeString(&BnoString, Buffer);
 317
 318     /* Allocate the server data */
 319     BaseStaticServerData = RtlAllocateHeap(BaseSrvSharedHeap,
 320                                            HEAP_ZERO_MEMORY,
 321                                            sizeof(BASE_STATIC_SERVER_DATA));
 322     ASSERT(BaseStaticServerData != NULL);
 323
 324     /* Process timezone information */
 325     BaseStaticServerData->TermsrvClientTimeZoneId = TIME_ZONE_ID_INVALID;
 326     BaseStaticServerData->TermsrvClientTimeZoneChangeNum = 0;
 327     Status = NtQuerySystemInformation(SystemTimeOfDayInformation,
 328                                       &BaseStaticServerData->TimeOfDay,
 329                                       sizeof(BaseStaticServerData->TimeOfDay),
 330                                       NULL);
 331     ASSERT(NT_SUCCESS(Status));
 332
 333     /* Make a shared heap copy of the Windows directory */
 334     BaseStaticServerData->WindowsDirectory = BaseSrvWindowsDirectory;
 335     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 336                                  0,
 337                                  BaseSrvWindowsDirectory.MaximumLength);
 338     ASSERT(HeapBuffer);
 339     RtlCopyMemory(HeapBuffer,
 340                   BaseStaticServerData->WindowsDirectory.Buffer,
 341                   BaseSrvWindowsDirectory.MaximumLength);
 342     BaseStaticServerData->WindowsDirectory.Buffer = HeapBuffer;
 343
 344     /* Make a shared heap copy of the System directory */
 345     BaseStaticServerData->WindowsSystemDirectory = BaseSrvWindowsSystemDirectory;
 346     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 347                                  0,
 348                                  BaseSrvWindowsSystemDirectory.MaximumLength);
 349     ASSERT(HeapBuffer);
 350     RtlCopyMemory(HeapBuffer,
 351                   BaseStaticServerData->WindowsSystemDirectory.Buffer,
 352                   BaseSrvWindowsSystemDirectory.MaximumLength);
 353     BaseStaticServerData->WindowsSystemDirectory.Buffer = HeapBuffer;
 354
 355     /* This string is not used */
 356     RtlInitEmptyUnicodeString(&BaseStaticServerData->WindowsSys32x86Directory,
 357                               NULL,
 358                               0);
 359
 360     /* Make a shared heap copy of the BNO directory */
 361     BaseStaticServerData->NamedObjectDirectory = BnoString;
 362     BaseStaticServerData->NamedObjectDirectory.MaximumLength = BnoString.Length +
 363                                                                sizeof(UNICODE_NULL);
 364     HeapBuffer = RtlAllocateHeap(BaseSrvSharedHeap,
 365                                  0,
 366                                  BaseStaticServerData->NamedObjectDirectory.MaximumLength);
 367     ASSERT(HeapBuffer);
 368     RtlCopyMemory(HeapBuffer,
 369                   BaseStaticServerData->NamedObjectDirectory.Buffer,
 370                   BaseStaticServerData->NamedObjectDirectory.MaximumLength);
 371     BaseStaticServerData->NamedObjectDirectory.Buffer = HeapBuffer;
 372
 373     /*
 374      * Confirmed that in Windows, CSDNumber and RCNumber are actually Length
 375      * and MaximumLength of the CSD String, since the same UNICODE_STRING is
 376      * being queried twice, the first time as a ULONG!
 377      *
 378      * Somehow, in Windows this doesn't cause a buffer overflow, but it might
 379      * in ReactOS, so this code is disabled until someone figures out WTF.
 380      */
 381     BaseStaticServerData->CSDNumber = 0;
 382     BaseStaticServerData->RCNumber = 0;
 383
 384     /* Initialize the CSD string and query its value from the registry */
 385     RtlInitEmptyUnicodeString(&BaseSrvCSDString, Buffer, sizeof(Buffer));
 386     Status = RtlQueryRegistryValues(RTL_REGISTRY_WINDOWS_NT,
 387                                     L"",
 388                                     BaseServerRegistryConfigurationTable,
 389                                     NULL,
 390                                     NULL);
 391     if (NT_SUCCESS(Status))
 392     {
 393         /* Copy into the shared buffer */
 394         wcsncpy(BaseStaticServerData->CSDVersion,
 395                 BaseSrvCSDString.Buffer,
 396                 BaseSrvCSDString.Length / sizeof(WCHAR));
 397     }
 398     else
 399     {
 400         /* NULL-terminate to indicate nothing is there */
 401         BaseStaticServerData->CSDVersion[0] = UNICODE_NULL;
 402     }
 403
 404     /* Cache the system information */
 405     Status = NtQuerySystemInformation(SystemBasicInformation,
 406                                       &BaseStaticServerData->SysInfo,
 407                                       sizeof(BaseStaticServerData->SysInfo),
 408                                       NULL);
 409     ASSERT(NT_SUCCESS(Status));
 410
 411     /* FIXME: Should query the registry for these */
 412     BaseStaticServerData->DefaultSeparateVDM = FALSE;
 413     BaseStaticServerData->IsWowTaskReady = FALSE;
 414
 415     /* Allocate a security descriptor and create it */
 416     BnoSd = RtlAllocateHeap(BaseSrvHeap, 0, 1024);
 417     ASSERT(BnoSd);
 418     Status = RtlCreateSecurityDescriptor(BnoSd, SECURITY_DESCRIPTOR_REVISION);
 419     ASSERT(NT_SUCCESS(Status));
 420
 421     /* Create the BNO and \Restricted DACLs */
 422     Status = CreateBaseAcls(&BnoDacl, &BnoRestrictedDacl);
 423     ASSERT(NT_SUCCESS(Status));
 424
 425     /* Set the BNO DACL as active for now */
 426     Status = RtlSetDaclSecurityDescriptor(BnoSd, TRUE, BnoDacl, FALSE);
 427     ASSERT(NT_SUCCESS(Status));
 428
 429     /* Create the BNO directory */
 430     RtlInitUnicodeString(&BnoString, L"\\BaseNamedObjects");
 431     InitializeObjectAttributes(&ObjectAttributes,
 432                                &BnoString,
 433                                OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 434                                NULL,
 435                                BnoSd);
 436     Status = NtCreateDirectoryObject(&BaseSrvNamedObjectDirectory,
 437                                      DIRECTORY_ALL_ACCESS,
 438                                      &ObjectAttributes);
 439     ASSERT(NT_SUCCESS(Status));
 440
 441     /* Check if we are session 0 */
 442     if (SessionId == 0)
 443     {
 444         /* Mark this as a session 0 directory */
 445         Status = NtSetInformationObject(BaseSrvNamedObjectDirectory,
 446                                         ObjectSessionInformation,
 447                                         NULL,
 448                                         0);
 449         ASSERT(NT_SUCCESS(Status));
 450     }
 451
 452     /* Check if LUID device maps are enabled */
 453     Status = NtQueryInformationProcess(NtCurrentProcess(),
 454                                        ProcessLUIDDeviceMapsEnabled,
 455                                        &LuidEnabled,
 456                                        sizeof(LuidEnabled),
 457                                        NULL);
 458     ASSERT(NT_SUCCESS(Status));
 459     BaseStaticServerData->LUIDDeviceMapsEnabled = (BOOLEAN)LuidEnabled;
 460     if (!BaseStaticServerData->LUIDDeviceMapsEnabled)
 461     {
 462         /* Make Global point back to BNO */
 463         RtlInitUnicodeString(&DirectoryName, L"Global");
 464         RtlInitUnicodeString(&SymlinkName, L"\\BaseNamedObjects");
 465         InitializeObjectAttributes(&ObjectAttributes,
 466                                    &DirectoryName,
 467                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 468                                    BaseSrvNamedObjectDirectory,
 469                                    BnoSd);
 470         Status = NtCreateSymbolicLinkObject(&SymHandle,
 471                                             SYMBOLIC_LINK_ALL_ACCESS,
 472                                             &ObjectAttributes,
 473                                             &SymlinkName);
 474         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 475
 476         /* Make local point back to \Sessions\x\BNO */
 477         RtlInitUnicodeString(&DirectoryName, L"Local");
 478         ASSERT(SessionId == 0);
 479         InitializeObjectAttributes(&ObjectAttributes,
 480                                    &DirectoryName,
 481                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 482                                    BaseSrvNamedObjectDirectory,
 483                                    BnoSd);
 484         Status = NtCreateSymbolicLinkObject(&SymHandle,
 485                                             SYMBOLIC_LINK_ALL_ACCESS,
 486                                             &ObjectAttributes,
 487                                             &SymlinkName);
 488         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 489
 490         /* Make Session point back to BNOLINKS */
 491         RtlInitUnicodeString(&DirectoryName, L"Session");
 492         RtlInitUnicodeString(&SymlinkName, L"\\Sessions\\BNOLINKS");
 493         InitializeObjectAttributes(&ObjectAttributes,
 494                                    &DirectoryName,
 495                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 496                                    BaseSrvNamedObjectDirectory,
 497                                    BnoSd);
 498         Status = NtCreateSymbolicLinkObject(&SymHandle,
 499                                             SYMBOLIC_LINK_ALL_ACCESS,
 500                                             &ObjectAttributes,
 501                                             &SymlinkName);
 502         if ((NT_SUCCESS(Status)) && SessionId == 0) NtClose(SymHandle);
 503
 504         /* Create the BNO\Restricted directory and set the restricted DACL */
 505         RtlInitUnicodeString(&DirectoryName, L"Restricted");
 506         Status = RtlSetDaclSecurityDescriptor(BnoSd, TRUE, BnoRestrictedDacl, FALSE);
 507         ASSERT(NT_SUCCESS(Status));
 508         InitializeObjectAttributes(&ObjectAttributes,
 509                                    &DirectoryName,
 510                                    OBJ_OPENIF | OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
 511                                    BaseSrvNamedObjectDirectory,
 512                                    BnoSd);
 513         Status = NtCreateDirectoryObject(&BaseSrvRestrictedObjectDirectory,
 514                                          DIRECTORY_ALL_ACCESS,
 515                                          &ObjectAttributes);
 516         ASSERT(NT_SUCCESS(Status));
 517     }
 518
 519     /* Finally, set the pointer */
 520     LoadedServerDll->SharedSection = BaseStaticServerData;
 521 }
 522
 523 CSR_SERVER_DLL_INIT(ServerDllInitialization)
 524 {
 525     /* Setup the DLL Object */
 526     LoadedServerDll->ApiBase = BASESRV_FIRST_API_NUMBER;
 527     LoadedServerDll->HighestApiSupported = BasepMaxApiNumber;
 528     LoadedServerDll->DispatchTable = BaseServerApiDispatchTable;
 529     LoadedServerDll->ValidTable = BaseServerApiServerValidTable;
 530     LoadedServerDll->NameTable = BaseServerApiNameTable;
 531     LoadedServerDll->SizeOfProcessData = 0;
 532     LoadedServerDll->ConnectCallback = NULL;
 533     LoadedServerDll->DisconnectCallback = NULL;
 534     LoadedServerDll->ShutdownProcessCallback = NULL;
 535
 536     BaseSrvDllInstance = LoadedServerDll->ServerHandle;
 537
 538     BaseInitializeStaticServerData(LoadedServerDll);
 539
 540     /* Initialize DOS devices management */
 541     BaseInitDefineDosDevice();
 542
 543     /* All done */
 544     return STATUS_SUCCESS;
 545 }
 546
 547 BOOL
 548 NTAPI
 549 DllMain(IN HINSTANCE hInstanceDll,
 550         IN DWORD dwReason,
 551         IN LPVOID lpReserved)
 552 {
 553     UNREFERENCED_PARAMETER(hInstanceDll);
 554     UNREFERENCED_PARAMETER(dwReason);
 555     UNREFERENCED_PARAMETER(lpReserved);
 556
 557     if (DLL_PROCESS_DETACH == dwReason)
 558     {
 559         BaseCleanupDefineDosDevice();
 560     }
 561
 562     return TRUE;
 563 }
 564
 565 /* EOF */