?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid gratuitously changing the ZORDER.
[wine.git] / loader / ne / segment.c
blob6da63719ecb7638ad486c3fbf52aaa1bfd063beb
1 /*
2 * NE segment loading
3 *
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
6 */
7
8 #include <assert.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <fcntl.h>
14 #include <unistd.h>
15 #include <ctype.h>
16 #include <string.h>
17 #include <errno.h>
18
19 #include "wine/winbase16.h"
20 #include "neexe.h"
21 #include "global.h"
22 #include "task.h"
23 #include "selectors.h"
24 #include "callback.h"
25 #include "file.h"
26 #include "module.h"
27 #include "stackframe.h"
28 #include "builtin16.h"
29 #include "debugtools.h"
30 #include "toolhelp.h"
31
32 DECLARE_DEBUG_CHANNEL(dll)
33 DECLARE_DEBUG_CHANNEL(fixup)
34 DECLARE_DEBUG_CHANNEL(module)
35 DECLARE_DEBUG_CHANNEL(segment)
36
37 #define SEL(x) ((x)|1)
38
39 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum);
40
41 /***********************************************************************
42 * NE_GetRelocAddrName
43 */
44 static const char *NE_GetRelocAddrName( BYTE addr_type, int additive )
45 {
46 switch(addr_type & 0x7f)
47 {
48 case NE_RADDR_LOWBYTE: return additive ? "BYTE add" : "BYTE";
49 case NE_RADDR_OFFSET16: return additive ? "OFFSET16 add" : "OFFSET16";
50 case NE_RADDR_POINTER32: return additive ? "POINTER32 add" : "POINTER32";
51 case NE_RADDR_SELECTOR: return additive ? "SELECTOR add" : "SELECTOR";
52 case NE_RADDR_POINTER48: return additive ? "POINTER48 add" : "POINTER48";
53 case NE_RADDR_OFFSET32: return additive ? "OFFSET32 add" : "OFFSET32";
54 }
55 return "???";
56 }
57
58
59 /***********************************************************************
60 * NE_LoadSegment
61 */
62 BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
63 {
64 SEGTABLEENTRY *pSegTable, *pSeg;
65 WORD *pModuleTable;
66 WORD count, i, offset, next_offset;
67 HMODULE16 module;
68 FARPROC16 address = 0;
69 HFILE hf;
70 DWORD res;
71 struct relocation_entry_s *rep, *reloc_entries;
72 BYTE *func_name;
73 int size;
74 char* mem;
75
76 char buffer[256];
77 int ordinal, additive;
78 unsigned short *sp;
79
80 pSegTable = NE_SEG_TABLE( pModule );
81 pSeg = pSegTable + segnum - 1;
82
83 if (pSeg->flags & NE_SEGFLAGS_LOADED)
84 {
85 /* self-loader ? -> already loaded it */
86 if (pModule->flags & NE_FFLAGS_SELFLOAD)
87 return TRUE;
88
89 /* leave, except for DGROUP, as this may be the second instance */
90 if (segnum != pModule->dgroup)
91 return TRUE;
92 }
93
94 if (!pSeg->filepos) return TRUE; /* No file image, just return */
95
96 pModuleTable = NE_MODULE_TABLE( pModule );
97
98 hf = NE_OpenFile( pModule );
99 TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
100 segnum, pSeg->hSeg, pSeg->flags );
101 SetFilePointer( hf, pSeg->filepos << pModule->alignment, NULL, SEEK_SET );
102 if (pSeg->size) size = pSeg->size;
103 else size = pSeg->minsize ? pSeg->minsize : 0x10000;
104 mem = GlobalLock16(pSeg->hSeg);
105 if (pModule->flags & NE_FFLAGS_SELFLOAD && segnum > 1)
106 {
107 /* Implement self-loading segments */
108 SELFLOADHEADER *selfloadheader;
109 DWORD oldstack;
110 HFILE hFile32;
111 HFILE16 hFile16;
112
113 selfloadheader = (SELFLOADHEADER *)
114 PTR_SEG_OFF_TO_LIN(SEL(pSegTable->hSeg),0);
115 oldstack = NtCurrentTeb()->cur_stack;
116 NtCurrentTeb()->cur_stack = PTR_SEG_OFF_TO_SEGPTR(pModule->self_loading_sel,
117 0xff00 - sizeof(STACK16FRAME));
118
119 TRACE_(dll)("CallLoadAppSegProc(hmodule=0x%04x,hf=0x%04x,segnum=%d\n",
120 pModule->self,hf,segnum );
121 DuplicateHandle( GetCurrentProcess(), hf, GetCurrentProcess(), &hFile32,
122 0, FALSE, DUPLICATE_SAME_ACCESS );
123 hFile16 = FILE_AllocDosHandle( hFile32 );
124 pSeg->hSeg = Callbacks->CallLoadAppSegProc( selfloadheader->LoadAppSeg,
125 pModule->self, hFile16,
126 segnum );
127 TRACE_(dll)("Ret CallLoadAppSegProc: hSeg = 0x%04x\n", pSeg->hSeg);
128 _lclose16( hFile16 );
129 NtCurrentTeb()->cur_stack = oldstack;
130 }
131 else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
132 ReadFile(hf, mem, size, &res, NULL);
133 else {
134 /*
135 The following bit of code for "iterated segments" was written without
136 any documentation on the format of these segments. It seems to work,
137 but may be missing something. If you have any doc please either send
138 it to me or fix the code yourself. gfm@werple.mira.net.au
139 */
140 char* buff = HeapAlloc(GetProcessHeap(), 0, size);
141 char* curr = buff;
142
143 if(buff == NULL) {
144 WARN_(dll)("Memory exausted!");
145 return FALSE;
146 }
147
148 ReadFile(hf, buff, size, &res, NULL);
149 while(curr < buff + size) {
150 unsigned int rept = *((short*) curr)++;
151 unsigned int len = *((short*) curr)++;
152 for(; rept > 0; rept--) {
153 char* bytes = curr;
154 unsigned int byte;
155 for(byte = 0; byte < len; byte++)
156 *mem++ = *bytes++;
157 }
158 curr += len;
159 }
160 HeapFree(GetProcessHeap(), 0, buff);
161 }
162
163 pSeg->flags |= NE_SEGFLAGS_LOADED;
164
165 /* Perform exported function prolog fixups */
166 NE_FixupSegmentPrologs( pModule, segnum );
167
168 if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
169 return TRUE; /* No relocation data, we are done */
170
171 ReadFile(hf, &count, sizeof(count), &res, NULL);
172 if (!count) return TRUE;
173
174 TRACE_(fixup)("Fixups for %.*s, segment %d, hSeg %04x\n",
175 *((BYTE *)pModule + pModule->name_table),
176 (char *)pModule + pModule->name_table + 1,
177 segnum, pSeg->hSeg );
178 TRACE_(segment)("Fixups for %.*s, segment %d, hSeg %04x\n",
179 *((BYTE *)pModule + pModule->name_table),
180 (char *)pModule + pModule->name_table + 1,
181 segnum, pSeg->hSeg );
182
183 reloc_entries = (struct relocation_entry_s *)HeapAlloc(GetProcessHeap(), 0, count * sizeof(struct relocation_entry_s));
184 if(reloc_entries == NULL) {
185 WARN_(fixup)("Not enough memory for relocation entries!");
186 return FALSE;
187 }
188 if (!ReadFile( hf, reloc_entries, count * sizeof(struct relocation_entry_s), &res, NULL) ||
189 (res != count * sizeof(struct relocation_entry_s)))
190 {
191 WARN_(fixup)("Unable to read relocation information\n" );
192 return FALSE;
193 }
194
195 /*
196 * Go through the relocation table one entry at a time.
197 */
198 rep = reloc_entries;
199 for (i = 0; i < count; i++, rep++)
200 {
201 /*
202 * Get the target address corresponding to this entry.
203 */
204
205 /* If additive, there is no target chain list. Instead, add source
206 and target */
207 additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
208 rep->relocation_type &= 0x3;
209
210 switch (rep->relocation_type)
211 {
212 case NE_RELTYPE_ORDINAL:
213 module = pModuleTable[rep->target1-1];
214 ordinal = rep->target2;
215 address = NE_GetEntryPoint( module, ordinal );
216 if (!address)
217 {
218 NE_MODULE *pTarget = NE_GetPtr( module );
219 if (!pTarget)
220 WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
221 module, rep->target1,
222 *((BYTE *)pModule + pModule->name_table),
223 *((BYTE *)pModule + pModule->name_table),
224 (char *)pModule + pModule->name_table + 1 );
225 else
226 {
227 ERR_(fixup)("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
228 *((BYTE *)pTarget + pTarget->name_table),
229 (char *)pTarget + pTarget->name_table + 1,
230 ordinal );
231 address = (FARPROC16)0xdeadbeef;
232 }
233 }
234 if (TRACE_ON(fixup))
235 {
236 NE_MODULE *pTarget = NE_GetPtr( module );
237 TRACE_(fixup)("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
238 *((BYTE *)pTarget + pTarget->name_table),
239 (char *)pTarget + pTarget->name_table + 1,
240 ordinal, HIWORD(address), LOWORD(address),
241 NE_GetRelocAddrName( rep->address_type, additive ) );
242 }
243 break;
244
245 case NE_RELTYPE_NAME:
246 module = pModuleTable[rep->target1-1];
247 func_name = (char *)pModule + pModule->import_table + rep->target2;
248 memcpy( buffer, func_name+1, *func_name );
249 buffer[*func_name] = '\0';
250 func_name = buffer;
251 ordinal = NE_GetOrdinal( module, func_name );
252 address = NE_GetEntryPoint( module, ordinal );
253
254 if (ERR_ON(fixup) && !address)
255 {
256 NE_MODULE *pTarget = NE_GetPtr( module );
257 ERR_(fixup)("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
258 *((BYTE *)pTarget + pTarget->name_table),
259 (char *)pTarget + pTarget->name_table + 1, func_name );
260 }
261 if (!address) address = (FARPROC16) 0xdeadbeef;
262 if (TRACE_ON(fixup))
263 {
264 NE_MODULE *pTarget = NE_GetPtr( module );
265 TRACE_(fixup)("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
266 *((BYTE *)pTarget + pTarget->name_table),
267 (char *)pTarget + pTarget->name_table + 1,
268 func_name, HIWORD(address), LOWORD(address),
269 NE_GetRelocAddrName( rep->address_type, additive ) );
270 }
271 break;
272
273 case NE_RELTYPE_INTERNAL:
274 if ((rep->target1 & 0xff) == 0xff)
275 {
276 address = NE_GetEntryPoint( pModule->self, rep->target2 );
277 }
278 else
279 {
280 address = (FARPROC16)PTR_SEG_OFF_TO_SEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
281 }
282
283 TRACE_(fixup)("%d: %04x:%04x %s\n",
284 i + 1, HIWORD(address), LOWORD(address),
285 NE_GetRelocAddrName( rep->address_type, additive ) );
286 break;
287
288 case NE_RELTYPE_OSFIXUP:
289 /* Relocation type 7:
290 *
291 * These appear to be used as fixups for the Windows
292 * floating point emulator. Let's just ignore them and
293 * try to use the hardware floating point. Linux should
294 * successfully emulate the coprocessor if it doesn't
295 * exist.
296 */
297 TRACE_(fixup)("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
298 i + 1, rep->relocation_type, rep->offset,
299 rep->target1, rep->target2,
300 NE_GetRelocAddrName( rep->address_type, additive ) );
301 continue;
302 }
303
304 offset = rep->offset;
305
306 /* Apparently, high bit of address_type is sometimes set; */
307 /* we ignore it for now */
308 if (rep->address_type > NE_RADDR_OFFSET32)
309 {
310 char module[10];
311 GetModuleName16( pModule->self, module, sizeof(module) );
312 ERR_(fixup)("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
313 module, rep->address_type );
314 }
315
316 if (additive)
317 {
318 sp = PTR_SEG_OFF_TO_LIN( SEL(pSeg->hSeg), offset );
319 TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
320 switch (rep->address_type & 0x7f)
321 {
322 case NE_RADDR_LOWBYTE:
323 *(BYTE *)sp += LOBYTE((int)address);
324 break;
325 case NE_RADDR_OFFSET16:
326 *sp += LOWORD(address);
327 break;
328 case NE_RADDR_POINTER32:
329 *sp += LOWORD(address);
330 *(sp+1) = HIWORD(address);
331 break;
332 case NE_RADDR_SELECTOR:
333 /* Borland creates additive records with offset zero. Strange, but OK */
334 if (*sp)
335 ERR_(fixup)("Additive selector to %04x.Please report\n",*sp);
336 else
337 *sp = HIWORD(address);
338 break;
339 default:
340 goto unknown;
341 }
342 }
343 else /* non-additive fixup */
344 {
345 do
346 {
347 sp = PTR_SEG_OFF_TO_LIN( SEL(pSeg->hSeg), offset );
348 next_offset = *sp;
349 TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
350 switch (rep->address_type & 0x7f)
351 {
352 case NE_RADDR_LOWBYTE:
353 *(BYTE *)sp = LOBYTE((int)address);
354 break;
355 case NE_RADDR_OFFSET16:
356 *sp = LOWORD(address);
357 break;
358 case NE_RADDR_POINTER32:
359 *(FARPROC16 *)sp = address;
360 break;
361 case NE_RADDR_SELECTOR:
362 *sp = SELECTOROF(address);
363 break;
364 default:
365 goto unknown;
366 }
367 if (next_offset == offset) break; /* avoid infinite loop */
368 if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
369 offset = next_offset;
370 } while (offset != 0xffff);
371 }
372 }
373
374 HeapFree(GetProcessHeap(), 0, reloc_entries);
375 return TRUE;
376
377 unknown:
378 WARN_(fixup)("WARNING: %d: unknown ADDR TYPE %d, "
379 "TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
380 i + 1, rep->address_type, rep->relocation_type,
381 rep->offset, rep->target1, rep->target2);
382 HeapFree(GetProcessHeap(), 0, reloc_entries);
383 return FALSE;
384 }
385
386
387 /***********************************************************************
388 * NE_LoadAllSegments
389 */
390 BOOL NE_LoadAllSegments( NE_MODULE *pModule )
391 {
392 int i;
393 SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
394
395 if (pModule->flags & NE_FFLAGS_SELFLOAD)
396 {
397 HFILE hf;
398 HFILE16 hFile16;
399 /* Handle self-loading modules */
400 SELFLOADHEADER *selfloadheader;
401 HMODULE16 hselfload = GetModuleHandle16("WPROCS");
402 DWORD oldstack;
403
404 TRACE_(module)("%.*s is a self-loading module!\n",
405 *((BYTE*)pModule + pModule->name_table),
406 (char *)pModule + pModule->name_table + 1);
407 if (!NE_LoadSegment( pModule, 1 )) return FALSE;
408 selfloadheader = (SELFLOADHEADER *)
409 PTR_SEG_OFF_TO_LIN(SEL(pSegTable->hSeg), 0);
410 selfloadheader->EntryAddrProc = NE_GetEntryPoint(hselfload,27);
411 selfloadheader->MyAlloc = NE_GetEntryPoint(hselfload,28);
412 selfloadheader->SetOwner = NE_GetEntryPoint(GetModuleHandle16("KERNEL"),403);
413 pModule->self_loading_sel = SEL(GLOBAL_Alloc(GMEM_ZEROINIT, 0xFF00, pModule->self, FALSE, FALSE, FALSE));
414 oldstack = NtCurrentTeb()->cur_stack;
415 NtCurrentTeb()->cur_stack = PTR_SEG_OFF_TO_SEGPTR(pModule->self_loading_sel,
416 0xff00 - sizeof(STACK16FRAME) );
417
418 DuplicateHandle( GetCurrentProcess(), NE_OpenFile(pModule),
419 GetCurrentProcess(), &hf, 0, FALSE, DUPLICATE_SAME_ACCESS );
420 hFile16 = FILE_AllocDosHandle( hf );
421 TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n",
422 pModule->self,hFile16);
423 Callbacks->CallBootAppProc(selfloadheader->BootApp, pModule->self,hFile16);
424 TRACE_(dll)("Return from CallBootAppProc\n");
425 _lclose16(hf);
426 NtCurrentTeb()->cur_stack = oldstack;
427
428 for (i = 2; i <= pModule->seg_count; i++)
429 if (!NE_LoadSegment( pModule, i )) return FALSE;
430 }
431 else
432 {
433 for (i = 1; i <= pModule->seg_count; i++)
434 if (!NE_LoadSegment( pModule, i )) return FALSE;
435 }
436 return TRUE;
437 }
438
439
440 /***********************************************************************
441 * NE_FixupSegmentPrologs
442 *
443 * Fixup exported functions prologs of one segment
444 */
445 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
446 {
447 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
448 ET_BUNDLE *bundle;
449 ET_ENTRY *entry;
450 WORD dgroup, num_entries, sel = SEL(pSegTable[segnum-1].hSeg);
451 BYTE *pSeg, *pFunc;
452
453 TRACE_(module)("(%d);\n", segnum);
454
455 if (pSegTable[segnum-1].flags & NE_SEGFLAGS_DATA)
456 {
457 pSegTable[segnum-1].flags |= NE_SEGFLAGS_LOADED;
458 return;
459 }
460
461 if (!pModule->dgroup) return;
462
463 if (!(dgroup = SEL(pSegTable[pModule->dgroup-1].hSeg))) return;
464
465 pSeg = PTR_SEG_OFF_TO_LIN(sel, 0);
466
467 bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->entry_table);
468
469 do {
470 TRACE_(module)("num_entries: %d, bundle: %p, next: %04x, pSeg: %p\n", bundle->last - bundle->first, bundle, bundle->next, pSeg);
471 if (!(num_entries = bundle->last - bundle->first))
472 return;
473 entry = (ET_ENTRY *)((BYTE *)bundle+6);
474 while (num_entries--)
475 {
476 /*TRACE(module, "entry: %p, entry->segnum: %d, entry->offs: %04x\n", entry, entry->segnum, entry->offs);*/
477 if (entry->segnum == segnum)
478 {
479 pFunc = ((BYTE *)pSeg+entry->offs);
480 TRACE_(module)("pFunc: %p, *(DWORD *)pFunc: %08lx, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
481 if (*(pFunc+2) == 0x90)
482 {
483 if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
484 {
485 TRACE_(module)("patch %04x:%04x -> mov ax, ds\n", sel, entry->offs);
486 *(WORD *)pFunc = 0xd88c; /* mov ax, ds */
487 }
488
489 if (*(WORD *)pFunc == 0xd88c)
490 {
491 if ((entry->flags & 2)) /* public data ? */
492 {
493 TRACE_(module)("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry->offs, dgroup);
494 *pFunc = 0xb8; /* mov ax, */
495 *(WORD *)(pFunc+1) = dgroup;
496 }
497 else
498 if ((pModule->flags & NE_FFLAGS_MULTIPLEDATA)
499 && (entry->flags & 1)) /* exported ? */
500 {
501 TRACE_(module)("patch %04x:%04x -> nop, nop\n", sel, entry->offs);
502 *(WORD *)pFunc = 0x9090; /* nop, nop */
503 }
504 }
505 }
506 }
507 entry++;
508 }
509 } while ( (bundle->next)
510 && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
511 }
512
513
514 /***********************************************************************
515 * PatchCodeHandle
516 *
517 * Needed for self-loading modules.
518 */
519 DWORD WINAPI PatchCodeHandle16(HANDLE16 hSeg)
520 {
521 WORD segnum;
522 WORD sel = SEL(hSeg);
523 NE_MODULE *pModule = NE_GetPtr(FarGetOwner16(sel));
524 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE(pModule);
525
526 TRACE_(module)("(%04x);\n", hSeg);
527
528 /* find the segment number of the module that belongs to hSeg */
529 for (segnum = 1; segnum <= pModule->seg_count; segnum++)
530 {
531 if (SEL(pSegTable[segnum-1].hSeg) == sel)
532 {
533 NE_FixupSegmentPrologs(pModule, segnum);
534 break;
535 }
536 }
537
538 return MAKELONG(hSeg, sel);
539 }
540
541
542 /***********************************************************************
543 * NE_GetDLLInitParams
544 */
545 static VOID NE_GetDLLInitParams( NE_MODULE *pModule,
546 WORD *hInst, WORD *ds, WORD *heap )
547 {
548 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
549
550 if (!(pModule->flags & NE_FFLAGS_SINGLEDATA))
551 {
552 if (pModule->flags & NE_FFLAGS_MULTIPLEDATA || pModule->dgroup)
553 {
554 /* Not SINGLEDATA */
555 ERR_(dll)("Library is not marked SINGLEDATA\n");
556 exit(1);
557 }
558 else /* DATA NONE DLL */
559 {
560 *ds = 0;
561 *heap = 0;
562 }
563 }
564 else /* DATA SINGLE DLL */
565 {
566 if (pModule->dgroup) {
567 *ds = SEL(pSegTable[pModule->dgroup-1].hSeg);
568 *heap = pModule->heap_size;
569 }
570 else /* hmm, DLL has no dgroup,
571 but why has it NE_FFLAGS_SINGLEDATA set ?
572 Buggy DLL compiler ? */
573 {
574 *ds = 0;
575 *heap = 0;
576 }
577 }
578
579 *hInst = *ds ? GlobalHandle16(*ds) : pModule->self;
580 }
581
582
583 /***********************************************************************
584 * NE_InitDLL
585 *
586 * Call the DLL initialization code
587 */
588 static BOOL NE_InitDLL( TDB* pTask, NE_MODULE *pModule )
589 {
590 SEGTABLEENTRY *pSegTable;
591 WORD hInst, ds, heap;
592 CONTEXT86 context;
593
594 pSegTable = NE_SEG_TABLE( pModule );
595
596 if (!(pModule->flags & NE_FFLAGS_LIBMODULE) ||
597 (pModule->flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
598
599 /* Call USER signal handler for Win3.1 compatibility. */
600 TASK_CallTaskSignalProc( USIG16_DLL_LOAD, pModule->self );
601
602 if (!pModule->cs) return TRUE; /* no initialization code */
603
604
605 /* Registers at initialization must be:
606 * cx heap size
607 * di library instance
608 * ds data segment if any
609 * es:si command line (always 0)
610 */
611
612 memset( &context, 0, sizeof(context) );
613
614 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
615
616 ECX_reg(&context) = heap;
617 EDI_reg(&context) = hInst;
618 DS_reg(&context) = ds;
619 ES_reg(&context) = ds; /* who knows ... */
620
621 CS_reg(&context) = SEL(pSegTable[pModule->cs-1].hSeg);
622 EIP_reg(&context) = pModule->ip;
623 EBP_reg(&context) = OFFSETOF(NtCurrentTeb()->cur_stack) + (WORD)&((STACK16FRAME*)0)->bp;
624
625
626 pModule->cs = 0; /* Don't initialize it twice */
627 TRACE_(dll)("Calling LibMain, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
628 CS_reg(&context), EIP_reg(&context), DS_reg(&context),
629 DI_reg(&context), CX_reg(&context) );
630 Callbacks->CallRegisterShortProc( &context, 0 );
631 return TRUE;
632 }
633
634 /***********************************************************************
635 * NE_InitializeDLLs
636 *
637 * Recursively initialize all DLLs (according to the order in which
638 * they where loaded).
639 */
640 void NE_InitializeDLLs( HMODULE16 hModule )
641 {
642 TDB* pTask = (TDB*)GlobalLock16(GetCurrentTask());
643 NE_MODULE *pModule;
644 HMODULE16 *pDLL;
645
646 if (!(pModule = NE_GetPtr( hModule ))) return;
647 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
648
649 if (pModule->dlls_to_init)
650 {
651 HGLOBAL16 to_init = pModule->dlls_to_init;
652 pModule->dlls_to_init = 0;
653 for (pDLL = (HMODULE16 *)GlobalLock16( to_init ); *pDLL; pDLL++)
654 {
655 NE_InitializeDLLs( *pDLL );
656 }
657 GlobalFree16( to_init );
658 }
659 NE_InitDLL( pTask, pModule );
660 }
661
662
663 /***********************************************************************
664 * NE_CallDllEntryPoint
665 *
666 * Call the DllEntryPoint of DLLs with subsystem >= 4.0
667 */
668 typedef DWORD WINAPI (*WinNEEntryProc)(DWORD,WORD,WORD,WORD,DWORD,WORD);
669
670 static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
671 {
672 WORD hInst, ds, heap;
673 FARPROC16 entryPoint;
674 WORD ordinal;
675
676 if (!(pModule->flags & NE_FFLAGS_LIBMODULE)) return;
677 if (!(pModule->flags & NE_FFLAGS_BUILTIN) && pModule->expected_version < 0x0400) return;
678 if (!(ordinal = NE_GetOrdinal( pModule->self, "DllEntryPoint" ))) return;
679 if (!(entryPoint = NE_GetEntryPoint( pModule->self, ordinal ))) return;
680
681 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
682
683 TRACE_(dll)( "Calling %s DllEntryPoint, cs:ip=%04x:%04x\n",
684 NE_MODULE_NAME( pModule ),
685 SELECTOROF(entryPoint), OFFSETOF(entryPoint) );
686
687 if ( pModule->flags & NE_FFLAGS_BUILTIN )
688 {
689 WinNEEntryProc entryProc = (WinNEEntryProc)
690 ((ENTRYPOINT16 *)PTR_SEG_TO_LIN( entryPoint ))->target;
691
692 entryProc( dwReason, hInst, ds, heap, 0, 0 );
693 }
694 else
695 {
696 LPBYTE stack = (LPBYTE)CURRENT_STACK16;
697 CONTEXT86 context;
698
699 memset( &context, 0, sizeof(context) );
700 DS_reg(&context) = ds;
701 ES_reg(&context) = ds; /* who knows ... */
702
703 CS_reg(&context) = HIWORD(entryPoint);
704 EIP_reg(&context) = LOWORD(entryPoint);
705 EBP_reg(&context) = OFFSETOF( NtCurrentTeb()->cur_stack )
706 + (WORD)&((STACK16FRAME*)0)->bp;
707
708 *(DWORD *)(stack - 4) = dwReason; /* dwReason */
709 *(WORD *) (stack - 6) = hInst; /* hInst */
710 *(WORD *) (stack - 8) = ds; /* wDS */
711 *(WORD *) (stack - 10) = heap; /* wHeapSize */
712 *(DWORD *)(stack - 14) = 0; /* dwReserved1 */
713 *(WORD *) (stack - 16) = 0; /* wReserved2 */
714
715 Callbacks->CallRegisterShortProc( &context, 16 );
716 }
717 }
718
719 /***********************************************************************
720 * NE_DllProcessAttach
721 *
722 * Call the DllEntryPoint of all modules this one (recursively)
723 * depends on, according to the order in which they were loaded.
724 *
725 * Note that --as opposed to the PE module case-- there is no notion
726 * of 'module loaded into a process' for NE modules, and hence we
727 * have no place to store the fact that the DllEntryPoint of a
728 * given module was already called on behalf of this process (e.g.
729 * due to some earlier LoadLibrary16 call).
730 *
731 * Thus, we just call the DllEntryPoint twice in that case. Win9x
732 * appears to behave this way as well ...
733 *
734 * This routine must only be called with the Win16Lock held.
735 *
736 * FIXME: We should actually abort loading in case the DllEntryPoint
737 * returns FALSE ...
738 *
739 */
740 void NE_DllProcessAttach( HMODULE16 hModule )
741 {
742 NE_MODULE *pModule;
743 WORD *pModRef;
744 int i;
745
746 if (!(pModule = NE_GetPtr( hModule ))) return;
747 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
748
749 /* Check for recursive call */
750 if ( pModule->misc_flags & 0x80 ) return;
751
752 TRACE_(dll)("(%s) - START\n", NE_MODULE_NAME(pModule) );
753
754 /* Tag current module to prevent recursive loop */
755 pModule->misc_flags |= 0x80;
756
757 /* Recursively attach all DLLs this one depends on */
758 pModRef = NE_MODULE_TABLE( pModule );
759 for ( i = 0; i < pModule->modref_count; i++ )
760 if ( pModRef[i] )
761 NE_DllProcessAttach( (HMODULE16)pModRef[i] );
762
763 /* Call DLL entry point */
764 NE_CallDllEntryPoint( pModule, DLL_PROCESS_ATTACH );
765
766 /* Remove recursion flag */
767 pModule->misc_flags &= ~0x80;
768
769 TRACE_(dll)("(%s) - END\n", NE_MODULE_NAME(pModule) );
770 }
771
772
773 /***********************************************************************
774 * NE_Ne2MemFlags
775 *
776 * This function translates NE segment flags to GlobalAlloc flags
777 */
778 static WORD NE_Ne2MemFlags(WORD flags)
779 {
780 WORD memflags = 0;
781 #if 1
782 if (flags & NE_SEGFLAGS_DISCARDABLE)
783 memflags |= GMEM_DISCARDABLE;
784 if (flags & NE_SEGFLAGS_MOVEABLE ||
785 ( ! (flags & NE_SEGFLAGS_DATA) &&
786 ! (flags & NE_SEGFLAGS_LOADED) &&
787 ! (flags & NE_SEGFLAGS_ALLOCATED)
788 )
789 )
790 memflags |= GMEM_MOVEABLE;
791 memflags |= GMEM_ZEROINIT;
792 #else
793 memflags = GMEM_ZEROINIT | GMEM_FIXED;
794 #endif
795 return memflags;
796 }
797
798 /***********************************************************************
799 * NE_AllocateSegment (WPROCS.26)
800 *
801 * MyAlloc() function for self-loading apps.
802 */
803 DWORD WINAPI NE_AllocateSegment( WORD wFlags, WORD wSize, WORD wElem )
804 {
805 WORD size = wSize << wElem;
806 HANDLE16 hMem = 0;
807
808 if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE))
809 hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size);
810
811 if ( ((wFlags & 0x7) != 0x1) && /* DATA */
812 ((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */
813 {
814 WORD hSel = SEL(hMem);
815 WORD access = SelectorAccessRights16(hSel,0,0);
816
817 access |= 2<<2; /* SEGMENT_CODE */
818 SelectorAccessRights16(hSel,1,access);
819 }
820 if (size)
821 return MAKELONG( hMem, SEL(hMem) );
822 else
823 return MAKELONG( 0, hMem );
824 }
825
826 /***********************************************************************
827 * NE_GetInstance
828 */
829 HINSTANCE16 NE_GetInstance( NE_MODULE *pModule )
830 {
831 if ( !pModule->dgroup )
832 return pModule->self;
833 else
834 {
835 SEGTABLEENTRY *pSeg;
836 pSeg = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
837 return pSeg->hSeg;
838 }
839 }
840
841 /***********************************************************************
842 * NE_CreateSegment
843 */
844 BOOL NE_CreateSegment( NE_MODULE *pModule, int segnum )
845 {
846 SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + segnum - 1;
847 int minsize;
848
849 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
850
851 if ( segnum < 1 || segnum > pModule->seg_count )
852 return FALSE;
853
854 if ( (pModule->flags & NE_FFLAGS_SELFLOAD) && segnum != 1 )
855 return TRUE; /* selfloader allocates segment itself */
856
857 if ( (pSeg->flags & NE_SEGFLAGS_ALLOCATED) && segnum != pModule->dgroup )
858 return TRUE; /* all but DGROUP only allocated once */
859
860 minsize = pSeg->minsize ? pSeg->minsize : 0x10000;
861 if ( segnum == pModule->ss ) minsize += pModule->stack_size;
862 if ( segnum == pModule->dgroup ) minsize += pModule->heap_size;
863
864 pSeg->hSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSeg->flags),
865 minsize, pModule->self,
866 !(pSeg->flags & NE_SEGFLAGS_DATA),
867 (pSeg->flags & NE_SEGFLAGS_32BIT) != 0,
868 FALSE /*pSeg->flags & NE_SEGFLAGS_READONLY*/ );
869 if (!pSeg->hSeg) return FALSE;
870
871 pSeg->flags |= NE_SEGFLAGS_ALLOCATED;
872 return TRUE;
873 }
874
875 /***********************************************************************
876 * NE_CreateAllSegments
877 */
878 BOOL NE_CreateAllSegments( NE_MODULE *pModule )
879 {
880 int i;
881 for ( i = 1; i <= pModule->seg_count; i++ )
882 if ( !NE_CreateSegment( pModule, i ) )
883 return FALSE;
884
885 pModule->dgroup_entry = pModule->dgroup ? pModule->seg_table +
886 (pModule->dgroup - 1) * sizeof(SEGTABLEENTRY) : 0;
887 return TRUE;
888 }
889
890
891 /**********************************************************************
892 * IsSharedSelector (KERNEL.345)
893 */
894 BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
895 {
896 /* Check whether the selector belongs to a DLL */
897 NE_MODULE *pModule = NE_GetPtr( selector );
898 if (!pModule) return FALSE;
899 return (pModule->flags & NE_FFLAGS_LIBMODULE) != 0;
900 }
Windows API implementation