8edeefc5b7c52922f9b42f86432ecdefa2bdb7c0
[reactos.git] / 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 = 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 */