?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added YUV routines needed for v4l driver, and in the future possibly
[wine/gsoc-2012-control.git] / dlls / kernel / ne_segment.c
blob8756d127e272013da3d65d971a94c34d3f9da1fd
1 /*
2 * NE segment loading
3 *
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <sys/types.h>
29 #include <fcntl.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33 #include <ctype.h>
34 #include <string.h>
35
36 #include "wine/winbase16.h"
37 #include "wownt32.h"
38 #include "wine/library.h"
39 #include "kernel_private.h"
40 #include "kernel16_private.h"
41 #include "toolhelp.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(fixup);
45 WINE_DECLARE_DEBUG_CHANNEL(dll);
46 WINE_DECLARE_DEBUG_CHANNEL(module);
47
48 /*
49 * Relocation table entry
50 */
51 struct relocation_entry_s
52 {
53 BYTE address_type; /* Relocation address type */
54 BYTE relocation_type; /* Relocation type */
55 WORD offset; /* Offset in segment to fixup */
56 WORD target1; /* Target specification */
57 WORD target2; /* Target specification */
58 };
59
60 /*
61 * Relocation address types
62 */
63 #define NE_RADDR_LOWBYTE 0
64 #define NE_RADDR_SELECTOR 2
65 #define NE_RADDR_POINTER32 3
66 #define NE_RADDR_OFFSET16 5
67 #define NE_RADDR_POINTER48 11
68 #define NE_RADDR_OFFSET32 13
69
70 /*
71 * Relocation types
72 */
73 #define NE_RELTYPE_INTERNAL 0
74 #define NE_RELTYPE_ORDINAL 1
75 #define NE_RELTYPE_NAME 2
76 #define NE_RELTYPE_OSFIXUP 3
77 #define NE_RELFLAG_ADDITIVE 4
78
79 /* Self-loading modules contain this structure in their first segment */
80 typedef struct
81 {
82 WORD version; /* Must be "A0" (0x3041) */
83 WORD reserved;
84 FARPROC16 BootApp; /* startup procedure */
85 FARPROC16 LoadAppSeg; /* procedure to load a segment */
86 FARPROC16 reserved2;
87 FARPROC16 MyAlloc; /* memory allocation procedure,
88 * wine must write this field */
89 FARPROC16 EntryAddrProc;
90 FARPROC16 ExitProc; /* exit procedure */
91 WORD reserved3[4];
92 FARPROC16 SetOwner; /* Set Owner procedure, exported by wine */
93 } SELFLOADHEADER;
94
95 #define SEL(x) ((x)|1)
96
97 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum);
98
99
100 /***********************************************************************
101 * NE_GetRelocAddrName
102 */
103 static const char *NE_GetRelocAddrName( BYTE addr_type, int additive )
104 {
105 switch(addr_type & 0x7f)
106 {
107 case NE_RADDR_LOWBYTE: return additive ? "BYTE add" : "BYTE";
108 case NE_RADDR_OFFSET16: return additive ? "OFFSET16 add" : "OFFSET16";
109 case NE_RADDR_POINTER32: return additive ? "POINTER32 add" : "POINTER32";
110 case NE_RADDR_SELECTOR: return additive ? "SELECTOR add" : "SELECTOR";
111 case NE_RADDR_POINTER48: return additive ? "POINTER48 add" : "POINTER48";
112 case NE_RADDR_OFFSET32: return additive ? "OFFSET32 add" : "OFFSET32";
113 }
114 return "???";
115 }
116
117
118 /***********************************************************************
119 * NE_OpenFile
120 */
121 static HFILE16 NE_OpenFile( NE_MODULE *pModule )
122 {
123 char *name = NE_MODULE_NAME( pModule );
124 HANDLE handle = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
125 NULL, OPEN_EXISTING, 0, 0 );
126
127 if (handle == INVALID_HANDLE_VALUE)
128 {
129 ERR( "Can't open file '%s' for module %04x\n", name, pModule->self );
130 return HFILE_ERROR;
131 }
132 return Win32HandleToDosFileHandle( handle );
133 }
134
135
136 /***********************************************************************
137 * apply_relocations
138 *
139 * Apply relocations to a segment. Helper for NE_LoadSegment.
140 */
141 static inline BOOL apply_relocations( NE_MODULE *pModule, const struct relocation_entry_s *rep,
142 int count, int segnum )
143 {
144 BYTE *func_name;
145 char buffer[256];
146 int i, ordinal;
147 WORD offset, *sp;
148 HMODULE16 module;
149 FARPROC16 address = 0;
150 HMODULE16 *pModuleTable = (HMODULE16 *)((char *)pModule + pModule->ne_modtab);
151 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
152 SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
153
154 /*
155 * Go through the relocation table one entry at a time.
156 */
157 for (i = 0; i < count; i++, rep++)
158 {
159 /*
160 * Get the target address corresponding to this entry.
161 */
162
163 /* If additive, there is no target chain list. Instead, add source
164 and target */
165 int additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
166 switch (rep->relocation_type & 3)
167 {
168 case NE_RELTYPE_ORDINAL:
169 module = pModuleTable[rep->target1-1];
170 ordinal = rep->target2;
171 address = NE_GetEntryPoint( module, ordinal );
172 if (!address)
173 {
174 NE_MODULE *pTarget = NE_GetPtr( module );
175 if (!pTarget)
176 WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
177 module, rep->target1,
178 *((BYTE *)pModule + pModule->ne_restab),
179 *((BYTE *)pModule + pModule->ne_restab),
180 (char *)pModule + pModule->ne_restab + 1 );
181 else
182 {
183 ERR("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
184 *((BYTE *)pTarget + pTarget->ne_restab),
185 (char *)pTarget + pTarget->ne_restab + 1,
186 ordinal );
187 address = (FARPROC16)0xdeadbeef;
188 }
189 }
190 if (TRACE_ON(fixup))
191 {
192 NE_MODULE *pTarget = NE_GetPtr( module );
193 TRACE("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
194 *((BYTE *)pTarget + pTarget->ne_restab),
195 (char *)pTarget + pTarget->ne_restab + 1,
196 ordinal, HIWORD(address), LOWORD(address),
197 NE_GetRelocAddrName( rep->address_type, additive ) );
198 }
199 break;
200
201 case NE_RELTYPE_NAME:
202 module = pModuleTable[rep->target1-1];
203 func_name = (char *)pModule + pModule->ne_imptab + rep->target2;
204 memcpy( buffer, func_name+1, *func_name );
205 buffer[*func_name] = '\0';
206 func_name = buffer;
207 ordinal = NE_GetOrdinal( module, func_name );
208 address = NE_GetEntryPoint( module, ordinal );
209
210 if (ERR_ON(fixup) && !address)
211 {
212 NE_MODULE *pTarget = NE_GetPtr( module );
213 ERR("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
214 *((BYTE *)pTarget + pTarget->ne_restab),
215 (char *)pTarget + pTarget->ne_restab + 1, func_name );
216 }
217 if (!address) address = (FARPROC16) 0xdeadbeef;
218 if (TRACE_ON(fixup))
219 {
220 NE_MODULE *pTarget = NE_GetPtr( module );
221 TRACE("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
222 *((BYTE *)pTarget + pTarget->ne_restab),
223 (char *)pTarget + pTarget->ne_restab + 1,
224 func_name, HIWORD(address), LOWORD(address),
225 NE_GetRelocAddrName( rep->address_type, additive ) );
226 }
227 break;
228
229 case NE_RELTYPE_INTERNAL:
230 if ((rep->target1 & 0xff) == 0xff)
231 {
232 address = NE_GetEntryPoint( pModule->self, rep->target2 );
233 }
234 else
235 {
236 address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
237 }
238
239 TRACE("%d: %04x:%04x %s\n",
240 i + 1, HIWORD(address), LOWORD(address),
241 NE_GetRelocAddrName( rep->address_type, additive ) );
242 break;
243
244 case NE_RELTYPE_OSFIXUP:
245 /* Relocation type 7:
246 *
247 * These appear to be used as fixups for the Windows
248 * floating point emulator. Let's just ignore them and
249 * try to use the hardware floating point. Linux should
250 * successfully emulate the coprocessor if it doesn't
251 * exist.
252 */
253 TRACE("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
254 i + 1, rep->relocation_type, rep->offset,
255 rep->target1, rep->target2,
256 NE_GetRelocAddrName( rep->address_type, additive ) );
257 continue;
258 }
259
260 offset = rep->offset;
261
262 /* Apparently, high bit of address_type is sometimes set; */
263 /* we ignore it for now */
264 if (rep->address_type > NE_RADDR_OFFSET32)
265 {
266 char module[10];
267 GetModuleName16( pModule->self, module, sizeof(module) );
268 ERR("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
269 module, rep->address_type );
270 }
271
272 if (additive)
273 {
274 sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
275 TRACE(" %04x:%04x\n", offset, *sp );
276 switch (rep->address_type & 0x7f)
277 {
278 case NE_RADDR_LOWBYTE:
279 *(BYTE *)sp += LOBYTE((int)address);
280 break;
281 case NE_RADDR_OFFSET16:
282 *sp += LOWORD(address);
283 break;
284 case NE_RADDR_POINTER32:
285 *sp += LOWORD(address);
286 *(sp+1) = HIWORD(address);
287 break;
288 case NE_RADDR_SELECTOR:
289 /* Borland creates additive records with offset zero. Strange, but OK */
290 if (*sp)
291 ERR("Additive selector to %04x.Please report\n",*sp);
292 else
293 *sp = HIWORD(address);
294 break;
295 default:
296 goto unknown;
297 }
298 }
299 else /* non-additive fixup */
300 {
301 do
302 {
303 WORD next_offset;
304
305 sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
306 next_offset = *sp;
307 TRACE(" %04x:%04x\n", offset, *sp );
308 switch (rep->address_type & 0x7f)
309 {
310 case NE_RADDR_LOWBYTE:
311 *(BYTE *)sp = LOBYTE((int)address);
312 break;
313 case NE_RADDR_OFFSET16:
314 *sp = LOWORD(address);
315 break;
316 case NE_RADDR_POINTER32:
317 *(FARPROC16 *)sp = address;
318 break;
319 case NE_RADDR_SELECTOR:
320 *sp = SELECTOROF(address);
321 break;
322 default:
323 goto unknown;
324 }
325 if (next_offset == offset) break; /* avoid infinite loop */
326 if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
327 offset = next_offset;
328 } while (offset != 0xffff);
329 }
330 }
331 return TRUE;
332
333 unknown:
334 WARN("WARNING: %d: unknown ADDR TYPE %d, "
335 "TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
336 i + 1, rep->address_type, rep->relocation_type,
337 rep->offset, rep->target1, rep->target2);
338 return FALSE;
339 }
340
341
342 /***********************************************************************
343 * NE_LoadSegment
344 */
345 BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
346 {
347 WORD count;
348 DWORD pos;
349 const struct relocation_entry_s *rep;
350 int size;
351 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
352 SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
353
354 if (pSeg->flags & NE_SEGFLAGS_LOADED)
355 {
356 /* self-loader ? -> already loaded it */
357 if (pModule->ne_flags & NE_FFLAGS_SELFLOAD)
358 return TRUE;
359
360 /* leave, except for DGROUP, as this may be the second instance */
361 if (segnum != pModule->ne_autodata)
362 return TRUE;
363 }
364
365 if (!pSeg->filepos) return TRUE; /* No file image, just return */
366
367 TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
368 segnum, pSeg->hSeg, pSeg->flags );
369 pos = pSeg->filepos << pModule->ne_align;
370 if (pSeg->size) size = pSeg->size;
371 else size = pSeg->minsize ? pSeg->minsize : 0x10000;
372
373 if (pModule->ne_flags & NE_FFLAGS_SELFLOAD && segnum > 1)
374 {
375 /* Implement self-loading segments */
376 SELFLOADHEADER *selfloadheader;
377 void *oldstack;
378 HFILE16 hFile16;
379 WORD args[3];
380 DWORD ret;
381
382 selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
383 oldstack = NtCurrentTeb()->WOW32Reserved;
384 NtCurrentTeb()->WOW32Reserved = (void *)MAKESEGPTR(pModule->self_loading_sel,
385 0xff00 - sizeof(STACK16FRAME));
386
387 hFile16 = NE_OpenFile( pModule );
388 TRACE_(dll)("CallLoadAppSegProc(hmodule=0x%04x,hf=%x,segnum=%d\n",
389 pModule->self,hFile16,segnum );
390 args[2] = pModule->self;
391 args[1] = hFile16;
392 args[0] = segnum;
393 WOWCallback16Ex( (DWORD)selfloadheader->LoadAppSeg, WCB16_PASCAL, sizeof(args), args, &ret );
394 pSeg->hSeg = LOWORD(ret);
395 TRACE_(dll)("Ret CallLoadAppSegProc: hSeg = 0x%04x\n", pSeg->hSeg);
396 _lclose16( hFile16 );
397 NtCurrentTeb()->WOW32Reserved = oldstack;
398 }
399 else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
400 {
401 void *mem = GlobalLock16(pSeg->hSeg);
402 if (!NE_READ_DATA( pModule, mem, pos, size ))
403 return FALSE;
404 pos += size;
405 }
406 else
407 {
408 /*
409 The following bit of code for "iterated segments" was written without
410 any documentation on the format of these segments. It seems to work,
411 but may be missing something.
412 */
413 const char *buff = NE_GET_DATA( pModule, pos, size );
414 const char* curr = buff;
415 char *mem = GlobalLock16(pSeg->hSeg);
416
417 pos += size;
418 if (buff == NULL) return FALSE;
419
420 while(curr < buff + size) {
421 unsigned int rept = ((short*)curr)[0];
422 unsigned int len = ((short*)curr)[1];
423
424 curr += 2*sizeof(short);
425 while (rept--)
426 {
427 memcpy( mem, curr, len );
428 mem += len;
429 }
430 curr += len;
431 }
432 }
433
434 pSeg->flags |= NE_SEGFLAGS_LOADED;
435
436 /* Perform exported function prolog fixups */
437 NE_FixupSegmentPrologs( pModule, segnum );
438
439 if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
440 return TRUE; /* No relocation data, we are done */
441
442 if (!NE_READ_DATA( pModule, &count, pos, sizeof(count) ) || !count) return TRUE;
443 pos += sizeof(count);
444
445 TRACE("Fixups for %.*s, segment %d, hSeg %04x\n",
446 *((BYTE *)pModule + pModule->ne_restab),
447 (char *)pModule + pModule->ne_restab + 1,
448 segnum, pSeg->hSeg );
449
450 if (!(rep = NE_GET_DATA( pModule, pos, count * sizeof(struct relocation_entry_s) )))
451 return FALSE;
452
453 return apply_relocations( pModule, rep, count, segnum );
454 }
455
456
457 /***********************************************************************
458 * NE_LoadAllSegments
459 */
460 BOOL NE_LoadAllSegments( NE_MODULE *pModule )
461 {
462 int i;
463 SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
464
465 if (pModule->ne_flags & NE_FFLAGS_SELFLOAD)
466 {
467 HFILE16 hFile16;
468 HGLOBAL16 sel;
469 /* Handle self-loading modules */
470 SELFLOADHEADER *selfloadheader;
471 HMODULE16 mod = GetModuleHandle16("KERNEL");
472 void *oldstack;
473 WORD args[2];
474
475 TRACE_(module)("%.*s is a self-loading module!\n",
476 *((BYTE*)pModule + pModule->ne_restab),
477 (char *)pModule + pModule->ne_restab + 1);
478 if (!NE_LoadSegment( pModule, 1 )) return FALSE;
479 selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) );
480 selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc");
481 selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc");
482 selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner");
483 sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 );
484 pModule->self_loading_sel = SEL(sel);
485 FarSetOwner16( sel, pModule->self );
486 oldstack = NtCurrentTeb()->WOW32Reserved;
487 NtCurrentTeb()->WOW32Reserved = (void *)MAKESEGPTR(pModule->self_loading_sel,
488 0xff00 - sizeof(STACK16FRAME) );
489
490 hFile16 = NE_OpenFile(pModule);
491 TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n",
492 pModule->self,hFile16);
493 args[1] = pModule->self;
494 args[0] = hFile16;
495 WOWCallback16Ex( (DWORD)selfloadheader->BootApp, WCB16_PASCAL, sizeof(args), args, NULL );
496 TRACE_(dll)("Return from CallBootAppProc\n");
497 _lclose16(hFile16);
498 NtCurrentTeb()->WOW32Reserved = oldstack;
499
500 for (i = 2; i <= pModule->ne_cseg; i++)
501 if (!NE_LoadSegment( pModule, i )) return FALSE;
502 }
503 else
504 {
505 for (i = 1; i <= pModule->ne_cseg; i++)
506 if (!NE_LoadSegment( pModule, i )) return FALSE;
507 }
508 return TRUE;
509 }
510
511
512 /***********************************************************************
513 * NE_FixupSegmentPrologs
514 *
515 * Fixup exported functions prologs of one segment
516 */
517 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
518 {
519 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
520 ET_BUNDLE *bundle;
521 ET_ENTRY *entry;
522 WORD dgroup, num_entries, sel = SEL(pSegTable[segnum-1].hSeg);
523 BYTE *pSeg, *pFunc;
524
525 TRACE("(%d);\n", segnum);
526
527 if (pSegTable[segnum-1].flags & NE_SEGFLAGS_DATA)
528 {
529 pSegTable[segnum-1].flags |= NE_SEGFLAGS_LOADED;
530 return;
531 }
532
533 if (!pModule->ne_autodata) return;
534
535 if (!(dgroup = SEL(pSegTable[pModule->ne_autodata-1].hSeg))) return;
536
537 pSeg = MapSL( MAKESEGPTR(sel, 0) );
538
539 bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->ne_enttab);
540
541 do {
542 TRACE("num_entries: %d, bundle: %p, next: %04x, pSeg: %p\n", bundle->last - bundle->first, bundle, bundle->next, pSeg);
543 if (!(num_entries = bundle->last - bundle->first))
544 return;
545 entry = (ET_ENTRY *)((BYTE *)bundle+6);
546 while (num_entries--)
547 {
548 /*TRACE("entry: %p, entry->segnum: %d, entry->offs: %04x\n", entry, entry->segnum, entry->offs);*/
549 if (entry->segnum == segnum)
550 {
551 pFunc = ((BYTE *)pSeg+entry->offs);
552 TRACE("pFunc: %p, *(DWORD *)pFunc: %08lx, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
553 if (*(pFunc+2) == 0x90)
554 {
555 if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
556 {
557 TRACE("patch %04x:%04x -> mov ax, ds\n", sel, entry->offs);
558 *(WORD *)pFunc = 0xd88c; /* mov ax, ds */
559 }
560
561 if (*(WORD *)pFunc == 0xd88c)
562 {
563 if ((entry->flags & 2)) /* public data ? */
564 {
565 TRACE("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry->offs, dgroup);
566 *pFunc = 0xb8; /* mov ax, */
567 *(WORD *)(pFunc+1) = dgroup;
568 }
569 else
570 if ((pModule->ne_flags & NE_FFLAGS_MULTIPLEDATA)
571 && (entry->flags & 1)) /* exported ? */
572 {
573 TRACE("patch %04x:%04x -> nop, nop\n", sel, entry->offs);
574 *(WORD *)pFunc = 0x9090; /* nop, nop */
575 }
576 }
577 }
578 }
579 entry++;
580 }
581 } while ( (bundle->next)
582 && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
583 }
584
585
586 /***********************************************************************
587 * PatchCodeHandle (KERNEL.110)
588 *
589 * Needed for self-loading modules.
590 */
591 DWORD WINAPI PatchCodeHandle16(HANDLE16 hSeg)
592 {
593 WORD segnum;
594 WORD sel = SEL(hSeg);
595 NE_MODULE *pModule = NE_GetPtr(FarGetOwner16(sel));
596 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE(pModule);
597
598 TRACE_(module)("(%04x);\n", hSeg);
599
600 /* find the segment number of the module that belongs to hSeg */
601 for (segnum = 1; segnum <= pModule->ne_cseg; segnum++)
602 {
603 if (SEL(pSegTable[segnum-1].hSeg) == sel)
604 {
605 NE_FixupSegmentPrologs(pModule, segnum);
606 break;
607 }
608 }
609
610 return MAKELONG(hSeg, sel);
611 }
612
613
614 /***********************************************************************
615 * NE_GetDLLInitParams
616 */
617 static VOID NE_GetDLLInitParams( NE_MODULE *pModule,
618 WORD *hInst, WORD *ds, WORD *heap )
619 {
620 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
621
622 if (!(pModule->ne_flags & NE_FFLAGS_SINGLEDATA))
623 {
624 if (pModule->ne_flags & NE_FFLAGS_MULTIPLEDATA || pModule->ne_autodata)
625 {
626 /* Not SINGLEDATA */
627 ERR_(dll)("Library is not marked SINGLEDATA\n");
628 exit(1);
629 }
630 else /* DATA NONE DLL */
631 {
632 *ds = 0;
633 *heap = 0;
634 }
635 }
636 else /* DATA SINGLE DLL */
637 {
638 if (pModule->ne_autodata) {
639 *ds = SEL(pSegTable[pModule->ne_autodata-1].hSeg);
640 *heap = pModule->ne_heap;
641 }
642 else /* hmm, DLL has no dgroup,
643 but why has it NE_FFLAGS_SINGLEDATA set ?
644 Buggy DLL compiler ? */
645 {
646 *ds = 0;
647 *heap = 0;
648 }
649 }
650
651 *hInst = *ds ? GlobalHandle16(*ds) : pModule->self;
652 }
653
654
655 /***********************************************************************
656 * NE_InitDLL
657 *
658 * Call the DLL initialization code
659 */
660 static BOOL NE_InitDLL( NE_MODULE *pModule )
661 {
662 SEGTABLEENTRY *pSegTable;
663 WORD hInst, ds, heap;
664 CONTEXT86 context;
665
666 pSegTable = NE_SEG_TABLE( pModule );
667
668 if (!(pModule->ne_flags & NE_FFLAGS_LIBMODULE) ||
669 (pModule->ne_flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
670
671 /* Call USER signal handler for Win3.1 compatibility. */
672 NE_CallUserSignalProc( pModule->self, USIG16_DLL_LOAD );
673
674 if (!SELECTOROF(pModule->ne_csip)) return TRUE; /* no initialization code */
675
676
677 /* Registers at initialization must be:
678 * cx heap size
679 * di library instance
680 * ds data segment if any
681 * es:si command line (always 0)
682 */
683
684 memset( &context, 0, sizeof(context) );
685
686 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
687
688 context.Ecx = heap;
689 context.Edi = hInst;
690 context.SegDs = ds;
691 context.SegEs = ds; /* who knows ... */
692 context.SegFs = wine_get_fs();
693 context.SegGs = wine_get_gs();
694 context.SegCs = SEL(pSegTable[SELECTOROF(pModule->ne_csip)-1].hSeg);
695 context.Eip = OFFSETOF(pModule->ne_csip);
696 context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
697
698 pModule->ne_csip = 0; /* Don't initialize it twice */
699 TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
700 *((BYTE*)pModule + pModule->ne_restab),
701 (char *)pModule + pModule->ne_restab + 1,
702 context.SegCs, context.Eip, context.SegDs,
703 LOWORD(context.Edi), LOWORD(context.Ecx) );
704 WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&context );
705 return TRUE;
706 }
707
708 /***********************************************************************
709 * NE_InitializeDLLs
710 *
711 * Recursively initialize all DLLs (according to the order in which
712 * they where loaded).
713 */
714 void NE_InitializeDLLs( HMODULE16 hModule )
715 {
716 NE_MODULE *pModule;
717 HMODULE16 *pDLL;
718
719 if (!(pModule = NE_GetPtr( hModule ))) return;
720 assert( !(pModule->ne_flags & NE_FFLAGS_WIN32) );
721
722 if (pModule->dlls_to_init)
723 {
724 HGLOBAL16 to_init = pModule->dlls_to_init;
725 pModule->dlls_to_init = 0;
726 for (pDLL = (HMODULE16 *)GlobalLock16( to_init ); *pDLL; pDLL++)
727 {
728 NE_InitializeDLLs( *pDLL );
729 }
730 GlobalFree16( to_init );
731 }
732 NE_InitDLL( pModule );
733 }
734
735
736 /**********************************************************************
737 * NE_CallUserSignalProc
738 *
739 * According to "Undocumented Windows", the task signal proc is
740 * bypassed for module load/unload notifications, and the USER signal
741 * proc is called directly instead. This is what this function does.
742 */
743 typedef DWORD (WINAPI *pSignalProc)( HANDLE16 module, UINT16 code, UINT16 exit,
744 HINSTANCE16 inst, HQUEUE16 queue );
745
746 void NE_CallUserSignalProc( HMODULE16 hModule, UINT16 code )
747 {
748 FARPROC16 proc;
749 HMODULE16 user = GetModuleHandle16("user.exe");
750
751 if (!user) return;
752 if ((proc = GetProcAddress16( user, "SignalProc" )))
753 {
754 /* USER is always a builtin dll */
755 pSignalProc sigproc = (pSignalProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)proc ))->target;
756 sigproc( hModule, code, 0, 0, 0 );
757 }
758 }
759
760
761 /***********************************************************************
762 * NE_CallDllEntryPoint
763 *
764 * Call the DllEntryPoint of DLLs with subsystem >= 4.0
765 */
766 typedef DWORD (WINAPI *WinNEEntryProc)(DWORD,WORD,WORD,WORD,DWORD,WORD);
767
768 static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
769 {
770 WORD hInst, ds, heap;
771 FARPROC16 entryPoint;
772
773 if (!(pModule->ne_flags & NE_FFLAGS_LIBMODULE)) return;
774 if (!(pModule->ne_flags & NE_FFLAGS_BUILTIN) && pModule->ne_expver < 0x0400) return;
775 if (!(entryPoint = GetProcAddress16( pModule->self, "DllEntryPoint" ))) return;
776
777 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
778
779 TRACE_(dll)( "Calling %s DllEntryPoint, cs:ip=%04x:%04x\n",
780 NE_MODULE_NAME( pModule ),
781 SELECTOROF(entryPoint), OFFSETOF(entryPoint) );
782
783 if ( pModule->ne_flags & NE_FFLAGS_BUILTIN )
784 {
785 WinNEEntryProc entryProc = (WinNEEntryProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)entryPoint ))->target;
786
787 entryProc( dwReason, hInst, ds, heap, 0, 0 );
788 }
789 else
790 {
791 CONTEXT86 context;
792 WORD args[8];
793
794 memset( &context, 0, sizeof(context) );
795 context.SegDs = ds;
796 context.SegEs = ds; /* who knows ... */
797 context.SegFs = wine_get_fs();
798 context.SegGs = wine_get_gs();
799 context.SegCs = HIWORD(entryPoint);
800 context.Eip = LOWORD(entryPoint);
801 context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
802
803 args[7] = HIWORD(dwReason);
804 args[6] = LOWORD(dwReason);
805 args[5] = hInst;
806 args[4] = ds;
807 args[3] = heap;
808 args[2] = 0; /* HIWORD(dwReserved1) */
809 args[1] = 0; /* LOWORD(dwReserved1) */
810 args[0] = 0; /* wReserved2 */
811 WOWCallback16Ex( 0, WCB16_REGS, sizeof(args), args, (DWORD *)&context );
812 }
813 }
814
815 /***********************************************************************
816 * NE_DllProcessAttach
817 *
818 * Call the DllEntryPoint of all modules this one (recursively)
819 * depends on, according to the order in which they were loaded.
820 *
821 * Note that --as opposed to the PE module case-- there is no notion
822 * of 'module loaded into a process' for NE modules, and hence we
823 * have no place to store the fact that the DllEntryPoint of a
824 * given module was already called on behalf of this process (e.g.
825 * due to some earlier LoadLibrary16 call).
826 *
827 * Thus, we just call the DllEntryPoint twice in that case. Win9x
828 * appears to behave this way as well ...
829 *
830 * This routine must only be called with the Win16Lock held.
831 *
832 * FIXME: We should actually abort loading in case the DllEntryPoint
833 * returns FALSE ...
834 *
835 */
836
837 struct ne_init_list
838 {
839 int count;
840 int size;
841 NE_MODULE **module;
842 };
843
844 static void add_to_init_list( struct ne_init_list *list, NE_MODULE *hModule )
845 {
846 NE_MODULE **newModule = NULL;
847 if ( list->count == list->size )
848 {
849 int newSize = list->size + 128;
850
851 if (list->module)
852 newModule = HeapReAlloc( GetProcessHeap(), 0,
853 list->module, newSize*sizeof(NE_MODULE *) );
854 else
855 newModule = HeapAlloc( GetProcessHeap(), 0,
856 newSize*sizeof(NE_MODULE *) );
857 if ( !newModule )
858 {
859 FIXME_(dll)("Out of memory!\n");
860 return;
861 }
862
863 list->module = newModule;
864 list->size = newSize;
865 }
866
867 list->module[list->count++] = hModule;
868 }
869
870 static void free_init_list( struct ne_init_list *list )
871 {
872 if ( list->module )
873 {
874 HeapFree( GetProcessHeap(), 0, list->module );
875 memset( list, 0, sizeof(*list) );
876 }
877 }
878
879 static void fill_init_list( struct ne_init_list *list, HMODULE16 hModule )
880 {
881 NE_MODULE *pModule;
882 HMODULE16 *pModRef;
883 int i;
884
885 if (!(pModule = NE_GetPtr( hModule ))) return;
886 assert( !(pModule->ne_flags & NE_FFLAGS_WIN32) );
887
888 /* Never add a module twice */
889 for ( i = 0; i < list->count; i++ )
890 if ( list->module[i] == pModule )
891 return;
892
893 /* Check for recursive call */
894 if ( pModule->ne_flagsothers & 0x80 ) return;
895
896 TRACE_(dll)("(%s) - START\n", NE_MODULE_NAME(pModule) );
897
898 /* Tag current module to prevent recursive loop */
899 pModule->ne_flagsothers |= 0x80;
900
901 /* Recursively attach all DLLs this one depends on */
902 pModRef = (HMODULE16 *)((char *)pModule + pModule->ne_modtab);
903 for ( i = 0; i < pModule->ne_cmod; i++ )
904 if ( pModRef[i] ) fill_init_list( list, pModRef[i] );
905
906 /* Add current module */
907 add_to_init_list( list, pModule );
908
909 /* Remove recursion flag */
910 pModule->ne_flagsothers &= ~0x80;
911
912 TRACE_(dll)("(%s) - END\n", NE_MODULE_NAME(pModule) );
913 }
914
915 static void call_init_list( struct ne_init_list *list )
916 {
917 int i;
918 for ( i = 0; i < list->count; i++ )
919 NE_CallDllEntryPoint( list->module[i], DLL_PROCESS_ATTACH );
920 }
921
922 void NE_DllProcessAttach( HMODULE16 hModule )
923 {
924 struct ne_init_list list;
925 memset( &list, 0, sizeof(list) );
926
927 fill_init_list( &list, hModule );
928 call_init_list( &list );
929 free_init_list( &list );
930 }
931
932
933 /***********************************************************************
934 * NE_Ne2MemFlags
935 *
936 * This function translates NE segment flags to GlobalAlloc flags
937 */
938 static WORD NE_Ne2MemFlags(WORD flags)
939 {
940 WORD memflags = 0;
941 #if 1
942 if (flags & NE_SEGFLAGS_DISCARDABLE)
943 memflags |= GMEM_DISCARDABLE;
944 if (flags & NE_SEGFLAGS_MOVEABLE ||
945 ( ! (flags & NE_SEGFLAGS_DATA) &&
946 ! (flags & NE_SEGFLAGS_LOADED) &&
947 ! (flags & NE_SEGFLAGS_ALLOCATED)
948 )
949 )
950 memflags |= GMEM_MOVEABLE;
951 memflags |= GMEM_ZEROINIT;
952 #else
953 memflags = GMEM_ZEROINIT | GMEM_FIXED;
954 #endif
955 return memflags;
956 }
957
958 /***********************************************************************
959 * MyAlloc (KERNEL.668) Wine-specific export
960 *
961 * MyAlloc() function for self-loading apps.
962 */
963 DWORD WINAPI MyAlloc16( WORD wFlags, WORD wSize, WORD wElem )
964 {
965 WORD size = wSize << wElem;
966 HANDLE16 hMem = 0;
967
968 if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE))
969 hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size);
970
971 if ( ((wFlags & 0x7) != 0x1) && /* DATA */
972 ((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */
973 {
974 WORD hSel = SEL(hMem);
975 WORD access = SelectorAccessRights16(hSel,0,0);
976
977 access |= 2<<2; /* SEGMENT_CODE */
978 SelectorAccessRights16(hSel,1,access);
979 }
980 if (size)
981 return MAKELONG( hMem, SEL(hMem) );
982 else
983 return MAKELONG( 0, hMem );
984 }
985
986 /***********************************************************************
987 * NE_GetInstance
988 */
989 HINSTANCE16 NE_GetInstance( NE_MODULE *pModule )
990 {
991 if ( !pModule->ne_autodata )
992 return pModule->self;
993 else
994 {
995 SEGTABLEENTRY *pSeg;
996 pSeg = NE_SEG_TABLE( pModule ) + pModule->ne_autodata - 1;
997 return pSeg->hSeg;
998 }
999 }
1000
1001 /***********************************************************************
1002 * NE_CreateSegment
1003 */
1004 BOOL NE_CreateSegment( NE_MODULE *pModule, int segnum )
1005 {
1006 SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + segnum - 1;
1007 int minsize;
1008 unsigned char selflags;
1009
1010 assert( !(pModule->ne_flags & NE_FFLAGS_WIN32) );
1011
1012 if ( segnum < 1 || segnum > pModule->ne_cseg )
1013 return FALSE;
1014
1015 if ( (pModule->ne_flags & NE_FFLAGS_SELFLOAD) && segnum != 1 )
1016 return TRUE; /* selfloader allocates segment itself */
1017
1018 if ( (pSeg->flags & NE_SEGFLAGS_ALLOCATED) && segnum != pModule->ne_autodata )
1019 return TRUE; /* all but DGROUP only allocated once */
1020
1021 minsize = pSeg->minsize ? pSeg->minsize : 0x10000;
1022 if ( segnum == SELECTOROF(pModule->ne_sssp) ) minsize += pModule->ne_stack;
1023 if ( segnum == pModule->ne_autodata ) minsize += pModule->ne_heap;
1024
1025 selflags = (pSeg->flags & NE_SEGFLAGS_DATA) ? WINE_LDT_FLAGS_DATA : WINE_LDT_FLAGS_CODE;
1026 if (pSeg->flags & NE_SEGFLAGS_32BIT) selflags |= WINE_LDT_FLAGS_32BIT;
1027 pSeg->hSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSeg->flags), minsize, pModule->self, selflags );
1028 if (!pSeg->hSeg) return FALSE;
1029
1030 pSeg->flags |= NE_SEGFLAGS_ALLOCATED;
1031 return TRUE;
1032 }
1033
1034 /***********************************************************************
1035 * NE_CreateAllSegments
1036 */
1037 BOOL NE_CreateAllSegments( NE_MODULE *pModule )
1038 {
1039 int i;
1040 for ( i = 1; i <= pModule->ne_cseg; i++ )
1041 if ( !NE_CreateSegment( pModule, i ) )
1042 return FALSE;
1043
1044 pModule->dgroup_entry = pModule->ne_autodata ? pModule->ne_segtab +
1045 (pModule->ne_autodata - 1) * sizeof(SEGTABLEENTRY) : 0;
1046 return TRUE;
1047 }
1048
1049
1050 /**********************************************************************
1051 * IsSharedSelector (KERNEL.345)
1052 */
1053 BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
1054 {
1055 /* Check whether the selector belongs to a DLL */
1056 NE_MODULE *pModule = NE_GetPtr( selector );
1057 if (!pModule) return FALSE;
1058 return (pModule->ne_flags & NE_FFLAGS_LIBMODULE) != 0;
1059 }
GSOC 2012 project to enhance the control panel