Ignore:
Timestamp:
Sep 9, 2016, 7:15:22 PM (9 years ago)
Author:
bird
Message:

Made link work inside kWorker too.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kWorker/kWorker.c

    r2900 r2902  
    443443
    444444
     445/** Pointer to a heap (HeapCreate) tracker entry. */
     446typedef struct KWHEAP *PKWHEAP;
     447/**
     448 * Tracking an heap (HeapCreate)
     449 */
     450typedef struct KWHEAP
     451{
     452    PKWHEAP             pNext;
     453    HANDLE              hHeap;
     454} KWHEAP;
     455
     456
    445457/** Pointer to a FlsAlloc/TlsAlloc tracker entry. */
    446458typedef struct KWLOCALSTORAGE *PKWLOCALSTORAGE;
    … …  
    453465    KU32                idx;
    454466} KWLOCALSTORAGE;
     467
     468
     469/** Pointer to an at exit callback record */
     470typedef struct KWEXITCALLACK *PKWEXITCALLACK;
     471/**
     472 * At exit callback record.
     473 */
     474typedef struct KWEXITCALLACK
     475{
     476    PKWEXITCALLACK      pNext;
     477    _onexit_t           pfnCallback;
     478    /** At exit doesn't have an exit code. */
     479    KBOOL               fAtExit;
     480} KWEXITCALLACK;
    455481
    456482
    … …  
    469495    KWTOOLHINT_NONE,
    470496    KWTOOLHINT_VISUAL_CPP_CL,
     497    KWTOOLHINT_VISUAL_CPP_LINK,
    471498    KWTOOLHINT_END
    472499} KWTOOLHINT;
    … …  
    577604    /** Head of the virtual alloc allocations. */
    578605    PKWVIRTALLOC    pVirtualAllocHead;
     606    /** Head of the heap list (HeapCreate).
     607     * This is only done from images we forcibly restore.  */
     608    PKWHEAP         pHeapHead;
    579609    /** Head of the FlsAlloc indexes. */
    580610    PKWLOCALSTORAGE pFlsAllocHead;
    581611    /** Head of the TlsAlloc indexes. */
    582612    PKWLOCALSTORAGE pTlsAllocHead;
     613
     614    /** The at exit callback head.
     615     * This is only done from images we forcibly restore.  */
     616    PKWEXITCALLACK  pExitCallbackHead;
    583617
    584618    UNICODE_STRING  SavedCommandLine;
    … …  
    627661    /** The replacement function or data address. */
    628662    KUPTR       pfnReplacement;
     663    /** Only replace in the executable.
     664     * @todo fix the reinitialization of non-native DLLs!  */
     665    KBOOL       fOnlyExe;
    629666} KWREPLACEMENTFUNCTION;
    630667typedef KWREPLACEMENTFUNCTION const *PCKWREPLACEMENTFUNCTION;
    … …  
    17591796                    || kHlpStrICompAscii(g_aSandboxReplacements[i].pszModule, &pImpMod->pszPath[pImpMod->offFilename]) == 0)
    17601797                {
    1761                     KW_LOG(("replacing %s!%s\n", &pImpMod->pszPath[pImpMod->offFilename], g_aSandboxReplacements[i].pszFunction));
    1762                     *puValue = g_aSandboxReplacements[i].pfnReplacement;
     1798                    if (   pCurMod->fExe
     1799                        || !g_aSandboxReplacements[i].fOnlyExe)
     1800                    {
     1801                        KW_LOG(("replacing %s!%s\n",&pImpMod->pszPath[pImpMod->offFilename], g_aSandboxReplacements[i].pszFunction));
     1802                        *puValue = g_aSandboxReplacements[i].pfnReplacement;
     1803                    }
    17631804                    break;
    17641805                }
    … …  
    22922333                if (kHlpStrICompAscii(pToolFsObj->pszName, "cl.exe") == 0)
    22932334                    pTool->u.Sandboxed.enmHint = KWTOOLHINT_VISUAL_CPP_CL;
     2335                else if (kHlpStrICompAscii(pToolFsObj->pszName, "link.exe") == 0)
     2336                    pTool->u.Sandboxed.enmHint = KWTOOLHINT_VISUAL_CPP_LINK;
    22942337                else
    22952338                    pTool->u.Sandboxed.enmHint = KWTOOLHINT_NONE;
    … …  
    25922635
    25932636
     2637/** CRT - _onexit   */
     2638static _onexit_t __cdecl kwSandbox_msvcrt__onexit(_onexit_t pfnFunc)
     2639{
     2640    PKWEXITCALLACK pCallback;
     2641    KW_LOG(("_onexit(%p)\n", pfnFunc));
     2642    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     2643
     2644    pCallback = kHlpAlloc(sizeof(*pCallback));
     2645    if (pCallback)
     2646    {
     2647        pCallback->pfnCallback = pfnFunc;
     2648        pCallback->fAtExit     = K_FALSE;
     2649        pCallback->pNext       = g_Sandbox.pExitCallbackHead;
     2650        g_Sandbox.pExitCallbackHead = pCallback;
     2651        return pfnFunc;
     2652    }
     2653
     2654    return NULL;
     2655}
     2656
     2657
     2658/** CRT - atexit   */
     2659static int __cdecl kwSandbox_msvcrt_atexit(int (__cdecl *pfnFunc)(void))
     2660{
     2661    PKWEXITCALLACK pCallback;
     2662    KW_LOG(("_onexit(%p)\n", pfnFunc));
     2663    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     2664
     2665    pCallback = kHlpAlloc(sizeof(*pCallback));
     2666    if (pCallback)
     2667    {
     2668        pCallback->pfnCallback = (_onexit_t)pfnFunc;
     2669        pCallback->fAtExit     = K_TRUE;
     2670        pCallback->pNext       = g_Sandbox.pExitCallbackHead;
     2671        g_Sandbox.pExitCallbackHead = pCallback;
     2672        return 0;
     2673    }
     2674
     2675    return -1;
     2676}
     2677
     2678
    25942679/** Kernel32 - SetConsoleCtrlHandler(). */
    25952680static BOOL WINAPI kwSandbox_Kernel32_SetConsoleCtrlHandler(PHANDLER_ROUTINE pfnHandler, BOOL fAdd)
    … …  
    26042689                                                  int dowildcard, int const *piNewMode)
    26052690{
     2691    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26062692    *pargc = g_Sandbox.cArgs;
    26072693    *pargv = g_Sandbox.papszArgs;
    … …  
    26172703                                                   int dowildcard, int const *piNewMode)
    26182704{
     2705    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26192706    *pargc = g_Sandbox.cArgs;
    26202707    *pargv = g_Sandbox.papwszArgs;
    … …  
    26302717static LPCSTR /*LPSTR*/ WINAPI kwSandbox_Kernel32_GetCommandLineA(VOID)
    26312718{
     2719    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26322720    return g_Sandbox.pszCmdLine;
    26332721}
    … …  
    26372725static LPCWSTR /*LPWSTR*/ WINAPI kwSandbox_Kernel32_GetCommandLineW(VOID)
    26382726{
     2727    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26392728    return g_Sandbox.pwszCmdLine;
    26402729}
    … …  
    26682757static int * __cdecl kwSandbox_msvcrt___p___argc(void)
    26692758{
     2759    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26702760    return &g_Sandbox.cArgs;
    26712761}
    … …  
    26752765static char *** __cdecl kwSandbox_msvcrt___p___argv(void)
    26762766{
     2767    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26772768    return &g_Sandbox.papszArgs;
    26782769}
    … …  
    26822773static wchar_t *** __cdecl kwSandbox_msvcrt___p___wargv(void)
    26832774{
     2775    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26842776    return &g_Sandbox.papwszArgs;
    26852777}
    … …  
    26892781static char ** __cdecl kwSandbox_msvcrt___p__acmdln(void)
    26902782{
     2783    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26912784    return (char **)&g_Sandbox.pszCmdLine;
    26922785}
    … …  
    26962789static wchar_t ** __cdecl kwSandbox_msvcrt___p__wcmdln(void)
    26972790{
     2791    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    26982792    return &g_Sandbox.pwszCmdLine;
    26992793}
    … …  
    27032797static char ** __cdecl kwSandbox_msvcrt___p__pgmptr(void)
    27042798{
     2799    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27052800    return &g_Sandbox.pgmptr;
    27062801}
    … …  
    27102805static wchar_t ** __cdecl kwSandbox_msvcrt___p__wpgmptr(void)
    27112806{
     2807    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27122808    return &g_Sandbox.wpgmptr;
    27132809}
    … …  
    27172813static errno_t __cdecl kwSandbox_msvcrt__get_pgmptr(char **ppszValue)
    27182814{
     2815    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27192816    *ppszValue = g_Sandbox.pgmptr;
    27202817    return 0;
    … …  
    27252822static errno_t __cdecl kwSandbox_msvcrt__get_wpgmptr(wchar_t **ppwszValue)
    27262823{
     2824    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27272825    *ppwszValue = g_Sandbox.wpgmptr;
    27282826    return 0;
    … …  
    27322830static void kwSandbox_msvcrt__wincmdln(void)
    27332831{
     2832    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27342833    KWFS_TODO();
    27352834}
    … …  
    27392838static void kwSandbox_msvcrt__wwincmdln(void)
    27402839{
     2840    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27412841    KWFS_TODO();
    27422842}
    … …  
    27472847                                                     DWORD fFlags, PDWORD pidThread)
    27482848{
    2749     KWFS_TODO();
    2750     return NULL;
     2849    HANDLE hThread = NULL;
     2850    KW_LOG(("CreateThread: pSecAttr=%p (inh=%d) cbStack=%#x pfnThreadProc=%p pvUser=%p fFlags=%#x pidThread=%p\n",
     2851            pSecAttr, pSecAttr ? pSecAttr->bInheritHandle : 0, cbStack, pfnThreadProc, pvUser, fFlags, pidThread));
     2852    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     2853    if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
     2854    {
     2855        /* Allow link::DbgThread. */
     2856        hThread = CreateThread(pSecAttr, cbStack, pfnThreadProc, pvUser, fFlags, pidThread);
     2857        KW_LOG(("CreateThread -> %p, *pidThread=%#x\n", hThread, pidThread ? *pidThread : 0));
     2858    }
     2859    else
     2860        KWFS_TODO();
     2861    return hThread;
    27512862}
    27522863
    … …  
    27552866static uintptr_t __cdecl kwSandbox_msvcrt__beginthread(void (__cdecl *pfnThreadProc)(void *), unsigned cbStack, void *pvUser)
    27562867{
     2868    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27572869    KWFS_TODO();
    27582870    return 0;
    … …  
    27652877                                                         unsigned fCreate, unsigned *pidThread)
    27662878{
     2879    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    27672880    KWFS_TODO();
    27682881    return 0;
    … …  
    27822895{
    27832896    char *pszzEnv;
    2784 
    2785     /* Figure how space much we need first.  */
    27862897    char *pszCur;
    27872898    KSIZE cbNeeded = 1;
    27882899    KSIZE iVar = 0;
     2900
     2901    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     2902
     2903    /* Figure how space much we need first.  */
    27892904    while ((pszCur = g_Sandbox.papszEnvVars[iVar++]) != NULL)
    27902905        cbNeeded += kHlpStrLen(pszCur) + 1;
    … …  
    28372952{
    28382953    wchar_t *pwszzEnv;
    2839 
    2840     /* Figure how space much we need first.  */
    28412954    wchar_t *pwszCur;
    28422955    KSIZE    cwcNeeded = 1;
    28432956    KSIZE    iVar = 0;
     2957
     2958    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     2959
     2960    /* Figure how space much we need first.  */
    28442961    while ((pwszCur = g_Sandbox.papwszEnvVars[iVar++]) != NULL)
    28452962        cwcNeeded += kwUtf16Len(pwszCur) + 1;
    … …  
    28702987{
    28712988    KW_LOG(("FreeEnvironmentStringsA: %p -> TRUE\n", pszzEnv));
     2989    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    28722990    kHlpFree(pszzEnv);
    28732991    return TRUE;
    … …  
    28792997{
    28802998    KW_LOG(("FreeEnvironmentStringsW: %p -> TRUE\n", pwszzEnv));
     2999    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    28813000    kHlpFree(pwszzEnv);
    28823001    return TRUE;
    … …  
    32063325static DWORD WINAPI kwSandbox_Kernel32_GetEnvironmentVariableA(LPCSTR pszVar, LPSTR pszValue, DWORD cbValue)
    32073326{
    3208     char *pszFoundValue = kwSandboxDoGetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar));
     3327    char *pszFoundValue;
     3328    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3329
     3330    pszFoundValue = kwSandboxDoGetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar));
    32093331    if (pszFoundValue)
    32103332    {
    … …  
    32223344static DWORD WINAPI kwSandbox_Kernel32_GetEnvironmentVariableW(LPCWSTR pwszVar, LPWSTR pwszValue, DWORD cwcValue)
    32233345{
    3224     wchar_t *pwszFoundValue = kwSandboxDoGetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar));
     3346    wchar_t *pwszFoundValue;
     3347    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3348
     3349    pwszFoundValue = kwSandboxDoGetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar));
    32253350    if (pwszFoundValue)
    32263351    {
    … …  
    32393364{
    32403365    int rc;
     3366    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3367
    32413368    if (pszValue)
    32423369        rc = kwSandboxDoSetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar), pszValue);
    … …  
    32613388{
    32623389    int rc;
     3390    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3391
    32633392    if (pwszValue)
    32643393        rc = kwSandboxDoSetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar), pwszValue);
    … …  
    32823411static DWORD WINAPI kwSandbox_Kernel32_ExpandEnvironmentStringsA(LPCSTR pszSrc, LPSTR pwszDst, DWORD cbDst)
    32833412{
     3413    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    32843414    KWFS_TODO();
    32853415    return 0;
    … …  
    32903420static DWORD WINAPI kwSandbox_Kernel32_ExpandEnvironmentStringsW(LPCWSTR pwszSrc, LPWSTR pwszDst, DWORD cbDst)
    32913421{
     3422    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    32923423    KWFS_TODO();
    32933424    return 0;
    … …  
    32993430{
    33003431    int rc;
    3301     char const *pszEqual = kHlpStrChr(pszVarEqualValue, '=');
     3432    char const *pszEqual;
     3433    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3434
     3435    pszEqual = kHlpStrChr(pszVarEqualValue, '=');
    33023436    if (pszEqual)
    33033437    {
    … …  
    33223456{
    33233457    int rc;
    3324     wchar_t const *pwszEqual = wcschr(pwszVarEqualValue, '=');
     3458    wchar_t const *pwszEqual;
     3459    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3460
     3461    pwszEqual = wcschr(pwszVarEqualValue, '=');
    33253462    if (pwszEqual)
    33263463    {
    … …  
    33443481static errno_t __cdecl kwSandbox_msvcrt__putenv_s(const char *pszVar, const char *pszValue)
    33453482{
    3346     char const *pszEqual = kHlpStrChr(pszVar, '=');
     3483    char const *pszEqual;
     3484    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3485
     3486    pszEqual = kHlpStrChr(pszVar, '=');
    33473487    if (pszEqual == NULL)
    33483488    {
    … …  
    33733513static errno_t __cdecl kwSandbox_msvcrt__wputenv_s(const wchar_t *pwszVar, const wchar_t *pwszValue)
    33743514{
    3375     wchar_t const *pwszEqual = wcschr(pwszVar, '=');
     3515    wchar_t const *pwszEqual;
     3516    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     3517
     3518    pwszEqual = wcschr(pwszVar, '=');
    33763519    if (pwszEqual == NULL)
    33773520    {
    … …  
    34033546{
    34043547    KW_LOG(("__p___initenv\n"));
     3548    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34053549    KWFS_TODO();
    34063550    return &g_Sandbox.initenv;
    … …  
    34123556{
    34133557    KW_LOG(("__p___winitenv\n"));
     3558    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34143559    KWFS_TODO();
    34153560    return &g_Sandbox.winitenv;
    … …  
    34213566{
    34223567    KW_LOG(("__p__environ\n"));
     3568    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34233569    return &g_Sandbox.environ;
    34243570}
    … …  
    34293575{
    34303576    KW_LOG(("__p__wenviron\n"));
     3577    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34313578    return &g_Sandbox.wenviron;
    34323579}
    … …  
    34383585{
    34393586    KWFS_TODO(); /** @todo check the callers expectations! */
     3587    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34403588    *ppapszEnviron = g_Sandbox.environ;
    34413589    return 0;
    … …  
    34483596{
    34493597    KWFS_TODO(); /** @todo check the callers expectations! */
     3598    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    34503599    *ppapwszEnviron = g_Sandbox.wenviron;
    34513600    return 0;
    … …  
    35853734    PKWMODULE   pMod;
    35863735    int         rc;
     3736    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    35873737
    35883738    /*
    … …  
    37323882{
    37333883    /* Ignored, we like to keep everything loaded. */
     3884    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    37343885    return TRUE;
    37353886}
    … …  
    37413892    KSIZE i;
    37423893    KSIZE cchModule;
     3894    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    37433895
    37443896    /*
    … …  
    37713923    KSIZE i;
    37723924    KSIZE cwcModule;
     3925    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    37733926
    37743927    /*
    … …  
    37993952static UINT WINAPI kwSandbox_BreakIntoDebugger(void *pv1, void *pv2, void *pv3, void *pv4)
    38003953{
     3954#ifdef _MSC_VER
     3955    __debugbreak();
     3956#else
    38013957    KWFS_TODO();
     3958#endif
    38023959    return -1;
    38033960}
    … …  
    38083965{
    38093966    KSIZE i;
     3967    PKWMODULE pMod;
     3968    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    38103969
    38113970    /*
    38123971     * Try locate the module.
    38133972     */
    3814     PKWMODULE pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
     3973    pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
    38153974    if (pMod)
    38163975    {
    … …  
    38584017static DWORD WINAPI kwSandbox_Kernel32_GetModuleFileNameA(HMODULE hmod, LPSTR pszFilename, DWORD cbFilename)
    38594018{
    3860     PKWMODULE pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
     4019    PKWMODULE pMod;
     4020    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     4021
     4022    pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
    38614023    if (pMod != NULL)
    38624024    {
    … …  
    38734035static DWORD WINAPI kwSandbox_Kernel32_GetModuleFileNameW(HMODULE hmod, LPWSTR pwszFilename, DWORD cbFilename)
    38744036{
    3875     PKWMODULE pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
     4037    PKWMODULE pMod;
     4038    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     4039
     4040    pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
    38764041    if (pMod)
    38774042    {
    … …  
    43664531    MY_UNICODE_STRING       UniStr;
    43674532    MY_NTSTATUS             rcNt;
     4533    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    43684534
    43694535    /*
    … …  
    45384704                    {
    45394705                        KFSLOOKUPERROR enmError;
    4540                         PKFSOBJ pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
     4706                        PKFSOBJ pFsObj;
     4707                        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     4708
     4709                        pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
    45414710                        if (pFsObj)
    45424711                        {
    … …  
    46174786                    if (kwFsIsCachablePathExtensionW(pwszFilename, K_FALSE /*fAttrQuery*/))
    46184787                    {
    4619                         /** @todo rewrite to pure UTF-16. */
     4788                        /** @todo rewrite in pure UTF-16. */
    46204789                        char szTmp[2048];
    46214790                        KSIZE cch = kwUtf16ToStr(pwszFilename, szTmp, sizeof(szTmp));
    … …  
    46484817{
    46494818    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     4819    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    46504820    if (idxHandle < g_Sandbox.cHandles)
    46514821    {
    … …  
    47284898{
    47294899    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     4900    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    47304901    if (idxHandle < g_Sandbox.cHandles)
    47314902    {
    … …  
    48074978{
    48084979    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     4980    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    48094981    if (idxHandle < g_Sandbox.cHandles)
    48104982    {
    … …  
    49225094{
    49235095    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5096    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    49245097    if (idxHandle < g_Sandbox.cHandles)
    49255098    {
    … …  
    49985171{
    49995172    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5173    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    50005174    if (idxHandle < g_Sandbox.cHandles)
    50015175    {
    … …  
    51035277{
    51045278    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5279    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    51055280    if (idxHandle < g_Sandbox.cHandles)
    51065281    {
    … …  
    51215296{
    51225297    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5298    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    51235299    if (idxHandle < g_Sandbox.cHandles)
    51245300    {
    … …  
    51675343{
    51685344    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5345    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    51695346    if (idxHandle < g_Sandbox.cHandles)
    51705347    {
    … …  
    51945371{
    51955372    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5373    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    51965374    if (idxHandle < g_Sandbox.cHandles)
    51975375    {
    … …  
    52295407{
    52305408    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5409    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    52315410    if (idxHandle < g_Sandbox.cHandles)
    52325411    {
    … …  
    52655444{
    52665445    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
     5446    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    52675447    if (idxHandle < g_Sandbox.cHandles)
    52685448    {
    … …  
    53045484{
    53055485    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hSection);
     5486    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    53065487    if (idxHandle < g_Sandbox.cHandles)
    53075488    {
    … …  
    53895570    /* Is this one of our temporary mappings? */
    53905571    PKWFSTEMPFILE pCur = g_Sandbox.pTempFileHead;
     5572    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    53915573    while (pCur)
    53925574    {
    … …  
    54155597    BOOL        fRet;
    54165598    KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hObject);
     5599    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    54175600    if (   idxHandle < g_Sandbox.cHandles
    54185601        && g_Sandbox.papHandles[idxHandle] != NULL)
    … …  
    54545637    {
    54555638        KFSLOOKUPERROR enmError;
    5456         PKFSOBJ pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
     5639        PKFSOBJ pFsObj;
     5640        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     5641
     5642        pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
    54575643        if (pFsObj)
    54585644        {
    … …  
    54845670    {
    54855671        KFSLOOKUPERROR enmError;
    5486         PKFSOBJ pFsObj = kFsCacheLookupNoMissingW(g_pFsCache, pwszFilename, &enmError);
     5672        PKFSOBJ pFsObj;
     5673        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     5674
     5675        pFsObj = kFsCacheLookupNoMissingW(g_pFsCache, pwszFilename, &enmError);
    54875676        if (pFsObj)
    54885677        {
    … …  
    55165705    {
    55175706        KFSLOOKUPERROR enmError;
    5518         PKFSOBJ pObj = kFsCacheLookupW(g_pFsCache, pwszLongPath, &enmError);
     5707        PKFSOBJ pObj;
     5708        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     5709
     5710        pObj = kFsCacheLookupW(g_pFsCache, pwszLongPath, &enmError);
    55195711        if (pObj)
    55205712        {
    … …  
    55685760        && kwFsIsClTempFileW(pwszFilename))
    55695761    {
     5762        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    55705763        KWFS_LOG(("DeleteFileW(%s) -> TRUE [temp]\n", pwszFilename));
    55715764        fRc = TRUE;
    … …  
    59786171    BOOL                    fRc;
    59796172    PKWCONSOLEOUTPUTLINE    pLineBuf;
     6173    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    59806174
    59816175    if (hConOutput == g_Sandbox.StdErr.hOutput)
    … …  
    60096203    BOOL                    fRc;
    60106204    PKWCONSOLEOUTPUTLINE    pLineBuf;
     6205    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    60116206
    60126207    if (hConOutput == g_Sandbox.StdErr.hOutput)
    … …  
    60546249        && pvMem)
    60556250    {
    6056         PKWVIRTALLOC pTracker = g_Sandbox.pVirtualAllocHead;
     6251        PKWVIRTALLOC pTracker;
     6252        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     6253
     6254        pTracker = g_Sandbox.pVirtualAllocHead;
    60576255        while (   pTracker
    60586256               && (KUPTR)pvMem - (KUPTR)pTracker->pvAlloc >= pTracker->cbAlloc)
    … …  
    60836281    if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL)
    60846282    {
     6283        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    60856284        if (dwFreeType & MEM_RELEASE)
    60866285        {
    … …  
    61126311
    61136312
     6313/** Kernel32 - HeapCreate / NtDll - RTlCreateHeap  */
     6314HANDLE WINAPI kwSandbox_Kernel32_HeapCreate(DWORD fOptions, SIZE_T cbInitial, SIZE_T cbMax)
     6315{
     6316    HANDLE hHeap;
     6317    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     6318
     6319    hHeap = HeapCreate(fOptions, cbInitial, cbMax);
     6320    if (hHeap != NULL)
     6321    {
     6322        DWORD dwErr = GetLastError();
     6323        PKWHEAP pTracker = (PKWHEAP)kHlpAlloc(sizeof(*pTracker));
     6324        if (pTracker)
     6325        {
     6326            pTracker->hHeap = hHeap;
     6327            pTracker->pNext = g_Sandbox.pHeapHead;
     6328            g_Sandbox.pHeapHead = pTracker;
     6329        }
     6330
     6331        SetLastError(dwErr);
     6332    }
     6333    return hHeap;
     6334
     6335}
     6336
     6337
     6338/** Kernel32 - HeapDestroy / NtDll - RTlDestroyHeap */
     6339BOOL WINAPI kwSandbox_Kernel32_HeapDestroy(HANDLE hHeap)
     6340{
     6341    BOOL fRc = HeapDestroy(hHeap);
     6342    KW_LOG(("HeapDestroy: hHeap=%p -> %d\n", hHeap, fRc));
     6343    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     6344    if (fRc)
     6345    {
     6346        PKWHEAP pTracker = g_Sandbox.pHeapHead;
     6347        if (pTracker)
     6348        {
     6349            if (pTracker->hHeap == hHeap)
     6350                g_Sandbox.pHeapHead = pTracker->pNext;
     6351            else
     6352            {
     6353                PKWHEAP pPrev;
     6354                do
     6355                {
     6356                    pPrev = pTracker;
     6357                    pTracker = pTracker->pNext;
     6358                } while (pTracker && pTracker->hHeap == hHeap);
     6359                if (pTracker)
     6360                    pPrev->pNext = pTracker->pNext;
     6361            }
     6362            if (pTracker)
     6363                kHlpFree(pTracker);
     6364            else
     6365                KW_LOG(("HeapDestroy: pvAddr=%p not found!\n", hHeap));
     6366        }
     6367    }
     6368
     6369    return fRc;
     6370}
     6371
     6372
    61146373
    61156374/*
    … …  
    61366395        if (pTracker)
    61376396        {
     6397            kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    61386398            pTracker->idx = idxFls;
    61396399            pTracker->pNext = g_Sandbox.pFlsAllocHead;
    … …  
    61526412    if (fRc)
    61536413    {
    6154         PKWLOCALSTORAGE pTracker = g_Sandbox.pFlsAllocHead;
     6414        PKWLOCALSTORAGE pTracker;
     6415        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
     6416
     6417        pTracker = g_Sandbox.pFlsAllocHead;
    61556418        if (pTracker)
    61566419        {
    … …  
    62156478                    if (pHash)
    62166479                    {
     6480                        kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    62176481                        pHash->uMagic        = KWHASHMD5_MAGIC;
    62186482                        pHash->cbHashed      = 0;
    … …  
    62586522    BOOL        fRc;
    62596523    PKWHASHMD5  pHash = g_Sandbox.pHashHead;
     6524    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    62606525    while (pHash && (KUPTR)pHash != hHash)
    62616526        pHash = pHash->pNext;
    … …  
    63736638    BOOL        fRc;
    63746639    PKWHASHMD5  pHash = g_Sandbox.pHashHead;
     6640    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    63756641    while (pHash && (KUPTR)pHash != hHash)
    63766642        pHash = pHash->pNext;
    … …  
    65306796    PKWHASHMD5  pPrev = NULL;
    65316797    PKWHASHMD5  pHash = g_Sandbox.pHashHead;
     6798    kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
    65326799    while (pHash && (KUPTR)pHash != hHash)
    65336800    {
    … …  
    66686935    { TUPLE("VirtualFree"),                 NULL,       (KUPTR)kwSandbox_Kernel32_VirtualFree },
    66696936
     6937    { TUPLE("HeapCreate"),                  NULL,       (KUPTR)kwSandbox_Kernel32_HeapCreate,       K_TRUE /*fOnlyExe*/ },
     6938    { TUPLE("HeapDestroy"),                 NULL,       (KUPTR)kwSandbox_Kernel32_HeapDestroy,      K_TRUE /*fOnlyExe*/ },
     6939
    66706940    { TUPLE("FlsAlloc"),                    NULL,       (KUPTR)kwSandbox_Kernel32_FlsAlloc },
    66716941    { TUPLE("FlsFree"),                     NULL,       (KUPTR)kwSandbox_Kernel32_FlsFree },
    … …  
    66896959    { TUPLE("_amsg_exit"),                  NULL,       (KUPTR)kwSandbox_msvcrt__amsg_exit },
    66906960    { TUPLE("terminate"),                   NULL,       (KUPTR)kwSandbox_msvcrt_terminate },
     6961
     6962    { TUPLE("onexit"),                      NULL,       (KUPTR)kwSandbox_msvcrt__onexit,            K_TRUE /*fOnlyExe*/ },
     6963    { TUPLE("_onexit"),                     NULL,       (KUPTR)kwSandbox_msvcrt__onexit,            K_TRUE /*fOnlyExe*/ },
     6964    { TUPLE("atexit"),                      NULL,       (KUPTR)kwSandbox_msvcrt_atexit,             K_TRUE /*fOnlyExe*/ },
    66916965
    66926966    { TUPLE("_beginthread"),                NULL,       (KUPTR)kwSandbox_msvcrt__beginthread },
    … …  
    72007474    PROCESS_MEMORY_COUNTERS     MemInfo;
    72017475    PKWVIRTALLOC                pTracker;
     7476    PKWHEAP                     pHeap;
    72027477    PKWLOCALSTORAGE             pLocalStorage;
    72037478#ifdef WITH_HASH_MD5_CACHE
    … …  
    72067481#ifdef WITH_TEMP_MEMORY_FILES
    72077482    PKWFSTEMPFILE               pTempFile;
    7208 
     7483#endif
     7484    PKWEXITCALLACK              pExitCallback;
     7485
     7486    /* Do exit callback first. */
     7487    pExitCallback = g_Sandbox.pExitCallbackHead;
     7488    g_Sandbox.pExitCallbackHead = NULL;
     7489    while (pExitCallback)
     7490    {
     7491        PKWEXITCALLACK  pNext = pExitCallback->pNext;
     7492        KW_LOG(("kwSandboxCleanupLate: calling %p %sexit handler\n",
     7493                pExitCallback->pfnCallback, pExitCallback->fAtExit ? "at" : "_on"));
     7494        __try
     7495        {
     7496            pExitCallback->pfnCallback();
     7497        }
     7498        __except (EXCEPTION_EXECUTE_HANDLER)
     7499        {
     7500            KW_LOG(("kwSandboxCleanupLate: %sexit handler %p threw an exception!\n",
     7501                    pExitCallback->fAtExit ? "at" : "_on", pExitCallback->pfnCallback));
     7502            kHlpAssertFailed();
     7503        }
     7504        kHlpFree(pExitCallback);
     7505        pExitCallback = pNext;
     7506    }
     7507
     7508
     7509#ifdef WITH_TEMP_MEMORY_FILES
    72097510    /* The temporary files aren't externally visible, they're all in memory. */
    72107511    pTempFile = pSandbox->pTempFileHead;
    … …  
    72347535        kHlpFree(pTracker);
    72357536        pTracker = pNext;
     7537    }
     7538
     7539    /* Free left behind HeapCreate leaks. */
     7540    pHeap = g_Sandbox.pHeapHead;
     7541    g_Sandbox.pHeapHead = NULL;
     7542    while (pHeap != NULL)
     7543    {
     7544        PKWHEAP pNext = pHeap->pNext;
     7545        KW_LOG(("Freeing HeapCreate leak %p\n", pHeap->hHeap));
     7546        HeapDestroy(pHeap->hHeap);
     7547        pHeap = pNext;
    72367548    }
    72377549
Note: See TracChangeset for help on using the changeset viewer.