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