8a16a14744f11d27c3637e7823a83fa855039691
[reactos.git] / reactos / dll / win32 / kernel32 / client / utils.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/kernel32/client/utils.c
5 * PURPOSE: Utility and Support Functions
6 * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
7 * Pierre Schweitzer (pierre.schweitzer@reactos.org)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <k32.h>
13 #ifdef _M_IX86
14 #include "i386/ketypes.h"
15 #elif defined _M_AMD64
16 #include "amd64/ketypes.h"
17 #endif
18
19 #define NDEBUG
20 #include <debug.h>
21
22 /* GLOBALS ********************************************************************/
23
24 UNICODE_STRING Restricted = RTL_CONSTANT_STRING(L"Restricted");
25 BOOL bIsFileApiAnsi = TRUE; // set the file api to ansi or oem
26 PRTL_CONVERT_STRING Basep8BitStringToUnicodeString = RtlAnsiStringToUnicodeString;
27 PRTL_CONVERT_STRINGA BasepUnicodeStringTo8BitString = RtlUnicodeStringToAnsiString;
28 PRTL_COUNT_STRING BasepUnicodeStringTo8BitSize = BasepUnicodeStringToAnsiSize;
29 PRTL_COUNT_STRINGA Basep8BitStringToUnicodeSize = BasepAnsiStringToUnicodeSize;
30
31 /* FUNCTIONS ******************************************************************/
32
33 ULONG
34 NTAPI
35 BasepUnicodeStringToOemSize(IN PUNICODE_STRING String)
36 {
37 return RtlUnicodeStringToOemSize(String);
38 }
39
40 ULONG
41 NTAPI
42 BasepOemStringToUnicodeSize(IN PANSI_STRING String)
43 {
44 return RtlOemStringToUnicodeSize(String);
45 }
46
47 ULONG
48 NTAPI
49 BasepUnicodeStringToAnsiSize(IN PUNICODE_STRING String)
50 {
51 return RtlUnicodeStringToAnsiSize(String);
52 }
53
54 ULONG
55 NTAPI
56 BasepAnsiStringToUnicodeSize(IN PANSI_STRING String)
57 {
58 return RtlAnsiStringToUnicodeSize(String);
59 }
60
61 HANDLE
62 WINAPI
63 BaseGetNamedObjectDirectory(VOID)
64 {
65 OBJECT_ATTRIBUTES ObjectAttributes;
66 NTSTATUS Status;
67 HANDLE DirHandle, BnoHandle, Token, NewToken;
68
69 if (BaseNamedObjectDirectory) return BaseNamedObjectDirectory;
70
71 if (NtCurrentTeb()->IsImpersonating)
72 {
73 Status = NtOpenThreadToken(NtCurrentThread(),
74 TOKEN_IMPERSONATE,
75 TRUE,
76 &Token);
77 if (!NT_SUCCESS(Status)) return BaseNamedObjectDirectory;
78
79 NewToken = NULL;
80 Status = NtSetInformationThread(NtCurrentThread(),
81 ThreadImpersonationToken,
82 &NewToken,
83 sizeof(HANDLE));
84 if (!NT_SUCCESS (Status))
85 {
86 NtClose(Token);
87 return BaseNamedObjectDirectory;
88 }
89 }
90 else
91 {
92 Token = NULL;
93 }
94
95 RtlAcquirePebLock();
96 if (BaseNamedObjectDirectory) goto Quickie;
97
98 InitializeObjectAttributes(&ObjectAttributes,
99 &BaseStaticServerData->NamedObjectDirectory,
100 OBJ_CASE_INSENSITIVE,
101 NULL,
102 NULL);
103
104 Status = NtOpenDirectoryObject(&BnoHandle,
105 DIRECTORY_QUERY |
106 DIRECTORY_TRAVERSE |
107 DIRECTORY_CREATE_OBJECT |
108 DIRECTORY_CREATE_SUBDIRECTORY,
109 &ObjectAttributes);
110 if (!NT_SUCCESS(Status))
111 {
112 Status = NtOpenDirectoryObject(&DirHandle,
113 DIRECTORY_TRAVERSE,
114 &ObjectAttributes);
115
116 if (NT_SUCCESS(Status))
117 {
118 InitializeObjectAttributes(&ObjectAttributes,
119 (PUNICODE_STRING)&Restricted,
120 OBJ_CASE_INSENSITIVE,
121 DirHandle,
122 NULL);
123
124 Status = NtOpenDirectoryObject(&BnoHandle,
125 DIRECTORY_QUERY |
126 DIRECTORY_TRAVERSE |
127 DIRECTORY_CREATE_OBJECT |
128 DIRECTORY_CREATE_SUBDIRECTORY,
129 &ObjectAttributes);
130 NtClose(DirHandle);
131
132 }
133 }
134
135 if (NT_SUCCESS(Status)) BaseNamedObjectDirectory = BnoHandle;
136
137 Quickie:
138
139 RtlReleasePebLock();
140
141 if (Token)
142 {
143 NtSetInformationThread(NtCurrentThread(),
144 ThreadImpersonationToken,
145 &Token,
146 sizeof(Token));
147
148 NtClose(Token);
149 }
150
151 return BaseNamedObjectDirectory;
152 }
153
154 VOID
155 NTAPI
156 BasepLocateExeLdrEntry(IN PLDR_DATA_TABLE_ENTRY Entry,
157 IN PVOID Context,
158 OUT BOOLEAN *StopEnumeration)
159 {
160 /* Make sure we get Entry, Context and valid StopEnumeration pointer */
161 ASSERT(Entry);
162 ASSERT(Context);
163 ASSERT(StopEnumeration);
164
165 /* If entry is already found - signal to stop */
166 if (BasepExeLdrEntry)
167 {
168 *StopEnumeration = TRUE;
169 return;
170 }
171
172 /* Otherwise keep enumerating until we find a match */
173 if (Entry->DllBase == Context)
174 {
175 /* It matches, so remember the ldr entry */
176 BasepExeLdrEntry = Entry;
177
178 /* And stop enumeration */
179 *StopEnumeration = TRUE;
180 }
181 }
182
183 /*
184 * Converts an ANSI or OEM String to the TEB StaticUnicodeString
185 */
186 PUNICODE_STRING
187 WINAPI
188 Basep8BitStringToStaticUnicodeString(IN LPCSTR String)
189 {
190 PUNICODE_STRING StaticString = &(NtCurrentTeb()->StaticUnicodeString);
191 ANSI_STRING AnsiString;
192 NTSTATUS Status;
193
194 /* Initialize an ANSI String */
195 Status = RtlInitAnsiStringEx(&AnsiString, String);
196 if (!NT_SUCCESS(Status))
197 {
198 Status = STATUS_BUFFER_OVERFLOW;
199 }
200 else
201 {
202 /* Convert it */
203 Status = Basep8BitStringToUnicodeString(StaticString, &AnsiString, FALSE);
204 }
205
206 if (NT_SUCCESS(Status)) return StaticString;
207
208 if (Status == STATUS_BUFFER_OVERFLOW)
209 {
210 SetLastError(ERROR_FILENAME_EXCED_RANGE);
211 }
212 else
213 {
214 BaseSetLastNTError(Status);
215 }
216
217 return NULL;
218 }
219
220 /*
221 * Allocates space from the Heap and converts an Unicode String into it
222 */
223 BOOLEAN
224 WINAPI
225 Basep8BitStringToDynamicUnicodeString(OUT PUNICODE_STRING UnicodeString,
226 IN LPCSTR String)
227 {
228 ANSI_STRING AnsiString;
229 NTSTATUS Status;
230
231 /* Initialize an ANSI String */
232 Status = RtlInitAnsiStringEx(&AnsiString, String);
233 if (!NT_SUCCESS(Status))
234 {
235 Status = STATUS_BUFFER_OVERFLOW;
236 }
237 else
238 {
239 /* Convert it */
240 Status = Basep8BitStringToUnicodeString(UnicodeString, &AnsiString, TRUE);
241 }
242
243 if (NT_SUCCESS(Status)) return TRUE;
244
245 if (Status == STATUS_BUFFER_OVERFLOW)
246 {
247 SetLastError(ERROR_FILENAME_EXCED_RANGE);
248 }
249 else
250 {
251 BaseSetLastNTError(Status);
252 }
253
254 return FALSE;
255 }
256
257 /*
258 * Allocates space from the Heap and converts an Ansi String into it
259 */
260 /*NOTE: API IS A HACK */
261 VOID
262 WINAPI
263 BasepAnsiStringToHeapUnicodeString(IN LPCSTR AnsiString,
264 OUT LPWSTR* UnicodeString)
265 {
266 ANSI_STRING AnsiTemp;
267 UNICODE_STRING UnicodeTemp;
268
269 DPRINT("BasepAnsiStringToHeapUnicodeString\n");
270
271 /* First create the ANSI_STRING */
272 RtlInitAnsiString(&AnsiTemp, AnsiString);
273
274 if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeTemp,
275 &AnsiTemp,
276 TRUE)))
277 {
278 *UnicodeString = UnicodeTemp.Buffer;
279 }
280 else
281 {
282 *UnicodeString = NULL;
283 }
284 }
285
286 PLARGE_INTEGER
287 WINAPI
288 BaseFormatTimeOut(OUT PLARGE_INTEGER Timeout,
289 IN DWORD dwMilliseconds)
290 {
291 /* Check if this is an infinite wait, which means no timeout argument */
292 if (dwMilliseconds == INFINITE) return NULL;
293
294 /* Otherwise, convert the time to NT Format */
295 Timeout->QuadPart = dwMilliseconds * -10000LL;
296 return Timeout;
297 }
298
299 /*
300 * Converts lpSecurityAttributes + Object Name into ObjectAttributes.
301 */
302 POBJECT_ATTRIBUTES
303 WINAPI
304 BaseFormatObjectAttributes(OUT POBJECT_ATTRIBUTES ObjectAttributes,
305 IN PSECURITY_ATTRIBUTES SecurityAttributes OPTIONAL,
306 IN PUNICODE_STRING ObjectName)
307 {
308 ULONG Attributes;
309 HANDLE RootDirectory;
310 PVOID SecurityDescriptor;
311 DPRINT("BaseFormatObjectAttributes. Security: %p, Name: %p\n",
312 SecurityAttributes, ObjectName);
313
314 /* Get the attributes if present */
315 if (SecurityAttributes)
316 {
317 Attributes = SecurityAttributes->bInheritHandle ? OBJ_INHERIT : 0;
318 SecurityDescriptor = SecurityAttributes->lpSecurityDescriptor;
319 }
320 else
321 {
322 if (!ObjectName) return NULL;
323 Attributes = 0;
324 SecurityDescriptor = NULL;
325 }
326
327 if (ObjectName)
328 {
329 Attributes |= OBJ_OPENIF;
330 RootDirectory = BaseGetNamedObjectDirectory();
331 }
332 else
333 {
334 RootDirectory = NULL;
335 }
336
337 /* Create the Object Attributes */
338 InitializeObjectAttributes(ObjectAttributes,
339 ObjectName,
340 Attributes,
341 RootDirectory,
342 SecurityDescriptor);
343 DPRINT("Attributes: %lx, RootDirectory: %p, SecurityDescriptor: %p\n",
344 Attributes, RootDirectory, SecurityDescriptor);
345 return ObjectAttributes;
346 }
347
348 /*
349 * Creates a stack for a thread or fiber
350 */
351 NTSTATUS
352 WINAPI
353 BaseCreateStack(HANDLE hProcess,
354 SIZE_T StackCommit,
355 SIZE_T StackReserve,
356 PINITIAL_TEB InitialTeb)
357 {
358 NTSTATUS Status;
359 PIMAGE_NT_HEADERS Headers;
360 ULONG_PTR Stack;
361 BOOLEAN UseGuard;
362 ULONG PageSize, Dummy, AllocationGranularity;
363 SIZE_T StackReserveHeader, StackCommitHeader, GuardPageSize, GuaranteedStackCommit;
364 DPRINT("BaseCreateStack (hProcess: %p, Max: %lx, Current: %lx)\n",
365 hProcess, StackReserve, StackCommit);
366
367 /* Read page size */
368 PageSize = BaseStaticServerData->SysInfo.PageSize;
369 AllocationGranularity = BaseStaticServerData->SysInfo.AllocationGranularity;
370
371 /* Get the Image Headers */
372 Headers = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress);
373 if (!Headers) return STATUS_INVALID_IMAGE_FORMAT;
374
375 StackCommitHeader = Headers->OptionalHeader.SizeOfStackCommit;
376 StackReserveHeader = Headers->OptionalHeader.SizeOfStackReserve;
377
378 if (!StackReserve) StackReserve = StackReserveHeader;
379
380 if (!StackCommit)
381 {
382 StackCommit = StackCommitHeader;
383 }
384 else if (StackCommit >= StackReserve)
385 {
386 StackReserve = ROUND_UP(StackCommit, 1024 * 1024);
387 }
388
389 StackCommit = ROUND_UP(StackCommit, PageSize);
390 StackReserve = ROUND_UP(StackReserve, AllocationGranularity);
391
392 GuaranteedStackCommit = NtCurrentTeb()->GuaranteedStackBytes;
393 if ((GuaranteedStackCommit) && (StackCommit < GuaranteedStackCommit))
394 {
395 StackCommit = GuaranteedStackCommit;
396 }
397
398 if (StackCommit >= StackReserve)
399 {
400 StackReserve = ROUND_UP(StackCommit, 1024 * 1024);
401 }
402
403 StackCommit = ROUND_UP(StackCommit, PageSize);
404 StackReserve = ROUND_UP(StackReserve, AllocationGranularity);
405
406 /* Reserve memory for the stack */
407 Stack = 0;
408 Status = NtAllocateVirtualMemory(hProcess,
409 (PVOID*)&Stack,
410 0,
411 &StackReserve,
412 MEM_RESERVE,
413 PAGE_READWRITE);
414 if (!NT_SUCCESS(Status))
415 {
416 DPRINT1("Failure to reserve stack: %lx\n", Status);
417 return Status;
418 }
419
420 /* Now set up some basic Initial TEB Parameters */
421 InitialTeb->AllocatedStackBase = (PVOID)Stack;
422 InitialTeb->StackBase = (PVOID)(Stack + StackReserve);
423 InitialTeb->PreviousStackBase = NULL;
424 InitialTeb->PreviousStackLimit = NULL;
425
426 /* Update the Stack Position */
427 Stack += StackReserve - StackCommit;
428
429 /* Check if we will need a guard page */
430 if (StackReserve > StackCommit)
431 {
432 Stack -= PageSize;
433 StackCommit += PageSize;
434 UseGuard = TRUE;
435 }
436 else
437 {
438 UseGuard = FALSE;
439 }
440
441 /* Allocate memory for the stack */
442 Status = NtAllocateVirtualMemory(hProcess,
443 (PVOID*)&Stack,
444 0,
445 &StackCommit,
446 MEM_COMMIT,
447 PAGE_READWRITE);
448 if (!NT_SUCCESS(Status))
449 {
450 DPRINT1("Failure to allocate stack\n");
451 GuardPageSize = 0;
452 NtFreeVirtualMemory(hProcess, (PVOID*)&Stack, &GuardPageSize, MEM_RELEASE);
453 return Status;
454 }
455
456 /* Now set the current Stack Limit */
457 InitialTeb->StackLimit = (PVOID)Stack;
458
459 /* Create a guard page */
460 if (UseGuard)
461 {
462 /* Set the guard page */
463 GuardPageSize = PAGE_SIZE;
464 Status = NtProtectVirtualMemory(hProcess,
465 (PVOID*)&Stack,
466 &GuardPageSize,
467 PAGE_GUARD | PAGE_READWRITE,
468 &Dummy);
469 if (!NT_SUCCESS(Status))
470 {
471 DPRINT1("Failure to set guard page\n");
472 return Status;
473 }
474
475 /* Update the Stack Limit keeping in mind the Guard Page */
476 InitialTeb->StackLimit = (PVOID)((ULONG_PTR)InitialTeb->StackLimit +
477 GuardPageSize);
478 }
479
480 /* We are done! */
481 return STATUS_SUCCESS;
482 }
483
484 VOID
485 WINAPI
486 BaseFreeThreadStack(IN HANDLE hProcess,
487 IN PINITIAL_TEB InitialTeb)
488 {
489 SIZE_T Dummy = 0;
490
491 /* Free the Stack */
492 NtFreeVirtualMemory(hProcess,
493 &InitialTeb->AllocatedStackBase,
494 &Dummy,
495 MEM_RELEASE);
496 }
497
498 /*
499 * Creates the Initial Context for a Thread or Fiber
500 */
501 VOID
502 WINAPI
503 BaseInitializeContext(IN PCONTEXT Context,
504 IN PVOID Parameter,
505 IN PVOID StartAddress,
506 IN PVOID StackAddress,
507 IN ULONG ContextType)
508 {
509 #ifdef _M_IX86
510 ULONG ContextFlags;
511 DPRINT("BaseInitializeContext: %p\n", Context);
512
513 /* Setup the Initial Win32 Thread Context */
514 Context->Eax = (ULONG)StartAddress;
515 Context->Ebx = (ULONG)Parameter;
516 Context->Esp = (ULONG)StackAddress;
517 /* The other registers are undefined */
518
519 /* Setup the Segments */
520 Context->SegFs = KGDT_R3_TEB;
521 Context->SegEs = KGDT_R3_DATA;
522 Context->SegDs = KGDT_R3_DATA;
523 Context->SegCs = KGDT_R3_CODE;
524 Context->SegSs = KGDT_R3_DATA;
525 Context->SegGs = 0;
526
527 /* Set the Context Flags */
528 ContextFlags = Context->ContextFlags;
529 Context->ContextFlags = CONTEXT_FULL;
530
531 /* Give it some room for the Parameter */
532 Context->Esp -= sizeof(PVOID);
533
534 /* Set the EFLAGS */
535 Context->EFlags = 0x3000; /* IOPL 3 */
536
537 /* What kind of context is being created? */
538 if (ContextType == 1)
539 {
540 /* For Threads */
541 Context->Eip = (ULONG)BaseThreadStartupThunk;
542 }
543 else if (ContextType == 2)
544 {
545 /* This is a fiber: make space for the return address */
546 Context->Esp -= sizeof(PVOID);
547 *((PVOID*)Context->Esp) = BaseFiberStartup;
548
549 /* Is FPU state required? */
550 Context->ContextFlags |= ContextFlags;
551 if ((ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT)
552 {
553 /* Set an initial state */
554 Context->FloatSave.ControlWord = 0x27F;
555 Context->FloatSave.StatusWord = 0;
556 Context->FloatSave.TagWord = 0xFFFF;
557 Context->FloatSave.ErrorOffset = 0;
558 Context->FloatSave.ErrorSelector = 0;
559 Context->FloatSave.DataOffset = 0;
560 Context->FloatSave.DataSelector = 0;
561 if (SharedUserData->ProcessorFeatures[PF_XMMI_INSTRUCTIONS_AVAILABLE])
562 Context->Dr6 = 0x1F80;
563 }
564 }
565 else
566 {
567 /* For first thread in a Process */
568 Context->Eip = (ULONG)BaseProcessStartThunk;
569 }
570
571 #elif defined(_M_AMD64)
572 DPRINT("BaseInitializeContext: %p\n", Context);
573
574 /* Setup the Initial Win32 Thread Context */
575 Context->Rax = (ULONG_PTR)StartAddress;
576 Context->Rbx = (ULONG_PTR)Parameter;
577 Context->Rsp = (ULONG_PTR)StackAddress;
578 /* The other registers are undefined */
579
580 /* Setup the Segments */
581 Context->SegGs = KGDT64_R3_DATA | RPL_MASK;
582 Context->SegEs = KGDT64_R3_DATA | RPL_MASK;
583 Context->SegDs = KGDT64_R3_DATA | RPL_MASK;
584 Context->SegCs = KGDT64_R3_CODE | RPL_MASK;
585 Context->SegSs = KGDT64_R3_DATA | RPL_MASK;
586 Context->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
587
588 /* Set the EFLAGS */
589 Context->EFlags = 0x3000; /* IOPL 3 */
590
591 if (ContextType == 1) /* For Threads */
592 {
593 Context->Rip = (ULONG_PTR)BaseThreadStartupThunk;
594 }
595 else if (ContextType == 2) /* For Fibers */
596 {
597 Context->Rip = (ULONG_PTR)BaseFiberStartup;
598 }
599 else /* For first thread in a Process */
600 {
601 Context->Rip = (ULONG_PTR)BaseProcessStartThunk;
602 }
603
604 /* Set the Context Flags */
605 Context->ContextFlags = CONTEXT_FULL;
606
607 /* Give it some room for the Parameter */
608 Context->Rsp -= sizeof(PVOID);
609 #elif defined(_M_ARM)
610 DPRINT("BaseInitializeContext: %p\n", Context);
611
612 // FIXME: check if this is correct!
613 /* Setup the Initial Win32 Thread Context */
614 Context->R0 = (ULONG_PTR)StartAddress;
615 Context->R1 = (ULONG_PTR)Parameter;
616 Context->Sp = (ULONG_PTR)StackAddress;
617
618 if (ContextType == 1) /* For Threads */
619 {
620 Context->Pc = (ULONG_PTR)BaseThreadStartupThunk;
621 }
622 else if (ContextType == 2) /* For Fibers */
623 {
624 Context->Pc = (ULONG_PTR)BaseFiberStartup;
625 }
626 else /* For first thread in a Process */
627 {
628 Context->Pc = (ULONG_PTR)BaseProcessStartThunk;
629 }
630
631 /* Set the Context Flags */
632 Context->ContextFlags = CONTEXT_FULL;
633
634 /* Give it some room for the Parameter */
635 Context->Sp -= sizeof(PVOID);
636 #else
637 #warning Unknown architecture
638 UNIMPLEMENTED;
639 DbgBreakPoint();
640 #endif
641 }
642
643 /*
644 * Checks if the privilege for Real-Time Priority is there
645 * Beware about this function behavior:
646 * - In case Keep is set to FALSE, then the function will only check
647 * whether real time is allowed and won't grant the privilege. In that case
648 * it will return TRUE if allowed, FALSE otherwise. Not a state!
649 * It means you don't have to release privilege when calling with FALSE.
650 */
651 PVOID
652 WINAPI
653 BasepIsRealtimeAllowed(IN BOOLEAN Keep)
654 {
655 ULONG Privilege = SE_INC_BASE_PRIORITY_PRIVILEGE;
656 PVOID State;
657 NTSTATUS Status;
658
659 Status = RtlAcquirePrivilege(&Privilege, 1, 0, &State);
660 if (!NT_SUCCESS(Status)) return NULL;
661
662 if (!Keep)
663 {
664 RtlReleasePrivilege(State);
665 State = (PVOID)TRUE;
666 }
667
668 return State;
669 }
670
671 /*
672 * Maps an image file into a section
673 */
674 NTSTATUS
675 WINAPI
676 BasepMapFile(IN LPCWSTR lpApplicationName,
677 OUT PHANDLE hSection,
678 IN PUNICODE_STRING ApplicationName)
679 {
680 RTL_RELATIVE_NAME_U RelativeName;
681 OBJECT_ATTRIBUTES ObjectAttributes;
682 NTSTATUS Status;
683 HANDLE hFile = NULL;
684 IO_STATUS_BLOCK IoStatusBlock;
685
686 DPRINT("BasepMapFile\n");
687
688 /* Zero out the Relative Directory */
689 RelativeName.ContainingDirectory = NULL;
690
691 /* Find the application name */
692 if (!RtlDosPathNameToNtPathName_U(lpApplicationName,
693 ApplicationName,
694 NULL,
695 &RelativeName))
696 {
697 return STATUS_OBJECT_PATH_NOT_FOUND;
698 }
699
700 DPRINT("ApplicationName %wZ\n", ApplicationName);
701 DPRINT("RelativeName %wZ\n", &RelativeName.RelativeName);
702
703 /* Did we get a relative name? */
704 if (RelativeName.RelativeName.Length)
705 {
706 ApplicationName = &RelativeName.RelativeName;
707 }
708
709 /* Initialize the Object Attributes */
710 InitializeObjectAttributes(&ObjectAttributes,
711 ApplicationName,
712 OBJ_CASE_INSENSITIVE,
713 RelativeName.ContainingDirectory,
714 NULL);
715
716 /* Try to open the executable */
717 Status = NtOpenFile(&hFile,
718 SYNCHRONIZE | FILE_EXECUTE | FILE_READ_DATA,
719 &ObjectAttributes,
720 &IoStatusBlock,
721 FILE_SHARE_DELETE | FILE_SHARE_READ,
722 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
723 if (!NT_SUCCESS(Status))
724 {
725 DPRINT1("Failed to open file\n");
726 BaseSetLastNTError(Status);
727 return Status;
728 }
729
730 /* Create a section for this file */
731 Status = NtCreateSection(hSection,
732 SECTION_ALL_ACCESS,
733 NULL,
734 NULL,
735 PAGE_EXECUTE,
736 SEC_IMAGE,
737 hFile);
738 NtClose(hFile);
739
740 /* Return status */
741 DPRINT("Section: %p for file: %p\n", *hSection, hFile);
742 return Status;
743 }
744
745 /*
746 * @implemented
747 */
748 BOOLEAN
749 WINAPI
750 Wow64EnableWow64FsRedirection(IN BOOLEAN Wow64EnableWow64FsRedirection)
751 {
752 NTSTATUS Status;
753 BOOL Result;
754
755 Status = RtlWow64EnableFsRedirection(Wow64EnableWow64FsRedirection);
756 if (NT_SUCCESS(Status))
757 {
758 Result = TRUE;
759 }
760 else
761 {
762 BaseSetLastNTError(Status);
763 Result = FALSE;
764 }
765 return Result;
766 }
767
768 /*
769 * @implemented
770 */
771 BOOL
772 WINAPI
773 Wow64DisableWow64FsRedirection(IN PVOID *OldValue)
774 {
775 NTSTATUS Status;
776 BOOL Result;
777
778 Status = RtlWow64EnableFsRedirectionEx((PVOID)TRUE, OldValue);
779 if (NT_SUCCESS(Status))
780 {
781 Result = TRUE;
782 }
783 else
784 {
785 BaseSetLastNTError(Status);
786 Result = FALSE;
787 }
788 return Result;
789 }
790
791 /*
792 * @implemented
793 */
794 BOOL
795 WINAPI
796 Wow64RevertWow64FsRedirection(IN PVOID OldValue)
797 {
798 NTSTATUS Status;
799 BOOL Result;
800
801 Status = RtlWow64EnableFsRedirectionEx(OldValue, &OldValue);
802 if (NT_SUCCESS(Status))
803 {
804 Result = TRUE;
805 }
806 else
807 {
808 BaseSetLastNTError(Status);
809 Result = FALSE;
810 }
811 return Result;
812 }
813
814 /*
815 * @implemented
816 */
817 VOID
818 WINAPI
819 SetFileApisToOEM(VOID)
820 {
821 /* Set the correct Base Api */
822 Basep8BitStringToUnicodeString = (PRTL_CONVERT_STRING)RtlOemStringToUnicodeString;
823 BasepUnicodeStringTo8BitString = RtlUnicodeStringToOemString;
824 BasepUnicodeStringTo8BitSize = BasepUnicodeStringToOemSize;
825 Basep8BitStringToUnicodeSize = BasepOemStringToUnicodeSize;
826
827 /* FIXME: Old, deprecated way */
828 bIsFileApiAnsi = FALSE;
829 }
830
831
832 /*
833 * @implemented
834 */
835 VOID
836 WINAPI
837 SetFileApisToANSI(VOID)
838 {
839 /* Set the correct Base Api */
840 Basep8BitStringToUnicodeString = RtlAnsiStringToUnicodeString;
841 BasepUnicodeStringTo8BitString = RtlUnicodeStringToAnsiString;
842 BasepUnicodeStringTo8BitSize = BasepUnicodeStringToAnsiSize;
843 Basep8BitStringToUnicodeSize = BasepAnsiStringToUnicodeSize;
844
845 /* FIXME: Old, deprecated way */
846 bIsFileApiAnsi = TRUE;
847 }
848
849 /*
850 * @implemented
851 */
852 BOOL
853 WINAPI
854 AreFileApisANSI(VOID)
855 {
856 return Basep8BitStringToUnicodeString == RtlAnsiStringToUnicodeString;
857 }
858
859 /*
860 * @implemented
861 */
862 VOID
863 WINAPI
864 BaseMarkFileForDelete(IN HANDLE FileHandle,
865 IN ULONG FileAttributes)
866 {
867 IO_STATUS_BLOCK IoStatusBlock;
868 FILE_BASIC_INFORMATION FileBasicInfo;
869 FILE_DISPOSITION_INFORMATION FileDispositionInfo;
870
871 /* If no attributes were given, get them */
872 if (!FileAttributes)
873 {
874 FileBasicInfo.FileAttributes = 0;
875 NtQueryInformationFile(FileHandle,
876 &IoStatusBlock,
877 &FileBasicInfo,
878 sizeof(FileBasicInfo),
879 FileBasicInformation);
880 FileAttributes = FileBasicInfo.FileAttributes;
881 }
882
883 /* If file is marked as RO, reset its attributes */
884 if (FileAttributes & FILE_ATTRIBUTE_READONLY)
885 {
886 RtlZeroMemory(&FileBasicInfo, sizeof(FileBasicInfo));
887 FileBasicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
888 NtSetInformationFile(FileHandle,
889 &IoStatusBlock,
890 &FileBasicInfo,
891 sizeof(FileBasicInfo),
892 FileBasicInformation);
893 }
894
895 /* Finally, mark the file for deletion */
896 FileDispositionInfo.DeleteFile = TRUE;
897 NtSetInformationFile(FileHandle,
898 &IoStatusBlock,
899 &FileDispositionInfo,
900 sizeof(FileDispositionInfo),
901 FileDispositionInformation);
902 }
903
904 /*
905 * @unimplemented
906 */
907 BOOL
908 WINAPI
909 BaseCheckRunApp(IN DWORD Unknown1,
910 IN DWORD Unknown2,
911 IN DWORD Unknown3,
912 IN DWORD Unknown4,
913 IN DWORD Unknown5,
914 IN DWORD Unknown6,
915 IN DWORD Unknown7,
916 IN DWORD Unknown8,
917 IN DWORD Unknown9,
918 IN DWORD Unknown10)
919 {
920 STUB;
921 return FALSE;
922 }
923
924 /*
925 * @unimplemented
926 */
927 NTSTATUS
928 WINAPI
929 BasepCheckWinSaferRestrictions(IN HANDLE UserToken,
930 IN LPWSTR ApplicationName,
931 IN HANDLE FileHandle,
932 OUT PBOOLEAN InJob,
933 OUT PHANDLE NewToken,
934 OUT PHANDLE JobHandle)
935 {
936 NTSTATUS Status;
937
938 /* Validate that there's a name */
939 if ((ApplicationName) && *(ApplicationName))
940 {
941 /* Validate that the required output parameters are there */
942 if ((InJob) && (NewToken) && (JobHandle))
943 {
944 /* Do the work (one day...) */
945 DPRINT("BasepCheckWinSaferRestrictions is UNIMPLEMENTED\n");
946 Status = STATUS_SUCCESS;
947 }
948 else
949 {
950 /* Act as if SEH hit this */
951 Status = STATUS_ACCESS_VIOLATION;
952 }
953 }
954 else
955 {
956 /* Input is invalid */
957 Status = STATUS_INVALID_PARAMETER;
958 }
959
960 /* Return the status */
961 return Status;
962 }