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 "winerror.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 "dosexe.h"
  23 #include "process.h"
  24 #include "thread.h"
  25 #include "resource.h"
  26 #include "selectors.h"
  27 #include "stackframe.h"
  28 #include "task.h"
  29 #include "debug.h"
  30 #include "callback.h"
  31
  32 extern BOOL32 THREAD_InitDone;
  33
  34
  35 /*************************************************************************
  36  *              MODULE32_LookupHMODULE
  37  * looks for the referenced HMODULE in the current process
  38  */
  39 WINE_MODREF*
  40 MODULE32_LookupHMODULE(PDB32 *process,HMODULE32 hmod) {
  41     WINE_MODREF *wm;
  42
  43     if (!hmod)
  44         return process->exe_modref;
  45     if (!HIWORD(hmod)) {
  46         ERR(module,"tried to lookup 0x%04x in win32 module handler!\n",hmod);
  47         return NULL;
  48     }
  49     for (wm = process->modref_list;wm;wm=wm->next)
  50         if (wm->module == hmod)
  51             return wm;
  52     return NULL;
  53 }
  54
  55 /*************************************************************************
  56  *              MODULE_InitializeDLLs
  57  *
  58  * Call the initialization routines of all DLLs belonging to the
  59  * current process. This is somewhat complicated due to the fact that
  60  *
  61  * - we have to respect the module dependencies, i.e. modules implicitly
  62  *   referenced by another module have to be initialized before the module
  63  *   itself can be initialized
  64  *
  65  * - the initialization routine of a DLL can itself call LoadLibrary,
  66  *   thereby introducing a whole new set of dependencies (even involving
  67  *   the 'old' modules) at any time during the whole process
  68  *
  69  * (Note that this routine can be recursively entered not only directly
  70  *  from itself, but also via LoadLibrary from one of the called initialization
  71  *  routines.)
  72  */
  73 void MODULE_InitializeDLLs( PDB32 *process, HMODULE32 root,
  74                             DWORD type, LPVOID lpReserved )
  75 {
  76     WINE_MODREF *wm = MODULE32_LookupHMODULE( process, root );
  77     int i;
  78
  79     if (!wm) return;
  80
  81     /* If called for main EXE, check for invalid recursion */
  82     if ( !root && wm->initDone )
  83     {
  84         FIXME(module, "Invalid recursion!\n");
  85         return;
  86     }
  87
  88     /* Tag current MODREF to prevent recursive loop */
  89     wm->initDone = TRUE;
  90
  91     /* Recursively initialize all child DLLs */
  92     for ( i = 0; i < wm->nDeps; i++ )
  93         if ( wm->deps[i] && !wm->deps[i]->initDone )
  94             MODULE_InitializeDLLs( process,
  95                                    wm->deps[i]->module, type, lpReserved );
  96
  97     /* Now we can call the initialization routine */
  98     switch ( wm->type )
  99     {
 100     case MODULE32_PE:
 101         PE_InitDLL( wm, type, lpReserved );
 102         break;
 103
 104     default:
 105         ERR(module, "wine_modref type %d not handled.\n", wm->type);
 106         break;
 107     }
 108
 109     /* If called for main EXE, reset recursion flags */
 110     if ( !root )
 111         for ( wm = process->modref_list; wm; wm = wm->next )
 112         {
 113             if (!wm->initDone)
 114                 FIXME(module, "Orphaned module in modref_list?\n");
 115
 116             wm->initDone = FALSE;
 117         }
 118 }
 119
 120
 121 /***********************************************************************
 122  *           MODULE_CreateDummyModule
 123  *
 124  * Create a dummy NE module for Win32 or Winelib.
 125  */
 126 HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs )
 127 {
 128     HMODULE32 hModule;
 129     NE_MODULE *pModule;
 130     SEGTABLEENTRY *pSegment;
 131     char *pStr,*s;
 132     int len;
 133     const char* basename;
 134
 135     INT32 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
 136                     + strlen(ofs->szPathName) + 1;
 137     INT32 size = sizeof(NE_MODULE) +
 138                  /* loaded file info */
 139                  of_size +
 140                  /* segment table: DS,CS */
 141                  2 * sizeof(SEGTABLEENTRY) +
 142                  /* name table */
 143                  9 +
 144                  /* several empty tables */
 145                  8;
 146
 147     hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
 148     if (!hModule) return (HMODULE32)11;  /* invalid exe */
 149
 150     FarSetOwner( hModule, hModule );
 151     pModule = (NE_MODULE *)GlobalLock16( hModule );
 152
 153     /* Set all used entries */
 154     pModule->magic            = IMAGE_OS2_SIGNATURE;
 155     pModule->count            = 1;
 156     pModule->next             = 0;
 157     pModule->flags            = 0;
 158     pModule->dgroup           = 1;
 159     pModule->ss               = 1;
 160     pModule->cs               = 2;
 161     pModule->heap_size        = 0xe000;
 162     pModule->stack_size       = 0x1000;
 163     pModule->seg_count        = 2;
 164     pModule->modref_count     = 0;
 165     pModule->nrname_size      = 0;
 166     pModule->fileinfo         = sizeof(NE_MODULE);
 167     pModule->os_flags         = NE_OSFLAGS_WINDOWS;
 168     pModule->expected_version = 0x030a;
 169     pModule->self             = hModule;
 170
 171     /* Set loaded file information */
 172     memcpy( pModule + 1, ofs, of_size );
 173     ((OFSTRUCT *)(pModule+1))->cBytes = of_size - 1;
 174
 175     pSegment = (SEGTABLEENTRY*)((char*)(pModule + 1) + of_size);
 176     pModule->seg_table = pModule->dgroup_entry = (int)pSegment - (int)pModule;
 177     /* Data segment */
 178     pSegment->size    = 0;
 179     pSegment->flags   = NE_SEGFLAGS_DATA;
 180     pSegment->minsize = 0x1000;
 181     pSegment++;
 182     /* Code segment */
 183     pSegment->flags   = 0;
 184     pSegment++;
 185
 186     /* Module name */
 187     pStr = (char *)pSegment;
 188     pModule->name_table = (int)pStr - (int)pModule;
 189     basename = strrchr(ofs->szPathName,'\\');
 190     if (!basename) basename = ofs->szPathName;
 191     else basename++;
 192     len = strlen(basename);
 193     if ((s = strchr(basename,'.'))) len = s - basename;
 194     if (len > 8) len = 8;
 195     *pStr = len;
 196     strncpy( pStr+1, basename, len );
 197     if (len < 8) pStr[len+1] = 0;
 198     pStr += 9;
 199
 200     /* All tables zero terminated */
 201     pModule->res_table = pModule->import_table = pModule->entry_table =
 202                 (int)pStr - (int)pModule;
 203
 204     NE_RegisterModule( pModule );
 205     return hModule;
 206 }
 207
 208
 209 /***********************************************************************
 210  *           MODULE_GetWndProcEntry16  (not a Windows API function)
 211  *
 212  * Return an entry point from the WPROCS dll.
 213  */
 214 FARPROC16 MODULE_GetWndProcEntry16( LPCSTR name )
 215 {
 216     FARPROC16 ret = NULL;
 217
 218     if (__winelib)
 219     {
 220         /* FIXME: hack for Winelib */
 221         extern LRESULT ColorDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 222         extern LRESULT FileOpenDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 223         extern LRESULT FileSaveDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 224         extern LRESULT FindTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
 225         extern LRESULT PrintDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 226         extern LRESULT PrintSetupDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
 227         extern LRESULT ReplaceTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
 228
 229         if (!strcmp(name,"ColorDlgProc"))
 230             return (FARPROC16)ColorDlgProc;
 231         if (!strcmp(name,"FileOpenDlgProc"))
 232             return (FARPROC16)FileOpenDlgProc;
 233         if (!strcmp(name,"FileSaveDlgProc"))
 234             return (FARPROC16)FileSaveDlgProc;
 235         if (!strcmp(name,"FindTextDlgProc"))
 236             return (FARPROC16)FindTextDlgProc16;
 237         if (!strcmp(name,"PrintDlgProc"))
 238             return (FARPROC16)PrintDlgProc;
 239         if (!strcmp(name,"PrintSetupDlgProc"))
 240             return (FARPROC16)PrintSetupDlgProc;
 241         if (!strcmp(name,"ReplaceTextDlgProc"))
 242             return (FARPROC16)ReplaceTextDlgProc16;
 243         if (!strcmp(name,"DefResourceHandler"))
 244             return (FARPROC16)NE_DefResourceHandler;
 245         if (!strcmp(name,"LoadDIBIconHandler"))
 246             return (FARPROC16)LoadDIBIconHandler;
 247         if (!strcmp(name,"LoadDIBCursorHandler"))
 248             return (FARPROC16)LoadDIBCursorHandler;
 249         FIXME(module,"No mapping for %s(), add one in library/miscstubs.c\n",name);
 250         assert( FALSE );
 251         return NULL;
 252     }
 253     else
 254     {
 255         WORD ordinal;
 256         static HMODULE32 hModule = 0;
 257
 258         if (!hModule) hModule = GetModuleHandle16( "WPROCS" );
 259         ordinal = NE_GetOrdinal( hModule, name );
 260         if (!(ret = NE_GetEntryPoint( hModule, ordinal )))
 261         {
 262             WARN( module, "%s not found\n", name );
 263             assert( FALSE );
 264         }
 265     }
 266     return ret;
 267 }
 268
 269
 270 /**********************************************************************
 271  *          MODULE_FindModule32
 272  *
 273  * Find a (loaded) win32 module depending on path
 274  * The handling of '.' is a bit weird, but we need it that way,
 275  * for sometimes the programs use '<name>.exe' and '<name>.dll' and
 276  * this is the only way to differentiate. (mainly hypertrm.exe)
 277  *
 278  * RETURNS
 279  *      the module handle if found
 280  *      0 if not
 281  */
 282 HMODULE32 MODULE_FindModule32(
 283         PDB32* process, /* [in] process in which to find the library */
 284         LPCSTR path     /* [in] pathname of module/library to be found */
 285 ) {
 286     LPSTR       filename;
 287     LPSTR       dotptr;
 288     WINE_MODREF *wm;
 289
 290     if (!process)
 291         return 0;
 292     if (!(filename = strrchr( path, '\\' )))
 293         filename = HEAP_strdupA(process->heap,0,path);
 294     else
 295         filename = HEAP_strdupA(process->heap,0,filename+1);
 296     dotptr=strrchr(filename,'.');
 297
 298     for (wm=process->modref_list;wm;wm=wm->next) {
 299         LPSTR   xmodname,xdotptr;
 300
 301         assert (wm->modname);
 302         xmodname = HEAP_strdupA(process->heap,0,wm->modname);
 303         xdotptr=strrchr(xmodname,'.');
 304         if (    (xdotptr && !dotptr) ||
 305                 (!xdotptr && dotptr)
 306         ) {
 307             if (dotptr) *dotptr         = '\0';
 308             if (xdotptr) *xdotptr       = '\0';
 309         }
 310         if (!strcasecmp( filename, xmodname)) {
 311             HeapFree(process->heap,0,filename);
 312             HeapFree(process->heap,0,xmodname);
 313             return wm->module;
 314         }
 315         if (dotptr) *dotptr='.';
 316         /* FIXME: add paths, shortname */
 317         HeapFree(process->heap,0,xmodname);
 318     }
 319     /* if that fails, try looking for the filename... */
 320     for (wm=process->modref_list;wm;wm=wm->next) {
 321         LPSTR   xlname,xdotptr;
 322
 323         assert (wm->longname);
 324         xlname = strrchr(wm->longname,'\\');
 325         if (!xlname)
 326             xlname = wm->longname;
 327         else
 328             xlname++;
 329         xlname = HEAP_strdupA(process->heap,0,xlname);
 330         xdotptr=strrchr(xlname,'.');
 331         if (    (xdotptr && !dotptr) ||
 332                 (!xdotptr && dotptr)
 333         ) {
 334             if (dotptr) *dotptr         = '\0';
 335             if (xdotptr) *xdotptr       = '\0';
 336         }
 337         if (!strcasecmp( filename, xlname)) {
 338             HeapFree(process->heap,0,filename);
 339             HeapFree(process->heap,0,xlname);
 340             return wm->module;
 341         }
 342         if (dotptr) *dotptr='.';
 343         /* FIXME: add paths, shortname */
 344         HeapFree(process->heap,0,xlname);
 345     }
 346     HeapFree(process->heap,0,filename);
 347     return 0;
 348 }
 349
 350
 351
 352 /**********************************************************************
 353  *          NE_CreateProcess
 354  */
 355 static HINSTANCE16 NE_CreateProcess( LPCSTR name, LPCSTR cmd_line, LPCSTR env,
 356                                      LPSTARTUPINFO32A startup,
 357                                      LPPROCESS_INFORMATION info )
 358 {
 359     HMODULE16 hModule;
 360     HINSTANCE16 hInstance, hPrevInstance;
 361     NE_MODULE *pModule;
 362
 363     if (__winelib)
 364     {
 365         OFSTRUCT ofs;
 366         lstrcpyn32A( ofs.szPathName, name, sizeof(ofs.szPathName) );
 367         if ((hModule = MODULE_CreateDummyModule( &ofs )) < 32) return hModule;
 368         pModule = (NE_MODULE *)GlobalLock16( hModule );
 369         hInstance = NE_CreateInstance( pModule, &hPrevInstance, FALSE );
 370     }
 371     else
 372     {
 373         hInstance = NE_LoadModule( name, &hPrevInstance, TRUE, FALSE );
 374         if (hInstance < 32) return hInstance;
 375
 376         if (   !(pModule = NE_GetPtr(hInstance))
 377             ||  (pModule->flags & NE_FFLAGS_LIBMODULE))
 378         {
 379             /* FIXME: cleanup */
 380             return 11;
 381         }
 382     }
 383
 384     /* Create a task for this instance */
 385
 386     pModule->flags |= NE_FFLAGS_GUI;  /* FIXME: is this necessary? */
 387
 388     PROCESS_Create( pModule, cmd_line, env, hInstance,
 389                     hPrevInstance, startup, info );
 390
 391     return hInstance;
 392 }
 393
 394
 395 /**********************************************************************
 396  *          LoadModule16    (KERNEL.45)
 397  */
 398 HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
 399 {
 400     LOADPARAMS *params;
 401     LPSTR cmd_line, new_cmd_line;
 402     LPCVOID env = NULL;
 403     STARTUPINFO32A startup;
 404     PROCESS_INFORMATION info;
 405     HINSTANCE16 hInstance, hPrevInstance;
 406     NE_MODULE *pModule;
 407     PDB32 *pdb;
 408
 409     /* Load module */
 410
 411     if (!paramBlock || (paramBlock == (LPVOID)-1))
 412         return LoadLibrary16( name );
 413
 414     hInstance = NE_LoadModule( name, &hPrevInstance, FALSE, FALSE );
 415     if (   hInstance < 32 || !(pModule = NE_GetPtr(hInstance))
 416         || (pModule->flags & NE_FFLAGS_LIBMODULE))
 417         return hInstance;
 418
 419     /* Create a task for this instance */
 420
 421     pModule->flags |= NE_FFLAGS_GUI;  /* FIXME: is this necessary? */
 422
 423     params = (LOADPARAMS *)paramBlock;
 424     cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine );
 425     if (!cmd_line) cmd_line = "";
 426     else if (*cmd_line) cmd_line++;  /* skip the length byte */
 427
 428     if (!(new_cmd_line = HeapAlloc( GetProcessHeap(), 0,
 429                                     strlen(cmd_line)+strlen(name)+2 )))
 430         return 0;
 431     strcpy( new_cmd_line, name );
 432     strcat( new_cmd_line, " " );
 433     strcat( new_cmd_line, cmd_line );
 434
 435     if (params->hEnvironment) env = GlobalLock16( params->hEnvironment );
 436
 437     memset( &info, '\0', sizeof(info) );
 438     memset( &startup, '\0', sizeof(startup) );
 439     startup.cb = sizeof(startup);
 440     if (params->showCmd)
 441     {
 442         startup.dwFlags = STARTF_USESHOWWINDOW;
 443         startup.wShowWindow = ((UINT16 *)PTR_SEG_TO_LIN(params->showCmd))[1];
 444     }
 445
 446     pdb = PROCESS_Create( pModule, new_cmd_line, env,
 447                           hInstance, hPrevInstance, &startup, &info );
 448
 449     CloseHandle( info.hThread );
 450     CloseHandle( info.hProcess );
 451
 452     if (params->hEnvironment) GlobalUnlock16( params->hEnvironment );
 453     HeapFree( GetProcessHeap(), 0, new_cmd_line );
 454
 455     /* Start task */
 456
 457     if (pdb) TASK_StartTask( pdb->task );
 458
 459     return hInstance;
 460 }
 461
 462 /**********************************************************************
 463  *          LoadModule32    (KERNEL32.499)
 464  */
 465 HINSTANCE32 WINAPI LoadModule32( LPCSTR name, LPVOID paramBlock )
 466 {
 467     LOADPARAMS32 *params = (LOADPARAMS32 *)paramBlock;
 468     PROCESS_INFORMATION info;
 469     STARTUPINFO32A startup;
 470     HINSTANCE32 hInstance;
 471     PDB32 *pdb;
 472     TDB *tdb;
 473
 474     memset( &startup, '\0', sizeof(startup) );
 475     startup.cb = sizeof(startup);
 476     startup.dwFlags = STARTF_USESHOWWINDOW;
 477     startup.wShowWindow = params->lpCmdShow? params->lpCmdShow[1] : 0;
 478
 479     if (!CreateProcess32A( name, params->lpCmdLine,
 480                            NULL, NULL, FALSE, 0, params->lpEnvAddress,
 481                            NULL, &startup, &info ))
 482         return GetLastError();  /* guaranteed to be < 32 */
 483
 484     /* Get hInstance from process */
 485     pdb = PROCESS_IdToPDB( info.dwProcessId );
 486     tdb = pdb? (TDB *)GlobalLock16( pdb->task ) : NULL;
 487     hInstance = tdb? tdb->hInstance : 0;
 488
 489     /* Close off the handles */
 490     CloseHandle( info.hThread );
 491     CloseHandle( info.hProcess );
 492
 493     return hInstance;
 494 }
 495
 496 /**********************************************************************
 497  *       CreateProcess32A          (KERNEL32.171)
 498  */
 499 BOOL32 WINAPI CreateProcess32A( LPCSTR lpApplicationName, LPSTR lpCommandLine,
 500                                 LPSECURITY_ATTRIBUTES lpProcessAttributes,
 501                                 LPSECURITY_ATTRIBUTES lpThreadAttributes,
 502                                 BOOL32 bInheritHandles, DWORD dwCreationFlags,
 503                                 LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
 504                                 LPSTARTUPINFO32A lpStartupInfo,
 505                                 LPPROCESS_INFORMATION lpProcessInfo )
 506 {
 507     HINSTANCE16 hInstance;
 508     LPCSTR cmdline;
 509     PDB32 *pdb;
 510     char name[256];
 511
 512     /* Get name and command line */
 513
 514     if (!lpApplicationName && !lpCommandLine)
 515     {
 516         SetLastError( ERROR_FILE_NOT_FOUND );
 517         return FALSE;
 518     }
 519
 520     cmdline = lpCommandLine? lpCommandLine : lpApplicationName;
 521
 522     if (lpApplicationName)
 523         lstrcpyn32A(name, lpApplicationName, sizeof(name) - 4);
 524     else {
 525         char    *ptr;
 526         int     len;
 527
 528         /* Take care off .exes with spaces in their names */
 529         ptr = strchr(lpCommandLine, ' ');
 530         do {
 531             len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
 532             if (len > sizeof(name) - 4) len = sizeof(name) - 4;
 533             lstrcpyn32A(name, lpCommandLine, len);
 534             if (!strchr(name, '\\') && !strchr(name, '.'))
 535                 strcat(name, ".exe");
 536             fprintf(stderr,"looking for: %s\n",name);
 537             if (GetFileAttributes32A(name)!=-1)
 538                 break;
 539             /* if there is a space and no file found yet, include the word
 540              * up to the next space too. If there is no next space, just
 541              * use the first word.
 542              */
 543             if (ptr) {
 544                 ptr = strchr(ptr+1, ' ');
 545             } else {
 546                 ptr = strchr(lpCommandLine, ' ');
 547                 len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
 548                 if (len > sizeof(name) - 4) len = sizeof(name) - 4;
 549                 lstrcpyn32A(name, lpCommandLine, len);
 550                 break;
 551             }
 552         } while (1);
 553     }
 554
 555     if (!strchr(name, '\\') && !strchr(name, '.'))
 556         strcat(name, ".exe");
 557
 558
 559     /* Warn if unsupported features are used */
 560
 561     if (lpProcessAttributes)
 562         FIXME(module, "(%s,...): lpProcessAttributes ignored\n", name);
 563     if (lpThreadAttributes)
 564         FIXME(module, "(%s,...): lpThreadAttributes ignored\n", name);
 565     if (bInheritHandles)
 566         FIXME(module, "(%s,...): bInheritHandles ignored\n", name);
 567     if (dwCreationFlags & DEBUG_PROCESS)
 568         FIXME(module, "(%s,...): DEBUG_PROCESS ignored\n", name);
 569     if (dwCreationFlags & DEBUG_ONLY_THIS_PROCESS)
 570         FIXME(module, "(%s,...): DEBUG_ONLY_THIS_PROCESS ignored\n", name);
 571     if (dwCreationFlags & CREATE_SUSPENDED)
 572         FIXME(module, "(%s,...): CREATE_SUSPENDED ignored\n", name);
 573     if (dwCreationFlags & DETACHED_PROCESS)
 574         FIXME(module, "(%s,...): DETACHED_PROCESS ignored\n", name);
 575     if (dwCreationFlags & CREATE_NEW_CONSOLE)
 576         FIXME(module, "(%s,...): CREATE_NEW_CONSOLE ignored\n", name);
 577     if (dwCreationFlags & NORMAL_PRIORITY_CLASS)
 578         FIXME(module, "(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name);
 579     if (dwCreationFlags & IDLE_PRIORITY_CLASS)
 580         FIXME(module, "(%s,...): IDLE_PRIORITY_CLASS ignored\n", name);
 581     if (dwCreationFlags & HIGH_PRIORITY_CLASS)
 582         FIXME(module, "(%s,...): HIGH_PRIORITY_CLASS ignored\n", name);
 583     if (dwCreationFlags & REALTIME_PRIORITY_CLASS)
 584         FIXME(module, "(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name);
 585     if (dwCreationFlags & CREATE_NEW_PROCESS_GROUP)
 586         FIXME(module, "(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name);
 587     if (dwCreationFlags & CREATE_UNICODE_ENVIRONMENT)
 588         FIXME(module, "(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name);
 589     if (dwCreationFlags & CREATE_SEPARATE_WOW_VDM)
 590         FIXME(module, "(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name);
 591     if (dwCreationFlags & CREATE_SHARED_WOW_VDM)
 592         FIXME(module, "(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name);
 593     if (dwCreationFlags & CREATE_DEFAULT_ERROR_MODE)
 594         FIXME(module, "(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name);
 595     if (dwCreationFlags & CREATE_NO_WINDOW)
 596         FIXME(module, "(%s,...): CREATE_NO_WINDOW ignored\n", name);
 597     if (dwCreationFlags & PROFILE_USER)
 598         FIXME(module, "(%s,...): PROFILE_USER ignored\n", name);
 599     if (dwCreationFlags & PROFILE_KERNEL)
 600         FIXME(module, "(%s,...): PROFILE_KERNEL ignored\n", name);
 601     if (dwCreationFlags & PROFILE_SERVER)
 602         FIXME(module, "(%s,...): PROFILE_SERVER ignored\n", name);
 603     if (lpCurrentDirectory)
 604         FIXME(module, "(%s,...): lpCurrentDirectory %s ignored\n",
 605                       name, lpCurrentDirectory);
 606     if (lpStartupInfo->lpDesktop)
 607         FIXME(module, "(%s,...): lpStartupInfo->lpDesktop %s ignored\n",
 608                       name, lpStartupInfo->lpDesktop);
 609     if (lpStartupInfo->lpTitle)
 610         FIXME(module, "(%s,...): lpStartupInfo->lpTitle %s ignored\n",
 611                       name, lpStartupInfo->lpTitle);
 612     if (lpStartupInfo->dwFlags & STARTF_USECOUNTCHARS)
 613         FIXME(module, "(%s,...): STARTF_USECOUNTCHARS (%ld,%ld) ignored\n",
 614                       name, lpStartupInfo->dwXCountChars, lpStartupInfo->dwYCountChars);
 615     if (lpStartupInfo->dwFlags & STARTF_USEFILLATTRIBUTE)
 616         FIXME(module, "(%s,...): STARTF_USEFILLATTRIBUTE %lx ignored\n",
 617                       name, lpStartupInfo->dwFillAttribute);
 618     if (lpStartupInfo->dwFlags & STARTF_RUNFULLSCREEN)
 619         FIXME(module, "(%s,...): STARTF_RUNFULLSCREEN ignored\n", name);
 620     if (lpStartupInfo->dwFlags & STARTF_FORCEONFEEDBACK)
 621         FIXME(module, "(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name);
 622     if (lpStartupInfo->dwFlags & STARTF_FORCEOFFFEEDBACK)
 623         FIXME(module, "(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name);
 624     if (lpStartupInfo->dwFlags & STARTF_USEHOTKEY)
 625         FIXME(module, "(%s,...): STARTF_USEHOTKEY ignored\n", name);
 626
 627
 628     /* Try NE (or winelib) module */
 629     hInstance = NE_CreateProcess( name, cmdline, lpEnvironment,
 630                                   lpStartupInfo, lpProcessInfo );
 631
 632     /* Try PE module */
 633     if (hInstance == 21)
 634         hInstance = PE_CreateProcess( name, cmdline, lpEnvironment,
 635                                       lpStartupInfo, lpProcessInfo );
 636
 637     /* Try DOS module */
 638     if (hInstance == 11)
 639         hInstance = MZ_CreateProcess( name, cmdline, lpEnvironment,
 640                                       lpStartupInfo, lpProcessInfo );
 641
 642     if (hInstance < 32)
 643     {
 644         SetLastError( hInstance );
 645         return FALSE;
 646     }
 647
 648     /* Get hTask from process and start the task */
 649     pdb = PROCESS_IdToPDB( lpProcessInfo->dwProcessId );
 650     if (pdb) TASK_StartTask( pdb->task );
 651
 652     return TRUE;
 653 }
 654
 655 /**********************************************************************
 656  *       CreateProcess32W          (KERNEL32.172)
 657  */
 658 BOOL32 WINAPI CreateProcess32W( LPCWSTR lpApplicationName, LPWSTR lpCommandLine,
 659                                 LPSECURITY_ATTRIBUTES lpProcessAttributes,
 660                                 LPSECURITY_ATTRIBUTES lpThreadAttributes,
 661                                 BOOL32 bInheritHandles, DWORD dwCreationFlags,
 662                                 LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory,
 663                                 LPSTARTUPINFO32W lpStartupInfo,
 664                                 LPPROCESS_INFORMATION lpProcessInfo )
 665 {
 666     FIXME(win32, "(%s,%s,...): stub\n", debugstr_w(lpApplicationName),
 667                  debugstr_w(lpCommandLine));
 668
 669     /* make from lcc uses system as fallback if CreateProcess returns
 670        FALSE, so return false */
 671     return FALSE;
 672 }
 673
 674 /***********************************************************************
 675  *              GetModuleHandle         (KERNEL32.237)
 676  */
 677 HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module)
 678 {
 679     if (module == NULL)
 680         return PROCESS_Current()->exe_modref->module;
 681     else
 682         return MODULE_FindModule32(PROCESS_Current(),module);
 683 }
 684
 685 HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module)
 686 {
 687     HMODULE32 hModule;
 688     LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module );
 689     hModule = GetModuleHandle32A( modulea );
 690     HeapFree( GetProcessHeap(), 0, modulea );
 691     return hModule;
 692 }
 693
 694
 695 /***********************************************************************
 696  *              GetModuleFileName32A      (KERNEL32.235)
 697  */
 698 DWORD WINAPI GetModuleFileName32A(
 699         HMODULE32 hModule,      /* [in] module handle (32bit) */
 700         LPSTR lpFileName,       /* [out] filenamebuffer */
 701         DWORD size              /* [in] size of filenamebuffer */
 702 ) {
 703     WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
 704
 705     if (!wm) /* can happen on start up or the like */
 706         return 0;
 707
 708     if (PE_HEADER(wm->module)->OptionalHeader.MajorOperatingSystemVersion >= 4.0)
 709       lstrcpyn32A( lpFileName, wm->longname, size );
 710     else
 711       lstrcpyn32A( lpFileName, wm->shortname, size );
 712
 713     TRACE(module, "%s\n", lpFileName );
 714     return strlen(lpFileName);
 715 }
 716
 717
 718 /***********************************************************************
 719  *              GetModuleFileName32W      (KERNEL32.236)
 720  */
 721 DWORD WINAPI GetModuleFileName32W( HMODULE32 hModule, LPWSTR lpFileName,
 722                                    DWORD size )
 723 {
 724     LPSTR fnA = (char*)HeapAlloc( GetProcessHeap(), 0, size );
 725     DWORD res = GetModuleFileName32A( hModule, fnA, size );
 726     lstrcpynAtoW( lpFileName, fnA, size );
 727     HeapFree( GetProcessHeap(), 0, fnA );
 728     return res;
 729 }
 730
 731
 732 /***********************************************************************
 733  *           LoadLibraryEx32W   (KERNEL.513)
 734  * FIXME
 735  */
 736 HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
 737                                        DWORD flags )
 738 {
 739     TRACE(module,"(%s,%d,%08lx)\n",libname,hf,flags);
 740     return LoadLibraryEx32A(libname, hf,flags);
 741 }
 742
 743 /***********************************************************************
 744  *           LoadLibraryEx32A   (KERNEL32)
 745  */
 746 HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
 747 {
 748         return MODULE_LoadLibraryEx32A(libname,PROCESS_Current(),hfile,flags);
 749 }
 750
 751 HMODULE32 MODULE_LoadLibraryEx32A(LPCSTR libname,PDB32*process,HFILE32 hfile,DWORD flags)
 752 {
 753     HMODULE32 hmod;
 754
 755     hmod = ELF_LoadLibraryEx32A(libname,process,hfile,flags);
 756     if (hmod)
 757         return hmod; /* already initialized for ELF */
 758
 759     hmod = PE_LoadLibraryEx32A(libname,process,hfile,flags);
 760     if (hmod < 32) {
 761         char buffer[256];
 762
 763         strcpy( buffer, libname );
 764         strcat( buffer, ".dll" );
 765         hmod = PE_LoadLibraryEx32A(buffer,process,hfile,flags);
 766     }
 767     /* initialize DLL just loaded */
 768     if (hmod >= 32)
 769         MODULE_InitializeDLLs( PROCESS_Current(), hmod, DLL_PROCESS_ATTACH, NULL);
 770     return hmod;
 771 }
 772
 773 /***********************************************************************
 774  *           LoadLibraryA         (KERNEL32)
 775  */
 776 HMODULE32 WINAPI LoadLibrary32A(LPCSTR libname) {
 777         return LoadLibraryEx32A(libname,0,0);
 778 }
 779
 780 /***********************************************************************
 781  *           LoadLibraryW         (KERNEL32)
 782  */
 783 HMODULE32 WINAPI LoadLibrary32W(LPCWSTR libnameW)
 784 {
 785     return LoadLibraryEx32W(libnameW,0,0);
 786 }
 787
 788 /***********************************************************************
 789  *           LoadLibraryExW       (KERNEL32)
 790  */
 791 HMODULE32 WINAPI LoadLibraryEx32W(LPCWSTR libnameW,HFILE32 hfile,DWORD flags)
 792 {
 793     LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
 794     HMODULE32 ret = LoadLibraryEx32A( libnameA , hfile, flags );
 795
 796     HeapFree( GetProcessHeap(), 0, libnameA );
 797     return ret;
 798 }
 799
 800 /***********************************************************************
 801  *           FreeLibrary
 802  */
 803 BOOL32 WINAPI FreeLibrary32(HINSTANCE32 hLibModule)
 804 {
 805     FIXME(module,"(0x%08x): stub\n", hLibModule);
 806     return TRUE;  /* FIXME */
 807 }
 808
 809
 810 /***********************************************************************
 811  *           PrivateLoadLibrary       (KERNEL32)
 812  *
 813  * FIXME: rough guesswork, don't know what "Private" means
 814  */
 815 HINSTANCE32 WINAPI PrivateLoadLibrary(LPCSTR libname)
 816 {
 817         return (HINSTANCE32)LoadLibrary16(libname);
 818 }
 819
 820
 821
 822 /***********************************************************************
 823  *           PrivateFreeLibrary       (KERNEL32)
 824  *
 825  * FIXME: rough guesswork, don't know what "Private" means
 826  */
 827 void WINAPI PrivateFreeLibrary(HINSTANCE32 handle)
 828 {
 829         FreeLibrary16((HINSTANCE16)handle);
 830 }
 831
 832
 833 /***********************************************************************
 834  *           WinExec16   (KERNEL.166)
 835  */
 836 HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow )
 837 {
 838     return WinExec32( lpCmdLine, nCmdShow );
 839 }
 840
 841
 842 /***********************************************************************
 843  *           WinExec32   (KERNEL32.566)
 844  */
 845 HINSTANCE32 WINAPI WinExec32( LPCSTR lpCmdLine, UINT32 nCmdShow )
 846 {
 847     HINSTANCE32 handle = 2;
 848     char *p, filename[256];
 849     static int use_load_module = 1;
 850     int  spacelimit = 0, exhausted = 0;
 851     LOADPARAMS32 params;
 852     UINT16 paramCmdShow[2];
 853
 854     if (!lpCmdLine)
 855         return 2;  /* File not found */
 856
 857     /* Set up LOADPARAMS32 buffer for LoadModule32 */
 858
 859     memset( &params, '\0', sizeof(params) );
 860     params.lpCmdLine    = (LPSTR)lpCmdLine;
 861     params.lpCmdShow    = paramCmdShow;
 862     params.lpCmdShow[0] = 2;
 863     params.lpCmdShow[1] = nCmdShow;
 864
 865
 866     /* Keep trying to load a file by trying different filenames; e.g.,
 867        for the cmdline "abcd efg hij", try "abcd" with args "efg hij",
 868        then "abcd efg" with arg "hij", and finally "abcd efg hij" with
 869        no args */
 870
 871     while(!exhausted && handle == 2) {
 872         int spacecount = 0;
 873
 874         /* Build the filename and command-line */
 875
 876         lstrcpyn32A(filename, lpCmdLine,
 877                     sizeof(filename) - 4 /* for extension */);
 878
 879         /* Keep grabbing characters until end-of-string, tab, or until the
 880            number of spaces is greater than the spacelimit */
 881
 882         for (p = filename; ; p++) {
 883             if(*p == ' ') {
 884                 ++spacecount;
 885                 if(spacecount > spacelimit) {
 886                     ++spacelimit;
 887                     break;
 888                 }
 889             }
 890
 891             if(*p == '\0' || *p == '\t') {
 892                 exhausted = 1;
 893                 break;
 894             }
 895         }
 896
 897         *p = '\0';
 898
 899         /* Now load the executable file */
 900
 901         if (use_load_module)
 902         {
 903             /* Winelib: Use LoadModule() only for the program itself */
 904             if (__winelib) use_load_module = 0;
 905             handle = LoadModule32( filename, &params );
 906             if (handle == 2)  /* file not found */
 907             {
 908                 /* Check that the original file name did not have a suffix */
 909                 p = strrchr(filename, '.');
 910                 /* if there is a '.', check if either \ OR / follow */
 911                 if (!p || strchr(p, '/') || strchr(p, '\\'))
 912                 {
 913                     p = filename + strlen(filename);
 914                     strcpy( p, ".exe" );
 915                     handle = LoadModule32( filename, &params );
 916                     *p = '\0';  /* Remove extension */
 917                 }
 918             }
 919         }
 920         else
 921             handle = 2; /* file not found */
 922
 923         if (handle < 32)
 924         {
 925             /* Try to start it as a unix program */
 926             if (!fork())
 927             {
 928                 /* Child process */
 929                 DOS_FULL_NAME full_name;
 930                 const char *unixfilename = NULL;
 931                 const char *argv[256], **argptr;
 932                 int iconic = (nCmdShow == SW_SHOWMINIMIZED ||
 933                               nCmdShow == SW_SHOWMINNOACTIVE);
 934
 935                 THREAD_InitDone = FALSE; /* we didn't init this process */
 936                 /* get unixfilename */
 937                 if (strchr(filename, '/') ||
 938                     strchr(filename, ':') ||
 939                     strchr(filename, '\\'))
 940                 {
 941                     if (DOSFS_GetFullName( filename, TRUE, &full_name ))
 942                         unixfilename = full_name.long_name;
 943                 }
 944                 else unixfilename = filename;
 945
 946                 if (unixfilename)
 947                 {
 948                     /* build argv */
 949                     argptr = argv;
 950                     if (iconic) *argptr++ = "-iconic";
 951                     *argptr++ = unixfilename;
 952                     p = strdup(lpCmdLine);
 953                     while (1)
 954                     {
 955                         while (*p && (*p == ' ' || *p == '\t')) *p++ = '\0';
 956                         if (!*p) break;
 957                         *argptr++ = p;
 958                         while (*p && *p != ' ' && *p != '\t') p++;
 959                     }
 960                     *argptr++ = 0;
 961
 962                     /* Execute */
 963                     execvp(argv[0], (char**)argv);
 964                 }
 965
 966                 /* Failed ! */
 967
 968                 if (__winelib)
 969                 {
 970                     /* build argv */
 971                     argptr = argv;
 972                     *argptr++ = "wine";
 973                     if (iconic) *argptr++ = "-iconic";
 974                     *argptr++ = lpCmdLine;
 975                     *argptr++ = 0;
 976
 977                     /* Execute */
 978                     execvp(argv[0] , (char**)argv);
 979
 980                     /* Failed ! */
 981                     MSG("WinExec: can't exec 'wine %s'\n",
 982                             lpCmdLine);
 983                 }
 984                 exit(1);
 985             }
 986         }
 987     } /* while (!exhausted && handle < 32) */
 988
 989     return handle;
 990 }
 991
 992
 993 /***********************************************************************
 994  *           WIN32_GetProcAddress16   (KERNEL32.36)
 995  * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
 996  */
 997 FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hModule, LPCSTR name )
 998 {
 999     WORD        ordinal;
1000     FARPROC16   ret;
1001
1002     if (!hModule) {
1003         WARN(module,"hModule may not be 0!\n");
1004         return (FARPROC16)0;
1005     }
1006     if (HIWORD(hModule))
1007     {
1008         WARN( module, "hModule is Win32 handle (%08x)\n", hModule );
1009         return (FARPROC16)0;
1010     }
1011     hModule = GetExePtr( hModule );
1012     if (HIWORD(name)) {
1013         ordinal = NE_GetOrdinal( hModule, name );
1014         TRACE(module, "%04x '%s'\n",
1015                         hModule, name );
1016     } else {
1017         ordinal = LOWORD(name);
1018         TRACE(module, "%04x %04x\n",
1019                         hModule, ordinal );
1020     }
1021     if (!ordinal) return (FARPROC16)0;
1022     ret = NE_GetEntryPoint( hModule, ordinal );
1023     TRACE(module,"returning %08x\n",(UINT32)ret);
1024     return ret;
1025 }
1026
1027 /***********************************************************************
1028  *           GetProcAddress16   (KERNEL.50)
1029  */
1030 FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, SEGPTR name )
1031 {
1032     WORD ordinal;
1033     FARPROC16 ret;
1034
1035     if (!hModule) hModule = GetCurrentTask();
1036     hModule = GetExePtr( hModule );
1037
1038     if (HIWORD(name) != 0)
1039     {
1040         ordinal = NE_GetOrdinal( hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
1041         TRACE(module, "%04x '%s'\n",
1042                         hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
1043     }
1044     else
1045     {
1046         ordinal = LOWORD(name);
1047         TRACE(module, "%04x %04x\n",
1048                         hModule, ordinal );
1049     }
1050     if (!ordinal) return (FARPROC16)0;
1051
1052     ret = NE_GetEntryPoint( hModule, ordinal );
1053
1054     TRACE(module, "returning %08x\n", (UINT32)ret );
1055     return ret;
1056 }
1057
1058
1059 /***********************************************************************
1060  *           GetProcAddress32                   (KERNEL32.257)
1061  */
1062 FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
1063 {
1064     return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function, TRUE );
1065 }
1066
1067 /***********************************************************************
1068  *           WIN16_GetProcAddress32             (KERNEL.453)
1069  */
1070 FARPROC32 WINAPI WIN16_GetProcAddress32( HMODULE32 hModule, LPCSTR function )
1071 {
1072     return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function, FALSE );
1073 }
1074
1075 /***********************************************************************
1076  *           MODULE_GetProcAddress32            (internal)
1077  */
1078 FARPROC32 MODULE_GetProcAddress32(
1079         PDB32 *process,         /* [in] process context */
1080         HMODULE32 hModule,      /* [in] current module handle */
1081         LPCSTR function,        /* [in] function to be looked up */
1082         BOOL32 snoop )
1083 {
1084     WINE_MODREF *wm = MODULE32_LookupHMODULE(process,hModule);
1085
1086     if (HIWORD(function))
1087         TRACE(win32,"(%08lx,%s)\n",(DWORD)hModule,function);
1088     else
1089         TRACE(win32,"(%08lx,%p)\n",(DWORD)hModule,function);
1090     if (!wm)
1091         return (FARPROC32)0;
1092     switch (wm->type)
1093     {
1094     case MODULE32_PE:
1095         return PE_FindExportedFunction( process, wm, function, snoop );
1096     case MODULE32_ELF:
1097         return ELF_FindExportedFunction( process, wm, function);
1098     default:
1099         ERR(module,"wine_modref type %d not handled.\n",wm->type);
1100         return (FARPROC32)0;
1101     }
1102 }
1103
1104
1105 /***********************************************************************
1106  *           RtlImageNtHeaders   (NTDLL)
1107  */
1108 LPIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
1109 {
1110     /* basically:
1111      * return  hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew);
1112      * but we could get HMODULE16 or the like (think builtin modules)
1113      */
1114
1115     WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule );
1116     if (!wm || (wm->type != MODULE32_PE)) return (LPIMAGE_NT_HEADERS)0;
1117     return PE_HEADER(wm->module);
1118 }
1119
1120
1121 /***************************************************************************
1122  *              HasGPHandler                    (KERNEL.338)
1123  */
1124
1125 #pragma pack(1)
1126 typedef struct _GPHANDLERDEF
1127 {
1128     WORD selector;
1129     WORD rangeStart;
1130     WORD rangeEnd;
1131     WORD handler;
1132 } GPHANDLERDEF;
1133 #pragma pack(4)
1134
1135 SEGPTR WINAPI HasGPHandler( SEGPTR address )
1136 {
1137     HMODULE16 hModule;
1138     int gpOrdinal;
1139     SEGPTR gpPtr;
1140     GPHANDLERDEF *gpHandler;
1141
1142     if (    (hModule = FarGetOwner( SELECTOROF(address) )) != 0
1143          && (gpOrdinal = NE_GetOrdinal( hModule, "__GP" )) != 0
1144          && (gpPtr = (SEGPTR)NE_GetEntryPointEx( hModule, gpOrdinal, FALSE )) != 0
1145          && !IsBadReadPtr16( gpPtr, sizeof(GPHANDLERDEF) )
1146          && (gpHandler = PTR_SEG_TO_LIN( gpPtr )) != NULL )
1147     {
1148         while (gpHandler->selector)
1149         {
1150             if (    SELECTOROF(address) == gpHandler->selector
1151                  && OFFSETOF(address)   >= gpHandler->rangeStart
1152                  && OFFSETOF(address)   <  gpHandler->rangeEnd  )
1153                 return PTR_SEG_OFF_TO_SEGPTR( gpHandler->selector,
1154                                               gpHandler->handler );
1155             gpHandler++;
1156         }
1157     }
1158
1159     return 0;
1160 }
1161