开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WinBase.Inl
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：17k
源码类别：

模拟服务器

开发平台：

C/C++

WinBase.Inl：源码内容
  1. /* Copyright (c) 2001 Microsoft Corp. All rights reserved. */
  3. #if _MSC_VER > 1000
  4. #pragma once
  5. #endif
  7. #if defined(__cplusplus)
  8. extern "C" {
  9. #endif
  12. #if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */
  13. #if ISOLATION_AWARE_ENABLED
  16. #if !defined(ISOLATION_AWARE_INLINE)
  17. #if defined(__cplusplus)
  18. #define ISOLATION_AWARE_INLINE inline
  19. #else
  20. #define ISOLATION_AWARE_INLINE __inline
  21. #endif
  22. #endif
  26. BOOL WINAPI IsolationAwarePrivatenCgIiAgEzlnCgpgk(ULONG_PTR* pulpCookie);
  28. /*
  29. These are private.
  30. */
  31. __declspec(selectany) HANDLE WinbaseIsolationAwarePrivateG_HnCgpgk = INVALID_HANDLE_VALUE;
  32. __declspec(selectany) BOOL   IsolationAwarePrivateG_FqbjaLEiEL = FALSE;
  33. __declspec(selectany) BOOL   WinbaseIsolationAwarePrivateG_FpeEAgEDnCgpgk = FALSE;
  34. __declspec(selectany) BOOL   WinbaseIsolationAwarePrivateG_FpLEAahcpALLED = FALSE;
  35. FARPROC WINAPI WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL(LPCSTR pszProcName);
  37. HMODULE WINAPI IsolationAwareLoadLibraryA(LPCSTR lpLibFileName);
  38. HMODULE WINAPI IsolationAwareLoadLibraryW(LPCWSTR lpLibFileName);
  39. HMODULE WINAPI IsolationAwareLoadLibraryExA(LPCSTR lpLibFileName,HANDLE hFile,DWORD dwFlags);
  40. HMODULE WINAPI IsolationAwareLoadLibraryExW(LPCWSTR lpLibFileName,HANDLE hFile,DWORD dwFlags);
  41. HANDLE WINAPI IsolationAwareCreateActCtxW(PCACTCTXW pActCtx);
  42. void WINAPI IsolationAwareReleaseActCtx(HANDLE hActCtx);
  43. BOOL WINAPI IsolationAwareActivateActCtx(HANDLE hActCtx,ULONG_PTR*lpCookie);
  44. BOOL WINAPI IsolationAwareDeactivateActCtx(DWORD dwFlags,ULONG_PTR ulCookie);
  45. BOOL WINAPI IsolationAwareFindActCtxSectionStringW(DWORD dwFlags,const GUID*lpExtensionGuid,ULONG ulSectionId,LPCWSTR lpStringToFind,PACTCTX_SECTION_KEYED_DATA ReturnedData);
  46. BOOL WINAPI IsolationAwareQueryActCtxW(DWORD dwFlags,HANDLE hActCtx,PVOID pvSubInstance,ULONG ulInfoClass,PVOID pvBuffer,SIZE_T cbBuffer,SIZE_T*pcbWrittenOrRequired);
  48. #if defined(UNICODE)
  50. #define IsolationAwareLoadLibrary IsolationAwareLoadLibraryW
  51. #define IsolationAwareLoadLibraryEx IsolationAwareLoadLibraryExW
  53. #else /* UNICODE */
  55. #define IsolationAwareLoadLibrary IsolationAwareLoadLibraryA
  56. #define IsolationAwareLoadLibraryEx IsolationAwareLoadLibraryExA
  58. #endif /* UNICODE */
  60. ISOLATION_AWARE_INLINE HMODULE WINAPI IsolationAwareLoadLibraryA(LPCSTR lpLibFileName)
  61. {
  62.     HMODULE moduleResult = NULL;
  63.     ULONG_PTR  ulpCookie = 0;
  64.     const BOOL fActivateActCtxSuccess = IsolationAwarePrivateG_FqbjaLEiEL || IsolationAwarePrivatenCgIiAgEzlnCgpgk(&ulpCookie);
  65.     if (!fActivateActCtxSuccess)
  66.         return moduleResult;
  67.     __try
  68.     {
  69.         moduleResult = LoadLibraryA(lpLibFileName);
  70.     }
  71.     __finally
  72.     {
  73.         if (!IsolationAwarePrivateG_FqbjaLEiEL)
  74.         {
  75.             const BOOL fPreserveLastError = (moduleResult == NULL);
  76.             const DWORD dwLastError = fPreserveLastError ? GetLastError() : NO_ERROR;
  77.             (void)IsolationAwareDeactivateActCtx(0, ulpCookie);
  78.             if (fPreserveLastError)
  79.                 SetLastError(dwLastError);
  80.         }
  81.     }
  82.     return moduleResult;
  83. }
  85. ISOLATION_AWARE_INLINE HMODULE WINAPI IsolationAwareLoadLibraryW(LPCWSTR lpLibFileName)
  86. {
  87.     HMODULE moduleResult = NULL;
  88.     ULONG_PTR  ulpCookie = 0;
  89.     const BOOL fActivateActCtxSuccess = IsolationAwarePrivateG_FqbjaLEiEL || IsolationAwarePrivatenCgIiAgEzlnCgpgk(&ulpCookie);
  90.     if (!fActivateActCtxSuccess)
  91.         return moduleResult;
  92.     __try
  93.     {
  94.         moduleResult = LoadLibraryW(lpLibFileName);
  95.     }
  96.     __finally
  97.     {
  98.         if (!IsolationAwarePrivateG_FqbjaLEiEL)
  99.         {
  100.             const BOOL fPreserveLastError = (moduleResult == NULL);
  101.             const DWORD dwLastError = fPreserveLastError ? GetLastError() : NO_ERROR;
  102.             (void)IsolationAwareDeactivateActCtx(0, ulpCookie);
  103.             if (fPreserveLastError)
  104.                 SetLastError(dwLastError);
  105.         }
  106.     }
  107.     return moduleResult;
  108. }
  110. ISOLATION_AWARE_INLINE HMODULE WINAPI IsolationAwareLoadLibraryExA(LPCSTR lpLibFileName,HANDLE hFile,DWORD dwFlags)
  111. {
  112.     HMODULE moduleResult = NULL;
  113.     ULONG_PTR  ulpCookie = 0;
  114.     const BOOL fActivateActCtxSuccess = IsolationAwarePrivateG_FqbjaLEiEL || IsolationAwarePrivatenCgIiAgEzlnCgpgk(&ulpCookie);
  115.     if (!fActivateActCtxSuccess)
  116.         return moduleResult;
  117.     __try
  118.     {
  119.         moduleResult = LoadLibraryExA(lpLibFileName,hFile,dwFlags);
  120.     }
  121.     __finally
  122.     {
  123.         if (!IsolationAwarePrivateG_FqbjaLEiEL)
  124.         {
  125.             const BOOL fPreserveLastError = (moduleResult == NULL);
  126.             const DWORD dwLastError = fPreserveLastError ? GetLastError() : NO_ERROR;
  127.             (void)IsolationAwareDeactivateActCtx(0, ulpCookie);
  128.             if (fPreserveLastError)
  129.                 SetLastError(dwLastError);
  130.         }
  131.     }
  132.     return moduleResult;
  133. }
  135. ISOLATION_AWARE_INLINE HMODULE WINAPI IsolationAwareLoadLibraryExW(LPCWSTR lpLibFileName,HANDLE hFile,DWORD dwFlags)
  136. {
  137.     HMODULE moduleResult = NULL;
  138.     ULONG_PTR  ulpCookie = 0;
  139.     const BOOL fActivateActCtxSuccess = IsolationAwarePrivateG_FqbjaLEiEL || IsolationAwarePrivatenCgIiAgEzlnCgpgk(&ulpCookie);
  140.     if (!fActivateActCtxSuccess)
  141.         return moduleResult;
  142.     __try
  143.     {
  144.         moduleResult = LoadLibraryExW(lpLibFileName,hFile,dwFlags);
  145.     }
  146.     __finally
  147.     {
  148.         if (!IsolationAwarePrivateG_FqbjaLEiEL)
  149.         {
  150.             const BOOL fPreserveLastError = (moduleResult == NULL);
  151.             const DWORD dwLastError = fPreserveLastError ? GetLastError() : NO_ERROR;
  152.             (void)IsolationAwareDeactivateActCtx(0, ulpCookie);
  153.             if (fPreserveLastError)
  154.                 SetLastError(dwLastError);
  155.         }
  156.     }
  157.     return moduleResult;
  158. }
  160. ISOLATION_AWARE_INLINE HANDLE WINAPI IsolationAwareCreateActCtxW(PCACTCTXW pActCtx)
  161. {
  162.     HANDLE result = INVALID_HANDLE_VALUE;
  163.     typedef HANDLE (WINAPI* PFN)(PCACTCTXW pActCtx);
  164.     static PFN s_pfn;
  165.     if (s_pfn == NULL)
  166.     {
  167.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("CreateActCtxW");
  168.         if (s_pfn == NULL)
  169.             return result;
  170.     }
  171.     result = s_pfn(pActCtx);
  172.     return result;
  173. }
  175. ISOLATION_AWARE_INLINE void WINAPI IsolationAwareReleaseActCtx(HANDLE hActCtx)
  176. {
  177.     typedef void (WINAPI* PFN)(HANDLE hActCtx);
  178.     static PFN s_pfn;
  179.     if (s_pfn == NULL)
  180.     {
  181.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("ReleaseActCtx");
  182.         if (s_pfn == NULL)
  183.             return;
  184.     }
  185.     s_pfn(hActCtx);
  186.     return;
  187. }
  189. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwareActivateActCtx(HANDLE hActCtx,ULONG_PTR*lpCookie)
  190. {
  191.     BOOL fResult = FALSE;
  192.     typedef BOOL (WINAPI* PFN)(HANDLE hActCtx,ULONG_PTR*lpCookie);
  193.     static PFN s_pfn;
  194.     if (s_pfn == NULL)
  195.     {
  196.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("ActivateActCtx");
  197.         if (s_pfn == NULL)
  198.             return fResult;
  199.     }
  200.     fResult = s_pfn(hActCtx,lpCookie);
  201.     return fResult;
  202. }
  204. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwareDeactivateActCtx(DWORD dwFlags,ULONG_PTR ulCookie)
  205. {
  206.     BOOL fResult = FALSE;
  207.     typedef BOOL (WINAPI* PFN)(DWORD dwFlags,ULONG_PTR ulCookie);
  208.     static PFN s_pfn;
  209.     if (s_pfn == NULL)
  210.     {
  211.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("DeactivateActCtx");
  212.         if (s_pfn == NULL)
  213.             return fResult;
  214.     }
  215.     fResult = s_pfn(dwFlags,ulCookie);
  216.     return fResult;
  217. }
  219. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwareFindActCtxSectionStringW(DWORD dwFlags,const GUID*lpExtensionGuid,ULONG ulSectionId,LPCWSTR lpStringToFind,PACTCTX_SECTION_KEYED_DATA ReturnedData)
  220. {
  221.     BOOL fResult = FALSE;
  222.     typedef BOOL (WINAPI* PFN)(DWORD dwFlags,const GUID*lpExtensionGuid,ULONG ulSectionId,LPCWSTR lpStringToFind,PACTCTX_SECTION_KEYED_DATA ReturnedData);
  223.     static PFN s_pfn;
  224.     if (s_pfn == NULL)
  225.     {
  226.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("FindActCtxSectionStringW");
  227.         if (s_pfn == NULL)
  228.             return fResult;
  229.     }
  230.     fResult = s_pfn(dwFlags,lpExtensionGuid,ulSectionId,lpStringToFind,ReturnedData);
  231.     return fResult;
  232. }
  234. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwareQueryActCtxW(DWORD dwFlags,HANDLE hActCtx,PVOID pvSubInstance,ULONG ulInfoClass,PVOID pvBuffer,SIZE_T cbBuffer,SIZE_T*pcbWrittenOrRequired)
  235. {
  236.     BOOL fResult = FALSE;
  237.     typedef BOOL (WINAPI* PFN)(DWORD dwFlags,HANDLE hActCtx,PVOID pvSubInstance,ULONG ulInfoClass,PVOID pvBuffer,SIZE_T cbBuffer,SIZE_T*pcbWrittenOrRequired);
  238.     static PFN s_pfn;
  239.     if (s_pfn == NULL)
  240.     {
  241.         s_pfn = (PFN)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("QueryActCtxW");
  242.         if (s_pfn == NULL)
  243.             return fResult;
  244.     }
  245.     fResult = s_pfn(dwFlags,hActCtx,pvSubInstance,ulInfoClass,pvBuffer,cbBuffer,pcbWrittenOrRequired);
  246.     return fResult;
  247. }
  251. FORCEINLINE
  252. HMODULE
  253. WINAPI
  254. WinbaseIsolationAwarePrivatetEgzbDhLEuAaDLE_xEeaELDC_DLL(
  255.     )
  256. {
  257.     HMODULE hKernel32 = GetModuleHandleW(L"Kernel32.dll");
  258.     if (hKernel32 == NULL
  259.            && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
  260.        )
  261.         hKernel32 = GetModuleHandleA("Kernel32.dll");
  262.     return hKernel32;
  263. }
  265. #define WINBASE_NUMBER_OF(x) (sizeof(x) / sizeof((x)[0]))
  269. ISOLATION_AWARE_INLINE BOOL WINAPI WinbaseIsolationAwarePrivatetEgzlnCgpgk (void)
  270. /*
  271. The correctness of this function depends on it being statically
  272. linked into its clients.
  274. This function is private to functions present in this header.
  275. Do not use it.
  276. */
  277. {
  278.     BOOL fResult = FALSE;
  279.     ACTIVATION_CONTEXT_BASIC_INFORMATION actCtxBasicInfo;
  280.     ULONG_PTR ulpCookie = 0;
  282.     if (IsolationAwarePrivateG_FqbjaLEiEL)
  283.     {
  284.         fResult = TRUE;
  285.         goto Exit;
  286.     }
  288.     if (WinbaseIsolationAwarePrivateG_HnCgpgk != INVALID_HANDLE_VALUE)
  289.     {
  290.         fResult = TRUE;
  291.         goto Exit;
  292.     }
  294.     if (!IsolationAwareQueryActCtxW(
  295.         QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS
  296.         | QUERY_ACTCTX_FLAG_NO_ADDREF,
  297.         &WinbaseIsolationAwarePrivateG_HnCgpgk,
  298.         NULL,
  299.         ActivationContextBasicInformation,
  300.         &actCtxBasicInfo,
  301.         sizeof(actCtxBasicInfo),
  302.         NULL
  303.         ))
  304.         goto Exit;
  306.     /*
  307.     If QueryActCtxW returns NULL, try CreateActCtx(3).
  308.     */
  309.     if (actCtxBasicInfo.hActCtx == NULL)
  310.     {
  311.         ACTCTXW actCtx;
  312.         WCHAR rgchFullModulePath[MAX_PATH + 2];
  313.         DWORD dw;
  314.         HMODULE hmodSelf;
  315.         PGET_MODULE_HANDLE_EXW pfnGetModuleHandleExW;
  317.         pfnGetModuleHandleExW = (PGET_MODULE_HANDLE_EXW)WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL("GetModuleHandleExW");
  318.         if (pfnGetModuleHandleExW == NULL)
  319.             goto Exit;
  321.         if (!(*pfnGetModuleHandleExW)(
  322.                   GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT
  323.                 | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
  324.                 (LPCWSTR)&WinbaseIsolationAwarePrivateG_HnCgpgk,
  325.                 &hmodSelf
  326.                 ))
  327.             goto Exit;
  329.         rgchFullModulePath[WINBASE_NUMBER_OF(rgchFullModulePath) - 1] = 0;
  330.         rgchFullModulePath[WINBASE_NUMBER_OF(rgchFullModulePath) - 2] = 0;
  331.         dw = GetModuleFileNameW(hmodSelf, rgchFullModulePath, WINBASE_NUMBER_OF(rgchFullModulePath));
  332.         if (dw == 0)
  333.             goto Exit;
  334.         if (rgchFullModulePath[WINBASE_NUMBER_OF(rgchFullModulePath) - 2] != 0)
  335.         {
  336.             SetLastError(ERROR_BUFFER_OVERFLOW);
  337.             goto Exit;
  338.         }
  340.         actCtx.cbSize = sizeof(actCtx);
  341.         actCtx.dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
  342.         actCtx.lpSource = rgchFullModulePath;
  343.         actCtx.lpResourceName = (LPCWSTR)(ULONG_PTR)3;
  344.         actCtx.hModule = hmodSelf;
  345.         actCtxBasicInfo.hActCtx = IsolationAwareCreateActCtxW(&actCtx);
  346.         if (actCtxBasicInfo.hActCtx == INVALID_HANDLE_VALUE)
  347.         {
  348.             const DWORD dwLastError = GetLastError();
  349.             if ((dwLastError != ERROR_RESOURCE_DATA_NOT_FOUND) &&
  350.                 (dwLastError != ERROR_RESOURCE_TYPE_NOT_FOUND) &&
  351.                 (dwLastError != ERROR_RESOURCE_LANG_NOT_FOUND) &&
  352.                 (dwLastError != ERROR_RESOURCE_NAME_NOT_FOUND))
  353.                 goto Exit;
  355.             actCtxBasicInfo.hActCtx = NULL;
  356.         }
  358.         WinbaseIsolationAwarePrivateG_FpeEAgEDnCgpgk = TRUE;
  359.     }
  361.     WinbaseIsolationAwarePrivateG_HnCgpgk = actCtxBasicInfo.hActCtx;
  363. #define ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION              (2)
  365.     if (IsolationAwareActivateActCtx(actCtxBasicInfo.hActCtx, &ulpCookie))
  366.     {
  367.         __try
  368.         {
  369.             ACTCTX_SECTION_KEYED_DATA actCtxSectionKeyedData;
  371.             actCtxSectionKeyedData.cbSize = sizeof(actCtxSectionKeyedData);
  372.             if (IsolationAwareFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"Comctl32.dll", &actCtxSectionKeyedData))
  373.             {
  374.                 /* get button, edit, etc. registered */
  375.                 LoadLibraryW(L"Comctl32.dll");
  376.             }
  377.         }
  378.         __finally
  379.         {
  380.             IsolationAwareDeactivateActCtx(0, ulpCookie);
  381.         }
  382.     }
  384.     fResult = TRUE;
  385. Exit:
  386.     return fResult;
  387. }
  389. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwareInit(void)
  390. /*
  391. The correctness of this function depends on it being statically
  392. linked into its clients.
  394. Call this from DllMain(DLL_PROCESS_ATTACH) if you use id 3 and wish to avoid a race condition that
  395.     can cause an hActCtx leak.
  396. Call this from your .exe's initialization if you use id 3 and wish to avoid a race condition that
  397.     can cause an hActCtx leak.
  398. If you use id 2, this function fetches data from your .dll
  399.     that you do not need to worry about cleaning up.
  400. */
  401. {
  402.     return WinbaseIsolationAwarePrivatetEgzlnCgpgk();
  403. }
  405. ISOLATION_AWARE_INLINE void WINAPI IsolationAwareCleanup(void)
  406. /*
  407. Call this from DllMain(DLL_PROCESS_DETACH), if you use id 3, to avoid a leak.
  408. Call this from your .exe's cleanup to possibly avoid apparent (but not actual) leaks, if use id 3.
  409. This function does nothing, safely, if you use id 2.
  410. */
  411. {
  412.     HANDLE hActCtx;
  414.     if (WinbaseIsolationAwarePrivateG_FpLEAahcpALLED)
  415.         return;
  417.     /* IsolationAware* calls made from here on out will OutputDebugString
  418.        and use the process default activation context instead of id 3 or will
  419.        continue to successfully use id 2 (but still OutputDebugString).
  420.     */
  421.     WinbaseIsolationAwarePrivateG_FpLEAahcpALLED = TRUE;
  422.     
  423.     /* There is no cleanup to do if we did not CreateActCtx but only called QueryActCtx.
  424.     */
  425.     if (!WinbaseIsolationAwarePrivateG_FpeEAgEDnCgpgk)
  426.         return;
  428.     hActCtx = WinbaseIsolationAwarePrivateG_HnCgpgk;
  429.     WinbaseIsolationAwarePrivateG_HnCgpgk = NULL; /* process default */
  431.     if (hActCtx == INVALID_HANDLE_VALUE)
  432.         return;
  433.     if (hActCtx == NULL)
  434.         return;
  435.     IsolationAwareReleaseActCtx(hActCtx);
  436. }
  438. ISOLATION_AWARE_INLINE BOOL WINAPI IsolationAwarePrivatenCgIiAgEzlnCgpgk(ULONG_PTR* pulpCookie)
  439. /*
  440. This function is private to functions present in this header and other headers.
  441. */
  442. {
  443.     BOOL fResult = FALSE;
  445.     if (WinbaseIsolationAwarePrivateG_FpLEAahcpALLED)
  446.     {
  447.         const static char debugString[] = "IsolationAware function called after IsolationAwareCleanupn";
  448.         OutputDebugStringA(debugString);
  449.     }
  451.     if (IsolationAwarePrivateG_FqbjaLEiEL)
  452.     {
  453.         fResult = TRUE;
  454.         goto Exit;
  455.     }
  457.     /* Do not call Init if Cleanup has been called. */
  458.     if (!WinbaseIsolationAwarePrivateG_FpLEAahcpALLED)
  459.     {
  460.         if (!WinbaseIsolationAwarePrivatetEgzlnCgpgk())
  461.             goto Exit;
  462.     }
  463.     /* If Cleanup has been called and id3 was in use, this will activate NULL. */
  464.     if (!IsolationAwareActivateActCtx(WinbaseIsolationAwarePrivateG_HnCgpgk, pulpCookie))
  465.         goto Exit;
  467.     fResult = TRUE;
  468. Exit:
  469.     if (!fResult)
  470.     {
  471.         const DWORD dwLastError = GetLastError();
  472.         if (dwLastError == ERROR_PROC_NOT_FOUND
  473.             || dwLastError == ERROR_CALL_NOT_IMPLEMENTED
  474.             )
  475.         {
  476.             IsolationAwarePrivateG_FqbjaLEiEL = TRUE;
  477.             fResult = TRUE;
  478.         }
  479.     }
  480.     return fResult;
  481. }
  483. #undef WINBASE_NUMBER_OF
  485. ISOLATION_AWARE_INLINE FARPROC WINAPI WinbaseIsolationAwarePrivatetEgCebCnDDeEff_xEeaELDC_DLL(LPCSTR pszProcName)
  486. /* This function is shared by the other stubs in this header. */
  487. {
  488.     FARPROC proc = NULL;
  489.     static HMODULE s_module;
  490.     if (s_module == NULL)
  491.     {
  492.         s_module = WinbaseIsolationAwarePrivatetEgzbDhLEuAaDLE_xEeaELDC_DLL();
  493.         if (s_module == NULL)
  494.             return proc;
  495.     }
  496.     proc = GetProcAddress(s_module, pszProcName);
  497.     return proc;
  498. }
  500. #define ActivateActCtx IsolationAwareActivateActCtx
  501. #define CreateActCtxW IsolationAwareCreateActCtxW
  502. #define DeactivateActCtx IsolationAwareDeactivateActCtx
  503. #define FindActCtxSectionStringW IsolationAwareFindActCtxSectionStringW
  504. #define LoadLibraryA IsolationAwareLoadLibraryA
  505. #define LoadLibraryExA IsolationAwareLoadLibraryExA
  506. #define LoadLibraryExW IsolationAwareLoadLibraryExW
  507. #define LoadLibraryW IsolationAwareLoadLibraryW
  508. #define QueryActCtxW IsolationAwareQueryActCtxW
  509. #define ReleaseActCtx IsolationAwareReleaseActCtx
  511. #endif /* ISOLATION_AWARE_ENABLED */
  512. #endif /* RC */
  515. #if defined(__cplusplus)
  516. } /* __cplusplus */
  517. #endif