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