loader/module.c

   1 /*
   2  * Modules
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <fcntl.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12 #include <unistd.h>
  13 #include "windows.h"
  14 #include "dlls.h"
  15 #include "dos_fs.h"
  16 #include "global.h"
  17 #include "ldt.h"
  18 #include "module.h"
  19 #include "neexe.h"
  20 #include "stackframe.h"
  21 #include "task.h"
  22 #include "toolhelp.h"
  23 #include "stddebug.h"
  24 #include "debug.h"
  25
  26 #include "callback.h"
  27
  28 static HMODULE hFirstModule = 0;
  29 static HMODULE hCachedModule = 0;  /* Module cached by MODULE_OpenFile */
  30
  31
  32 /***********************************************************************
  33  *           MODULE_LoadBuiltin
  34  *
  35  * Load a built-in module. If the 'force' parameter is FALSE, we only
  36  * load the module if it has not been disabled via the -dll option.
  37  */
  38 static HMODULE MODULE_LoadBuiltin( LPCSTR name, BOOL force )
  39 {
  40 #ifndef WINELIB /* JBP: Not really allowed in libwine.a (FIXME:?) */
  41     HMODULE hModule;
  42     NE_MODULE *pModule;
  43     SEGTABLEENTRY *pSegTable;
  44     struct dll_table_s *table;
  45     int i;
  46     char dllname[16], *p;
  47
  48     /* Fix the name in case we have a full path and extension */
  49
  50     if ((p = strrchr( name, '\\' ))) name = p + 1;
  51     strncpy( dllname, name, 15 );
  52     dllname[15] = '\0';
  53     if ((p = strrchr( dllname, '.' ))) *p = '\0';
  54
  55     for (i = 0, table = dll_builtin_table; i < N_BUILTINS; i++, table++)
  56         if (!strcasecmp( table->name, dllname )) break;
  57     if (i >= N_BUILTINS) return 0;
  58     if (!table->used && !force) return 0;
  59
  60     hModule = GLOBAL_CreateBlock( GMEM_MOVEABLE, table->module_start,
  61                                   table->module_end - table->module_start,
  62                                   0, FALSE, FALSE, FALSE, NULL );
  63     if (!hModule) return 0;
  64     FarSetOwner( hModule, hModule );
  65
  66     table->hModule = hModule;
  67
  68     dprintf_module( stddeb, "Built-in %s: hmodule=%04x\n",
  69                     table->name, hModule );
  70
  71     /* Allocate the code segment */
  72
  73     pModule = (NE_MODULE *)GlobalLock( hModule );
  74     pSegTable = NE_SEG_TABLE( pModule );
  75
  76     pSegTable->selector = GLOBAL_CreateBlock( GMEM_FIXED, table->code_start,
  77                                               pSegTable->minsize, hModule,
  78                                               TRUE, TRUE, FALSE, NULL );
  79     if (!pSegTable->selector) return 0;
  80     pSegTable++;
  81
  82     /* Allocate the data segment */
  83
  84     pSegTable->selector = GLOBAL_Alloc( GMEM_FIXED, pSegTable->minsize,
  85                                         hModule, FALSE, FALSE, FALSE );
  86     if (!pSegTable->selector) return 0;
  87     memcpy( GlobalLock( pSegTable->selector ),
  88             table->data_start, pSegTable->minsize );
  89
  90     pModule->next = hFirstModule;
  91     hFirstModule = hModule;
  92     return hModule;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           MODULE_Init
  98  *
  99  * Create the built-in modules.
 100  */
 101 BOOL MODULE_Init(void)
 102 {
 103     /* For these, built-in modules are always used */
 104
 105     if (!MODULE_LoadBuiltin( "KERNEL", TRUE ) ||
 106         !MODULE_LoadBuiltin( "GDI", TRUE ) ||
 107         !MODULE_LoadBuiltin( "USER", TRUE ) ||
 108         !MODULE_LoadBuiltin( "WINPROCS", TRUE )) return FALSE;
 109
 110 #else
 111     fprintf(stderr, "JBP: MODULE_Init() ignored.\n");
 112 #endif
 113     /* Initialize KERNEL.178 (__WINFLAGS) with the correct flags value */
 114
 115     MODULE_SetEntryPoint( GetModuleHandle( "KERNEL" ), 178, GetWinFlags() );
 116     return TRUE;
 117 }
 118
 119
 120 /***********************************************************************
 121  *           MODULE_PrintModule
 122  */
 123 void MODULE_PrintModule( HMODULE hmodule )
 124 {
 125     int i, ordinal;
 126     SEGTABLEENTRY *pSeg;
 127     BYTE *pstr;
 128     WORD *pword;
 129     NE_MODULE *pModule = (NE_MODULE *)GlobalLock( hmodule );
 130
 131       /* Dump the module info */
 132
 133     printf( "Module "NPFMT":\n", hmodule );
 134     printf( "count=%d flags=%04x heap=%d stack=%d\n",
 135             pModule->count, pModule->flags,
 136             pModule->heap_size, pModule->stack_size );
 137     printf( "cs:ip=%04x:%04x ss:sp=%04x:%04x ds=%04x nb seg=%d modrefs=%d\n",
 138            pModule->cs, pModule->ip, pModule->ss, pModule->sp, pModule->dgroup,
 139            pModule->seg_count, pModule->modref_count );
 140     printf( "os_flags=%d swap_area=%d version=%04x\n",
 141             pModule->os_flags, pModule->min_swap_area,
 142             pModule->expected_version );
 143
 144       /* Dump the file info */
 145
 146     printf( "Filename: '%s'\n",
 147          ((LOADEDFILEINFO *)((BYTE *)pModule + pModule->fileinfo))->filename );
 148
 149       /* Dump the segment table */
 150
 151     printf( "\nSegment table:\n" );
 152     pSeg = NE_SEG_TABLE( pModule );
 153     for (i = 0; i < pModule->seg_count; i++, pSeg++)
 154         printf( "%02x: pos=%d size=%d flags=%04x minsize=%d sel="NPFMT"\n",
 155                 i + 1, pSeg->filepos, pSeg->size, pSeg->flags,
 156                 pSeg->minsize, pSeg->selector );
 157
 158       /* Dump the resource table */
 159
 160     printf( "\nResource table:\n" );
 161     if (pModule->res_table)
 162     {
 163         pword = (WORD *)((BYTE *)pModule + pModule->res_table);
 164         printf( "Alignment: %d\n", *pword++ );
 165         while (*pword)
 166         {
 167             struct resource_typeinfo_s *ptr = (struct resource_typeinfo_s *)pword;
 168             struct resource_nameinfo_s *pname = (struct resource_nameinfo_s *)(ptr + 1);
 169             printf( "id=%04x count=%d\n", ptr->type_id, ptr->count );
 170             for (i = 0; i < ptr->count; i++, pname++)
 171                 printf( "offset=%d len=%d id=%04x\n",
 172                        pname->offset, pname->length, pname->id );
 173             pword = (WORD *)pname;
 174         }
 175     }
 176     else printf( "None\n" );
 177
 178       /* Dump the resident name table */
 179
 180     printf( "\nResident-name table:\n" );
 181     pstr = (char *)pModule + pModule->name_table;
 182     while (*pstr)
 183     {
 184         printf( "%*.*s: %d\n", *pstr, *pstr, pstr + 1,
 185                 *(WORD *)(pstr + *pstr + 1) );
 186         pstr += *pstr + 1 + sizeof(WORD);
 187     }
 188
 189       /* Dump the module reference table */
 190
 191     printf( "\nModule ref table:\n" );
 192     if (pModule->modref_table)
 193     {
 194         pword = (WORD *)((BYTE *)pModule + pModule->modref_table);
 195         for (i = 0; i < pModule->modref_count; i++, pword++)
 196         {
 197             char *name = (char *)pModule + pModule->import_table + *pword;
 198             printf( "%d: %04x -> '%*.*s'\n",
 199                     i, *pword, *name, *name, name + 1 );
 200         }
 201     }
 202     else printf( "None\n" );
 203
 204       /* Dump the entry table */
 205
 206     printf( "\nEntry table:\n" );
 207     pstr = (char *)pModule + pModule->entry_table;
 208     ordinal = 1;
 209     while (*pstr)
 210     {
 211         printf( "Bundle %d-%d: %02x\n", ordinal, ordinal + *pstr - 1, pstr[1]);
 212         if (!pstr[1])
 213         {
 214             ordinal += *pstr;
 215             pstr += 2;
 216         }
 217         else if ((BYTE)pstr[1] == 0xff)  /* moveable */
 218         {
 219             struct entry_tab_movable_s *pe = (struct entry_tab_movable_s*)(pstr+2);
 220             for (i = 0; i < *pstr; i++, pe++)
 221                 printf( "%d: %02x:%04x (moveable)\n",
 222                         ordinal++, pe->seg_number, pe->offset );
 223             pstr = (char *)pe;
 224         }
 225         else  /* fixed */
 226         {
 227             struct entry_tab_fixed_s *pe = (struct entry_tab_fixed_s*)(pstr+2);
 228             for (i = 0; i < *pstr; i++, pe++)
 229                 printf( "%d: %04x (fixed)\n",
 230                         ordinal++, pe->offset[0] + (pe->offset[1] << 8) );
 231             pstr = (char *)pe;
 232         }
 233     }
 234
 235     /* Dump the non-resident names table */
 236
 237     printf( "\nNon-resident names table:\n" );
 238     if (pModule->nrname_handle)
 239     {
 240         pstr = (char *)GlobalLock( pModule->nrname_handle );
 241         while (*pstr)
 242         {
 243             printf( "%*.*s: %d\n", *pstr, *pstr, pstr + 1,
 244                    *(WORD *)(pstr + *pstr + 1) );
 245             pstr += *pstr + 1 + sizeof(WORD);
 246         }
 247     }
 248     printf( "\n" );
 249 }
 250
 251
 252 /***********************************************************************
 253  *           MODULE_OpenFile
 254  */
 255 int MODULE_OpenFile( HMODULE hModule )
 256 {
 257     NE_MODULE *pModule;
 258     char *name;
 259
 260     static int cachedfd = -1;
 261
 262     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 263     dprintf_module( stddeb, "MODULE_OpenFile("NPFMT") cache: mod="NPFMT" fd=%d\n",
 264                     hModule, hCachedModule, cachedfd );
 265     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return -1;
 266     if (hCachedModule == hModule) return cachedfd;
 267     close( cachedfd );
 268     hCachedModule = hModule;
 269     name = ((LOADEDFILEINFO*)((char*)pModule + pModule->fileinfo))->filename;
 270     cachedfd = open( DOS_GetUnixFileName( name ), O_RDONLY );
 271     dprintf_module( stddeb, "MODULE_OpenFile: opened '%s' -> %d\n",
 272                     name, cachedfd );
 273     return cachedfd;
 274 }
 275 /***********************************************************************
 276  *           MODULE_Ne2MemFlags
 277  */
 278
 279 /* This function translates NE segment flags to GlobalAlloc flags */
 280
 281 static WORD MODULE_Ne2MemFlags(WORD flags)
 282 {
 283     WORD memflags = 0;
 284 #if 0
 285     if (flags & NE_SEGFLAGS_DISCARDABLE)
 286       memflags |= GMEM_DISCARDABLE;
 287     if (flags & NE_SEGFLAGS_MOVEABLE ||
 288         ( ! (flags & NE_SEGFLAGS_DATA) &&
 289           ! (flags & NE_SEGFLAGS_LOADED) &&
 290           ! (flags & NE_SEGFLAGS_ALLOCATED)
 291          )
 292         )
 293       memflags |= GMEM_MOVEABLE;
 294     memflags |= GMEM_ZEROINIT;
 295 #else
 296     memflags = GMEM_ZEROINIT | GMEM_FIXED;
 297     return memflags;
 298 #endif
 299 }
 300
 301 /***********************************************************************
 302  *           MODULE_AllocateSegment (WINPROCS.26)
 303  */
 304
 305 DWORD MODULE_AllocateSegment(WORD wFlags, WORD wSize, WORD wElem)
 306 {
 307     WORD size = wSize << wElem;
 308     HANDLE hMem = GlobalAlloc( MODULE_Ne2MemFlags(wFlags), size);
 309 #ifdef WINELIB32
 310     return (DWORD)GlobalLock(hMem);
 311 #else
 312     WORD selector = HIWORD(GlobalLock(hMem));
 313     return MAKELONG(hMem, selector);
 314 #endif
 315 }
 316
 317 /***********************************************************************
 318  *           MODULE_CreateSegments
 319  */
 320 static BOOL MODULE_CreateSegments( HMODULE hModule )
 321 {
 322     SEGTABLEENTRY *pSegment;
 323     NE_MODULE *pModule;
 324     int i, minsize;
 325
 326     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return FALSE;
 327     pSegment = NE_SEG_TABLE( pModule );
 328     for (i = 1; i <= pModule->seg_count; i++, pSegment++)
 329     {
 330         minsize = pSegment->minsize ? pSegment->minsize : 0x10000;
 331         if (i == pModule->ss) minsize += pModule->stack_size;
 332         /* The DGROUP is allocated by MODULE_CreateInstance */
 333         if (i == pModule->dgroup) continue;
 334         pSegment->selector = GLOBAL_Alloc( MODULE_Ne2MemFlags(pSegment->flags),
 335                                       minsize, hModule,
 336                                       !(pSegment->flags & NE_SEGFLAGS_DATA),
 337                                       FALSE,
 338                             FALSE /*pSegment->flags & NE_SEGFLAGS_READONLY*/ );
 339         if (!pSegment->selector) return FALSE;
 340     }
 341
 342     pModule->dgroup_entry = pModule->dgroup ? pModule->seg_table +
 343                             (pModule->dgroup - 1) * sizeof(SEGTABLEENTRY) : 0;
 344     return TRUE;
 345 }
 346
 347
 348 /***********************************************************************
 349  *           MODULE_GetInstance
 350  */
 351 static HINSTANCE MODULE_GetInstance( HMODULE hModule )
 352 {
 353     SEGTABLEENTRY *pSegment;
 354     NE_MODULE *pModule;
 355
 356     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
 357     if (pModule->dgroup == 0) return hModule;
 358
 359     pSegment = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
 360
 361     return pSegment->selector;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           MODULE_CreateInstance
 367  */
 368 HINSTANCE MODULE_CreateInstance( HMODULE hModule, LOADPARAMS *params )
 369 {
 370     SEGTABLEENTRY *pSegment;
 371     NE_MODULE *pModule;
 372     int minsize;
 373     HINSTANCE hNewInstance, hPrevInstance;
 374
 375     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
 376     if (pModule->dgroup == 0) return hModule;
 377
 378     pSegment = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
 379     hPrevInstance = pSegment->selector;
 380
 381       /* if it's a library, create a new instance only the first time */
 382     if (hPrevInstance)
 383     {
 384         if (pModule->flags & NE_FFLAGS_LIBMODULE) return hPrevInstance;
 385         if (params == (LOADPARAMS*)-1) return hPrevInstance;
 386     }
 387
 388     minsize = pSegment->minsize ? pSegment->minsize : 0x10000;
 389     if (pModule->ss == pModule->dgroup) minsize += pModule->stack_size;
 390     minsize += pModule->heap_size;
 391     hNewInstance = GLOBAL_Alloc( GMEM_ZEROINIT | GMEM_FIXED,
 392                                  minsize, hModule, FALSE, FALSE, FALSE );
 393     if (!hNewInstance) return 0;
 394     pSegment->selector = hNewInstance;
 395     return hNewInstance;
 396 }
 397
 398
 399 /***********************************************************************
 400  *           MODULE_LoadExeHeader
 401  */
 402 HMODULE MODULE_LoadExeHeader( int fd, OFSTRUCT *ofs )
 403 {
 404     struct mz_header_s mz_header;
 405     struct ne_header_s ne_header;
 406     int size;
 407     HMODULE hModule;
 408     NE_MODULE *pModule;
 409     BYTE *pData;
 410     char *buffer, *fastload = NULL;
 411     int fastload_offset = 0, fastload_length = 0;
 412
 413   /* Read a block from either the file or the fast-load area. */
 414 #define READ(offset,size,buffer) \
 415        ((fastload && ((offset) >= fastload_offset) && \
 416          ((offset)+(size) <= fastload_offset+fastload_length)) ? \
 417         (memcpy( buffer, fastload+(offset)-fastload_offset, (size) ), TRUE) : \
 418         (lseek( fd, mz_header.ne_offset+(offset), SEEK_SET), \
 419          read( fd, (buffer), (size) ) == (size)))
 420
 421     lseek( fd, 0, SEEK_SET );
 422     if ((read( fd, &mz_header, sizeof(mz_header) ) != sizeof(mz_header)) ||
 423         (mz_header.mz_magic != MZ_SIGNATURE)) return (HMODULE)11;  /* invalid exe */
 424
 425     lseek( fd, mz_header.ne_offset, SEEK_SET );
 426     if (read( fd, &ne_header, sizeof(ne_header) ) != sizeof(ne_header))
 427         return (HMODULE)11;  /* invalid exe */
 428
 429     if (ne_header.ne_magic == PE_SIGNATURE) return (HMODULE)21;  /* win32 exe */
 430     if (ne_header.ne_magic != NE_SIGNATURE) return (HMODULE)11;  /* invalid exe */
 431
 432     /* We now have a valid NE header */
 433
 434     size = sizeof(NE_MODULE) +
 435              /* loaded file info */
 436            sizeof(LOADEDFILEINFO) + strlen(ofs->szPathName) +
 437              /* segment table */
 438            ne_header.n_segment_tab * sizeof(SEGTABLEENTRY) +
 439              /* resource table */
 440            ne_header.rname_tab_offset - ne_header.resource_tab_offset +
 441              /* resident names table */
 442            ne_header.moduleref_tab_offset - ne_header.rname_tab_offset +
 443              /* module ref table */
 444            ne_header.n_mod_ref_tab * sizeof(WORD) +
 445              /* imported names table */
 446            ne_header.entry_tab_offset - ne_header.iname_tab_offset +
 447              /* entry table length */
 448            ne_header.entry_tab_length;
 449
 450     hModule = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
 451     if (!hModule) return (HMODULE)11;  /* invalid exe */
 452     FarSetOwner( hModule, hModule );
 453     pModule = (NE_MODULE *)GlobalLock( hModule );
 454     memcpy( pModule, &ne_header, sizeof(NE_MODULE) );
 455     pModule->count = 0;
 456     pData = (BYTE *)(pModule + 1);
 457
 458     /* Read the fast-load area */
 459
 460     if (ne_header.additional_flags & NE_AFLAGS_FASTLOAD)
 461     {
 462         fastload_offset=ne_header.fastload_offset<<ne_header.align_shift_count;
 463         fastload_length=ne_header.fastload_length<<ne_header.align_shift_count;
 464         dprintf_module( stddeb, "Using fast-load area offset=%x len=%d\n",
 465                         fastload_offset, fastload_length );
 466         if ((fastload = (char *)malloc( fastload_length )) != NULL)
 467         {
 468             lseek( fd, mz_header.ne_offset + fastload_offset, SEEK_SET );
 469             if (read( fd, fastload, fastload_length ) != fastload_length)
 470             {
 471                 free( fastload );
 472                 fastload = NULL;
 473             }
 474         }
 475     }
 476
 477     /* Store the filename information */
 478
 479     pModule->fileinfo = (int)pData - (int)pModule;
 480     ((LOADEDFILEINFO*)pData)->length = sizeof(LOADEDFILEINFO)+strlen(ofs->szPathName);
 481     ((LOADEDFILEINFO*)pData)->fixed_media = TRUE;
 482     ((LOADEDFILEINFO*)pData)->error = 0;
 483     ((LOADEDFILEINFO*)pData)->date = 0;
 484     ((LOADEDFILEINFO*)pData)->time = 0;
 485     strcpy( ((LOADEDFILEINFO*)pData)->filename, ofs->szPathName );
 486     pData += ((LOADEDFILEINFO*)pData)->length--;
 487
 488     /* Get the segment table */
 489
 490     pModule->seg_table = (int)pData - (int)pModule;
 491     buffer = malloc( ne_header.n_segment_tab * sizeof(struct ne_segment_table_entry_s) );
 492     if (buffer)
 493     {
 494         int i;
 495         struct ne_segment_table_entry_s *pSeg;
 496
 497         if (!READ( ne_header.segment_tab_offset,
 498              ne_header.n_segment_tab * sizeof(struct ne_segment_table_entry_s),
 499              buffer )) return (HMODULE)11;  /* invalid exe */
 500         pSeg = (struct ne_segment_table_entry_s *)buffer;
 501         for (i = ne_header.n_segment_tab; i > 0; i--, pSeg++)
 502         {
 503             memcpy( pData, pSeg, sizeof(*pSeg) );
 504             pData += sizeof(SEGTABLEENTRY);
 505         }
 506         free( buffer );
 507     }
 508     else return (HMODULE)11;  /* invalid exe */
 509
 510     /* Get the resource table */
 511
 512     if (ne_header.resource_tab_offset < ne_header.rname_tab_offset)
 513     {
 514         pModule->res_table = (int)pData - (int)pModule;
 515         if (!READ(ne_header.resource_tab_offset,
 516                   ne_header.rname_tab_offset - ne_header.resource_tab_offset,
 517                   pData )) return (HMODULE)11;  /* invalid exe */
 518         pData += ne_header.rname_tab_offset - ne_header.resource_tab_offset;
 519     }
 520     else pModule->res_table = 0;  /* No resource table */
 521
 522     /* Get the resident names table */
 523
 524     pModule->name_table = (int)pData - (int)pModule;
 525     if (!READ( ne_header.rname_tab_offset,
 526                ne_header.moduleref_tab_offset - ne_header.rname_tab_offset,
 527                pData )) return (HMODULE)11;  /* invalid exe */
 528     pData += ne_header.moduleref_tab_offset - ne_header.rname_tab_offset;
 529
 530     /* Get the module references table */
 531
 532     if (ne_header.n_mod_ref_tab > 0)
 533     {
 534         pModule->modref_table = (int)pData - (int)pModule;
 535         if (!READ( ne_header.moduleref_tab_offset,
 536                   ne_header.n_mod_ref_tab * sizeof(WORD),
 537                   pData )) return (HMODULE)11;  /* invalid exe */
 538         pData += ne_header.n_mod_ref_tab * sizeof(WORD);
 539     }
 540     else pModule->modref_table = 0;  /* No module references */
 541
 542     /* Get the imported names table */
 543
 544     pModule->import_table = (int)pData - (int)pModule;
 545     if (!READ( ne_header.iname_tab_offset,
 546                ne_header.entry_tab_offset - ne_header.iname_tab_offset,
 547                pData )) return (HMODULE)11;  /* invalid exe */
 548     pData += ne_header.entry_tab_offset - ne_header.iname_tab_offset;
 549
 550     /* Get the entry table */
 551
 552     pModule->entry_table = (int)pData - (int)pModule;
 553     if (!READ( ne_header.entry_tab_offset,
 554                ne_header.entry_tab_length,
 555                pData )) return (HMODULE)11;  /* invalid exe */
 556     pData += ne_header.entry_tab_length;
 557
 558     /* Get the non-resident names table */
 559
 560     if (ne_header.nrname_tab_length)
 561     {
 562         pModule->nrname_handle = GLOBAL_Alloc( 0, ne_header.nrname_tab_length,
 563                                                hModule, FALSE, FALSE, FALSE );
 564         if (!pModule->nrname_handle) return (HMODULE)11;  /* invalid exe */
 565         buffer = GlobalLock( pModule->nrname_handle );
 566         lseek( fd, ne_header.nrname_tab_offset, SEEK_SET );
 567         if (read( fd, buffer, ne_header.nrname_tab_length )
 568               != ne_header.nrname_tab_length) return (HMODULE)11;  /* invalid exe */
 569     }
 570     else pModule->nrname_handle = 0;
 571
 572     /* Allocate a segment for the implicitly-loaded DLLs */
 573
 574     if (pModule->modref_count)
 575     {
 576         pModule->dlls_to_init = GLOBAL_Alloc(GMEM_ZEROINIT,
 577                                     (pModule->modref_count+1)*sizeof(HMODULE),
 578                                     hModule, FALSE, FALSE, FALSE );
 579         if (!pModule->dlls_to_init) return (HMODULE)11;  /* invalid exe */
 580     }
 581     else pModule->dlls_to_init = 0;
 582
 583     if (debugging_module) MODULE_PrintModule( hModule );
 584     pModule->next = hFirstModule;
 585     hFirstModule = hModule;
 586     return hModule;
 587 }
 588
 589
 590 /***********************************************************************
 591  *           MODULE_GetOrdinal
 592  *
 593  * Lookup the ordinal for a given name.
 594  */
 595 WORD MODULE_GetOrdinal( HMODULE hModule, char *name )
 596 {
 597     char buffer[256], *cpnt;
 598     BYTE len;
 599     NE_MODULE *pModule;
 600
 601     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
 602
 603     dprintf_module( stddeb, "MODULE_GetOrdinal("NPFMT",'%s')\n",
 604                     hModule, name );
 605
 606       /* First handle names of the form '#xxxx' */
 607
 608     if (name[0] == '#') return atoi( name + 1 );
 609
 610       /* Now copy and uppercase the string */
 611
 612     strcpy( buffer, name );
 613     AnsiUpper( buffer );
 614     len = strlen( buffer );
 615
 616       /* First search the resident names */
 617
 618     cpnt = (char *)pModule + pModule->name_table;
 619
 620       /* Skip the first entry (module name) */
 621     cpnt += *cpnt + 1 + sizeof(WORD);
 622     while (*cpnt)
 623     {
 624         dprintf_module( stddeb, "  Checking '%*.*s'\n", *cpnt, *cpnt, cpnt+1 );
 625         if (((BYTE)*cpnt == len) && !memcmp( cpnt+1, buffer, len ))
 626         {
 627             dprintf_module( stddeb, "  Found: ordinal=%d\n",
 628                             *(WORD *)(cpnt + *cpnt + 1) );
 629             return *(WORD *)(cpnt + *cpnt + 1);
 630         }
 631         cpnt += *cpnt + 1 + sizeof(WORD);
 632     }
 633
 634       /* Now search the non-resident names table */
 635
 636     if (!pModule->nrname_handle) return 0;  /* No non-resident table */
 637     cpnt = (char *)GlobalLock( pModule->nrname_handle );
 638
 639       /* Skip the first entry (module description string) */
 640     cpnt += *cpnt + 1 + sizeof(WORD);
 641     while (*cpnt)
 642     {
 643         dprintf_module( stddeb, "  Checking '%*.*s'\n", *cpnt, *cpnt, cpnt+1 );
 644         if (((BYTE)*cpnt == len) && !memcmp( cpnt+1, buffer, len ))
 645         {
 646             dprintf_module( stddeb, "  Found: ordinal=%d\n",
 647                             *(WORD *)(cpnt + *cpnt + 1) );
 648             return *(WORD *)(cpnt + *cpnt + 1);
 649         }
 650         cpnt += *cpnt + 1 + sizeof(WORD);
 651     }
 652     return 0;
 653 }
 654
 655
 656 /***********************************************************************
 657  *           MODULE_GetEntryPoint
 658  *
 659  * Return the entry point for a given ordinal.
 660  */
 661 DWORD MODULE_GetEntryPoint( HMODULE hModule, WORD ordinal )
 662 {
 663     NE_MODULE *pModule;
 664     WORD curOrdinal = 1;
 665     BYTE *p;
 666     WORD sel, offset;
 667
 668     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
 669
 670     p = (BYTE *)pModule + pModule->entry_table;
 671     while (*p && (curOrdinal + *p <= ordinal))
 672     {
 673           /* Skipping this bundle */
 674         curOrdinal += *p;
 675         switch(p[1])
 676         {
 677             case 0:    p += 2; break;  /* unused */
 678             case 0xff: p += 2 + *p * 6; break;  /* moveable */
 679             default:   p += 2 + *p * 3; break;  /* fixed */
 680         }
 681     }
 682     if (!*p) return 0;
 683
 684     switch(p[1])
 685     {
 686         case 0:  /* unused */
 687             return 0;
 688         case 0xff:  /* moveable */
 689             p += 2 + 6 * (ordinal - curOrdinal);
 690             sel = p[3];
 691             offset = *(WORD *)(p + 4);
 692             break;
 693         default:  /* fixed */
 694             sel = p[1];
 695             p += 2 + 3 * (ordinal - curOrdinal);
 696             offset = *(WORD *)(p + 1);
 697             break;
 698     }
 699
 700     if (sel == 0xfe) sel = 0xffff;  /* constant entry */
 701     else sel = NE_SEG_TABLE(pModule)[sel-1].selector;
 702     return MAKELONG( offset, sel );
 703 }
 704
 705
 706 /***********************************************************************
 707  *           MODULE_SetEntryPoint
 708  *
 709  * Change the value of an entry point. Use with caution!
 710  * It can only change the offset value, not the selector.
 711  */
 712 BOOL MODULE_SetEntryPoint( HMODULE hModule, WORD ordinal, WORD offset )
 713 {
 714     NE_MODULE *pModule;
 715     WORD curOrdinal = 1;
 716     BYTE *p;
 717
 718     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return FALSE;
 719
 720     p = (BYTE *)pModule + pModule->entry_table;
 721     while (*p && (curOrdinal + *p <= ordinal))
 722     {
 723           /* Skipping this bundle */
 724         curOrdinal += *p;
 725         switch(p[1])
 726         {
 727             case 0:    p += 2; break;  /* unused */
 728             case 0xff: p += 2 + *p * 6; break;  /* moveable */
 729             default:   p += 2 + *p * 3; break;  /* fixed */
 730         }
 731     }
 732     if (!*p) return FALSE;
 733
 734     switch(p[1])
 735     {
 736         case 0:  /* unused */
 737             return FALSE;
 738         case 0xff:  /* moveable */
 739             p += 2 + 6 * (ordinal - curOrdinal);
 740             *(WORD *)(p + 4) = offset;
 741             break;
 742         default:  /* fixed */
 743             p += 2 + 3 * (ordinal - curOrdinal);
 744             *(WORD *)(p + 1) = offset;
 745             break;
 746     }
 747     return TRUE;
 748 }
 749
 750
 751 /***********************************************************************
 752  *           MODULE_GetEntryPointName
 753  *
 754  * Return the entry point name for a given ordinal.
 755  * Used only by relay debugging.
 756  * Warning: returned pointer is to a Pascal-type string.
 757  */
 758 LPSTR MODULE_GetEntryPointName( HMODULE hModule, WORD ordinal )
 759 {
 760     register char *cpnt;
 761     NE_MODULE *pModule;
 762
 763     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
 764
 765       /* First search the resident names */
 766
 767     cpnt = (char *)pModule + pModule->name_table;
 768     while (*cpnt)
 769     {
 770         cpnt += *cpnt + 1 + sizeof(WORD);
 771         if (*(WORD *)(cpnt + *cpnt + 1) == ordinal) return cpnt;
 772     }
 773
 774       /* Now search the non-resident names table */
 775
 776     if (!pModule->nrname_handle) return 0;  /* No non-resident table */
 777     cpnt = (char *)GlobalLock( pModule->nrname_handle );
 778     while (*cpnt)
 779     {
 780         cpnt += *cpnt + 1 + sizeof(WORD);
 781         if (*(WORD *)(cpnt + *cpnt + 1) == ordinal) return cpnt;
 782     }
 783     return NULL;
 784 }
 785
 786
 787 /***********************************************************************
 788  *           MODULE_GetModuleName
 789  */
 790 LPSTR MODULE_GetModuleName( HMODULE hModule )
 791 {
 792     NE_MODULE *pModule;
 793     BYTE *p, len;
 794     static char buffer[10];
 795
 796     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return NULL;
 797     p = (BYTE *)pModule + pModule->name_table;
 798     len = min( *p, 8 );
 799     memcpy( buffer, p + 1, len );
 800     buffer[len] = '\0';
 801     return buffer;
 802 }
 803
 804
 805 /**********************************************************************
 806  *          MODULE_FindModule
 807  *
 808  * Find a module from a path name.
 809  */
 810 HMODULE MODULE_FindModule( LPCSTR path )
 811 {
 812     HMODULE hModule = hFirstModule;
 813     LPCSTR filename, dotptr, modulepath, modulename;
 814     BYTE len, *name_table;
 815
 816     if (!(filename = strrchr( path, '\\' ))) filename = path;
 817     else filename++;
 818     if ((dotptr = strrchr( filename, '.' )) != NULL)
 819         len = (BYTE)(dotptr - filename);
 820     else len = strlen( filename );
 821
 822     while(hModule)
 823     {
 824         NE_MODULE *pModule = (NE_MODULE *)GlobalLock( hModule );
 825         if (!pModule) break;
 826         modulepath = ((LOADEDFILEINFO*)((char*)pModule + pModule->fileinfo))->filename;
 827         if (!(modulename = strrchr( modulepath, '\\' )))
 828             modulename = modulepath;
 829         else modulename++;
 830         if (!strcasecmp( modulename, filename )) return hModule;
 831
 832         name_table = (BYTE *)pModule + pModule->name_table;
 833         if ((*name_table == len) && !strncasecmp(filename, name_table+1, len))
 834             return hModule;
 835         hModule = pModule->next;
 836     }
 837     return 0;
 838 }
 839
 840
 841 /**********************************************************************
 842  *          MODULE_FreeModule
 843  *
 844  * Remove a module from memory.
 845  */
 846 static void MODULE_FreeModule( HMODULE hModule )
 847 {
 848     HMODULE *hPrevModule;
 849     NE_MODULE *pModule;
 850     SEGTABLEENTRY *pSegment;
 851     HMODULE *pModRef;
 852     int i;
 853
 854     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return;
 855     if (pModule->flags & NE_FFLAGS_BUILTIN)
 856         return;  /* Can't free built-in module */
 857
 858     /* FIXME: should call the exit code for the library here */
 859
 860       /* Remove it from the linked list */
 861
 862     hPrevModule = &hFirstModule;
 863     while (*hPrevModule && (*hPrevModule != hModule))
 864     {
 865         hPrevModule = &((NE_MODULE *)GlobalLock( *hPrevModule ))->next;
 866     }
 867     if (*hPrevModule) *hPrevModule = pModule->next;
 868
 869       /* Free all the segments */
 870
 871     pSegment = NE_SEG_TABLE( pModule );
 872     for (i = 1; i <= pModule->seg_count; i++, pSegment++)
 873     {
 874         GlobalFree( pSegment->selector );
 875     }
 876
 877       /* Free the referenced modules */
 878
 879     pModRef = NE_MODULE_TABLE( pModule );
 880     for (i = 0; i < pModule->modref_count; i++, pModRef++)
 881     {
 882         FreeModule( *pModRef );
 883     }
 884
 885       /* Free the module storage */
 886
 887     if (pModule->nrname_handle) GlobalFree( pModule->nrname_handle );
 888     if (pModule->dlls_to_init) GlobalFree( pModule->dlls_to_init );
 889     GlobalFree( hModule );
 890
 891       /* Remove module from cache */
 892
 893     if (hCachedModule == hModule) hCachedModule = 0;
 894 }
 895
 896
 897 HINSTANCE PE_LoadModule(int fd, OFSTRUCT *ofs, LOADPARAMS* params);
 898
 899 /**********************************************************************
 900  *          LoadModule    (KERNEL.45)
 901  */
 902 HINSTANCE LoadModule( LPCSTR name, LPVOID paramBlock )
 903 {
 904     HMODULE hModule;
 905     HANDLE hInstance, hPrevInstance;
 906     NE_MODULE *pModule;
 907     LOADPARAMS *params = (LOADPARAMS *)paramBlock;
 908 #ifndef WINELIB /* JBP: Disabled for now in winelib.a */
 909     WORD *pModRef, *pDLLs;
 910     int i, fd;
 911
 912     hModule = MODULE_FindModule( name );
 913
 914     if (!hModule)  /* We have to load the module */
 915     {
 916         OFSTRUCT ofs;
 917
 918         /* Try to load the built-in first if not disabled */
 919         if ((hModule = MODULE_LoadBuiltin( name, FALSE ))) return hModule;
 920
 921         if (strchr( name, '/' )) name = DOS_GetDosFileName( name );
 922         if ((fd = OpenFile( name, &ofs, OF_READ )) == -1)
 923         {
 924             /* Now try the built-in even if disabled */
 925             if ((hModule = MODULE_LoadBuiltin( name, TRUE )))
 926             {
 927                 fprintf( stderr, "Warning: could not load Windows DLL '%s', using built-in module.\n", name );
 928                 return hModule;
 929             }
 930             return 2;  /* File not found */
 931         }
 932
 933           /* Create the module structure */
 934
 935         if ((hModule = MODULE_LoadExeHeader( fd, &ofs )) < 32)
 936         {
 937                         if(hModule == 21)
 938                                 return PE_LoadModule(fd,&ofs,paramBlock);
 939             close( fd );
 940             fprintf( stderr, "LoadModule: can't load '%s', error=%d\n",
 941                      name, hModule );
 942             return hModule;
 943         }
 944         pModule = (NE_MODULE *)GlobalLock( hModule );
 945
 946           /* Allocate the segments for this module */
 947
 948         MODULE_CreateSegments( hModule );
 949
 950         hPrevInstance = 0;
 951         hInstance = MODULE_CreateInstance( hModule, (LOADPARAMS*)paramBlock );
 952
 953           /* Load the referenced DLLs */
 954
 955         pModRef = (WORD *)((char *)pModule + pModule->modref_table);
 956         pDLLs = (WORD *)GlobalLock( pModule->dlls_to_init );
 957         for (i = 0; i < pModule->modref_count; i++, pModRef++)
 958         {
 959             char buffer[256];
 960             BYTE *pstr = (BYTE *)pModule + pModule->import_table + *pModRef;
 961             memcpy( buffer, pstr + 1, *pstr );
 962             strcpy( buffer + *pstr, ".dll" );
 963             dprintf_module( stddeb, "Loading '%s'\n", buffer );
 964             if (!(*pModRef = MODULE_FindModule( buffer )))
 965             {
 966                 /* If the DLL is not loaded yet, load it and store */
 967                 /* its handle in the list of DLLs to initialize.   */
 968                 HMODULE hDLL;
 969
 970                 if ((hDLL = LoadModule( buffer, (LPVOID)-1 )) == 2)  /* file not found */
 971                 {
 972                     char *p;
 973
 974                     /* Try with prepending the path of the current module */
 975                     GetModuleFileName( hModule, buffer, 256 );
 976                     if (!(p = strrchr( buffer, '\\' ))) p = buffer;
 977                     memcpy( p + 1, pstr + 1, *pstr );
 978                     strcpy( p + 1 + *pstr, ".dll" );
 979                     hDLL = LoadModule( buffer, (LPVOID)-1 );
 980                 }
 981                 if (hDLL < 32)
 982                 {
 983                     fprintf( stderr, "Could not load '%s' required by '%s', error = %d\n",
 984                              buffer, name, hDLL );
 985                     return 2;  /* file not found */
 986                 }
 987                 *pModRef = GetExePtr( hDLL );
 988                 *pDLLs++ = *pModRef;
 989             }
 990             else  /* Increment the reference count of the DLL */
 991             {
 992                 NE_MODULE *pOldDLL = (NE_MODULE *)GlobalLock( *pModRef );
 993                 if (pOldDLL) pOldDLL->count++;
 994             }
 995         }
 996
 997           /* Load the segments */
 998
 999         if (pModule->flags & NE_FFLAGS_SELFLOAD)
1000         {
1001                 /* Handle self loading modules */
1002                 SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
1003                 SELFLOADHEADER *selfloadheader;
1004                 HMODULE hselfload = GetModuleHandle("WINPROCS");
1005                 WORD oldss, oldsp, saved_dgroup = pSegTable[pModule->dgroup - 1].selector;
1006                 fprintf (stderr, "Warning:  %*.*s is a self-loading module\n"
1007                                 "Support for self-loading modules is very experimental\n",
1008                 *((BYTE*)pModule + pModule->name_table),
1009                 *((BYTE*)pModule + pModule->name_table),
1010                 (char *)pModule + pModule->name_table + 1);
1011                 NE_LoadSegment( hModule, 1 );
1012                 selfloadheader = (SELFLOADHEADER *)
1013                         PTR_SEG_OFF_TO_LIN(pSegTable->selector, 0);
1014                 selfloadheader->EntryAddrProc =
1015                                            MODULE_GetEntryPoint(hselfload,27);
1016                 selfloadheader->MyAlloc  = MODULE_GetEntryPoint(hselfload,28);
1017                 selfloadheader->SetOwner = MODULE_GetEntryPoint(GetModuleHandle("KERNEL"),403);
1018                 pModule->self_loading_sel = GlobalHandleToSel(
1019                                         GLOBAL_Alloc (GMEM_ZEROINIT,
1020                                         0xFF00, hModule, FALSE, FALSE, FALSE)
1021                                         );
1022                 oldss = IF1632_Saved16_ss;
1023                 oldsp = IF1632_Saved16_sp;
1024                 IF1632_Saved16_ss = pModule->self_loading_sel;
1025                 IF1632_Saved16_sp = 0xFF00;
1026                 CallTo16_word_ww (selfloadheader->BootApp,
1027                         pModule->self_loading_sel, hModule, fd);
1028                 /* some BootApp procs overwrite the selector of dgroup */
1029                 pSegTable[pModule->dgroup - 1].selector = saved_dgroup;
1030                 IF1632_Saved16_ss = oldss;
1031                 IF1632_Saved16_sp = oldsp;
1032                 for (i = 2; i <= pModule->seg_count; i++) NE_LoadSegment( hModule, i );
1033         }
1034         else
1035         {
1036             for (i = 1; i <= pModule->seg_count; i++)
1037                 NE_LoadSegment( hModule, i );
1038         }
1039
1040           /* Fixup the functions prologs */
1041
1042         NE_FixupPrologs( hModule );
1043
1044           /* Make sure the usage count is 1 on the first loading of  */
1045           /* the module, even if it contains circular DLL references */
1046
1047         pModule->count = 1;
1048
1049           /* Clear built-in flag in case it was set in the EXE file */
1050
1051         pModule->flags &= ~NE_FFLAGS_BUILTIN;
1052     }
1053     else
1054     {
1055         pModule = (NE_MODULE *)GlobalLock( hModule );
1056         hPrevInstance = MODULE_GetInstance( hModule );
1057         hInstance = MODULE_CreateInstance( hModule, params );
1058         if (hInstance != hPrevInstance)  /* not a library */
1059             NE_LoadSegment( hModule, pModule->dgroup );
1060         pModule->count++;
1061     }
1062 #else
1063     hModule = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(NE_MODULE) );
1064     pModule = (NE_MODULE *)GlobalLock( hModule );
1065     pModule->count = 1;
1066     pModule->magic = 0x454e;
1067     hPrevInstance = 0;
1068     hInstance = MODULE_CreateInstance( hModule, (LOADPARAMS*)paramBlock );
1069 #endif /* WINELIB */
1070
1071       /* Create a task for this instance */
1072
1073     if (!(pModule->flags & NE_FFLAGS_LIBMODULE) && (paramBlock != (LPVOID)-1))
1074     {
1075         TASK_CreateTask( hModule, hInstance, hPrevInstance,
1076                          params->hEnvironment,
1077                          (LPSTR)PTR_SEG_TO_LIN( params->cmdLine ),
1078                          *((WORD *)PTR_SEG_TO_LIN(params->showCmd)+1) );
1079     }
1080
1081     return hInstance;
1082 }
1083
1084
1085 /**********************************************************************
1086  *          FreeModule    (KERNEL.46)
1087  */
1088 BOOL FreeModule( HANDLE hModule )
1089 {
1090     NE_MODULE *pModule;
1091
1092     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
1093     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return FALSE;
1094
1095     dprintf_module( stddeb, "FreeModule: %s count %d\n",
1096                     MODULE_GetModuleName(hModule), pModule->count );
1097     if (--pModule->count == 0) MODULE_FreeModule( hModule );
1098     return TRUE;
1099 }
1100
1101
1102 /**********************************************************************
1103  *          GetModuleHandle    (KERNEL.47)
1104  */
1105 HMODULE WIN16_GetModuleHandle( SEGPTR name )
1106 {
1107 #ifdef WINELIB32
1108     if (HIWORD(name) == 0) return GetExePtr( name );
1109 #else
1110     if (HIWORD(name) == 0) return GetExePtr( LOWORD(name) );
1111 #endif
1112     return MODULE_FindModule( PTR_SEG_TO_LIN(name) );
1113 }
1114
1115 HMODULE GetModuleHandle( LPCSTR name )
1116 {
1117     return MODULE_FindModule( name );
1118 }
1119
1120
1121 /**********************************************************************
1122  *          GetModuleUsage    (KERNEL.48)
1123  */
1124 int GetModuleUsage( HANDLE hModule )
1125 {
1126     NE_MODULE *pModule;
1127
1128     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
1129     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
1130     dprintf_module( stddeb, "GetModuleUsage("NPFMT"): returning %d\n",
1131                     hModule, pModule->count );
1132     return pModule->count;
1133 }
1134
1135
1136 /**********************************************************************
1137  *          GetModuleFileName    (KERNEL.49)
1138  */
1139 int GetModuleFileName( HANDLE hModule, LPSTR lpFileName, short nSize )
1140 {
1141     NE_MODULE *pModule;
1142     char *name;
1143
1144     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
1145     if (!(pModule = (NE_MODULE *)GlobalLock( hModule ))) return 0;
1146     name = ((LOADEDFILEINFO*)((char*)pModule + pModule->fileinfo))->filename;
1147     strncpy( lpFileName, name, nSize );
1148     lpFileName[nSize-1] = '\0';
1149     dprintf_module( stddeb, "GetModuleFilename: %s\n", lpFileName );
1150     return strlen(lpFileName);
1151 }
1152
1153
1154 /***********************************************************************
1155  *           LoadLibrary   (KERNEL.95)
1156  */
1157 HANDLE LoadLibrary( LPCSTR libname )
1158 {
1159     HANDLE handle;
1160
1161     dprintf_module( stddeb, "LoadLibrary: (%08x) %s\n", (int)libname, libname);
1162     /* This does not increment the module reference count, and will
1163      * therefore cause crashes on FreeLibrary calls.
1164     if ((handle = MODULE_FindModule( libname )) != 0) return handle;
1165      */
1166     handle = LoadModule( libname, (LPVOID)-1 );
1167     if (handle == (HANDLE)2)  /* file not found */
1168     {
1169         char buffer[256];
1170         strcpy( buffer, libname );
1171         strcat( buffer, ".dll" );
1172         handle = LoadModule( buffer, (LPVOID)-1 );
1173     }
1174     if (handle >= (HANDLE)32) NE_InitializeDLLs( GetExePtr(handle) );
1175     return handle;
1176 }
1177
1178
1179 /***********************************************************************
1180  *           FreeLibrary   (KERNEL.96)
1181  */
1182 void FreeLibrary( HANDLE handle )
1183 {
1184     dprintf_module( stddeb,"FreeLibrary: "NPFMT"\n", handle );
1185     FreeModule( handle );
1186 }
1187
1188
1189 /***********************************************************************
1190  *           WinExec   (KERNEL.166)
1191  */
1192 HANDLE WinExec( LPSTR lpCmdLine, WORD nCmdShow )
1193 {
1194     LOADPARAMS params;
1195     HLOCAL cmdShowHandle, cmdLineHandle;
1196     HANDLE handle;
1197     WORD *cmdShowPtr;
1198     char *p, *cmdline, filename[256];
1199
1200     if (!(cmdShowHandle = GlobalAlloc( 0, 2 * sizeof(WORD) ))) return 0;
1201     if (!(cmdLineHandle = GlobalAlloc( 0, 256 ))) return 0;
1202
1203       /* Store nCmdShow */
1204
1205     cmdShowPtr = (WORD *)GlobalLock( cmdShowHandle );
1206     cmdShowPtr[0] = 2;
1207     cmdShowPtr[1] = nCmdShow;
1208
1209       /* Build the filename and command-line */
1210
1211     cmdline = (char *)GlobalLock( cmdLineHandle );
1212     strncpy( filename, lpCmdLine, 256 );
1213     filename[255] = '\0';
1214     for (p = filename; *p && (*p != ' ') && (*p != '\t'); p++);
1215     if (*p)
1216     {
1217         strncpy( cmdline, p + 1, 128 );
1218         cmdline[127] = '\0';
1219     }
1220     else cmdline[0] = '\0';
1221     *p = '\0';
1222
1223       /* Now load the executable file */
1224
1225     params.hEnvironment = (HANDLE)SELECTOROF( GetDOSEnvironment() );
1226     params.cmdLine  = (SEGPTR)WIN16_GlobalLock( cmdLineHandle );
1227     params.showCmd  = (SEGPTR)WIN16_GlobalLock( cmdShowHandle );
1228     params.reserved = 0;
1229     handle = LoadModule( filename, &params );
1230     if (handle == (HANDLE)2)  /* file not found */
1231     {
1232         strcat( filename, ".exe" );
1233         handle = LoadModule( filename, &params );
1234     }
1235
1236     GlobalFree( cmdShowHandle );
1237     GlobalFree( cmdLineHandle );
1238     Yield();    /* program is executed immediatly ....needed for word */
1239     return handle;
1240 }
1241
1242
1243 /***********************************************************************
1244  *           GetProcAddress   (KERNEL.50)
1245  */
1246 FARPROC GetProcAddress( HANDLE hModule, SEGPTR name )
1247 {
1248     WORD ordinal;
1249     SEGPTR ret;
1250
1251     if (!hModule) hModule = GetCurrentTask();
1252     hModule = GetExePtr( hModule );
1253
1254     if (HIWORD(name) != 0)
1255     {
1256         ordinal = MODULE_GetOrdinal( hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
1257         dprintf_module( stddeb, "GetProcAddress: "NPFMT" '%s'\n",
1258                         hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
1259     }
1260     else
1261     {
1262         ordinal = LOWORD(name);
1263         dprintf_module( stddeb, "GetProcAddress: "NPFMT" %04x\n",
1264                         hModule, ordinal );
1265     }
1266     if (!ordinal) return (FARPROC)0;
1267
1268     ret = MODULE_GetEntryPoint( hModule, ordinal );
1269
1270     dprintf_module( stddeb, "GetProcAddress: returning %08lx\n", ret );
1271     return (FARPROC)ret;
1272 }
1273
1274
1275 #ifndef WINELIB
1276 /***********************************************************************
1277  *           GetWndProcEntry16 (not a Windows API function)
1278  *
1279  * Return an entry point from the WINPROCS dll.
1280  */
1281 WNDPROC GetWndProcEntry16( char *name )
1282 {
1283     WORD ordinal;
1284     static HMODULE hModule = 0;
1285
1286     if (!hModule) hModule = GetModuleHandle( "WINPROCS" );
1287     ordinal = MODULE_GetOrdinal( hModule, name );
1288     return MODULE_GetEntryPoint( hModule, ordinal );
1289 }
1290 #endif
1291
1292
1293 /**********************************************************************
1294  *          ModuleFirst    (TOOLHELP.59)
1295  */
1296 BOOL ModuleFirst( MODULEENTRY *lpme )
1297 {
1298     lpme->wNext = hFirstModule;
1299     return ModuleNext( lpme );
1300 }
1301
1302
1303 /**********************************************************************
1304  *          ModuleNext    (TOOLHELP.60)
1305  */
1306 BOOL ModuleNext( MODULEENTRY *lpme )
1307 {
1308     NE_MODULE *pModule;
1309
1310     if (!lpme->wNext) return FALSE;
1311     if (!(pModule = (NE_MODULE *)GlobalLock( lpme->wNext ))) return FALSE;
1312     strncpy( lpme->szModule, (char *)pModule + pModule->name_table,
1313              MAX_MODULE_NAME );
1314     lpme->szModule[MAX_MODULE_NAME] = '\0';
1315     lpme->hModule = lpme->wNext;
1316     lpme->wcUsage = pModule->count;
1317     strncpy( lpme->szExePath,
1318              ((LOADEDFILEINFO*)((char*)pModule + pModule->fileinfo))->filename,
1319              MAX_PATH );
1320     lpme->szExePath[MAX_PATH] = '\0';
1321     lpme->wNext = pModule->next;
1322     return TRUE;
1323 }
1324
1325
1326 /**********************************************************************
1327  *          ModuleFindName    (TOOLHELP.61)
1328  */
1329 BOOL ModuleFindName( MODULEENTRY *lpme, LPCSTR name )
1330 {
1331     lpme->wNext = GetModuleHandle( name );
1332     return ModuleNext( lpme );
1333 }
1334
1335
1336 /**********************************************************************
1337  *          ModuleFindHandle    (TOOLHELP.62)
1338  */
1339 BOOL ModuleFindHandle( MODULEENTRY *lpme, HMODULE hModule )
1340 {
1341     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
1342     lpme->wNext = hModule;
1343     return ModuleNext( lpme );
1344 }