git.oblomov.eu Git - wine/blob - dlls/krnl386.exe16/ne_segment.c

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