[NTOS][NDK][RTL] A bunch of 'wrong size' fixes
[reactos.git] / dll / win32 / kernel32 / client / loader.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT : ReactOS system libraries
4 * MODULE : kernel32.dll
5 * FILE : reactos/dll/win32/kernel32/misc/ldr.c
6 * AUTHOR : Aleksey Bragin <aleksey@reactos.org>
7 */
8
9 #include <k32.h>
10
11 #define NDEBUG
12 #include <debug.h>
13
14 /* FUNCTIONS ****************************************************************/
15
16 NTSTATUS
17 WINAPI
18 BasepInitializeTermsrvFpns(VOID)
19 {
20 UNIMPLEMENTED;
21 return STATUS_NOT_IMPLEMENTED;
22 }
23
24 DWORD
25 WINAPI
26 BasepGetModuleHandleExParameterValidation(DWORD dwFlags,
27 LPCWSTR lpwModuleName,
28 HMODULE *phModule)
29 {
30 /* Set phModule to 0 if it's not a NULL pointer */
31 if (phModule) *phModule = 0;
32
33 /* Check for invalid flags combination */
34 if (dwFlags & ~(GET_MODULE_HANDLE_EX_FLAG_PIN |
35 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
36 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS) ||
37 ((dwFlags & GET_MODULE_HANDLE_EX_FLAG_PIN) &&
38 (dwFlags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT)) ||
39 (!lpwModuleName && (dwFlags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
40 )
41 {
42 BaseSetLastNTError(STATUS_INVALID_PARAMETER_1);
43 return BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_ERROR;
44 }
45
46 /* Check 2nd parameter */
47 if (!phModule)
48 {
49 BaseSetLastNTError(STATUS_INVALID_PARAMETER_2);
50 return BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_ERROR;
51 }
52
53 /* Return what we have according to the module name */
54 if (lpwModuleName)
55 {
56 return BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_CONTINUE;
57 }
58
59 /* No name given, so put ImageBaseAddress there */
60 *phModule = (HMODULE)NtCurrentPeb()->ImageBaseAddress;
61
62 return BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_SUCCESS;
63 }
64
65 PVOID
66 WINAPI
67 BasepMapModuleHandle(HMODULE hModule, BOOLEAN AsDataFile)
68 {
69 /* If no handle is provided - use current image base address */
70 if (!hModule) return NtCurrentPeb()->ImageBaseAddress;
71
72 /* Check if it's a normal or a datafile one */
73 if (LDR_IS_DATAFILE(hModule) && !AsDataFile)
74 return NULL;
75
76 /* It's a normal DLL, just return its handle */
77 return hModule;
78 }
79
80 /*
81 * @implemented
82 */
83 BOOL
84 WINAPI
85 DisableThreadLibraryCalls(
86 IN HMODULE hLibModule)
87 {
88 NTSTATUS Status;
89
90 /* Disable thread library calls */
91 Status = LdrDisableThreadCalloutsForDll((PVOID)hLibModule);
92
93 /* If it wasn't success - set last error and return failure */
94 if (!NT_SUCCESS(Status))
95 {
96 BaseSetLastNTError(Status);
97 return FALSE;
98 }
99
100 /* Return success */
101 return TRUE;
102 }
103
104
105 /*
106 * @implemented
107 */
108 HINSTANCE
109 WINAPI
110 DECLSPEC_HOTPATCH
111 LoadLibraryA(LPCSTR lpLibFileName)
112 {
113 LPSTR PathBuffer;
114 UINT Len;
115 HINSTANCE Result;
116
117 /* Treat twain_32.dll in a special way (what a surprise...) */
118 if (lpLibFileName && !_strcmpi(lpLibFileName, "twain_32.dll"))
119 {
120 /* Allocate space for the buffer */
121 PathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, MAX_PATH);
122 if (PathBuffer)
123 {
124 /* Get windows dir in this buffer */
125 Len = GetWindowsDirectoryA(PathBuffer, MAX_PATH - 13); /* 13 is sizeof of '\\twain_32.dll' */
126 if (Len && Len < (MAX_PATH - 13))
127 {
128 /* We successfully got windows directory. Concatenate twain_32.dll to it */
129 strncat(PathBuffer, "\\twain_32.dll", 13);
130
131 /* And recursively call ourselves with a new string */
132 Result = LoadLibraryA(PathBuffer);
133
134 /* If it was successful - free memory and return result */
135 if (Result)
136 {
137 RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
138 return Result;
139 }
140 }
141
142 /* Free allocated buffer */
143 RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
144 }
145 }
146
147 /* Call the Ex version of the API */
148 return LoadLibraryExA(lpLibFileName, 0, 0);
149 }
150
151 /*
152 * @implemented
153 */
154 HINSTANCE
155 WINAPI
156 DECLSPEC_HOTPATCH
157 LoadLibraryExA(LPCSTR lpLibFileName,
158 HANDLE hFile,
159 DWORD dwFlags)
160 {
161 PUNICODE_STRING FileNameW;
162
163 /* Convert file name to unicode */
164 if (!(FileNameW = Basep8BitStringToStaticUnicodeString(lpLibFileName)))
165 return NULL;
166
167 /* And call W version of the API */
168 return LoadLibraryExW(FileNameW->Buffer, hFile, dwFlags);
169 }
170
171 /*
172 * @implemented
173 */
174 HINSTANCE
175 WINAPI
176 DECLSPEC_HOTPATCH
177 LoadLibraryW(LPCWSTR lpLibFileName)
178 {
179 /* Call Ex version of the API */
180 return LoadLibraryExW(lpLibFileName, 0, 0);
181 }
182
183
184 static
185 NTSTATUS
186 BasepLoadLibraryAsDatafile(PWSTR Path, LPCWSTR Name, HMODULE *hModule)
187 {
188 WCHAR FilenameW[MAX_PATH];
189 HANDLE hFile = INVALID_HANDLE_VALUE;
190 HANDLE hMapping;
191 NTSTATUS Status;
192 PVOID lpBaseAddress = NULL;
193 SIZE_T ViewSize = 0;
194 //PUNICODE_STRING OriginalName;
195 //UNICODE_STRING dotDLL = RTL_CONSTANT_STRING(L".DLL");
196
197 /* Zero out handle value */
198 *hModule = 0;
199
200 DPRINT("BasepLoadLibraryAsDatafile(%S %S %p)\n", Path, Name, hModule);
201
202 /*Status = RtlDosApplyFileIsolationRedirection_Ustr(TRUE,
203 Name,
204 &dotDLL,
205 RedirName,
206 RedirName2,
207 &OriginalName2,
208 NULL,
209 NULL,
210 NULL);*/
211
212 /* Try to search for it */
213 if (!SearchPathW(Path,
214 Name,
215 L".DLL",
216 sizeof(FilenameW) / sizeof(FilenameW[0]),
217 FilenameW,
218 NULL))
219 {
220 /* Return last status value directly */
221 return NtCurrentTeb()->LastStatusValue;
222 }
223
224 /* Open this file we found */
225 hFile = CreateFileW(FilenameW,
226 GENERIC_READ,
227 FILE_SHARE_READ | FILE_SHARE_DELETE,
228 NULL,
229 OPEN_EXISTING,
230 0,
231 0);
232
233 /* If opening failed - return last status value */
234 if (hFile == INVALID_HANDLE_VALUE) return NtCurrentTeb()->LastStatusValue;
235
236 /* Create file mapping */
237 hMapping = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
238
239 /* Close the file handle */
240 CloseHandle(hFile);
241
242 /* If creating file mapping failed - return last status value */
243 if (!hMapping) return NtCurrentTeb()->LastStatusValue;
244
245 /* Map view of section */
246 Status = NtMapViewOfSection(hMapping,
247 NtCurrentProcess(),
248 &lpBaseAddress,
249 0,
250 0,
251 0,
252 &ViewSize,
253 ViewShare,
254 0,
255 PAGE_READONLY);
256
257 /* Close handle to the section */
258 CloseHandle(hMapping);
259
260 /* If mapping view of section failed - return last status value */
261 if (!NT_SUCCESS(Status)) return NtCurrentTeb()->LastStatusValue;
262
263 /* Make sure it's a valid PE file */
264 if (!RtlImageNtHeader(lpBaseAddress))
265 {
266 /* Unmap the view and return failure status */
267 UnmapViewOfFile(lpBaseAddress);
268 return STATUS_INVALID_IMAGE_FORMAT;
269 }
270
271 /* Set low bit of handle to indicate datafile module */
272 *hModule = (HMODULE)((ULONG_PTR)lpBaseAddress | 1);
273
274 /* Load alternate resource module */
275 //LdrLoadAlternateResourceModule(*hModule, FilenameW);
276
277 return STATUS_SUCCESS;
278 }
279
280 /*
281 * @implemented
282 */
283 HINSTANCE
284 WINAPI
285 DECLSPEC_HOTPATCH
286 LoadLibraryExW(LPCWSTR lpLibFileName,
287 HANDLE hFile,
288 DWORD dwFlags)
289 {
290 UNICODE_STRING DllName;
291 HINSTANCE hInst;
292 NTSTATUS Status;
293 PWSTR SearchPath;
294 ULONG DllCharacteristics = 0;
295 BOOL FreeString = FALSE;
296
297 /* Check for any flags LdrLoadDll might be interested in */
298 if (dwFlags & DONT_RESOLVE_DLL_REFERENCES)
299 {
300 /* Tell LDR to treat it as an EXE */
301 DllCharacteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
302 }
303
304 /* Build up a unicode dll name from null-terminated string */
305 RtlInitUnicodeString(&DllName, (LPWSTR)lpLibFileName);
306
307 /* Lazy-initialize BasepExeLdrEntry */
308 if (!BasepExeLdrEntry)
309 LdrEnumerateLoadedModules(0, BasepLocateExeLdrEntry, NtCurrentPeb()->ImageBaseAddress);
310
311 /* Check if that module is our exe*/
312 if (BasepExeLdrEntry && !(dwFlags & LOAD_LIBRARY_AS_DATAFILE) &&
313 DllName.Length == BasepExeLdrEntry->FullDllName.Length)
314 {
315 /* Lengths match and it's not a datafile, so perform name comparison */
316 if (RtlEqualUnicodeString(&DllName, &BasepExeLdrEntry->FullDllName, TRUE))
317 {
318 /* That's us! */
319 return BasepExeLdrEntry->DllBase;
320 }
321 }
322
323 /* Check for trailing spaces and remove them if necessary */
324 if (DllName.Buffer[DllName.Length/sizeof(WCHAR) - 1] == L' ')
325 {
326 RtlCreateUnicodeString(&DllName, (LPWSTR)lpLibFileName);
327 while (DllName.Length > sizeof(WCHAR) &&
328 DllName.Buffer[DllName.Length/sizeof(WCHAR) - 1] == L' ')
329 {
330 DllName.Length -= sizeof(WCHAR);
331 }
332 DllName.Buffer[DllName.Length/sizeof(WCHAR)] = UNICODE_NULL;
333 FreeString = TRUE;
334 }
335
336 /* Compute the load path */
337 SearchPath = BaseComputeProcessDllPath((dwFlags & LOAD_WITH_ALTERED_SEARCH_PATH) ?
338 DllName.Buffer : NULL,
339 NULL);
340 if (!SearchPath)
341 {
342 /* Getting DLL path failed, so set last error, free mem and return */
343 BaseSetLastNTError(STATUS_NO_MEMORY);
344 if (FreeString) RtlFreeUnicodeString(&DllName);
345 return NULL;
346 }
347
348 _SEH2_TRY
349 {
350 if (dwFlags & LOAD_LIBRARY_AS_DATAFILE)
351 {
352 /* If the image is loaded as a datafile, try to get its handle */
353 Status = LdrGetDllHandleEx(0, SearchPath, NULL, &DllName, (PVOID*)&hInst);
354 if (!NT_SUCCESS(Status))
355 {
356 /* It's not loaded yet - so load it up */
357 Status = BasepLoadLibraryAsDatafile(SearchPath, DllName.Buffer, &hInst);
358 }
359 _SEH2_YIELD(goto done;)
360 }
361
362 /* Call the API Properly */
363 Status = LdrLoadDll(SearchPath,
364 &DllCharacteristics,
365 &DllName,
366 (PVOID*)&hInst);
367 }
368 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
369 {
370 Status = _SEH2_GetExceptionCode();
371 } _SEH2_END;
372
373
374 done:
375 /* Free SearchPath buffer */
376 RtlFreeHeap(RtlGetProcessHeap(), 0, SearchPath);
377
378 /* Free DllName string if it was dynamically allocated */
379 if (FreeString) RtlFreeUnicodeString(&DllName);
380
381 /* Set last error in failure case */
382 if (!NT_SUCCESS(Status))
383 {
384 DPRINT1("LoadLibraryExW(%ls) failing with status %lx\n", lpLibFileName, Status);
385 BaseSetLastNTError(Status);
386 return NULL;
387 }
388
389 /* Return loaded module handle */
390 return hInst;
391 }
392
393
394 /*
395 * @implemented
396 */
397 FARPROC
398 WINAPI
399 GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
400 {
401 ANSI_STRING ProcedureName, *ProcNamePtr = NULL;
402 FARPROC fnExp = NULL;
403 NTSTATUS Status;
404 PVOID hMapped;
405 ULONG Ordinal = 0;
406
407 if (HIWORD(lpProcName) != 0)
408 {
409 /* Look up by name */
410 RtlInitAnsiString(&ProcedureName, (LPSTR)lpProcName);
411 ProcNamePtr = &ProcedureName;
412 }
413 else
414 {
415 /* Look up by ordinal */
416 Ordinal = (ULONG)lpProcName;
417 }
418
419 /* Map provided handle */
420 hMapped = BasepMapModuleHandle(hModule, FALSE);
421
422 /* Get the proc address */
423 Status = LdrGetProcedureAddress(hMapped,
424 ProcNamePtr,
425 Ordinal,
426 (PVOID*)&fnExp);
427
428 if (!NT_SUCCESS(Status))
429 {
430 BaseSetLastNTError(Status);
431 return NULL;
432 }
433
434 /* Check for a special case when returned pointer is
435 the same as image's base address */
436 if (fnExp == hMapped)
437 {
438 /* Set correct error code */
439 if (HIWORD(lpProcName) != 0)
440 BaseSetLastNTError(STATUS_ENTRYPOINT_NOT_FOUND);
441 else
442 BaseSetLastNTError(STATUS_ORDINAL_NOT_FOUND);
443
444 return NULL;
445 }
446
447 /* All good, return procedure pointer */
448 return fnExp;
449 }
450
451
452 /*
453 * @implemented
454 */
455 BOOL
456 WINAPI
457 DECLSPEC_HOTPATCH
458 FreeLibrary(HINSTANCE hLibModule)
459 {
460 NTSTATUS Status;
461 PIMAGE_NT_HEADERS NtHeaders;
462
463 if (LDR_IS_DATAFILE(hLibModule))
464 {
465 // FIXME: This SEH should go inside RtlImageNtHeader instead
466 _SEH2_TRY
467 {
468 /* This is a LOAD_LIBRARY_AS_DATAFILE module, check if it's a valid one */
469 NtHeaders = RtlImageNtHeader((PVOID)((ULONG_PTR)hLibModule & ~1));
470 }
471 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
472 {
473 NtHeaders = NULL;
474 } _SEH2_END
475
476 if (NtHeaders)
477 {
478 /* Unmap view */
479 Status = NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)((ULONG_PTR)hLibModule & ~1));
480
481 /* Unload alternate resource module */
482 LdrUnloadAlternateResourceModule(hLibModule);
483 }
484 else
485 Status = STATUS_INVALID_IMAGE_FORMAT;
486 }
487 else
488 {
489 /* Just unload it */
490 Status = LdrUnloadDll((PVOID)hLibModule);
491 }
492
493 /* Check what kind of status we got */
494 if (!NT_SUCCESS(Status))
495 {
496 /* Set last error */
497 BaseSetLastNTError(Status);
498
499 /* Return failure */
500 return FALSE;
501 }
502
503 /* Return success */
504 return TRUE;
505 }
506
507
508 /*
509 * @implemented
510 */
511 VOID
512 WINAPI
513 FreeLibraryAndExitThread(HMODULE hLibModule,
514 DWORD dwExitCode)
515 {
516
517 if (LDR_IS_DATAFILE(hLibModule))
518 {
519 /* This is a LOAD_LIBRARY_AS_DATAFILE module */
520 if (RtlImageNtHeader((PVOID)((ULONG_PTR)hLibModule & ~1)))
521 {
522 /* Unmap view */
523 NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)((ULONG_PTR)hLibModule & ~1));
524
525 /* Unload alternate resource module */
526 LdrUnloadAlternateResourceModule(hLibModule);
527 }
528 }
529 else
530 {
531 /* Just unload it */
532 LdrUnloadDll((PVOID)hLibModule);
533 }
534
535 /* Exit thread */
536 ExitThread(dwExitCode);
537 }
538
539
540 /*
541 * @implemented
542 */
543 DWORD
544 WINAPI
545 GetModuleFileNameA(HINSTANCE hModule,
546 LPSTR lpFilename,
547 DWORD nSize)
548 {
549 UNICODE_STRING FilenameW;
550 ANSI_STRING FilenameA;
551 NTSTATUS Status;
552 DWORD Length = 0, LengthToCopy;
553
554 /* Allocate a unicode buffer */
555 FilenameW.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nSize * sizeof(WCHAR));
556 if (!FilenameW.Buffer)
557 {
558 BaseSetLastNTError(STATUS_NO_MEMORY);
559 return 0;
560 }
561
562 /* Call unicode API */
563 FilenameW.Length = (USHORT)GetModuleFileNameW(hModule, FilenameW.Buffer, nSize) * sizeof(WCHAR);
564 FilenameW.MaximumLength = FilenameW.Length + sizeof(WCHAR);
565
566 if (FilenameW.Length)
567 {
568 /* Convert to ansi string */
569 Status = BasepUnicodeStringTo8BitString(&FilenameA, &FilenameW, TRUE);
570 if (!NT_SUCCESS(Status))
571 {
572 /* Set last error, free string and return failure */
573 BaseSetLastNTError(Status);
574 RtlFreeUnicodeString(&FilenameW);
575 return 0;
576 }
577
578 /* Calculate size to copy */
579 Length = min(nSize, FilenameA.Length);
580
581 /* Include terminating zero */
582 if (nSize > Length)
583 LengthToCopy = Length + 1;
584 else
585 LengthToCopy = nSize;
586
587 /* Now copy back to the caller amount he asked */
588 RtlMoveMemory(lpFilename, FilenameA.Buffer, LengthToCopy);
589
590 /* Free ansi filename */
591 RtlFreeAnsiString(&FilenameA);
592 }
593
594 /* Free unicode filename */
595 RtlFreeHeap(RtlGetProcessHeap(), 0, FilenameW.Buffer);
596
597 /* Return length copied */
598 return Length;
599 }
600
601 /*
602 * @implemented
603 */
604 DWORD
605 WINAPI
606 GetModuleFileNameW(HINSTANCE hModule,
607 LPWSTR lpFilename,
608 DWORD nSize)
609 {
610 PLIST_ENTRY ModuleListHead, Entry;
611 PLDR_DATA_TABLE_ENTRY Module;
612 ULONG Length = 0;
613 ULONG_PTR Cookie;
614 PPEB Peb;
615
616 hModule = BasepMapModuleHandle(hModule, FALSE);
617
618 /* Upscale nSize from chars to bytes */
619 nSize *= sizeof(WCHAR);
620
621 _SEH2_TRY
622 {
623 /* We don't use per-thread cur dir now */
624 //PRTL_PERTHREAD_CURDIR PerThreadCurdir = (PRTL_PERTHREAD_CURDIR)teb->NtTib.SubSystemTib;
625
626 Peb = NtCurrentPeb ();
627
628 /* Acquire a loader lock */
629 LdrLockLoaderLock(LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS, NULL, &Cookie);
630
631 /* Traverse the module list */
632 ModuleListHead = &Peb->Ldr->InLoadOrderModuleList;
633 Entry = ModuleListHead->Flink;
634 while (Entry != ModuleListHead)
635 {
636 Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
637
638 /* Check if this is the requested module */
639 if (Module->DllBase == (PVOID)hModule)
640 {
641 /* Calculate size to copy */
642 Length = min(nSize, Module->FullDllName.MaximumLength);
643
644 /* Copy contents */
645 RtlMoveMemory(lpFilename, Module->FullDllName.Buffer, Length);
646
647 /* Subtract a terminating zero */
648 if (Length == Module->FullDllName.MaximumLength)
649 Length -= sizeof(WCHAR);
650
651 /* Break out of the loop */
652 break;
653 }
654
655 /* Advance to the next entry */
656 Entry = Entry->Flink;
657 }
658 }
659 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
660 {
661 BaseSetLastNTError(_SEH2_GetExceptionCode());
662 Length = 0;
663 } _SEH2_END
664
665 /* Release the loader lock */
666 LdrUnlockLoaderLock(LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS, Cookie);
667
668 return Length / sizeof(WCHAR);
669 }
670
671 HMODULE
672 WINAPI
673 GetModuleHandleForUnicodeString(PUNICODE_STRING ModuleName)
674 {
675 NTSTATUS Status;
676 PVOID Module;
677 LPWSTR DllPath;
678
679 /* Try to get a handle with a magic value of 1 for DllPath */
680 Status = LdrGetDllHandle((LPWSTR)1, NULL, ModuleName, &Module);
681
682 /* If that succeeded - we're done */
683 if (NT_SUCCESS(Status)) return Module;
684
685 /* If not, then the path should be computed */
686 DllPath = BaseComputeProcessDllPath(NULL, 0);
687 if (!DllPath)
688 {
689 Status = STATUS_NO_MEMORY;
690 }
691 else
692 {
693 _SEH2_TRY
694 {
695 Status = LdrGetDllHandle(DllPath, NULL, ModuleName, &Module);
696 }
697 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
698 {
699 /* Fail with the SEH error */
700 Status = _SEH2_GetExceptionCode();
701 }
702 _SEH2_END;
703 }
704
705 /* Free the DllPath */
706 RtlFreeHeap(RtlGetProcessHeap(), 0, DllPath);
707
708 /* In case of error set last win32 error and return NULL */
709 if (!NT_SUCCESS(Status))
710 {
711 DPRINT("Failure acquiring DLL module '%wZ' handle, Status 0x%08X\n", ModuleName, Status);
712 BaseSetLastNTError(Status);
713 Module = 0;
714 }
715
716 /* Return module */
717 return (HMODULE)Module;
718 }
719
720 BOOLEAN
721 WINAPI
722 BasepGetModuleHandleExW(BOOLEAN NoLock, DWORD dwPublicFlags, LPCWSTR lpwModuleName, HMODULE *phModule)
723 {
724 ULONG_PTR Cookie;
725 NTSTATUS Status = STATUS_SUCCESS, Status2;
726 HANDLE hModule = NULL;
727 UNICODE_STRING ModuleNameU;
728 DWORD dwValid;
729 BOOLEAN Redirected = FALSE; // FIXME
730
731 /* Validate parameters */
732 dwValid = BasepGetModuleHandleExParameterValidation(dwPublicFlags, lpwModuleName, phModule);
733 ASSERT(dwValid == BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_CONTINUE);
734
735 /* Acquire lock if necessary */
736 if (!NoLock)
737 {
738 Status = LdrLockLoaderLock(0, NULL, &Cookie);
739 if (!NT_SUCCESS(Status))
740 {
741 /* Fail */
742 BaseSetLastNTError(Status);
743 if (phModule) *phModule = NULL;
744 return NT_SUCCESS(Status);
745 }
746 }
747
748 if (!(dwPublicFlags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
749 {
750 /* Create a unicode string out of module name */
751 RtlInitUnicodeString(&ModuleNameU, lpwModuleName);
752
753 // FIXME: Do some redirected DLL stuff?
754 if (Redirected)
755 {
756 UNIMPLEMENTED;
757 }
758
759 if (!hModule)
760 {
761 hModule = GetModuleHandleForUnicodeString(&ModuleNameU);
762 if (!hModule)
763 {
764 /* Last error is already set, so just return failure by setting status */
765 Status = STATUS_DLL_NOT_FOUND;
766 goto quickie;
767 }
768 }
769 }
770 else
771 {
772 /* Perform Pc to file header to get module instance */
773 hModule = (HMODULE)RtlPcToFileHeader((PVOID)lpwModuleName,
774 (PVOID*)&hModule);
775
776 /* Check if it succeeded */
777 if (!hModule)
778 {
779 /* Set "dll not found" status and quit */
780 Status = STATUS_DLL_NOT_FOUND;
781 goto quickie;
782 }
783 }
784
785 /* Check if changing reference is not forbidden */
786 if (!(dwPublicFlags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
787 {
788 /* Add reference to this DLL */
789 Status = LdrAddRefDll((dwPublicFlags & GET_MODULE_HANDLE_EX_FLAG_PIN) ? LDR_ADDREF_DLL_PIN : 0,
790 hModule);
791 }
792
793 quickie:
794 /* Set last error in case of failure */
795 if (!NT_SUCCESS(Status))
796 BaseSetLastNTError(Status);
797
798 /* Unlock loader lock if it was acquired */
799 if (!NoLock)
800 {
801 Status2 = LdrUnlockLoaderLock(0, Cookie);
802 ASSERT(NT_SUCCESS(Status2));
803 }
804
805 /* Set the module handle to the caller */
806 if (phModule) *phModule = hModule;
807
808 /* Return TRUE on success and FALSE otherwise */
809 return NT_SUCCESS(Status);
810 }
811
812 /*
813 * @implemented
814 */
815 HMODULE
816 WINAPI
817 DECLSPEC_HOTPATCH
818 GetModuleHandleA(LPCSTR lpModuleName)
819 {
820 PUNICODE_STRING ModuleNameW;
821 PTEB pTeb = NtCurrentTeb();
822
823 /* Check if we have no name to convert */
824 if (!lpModuleName)
825 return ((HMODULE)pTeb->ProcessEnvironmentBlock->ImageBaseAddress);
826
827 /* Convert module name to unicode */
828 ModuleNameW = Basep8BitStringToStaticUnicodeString(lpModuleName);
829
830 /* Call W version if conversion was successful */
831 if (ModuleNameW)
832 return GetModuleHandleW(ModuleNameW->Buffer);
833
834 /* Return failure */
835 return 0;
836 }
837
838
839 /*
840 * @implemented
841 */
842 HMODULE
843 WINAPI
844 GetModuleHandleW(LPCWSTR lpModuleName)
845 {
846 HMODULE hModule;
847 BOOLEAN Success;
848
849 /* If current module is requested - return it right away */
850 if (!lpModuleName)
851 return ((HMODULE)NtCurrentPeb()->ImageBaseAddress);
852
853 /* Use common helper routine */
854 Success = BasepGetModuleHandleExW(TRUE,
855 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
856 lpModuleName,
857 &hModule);
858
859 /* If it wasn't successful - return NULL */
860 if (!Success) hModule = NULL;
861
862 /* Return the handle */
863 return hModule;
864 }
865
866
867 /*
868 * @implemented
869 */
870 BOOL
871 WINAPI
872 GetModuleHandleExW(IN DWORD dwFlags,
873 IN LPCWSTR lpwModuleName OPTIONAL,
874 OUT HMODULE* phModule)
875 {
876 DWORD dwValid;
877 BOOL Ret;
878
879 /* Validate parameters */
880 dwValid = BasepGetModuleHandleExParameterValidation(dwFlags, lpwModuleName, phModule);
881
882 /* If result is invalid parameter - return failure */
883 if (dwValid == BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_ERROR) return FALSE;
884
885 /* If result is 2, there is no need to do anything - return success. */
886 if (dwValid == BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_SUCCESS) return TRUE;
887
888 /* Use common helper routine */
889 Ret = BasepGetModuleHandleExW(FALSE,
890 dwFlags,
891 lpwModuleName,
892 phModule);
893
894 return Ret;
895 }
896
897 /*
898 * @implemented
899 */
900 BOOL
901 WINAPI
902 GetModuleHandleExA(IN DWORD dwFlags,
903 IN LPCSTR lpModuleName OPTIONAL,
904 OUT HMODULE* phModule)
905 {
906 PUNICODE_STRING lpModuleNameW;
907 DWORD dwValid;
908 BOOL Ret;
909
910 /* Validate parameters */
911 dwValid = BasepGetModuleHandleExParameterValidation(dwFlags, (LPCWSTR)lpModuleName, phModule);
912
913 /* If result is invalid parameter - return failure */
914 if (dwValid == BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_ERROR) return FALSE;
915
916 /* If result is 2, there is no need to do anything - return success. */
917 if (dwValid == BASEP_GET_MODULE_HANDLE_EX_PARAMETER_VALIDATION_SUCCESS) return TRUE;
918
919 /* Check if we don't need to convert the name */
920 if (dwFlags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS)
921 {
922 /* Call the extended version of the API without conversion */
923 Ret = BasepGetModuleHandleExW(FALSE,
924 dwFlags,
925 (LPCWSTR)lpModuleName,
926 phModule);
927 }
928 else
929 {
930 /* Convert module name to unicode */
931 lpModuleNameW = Basep8BitStringToStaticUnicodeString(lpModuleName);
932
933 /* Return FALSE if conversion failed */
934 if (!lpModuleNameW) return FALSE;
935
936 /* Call the extended version of the API */
937 Ret = BasepGetModuleHandleExW(FALSE,
938 dwFlags,
939 lpModuleNameW->Buffer,
940 phModule);
941 }
942
943 /* Return result */
944 return Ret;
945 }
946
947
948 /*
949 * @implemented
950 */
951 DWORD
952 WINAPI
953 LoadModule(LPCSTR lpModuleName,
954 LPVOID lpParameterBlock)
955 {
956 STARTUPINFOA StartupInfo;
957 PROCESS_INFORMATION ProcessInformation;
958 LOADPARMS32 *LoadParams;
959 char FileName[MAX_PATH];
960 LPSTR CommandLine;
961 DWORD Length, Error;
962 BOOL ProcessStatus;
963 ANSI_STRING AnsiStr;
964 UNICODE_STRING UnicStr;
965 RTL_PATH_TYPE PathType;
966 HANDLE Handle;
967
968 LoadParams = (LOADPARMS32*)lpParameterBlock;
969
970 /* Check load parameters */
971 if (LoadParams->dwReserved || LoadParams->wMagicValue != 2)
972 {
973 /* Fail with invalid param error */
974 BaseSetLastNTError(STATUS_INVALID_PARAMETER);
975 return 0;
976 }
977
978 /* Search path */
979 Length = SearchPathA(NULL, lpModuleName, ".exe", MAX_PATH, FileName, NULL);
980
981 /* Check if path was found */
982 if (Length && Length < MAX_PATH)
983 {
984 /* Build StartupInfo */
985 RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
986
987 StartupInfo.cb = sizeof(STARTUPINFOA);
988 StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
989 StartupInfo.wShowWindow = LoadParams->wCmdShow;
990
991 /* Allocate command line buffer */
992 CommandLine = RtlAllocateHeap(RtlGetProcessHeap(),
993 HEAP_ZERO_MEMORY,
994 (ULONG)LoadParams->lpCmdLine[0] + Length + 2);
995
996 /* Put module name there, then a space, and then copy provided command line,
997 and null-terminate it */
998 RtlCopyMemory(CommandLine, FileName, Length);
999 CommandLine[Length] = ' ';
1000 RtlCopyMemory(&CommandLine[Length + 1], &LoadParams->lpCmdLine[1], (ULONG)LoadParams->lpCmdLine[0]);
1001 CommandLine[Length + 1 + (ULONG)LoadParams->lpCmdLine[0]] = 0;
1002
1003 /* Create the process */
1004 ProcessStatus = CreateProcessA(FileName,
1005 CommandLine,
1006 NULL,
1007 NULL,
1008 FALSE,
1009 0,
1010 LoadParams->lpEnvAddress,
1011 NULL,
1012 &StartupInfo,
1013 &ProcessInformation);
1014
1015 /* Free the command line buffer */
1016 RtlFreeHeap(RtlGetProcessHeap(), 0, CommandLine);
1017
1018 if (!ProcessStatus)
1019 {
1020 /* Creating process failed, return right error code */
1021 Error = GetLastError();
1022 switch(Error)
1023 {
1024 case ERROR_BAD_EXE_FORMAT:
1025 return ERROR_BAD_FORMAT;
1026
1027 case ERROR_FILE_NOT_FOUND:
1028 case ERROR_PATH_NOT_FOUND:
1029 return Error;
1030 }
1031
1032 /* Return 0 otherwise */
1033 return 0;
1034 }
1035
1036 /* Wait up to 30 seconds for the process to become idle */
1037 if (UserWaitForInputIdleRoutine)
1038 {
1039 UserWaitForInputIdleRoutine(ProcessInformation.hProcess, 30000);
1040 }
1041
1042 /* Close handles */
1043 NtClose(ProcessInformation.hThread);
1044 NtClose(ProcessInformation.hProcess);
1045
1046 /* Return magic success value (33) */
1047 return 33;
1048 }
1049
1050 /* The path was not found, create an ansi string from
1051 the module name and convert it to unicode */
1052 RtlInitAnsiString(&AnsiStr, lpModuleName);
1053 if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicStr,&AnsiStr,TRUE)))
1054 return ERROR_FILE_NOT_FOUND;
1055
1056 /* Determine path type */
1057 PathType = RtlDetermineDosPathNameType_U(UnicStr.Buffer);
1058
1059 /* Free the unicode module name */
1060 RtlFreeUnicodeString(&UnicStr);
1061
1062 /* If it's a relative path, return file not found */
1063 if (PathType == RtlPathTypeRelative)
1064 return ERROR_FILE_NOT_FOUND;
1065
1066 /* If not, try to open it */
1067 Handle = CreateFile(lpModuleName,
1068 GENERIC_READ,
1069 FILE_SHARE_READ | FILE_SHARE_WRITE,
1070 NULL,
1071 OPEN_EXISTING,
1072 FILE_ATTRIBUTE_NORMAL,
1073 NULL);
1074
1075 if (Handle != INVALID_HANDLE_VALUE)
1076 {
1077 /* Opening file succeeded for some reason, close the handle and return file not found anyway */
1078 CloseHandle(Handle);
1079 return ERROR_FILE_NOT_FOUND;
1080 }
1081
1082 /* Return last error which CreateFile set during an attempt to open it */
1083 return GetLastError();
1084 }
1085
1086 /*
1087 * @unimplemented
1088 */
1089 FARPROC WINAPI DelayLoadFailureHook(LPCSTR pszDllName, LPCSTR pszProcName)
1090 {
1091 STUB;
1092 return NULL;
1093 }
1094
1095 /*
1096 * @unimplemented
1097 */
1098 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
1099 LPSTR lpszInitName, LPSTR lpszProcName,
1100 FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
1101 LPVOID lpBuff )
1102 {
1103 STUB;
1104 return 0;
1105 }
1106
1107 /*
1108 * @unimplemented
1109 */
1110 VOID WINAPI UTUnRegister( HMODULE hModule )
1111 {
1112 STUB;
1113 }
1114
1115 /*
1116 * @unimplemented
1117 */
1118 BOOL
1119 WINAPI
1120 BaseQueryModuleData(IN LPSTR ModuleName,
1121 IN LPSTR Unknown,
1122 IN PVOID Unknown2,
1123 IN PVOID Unknown3,
1124 IN PVOID Unknown4)
1125 {
1126 DPRINT1("BaseQueryModuleData called: %s %s %p %p %p\n",
1127 ModuleName,
1128 Unknown,
1129 Unknown2,
1130 Unknown3,
1131 Unknown4);
1132 return FALSE;
1133 }
1134
1135 /*
1136 * @implemented
1137 */
1138 NTSTATUS
1139 WINAPI
1140 BaseProcessInitPostImport(VOID)
1141 {
1142 /* Check if this is a terminal server */
1143 DPRINT1("Post-init called\n");
1144 if (SharedUserData->SuiteMask & VER_SUITE_TERMINAL)
1145 {
1146 /* Initialize TS pointers */
1147 return BasepInitializeTermsrvFpns();
1148 }
1149
1150 /* FIXME: Initialize TS pointers */
1151 return STATUS_SUCCESS;
1152 }
1153
1154 /* EOF */