loader/module.c

   1 /*
   2  * Modules
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <fcntl.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <sys/types.h>
  13 #include <unistd.h>
  14 #include "windows.h"
  15 #include "class.h"
  16 #include "file.h"
  17 #include "global.h"
  18 #include "heap.h"
  19 #include "module.h"
  20 #include "neexe.h"
  21 #include "pe_image.h"
  22 #include "process.h"
  23 #include "thread.h"
  24 #include "resource.h"
  25 #include "selectors.h"
  26 #include "stackframe.h"
  27 #include "task.h"
  28 #include "debug.h"
  29 #include "callback.h"
  30
  31 extern BOOL32 THREAD_InitDone;
  32
  33
  34 /*************************************************************************
  35  *              MODULE32_LookupHMODULE
  36  * looks for the referenced HMODULE in the current process
  37  */
  38 WINE_MODREF*
  39 MODULE32_LookupHMODULE(PDB32 *process,HMODULE32 hmod) {
  40     WINE_MODREF *wm;
  41
  42     if (!hmod)
  43         return process->exe_modref;
  44     if (!HIWORD(hmod)) {
  45         ERR(module,"tried to lookup 0x%04x in win32 module handler!\n",hmod);
  46         return NULL;
  47     }
  48     for (wm = process->modref_list;wm;wm=wm->next)
  49         if (wm->module == hmod)
  50             return wm;
  51     return NULL;
  52 }
  53
  54
  55 /***********************************************************************
  56  *           MODULE_CreateDummyModule
  57  *
  58  * Create a dummy NE module for Win32 or Winelib.
  59  */
  60 HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs )
  61 {
  62     HMODULE32 hModule;
  63     NE_MODULE *pModule;
  64     SEGTABLEENTRY *pSegment;
  65     char *pStr,*s;
  66     int len;
  67     const char* basename;
  68
  69     INT32 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
  70                     + strlen(ofs->szPathName) + 1;
  71     INT32 size = sizeof(NE_MODULE) +
  72                  /* loaded file info */
  73                  of_size +
  74                  /* segment table: DS,CS */
  75                  2 * sizeof(SEGTABLEENTRY) +
  76                  /* name table */
  77                  9 +
  78                  /* several empty tables */
  79                  8;
  80
  81     hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
  82     if (!hModule) return (HMODULE32)11;  /* invalid exe */
  83
  84     FarSetOwner( hModule, hModule );
  85     pModule = (NE_MODULE *)GlobalLock16( hModule );
  86
  87     /* Set all used entries */
  88     pModule->magic            = IMAGE_OS2_SIGNATURE;
  89     pModule->count            = 1;
  90     pModule->next             = 0;
  91     pModule->flags            = 0;
  92     pModule->dgroup           = 1;
  93     pModule->ss               = 1;
  94     pModule->cs               = 2;
  95     pModule->heap_size        = 0xe000;
  96     pModule->stack_size       = 0x1000;
  97     pModule->seg_count        = 2;
  98     pModule->modref_count     = 0;
  99     pModule->nrname_size      = 0;
 100     pModule->fileinfo         = sizeof(NE_MODULE);
 101     pModule->os_flags         = NE_OSFLAGS_WINDOWS;
 102     pModule->expected_version = 0x030a;
 103     pModule->self             = hModule;
 104
 105     /* Set loaded file information */
 106     memcpy( pModule + 1, ofs, of_size );
 107     ((OFSTRUCT *)(pModule+1))->cBytes = of_size - 1;
 108
 109     pSegment = (SEGTABLEENTRY*)((char*)(pModule + 1) + of_size);
 110     pModule->seg_table = pModule->dgroup_entry = (int)pSegment - (int)pModule;
 111     /* Data segment */
 112     pSegment->size    = 0;
 113     pSegment->flags   = NE_SEGFLAGS_DATA;
 114     pSegment->minsize = 0x1000;
 115     pSegment++;
 116     /* Code segment */
 117     pSegment->flags   = 0;
 118     pSegment++;
 119
 120     /* Module name */
 121     pStr = (char *)pSegment;
 122     pModule->name_table = (int)pStr - (int)pModule;
 123     basename = strrchr(ofs->szPathName,'\\');
 124     if (!basename) basename = ofs->szPathName;
 125     else basename++;
 126     len = strlen(basename);
 127     if ((s = strchr(basename,'.'))) len = s - basename;
 128     if (len > 8) len = 8;
 129     *pStr = len;
 130     strncpy( pStr+1, basename, len );
 131     if (len < 8) pStr[len+1] = 0;
 132     pStr += 9;
 133
 134     /* All tables zero terminated */
 135     pModule->res_table = pModule->import_table = pModule->entry_table =
 136                 (int)pStr - (int)pModule;
 137
 138     NE_RegisterModule( pModule );
 139     return hModule;
 140 }
 141
 142
 143 /***********************************************************************
 144  *           MODULE_GetWndProcEntry16  (not a Windows API function)
 145  *
 146  * Return an entry point from the WPROCS dll.
 147  */
 148 FARPROC16 MODULE_GetWndProcEntry16( LPCSTR name )
 149 {
 150     FARPROC16 ret = NULL;
 151
 152     if (__winelib)
 153     {
 154         /* FIXME: hack for Winelib */
 155         extern LRESULT ColorDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 156         extern LRESULT FileOpenDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 157         extern LRESULT FileSaveDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 158         extern LRESULT FindTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
 159         extern LRESULT PrintDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 160         extern LRESULT PrintSetupDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 161         extern LRESULT ReplaceTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
 162
 163         if (!strcmp(name,"ColorDlgProc"))
 164             return (FARPROC16)ColorDlgProc;
 165         if (!strcmp(name,"FileOpenDlgProc"))
 166             return (FARPROC16)FileOpenDlgProc;
 167         if (!strcmp(name,"FileSaveDlgProc"))
 168             return (FARPROC16)FileSaveDlgProc;
 169         if (!strcmp(name,"FindTextDlgProc"))
 170             return (FARPROC16)FindTextDlgProc16;
 171         if (!strcmp(name,"PrintDlgProc"))
 172             return (FARPROC16)PrintDlgProc;
 173         if (!strcmp(name,"PrintSetupDlgProc"))
 174             return (FARPROC16)PrintSetupDlgProc;
 175         if (!strcmp(name,"ReplaceTextDlgProc"))
 176             return (FARPROC16)ReplaceTextDlgProc16;
 177         WARN(module,"No mapping for %s(), add one in library/miscstubs.c\n",name);
 178         assert( FALSE );
 179         return NULL;
 180     }
 181     else
 182     {
 183         WORD ordinal;
 184         static HMODULE32 hModule = 0;
 185
 186         if (!hModule) hModule = GetModuleHandle16( "WPROCS" );
 187         ordinal = NE_GetOrdinal( hModule, name );
 188         if (!(ret = NE_GetEntryPoint( hModule, ordinal )))
 189         {
 190             WARN( module, "%s not found\n", name );
 191             assert( FALSE );
 192         }
 193     }
 194     return ret;
 195 }
 196
 197
 198 /**********************************************************************
 199  *          MODULE_FindModule32
 200  *
 201  * Find a (loaded) win32 module depending on path
 202  * The handling of '.' is a bit weird, but we need it that way,
 203  * for sometimes the programs use '<name>.exe' and '<name>.dll' and
 204  * this is the only way to differentiate. (mainly hypertrm.exe)
 205  *
 206  * RETURNS
 207  *      the module handle if found
 208  *      0 if not
 209  */
 210 HMODULE32 MODULE_FindModule32(
 211         PDB32* process, /* [in] process in which to find the library */
 212         LPCSTR path     /* [in] pathname of module/library to be found */
 213 ) {
 214     LPSTR       filename;
 215     LPSTR       dotptr;
 216     WINE_MODREF *wm;
 217
 218     if (!(filename = strrchr( path, '\\' )))
 219         filename = HEAP_strdupA(process->heap,0,path);
 220     else
 221         filename = HEAP_strdupA(process->heap,0,filename+1);
 222     dotptr=strrchr(filename,'.');
 223
 224     if (!process) {
 225         HeapFree(process->heap,0,filename);
 226         return 0;
 227     }
 228     for (wm=process->modref_list;wm;wm=wm->next) {
 229         LPSTR   xmodname,xdotptr;
 230
 231         assert (wm->modname);
 232         xmodname = HEAP_strdupA(process->heap,0,wm->modname);
 233         xdotptr=strrchr(xmodname,'.');
 234         if (    (xdotptr && !dotptr) ||
 235                 (!xdotptr && dotptr)
 236         ) {
 237             if (dotptr) *dotptr         = '\0';
 238             if (xdotptr) *xdotptr       = '\0';
 239         }
 240         if (!lstrcmpi32A( filename, xmodname)) {
 241             HeapFree(process->heap,0,filename);
 242             HeapFree(process->heap,0,xmodname);
 243             return wm->module;
 244         }
 245         if (dotptr) *dotptr='.';
 246         /* FIXME: add paths, shortname */
 247         HeapFree(process->heap,0,xmodname);
 248     }
 249     HeapFree(process->heap,0,filename);
 250     return 0;
 251 }
 252
 253
 254
 255 /**********************************************************************
 256  *          MODULE_Load
 257  *
 258  * Implementation of LoadModule().
 259  *
 260  * cmd_line must contain the whole command-line, including argv[0] (and
 261  * without a preceding length byte).
 262  * If cmd_line is NULL, the module is loaded as a library even if it is a .exe
 263  */
 264 HINSTANCE16 MODULE_Load( LPCSTR name, BOOL32 implicit,
 265                          LPCSTR cmd_line, LPCSTR env, UINT32 show_cmd )
 266 {
 267     HMODULE16 hModule;
 268     HINSTANCE16 hInstance, hPrevInstance;
 269     NE_MODULE *pModule;
 270
 271     if (__winelib)
 272     {
 273         OFSTRUCT ofs;
 274         lstrcpyn32A( ofs.szPathName, name, sizeof(ofs.szPathName) );
 275         if ((hModule = MODULE_CreateDummyModule( &ofs )) < 32) return hModule;
 276         pModule = (NE_MODULE *)GlobalLock16( hModule );
 277         hInstance = NE_CreateInstance( pModule, &hPrevInstance,
 278                                        (cmd_line == NULL) );
 279     }
 280     else
 281     {
 282         hInstance = NE_LoadModule( name, &hPrevInstance, implicit,
 283                                  (cmd_line == NULL) );
 284         if ((hInstance == 21) && cmd_line)
 285             return PE_LoadModule( name, cmd_line, env, show_cmd );
 286     }
 287
 288     /* Create a task for this instance */
 289
 290     if (hInstance < 32) return hInstance;
 291     pModule = NE_GetPtr( hInstance );
 292     if (cmd_line && !(pModule->flags & NE_FFLAGS_LIBMODULE))
 293     {
 294         PDB32 *pdb;
 295
 296         pModule->flags |= NE_FFLAGS_GUI;
 297
 298         pdb = PROCESS_Create( pModule, cmd_line, env, hInstance,
 299                               hPrevInstance, show_cmd );
 300         if (pdb && (GetNumTasks() > 1)) Yield16();
 301     }
 302
 303     return hInstance;
 304 }
 305
 306
 307 /**********************************************************************
 308  *          LoadModule16    (KERNEL.45)
 309  */
 310 HINSTANCE16 LoadModule16( LPCSTR name, LPVOID paramBlock )
 311 {
 312     LOADPARAMS *params;
 313     LPSTR cmd_line, new_cmd_line;
 314     UINT16 show_cmd = 0;
 315     LPCVOID env = NULL;
 316     HINSTANCE16 hInstance;
 317
 318     if (!paramBlock || (paramBlock == (LPVOID)-1))
 319         return LoadLibrary16( name );
 320
 321     params = (LOADPARAMS *)paramBlock;
 322     cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine );
 323     /* PowerPoint passes NULL as showCmd */
 324     if (params->showCmd)
 325         show_cmd = *((UINT16 *)PTR_SEG_TO_LIN(params->showCmd)+1);
 326
 327     if (!cmd_line) cmd_line = "";
 328     else if (*cmd_line) cmd_line++;  /* skip the length byte */
 329
 330     if (!(new_cmd_line = HeapAlloc( GetProcessHeap(), 0,
 331                                     strlen(cmd_line) + strlen(name) + 2 )))
 332         return 0;
 333     strcpy( new_cmd_line, name );
 334     strcat( new_cmd_line, " " );
 335     strcat( new_cmd_line, cmd_line );
 336
 337     if (params->hEnvironment) env = GlobalLock16( params->hEnvironment );
 338     hInstance = MODULE_Load( name, FALSE, new_cmd_line, env, show_cmd );
 339     if (params->hEnvironment) GlobalUnlock16( params->hEnvironment );
 340     HeapFree( GetProcessHeap(), 0, new_cmd_line );
 341     return hInstance;
 342 }
 343
 344 /**********************************************************************
 345  *          LoadModule32    (KERNEL32.499)
 346  *
 347  * FIXME
 348  *
 349  *  This should get implemented via CreateProcess -- MODULE_Load
 350  *  is resolutely 16-bit.
 351  */
 352 DWORD LoadModule32( LPCSTR name, LPVOID paramBlock )
 353 {
 354     LOADPARAMS32 *params = (LOADPARAMS32 *)paramBlock;
 355 #if 0
 356   STARTUPINFO st;
 357   PROCESSINFORMATION pi;
 358   st.cb = sizeof(STARTUPINFO);
 359   st.wShowWindow = p->lpCmdShow[2] ; WRONG
 360
 361   BOOL32 ret = CreateProcess32A( name, p->lpCmdLine,
 362                                  NULL, NULL, FALSE, 0, p->lpEnvAddress,
 363                                  NULL, &st, &pi);
 364   if (!ret) {
 365     /*    handle errors appropriately */
 366   }
 367   CloseHandle32(pi.hProcess);
 368   CloseHandle32(pi.hThread);
 369
 370 #else
 371   return MODULE_Load( name, FALSE, params->lpCmdLine, params->lpEnvAddress,
 372                         *((UINT16 *)params->lpCmdShow + 1) );
 373 #endif
 374 }
 375
 376
 377 /***********************************************************************
 378  *              GetModuleHandle         (KERNEL32.237)
 379  */
 380 HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module)
 381 {
 382
 383     TRACE(win32, "%s\n", module ? module : "NULL");
 384     if (module == NULL)
 385         return PROCESS_Current()->exe_modref->module;
 386     else
 387         return MODULE_FindModule32(PROCESS_Current(),module);
 388 }
 389
 390 HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module)
 391 {
 392     HMODULE32 hModule;
 393     LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module );
 394     hModule = GetModuleHandle32A( modulea );
 395     HeapFree( GetProcessHeap(), 0, modulea );
 396     return hModule;
 397 }
 398
 399
 400 /***********************************************************************
 401  *              GetModuleFileName32A      (KERNEL32.235)
 402  */
 403 DWORD WINAPI GetModuleFileName32A(
 404         HMODULE32 hModule,      /* [in] module handle (32bit) */
 405         LPSTR lpFileName,       /* [out] filenamebuffer */
 406         DWORD size              /* [in] size of filenamebuffer */
 407 ) {
 408     WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
 409
 410     if (!wm) /* can happen on start up or the like */
 411         return 0;
 412
 413     /* FIXME: we should probably get a real long name, but wm->longname
 414      * is currently a UNIX filename!
 415      */
 416     lstrcpyn32A( lpFileName, wm->shortname, size );
 417     TRACE(module, "%s\n", lpFileName );
 418     return strlen(lpFileName);
 419 }
 420
 421
 422 /***********************************************************************
 423  *              GetModuleFileName32W      (KERNEL32.236)
 424  */
 425 DWORD WINAPI GetModuleFileName32W( HMODULE32 hModule, LPWSTR lpFileName,
 426                                    DWORD size )
 427 {
 428     LPSTR fnA = (char*)HeapAlloc( GetProcessHeap(), 0, size );
 429     DWORD res = GetModuleFileName32A( hModule, fnA, size );
 430     lstrcpynAtoW( lpFileName, fnA, size );
 431     HeapFree( GetProcessHeap(), 0, fnA );
 432     return res;
 433 }
 434
 435
 436 /***********************************************************************
 437  *           LoadLibraryEx32W   (KERNEL.513)
 438  * FIXME
 439  */
 440 HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
 441                                        DWORD flags )
 442 {
 443     TRACE(module,"(%s,%d,%08lx)\n",libname,hf,flags);
 444     return LoadLibraryEx32A(libname, hf,flags);
 445 }
 446
 447 /***********************************************************************
 448  *           LoadLibraryEx32A   (KERNEL32)
 449  */
 450 HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
 451 {
 452     HMODULE32 hmod;
 453
 454     hmod = PE_LoadLibraryEx32A(libname,PROCESS_Current(),hfile,flags);
 455     if (hmod < 32) {
 456         char buffer[256];
 457
 458         strcpy( buffer, libname );
 459         strcat( buffer, ".dll" );
 460         hmod = PE_LoadLibraryEx32A(buffer,PROCESS_Current(),hfile,flags);
 461     }
 462     /* initialize all DLLs, which haven't been initialized yet. */
 463     if (hmod >= 32)
 464         PE_InitializeDLLs( PROCESS_Current(), DLL_PROCESS_ATTACH, NULL);
 465     return hmod;
 466 }
 467
 468 /***********************************************************************
 469  *           LoadLibraryA         (KERNEL32)
 470  */
 471 HMODULE32 WINAPI LoadLibrary32A(LPCSTR libname) {
 472         return LoadLibraryEx32A(libname,0,0);
 473 }
 474
 475 /***********************************************************************
 476  *           LoadLibraryW         (KERNEL32)
 477  */
 478 HMODULE32 WINAPI LoadLibrary32W(LPCWSTR libnameW)
 479 {
 480     return LoadLibraryEx32W(libnameW,0,0);
 481 }
 482
 483 /***********************************************************************
 484  *           LoadLibraryExW       (KERNEL32)
 485  */
 486 HMODULE32 WINAPI LoadLibraryEx32W(LPCWSTR libnameW,HFILE32 hfile,DWORD flags)
 487 {
 488     LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
 489     HMODULE32 ret = LoadLibraryEx32A( libnameA , hfile, flags );
 490
 491     HeapFree( GetProcessHeap(), 0, libnameA );
 492     return ret;
 493 }
 494
 495 /***********************************************************************
 496  *           FreeLibrary
 497  */
 498 BOOL32 WINAPI FreeLibrary32(HINSTANCE32 hLibModule)
 499 {
 500     WARN(module,"(%08x): stub\n", hLibModule);
 501     return TRUE;  /* FIXME */
 502 }
 503
 504
 505 /***********************************************************************
 506  *           PrivateLoadLibrary       (KERNEL32)
 507  *
 508  * FIXME: rough guesswork, don't know what "Private" means
 509  */
 510 HINSTANCE32 WINAPI PrivateLoadLibrary(LPCSTR libname)
 511 {
 512         return (HINSTANCE32)LoadLibrary16(libname);
 513 }
 514
 515
 516
 517 /***********************************************************************
 518  *           PrivateFreeLibrary       (KERNEL32)
 519  *
 520  * FIXME: rough guesswork, don't know what "Private" means
 521  */
 522 void WINAPI PrivateFreeLibrary(HINSTANCE32 handle)
 523 {
 524         FreeLibrary16((HINSTANCE16)handle);
 525 }
 526
 527
 528 /***********************************************************************
 529  *           WinExec16   (KERNEL.166)
 530  */
 531 HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow )
 532 {
 533     return WinExec32( lpCmdLine, nCmdShow );
 534 }
 535
 536
 537 /***********************************************************************
 538  *           WinExec32   (KERNEL32.566)
 539  */
 540 HINSTANCE32 WINAPI WinExec32( LPCSTR lpCmdLine, UINT32 nCmdShow )
 541 {
 542     HINSTANCE32 handle = 2;
 543     char *p, filename[256];
 544     static int use_load_module = 1;
 545     int  spacelimit = 0, exhausted = 0;
 546
 547     if (!lpCmdLine)
 548         return 2;  /* File not found */
 549
 550     /* Keep trying to load a file by trying different filenames; e.g.,
 551        for the cmdline "abcd efg hij", try "abcd" with args "efg hij",
 552        then "abcd efg" with arg "hij", and finally "abcd efg hij" with
 553        no args */
 554
 555     while(!exhausted && handle == 2) {
 556         int spacecount = 0;
 557
 558         /* Build the filename and command-line */
 559
 560         lstrcpyn32A(filename, lpCmdLine,
 561                     sizeof(filename) - 4 /* for extension */);
 562
 563         /* Keep grabbing characters until end-of-string, tab, or until the
 564            number of spaces is greater than the spacelimit */
 565
 566         for (p = filename; ; p++) {
 567             if(*p == ' ') {
 568                 ++spacecount;
 569                 if(spacecount > spacelimit) {
 570                     ++spacelimit;
 571                     break;
 572                 }
 573             }
 574
 575             if(*p == '\0' || *p == '\t') {
 576                 exhausted = 1;
 577                 break;
 578             }
 579         }
 580
 581         *p = '\0';
 582
 583         /* Now load the executable file */
 584
 585         if (use_load_module)
 586         {
 587             /* Winelib: Use LoadModule() only for the program itself */
 588             if (__winelib) use_load_module = 0;
 589             handle = MODULE_Load( filename, FALSE, lpCmdLine, NULL, nCmdShow );
 590             if (handle == 2)  /* file not found */
 591             {
 592                 /* Check that the original file name did not have a suffix */
 593                 p = strrchr(filename, '.');
 594                 /* if there is a '.', check if either \ OR / follow */
 595                 if (!p || strchr(p, '/') || strchr(p, '\\'))
 596                 {
 597                     p = filename + strlen(filename);
 598                     strcpy( p, ".exe" );
 599                     handle = MODULE_Load( filename, FALSE, lpCmdLine,
 600                                           NULL, nCmdShow );
 601                     *p = '\0';  /* Remove extension */
 602                 }
 603             }
 604         }
 605         else
 606             handle = 2; /* file not found */
 607
 608         if (handle < 32)
 609         {
 610             /* Try to start it as a unix program */
 611             if (!fork())
 612             {
 613                 /* Child process */
 614                 DOS_FULL_NAME full_name;
 615                 const char *unixfilename = NULL;
 616                 const char *argv[256], **argptr;
 617                 int iconic = (nCmdShow == SW_SHOWMINIMIZED ||
 618                               nCmdShow == SW_SHOWMINNOACTIVE);
 619
 620                 THREAD_InitDone = FALSE; /* we didn't init this process */
 621                 /* get unixfilename */
 622                 if (strchr(filename, '/') ||
 623                     strchr(filename, ':') ||
 624                     strchr(filename, '\\'))
 625                 {
 626                     if (DOSFS_GetFullName( filename, TRUE, &full_name ))
 627                         unixfilename = full_name.long_name;
 628                 }
 629                 else unixfilename = filename;
 630
 631                 if (unixfilename)
 632                 {
 633                     /* build argv */
 634                     argptr = argv;
 635                     if (iconic) *argptr++ = "-iconic";
 636                     *argptr++ = unixfilename;
 637                     p = strdup(lpCmdLine);
 638                     while (1)
 639                     {
 640                         while (*p && (*p == ' ' || *p == '\t')) *p++ = '\0';
 641                         if (!*p) break;
 642                         *argptr++ = p;
 643                         while (*p && *p != ' ' && *p != '\t') p++;
 644                     }
 645                     *argptr++ = 0;
 646
 647                     /* Execute */
 648                     execvp(argv[0], (char**)argv);
 649                 }
 650
 651                 /* Failed ! */
 652
 653                 if (__winelib)
 654                 {
 655                     /* build argv */
 656                     argptr = argv;
 657                     *argptr++ = "wine";
 658                     if (iconic) *argptr++ = "-iconic";
 659                     *argptr++ = lpCmdLine;
 660                     *argptr++ = 0;
 661
 662                     /* Execute */
 663                     execvp(argv[0] , (char**)argv);
 664
 665                     /* Failed ! */
 666                     MSG("WinExec: can't exec 'wine %s'\n",
 667                             lpCmdLine);
 668                 }
 669                 exit(1);
 670             }
 671         }
 672     } /* while (!exhausted && handle < 32) */
 673
 674     return handle;
 675 }
 676
 677
 678 /***********************************************************************
 679  *           WIN32_GetProcAddress16   (KERNEL32.36)
 680  * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
 681  */
 682 FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hModule, LPCSTR name )
 683 {
 684     WORD        ordinal;
 685     FARPROC16   ret;
 686
 687     if (!hModule) {
 688         WARN(module,"hModule may not be 0!\n");
 689         return (FARPROC16)0;
 690     }
 691     if (HIWORD(hModule))
 692     {
 693         WARN( module, "hModule is Win32 handle (%08x)\n", hModule );
 694         return (FARPROC16)0;
 695     }
 696     hModule = GetExePtr( hModule );
 697     if (HIWORD(name)) {
 698         ordinal = NE_GetOrdinal( hModule, name );
 699         TRACE(module, "%04x '%s'\n",
 700                         hModule, name );
 701     } else {
 702         ordinal = LOWORD(name);
 703         TRACE(module, "%04x %04x\n",
 704                         hModule, ordinal );
 705     }
 706     if (!ordinal) return (FARPROC16)0;
 707     ret = NE_GetEntryPoint( hModule, ordinal );
 708     TRACE(module,"returning %08x\n",(UINT32)ret);
 709     return ret;
 710 }
 711
 712 /***********************************************************************
 713  *           GetProcAddress16   (KERNEL.50)
 714  */
 715 FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, SEGPTR name )
 716 {
 717     WORD ordinal;
 718     FARPROC16 ret;
 719
 720     if (!hModule) hModule = GetCurrentTask();
 721     hModule = GetExePtr( hModule );
 722
 723     if (HIWORD(name) != 0)
 724     {
 725         ordinal = NE_GetOrdinal( hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
 726         TRACE(module, "%04x '%s'\n",
 727                         hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
 728     }
 729     else
 730     {
 731         ordinal = LOWORD(name);
 732         TRACE(module, "%04x %04x\n",
 733                         hModule, ordinal );
 734     }
 735     if (!ordinal) return (FARPROC16)0;
 736
 737     ret = NE_GetEntryPoint( hModule, ordinal );
 738
 739     TRACE(module, "returning %08x\n", (UINT32)ret );
 740     return ret;
 741 }
 742
 743
 744 /***********************************************************************
 745  *           GetProcAddress32                   (KERNEL32.257)
 746  */
 747 FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
 748 {
 749     return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function );
 750 }
 751
 752
 753 /***********************************************************************
 754  *           MODULE_GetProcAddress32            (internal)
 755  */
 756 FARPROC32 MODULE_GetProcAddress32(
 757         PDB32 *process,         /* [in] process context */
 758         HMODULE32 hModule,      /* [in] current module handle */
 759         LPCSTR function )       /* [in] function to be looked up */
 760 {
 761     WINE_MODREF *wm = MODULE32_LookupHMODULE(process,hModule);
 762
 763     if (HIWORD(function))
 764         TRACE(win32,"(%08lx,%s)\n",(DWORD)hModule,function);
 765     else
 766         TRACE(win32,"(%08lx,%p)\n",(DWORD)hModule,function);
 767     if (!wm)
 768         return (FARPROC32)0;
 769     switch (wm->type)
 770     {
 771     case MODULE32_PE:
 772         return PE_FindExportedFunction( process, wm, function);
 773     default:
 774         ERR(module,"wine_modref type %d not handled.\n",wm->type);
 775         return (FARPROC32)0;
 776     }
 777 }
 778
 779
 780 /***********************************************************************
 781  *           RtlImageNtHeaders   (NTDLL)
 782  */
 783 LPIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
 784 {
 785     /* basically:
 786      * return  hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew);
 787      * but we could get HMODULE16 or the like (think builtin modules)
 788      */
 789
 790     WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule );
 791     if (!wm || (wm->type != MODULE32_PE)) return (LPIMAGE_NT_HEADERS)0;
 792     return PE_HEADER(wm->module);
 793 }