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