4 * Copyright 1995 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
38 #include "wine/winbase16.h"
43 #include "builtin16.h"
44 #include "stackframe.h"
46 #include "kernel_private.h"
47 #include "wine/unicode.h"
48 #include "wine/exception.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(module);
52 WINE_DECLARE_DEBUG_CHANNEL(loaddll);
55 typedef struct _GPHANDLERDEF
67 struct ne_segment_table_entry_s
69 WORD seg_data_offset; /* Sector offset of segment data */
70 WORD seg_data_length; /* Length of segment data */
71 WORD seg_flags; /* Flags associated with this segment */
72 WORD min_alloc; /* Minimum allocation size for this */
75 #define hFirstModule (pThhook->hExeHead)
79 void *module_start; /* 32-bit address of the module data */
80 int module_size; /* Size of the module data */
81 void *code_start; /* 32-bit address of DLL code */
82 void *data_start; /* 32-bit address of DLL data */
83 const char *owner; /* 32-bit dll that contains this dll */
84 const void *rsrc; /* resources data */
85 } BUILTIN16_DESCRIPTOR;
87 /* Table of all built-in DLLs */
91 static const BUILTIN16_DESCRIPTOR *builtin_dlls[MAX_DLLS];
93 extern void SNOOP16_RegisterDLL(NE_MODULE*,LPCSTR);
94 extern FARPROC16 SNOOP16_GetProcAddress16(HMODULE16,DWORD,FARPROC16);
96 static HINSTANCE16 NE_LoadModule( LPCSTR name, BOOL lib_only );
97 static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL call_wep );
99 static HINSTANCE16 MODULE_LoadModule16( LPCSTR libname, BOOL implicit, BOOL lib_only );
101 static HMODULE16 NE_GetModuleByFilename( LPCSTR name );
104 static WINE_EXCEPTION_FILTER(page_fault)
106 if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ||
107 GetExceptionCode() == EXCEPTION_PRIV_INSTRUCTION)
108 return EXCEPTION_EXECUTE_HANDLER;
109 return EXCEPTION_CONTINUE_SEARCH;
113 /* patch all the flat cs references of the code segment if necessary */
114 inline static void patch_code_segment( void *code_segment )
117 CALLFROM16 *call = code_segment;
118 if (call->flatcs == wine_get_cs()) return; /* nothing to patch */
119 while (call->pushl == 0x68)
121 call->flatcs = wine_get_cs();
128 /***********************************************************************
131 * locale-independent case conversion for module lookups
133 static int NE_strcasecmp( const char *str1, const char *str2 )
136 for ( ; ; str1++, str2++)
137 if ((ret = RtlUpperChar(*str1) - RtlUpperChar(*str2)) || !*str1) break;
142 /***********************************************************************
145 * locale-independent case conversion for module lookups
147 static int NE_strncasecmp( const char *str1, const char *str2, int len )
150 for ( ; len > 0; len--, str1++, str2++)
151 if ((ret = RtlUpperChar(*str1) - RtlUpperChar(*str2)) || !*str1) break;
156 /***********************************************************************
159 * Find a descriptor in the list
161 static const BUILTIN16_DESCRIPTOR *find_dll_descr( const char *dllname )
164 for (i = 0; i < MAX_DLLS; i++)
166 const BUILTIN16_DESCRIPTOR *descr = builtin_dlls[i];
169 NE_MODULE *pModule = (NE_MODULE *)descr->module_start;
170 OFSTRUCT *pOfs = (OFSTRUCT *)((LPBYTE)pModule + pModule->fileinfo);
171 BYTE *name_table = (BYTE *)pModule + pModule->name_table;
173 /* check the dll file name */
174 if (!NE_strcasecmp( pOfs->szPathName, dllname )) return descr;
175 /* check the dll module name (without extension) */
176 if (!NE_strncasecmp( dllname, name_table+1, *name_table ) &&
177 !strcmp( dllname + *name_table, ".dll" ))
185 /***********************************************************************
186 * __wine_register_dll_16 (KERNEL32.@)
188 * Register a built-in DLL descriptor.
190 void __wine_register_dll_16( const BUILTIN16_DESCRIPTOR *descr )
194 for (i = 0; i < MAX_DLLS; i++)
196 if (builtin_dlls[i]) continue;
197 builtin_dlls[i] = descr;
200 assert( i < MAX_DLLS );
204 /***********************************************************************
205 * __wine_unregister_dll_16 (KERNEL32.@)
207 * Unregister a built-in DLL descriptor.
209 void __wine_unregister_dll_16( const BUILTIN16_DESCRIPTOR *descr )
213 for (i = 0; i < MAX_DLLS; i++)
215 if (builtin_dlls[i] != descr) continue;
216 builtin_dlls[i] = NULL;
222 /***********************************************************************
225 NE_MODULE *NE_GetPtr( HMODULE16 hModule )
227 return (NE_MODULE *)GlobalLock16( GetExePtr(hModule) );
231 /**********************************************************************
234 static void NE_RegisterModule( NE_MODULE *pModule )
236 pModule->next = hFirstModule;
237 hFirstModule = pModule->self;
241 /***********************************************************************
244 void NE_DumpModule( HMODULE16 hModule )
254 if (!(pModule = NE_GetPtr( hModule )))
256 MESSAGE( "**** %04x is not a module handle\n", hModule );
260 /* Dump the module info */
262 DPRINTF( "Module %04x:\n", hModule );
263 DPRINTF( "count=%d flags=%04x heap=%d stack=%d\n",
264 pModule->count, pModule->flags,
265 pModule->heap_size, pModule->stack_size );
266 DPRINTF( "cs:ip=%04x:%04x ss:sp=%04x:%04x ds=%04x nb seg=%d modrefs=%d\n",
267 pModule->cs, pModule->ip, pModule->ss, pModule->sp, pModule->dgroup,
268 pModule->seg_count, pModule->modref_count );
269 DPRINTF( "os_flags=%d swap_area=%d version=%04x\n",
270 pModule->os_flags, pModule->min_swap_area,
271 pModule->expected_version );
272 if (pModule->flags & NE_FFLAGS_WIN32)
273 DPRINTF( "PE module=%p\n", pModule->module32 );
275 /* Dump the file info */
277 DPRINTF( "Filename: '%s'\n", NE_MODULE_NAME(pModule) );
279 /* Dump the segment table */
281 DPRINTF( "Segment table:\n" );
282 pSeg = NE_SEG_TABLE( pModule );
283 for (i = 0; i < pModule->seg_count; i++, pSeg++)
284 DPRINTF( "%02x: pos=%d size=%d flags=%04x minsize=%d hSeg=%04x\n",
285 i + 1, pSeg->filepos, pSeg->size, pSeg->flags,
286 pSeg->minsize, pSeg->hSeg );
288 /* Dump the resource table */
290 DPRINTF( "Resource table:\n" );
291 if (pModule->res_table)
293 pword = (WORD *)((BYTE *)pModule + pModule->res_table);
294 DPRINTF( "Alignment: %d\n", *pword++ );
297 NE_TYPEINFO *ptr = (NE_TYPEINFO *)pword;
298 NE_NAMEINFO *pname = (NE_NAMEINFO *)(ptr + 1);
299 DPRINTF( "id=%04x count=%d\n", ptr->type_id, ptr->count );
300 for (i = 0; i < ptr->count; i++, pname++)
301 DPRINTF( "offset=%d len=%d id=%04x\n",
302 pname->offset, pname->length, pname->id );
303 pword = (WORD *)pname;
306 else DPRINTF( "None\n" );
308 /* Dump the resident name table */
310 DPRINTF( "Resident-name table:\n" );
311 pstr = (char *)pModule + pModule->name_table;
314 DPRINTF( "%*.*s: %d\n", *pstr, *pstr, pstr + 1,
315 *(WORD *)(pstr + *pstr + 1) );
316 pstr += *pstr + 1 + sizeof(WORD);
319 /* Dump the module reference table */
321 DPRINTF( "Module ref table:\n" );
322 if (pModule->modref_table)
324 pword = (WORD *)((BYTE *)pModule + pModule->modref_table);
325 for (i = 0; i < pModule->modref_count; i++, pword++)
328 GetModuleName16( *pword, name, sizeof(name) );
329 DPRINTF( "%d: %04x -> '%s'\n", i, *pword, name );
332 else DPRINTF( "None\n" );
334 /* Dump the entry table */
336 DPRINTF( "Entry table:\n" );
337 bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->entry_table);
339 entry = (ET_ENTRY *)((BYTE *)bundle+6);
340 DPRINTF( "Bundle %d-%d: %02x\n", bundle->first, bundle->last, entry->type);
341 ordinal = bundle->first;
342 while (ordinal < bundle->last)
344 if (entry->type == 0xff)
345 DPRINTF("%d: %02x:%04x (moveable)\n", ordinal++, entry->segnum, entry->offs);
347 DPRINTF("%d: %02x:%04x (fixed)\n", ordinal++, entry->segnum, entry->offs);
350 } while ( (bundle->next) && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
352 /* Dump the non-resident names table */
354 DPRINTF( "Non-resident names table:\n" );
355 if (pModule->nrname_handle)
357 pstr = (char *)GlobalLock16( pModule->nrname_handle );
360 DPRINTF( "%*.*s: %d\n", *pstr, *pstr, pstr + 1,
361 *(WORD *)(pstr + *pstr + 1) );
362 pstr += *pstr + 1 + sizeof(WORD);
369 /***********************************************************************
372 * Walk the module list and print the modules.
374 void NE_WalkModules(void)
376 HMODULE16 hModule = hFirstModule;
377 MESSAGE( "Module Flags Name\n" );
380 NE_MODULE *pModule = NE_GetPtr( hModule );
383 MESSAGE( "Bad module %04x in list\n", hModule );
386 MESSAGE( " %04x %04x %.*s\n", hModule, pModule->flags,
387 *((char *)pModule + pModule->name_table),
388 (char *)pModule + pModule->name_table + 1 );
389 hModule = pModule->next;
394 /***********************************************************************
395 * NE_InitResourceHandler
397 * Fill in 'resloader' fields in the resource table.
399 static void NE_InitResourceHandler( NE_MODULE *pModule )
401 static FARPROC16 proc;
403 NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
405 TRACE("InitResourceHandler[%04x]\n", pModule->self );
407 if (!proc) proc = GetProcAddress16( GetModuleHandle16("KERNEL"), "DefResourceHandler" );
409 while(pTypeInfo->type_id)
411 memcpy_unaligned( &pTypeInfo->resloader, &proc, sizeof(FARPROC16) );
412 pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo + 1) + pTypeInfo->count * sizeof(NE_NAMEINFO));
417 /***********************************************************************
420 * Lookup the ordinal for a given name.
422 WORD NE_GetOrdinal( HMODULE16 hModule, const char *name )
424 unsigned char buffer[256], *cpnt;
428 if (!(pModule = NE_GetPtr( hModule ))) return 0;
429 if (pModule->flags & NE_FFLAGS_WIN32) return 0;
431 TRACE("(%04x,'%s')\n", hModule, name );
433 /* First handle names of the form '#xxxx' */
435 if (name[0] == '#') return atoi( name + 1 );
437 /* Now copy and uppercase the string */
439 strcpy( buffer, name );
440 for (cpnt = buffer; *cpnt; cpnt++) *cpnt = RtlUpperChar(*cpnt);
443 /* First search the resident names */
445 cpnt = (char *)pModule + pModule->name_table;
447 /* Skip the first entry (module name) */
448 cpnt += *cpnt + 1 + sizeof(WORD);
451 if (((BYTE)*cpnt == len) && !memcmp( cpnt+1, buffer, len ))
454 memcpy( &ordinal, cpnt + *cpnt + 1, sizeof(ordinal) );
455 TRACE(" Found: ordinal=%d\n", ordinal );
458 cpnt += *cpnt + 1 + sizeof(WORD);
461 /* Now search the non-resident names table */
463 if (!pModule->nrname_handle) return 0; /* No non-resident table */
464 cpnt = (char *)GlobalLock16( pModule->nrname_handle );
466 /* Skip the first entry (module description string) */
467 cpnt += *cpnt + 1 + sizeof(WORD);
470 if (((BYTE)*cpnt == len) && !memcmp( cpnt+1, buffer, len ))
473 memcpy( &ordinal, cpnt + *cpnt + 1, sizeof(ordinal) );
474 TRACE(" Found: ordinal=%d\n", ordinal );
477 cpnt += *cpnt + 1 + sizeof(WORD);
483 /***********************************************************************
486 FARPROC16 WINAPI NE_GetEntryPoint( HMODULE16 hModule, WORD ordinal )
488 return NE_GetEntryPointEx( hModule, ordinal, TRUE );
491 /***********************************************************************
494 FARPROC16 NE_GetEntryPointEx( HMODULE16 hModule, WORD ordinal, BOOL16 snoop )
502 if (!(pModule = NE_GetPtr( hModule ))) return 0;
503 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
505 bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->entry_table);
506 while ((ordinal < bundle->first + 1) || (ordinal > bundle->last))
510 bundle = (ET_BUNDLE *)((BYTE *)pModule + bundle->next);
513 entry = (ET_ENTRY *)((BYTE *)bundle+6);
514 for (i=0; i < (ordinal - bundle->first - 1); i++)
518 memcpy( &offset, &entry->offs, sizeof(WORD) );
520 if (sel == 0xfe) sel = 0xffff; /* constant entry */
521 else sel = GlobalHandleToSel16(NE_SEG_TABLE(pModule)[sel-1].hSeg);
523 return (FARPROC16)MAKESEGPTR( sel, offset );
525 return (FARPROC16)MAKESEGPTR( sel, offset );
527 return (FARPROC16)SNOOP16_GetProcAddress16(hModule,ordinal,(FARPROC16)MAKESEGPTR( sel, offset ));
531 /***********************************************************************
532 * EntryAddrProc (KERNEL.667) Wine-specific export
534 * Return the entry point for a given ordinal.
536 FARPROC16 WINAPI EntryAddrProc16( HMODULE16 hModule, WORD ordinal )
538 FARPROC16 ret = NE_GetEntryPointEx( hModule, ordinal, TRUE );
539 CURRENT_STACK16->ecx = hModule; /* FIXME: might be incorrect value */
543 /***********************************************************************
546 * Change the value of an entry point. Use with caution!
547 * It can only change the offset value, not the selector.
549 BOOL16 NE_SetEntryPoint( HMODULE16 hModule, WORD ordinal, WORD offset )
556 if (!(pModule = NE_GetPtr( hModule ))) return FALSE;
557 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
559 bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->entry_table);
560 while ((ordinal < bundle->first + 1) || (ordinal > bundle->last))
562 bundle = (ET_BUNDLE *)((BYTE *)pModule + bundle->next);
563 if (!(bundle->next)) return 0;
566 entry = (ET_ENTRY *)((BYTE *)bundle+6);
567 for (i=0; i < (ordinal - bundle->first - 1); i++)
570 memcpy( &entry->offs, &offset, sizeof(WORD) );
575 /***********************************************************************
578 HANDLE NE_OpenFile( NE_MODULE *pModule )
581 char *name = NE_MODULE_NAME( pModule );
583 TRACE("(%p)\n", pModule );
587 if (!DuplicateHandle( GetCurrentProcess(), pModule->fd,
588 GetCurrentProcess(), &handle, 0, FALSE,
589 DUPLICATE_SAME_ACCESS )) handle = INVALID_HANDLE_VALUE;
593 handle = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
594 NULL, OPEN_EXISTING, 0, 0 );
596 if (handle == INVALID_HANDLE_VALUE)
597 ERR( "Can't open file '%s' for module %04x\n", name, pModule->self );
599 TRACE("opened '%s' -> %p\n", name, handle);
604 /* wrapper for SetFilePointer and ReadFile */
605 static BOOL read_data( HANDLE handle, LONG offset, void *buffer, DWORD size )
609 if (SetFilePointer( handle, offset, NULL, SEEK_SET ) == INVALID_SET_FILE_POINTER) return FALSE;
610 if (!ReadFile( handle, buffer, size, &result, NULL )) return FALSE;
611 return (result == size);
614 /***********************************************************************
617 static HMODULE16 NE_LoadExeHeader( HANDLE handle, LPCSTR path )
619 IMAGE_DOS_HEADER mz_header;
620 IMAGE_OS2_HEADER ne_header;
624 BYTE *pData, *pTempEntryTable;
625 char *buffer, *fastload = NULL;
626 int fastload_offset = 0, fastload_length = 0;
628 ET_BUNDLE *bundle, *oldbundle;
631 /* Read a block from either the file or the fast-load area. */
632 #define READ(offset,size,buffer) \
633 ((fastload && ((offset) >= fastload_offset) && \
634 ((offset)+(size) <= fastload_offset+fastload_length)) ? \
635 (memcpy( buffer, fastload+(offset)-fastload_offset, (size) ), TRUE) : \
636 read_data( handle, (offset), (buffer), (size)))
638 if (!read_data( handle, 0, &mz_header, sizeof(mz_header)) ||
639 (mz_header.e_magic != IMAGE_DOS_SIGNATURE))
640 return (HMODULE16)11; /* invalid exe */
642 if (!read_data( handle, mz_header.e_lfanew, &ne_header, sizeof(ne_header) ))
643 return (HMODULE16)11; /* invalid exe */
645 if (ne_header.ne_magic == IMAGE_NT_SIGNATURE) return (HMODULE16)21; /* win32 exe */
646 if (ne_header.ne_magic == IMAGE_OS2_SIGNATURE_LX) {
647 MESSAGE("Sorry, this is an OS/2 linear executable (LX) file !\n");
648 return (HMODULE16)12;
650 if (ne_header.ne_magic != IMAGE_OS2_SIGNATURE) return (HMODULE16)11; /* invalid exe */
652 /* We now have a valid NE header */
654 size = sizeof(NE_MODULE) +
656 ne_header.ne_cseg * sizeof(SEGTABLEENTRY) +
658 ne_header.ne_restab - ne_header.ne_rsrctab +
659 /* resident names table */
660 ne_header.ne_modtab - ne_header.ne_restab +
661 /* module ref table */
662 ne_header.ne_cmod * sizeof(WORD) +
663 /* imported names table */
664 ne_header.ne_enttab - ne_header.ne_imptab +
665 /* entry table length */
666 ne_header.ne_cbenttab +
667 /* entry table extra conversion space */
669 2 * (ne_header.ne_cbenttab - ne_header.ne_cmovent*6) +
670 /* loaded file info */
671 sizeof(OFSTRUCT) - sizeof(ofs->szPathName) + strlen(path) + 1;
673 hModule = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, size );
674 if (!hModule) return (HMODULE16)11; /* invalid exe */
676 FarSetOwner16( hModule, hModule );
677 pModule = (NE_MODULE *)GlobalLock16( hModule );
678 memcpy( pModule, &ne_header, sizeof(ne_header) );
680 /* check *programs* for default minimal stack size */
681 if ( (!(pModule->flags & NE_FFLAGS_LIBMODULE))
682 && (pModule->stack_size < 0x1400) )
683 pModule->stack_size = 0x1400;
684 pModule->module32 = 0;
685 pModule->self = hModule;
686 pModule->self_loading_sel = 0;
687 pData = (BYTE *)(pModule + 1);
689 /* Clear internal Wine flags in case they are set in the EXE file */
691 pModule->flags &= ~(NE_FFLAGS_BUILTIN | NE_FFLAGS_WIN32);
693 /* Read the fast-load area */
695 if (ne_header.ne_flagsothers & NE_AFLAGS_FASTLOAD)
697 fastload_offset=ne_header.ne_pretthunks << ne_header.ne_align;
698 fastload_length=ne_header.ne_psegrefbytes << ne_header.ne_align;
699 TRACE("Using fast-load area offset=%x len=%d\n",
700 fastload_offset, fastload_length );
701 if ((fastload = HeapAlloc( GetProcessHeap(), 0, fastload_length )) != NULL)
703 if (!read_data( handle, fastload_offset, fastload, fastload_length))
705 HeapFree( GetProcessHeap(), 0, fastload );
706 WARN("Error reading fast-load area!\n");
712 /* Get the segment table */
714 pModule->seg_table = pData - (BYTE *)pModule;
715 buffer = HeapAlloc( GetProcessHeap(), 0, ne_header.ne_cseg *
716 sizeof(struct ne_segment_table_entry_s));
720 struct ne_segment_table_entry_s *pSeg;
722 if (!READ( mz_header.e_lfanew + ne_header.ne_segtab,
723 ne_header.ne_cseg * sizeof(struct ne_segment_table_entry_s),
726 HeapFree( GetProcessHeap(), 0, buffer );
727 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
728 GlobalFree16( hModule );
729 return (HMODULE16)11; /* invalid exe */
731 pSeg = (struct ne_segment_table_entry_s *)buffer;
732 for (i = ne_header.ne_cseg; i > 0; i--, pSeg++)
734 memcpy( pData, pSeg, sizeof(*pSeg) );
735 pData += sizeof(SEGTABLEENTRY);
737 HeapFree( GetProcessHeap(), 0, buffer );
741 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
742 GlobalFree16( hModule );
743 return (HMODULE16)11; /* invalid exe */
746 /* Get the resource table */
748 if (ne_header.ne_rsrctab < ne_header.ne_restab)
750 pModule->res_table = pData - (BYTE *)pModule;
751 if (!READ(mz_header.e_lfanew + ne_header.ne_rsrctab,
752 ne_header.ne_restab - ne_header.ne_rsrctab,
754 return (HMODULE16)11; /* invalid exe */
755 pData += ne_header.ne_restab - ne_header.ne_rsrctab;
756 NE_InitResourceHandler( pModule );
758 else pModule->res_table = 0; /* No resource table */
760 /* Get the resident names table */
762 pModule->name_table = pData - (BYTE *)pModule;
763 if (!READ( mz_header.e_lfanew + ne_header.ne_restab,
764 ne_header.ne_modtab - ne_header.ne_restab,
767 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
768 GlobalFree16( hModule );
769 return (HMODULE16)11; /* invalid exe */
771 pData += ne_header.ne_modtab - ne_header.ne_restab;
773 /* Get the module references table */
775 if (ne_header.ne_cmod > 0)
777 pModule->modref_table = pData - (BYTE *)pModule;
778 if (!READ( mz_header.e_lfanew + ne_header.ne_modtab,
779 ne_header.ne_cmod * sizeof(WORD),
782 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
783 GlobalFree16( hModule );
784 return (HMODULE16)11; /* invalid exe */
786 pData += ne_header.ne_cmod * sizeof(WORD);
788 else pModule->modref_table = 0; /* No module references */
790 /* Get the imported names table */
792 pModule->import_table = pData - (BYTE *)pModule;
793 if (!READ( mz_header.e_lfanew + ne_header.ne_imptab,
794 ne_header.ne_enttab - ne_header.ne_imptab,
797 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
798 GlobalFree16( hModule );
799 return (HMODULE16)11; /* invalid exe */
801 pData += ne_header.ne_enttab - ne_header.ne_imptab;
803 /* Load entry table, convert it to the optimized version used by Windows */
805 if ((pTempEntryTable = HeapAlloc( GetProcessHeap(), 0, ne_header.ne_cbenttab)) != NULL)
807 BYTE nr_entries, type, *s;
809 TRACE("Converting entry table.\n");
810 pModule->entry_table = pData - (BYTE *)pModule;
811 if (!READ( mz_header.e_lfanew + ne_header.ne_enttab,
812 ne_header.ne_cbenttab, pTempEntryTable ))
814 HeapFree( GetProcessHeap(), 0, pTempEntryTable );
815 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
816 GlobalFree16( hModule );
817 return (HMODULE16)11; /* invalid exe */
821 TRACE("entry table: offs %04x, len %04x, entries %d\n", ne_header.ne_enttab, ne_header.ne_cbenttab, *s);
823 bundle = (ET_BUNDLE *)pData;
824 TRACE("first bundle: %p\n", bundle);
825 memset(bundle, 0, sizeof(ET_BUNDLE)); /* in case no entry table exists */
826 entry = (ET_ENTRY *)((BYTE *)bundle+6);
828 while ((nr_entries = *s++))
832 bundle->last += nr_entries;
839 entry->segnum = *s++;
840 entry->offs = *(WORD *)s; s += 2;
841 /*TRACE(module, "entry: %p, type: %d, flags: %d, segnum: %d, offs: %04x\n", entry, entry->type, entry->flags, entry->segnum, entry->offs);*/
849 entry->segnum = type;
850 entry->offs = *(WORD *)s; s += 2;
851 /*TRACE(module, "entry: %p, type: %d, flags: %d, segnum: %d, offs: %04x\n", entry, entry->type, entry->flags, entry->segnum, entry->offs);*/
857 if (bundle->first == bundle->last)
859 bundle->first += nr_entries;
860 bundle->last += nr_entries;
865 oldbundle->next = ((int)entry - (int)pModule);
866 bundle = (ET_BUNDLE *)entry;
867 TRACE("new bundle: %p\n", bundle);
868 bundle->first = bundle->last =
869 oldbundle->last + nr_entries;
871 (BYTE *)entry += sizeof(ET_BUNDLE);
875 HeapFree( GetProcessHeap(), 0, pTempEntryTable );
879 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
880 GlobalFree16( hModule );
881 return (HMODULE16)11; /* invalid exe */
884 pData += ne_header.ne_cbenttab + sizeof(ET_BUNDLE) +
885 2 * (ne_header.ne_cbenttab - ne_header.ne_cmovent*6);
887 if ((DWORD)entry > (DWORD)pData)
888 ERR("converted entry table bigger than reserved space !!!\nentry: %p, pData: %p. Please report !\n", entry, pData);
890 /* Store the filename information */
892 pModule->fileinfo = pData - (BYTE *)pModule;
893 size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName) + strlen(path) + 1;
894 ofs = (OFSTRUCT *)pData;
895 ofs->cBytes = size - 1;
897 strcpy( ofs->szPathName, path );
900 /* Free the fast-load area */
903 if (fastload) HeapFree( GetProcessHeap(), 0, fastload );
905 /* Get the non-resident names table */
907 if (ne_header.ne_cbnrestab)
909 pModule->nrname_handle = GlobalAlloc16( 0, ne_header.ne_cbnrestab );
910 if (!pModule->nrname_handle)
912 GlobalFree16( hModule );
913 return (HMODULE16)11; /* invalid exe */
915 FarSetOwner16( pModule->nrname_handle, hModule );
916 buffer = GlobalLock16( pModule->nrname_handle );
917 if (!read_data( handle, ne_header.ne_nrestab, buffer, ne_header.ne_cbnrestab ))
919 GlobalFree16( pModule->nrname_handle );
920 GlobalFree16( hModule );
921 return (HMODULE16)11; /* invalid exe */
924 else pModule->nrname_handle = 0;
926 /* Allocate a segment for the implicitly-loaded DLLs */
928 if (pModule->modref_count)
930 pModule->dlls_to_init = GlobalAlloc16( GMEM_ZEROINIT,
931 (pModule->modref_count+1)*sizeof(HMODULE16) );
932 if (!pModule->dlls_to_init)
934 if (pModule->nrname_handle) GlobalFree16( pModule->nrname_handle );
935 GlobalFree16( hModule );
936 return (HMODULE16)11; /* invalid exe */
938 FarSetOwner16( pModule->dlls_to_init, hModule );
940 else pModule->dlls_to_init = 0;
942 NE_RegisterModule( pModule );
943 SNOOP16_RegisterDLL(pModule,path);
948 /***********************************************************************
951 * Load all DLLs implicitly linked to a module.
953 static BOOL NE_LoadDLLs( NE_MODULE *pModule )
956 WORD *pModRef = (WORD *)((char *)pModule + pModule->modref_table);
957 WORD *pDLLs = (WORD *)GlobalLock16( pModule->dlls_to_init );
959 for (i = 0; i < pModule->modref_count; i++, pModRef++)
961 char buffer[260], *p;
962 BYTE *pstr = (BYTE *)pModule + pModule->import_table + *pModRef;
963 memcpy( buffer, pstr + 1, *pstr );
964 *(buffer + *pstr) = 0; /* terminate it */
966 TRACE("Loading '%s'\n", buffer );
967 if (!(*pModRef = GetModuleHandle16( buffer )))
969 /* If the DLL is not loaded yet, load it and store */
970 /* its handle in the list of DLLs to initialize. */
973 /* Append .DLL to name if no extension present */
974 if (!(p = strrchr( buffer, '.')) || strchr( p, '/' ) || strchr( p, '\\'))
975 strcat( buffer, ".DLL" );
977 if ((hDLL = MODULE_LoadModule16( buffer, TRUE, TRUE )) < 32)
979 /* FIXME: cleanup what was done */
981 MESSAGE( "Could not load '%s' required by '%.*s', error=%d\n",
982 buffer, *((BYTE*)pModule + pModule->name_table),
983 (char *)pModule + pModule->name_table + 1, hDLL );
986 *pModRef = GetExePtr( hDLL );
989 else /* Increment the reference count of the DLL */
991 NE_MODULE *pOldDLL = NE_GetPtr( *pModRef );
992 if (pOldDLL) pOldDLL->count++;
999 /**********************************************************************
1002 * Load first instance of NE module from file.
1004 * pModule must point to a module structure prepared by NE_LoadExeHeader.
1005 * This routine must never be called twice on a module.
1008 static HINSTANCE16 NE_DoLoadModule( NE_MODULE *pModule )
1010 /* Allocate the segments for this module */
1012 if (!NE_CreateAllSegments( pModule ))
1013 return ERROR_NOT_ENOUGH_MEMORY; /* 8 */
1015 /* Load the referenced DLLs */
1017 if (!NE_LoadDLLs( pModule ))
1018 return ERROR_FILE_NOT_FOUND; /* 2 */
1020 /* Load the segments */
1022 NE_LoadAllSegments( pModule );
1024 /* Make sure the usage count is 1 on the first loading of */
1025 /* the module, even if it contains circular DLL references */
1029 return NE_GetInstance( pModule );
1032 /**********************************************************************
1035 * Load first instance of NE module. (Note: caller is responsible for
1036 * ensuring the module isn't already loaded!)
1038 * If the module turns out to be an executable module, only a
1039 * handle to a module stub is returned; this needs to be initialized
1040 * by calling NE_DoLoadModule later, in the context of the newly
1043 * If lib_only is TRUE, however, the module is perforce treated
1044 * like a DLL module, even if it is an executable module.
1047 static HINSTANCE16 NE_LoadModule( LPCSTR name, BOOL lib_only )
1051 HINSTANCE16 hInstance;
1057 if ((hFile = OpenFile16( name, &ofs, OF_READ|OF_SHARE_DENY_WRITE )) == HFILE_ERROR16)
1058 return ERROR_FILE_NOT_FOUND;
1060 hModule = NE_LoadExeHeader( DosFileHandleToWin32Handle(hFile), ofs.szPathName );
1066 pModule = NE_GetPtr( hModule );
1068 drive_type = GetDriveTypeA( ofs.szPathName );
1069 if (drive_type != DRIVE_REMOVABLE && drive_type != DRIVE_CDROM)
1071 /* keep the file handle open if not on a removable media */
1072 DuplicateHandle( GetCurrentProcess(), DosFileHandleToWin32Handle(hFile),
1073 GetCurrentProcess(), &pModule->fd, 0, FALSE,
1074 DUPLICATE_SAME_ACCESS );
1078 if ( !lib_only && !( pModule->flags & NE_FFLAGS_LIBMODULE ) )
1081 hInstance = NE_DoLoadModule( pModule );
1082 if ( hInstance < 32 )
1085 NE_FreeModule( hModule, 0 );
1092 /***********************************************************************
1093 * NE_DoLoadBuiltinModule
1095 * Load a built-in Win16 module. Helper function for NE_LoadBuiltinModule.
1097 static HMODULE16 NE_DoLoadBuiltinModule( const BUILTIN16_DESCRIPTOR *descr )
1101 SEGTABLEENTRY *pSegTable;
1104 hModule = GLOBAL_CreateBlock( GMEM_MOVEABLE, descr->module_start,
1105 descr->module_size, 0, WINE_LDT_FLAGS_DATA );
1106 if (!hModule) return ERROR_NOT_ENOUGH_MEMORY;
1107 FarSetOwner16( hModule, hModule );
1109 pModule = (NE_MODULE *)GlobalLock16( hModule );
1110 pModule->self = hModule;
1111 /* NOTE: (Ab)use the hRsrcMap parameter for resource data pointer */
1112 pModule->hRsrcMap = (void *)descr->rsrc;
1114 /* Allocate the code segment */
1116 pSegTable = NE_SEG_TABLE( pModule );
1117 pSegTable->hSeg = GLOBAL_CreateBlock( GMEM_FIXED, descr->code_start,
1118 pSegTable->minsize, hModule,
1119 WINE_LDT_FLAGS_CODE|WINE_LDT_FLAGS_32BIT );
1120 if (!pSegTable->hSeg) return ERROR_NOT_ENOUGH_MEMORY;
1121 patch_code_segment( descr->code_start );
1124 /* Allocate the data segment */
1126 minsize = pSegTable->minsize ? pSegTable->minsize : 0x10000;
1127 minsize += pModule->heap_size;
1128 if (minsize > 0x10000) minsize = 0x10000;
1129 pSegTable->hSeg = GlobalAlloc16( GMEM_FIXED, minsize );
1130 if (!pSegTable->hSeg) return ERROR_NOT_ENOUGH_MEMORY;
1131 FarSetOwner16( pSegTable->hSeg, hModule );
1132 if (pSegTable->minsize) memcpy( GlobalLock16( pSegTable->hSeg ),
1133 descr->data_start, pSegTable->minsize);
1134 if (pModule->heap_size)
1135 LocalInit16( GlobalHandleToSel16(pSegTable->hSeg), pSegTable->minsize, minsize );
1137 if (descr->rsrc) NE_InitResourceHandler(pModule);
1139 NE_RegisterModule( pModule );
1145 /**********************************************************************
1146 * MODULE_LoadModule16
1148 * Load a NE module in the order of the loadorder specification.
1149 * The caller is responsible that the module is not loaded already.
1152 static HINSTANCE16 MODULE_LoadModule16( LPCSTR libname, BOOL implicit, BOOL lib_only )
1154 HINSTANCE16 hinst = 2;
1157 const BUILTIN16_DESCRIPTOR *descr = NULL;
1158 char dllname[20], owner[20], *p;
1159 const char *basename;
1161 /* strip path information */
1164 if (basename[0] && basename[1] == ':') basename += 2; /* strip drive specification */
1165 if ((p = strrchr( basename, '\\' ))) basename = p + 1;
1166 if ((p = strrchr( basename, '/' ))) basename = p + 1;
1168 if (strlen(basename) < sizeof(dllname)-4)
1170 strcpy( dllname, basename );
1171 p = strrchr( dllname, '.' );
1172 if (!p) strcat( dllname, ".dll" );
1173 for (p = dllname; *p; p++) if (*p >= 'A' && *p <= 'Z') *p += 32;
1175 if (!(descr = find_dll_descr( dllname )))
1179 if (wine_dll_get_owner( dllname, owner, sizeof(owner), &file_exists ) == -1)
1181 if (file_exists) return 21; /* it may be a Win32 module then */
1183 else /* found 32-bit owner, try to load it */
1185 HMODULE mod32 = LoadLibraryA( owner );
1188 if (!(descr = find_dll_descr( dllname ))) FreeLibrary( mod32 );
1189 /* loading the 32-bit library can have the side effect of loading the module */
1190 /* if so, simply incr the ref count and return the module */
1191 if ((hModule = GetModuleHandle16( libname )))
1193 TRACE( "module %s already loaded by owner\n", libname );
1194 pModule = NE_GetPtr( hModule );
1195 if (pModule) pModule->count++;
1201 /* it's probably disabled by the load order config */
1202 WARN( "couldn't load owner %s for 16-bit dll %s\n", owner, dllname );
1203 return ERROR_FILE_NOT_FOUND;
1211 TRACE("Trying built-in '%s'\n", libname);
1212 hinst = NE_DoLoadBuiltinModule( descr );
1213 if (hinst > 32) TRACE_(loaddll)("Loaded module %s : builtin\n", debugstr_a(libname));
1217 TRACE("Trying native dll '%s'\n", libname);
1218 hinst = NE_LoadModule(libname, lib_only);
1219 if (hinst > 32) TRACE_(loaddll)("Loaded module %s : native\n", debugstr_a(libname));
1222 if (hinst > 32 && !implicit)
1224 hModule = GetModuleHandle16(libname);
1227 ERR("Serious trouble. Just loaded module '%s' (hinst=0x%04x), but can't get module handle. Filename too long ?\n",
1229 return ERROR_INVALID_HANDLE;
1232 pModule = NE_GetPtr(hModule);
1235 ERR("Serious trouble. Just loaded module '%s' (hinst=0x%04x), but can't get NE_MODULE pointer\n",
1237 return ERROR_INVALID_HANDLE;
1240 TRACE("Loaded module '%s' at 0x%04x.\n", libname, hinst);
1243 * Call initialization routines for all loaded DLLs. Note that
1244 * when we load implicitly linked DLLs this will be done by InitTask().
1246 if(pModule->flags & NE_FFLAGS_LIBMODULE)
1248 NE_InitializeDLLs(hModule);
1249 NE_DllProcessAttach(hModule);
1252 return hinst; /* The last error that occurred */
1256 /**********************************************************************
1259 * Create the thread for a 16-bit module.
1261 static HINSTANCE16 NE_CreateThread( NE_MODULE *pModule, WORD cmdShow, LPCSTR cmdline )
1266 HINSTANCE16 instance = 0;
1268 if (!(hTask = TASK_SpawnTask( pModule, cmdShow, cmdline + 1, *cmdline, &hThread )))
1271 /* Post event to start the task */
1272 PostEvent16( hTask );
1274 /* Wait until we get the instance handle */
1277 DirectedYield16( hTask );
1278 if (!IsTask16( hTask )) /* thread has died */
1281 WaitForSingleObject( hThread, INFINITE );
1282 GetExitCodeThread( hThread, &exit_code );
1283 CloseHandle( hThread );
1286 if (!(pTask = GlobalLock16( hTask ))) break;
1287 instance = pTask->hInstance;
1288 GlobalUnlock16( hTask );
1289 } while (!instance);
1291 CloseHandle( hThread );
1296 /**********************************************************************
1297 * LoadModule (KERNEL.45)
1299 HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
1301 BOOL lib_only = !paramBlock || (paramBlock == (LPVOID)-1);
1302 LOADPARAMS16 *params;
1310 if ( (hModule = NE_GetModuleByFilename(name) ) != 0 )
1312 /* Special case: second instance of an already loaded NE module */
1314 if ( !( pModule = NE_GetPtr( hModule ) ) ) return (HINSTANCE16)11;
1315 if ( pModule->module32 ) return (HINSTANCE16)21;
1317 /* Increment refcount */
1323 /* Main case: load first instance of NE module */
1325 if ( (hModule = MODULE_LoadModule16( name, FALSE, lib_only )) < 32 )
1328 if ( !(pModule = NE_GetPtr( hModule )) )
1329 return (HINSTANCE16)11;
1332 /* If library module, we just retrieve the instance handle */
1334 if ( ( pModule->flags & NE_FFLAGS_LIBMODULE ) || lib_only )
1335 return NE_GetInstance( pModule );
1338 * At this point, we need to create a new process.
1340 * pModule points either to an already loaded module, whose refcount
1341 * has already been incremented (to avoid having the module vanish
1342 * in the meantime), or else to a stub module which contains only header
1345 params = (LOADPARAMS16 *)paramBlock;
1346 cmdShow = ((WORD *)MapSL(params->showCmd))[1];
1347 cmdline = MapSL( params->cmdLine );
1348 return NE_CreateThread( pModule, cmdShow, cmdline );
1352 /**********************************************************************
1355 * Startup code for a new 16-bit task.
1357 DWORD NE_StartTask(void)
1359 TDB *pTask = TASK_GetCurrent();
1360 NE_MODULE *pModule = NE_GetPtr( pTask->hModule );
1361 HINSTANCE16 hInstance, hPrevInstance;
1362 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
1365 if ( pModule->count > 0 )
1367 /* Second instance of an already loaded NE module */
1368 /* Note that the refcount was already incremented by the parent */
1370 hPrevInstance = NE_GetInstance( pModule );
1372 if ( pModule->dgroup )
1373 if ( NE_CreateSegment( pModule, pModule->dgroup ) )
1374 NE_LoadSegment( pModule, pModule->dgroup );
1376 hInstance = NE_GetInstance( pModule );
1377 TRACE("created second instance %04x[%d] of instance %04x.\n", hInstance, pModule->dgroup, hPrevInstance);
1382 /* Load first instance of NE module */
1384 pModule->flags |= NE_FFLAGS_GUI; /* FIXME: is this necessary? */
1386 hInstance = NE_DoLoadModule( pModule );
1390 if ( hInstance >= 32 )
1394 /* Enter instance handles into task struct */
1396 pTask->hInstance = hInstance;
1397 pTask->hPrevInstance = hPrevInstance;
1399 /* Use DGROUP for 16-bit stack */
1401 if (!(sp = pModule->sp))
1402 sp = pSegTable[pModule->ss-1].minsize + pModule->stack_size;
1404 sp -= sizeof(STACK16FRAME);
1405 NtCurrentTeb()->cur_stack = MAKESEGPTR( GlobalHandleToSel16(hInstance), sp );
1407 /* Registers at initialization must be:
1409 * bx stack size in bytes
1410 * cx heap size in bytes
1411 * si previous app instance
1412 * di current app instance
1414 * es selector to the PSP
1415 * ds dgroup of the application
1417 * sp top of the stack
1419 memset( &context, 0, sizeof(context) );
1420 context.SegCs = GlobalHandleToSel16(pSegTable[pModule->cs - 1].hSeg);
1421 context.SegDs = GlobalHandleToSel16(pTask->hInstance);
1422 context.SegEs = pTask->hPDB;
1423 context.SegFs = wine_get_fs();
1424 context.SegGs = wine_get_gs();
1425 context.Eip = pModule->ip;
1426 context.Ebx = pModule->stack_size;
1427 context.Ecx = pModule->heap_size;
1428 context.Edi = pTask->hInstance;
1429 context.Esi = pTask->hPrevInstance;
1431 /* Now call 16-bit entry point */
1433 TRACE("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
1434 context.SegCs, context.Eip, context.SegDs,
1435 SELECTOROF(NtCurrentTeb()->cur_stack),
1436 OFFSETOF(NtCurrentTeb()->cur_stack) );
1438 WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&context );
1439 ExitThread( LOWORD(context.Eax) );
1441 return hInstance; /* error code */
1444 /***********************************************************************
1445 * LoadLibrary (KERNEL.95)
1446 * LoadLibrary16 (KERNEL32.35)
1448 HINSTANCE16 WINAPI LoadLibrary16( LPCSTR libname )
1450 return LoadModule16(libname, (LPVOID)-1 );
1454 /**********************************************************************
1457 * Call a DLL's WEP, allowing it to shut down.
1458 * FIXME: we always pass the WEP WEP_FREE_DLL, never WEP_SYSTEM_EXIT
1460 static BOOL16 MODULE_CallWEP( HMODULE16 hModule )
1463 FARPROC16 WEP = GetProcAddress16( hModule, "WEP" );
1464 if (!WEP) return FALSE;
1471 args[0] = WEP_FREE_DLL;
1472 WOWCallback16Ex( (DWORD)WEP, WCB16_PASCAL, sizeof(args), args, &dwRet );
1473 ret = LOWORD(dwRet);
1475 __EXCEPT(page_fault)
1477 WARN("Page fault\n");
1486 /**********************************************************************
1489 * Implementation of FreeModule16().
1491 static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL call_wep )
1493 HMODULE16 *hPrevModule;
1498 if (!(pModule = NE_GetPtr( hModule ))) return FALSE;
1499 hModule = pModule->self;
1501 TRACE("%04x count %d\n", hModule, pModule->count );
1503 if (((INT16)(--pModule->count)) > 0 ) return TRUE;
1504 else pModule->count = 0;
1506 if (pModule->flags & NE_FFLAGS_BUILTIN)
1507 return FALSE; /* Can't free built-in module */
1509 if (call_wep && !(pModule->flags & NE_FFLAGS_WIN32))
1511 /* Free the objects owned by the DLL module */
1512 NE_CallUserSignalProc( hModule, USIG16_DLL_UNLOAD );
1514 if (pModule->flags & NE_FFLAGS_LIBMODULE)
1515 MODULE_CallWEP( hModule );
1517 call_wep = FALSE; /* We are freeing a task -> no more WEPs */
1521 /* Clear magic number just in case */
1523 pModule->magic = pModule->self = 0;
1524 if (pModule->fd) CloseHandle( pModule->fd );
1526 /* Remove it from the linked list */
1528 hPrevModule = &hFirstModule;
1529 while (*hPrevModule && (*hPrevModule != hModule))
1531 hPrevModule = &(NE_GetPtr( *hPrevModule ))->next;
1533 if (*hPrevModule) *hPrevModule = pModule->next;
1535 /* Free the referenced modules */
1537 pModRef = (HMODULE16*)((char *)pModule + pModule->modref_table);
1538 for (i = 0; i < pModule->modref_count; i++, pModRef++)
1540 NE_FreeModule( *pModRef, call_wep );
1543 /* Free the module storage */
1545 GlobalFreeAll16( hModule );
1550 /**********************************************************************
1551 * FreeModule (KERNEL.46)
1553 BOOL16 WINAPI FreeModule16( HMODULE16 hModule )
1555 return NE_FreeModule( hModule, TRUE );
1559 /***********************************************************************
1560 * FreeLibrary (KERNEL.96)
1561 * FreeLibrary16 (KERNEL32.36)
1563 void WINAPI FreeLibrary16( HINSTANCE16 handle )
1565 TRACE("%04x\n", handle );
1566 FreeModule16( handle );
1570 /***********************************************************************
1571 * GetModuleHandle16 (KERNEL32.@)
1573 HMODULE16 WINAPI GetModuleHandle16( LPCSTR name )
1575 HMODULE16 hModule = hFirstModule;
1577 BYTE len, *name_table;
1578 char tmpstr[MAX_PATH];
1581 TRACE("(%s)\n", name);
1583 if (!HIWORD(name)) return GetExePtr(LOWORD(name));
1588 lstrcpynA(tmpstr, name, sizeof(tmpstr));
1590 /* If 'name' matches exactly the module name of a module:
1591 * Return its handle.
1593 for (hModule = hFirstModule; hModule ; hModule = pModule->next)
1595 pModule = NE_GetPtr( hModule );
1596 if (!pModule) break;
1597 if (pModule->flags & NE_FFLAGS_WIN32) continue;
1599 name_table = (BYTE *)pModule + pModule->name_table;
1600 if ((*name_table == len) && !strncmp(name, name_table+1, len))
1604 /* If uppercased 'name' matches exactly the module name of a module:
1607 for (s = tmpstr; *s; s++) *s = RtlUpperChar(*s);
1609 for (hModule = hFirstModule; hModule ; hModule = pModule->next)
1611 pModule = NE_GetPtr( hModule );
1612 if (!pModule) break;
1613 if (pModule->flags & NE_FFLAGS_WIN32) continue;
1615 name_table = (BYTE *)pModule + pModule->name_table;
1616 /* FIXME: the strncasecmp is WRONG. It should not be case insensitive,
1617 * but case sensitive! (Unfortunately Winword 6 and subdlls have
1618 * lowercased module names, but try to load uppercase DLLs, so this
1619 * 'i' compare is just a quickfix until the loader handles that
1620 * correctly. -MM 990705
1622 if ((*name_table == len) && !NE_strncasecmp(tmpstr, name_table+1, len))
1626 /* If the base filename of 'name' matches the base filename of the module
1627 * filename of some module (case-insensitive compare):
1628 * Return its handle.
1631 /* basename: search backwards in passed name to \ / or : */
1632 s = tmpstr + strlen(tmpstr);
1635 if (s[-1]=='/' || s[-1]=='\\' || s[-1]==':')
1640 /* search this in loaded filename list */
1641 for (hModule = hFirstModule; hModule ; hModule = pModule->next)
1646 pModule = NE_GetPtr( hModule );
1647 if (!pModule) break;
1648 if (!pModule->fileinfo) continue;
1649 if (pModule->flags & NE_FFLAGS_WIN32) continue;
1651 ofs = (OFSTRUCT*)((BYTE *)pModule + pModule->fileinfo);
1652 loadedfn = ((char*)ofs->szPathName) + strlen(ofs->szPathName);
1653 /* basename: search backwards in pathname to \ / or : */
1654 while (loadedfn > (char*)ofs->szPathName)
1656 if (loadedfn[-1]=='/' || loadedfn[-1]=='\\' || loadedfn[-1]==':')
1660 /* case insensitive compare ... */
1661 if (!NE_strcasecmp(loadedfn, s))
1668 /**********************************************************************
1669 * GetModuleName (KERNEL.27)
1671 BOOL16 WINAPI GetModuleName16( HINSTANCE16 hinst, LPSTR buf, INT16 count )
1676 if (!(pModule = NE_GetPtr( hinst ))) return FALSE;
1677 p = (BYTE *)pModule + pModule->name_table;
1678 if (count > *p) count = *p + 1;
1681 memcpy( buf, p + 1, count - 1 );
1682 buf[count-1] = '\0';
1688 /**********************************************************************
1689 * GetModuleFileName (KERNEL.49)
1691 * Comment: see GetModuleFileNameA
1693 * Even if invoked by second instance of a program,
1694 * it still returns path of first one.
1696 INT16 WINAPI GetModuleFileName16( HINSTANCE16 hModule, LPSTR lpFileName,
1701 /* Win95 does not query hModule if set to 0 !
1702 * Is this wrong or maybe Win3.1 only ? */
1703 if (!hModule) hModule = GetCurrentTask();
1705 if (!(pModule = NE_GetPtr( hModule ))) return 0;
1706 lstrcpynA( lpFileName, NE_MODULE_NAME(pModule), nSize );
1707 if (pModule->expected_version >= 0x400)
1708 GetLongPathNameA(NE_MODULE_NAME(pModule), lpFileName, nSize);
1709 TRACE("%04x -> '%s'\n", hModule, lpFileName );
1710 return strlen(lpFileName);
1714 /**********************************************************************
1715 * GetModuleUsage (KERNEL.48)
1717 INT16 WINAPI GetModuleUsage16( HINSTANCE16 hModule )
1719 NE_MODULE *pModule = NE_GetPtr( hModule );
1720 return pModule ? pModule->count : 0;
1724 /**********************************************************************
1725 * GetExpWinVer (KERNEL.167)
1727 WORD WINAPI GetExpWinVer16( HMODULE16 hModule )
1729 NE_MODULE *pModule = NE_GetPtr( hModule );
1730 if ( !pModule ) return 0;
1733 * For built-in modules, fake the expected version the module should
1734 * have according to the Windows version emulated by Wine
1736 if ( !pModule->expected_version )
1738 OSVERSIONINFOA versionInfo;
1739 versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
1741 if ( GetVersionExA( &versionInfo ) )
1742 pModule->expected_version =
1743 (versionInfo.dwMajorVersion & 0xff) << 8
1744 | (versionInfo.dwMinorVersion & 0xff);
1747 return pModule->expected_version;
1751 /***********************************************************************
1752 * WinExec (KERNEL.166)
1754 HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow )
1756 LPCSTR p, args = NULL;
1757 LPCSTR name_beg, name_end;
1758 LPSTR name, cmdline;
1761 char buffer[MAX_PATH];
1763 if (*lpCmdLine == '"') /* has to be only one and only at beginning ! */
1765 name_beg = lpCmdLine+1;
1766 p = strchr ( lpCmdLine+1, '"' );
1770 args = strchr ( p, ' ' );
1772 else /* yes, even valid with trailing '"' missing */
1773 name_end = lpCmdLine+strlen(lpCmdLine);
1777 name_beg = lpCmdLine;
1778 args = strchr( lpCmdLine, ' ' );
1779 name_end = args ? args : lpCmdLine+strlen(lpCmdLine);
1782 if ((name_beg == lpCmdLine) && (!args))
1783 { /* just use the original cmdline string as file name */
1784 name = (LPSTR)lpCmdLine;
1788 if (!(name = HeapAlloc( GetProcessHeap(), 0, name_end - name_beg + 1 )))
1789 return ERROR_NOT_ENOUGH_MEMORY;
1790 memcpy( name, name_beg, name_end - name_beg );
1791 name[name_end - name_beg] = '\0';
1797 arglen = strlen(args);
1798 cmdline = HeapAlloc( GetProcessHeap(), 0, 2 + arglen );
1799 cmdline[0] = (BYTE)arglen;
1800 strcpy( cmdline + 1, args );
1804 cmdline = HeapAlloc( GetProcessHeap(), 0, 2 );
1805 cmdline[0] = cmdline[1] = 0;
1808 TRACE("name: '%s', cmdline: '%.*s'\n", name, cmdline[0], &cmdline[1]);
1810 if (SearchPathA( NULL, name, ".exe", sizeof(buffer), buffer, NULL ))
1812 LOADPARAMS16 params;
1815 showCmd[1] = nCmdShow;
1817 params.hEnvironment = 0;
1818 params.cmdLine = MapLS( cmdline );
1819 params.showCmd = MapLS( showCmd );
1820 params.reserved = 0;
1822 ret = LoadModule16( buffer, ¶ms );
1823 UnMapLS( params.cmdLine );
1824 UnMapLS( params.showCmd );
1826 else ret = GetLastError();
1828 HeapFree( GetProcessHeap(), 0, cmdline );
1829 if (name != lpCmdLine) HeapFree( GetProcessHeap(), 0, name );
1831 if (ret == 21) /* 32-bit module */
1834 ReleaseThunkLock( &count );
1835 ret = LOWORD( WinExec( lpCmdLine, nCmdShow ) );
1836 RestoreThunkLock( count );
1841 /***********************************************************************
1842 * GetProcAddress (KERNEL.50)
1844 FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, LPCSTR name )
1849 if (!hModule) hModule = GetCurrentTask();
1850 hModule = GetExePtr( hModule );
1852 if (HIWORD(name) != 0)
1854 ordinal = NE_GetOrdinal( hModule, name );
1855 TRACE("%04x '%s'\n", hModule, name );
1859 ordinal = LOWORD(name);
1860 TRACE("%04x %04x\n", hModule, ordinal );
1862 if (!ordinal) return (FARPROC16)0;
1864 ret = NE_GetEntryPoint( hModule, ordinal );
1866 TRACE("returning %08x\n", (UINT)ret );
1871 /***************************************************************************
1872 * HasGPHandler (KERNEL.338)
1874 SEGPTR WINAPI HasGPHandler16( SEGPTR address )
1879 GPHANDLERDEF *gpHandler;
1881 if ( (hModule = FarGetOwner16( SELECTOROF(address) )) != 0
1882 && (gpOrdinal = NE_GetOrdinal( hModule, "__GP" )) != 0
1883 && (gpPtr = (SEGPTR)NE_GetEntryPointEx( hModule, gpOrdinal, FALSE )) != 0
1884 && !IsBadReadPtr16( gpPtr, sizeof(GPHANDLERDEF) )
1885 && (gpHandler = MapSL( gpPtr )) != NULL )
1887 while (gpHandler->selector)
1889 if ( SELECTOROF(address) == gpHandler->selector
1890 && OFFSETOF(address) >= gpHandler->rangeStart
1891 && OFFSETOF(address) < gpHandler->rangeEnd )
1892 return MAKESEGPTR( gpHandler->selector, gpHandler->handler );
1901 /**********************************************************************
1902 * GetModuleHandle (KERNEL.47)
1904 * Find a module from a module name.
1906 * NOTE: The current implementation works the same way the Windows 95 one
1907 * does. Do not try to 'fix' it, fix the callers.
1908 * + It does not do ANY extension handling (except that strange .EXE bit)!
1909 * + It does not care about paths, just about basenames. (same as Windows)
1913 * the win16 module handle if found
1915 * HIWORD (undocumented, see "Undocumented Windows", chapter 5):
1916 * Always hFirstModule
1918 DWORD WINAPI WIN16_GetModuleHandle( SEGPTR name )
1920 if (HIWORD(name) == 0)
1921 return MAKELONG(GetExePtr( (HINSTANCE16)name), hFirstModule );
1922 return MAKELONG(GetModuleHandle16( MapSL(name)), hFirstModule );
1925 /**********************************************************************
1926 * NE_GetModuleByFilename
1928 static HMODULE16 NE_GetModuleByFilename( LPCSTR name )
1932 BYTE len, *name_table;
1933 char tmpstr[MAX_PATH];
1936 lstrcpynA(tmpstr, name, sizeof(tmpstr));
1938 /* If the base filename of 'name' matches the base filename of the module
1939 * filename of some module (case-insensitive compare):
1940 * Return its handle.
1943 /* basename: search backwards in passed name to \ / or : */
1944 s = tmpstr + strlen(tmpstr);
1947 if (s[-1]=='/' || s[-1]=='\\' || s[-1]==':')
1952 /* search this in loaded filename list */
1953 for (hModule = hFirstModule; hModule ; hModule = pModule->next)
1958 pModule = NE_GetPtr( hModule );
1959 if (!pModule) break;
1960 if (!pModule->fileinfo) continue;
1961 if (pModule->flags & NE_FFLAGS_WIN32) continue;
1963 ofs = (OFSTRUCT*)((BYTE *)pModule + pModule->fileinfo);
1964 loadedfn = ((char*)ofs->szPathName) + strlen(ofs->szPathName);
1965 /* basename: search backwards in pathname to \ / or : */
1966 while (loadedfn > (char*)ofs->szPathName)
1968 if (loadedfn[-1]=='/' || loadedfn[-1]=='\\' || loadedfn[-1]==':')
1972 /* case insensitive compare ... */
1973 if (!NE_strcasecmp(loadedfn, s))
1976 /* If basename (without ext) matches the module name of a module:
1977 * Return its handle.
1980 if ( (p = strrchr( s, '.' )) != NULL ) *p = '\0';
1983 for (hModule = hFirstModule; hModule ; hModule = pModule->next)
1985 pModule = NE_GetPtr( hModule );
1986 if (!pModule) break;
1987 if (pModule->flags & NE_FFLAGS_WIN32) continue;
1989 name_table = (BYTE *)pModule + pModule->name_table;
1990 if ((*name_table == len) && !NE_strncasecmp(s, name_table+1, len))
1997 /***********************************************************************
1998 * GetProcAddress16 (KERNEL32.37)
1999 * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
2001 FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE hModule, LPCSTR name )
2003 if (!hModule) return 0;
2004 if (HIWORD(hModule))
2006 WARN("hModule is Win32 handle (%p)\n", hModule );
2009 return GetProcAddress16( LOWORD(hModule), name );
2012 /**********************************************************************
2013 * ModuleFirst (TOOLHELP.59)
2015 BOOL16 WINAPI ModuleFirst16( MODULEENTRY *lpme )
2017 lpme->wNext = hFirstModule;
2018 return ModuleNext16( lpme );
2022 /**********************************************************************
2023 * ModuleNext (TOOLHELP.60)
2025 BOOL16 WINAPI ModuleNext16( MODULEENTRY *lpme )
2030 if (!lpme->wNext) return FALSE;
2031 if (!(pModule = NE_GetPtr( lpme->wNext ))) return FALSE;
2032 name = (char *)pModule + pModule->name_table;
2033 memcpy( lpme->szModule, name + 1, min(*name, MAX_MODULE_NAME) );
2034 lpme->szModule[min(*name, MAX_MODULE_NAME)] = '\0';
2035 lpme->hModule = lpme->wNext;
2036 lpme->wcUsage = pModule->count;
2037 lstrcpynA( lpme->szExePath, NE_MODULE_NAME(pModule), sizeof(lpme->szExePath) );
2038 lpme->wNext = pModule->next;
2043 /**********************************************************************
2044 * ModuleFindName (TOOLHELP.61)
2046 BOOL16 WINAPI ModuleFindName16( MODULEENTRY *lpme, LPCSTR name )
2048 lpme->wNext = GetModuleHandle16( name );
2049 return ModuleNext16( lpme );
2053 /**********************************************************************
2054 * ModuleFindHandle (TOOLHELP.62)
2056 BOOL16 WINAPI ModuleFindHandle16( MODULEENTRY *lpme, HMODULE16 hModule )
2058 hModule = GetExePtr( hModule );
2059 lpme->wNext = hModule;
2060 return ModuleNext16( lpme );
2064 /***************************************************************************
2065 * IsRomModule (KERNEL.323)
2067 BOOL16 WINAPI IsRomModule16( HMODULE16 unused )
2072 /***************************************************************************
2073 * IsRomFile (KERNEL.326)
2075 BOOL16 WINAPI IsRomFile16( HFILE16 unused )
2080 /***********************************************************************
2081 * create_dummy_module
2083 * Create a dummy NE module for Win32 or Winelib.
2085 static HMODULE16 create_dummy_module( HMODULE module32 )
2089 SEGTABLEENTRY *pSegment;
2092 const char* basename;
2095 char filename[MAX_PATH];
2096 IMAGE_NT_HEADERS *nt = RtlImageNtHeader( module32 );
2098 if (!nt) return (HMODULE16)11; /* invalid exe */
2100 /* Extract base filename */
2101 GetModuleFileNameA( module32, filename, sizeof(filename) );
2102 basename = strrchr(filename, '\\');
2103 if (!basename) basename = filename;
2105 len = strlen(basename);
2106 if ((s = strchr(basename, '.'))) len = s - basename;
2108 /* Allocate module */
2109 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
2110 + strlen(filename) + 1;
2111 size = sizeof(NE_MODULE) +
2112 /* loaded file info */
2113 ((of_size + 3) & ~3) +
2114 /* segment table: DS,CS */
2115 2 * sizeof(SEGTABLEENTRY) +
2118 /* several empty tables */
2121 hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
2122 if (!hModule) return (HMODULE16)11; /* invalid exe */
2124 FarSetOwner16( hModule, hModule );
2125 pModule = (NE_MODULE *)GlobalLock16( hModule );
2127 /* Set all used entries */
2128 pModule->magic = IMAGE_OS2_SIGNATURE;
2131 pModule->flags = NE_FFLAGS_WIN32;
2132 pModule->dgroup = 0;
2135 pModule->heap_size = 0;
2136 pModule->stack_size = 0;
2137 pModule->seg_count = 2;
2138 pModule->modref_count = 0;
2139 pModule->nrname_size = 0;
2140 pModule->fileinfo = sizeof(NE_MODULE);
2141 pModule->os_flags = NE_OSFLAGS_WINDOWS;
2142 pModule->self = hModule;
2143 pModule->module32 = module32;
2145 /* Set version and flags */
2146 pModule->expected_version = ((nt->OptionalHeader.MajorSubsystemVersion & 0xff) << 8 ) |
2147 (nt->OptionalHeader.MinorSubsystemVersion & 0xff);
2148 if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
2149 pModule->flags |= NE_FFLAGS_LIBMODULE | NE_FFLAGS_SINGLEDATA;
2151 /* Set loaded file information */
2152 ofs = (OFSTRUCT *)(pModule + 1);
2153 memset( ofs, 0, of_size );
2154 ofs->cBytes = of_size < 256 ? of_size : 255; /* FIXME */
2155 strcpy( ofs->szPathName, filename );
2157 pSegment = (SEGTABLEENTRY*)((char*)(pModule + 1) + ((of_size + 3) & ~3));
2158 pModule->seg_table = (int)pSegment - (int)pModule;
2161 pSegment->flags = NE_SEGFLAGS_DATA;
2162 pSegment->minsize = 0x1000;
2165 pSegment->flags = 0;
2169 pStr = (char *)pSegment;
2170 pModule->name_table = (int)pStr - (int)pModule;
2173 lstrcpynA( pStr+1, basename, len+1 );
2176 /* All tables zero terminated */
2177 pModule->res_table = pModule->import_table = pModule->entry_table = (int)pStr - (int)pModule;
2179 NE_RegisterModule( pModule );
2180 LoadLibraryA( filename ); /* increment the ref count of the 32-bit module */
2184 /***********************************************************************
2185 * PrivateLoadLibrary (KERNEL32.@)
2187 * FIXME: rough guesswork, don't know what "Private" means
2189 HINSTANCE16 WINAPI PrivateLoadLibrary(LPCSTR libname)
2191 return LoadLibrary16(libname);
2194 /***********************************************************************
2195 * PrivateFreeLibrary (KERNEL32.@)
2197 * FIXME: rough guesswork, don't know what "Private" means
2199 void WINAPI PrivateFreeLibrary(HINSTANCE16 handle)
2201 FreeLibrary16(handle);
2204 /***********************************************************************
2205 * LoadLibrary32 (KERNEL.452)
2206 * LoadSystemLibrary32 (KERNEL.482)
2208 HMODULE WINAPI LoadLibrary32_16( LPCSTR libname )
2213 ReleaseThunkLock( &count );
2214 hModule = LoadLibraryA( libname );
2215 RestoreThunkLock( count );
2219 /***************************************************************************
2220 * MapHModuleLS (KERNEL32.@)
2222 HMODULE16 WINAPI MapHModuleLS(HMODULE hmod)
2228 return TASK_GetCurrent()->hInstance;
2230 return LOWORD(hmod); /* we already have a 16 bit module handle */
2231 pModule = (NE_MODULE*)GlobalLock16(hFirstModule);
2233 if (pModule->module32 == hmod)
2234 return pModule->self;
2235 pModule = (NE_MODULE*)GlobalLock16(pModule->next);
2237 if ((ret = create_dummy_module( hmod )) < 32)
2245 /***************************************************************************
2246 * MapHModuleSL (KERNEL32.@)
2248 HMODULE WINAPI MapHModuleSL(HMODULE16 hmod)
2253 TDB *pTask = TASK_GetCurrent();
2254 hmod = pTask->hModule;
2256 pModule = (NE_MODULE*)GlobalLock16(hmod);
2257 if ((pModule->magic!=IMAGE_OS2_SIGNATURE) || !(pModule->flags & NE_FFLAGS_WIN32))
2259 return pModule->module32;
2262 /***************************************************************************
2263 * MapHInstLS (KERNEL32.@)
2264 * MapHInstLS (KERNEL.472)
2266 void WINAPI MapHInstLS( CONTEXT86 *context )
2268 context->Eax = MapHModuleLS( (HMODULE)context->Eax );
2271 /***************************************************************************
2272 * MapHInstSL (KERNEL32.@)
2273 * MapHInstSL (KERNEL.473)
2275 void WINAPI MapHInstSL( CONTEXT86 *context )
2277 context->Eax = (DWORD)MapHModuleSL( context->Eax );
2280 /***************************************************************************
2281 * MapHInstLS_PN (KERNEL32.@)
2283 void WINAPI MapHInstLS_PN( CONTEXT86 *context )
2285 if (context->Eax) context->Eax = MapHModuleLS( (HMODULE)context->Eax );
2288 /***************************************************************************
2289 * MapHInstSL_PN (KERNEL32.@)
2291 void WINAPI MapHInstSL_PN( CONTEXT86 *context )
2293 if (context->Eax) context->Eax = (DWORD)MapHModuleSL( context->Eax );