| 1 | typedef PVOID WINAPI FN_EncodePointer( PVOID Ptr );
|
|---|
| 2 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_EncodePointer( PVOID Ptr )
|
|---|
| 3 | {
|
|---|
| 4 | static FN_EncodePointer *pfn = 0;
|
|---|
| 5 | if (!pfn)
|
|---|
| 6 | kPrf2WrapResolve((void **)&pfn, "EncodePointer", &g_Kernel32);
|
|---|
| 7 | return pfn( Ptr );
|
|---|
| 8 | }
|
|---|
| 9 |
|
|---|
| 10 | typedef PVOID WINAPI FN_DecodePointer( PVOID Ptr );
|
|---|
| 11 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_DecodePointer( PVOID Ptr )
|
|---|
| 12 | {
|
|---|
| 13 | static FN_DecodePointer *pfn = 0;
|
|---|
| 14 | if (!pfn)
|
|---|
| 15 | kPrf2WrapResolve((void **)&pfn, "DecodePointer", &g_Kernel32);
|
|---|
| 16 | return pfn( Ptr );
|
|---|
| 17 | }
|
|---|
| 18 |
|
|---|
| 19 | typedef PVOID WINAPI FN_EncodeSystemPointer( PVOID Ptr );
|
|---|
| 20 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_EncodeSystemPointer( PVOID Ptr )
|
|---|
| 21 | {
|
|---|
| 22 | static FN_EncodeSystemPointer *pfn = 0;
|
|---|
| 23 | if (!pfn)
|
|---|
| 24 | kPrf2WrapResolve((void **)&pfn, "EncodeSystemPointer", &g_Kernel32);
|
|---|
| 25 | return pfn( Ptr );
|
|---|
| 26 | }
|
|---|
| 27 |
|
|---|
| 28 | typedef PVOID WINAPI FN_DecodeSystemPointer( PVOID Ptr );
|
|---|
| 29 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_DecodeSystemPointer( PVOID Ptr )
|
|---|
| 30 | {
|
|---|
| 31 | static FN_DecodeSystemPointer *pfn = 0;
|
|---|
| 32 | if (!pfn)
|
|---|
| 33 | kPrf2WrapResolve((void **)&pfn, "DecodeSystemPointer", &g_Kernel32);
|
|---|
| 34 | return pfn( Ptr );
|
|---|
| 35 | }
|
|---|
| 36 |
|
|---|
| 37 | typedef DWORD WINAPI FN_GetFreeSpace( UINT a);
|
|---|
| 38 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFreeSpace( UINT a)
|
|---|
| 39 | {
|
|---|
| 40 | static FN_GetFreeSpace *pfn = 0;
|
|---|
| 41 | if (!pfn)
|
|---|
| 42 | kPrf2WrapResolve((void **)&pfn, "GetFreeSpace", &g_Kernel32);
|
|---|
| 43 | return pfn( a);
|
|---|
| 44 | }
|
|---|
| 45 |
|
|---|
| 46 | typedef LONG WINAPI FN_InterlockedIncrement( LONG volatile * lpAddend );
|
|---|
| 47 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedIncrement( LONG volatile * lpAddend )
|
|---|
| 48 | {
|
|---|
| 49 | static FN_InterlockedIncrement *pfn = 0;
|
|---|
| 50 | if (!pfn)
|
|---|
| 51 | kPrf2WrapResolve((void **)&pfn, "InterlockedIncrement", &g_Kernel32);
|
|---|
| 52 | return pfn( lpAddend );
|
|---|
| 53 | }
|
|---|
| 54 |
|
|---|
| 55 | typedef LONG WINAPI FN_InterlockedDecrement( LONG volatile * lpAddend );
|
|---|
| 56 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedDecrement( LONG volatile * lpAddend )
|
|---|
| 57 | {
|
|---|
| 58 | static FN_InterlockedDecrement *pfn = 0;
|
|---|
| 59 | if (!pfn)
|
|---|
| 60 | kPrf2WrapResolve((void **)&pfn, "InterlockedDecrement", &g_Kernel32);
|
|---|
| 61 | return pfn( lpAddend );
|
|---|
| 62 | }
|
|---|
| 63 |
|
|---|
| 64 | typedef LONG WINAPI FN_InterlockedExchange( LONG volatile * Target, LONG Value );
|
|---|
| 65 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedExchange( LONG volatile * Target, LONG Value )
|
|---|
| 66 | {
|
|---|
| 67 | static FN_InterlockedExchange *pfn = 0;
|
|---|
| 68 | if (!pfn)
|
|---|
| 69 | kPrf2WrapResolve((void **)&pfn, "InterlockedExchange", &g_Kernel32);
|
|---|
| 70 | return pfn( Target, Value );
|
|---|
| 71 | }
|
|---|
| 72 |
|
|---|
| 73 | typedef LONG WINAPI FN_InterlockedExchangeAdd( LONG volatile * Addend, LONG Value );
|
|---|
| 74 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedExchangeAdd( LONG volatile * Addend, LONG Value )
|
|---|
| 75 | {
|
|---|
| 76 | static FN_InterlockedExchangeAdd *pfn = 0;
|
|---|
| 77 | if (!pfn)
|
|---|
| 78 | kPrf2WrapResolve((void **)&pfn, "InterlockedExchangeAdd", &g_Kernel32);
|
|---|
| 79 | return pfn( Addend, Value );
|
|---|
| 80 | }
|
|---|
| 81 |
|
|---|
| 82 | typedef LONG WINAPI FN_InterlockedCompareExchange( LONG volatile * Destination, LONG Exchange, LONG Comperand );
|
|---|
| 83 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedCompareExchange( LONG volatile * Destination, LONG Exchange, LONG Comperand )
|
|---|
| 84 | {
|
|---|
| 85 | static FN_InterlockedCompareExchange *pfn = 0;
|
|---|
| 86 | if (!pfn)
|
|---|
| 87 | kPrf2WrapResolve((void **)&pfn, "InterlockedCompareExchange", &g_Kernel32);
|
|---|
| 88 | return pfn( Destination, Exchange, Comperand );
|
|---|
| 89 | }
|
|---|
| 90 |
|
|---|
| 91 | typedef LONGLONG WINAPI FN_InterlockedCompareExchange64( LONGLONG volatile * Destination, LONGLONG Exchange, LONGLONG Comperand );
|
|---|
| 92 | __declspec(dllexport) LONGLONG WINAPI kPrf2Wrap_InterlockedCompareExchange64( LONGLONG volatile * Destination, LONGLONG Exchange, LONGLONG Comperand )
|
|---|
| 93 | {
|
|---|
| 94 | static FN_InterlockedCompareExchange64 *pfn = 0;
|
|---|
| 95 | if (!pfn)
|
|---|
| 96 | kPrf2WrapResolve((void **)&pfn, "InterlockedCompareExchange64", &g_Kernel32);
|
|---|
| 97 | return pfn( Destination, Exchange, Comperand );
|
|---|
| 98 | }
|
|---|
| 99 |
|
|---|
| 100 | typedef VOID WINAPI FN_InitializeSListHead( PSLIST_HEADER ListHead );
|
|---|
| 101 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_InitializeSListHead( PSLIST_HEADER ListHead )
|
|---|
| 102 | {
|
|---|
| 103 | static FN_InitializeSListHead *pfn = 0;
|
|---|
| 104 | if (!pfn)
|
|---|
| 105 | kPrf2WrapResolve((void **)&pfn, "InitializeSListHead", &g_Kernel32);
|
|---|
| 106 | pfn( ListHead );
|
|---|
| 107 | }
|
|---|
| 108 |
|
|---|
| 109 | typedef PSLIST_ENTRY WINAPI FN_InterlockedPopEntrySList( PSLIST_HEADER ListHead );
|
|---|
| 110 | __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedPopEntrySList( PSLIST_HEADER ListHead )
|
|---|
| 111 | {
|
|---|
| 112 | static FN_InterlockedPopEntrySList *pfn = 0;
|
|---|
| 113 | if (!pfn)
|
|---|
| 114 | kPrf2WrapResolve((void **)&pfn, "InterlockedPopEntrySList", &g_Kernel32);
|
|---|
| 115 | return pfn( ListHead );
|
|---|
| 116 | }
|
|---|
| 117 |
|
|---|
| 118 | typedef PSLIST_ENTRY WINAPI FN_InterlockedPushEntrySList( PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry );
|
|---|
| 119 | __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedPushEntrySList( PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry )
|
|---|
| 120 | {
|
|---|
| 121 | static FN_InterlockedPushEntrySList *pfn = 0;
|
|---|
| 122 | if (!pfn)
|
|---|
| 123 | kPrf2WrapResolve((void **)&pfn, "InterlockedPushEntrySList", &g_Kernel32);
|
|---|
| 124 | return pfn( ListHead, ListEntry );
|
|---|
| 125 | }
|
|---|
| 126 |
|
|---|
| 127 | typedef PSLIST_ENTRY WINAPI FN_InterlockedFlushSList( PSLIST_HEADER ListHead );
|
|---|
| 128 | __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedFlushSList( PSLIST_HEADER ListHead )
|
|---|
| 129 | {
|
|---|
| 130 | static FN_InterlockedFlushSList *pfn = 0;
|
|---|
| 131 | if (!pfn)
|
|---|
| 132 | kPrf2WrapResolve((void **)&pfn, "InterlockedFlushSList", &g_Kernel32);
|
|---|
| 133 | return pfn( ListHead );
|
|---|
| 134 | }
|
|---|
| 135 |
|
|---|
| 136 | typedef USHORT WINAPI FN_QueryDepthSList( PSLIST_HEADER ListHead );
|
|---|
| 137 | __declspec(dllexport) USHORT WINAPI kPrf2Wrap_QueryDepthSList( PSLIST_HEADER ListHead )
|
|---|
| 138 | {
|
|---|
| 139 | static FN_QueryDepthSList *pfn = 0;
|
|---|
| 140 | if (!pfn)
|
|---|
| 141 | kPrf2WrapResolve((void **)&pfn, "QueryDepthSList", &g_Kernel32);
|
|---|
| 142 | return pfn( ListHead );
|
|---|
| 143 | }
|
|---|
| 144 |
|
|---|
| 145 | typedef BOOL WINAPI FN_FreeResource( HGLOBAL hResData );
|
|---|
| 146 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeResource( HGLOBAL hResData )
|
|---|
| 147 | {
|
|---|
| 148 | static FN_FreeResource *pfn = 0;
|
|---|
| 149 | if (!pfn)
|
|---|
| 150 | kPrf2WrapResolve((void **)&pfn, "FreeResource", &g_Kernel32);
|
|---|
| 151 | return pfn( hResData );
|
|---|
| 152 | }
|
|---|
| 153 |
|
|---|
| 154 | typedef LPVOID WINAPI FN_LockResource( HGLOBAL hResData );
|
|---|
| 155 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_LockResource( HGLOBAL hResData )
|
|---|
| 156 | {
|
|---|
| 157 | static FN_LockResource *pfn = 0;
|
|---|
| 158 | if (!pfn)
|
|---|
| 159 | kPrf2WrapResolve((void **)&pfn, "LockResource", &g_Kernel32);
|
|---|
| 160 | return pfn( hResData );
|
|---|
| 161 | }
|
|---|
| 162 |
|
|---|
| 163 | typedef BOOL WINAPI FN_FreeLibrary( HMODULE hLibModule );
|
|---|
| 164 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeLibrary( HMODULE hLibModule )
|
|---|
| 165 | {
|
|---|
| 166 | static FN_FreeLibrary *pfn = 0;
|
|---|
| 167 | if (!pfn)
|
|---|
| 168 | kPrf2WrapResolve((void **)&pfn, "FreeLibrary", &g_Kernel32);
|
|---|
| 169 | return pfn( hLibModule );
|
|---|
| 170 | }
|
|---|
| 171 |
|
|---|
| 172 | typedef VOID WINAPI FN_FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode );
|
|---|
| 173 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode )
|
|---|
| 174 | {
|
|---|
| 175 | static FN_FreeLibraryAndExitThread *pfn = 0;
|
|---|
| 176 | if (!pfn)
|
|---|
| 177 | kPrf2WrapResolve((void **)&pfn, "FreeLibraryAndExitThread", &g_Kernel32);
|
|---|
| 178 | pfn( hLibModule, dwExitCode );
|
|---|
| 179 | }
|
|---|
| 180 |
|
|---|
| 181 | typedef BOOL WINAPI FN_DisableThreadLibraryCalls( HMODULE hLibModule );
|
|---|
| 182 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DisableThreadLibraryCalls( HMODULE hLibModule )
|
|---|
| 183 | {
|
|---|
| 184 | static FN_DisableThreadLibraryCalls *pfn = 0;
|
|---|
| 185 | if (!pfn)
|
|---|
| 186 | kPrf2WrapResolve((void **)&pfn, "DisableThreadLibraryCalls", &g_Kernel32);
|
|---|
| 187 | return pfn( hLibModule );
|
|---|
| 188 | }
|
|---|
| 189 |
|
|---|
| 190 | typedef FARPROC WINAPI FN_GetProcAddress( HMODULE hModule, LPCSTR lpProcName );
|
|---|
| 191 | __declspec(dllexport) FARPROC WINAPI kPrf2Wrap_GetProcAddress( HMODULE hModule, LPCSTR lpProcName )
|
|---|
| 192 | {
|
|---|
| 193 | static FN_GetProcAddress *pfn = 0;
|
|---|
| 194 | if (!pfn)
|
|---|
| 195 | kPrf2WrapResolve((void **)&pfn, "GetProcAddress", &g_Kernel32);
|
|---|
| 196 | return pfn( hModule, lpProcName );
|
|---|
| 197 | }
|
|---|
| 198 |
|
|---|
| 199 | typedef DWORD WINAPI FN_GetVersion( VOID );
|
|---|
| 200 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetVersion( VOID )
|
|---|
| 201 | {
|
|---|
| 202 | static FN_GetVersion *pfn = 0;
|
|---|
| 203 | if (!pfn)
|
|---|
| 204 | kPrf2WrapResolve((void **)&pfn, "GetVersion", &g_Kernel32);
|
|---|
| 205 | return pfn ();
|
|---|
| 206 | }
|
|---|
| 207 |
|
|---|
| 208 | typedef HGLOBAL WINAPI FN_GlobalAlloc( UINT uFlags, SIZE_T dwBytes );
|
|---|
| 209 | __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalAlloc( UINT uFlags, SIZE_T dwBytes )
|
|---|
| 210 | {
|
|---|
| 211 | static FN_GlobalAlloc *pfn = 0;
|
|---|
| 212 | if (!pfn)
|
|---|
| 213 | kPrf2WrapResolve((void **)&pfn, "GlobalAlloc", &g_Kernel32);
|
|---|
| 214 | return pfn( uFlags, dwBytes );
|
|---|
| 215 | }
|
|---|
| 216 |
|
|---|
| 217 | typedef HGLOBAL WINAPI FN_GlobalReAlloc( HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags );
|
|---|
| 218 | __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalReAlloc( HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags )
|
|---|
| 219 | {
|
|---|
| 220 | static FN_GlobalReAlloc *pfn = 0;
|
|---|
| 221 | if (!pfn)
|
|---|
| 222 | kPrf2WrapResolve((void **)&pfn, "GlobalReAlloc", &g_Kernel32);
|
|---|
| 223 | return pfn( hMem, dwBytes, uFlags );
|
|---|
| 224 | }
|
|---|
| 225 |
|
|---|
| 226 | typedef SIZE_T WINAPI FN_GlobalSize( HGLOBAL hMem );
|
|---|
| 227 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GlobalSize( HGLOBAL hMem )
|
|---|
| 228 | {
|
|---|
| 229 | static FN_GlobalSize *pfn = 0;
|
|---|
| 230 | if (!pfn)
|
|---|
| 231 | kPrf2WrapResolve((void **)&pfn, "GlobalSize", &g_Kernel32);
|
|---|
| 232 | return pfn( hMem );
|
|---|
| 233 | }
|
|---|
| 234 |
|
|---|
| 235 | typedef UINT WINAPI FN_GlobalFlags( HGLOBAL hMem );
|
|---|
| 236 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalFlags( HGLOBAL hMem )
|
|---|
| 237 | {
|
|---|
| 238 | static FN_GlobalFlags *pfn = 0;
|
|---|
| 239 | if (!pfn)
|
|---|
| 240 | kPrf2WrapResolve((void **)&pfn, "GlobalFlags", &g_Kernel32);
|
|---|
| 241 | return pfn( hMem );
|
|---|
| 242 | }
|
|---|
| 243 |
|
|---|
| 244 | typedef LPVOID WINAPI FN_GlobalLock( HGLOBAL hMem );
|
|---|
| 245 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_GlobalLock( HGLOBAL hMem )
|
|---|
| 246 | {
|
|---|
| 247 | static FN_GlobalLock *pfn = 0;
|
|---|
| 248 | if (!pfn)
|
|---|
| 249 | kPrf2WrapResolve((void **)&pfn, "GlobalLock", &g_Kernel32);
|
|---|
| 250 | return pfn( hMem );
|
|---|
| 251 | }
|
|---|
| 252 |
|
|---|
| 253 | typedef HGLOBAL WINAPI FN_GlobalHandle( LPCVOID pMem );
|
|---|
| 254 | __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalHandle( LPCVOID pMem )
|
|---|
| 255 | {
|
|---|
| 256 | static FN_GlobalHandle *pfn = 0;
|
|---|
| 257 | if (!pfn)
|
|---|
| 258 | kPrf2WrapResolve((void **)&pfn, "GlobalHandle", &g_Kernel32);
|
|---|
| 259 | return pfn( pMem );
|
|---|
| 260 | }
|
|---|
| 261 |
|
|---|
| 262 | typedef BOOL WINAPI FN_GlobalUnlock( HGLOBAL hMem );
|
|---|
| 263 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalUnlock( HGLOBAL hMem )
|
|---|
| 264 | {
|
|---|
| 265 | static FN_GlobalUnlock *pfn = 0;
|
|---|
| 266 | if (!pfn)
|
|---|
| 267 | kPrf2WrapResolve((void **)&pfn, "GlobalUnlock", &g_Kernel32);
|
|---|
| 268 | return pfn( hMem );
|
|---|
| 269 | }
|
|---|
| 270 |
|
|---|
| 271 | typedef HGLOBAL WINAPI FN_GlobalFree( HGLOBAL hMem );
|
|---|
| 272 | __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalFree( HGLOBAL hMem )
|
|---|
| 273 | {
|
|---|
| 274 | static FN_GlobalFree *pfn = 0;
|
|---|
| 275 | if (!pfn)
|
|---|
| 276 | kPrf2WrapResolve((void **)&pfn, "GlobalFree", &g_Kernel32);
|
|---|
| 277 | return pfn( hMem );
|
|---|
| 278 | }
|
|---|
| 279 |
|
|---|
| 280 | typedef SIZE_T WINAPI FN_GlobalCompact( DWORD dwMinFree );
|
|---|
| 281 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GlobalCompact( DWORD dwMinFree )
|
|---|
| 282 | {
|
|---|
| 283 | static FN_GlobalCompact *pfn = 0;
|
|---|
| 284 | if (!pfn)
|
|---|
| 285 | kPrf2WrapResolve((void **)&pfn, "GlobalCompact", &g_Kernel32);
|
|---|
| 286 | return pfn( dwMinFree );
|
|---|
| 287 | }
|
|---|
| 288 |
|
|---|
| 289 | typedef VOID WINAPI FN_GlobalFix( HGLOBAL hMem );
|
|---|
| 290 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalFix( HGLOBAL hMem )
|
|---|
| 291 | {
|
|---|
| 292 | static FN_GlobalFix *pfn = 0;
|
|---|
| 293 | if (!pfn)
|
|---|
| 294 | kPrf2WrapResolve((void **)&pfn, "GlobalFix", &g_Kernel32);
|
|---|
| 295 | pfn( hMem );
|
|---|
| 296 | }
|
|---|
| 297 |
|
|---|
| 298 | typedef VOID WINAPI FN_GlobalUnfix( HGLOBAL hMem );
|
|---|
| 299 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalUnfix( HGLOBAL hMem )
|
|---|
| 300 | {
|
|---|
| 301 | static FN_GlobalUnfix *pfn = 0;
|
|---|
| 302 | if (!pfn)
|
|---|
| 303 | kPrf2WrapResolve((void **)&pfn, "GlobalUnfix", &g_Kernel32);
|
|---|
| 304 | pfn( hMem );
|
|---|
| 305 | }
|
|---|
| 306 |
|
|---|
| 307 | typedef LPVOID WINAPI FN_GlobalWire( HGLOBAL hMem );
|
|---|
| 308 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_GlobalWire( HGLOBAL hMem )
|
|---|
| 309 | {
|
|---|
| 310 | static FN_GlobalWire *pfn = 0;
|
|---|
| 311 | if (!pfn)
|
|---|
| 312 | kPrf2WrapResolve((void **)&pfn, "GlobalWire", &g_Kernel32);
|
|---|
| 313 | return pfn( hMem );
|
|---|
| 314 | }
|
|---|
| 315 |
|
|---|
| 316 | typedef BOOL WINAPI FN_GlobalUnWire( HGLOBAL hMem );
|
|---|
| 317 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalUnWire( HGLOBAL hMem )
|
|---|
| 318 | {
|
|---|
| 319 | static FN_GlobalUnWire *pfn = 0;
|
|---|
| 320 | if (!pfn)
|
|---|
| 321 | kPrf2WrapResolve((void **)&pfn, "GlobalUnWire", &g_Kernel32);
|
|---|
| 322 | return pfn( hMem );
|
|---|
| 323 | }
|
|---|
| 324 |
|
|---|
| 325 | typedef VOID WINAPI FN_GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer );
|
|---|
| 326 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
|
|---|
| 327 | {
|
|---|
| 328 | static FN_GlobalMemoryStatus *pfn = 0;
|
|---|
| 329 | if (!pfn)
|
|---|
| 330 | kPrf2WrapResolve((void **)&pfn, "GlobalMemoryStatus", &g_Kernel32);
|
|---|
| 331 | pfn( lpBuffer );
|
|---|
| 332 | }
|
|---|
| 333 |
|
|---|
| 334 | typedef BOOL WINAPI FN_GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpBuffer );
|
|---|
| 335 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpBuffer )
|
|---|
| 336 | {
|
|---|
| 337 | static FN_GlobalMemoryStatusEx *pfn = 0;
|
|---|
| 338 | if (!pfn)
|
|---|
| 339 | kPrf2WrapResolve((void **)&pfn, "GlobalMemoryStatusEx", &g_Kernel32);
|
|---|
| 340 | return pfn( lpBuffer );
|
|---|
| 341 | }
|
|---|
| 342 |
|
|---|
| 343 | typedef HLOCAL WINAPI FN_LocalAlloc( UINT uFlags, SIZE_T uBytes );
|
|---|
| 344 | __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalAlloc( UINT uFlags, SIZE_T uBytes )
|
|---|
| 345 | {
|
|---|
| 346 | static FN_LocalAlloc *pfn = 0;
|
|---|
| 347 | if (!pfn)
|
|---|
| 348 | kPrf2WrapResolve((void **)&pfn, "LocalAlloc", &g_Kernel32);
|
|---|
| 349 | return pfn( uFlags, uBytes );
|
|---|
| 350 | }
|
|---|
| 351 |
|
|---|
| 352 | typedef HLOCAL WINAPI FN_LocalReAlloc( HLOCAL hMem, SIZE_T uBytes, UINT uFlags );
|
|---|
| 353 | __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalReAlloc( HLOCAL hMem, SIZE_T uBytes, UINT uFlags )
|
|---|
| 354 | {
|
|---|
| 355 | static FN_LocalReAlloc *pfn = 0;
|
|---|
| 356 | if (!pfn)
|
|---|
| 357 | kPrf2WrapResolve((void **)&pfn, "LocalReAlloc", &g_Kernel32);
|
|---|
| 358 | return pfn( hMem, uBytes, uFlags );
|
|---|
| 359 | }
|
|---|
| 360 |
|
|---|
| 361 | typedef LPVOID WINAPI FN_LocalLock( HLOCAL hMem );
|
|---|
| 362 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_LocalLock( HLOCAL hMem )
|
|---|
| 363 | {
|
|---|
| 364 | static FN_LocalLock *pfn = 0;
|
|---|
| 365 | if (!pfn)
|
|---|
| 366 | kPrf2WrapResolve((void **)&pfn, "LocalLock", &g_Kernel32);
|
|---|
| 367 | return pfn( hMem );
|
|---|
| 368 | }
|
|---|
| 369 |
|
|---|
| 370 | typedef HLOCAL WINAPI FN_LocalHandle( LPCVOID pMem );
|
|---|
| 371 | __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalHandle( LPCVOID pMem )
|
|---|
| 372 | {
|
|---|
| 373 | static FN_LocalHandle *pfn = 0;
|
|---|
| 374 | if (!pfn)
|
|---|
| 375 | kPrf2WrapResolve((void **)&pfn, "LocalHandle", &g_Kernel32);
|
|---|
| 376 | return pfn( pMem );
|
|---|
| 377 | }
|
|---|
| 378 |
|
|---|
| 379 | typedef BOOL WINAPI FN_LocalUnlock( HLOCAL hMem );
|
|---|
| 380 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LocalUnlock( HLOCAL hMem )
|
|---|
| 381 | {
|
|---|
| 382 | static FN_LocalUnlock *pfn = 0;
|
|---|
| 383 | if (!pfn)
|
|---|
| 384 | kPrf2WrapResolve((void **)&pfn, "LocalUnlock", &g_Kernel32);
|
|---|
| 385 | return pfn( hMem );
|
|---|
| 386 | }
|
|---|
| 387 |
|
|---|
| 388 | typedef SIZE_T WINAPI FN_LocalSize( HLOCAL hMem );
|
|---|
| 389 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalSize( HLOCAL hMem )
|
|---|
| 390 | {
|
|---|
| 391 | static FN_LocalSize *pfn = 0;
|
|---|
| 392 | if (!pfn)
|
|---|
| 393 | kPrf2WrapResolve((void **)&pfn, "LocalSize", &g_Kernel32);
|
|---|
| 394 | return pfn( hMem );
|
|---|
| 395 | }
|
|---|
| 396 |
|
|---|
| 397 | typedef UINT WINAPI FN_LocalFlags( HLOCAL hMem );
|
|---|
| 398 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_LocalFlags( HLOCAL hMem )
|
|---|
| 399 | {
|
|---|
| 400 | static FN_LocalFlags *pfn = 0;
|
|---|
| 401 | if (!pfn)
|
|---|
| 402 | kPrf2WrapResolve((void **)&pfn, "LocalFlags", &g_Kernel32);
|
|---|
| 403 | return pfn( hMem );
|
|---|
| 404 | }
|
|---|
| 405 |
|
|---|
| 406 | typedef HLOCAL WINAPI FN_LocalFree( HLOCAL hMem );
|
|---|
| 407 | __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalFree( HLOCAL hMem )
|
|---|
| 408 | {
|
|---|
| 409 | static FN_LocalFree *pfn = 0;
|
|---|
| 410 | if (!pfn)
|
|---|
| 411 | kPrf2WrapResolve((void **)&pfn, "LocalFree", &g_Kernel32);
|
|---|
| 412 | return pfn( hMem );
|
|---|
| 413 | }
|
|---|
| 414 |
|
|---|
| 415 | typedef SIZE_T WINAPI FN_LocalShrink( HLOCAL hMem, UINT cbNewSize );
|
|---|
| 416 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalShrink( HLOCAL hMem, UINT cbNewSize )
|
|---|
| 417 | {
|
|---|
| 418 | static FN_LocalShrink *pfn = 0;
|
|---|
| 419 | if (!pfn)
|
|---|
| 420 | kPrf2WrapResolve((void **)&pfn, "LocalShrink", &g_Kernel32);
|
|---|
| 421 | return pfn( hMem, cbNewSize );
|
|---|
| 422 | }
|
|---|
| 423 |
|
|---|
| 424 | typedef SIZE_T WINAPI FN_LocalCompact( UINT uMinFree );
|
|---|
| 425 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalCompact( UINT uMinFree )
|
|---|
| 426 | {
|
|---|
| 427 | static FN_LocalCompact *pfn = 0;
|
|---|
| 428 | if (!pfn)
|
|---|
| 429 | kPrf2WrapResolve((void **)&pfn, "LocalCompact", &g_Kernel32);
|
|---|
| 430 | return pfn( uMinFree );
|
|---|
| 431 | }
|
|---|
| 432 |
|
|---|
| 433 | typedef BOOL WINAPI FN_FlushInstructionCache( HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize );
|
|---|
| 434 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushInstructionCache( HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize )
|
|---|
| 435 | {
|
|---|
| 436 | static FN_FlushInstructionCache *pfn = 0;
|
|---|
| 437 | if (!pfn)
|
|---|
| 438 | kPrf2WrapResolve((void **)&pfn, "FlushInstructionCache", &g_Kernel32);
|
|---|
| 439 | return pfn( hProcess, lpBaseAddress, dwSize );
|
|---|
| 440 | }
|
|---|
| 441 |
|
|---|
| 442 | typedef LPVOID WINAPI FN_VirtualAlloc( LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect );
|
|---|
| 443 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_VirtualAlloc( LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect )
|
|---|
| 444 | {
|
|---|
| 445 | static FN_VirtualAlloc *pfn = 0;
|
|---|
| 446 | if (!pfn)
|
|---|
| 447 | kPrf2WrapResolve((void **)&pfn, "VirtualAlloc", &g_Kernel32);
|
|---|
| 448 | return pfn( lpAddress, dwSize, flAllocationType, flProtect );
|
|---|
| 449 | }
|
|---|
| 450 |
|
|---|
| 451 | typedef BOOL WINAPI FN_VirtualFree( LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType );
|
|---|
| 452 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualFree( LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType )
|
|---|
| 453 | {
|
|---|
| 454 | static FN_VirtualFree *pfn = 0;
|
|---|
| 455 | if (!pfn)
|
|---|
| 456 | kPrf2WrapResolve((void **)&pfn, "VirtualFree", &g_Kernel32);
|
|---|
| 457 | return pfn( lpAddress, dwSize, dwFreeType );
|
|---|
| 458 | }
|
|---|
| 459 |
|
|---|
| 460 | typedef BOOL WINAPI FN_VirtualProtect( LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect );
|
|---|
| 461 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualProtect( LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect )
|
|---|
| 462 | {
|
|---|
| 463 | static FN_VirtualProtect *pfn = 0;
|
|---|
| 464 | if (!pfn)
|
|---|
| 465 | kPrf2WrapResolve((void **)&pfn, "VirtualProtect", &g_Kernel32);
|
|---|
| 466 | return pfn( lpAddress, dwSize, flNewProtect, lpflOldProtect );
|
|---|
| 467 | }
|
|---|
| 468 |
|
|---|
| 469 | typedef SIZE_T WINAPI FN_VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength );
|
|---|
| 470 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength )
|
|---|
| 471 | {
|
|---|
| 472 | static FN_VirtualQuery *pfn = 0;
|
|---|
| 473 | if (!pfn)
|
|---|
| 474 | kPrf2WrapResolve((void **)&pfn, "VirtualQuery", &g_Kernel32);
|
|---|
| 475 | return pfn( lpAddress, lpBuffer, dwLength );
|
|---|
| 476 | }
|
|---|
| 477 |
|
|---|
| 478 | typedef LPVOID WINAPI FN_VirtualAllocEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect );
|
|---|
| 479 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_VirtualAllocEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect )
|
|---|
| 480 | {
|
|---|
| 481 | static FN_VirtualAllocEx *pfn = 0;
|
|---|
| 482 | if (!pfn)
|
|---|
| 483 | kPrf2WrapResolve((void **)&pfn, "VirtualAllocEx", &g_Kernel32);
|
|---|
| 484 | return pfn( hProcess, lpAddress, dwSize, flAllocationType, flProtect );
|
|---|
| 485 | }
|
|---|
| 486 |
|
|---|
| 487 | typedef UINT WINAPI FN_GetWriteWatch( DWORD dwFlags, PVOID lpBaseAddress, SIZE_T dwRegionSize, PVOID * lpAddresses, ULONG_PTR * lpdwCount, PULONG lpdwGranularity );
|
|---|
| 488 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWriteWatch( DWORD dwFlags, PVOID lpBaseAddress, SIZE_T dwRegionSize, PVOID * lpAddresses, ULONG_PTR * lpdwCount, PULONG lpdwGranularity )
|
|---|
| 489 | {
|
|---|
| 490 | static FN_GetWriteWatch *pfn = 0;
|
|---|
| 491 | if (!pfn)
|
|---|
| 492 | kPrf2WrapResolve((void **)&pfn, "GetWriteWatch", &g_Kernel32);
|
|---|
| 493 | return pfn( dwFlags, lpBaseAddress, dwRegionSize, lpAddresses, lpdwCount, lpdwGranularity );
|
|---|
| 494 | }
|
|---|
| 495 |
|
|---|
| 496 | typedef UINT WINAPI FN_ResetWriteWatch( LPVOID lpBaseAddress, SIZE_T dwRegionSize );
|
|---|
| 497 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_ResetWriteWatch( LPVOID lpBaseAddress, SIZE_T dwRegionSize )
|
|---|
| 498 | {
|
|---|
| 499 | static FN_ResetWriteWatch *pfn = 0;
|
|---|
| 500 | if (!pfn)
|
|---|
| 501 | kPrf2WrapResolve((void **)&pfn, "ResetWriteWatch", &g_Kernel32);
|
|---|
| 502 | return pfn( lpBaseAddress, dwRegionSize );
|
|---|
| 503 | }
|
|---|
| 504 |
|
|---|
| 505 | typedef SIZE_T WINAPI FN_GetLargePageMinimum( VOID );
|
|---|
| 506 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GetLargePageMinimum( VOID )
|
|---|
| 507 | {
|
|---|
| 508 | static FN_GetLargePageMinimum *pfn = 0;
|
|---|
| 509 | if (!pfn)
|
|---|
| 510 | kPrf2WrapResolve((void **)&pfn, "GetLargePageMinimum", &g_Kernel32);
|
|---|
| 511 | return pfn ();
|
|---|
| 512 | }
|
|---|
| 513 |
|
|---|
| 514 | typedef UINT WINAPI FN_EnumSystemFirmwareTables( DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize );
|
|---|
| 515 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_EnumSystemFirmwareTables( DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize )
|
|---|
| 516 | {
|
|---|
| 517 | static FN_EnumSystemFirmwareTables *pfn = 0;
|
|---|
| 518 | if (!pfn)
|
|---|
| 519 | kPrf2WrapResolve((void **)&pfn, "EnumSystemFirmwareTables", &g_Kernel32);
|
|---|
| 520 | return pfn( FirmwareTableProviderSignature, pFirmwareTableEnumBuffer, BufferSize );
|
|---|
| 521 | }
|
|---|
| 522 |
|
|---|
| 523 | typedef UINT WINAPI FN_GetSystemFirmwareTable( DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize );
|
|---|
| 524 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemFirmwareTable( DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize )
|
|---|
| 525 | {
|
|---|
| 526 | static FN_GetSystemFirmwareTable *pfn = 0;
|
|---|
| 527 | if (!pfn)
|
|---|
| 528 | kPrf2WrapResolve((void **)&pfn, "GetSystemFirmwareTable", &g_Kernel32);
|
|---|
| 529 | return pfn( FirmwareTableProviderSignature, FirmwareTableID, pFirmwareTableBuffer, BufferSize );
|
|---|
| 530 | }
|
|---|
| 531 |
|
|---|
| 532 | typedef BOOL WINAPI FN_VirtualFreeEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType );
|
|---|
| 533 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualFreeEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType )
|
|---|
| 534 | {
|
|---|
| 535 | static FN_VirtualFreeEx *pfn = 0;
|
|---|
| 536 | if (!pfn)
|
|---|
| 537 | kPrf2WrapResolve((void **)&pfn, "VirtualFreeEx", &g_Kernel32);
|
|---|
| 538 | return pfn( hProcess, lpAddress, dwSize, dwFreeType );
|
|---|
| 539 | }
|
|---|
| 540 |
|
|---|
| 541 | typedef BOOL WINAPI FN_VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect );
|
|---|
| 542 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect )
|
|---|
| 543 | {
|
|---|
| 544 | static FN_VirtualProtectEx *pfn = 0;
|
|---|
| 545 | if (!pfn)
|
|---|
| 546 | kPrf2WrapResolve((void **)&pfn, "VirtualProtectEx", &g_Kernel32);
|
|---|
| 547 | return pfn( hProcess, lpAddress, dwSize, flNewProtect, lpflOldProtect );
|
|---|
| 548 | }
|
|---|
| 549 |
|
|---|
| 550 | typedef SIZE_T WINAPI FN_VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength );
|
|---|
| 551 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength )
|
|---|
| 552 | {
|
|---|
| 553 | static FN_VirtualQueryEx *pfn = 0;
|
|---|
| 554 | if (!pfn)
|
|---|
| 555 | kPrf2WrapResolve((void **)&pfn, "VirtualQueryEx", &g_Kernel32);
|
|---|
| 556 | return pfn( hProcess, lpAddress, lpBuffer, dwLength );
|
|---|
| 557 | }
|
|---|
| 558 |
|
|---|
| 559 | typedef HANDLE WINAPI FN_HeapCreate( DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize );
|
|---|
| 560 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_HeapCreate( DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize )
|
|---|
| 561 | {
|
|---|
| 562 | static FN_HeapCreate *pfn = 0;
|
|---|
| 563 | if (!pfn)
|
|---|
| 564 | kPrf2WrapResolve((void **)&pfn, "HeapCreate", &g_Kernel32);
|
|---|
| 565 | return pfn( flOptions, dwInitialSize, dwMaximumSize );
|
|---|
| 566 | }
|
|---|
| 567 |
|
|---|
| 568 | typedef BOOL WINAPI FN_HeapDestroy( HANDLE hHeap );
|
|---|
| 569 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapDestroy( HANDLE hHeap )
|
|---|
| 570 | {
|
|---|
| 571 | static FN_HeapDestroy *pfn = 0;
|
|---|
| 572 | if (!pfn)
|
|---|
| 573 | kPrf2WrapResolve((void **)&pfn, "HeapDestroy", &g_Kernel32);
|
|---|
| 574 | return pfn( hHeap );
|
|---|
| 575 | }
|
|---|
| 576 |
|
|---|
| 577 | typedef LPVOID WINAPI FN_HeapAlloc( HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes );
|
|---|
| 578 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_HeapAlloc( HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes )
|
|---|
| 579 | {
|
|---|
| 580 | static FN_HeapAlloc *pfn = 0;
|
|---|
| 581 | if (!pfn)
|
|---|
| 582 | kPrf2WrapResolve((void **)&pfn, "HeapAlloc", &g_Kernel32);
|
|---|
| 583 | return pfn( hHeap, dwFlags, dwBytes );
|
|---|
| 584 | }
|
|---|
| 585 |
|
|---|
| 586 | typedef LPVOID WINAPI FN_HeapReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes );
|
|---|
| 587 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_HeapReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes )
|
|---|
| 588 | {
|
|---|
| 589 | static FN_HeapReAlloc *pfn = 0;
|
|---|
| 590 | if (!pfn)
|
|---|
| 591 | kPrf2WrapResolve((void **)&pfn, "HeapReAlloc", &g_Kernel32);
|
|---|
| 592 | return pfn( hHeap, dwFlags, lpMem, dwBytes );
|
|---|
| 593 | }
|
|---|
| 594 |
|
|---|
| 595 | typedef BOOL WINAPI FN_HeapFree( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem );
|
|---|
| 596 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapFree( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem )
|
|---|
| 597 | {
|
|---|
| 598 | static FN_HeapFree *pfn = 0;
|
|---|
| 599 | if (!pfn)
|
|---|
| 600 | kPrf2WrapResolve((void **)&pfn, "HeapFree", &g_Kernel32);
|
|---|
| 601 | return pfn( hHeap, dwFlags, lpMem );
|
|---|
| 602 | }
|
|---|
| 603 |
|
|---|
| 604 | typedef SIZE_T WINAPI FN_HeapSize( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem );
|
|---|
| 605 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_HeapSize( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem )
|
|---|
| 606 | {
|
|---|
| 607 | static FN_HeapSize *pfn = 0;
|
|---|
| 608 | if (!pfn)
|
|---|
| 609 | kPrf2WrapResolve((void **)&pfn, "HeapSize", &g_Kernel32);
|
|---|
| 610 | return pfn( hHeap, dwFlags, lpMem );
|
|---|
| 611 | }
|
|---|
| 612 |
|
|---|
| 613 | typedef BOOL WINAPI FN_HeapValidate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem );
|
|---|
| 614 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapValidate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem )
|
|---|
| 615 | {
|
|---|
| 616 | static FN_HeapValidate *pfn = 0;
|
|---|
| 617 | if (!pfn)
|
|---|
| 618 | kPrf2WrapResolve((void **)&pfn, "HeapValidate", &g_Kernel32);
|
|---|
| 619 | return pfn( hHeap, dwFlags, lpMem );
|
|---|
| 620 | }
|
|---|
| 621 |
|
|---|
| 622 | typedef SIZE_T WINAPI FN_HeapCompact( HANDLE hHeap, DWORD dwFlags );
|
|---|
| 623 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_HeapCompact( HANDLE hHeap, DWORD dwFlags )
|
|---|
| 624 | {
|
|---|
| 625 | static FN_HeapCompact *pfn = 0;
|
|---|
| 626 | if (!pfn)
|
|---|
| 627 | kPrf2WrapResolve((void **)&pfn, "HeapCompact", &g_Kernel32);
|
|---|
| 628 | return pfn( hHeap, dwFlags );
|
|---|
| 629 | }
|
|---|
| 630 |
|
|---|
| 631 | typedef HANDLE WINAPI FN_GetProcessHeap( VOID );
|
|---|
| 632 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetProcessHeap( VOID )
|
|---|
| 633 | {
|
|---|
| 634 | static FN_GetProcessHeap *pfn = 0;
|
|---|
| 635 | if (!pfn)
|
|---|
| 636 | kPrf2WrapResolve((void **)&pfn, "GetProcessHeap", &g_Kernel32);
|
|---|
| 637 | return pfn ();
|
|---|
| 638 | }
|
|---|
| 639 |
|
|---|
| 640 | typedef DWORD WINAPI FN_GetProcessHeaps( DWORD NumberOfHeaps, PHANDLE ProcessHeaps );
|
|---|
| 641 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessHeaps( DWORD NumberOfHeaps, PHANDLE ProcessHeaps )
|
|---|
| 642 | {
|
|---|
| 643 | static FN_GetProcessHeaps *pfn = 0;
|
|---|
| 644 | if (!pfn)
|
|---|
| 645 | kPrf2WrapResolve((void **)&pfn, "GetProcessHeaps", &g_Kernel32);
|
|---|
| 646 | return pfn( NumberOfHeaps, ProcessHeaps );
|
|---|
| 647 | }
|
|---|
| 648 |
|
|---|
| 649 | typedef BOOL WINAPI FN_HeapLock( HANDLE hHeap );
|
|---|
| 650 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapLock( HANDLE hHeap )
|
|---|
| 651 | {
|
|---|
| 652 | static FN_HeapLock *pfn = 0;
|
|---|
| 653 | if (!pfn)
|
|---|
| 654 | kPrf2WrapResolve((void **)&pfn, "HeapLock", &g_Kernel32);
|
|---|
| 655 | return pfn( hHeap );
|
|---|
| 656 | }
|
|---|
| 657 |
|
|---|
| 658 | typedef BOOL WINAPI FN_HeapUnlock( HANDLE hHeap );
|
|---|
| 659 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapUnlock( HANDLE hHeap )
|
|---|
| 660 | {
|
|---|
| 661 | static FN_HeapUnlock *pfn = 0;
|
|---|
| 662 | if (!pfn)
|
|---|
| 663 | kPrf2WrapResolve((void **)&pfn, "HeapUnlock", &g_Kernel32);
|
|---|
| 664 | return pfn( hHeap );
|
|---|
| 665 | }
|
|---|
| 666 |
|
|---|
| 667 | typedef BOOL WINAPI FN_HeapWalk( HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry );
|
|---|
| 668 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapWalk( HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry )
|
|---|
| 669 | {
|
|---|
| 670 | static FN_HeapWalk *pfn = 0;
|
|---|
| 671 | if (!pfn)
|
|---|
| 672 | kPrf2WrapResolve((void **)&pfn, "HeapWalk", &g_Kernel32);
|
|---|
| 673 | return pfn( hHeap, lpEntry );
|
|---|
| 674 | }
|
|---|
| 675 |
|
|---|
| 676 | typedef BOOL WINAPI FN_HeapSetInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength );
|
|---|
| 677 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapSetInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength )
|
|---|
| 678 | {
|
|---|
| 679 | static FN_HeapSetInformation *pfn = 0;
|
|---|
| 680 | if (!pfn)
|
|---|
| 681 | kPrf2WrapResolve((void **)&pfn, "HeapSetInformation", &g_Kernel32);
|
|---|
| 682 | return pfn( HeapHandle, HeapInformationClass, HeapInformation, HeapInformationLength );
|
|---|
| 683 | }
|
|---|
| 684 |
|
|---|
| 685 | typedef BOOL WINAPI FN_HeapQueryInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength );
|
|---|
| 686 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapQueryInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength )
|
|---|
| 687 | {
|
|---|
| 688 | static FN_HeapQueryInformation *pfn = 0;
|
|---|
| 689 | if (!pfn)
|
|---|
| 690 | kPrf2WrapResolve((void **)&pfn, "HeapQueryInformation", &g_Kernel32);
|
|---|
| 691 | return pfn( HeapHandle, HeapInformationClass, HeapInformation, HeapInformationLength, ReturnLength );
|
|---|
| 692 | }
|
|---|
| 693 |
|
|---|
| 694 | typedef BOOL WINAPI FN_GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
|
|---|
| 695 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
|
|---|
| 696 | {
|
|---|
| 697 | static FN_GetBinaryTypeA *pfn = 0;
|
|---|
| 698 | if (!pfn)
|
|---|
| 699 | kPrf2WrapResolve((void **)&pfn, "GetBinaryTypeA", &g_Kernel32);
|
|---|
| 700 | return pfn( lpApplicationName, lpBinaryType );
|
|---|
| 701 | }
|
|---|
| 702 |
|
|---|
| 703 | typedef BOOL WINAPI FN_GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType );
|
|---|
| 704 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType )
|
|---|
| 705 | {
|
|---|
| 706 | static FN_GetBinaryTypeW *pfn = 0;
|
|---|
| 707 | if (!pfn)
|
|---|
| 708 | kPrf2WrapResolve((void **)&pfn, "GetBinaryTypeW", &g_Kernel32);
|
|---|
| 709 | return pfn( lpApplicationName, lpBinaryType );
|
|---|
| 710 | }
|
|---|
| 711 |
|
|---|
| 712 | typedef DWORD WINAPI FN_GetShortPathNameA( LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer );
|
|---|
| 713 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetShortPathNameA( LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer )
|
|---|
| 714 | {
|
|---|
| 715 | static FN_GetShortPathNameA *pfn = 0;
|
|---|
| 716 | if (!pfn)
|
|---|
| 717 | kPrf2WrapResolve((void **)&pfn, "GetShortPathNameA", &g_Kernel32);
|
|---|
| 718 | return pfn( lpszLongPath, lpszShortPath, cchBuffer );
|
|---|
| 719 | }
|
|---|
| 720 |
|
|---|
| 721 | typedef DWORD WINAPI FN_GetShortPathNameW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer );
|
|---|
| 722 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetShortPathNameW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer )
|
|---|
| 723 | {
|
|---|
| 724 | static FN_GetShortPathNameW *pfn = 0;
|
|---|
| 725 | if (!pfn)
|
|---|
| 726 | kPrf2WrapResolve((void **)&pfn, "GetShortPathNameW", &g_Kernel32);
|
|---|
| 727 | return pfn( lpszLongPath, lpszShortPath, cchBuffer );
|
|---|
| 728 | }
|
|---|
| 729 |
|
|---|
| 730 | typedef DWORD WINAPI FN_GetLongPathNameA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer );
|
|---|
| 731 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLongPathNameA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer )
|
|---|
| 732 | {
|
|---|
| 733 | static FN_GetLongPathNameA *pfn = 0;
|
|---|
| 734 | if (!pfn)
|
|---|
| 735 | kPrf2WrapResolve((void **)&pfn, "GetLongPathNameA", &g_Kernel32);
|
|---|
| 736 | return pfn( lpszShortPath, lpszLongPath, cchBuffer );
|
|---|
| 737 | }
|
|---|
| 738 |
|
|---|
| 739 | typedef DWORD WINAPI FN_GetLongPathNameW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer );
|
|---|
| 740 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLongPathNameW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer )
|
|---|
| 741 | {
|
|---|
| 742 | static FN_GetLongPathNameW *pfn = 0;
|
|---|
| 743 | if (!pfn)
|
|---|
| 744 | kPrf2WrapResolve((void **)&pfn, "GetLongPathNameW", &g_Kernel32);
|
|---|
| 745 | return pfn( lpszShortPath, lpszLongPath, cchBuffer );
|
|---|
| 746 | }
|
|---|
| 747 |
|
|---|
| 748 | typedef BOOL WINAPI FN_GetProcessAffinityMask( HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask );
|
|---|
| 749 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessAffinityMask( HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask )
|
|---|
| 750 | {
|
|---|
| 751 | static FN_GetProcessAffinityMask *pfn = 0;
|
|---|
| 752 | if (!pfn)
|
|---|
| 753 | kPrf2WrapResolve((void **)&pfn, "GetProcessAffinityMask", &g_Kernel32);
|
|---|
| 754 | return pfn( hProcess, lpProcessAffinityMask, lpSystemAffinityMask );
|
|---|
| 755 | }
|
|---|
| 756 |
|
|---|
| 757 | typedef BOOL WINAPI FN_SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR dwProcessAffinityMask );
|
|---|
| 758 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR dwProcessAffinityMask )
|
|---|
| 759 | {
|
|---|
| 760 | static FN_SetProcessAffinityMask *pfn = 0;
|
|---|
| 761 | if (!pfn)
|
|---|
| 762 | kPrf2WrapResolve((void **)&pfn, "SetProcessAffinityMask", &g_Kernel32);
|
|---|
| 763 | return pfn( hProcess, dwProcessAffinityMask );
|
|---|
| 764 | }
|
|---|
| 765 |
|
|---|
| 766 | typedef BOOL WINAPI FN_GetProcessHandleCount( HANDLE hProcess, PDWORD pdwHandleCount );
|
|---|
| 767 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessHandleCount( HANDLE hProcess, PDWORD pdwHandleCount )
|
|---|
| 768 | {
|
|---|
| 769 | static FN_GetProcessHandleCount *pfn = 0;
|
|---|
| 770 | if (!pfn)
|
|---|
| 771 | kPrf2WrapResolve((void **)&pfn, "GetProcessHandleCount", &g_Kernel32);
|
|---|
| 772 | return pfn( hProcess, pdwHandleCount );
|
|---|
| 773 | }
|
|---|
| 774 |
|
|---|
| 775 | typedef BOOL WINAPI FN_GetProcessTimes( HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
|
|---|
| 776 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessTimes( HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
|
|---|
| 777 | {
|
|---|
| 778 | static FN_GetProcessTimes *pfn = 0;
|
|---|
| 779 | if (!pfn)
|
|---|
| 780 | kPrf2WrapResolve((void **)&pfn, "GetProcessTimes", &g_Kernel32);
|
|---|
| 781 | return pfn( hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime );
|
|---|
| 782 | }
|
|---|
| 783 |
|
|---|
| 784 | typedef BOOL WINAPI FN_GetProcessIoCounters( HANDLE hProcess, PIO_COUNTERS lpIoCounters );
|
|---|
| 785 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessIoCounters( HANDLE hProcess, PIO_COUNTERS lpIoCounters )
|
|---|
| 786 | {
|
|---|
| 787 | static FN_GetProcessIoCounters *pfn = 0;
|
|---|
| 788 | if (!pfn)
|
|---|
| 789 | kPrf2WrapResolve((void **)&pfn, "GetProcessIoCounters", &g_Kernel32);
|
|---|
| 790 | return pfn( hProcess, lpIoCounters );
|
|---|
| 791 | }
|
|---|
| 792 |
|
|---|
| 793 | typedef BOOL WINAPI FN_GetProcessWorkingSetSize( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize );
|
|---|
| 794 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessWorkingSetSize( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize )
|
|---|
| 795 | {
|
|---|
| 796 | static FN_GetProcessWorkingSetSize *pfn = 0;
|
|---|
| 797 | if (!pfn)
|
|---|
| 798 | kPrf2WrapResolve((void **)&pfn, "GetProcessWorkingSetSize", &g_Kernel32);
|
|---|
| 799 | return pfn( hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize );
|
|---|
| 800 | }
|
|---|
| 801 |
|
|---|
| 802 | typedef BOOL WINAPI FN_GetProcessWorkingSetSizeEx( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags );
|
|---|
| 803 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessWorkingSetSizeEx( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags )
|
|---|
| 804 | {
|
|---|
| 805 | static FN_GetProcessWorkingSetSizeEx *pfn = 0;
|
|---|
| 806 | if (!pfn)
|
|---|
| 807 | kPrf2WrapResolve((void **)&pfn, "GetProcessWorkingSetSizeEx", &g_Kernel32);
|
|---|
| 808 | return pfn( hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize, Flags );
|
|---|
| 809 | }
|
|---|
| 810 |
|
|---|
| 811 | typedef BOOL WINAPI FN_SetProcessWorkingSetSize( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize );
|
|---|
| 812 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessWorkingSetSize( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize )
|
|---|
| 813 | {
|
|---|
| 814 | static FN_SetProcessWorkingSetSize *pfn = 0;
|
|---|
| 815 | if (!pfn)
|
|---|
| 816 | kPrf2WrapResolve((void **)&pfn, "SetProcessWorkingSetSize", &g_Kernel32);
|
|---|
| 817 | return pfn( hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize );
|
|---|
| 818 | }
|
|---|
| 819 |
|
|---|
| 820 | typedef BOOL WINAPI FN_SetProcessWorkingSetSizeEx( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags );
|
|---|
| 821 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessWorkingSetSizeEx( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags )
|
|---|
| 822 | {
|
|---|
| 823 | static FN_SetProcessWorkingSetSizeEx *pfn = 0;
|
|---|
| 824 | if (!pfn)
|
|---|
| 825 | kPrf2WrapResolve((void **)&pfn, "SetProcessWorkingSetSizeEx", &g_Kernel32);
|
|---|
| 826 | return pfn( hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize, Flags );
|
|---|
| 827 | }
|
|---|
| 828 |
|
|---|
| 829 | typedef HANDLE WINAPI FN_OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId );
|
|---|
| 830 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId )
|
|---|
| 831 | {
|
|---|
| 832 | static FN_OpenProcess *pfn = 0;
|
|---|
| 833 | if (!pfn)
|
|---|
| 834 | kPrf2WrapResolve((void **)&pfn, "OpenProcess", &g_Kernel32);
|
|---|
| 835 | return pfn( dwDesiredAccess, bInheritHandle, dwProcessId );
|
|---|
| 836 | }
|
|---|
| 837 |
|
|---|
| 838 | typedef HANDLE WINAPI FN_GetCurrentProcess( VOID );
|
|---|
| 839 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetCurrentProcess( VOID )
|
|---|
| 840 | {
|
|---|
| 841 | static FN_GetCurrentProcess *pfn = 0;
|
|---|
| 842 | if (!pfn)
|
|---|
| 843 | kPrf2WrapResolve((void **)&pfn, "GetCurrentProcess", &g_Kernel32);
|
|---|
| 844 | return pfn ();
|
|---|
| 845 | }
|
|---|
| 846 |
|
|---|
| 847 | typedef DWORD WINAPI FN_GetCurrentProcessId( VOID );
|
|---|
| 848 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentProcessId( VOID )
|
|---|
| 849 | {
|
|---|
| 850 | static FN_GetCurrentProcessId *pfn = 0;
|
|---|
| 851 | if (!pfn)
|
|---|
| 852 | kPrf2WrapResolve((void **)&pfn, "GetCurrentProcessId", &g_Kernel32);
|
|---|
| 853 | return pfn ();
|
|---|
| 854 | }
|
|---|
| 855 |
|
|---|
| 856 | typedef VOID WINAPI FN_ExitProcess( UINT uExitCode );
|
|---|
| 857 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_ExitProcess( UINT uExitCode )
|
|---|
| 858 | {
|
|---|
| 859 | static FN_ExitProcess *pfn = 0;
|
|---|
| 860 | if (!pfn)
|
|---|
| 861 | kPrf2WrapResolve((void **)&pfn, "ExitProcess", &g_Kernel32);
|
|---|
| 862 | pfn( uExitCode );
|
|---|
| 863 | }
|
|---|
| 864 |
|
|---|
| 865 | typedef BOOL WINAPI FN_TerminateProcess( HANDLE hProcess, UINT uExitCode );
|
|---|
| 866 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateProcess( HANDLE hProcess, UINT uExitCode )
|
|---|
| 867 | {
|
|---|
| 868 | static FN_TerminateProcess *pfn = 0;
|
|---|
| 869 | if (!pfn)
|
|---|
| 870 | kPrf2WrapResolve((void **)&pfn, "TerminateProcess", &g_Kernel32);
|
|---|
| 871 | return pfn( hProcess, uExitCode );
|
|---|
| 872 | }
|
|---|
| 873 |
|
|---|
| 874 | typedef BOOL WINAPI FN_GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode );
|
|---|
| 875 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode )
|
|---|
| 876 | {
|
|---|
| 877 | static FN_GetExitCodeProcess *pfn = 0;
|
|---|
| 878 | if (!pfn)
|
|---|
| 879 | kPrf2WrapResolve((void **)&pfn, "GetExitCodeProcess", &g_Kernel32);
|
|---|
| 880 | return pfn( hProcess, lpExitCode );
|
|---|
| 881 | }
|
|---|
| 882 |
|
|---|
| 883 | typedef VOID WINAPI FN_FatalExit( int ExitCode );
|
|---|
| 884 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalExit( int ExitCode )
|
|---|
| 885 | {
|
|---|
| 886 | static FN_FatalExit *pfn = 0;
|
|---|
| 887 | if (!pfn)
|
|---|
| 888 | kPrf2WrapResolve((void **)&pfn, "FatalExit", &g_Kernel32);
|
|---|
| 889 | pfn( ExitCode );
|
|---|
| 890 | }
|
|---|
| 891 |
|
|---|
| 892 | typedef LPCH WINAPI FN_GetEnvironmentStrings( VOID );
|
|---|
| 893 | __declspec(dllexport) LPCH WINAPI kPrf2Wrap_GetEnvironmentStrings( VOID )
|
|---|
| 894 | {
|
|---|
| 895 | static FN_GetEnvironmentStrings *pfn = 0;
|
|---|
| 896 | if (!pfn)
|
|---|
| 897 | kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStrings", &g_Kernel32);
|
|---|
| 898 | return pfn ();
|
|---|
| 899 | }
|
|---|
| 900 |
|
|---|
| 901 | typedef LPWCH WINAPI FN_GetEnvironmentStringsW( VOID );
|
|---|
| 902 | __declspec(dllexport) LPWCH WINAPI kPrf2Wrap_GetEnvironmentStringsW( VOID )
|
|---|
| 903 | {
|
|---|
| 904 | static FN_GetEnvironmentStringsW *pfn = 0;
|
|---|
| 905 | if (!pfn)
|
|---|
| 906 | kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStringsW", &g_Kernel32);
|
|---|
| 907 | return pfn ();
|
|---|
| 908 | }
|
|---|
| 909 |
|
|---|
| 910 | typedef BOOL WINAPI FN_SetEnvironmentStringsA( LPCH NewEnvironment );
|
|---|
| 911 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentStringsA( LPCH NewEnvironment )
|
|---|
| 912 | {
|
|---|
| 913 | static FN_SetEnvironmentStringsA *pfn = 0;
|
|---|
| 914 | if (!pfn)
|
|---|
| 915 | kPrf2WrapResolve((void **)&pfn, "SetEnvironmentStringsA", &g_Kernel32);
|
|---|
| 916 | return pfn( NewEnvironment );
|
|---|
| 917 | }
|
|---|
| 918 |
|
|---|
| 919 | typedef BOOL WINAPI FN_SetEnvironmentStringsW( LPWCH NewEnvironment );
|
|---|
| 920 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentStringsW( LPWCH NewEnvironment )
|
|---|
| 921 | {
|
|---|
| 922 | static FN_SetEnvironmentStringsW *pfn = 0;
|
|---|
| 923 | if (!pfn)
|
|---|
| 924 | kPrf2WrapResolve((void **)&pfn, "SetEnvironmentStringsW", &g_Kernel32);
|
|---|
| 925 | return pfn( NewEnvironment );
|
|---|
| 926 | }
|
|---|
| 927 |
|
|---|
| 928 | typedef BOOL WINAPI FN_FreeEnvironmentStringsA( LPCH a);
|
|---|
| 929 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeEnvironmentStringsA( LPCH a)
|
|---|
| 930 | {
|
|---|
| 931 | static FN_FreeEnvironmentStringsA *pfn = 0;
|
|---|
| 932 | if (!pfn)
|
|---|
| 933 | kPrf2WrapResolve((void **)&pfn, "FreeEnvironmentStringsA", &g_Kernel32);
|
|---|
| 934 | return pfn( a);
|
|---|
| 935 | }
|
|---|
| 936 |
|
|---|
| 937 | typedef BOOL WINAPI FN_FreeEnvironmentStringsW( LPWCH a);
|
|---|
| 938 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeEnvironmentStringsW( LPWCH a)
|
|---|
| 939 | {
|
|---|
| 940 | static FN_FreeEnvironmentStringsW *pfn = 0;
|
|---|
| 941 | if (!pfn)
|
|---|
| 942 | kPrf2WrapResolve((void **)&pfn, "FreeEnvironmentStringsW", &g_Kernel32);
|
|---|
| 943 | return pfn( a);
|
|---|
| 944 | }
|
|---|
| 945 |
|
|---|
| 946 | typedef VOID WINAPI FN_RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, CONST ULONG_PTR * lpArguments );
|
|---|
| 947 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, CONST ULONG_PTR * lpArguments )
|
|---|
| 948 | {
|
|---|
| 949 | static FN_RaiseException *pfn = 0;
|
|---|
| 950 | if (!pfn)
|
|---|
| 951 | kPrf2WrapResolve((void **)&pfn, "RaiseException", &g_Kernel32);
|
|---|
| 952 | pfn( dwExceptionCode, dwExceptionFlags, nNumberOfArguments, lpArguments );
|
|---|
| 953 | }
|
|---|
| 954 |
|
|---|
| 955 | typedef LONG WINAPI FN_UnhandledExceptionFilter( struct _EXCEPTION_POINTERS * ExceptionInfo );
|
|---|
| 956 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_UnhandledExceptionFilter( struct _EXCEPTION_POINTERS * ExceptionInfo )
|
|---|
| 957 | {
|
|---|
| 958 | static FN_UnhandledExceptionFilter *pfn = 0;
|
|---|
| 959 | if (!pfn)
|
|---|
| 960 | kPrf2WrapResolve((void **)&pfn, "UnhandledExceptionFilter", &g_Kernel32);
|
|---|
| 961 | return pfn( ExceptionInfo );
|
|---|
| 962 | }
|
|---|
| 963 |
|
|---|
| 964 | typedef LPTOP_LEVEL_EXCEPTION_FILTER WINAPI FN_SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter );
|
|---|
| 965 | __declspec(dllexport) LPTOP_LEVEL_EXCEPTION_FILTER WINAPI kPrf2Wrap_SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter )
|
|---|
| 966 | {
|
|---|
| 967 | static FN_SetUnhandledExceptionFilter *pfn = 0;
|
|---|
| 968 | if (!pfn)
|
|---|
| 969 | kPrf2WrapResolve((void **)&pfn, "SetUnhandledExceptionFilter", &g_Kernel32);
|
|---|
| 970 | return pfn( lpTopLevelExceptionFilter );
|
|---|
| 971 | }
|
|---|
| 972 |
|
|---|
| 973 | typedef LPVOID WINAPI FN_CreateFiber( SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter );
|
|---|
| 974 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_CreateFiber( SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter )
|
|---|
| 975 | {
|
|---|
| 976 | static FN_CreateFiber *pfn = 0;
|
|---|
| 977 | if (!pfn)
|
|---|
| 978 | kPrf2WrapResolve((void **)&pfn, "CreateFiber", &g_Kernel32);
|
|---|
| 979 | return pfn( dwStackSize, lpStartAddress, lpParameter );
|
|---|
| 980 | }
|
|---|
| 981 |
|
|---|
| 982 | typedef LPVOID WINAPI FN_CreateFiberEx( SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter );
|
|---|
| 983 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_CreateFiberEx( SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter )
|
|---|
| 984 | {
|
|---|
| 985 | static FN_CreateFiberEx *pfn = 0;
|
|---|
| 986 | if (!pfn)
|
|---|
| 987 | kPrf2WrapResolve((void **)&pfn, "CreateFiberEx", &g_Kernel32);
|
|---|
| 988 | return pfn( dwStackCommitSize, dwStackReserveSize, dwFlags, lpStartAddress, lpParameter );
|
|---|
| 989 | }
|
|---|
| 990 |
|
|---|
| 991 | typedef VOID WINAPI FN_DeleteFiber( LPVOID lpFiber );
|
|---|
| 992 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_DeleteFiber( LPVOID lpFiber )
|
|---|
| 993 | {
|
|---|
| 994 | static FN_DeleteFiber *pfn = 0;
|
|---|
| 995 | if (!pfn)
|
|---|
| 996 | kPrf2WrapResolve((void **)&pfn, "DeleteFiber", &g_Kernel32);
|
|---|
| 997 | pfn( lpFiber );
|
|---|
| 998 | }
|
|---|
| 999 |
|
|---|
| 1000 | typedef LPVOID WINAPI FN_ConvertThreadToFiber( LPVOID lpParameter );
|
|---|
| 1001 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_ConvertThreadToFiber( LPVOID lpParameter )
|
|---|
| 1002 | {
|
|---|
| 1003 | static FN_ConvertThreadToFiber *pfn = 0;
|
|---|
| 1004 | if (!pfn)
|
|---|
| 1005 | kPrf2WrapResolve((void **)&pfn, "ConvertThreadToFiber", &g_Kernel32);
|
|---|
| 1006 | return pfn( lpParameter );
|
|---|
| 1007 | }
|
|---|
| 1008 |
|
|---|
| 1009 | typedef LPVOID WINAPI FN_ConvertThreadToFiberEx( LPVOID lpParameter, DWORD dwFlags );
|
|---|
| 1010 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_ConvertThreadToFiberEx( LPVOID lpParameter, DWORD dwFlags )
|
|---|
| 1011 | {
|
|---|
| 1012 | static FN_ConvertThreadToFiberEx *pfn = 0;
|
|---|
| 1013 | if (!pfn)
|
|---|
| 1014 | kPrf2WrapResolve((void **)&pfn, "ConvertThreadToFiberEx", &g_Kernel32);
|
|---|
| 1015 | return pfn( lpParameter, dwFlags );
|
|---|
| 1016 | }
|
|---|
| 1017 |
|
|---|
| 1018 | typedef BOOL WINAPI FN_ConvertFiberToThread( VOID );
|
|---|
| 1019 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConvertFiberToThread( VOID )
|
|---|
| 1020 | {
|
|---|
| 1021 | static FN_ConvertFiberToThread *pfn = 0;
|
|---|
| 1022 | if (!pfn)
|
|---|
| 1023 | kPrf2WrapResolve((void **)&pfn, "ConvertFiberToThread", &g_Kernel32);
|
|---|
| 1024 | return pfn ();
|
|---|
| 1025 | }
|
|---|
| 1026 |
|
|---|
| 1027 | typedef VOID WINAPI FN_SwitchToFiber( LPVOID lpFiber );
|
|---|
| 1028 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_SwitchToFiber( LPVOID lpFiber )
|
|---|
| 1029 | {
|
|---|
| 1030 | static FN_SwitchToFiber *pfn = 0;
|
|---|
| 1031 | if (!pfn)
|
|---|
| 1032 | kPrf2WrapResolve((void **)&pfn, "SwitchToFiber", &g_Kernel32);
|
|---|
| 1033 | pfn( lpFiber );
|
|---|
| 1034 | }
|
|---|
| 1035 |
|
|---|
| 1036 | typedef BOOL WINAPI FN_SwitchToThread( VOID );
|
|---|
| 1037 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SwitchToThread( VOID )
|
|---|
| 1038 | {
|
|---|
| 1039 | static FN_SwitchToThread *pfn = 0;
|
|---|
| 1040 | if (!pfn)
|
|---|
| 1041 | kPrf2WrapResolve((void **)&pfn, "SwitchToThread", &g_Kernel32);
|
|---|
| 1042 | return pfn ();
|
|---|
| 1043 | }
|
|---|
| 1044 |
|
|---|
| 1045 | typedef HANDLE WINAPI FN_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
|
|---|
| 1046 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId )
|
|---|
| 1047 | {
|
|---|
| 1048 | static FN_CreateThread *pfn = 0;
|
|---|
| 1049 | if (!pfn)
|
|---|
| 1050 | kPrf2WrapResolve((void **)&pfn, "CreateThread", &g_Kernel32);
|
|---|
| 1051 | return pfn( lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId );
|
|---|
| 1052 | }
|
|---|
| 1053 |
|
|---|
| 1054 | typedef HANDLE WINAPI FN_CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
|
|---|
| 1055 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId )
|
|---|
| 1056 | {
|
|---|
| 1057 | static FN_CreateRemoteThread *pfn = 0;
|
|---|
| 1058 | if (!pfn)
|
|---|
| 1059 | kPrf2WrapResolve((void **)&pfn, "CreateRemoteThread", &g_Kernel32);
|
|---|
| 1060 | return pfn( hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId );
|
|---|
| 1061 | }
|
|---|
| 1062 |
|
|---|
| 1063 | typedef HANDLE WINAPI FN_GetCurrentThread( VOID );
|
|---|
| 1064 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetCurrentThread( VOID )
|
|---|
| 1065 | {
|
|---|
| 1066 | static FN_GetCurrentThread *pfn = 0;
|
|---|
| 1067 | if (!pfn)
|
|---|
| 1068 | kPrf2WrapResolve((void **)&pfn, "GetCurrentThread", &g_Kernel32);
|
|---|
| 1069 | return pfn ();
|
|---|
| 1070 | }
|
|---|
| 1071 |
|
|---|
| 1072 | typedef DWORD WINAPI FN_GetCurrentThreadId( VOID );
|
|---|
| 1073 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentThreadId( VOID )
|
|---|
| 1074 | {
|
|---|
| 1075 | static FN_GetCurrentThreadId *pfn = 0;
|
|---|
| 1076 | if (!pfn)
|
|---|
| 1077 | kPrf2WrapResolve((void **)&pfn, "GetCurrentThreadId", &g_Kernel32);
|
|---|
| 1078 | return pfn ();
|
|---|
| 1079 | }
|
|---|
| 1080 |
|
|---|
| 1081 | typedef BOOL WINAPI FN_SetThreadStackGuarantee( PULONG StackSizeInBytes );
|
|---|
| 1082 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadStackGuarantee( PULONG StackSizeInBytes )
|
|---|
| 1083 | {
|
|---|
| 1084 | static FN_SetThreadStackGuarantee *pfn = 0;
|
|---|
| 1085 | if (!pfn)
|
|---|
| 1086 | kPrf2WrapResolve((void **)&pfn, "SetThreadStackGuarantee", &g_Kernel32);
|
|---|
| 1087 | return pfn( StackSizeInBytes );
|
|---|
| 1088 | }
|
|---|
| 1089 |
|
|---|
| 1090 | typedef DWORD WINAPI FN_GetProcessIdOfThread( HANDLE Thread );
|
|---|
| 1091 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessIdOfThread( HANDLE Thread )
|
|---|
| 1092 | {
|
|---|
| 1093 | static FN_GetProcessIdOfThread *pfn = 0;
|
|---|
| 1094 | if (!pfn)
|
|---|
| 1095 | kPrf2WrapResolve((void **)&pfn, "GetProcessIdOfThread", &g_Kernel32);
|
|---|
| 1096 | return pfn( Thread );
|
|---|
| 1097 | }
|
|---|
| 1098 |
|
|---|
| 1099 | typedef DWORD WINAPI FN_GetThreadId( HANDLE Thread );
|
|---|
| 1100 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetThreadId( HANDLE Thread )
|
|---|
| 1101 | {
|
|---|
| 1102 | static FN_GetThreadId *pfn = 0;
|
|---|
| 1103 | if (!pfn)
|
|---|
| 1104 | kPrf2WrapResolve((void **)&pfn, "GetThreadId", &g_Kernel32);
|
|---|
| 1105 | return pfn( Thread );
|
|---|
| 1106 | }
|
|---|
| 1107 |
|
|---|
| 1108 | typedef DWORD WINAPI FN_GetProcessId( HANDLE Process );
|
|---|
| 1109 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessId( HANDLE Process )
|
|---|
| 1110 | {
|
|---|
| 1111 | static FN_GetProcessId *pfn = 0;
|
|---|
| 1112 | if (!pfn)
|
|---|
| 1113 | kPrf2WrapResolve((void **)&pfn, "GetProcessId", &g_Kernel32);
|
|---|
| 1114 | return pfn( Process );
|
|---|
| 1115 | }
|
|---|
| 1116 |
|
|---|
| 1117 | typedef DWORD WINAPI FN_GetCurrentProcessorNumber( VOID );
|
|---|
| 1118 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentProcessorNumber( VOID )
|
|---|
| 1119 | {
|
|---|
| 1120 | static FN_GetCurrentProcessorNumber *pfn = 0;
|
|---|
| 1121 | if (!pfn)
|
|---|
| 1122 | kPrf2WrapResolve((void **)&pfn, "GetCurrentProcessorNumber", &g_Kernel32);
|
|---|
| 1123 | return pfn ();
|
|---|
| 1124 | }
|
|---|
| 1125 |
|
|---|
| 1126 | typedef DWORD_PTR WINAPI FN_SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask );
|
|---|
| 1127 | __declspec(dllexport) DWORD_PTR WINAPI kPrf2Wrap_SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
|
|---|
| 1128 | {
|
|---|
| 1129 | static FN_SetThreadAffinityMask *pfn = 0;
|
|---|
| 1130 | if (!pfn)
|
|---|
| 1131 | kPrf2WrapResolve((void **)&pfn, "SetThreadAffinityMask", &g_Kernel32);
|
|---|
| 1132 | return pfn( hThread, dwThreadAffinityMask );
|
|---|
| 1133 | }
|
|---|
| 1134 |
|
|---|
| 1135 | typedef DWORD WINAPI FN_SetThreadIdealProcessor( HANDLE hThread, DWORD dwIdealProcessor );
|
|---|
| 1136 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetThreadIdealProcessor( HANDLE hThread, DWORD dwIdealProcessor )
|
|---|
| 1137 | {
|
|---|
| 1138 | static FN_SetThreadIdealProcessor *pfn = 0;
|
|---|
| 1139 | if (!pfn)
|
|---|
| 1140 | kPrf2WrapResolve((void **)&pfn, "SetThreadIdealProcessor", &g_Kernel32);
|
|---|
| 1141 | return pfn( hThread, dwIdealProcessor );
|
|---|
| 1142 | }
|
|---|
| 1143 |
|
|---|
| 1144 | typedef BOOL WINAPI FN_SetProcessPriorityBoost( HANDLE hProcess, BOOL bDisablePriorityBoost );
|
|---|
| 1145 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessPriorityBoost( HANDLE hProcess, BOOL bDisablePriorityBoost )
|
|---|
| 1146 | {
|
|---|
| 1147 | static FN_SetProcessPriorityBoost *pfn = 0;
|
|---|
| 1148 | if (!pfn)
|
|---|
| 1149 | kPrf2WrapResolve((void **)&pfn, "SetProcessPriorityBoost", &g_Kernel32);
|
|---|
| 1150 | return pfn( hProcess, bDisablePriorityBoost );
|
|---|
| 1151 | }
|
|---|
| 1152 |
|
|---|
| 1153 | typedef BOOL WINAPI FN_GetProcessPriorityBoost( HANDLE hProcess, PBOOL pDisablePriorityBoost );
|
|---|
| 1154 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessPriorityBoost( HANDLE hProcess, PBOOL pDisablePriorityBoost )
|
|---|
| 1155 | {
|
|---|
| 1156 | static FN_GetProcessPriorityBoost *pfn = 0;
|
|---|
| 1157 | if (!pfn)
|
|---|
| 1158 | kPrf2WrapResolve((void **)&pfn, "GetProcessPriorityBoost", &g_Kernel32);
|
|---|
| 1159 | return pfn( hProcess, pDisablePriorityBoost );
|
|---|
| 1160 | }
|
|---|
| 1161 |
|
|---|
| 1162 | typedef BOOL WINAPI FN_RequestWakeupLatency( LATENCY_TIME latency );
|
|---|
| 1163 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RequestWakeupLatency( LATENCY_TIME latency )
|
|---|
| 1164 | {
|
|---|
| 1165 | static FN_RequestWakeupLatency *pfn = 0;
|
|---|
| 1166 | if (!pfn)
|
|---|
| 1167 | kPrf2WrapResolve((void **)&pfn, "RequestWakeupLatency", &g_Kernel32);
|
|---|
| 1168 | return pfn( latency );
|
|---|
| 1169 | }
|
|---|
| 1170 |
|
|---|
| 1171 | typedef BOOL WINAPI FN_IsSystemResumeAutomatic( VOID );
|
|---|
| 1172 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsSystemResumeAutomatic( VOID )
|
|---|
| 1173 | {
|
|---|
| 1174 | static FN_IsSystemResumeAutomatic *pfn = 0;
|
|---|
| 1175 | if (!pfn)
|
|---|
| 1176 | kPrf2WrapResolve((void **)&pfn, "IsSystemResumeAutomatic", &g_Kernel32);
|
|---|
| 1177 | return pfn ();
|
|---|
| 1178 | }
|
|---|
| 1179 |
|
|---|
| 1180 | typedef HANDLE WINAPI FN_OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId );
|
|---|
| 1181 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
|
|---|
| 1182 | {
|
|---|
| 1183 | static FN_OpenThread *pfn = 0;
|
|---|
| 1184 | if (!pfn)
|
|---|
| 1185 | kPrf2WrapResolve((void **)&pfn, "OpenThread", &g_Kernel32);
|
|---|
| 1186 | return pfn( dwDesiredAccess, bInheritHandle, dwThreadId );
|
|---|
| 1187 | }
|
|---|
| 1188 |
|
|---|
| 1189 | typedef BOOL WINAPI FN_SetThreadPriority( HANDLE hThread, int nPriority );
|
|---|
| 1190 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadPriority( HANDLE hThread, int nPriority )
|
|---|
| 1191 | {
|
|---|
| 1192 | static FN_SetThreadPriority *pfn = 0;
|
|---|
| 1193 | if (!pfn)
|
|---|
| 1194 | kPrf2WrapResolve((void **)&pfn, "SetThreadPriority", &g_Kernel32);
|
|---|
| 1195 | return pfn( hThread, nPriority );
|
|---|
| 1196 | }
|
|---|
| 1197 |
|
|---|
| 1198 | typedef BOOL WINAPI FN_SetThreadPriorityBoost( HANDLE hThread, BOOL bDisablePriorityBoost );
|
|---|
| 1199 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadPriorityBoost( HANDLE hThread, BOOL bDisablePriorityBoost )
|
|---|
| 1200 | {
|
|---|
| 1201 | static FN_SetThreadPriorityBoost *pfn = 0;
|
|---|
| 1202 | if (!pfn)
|
|---|
| 1203 | kPrf2WrapResolve((void **)&pfn, "SetThreadPriorityBoost", &g_Kernel32);
|
|---|
| 1204 | return pfn( hThread, bDisablePriorityBoost );
|
|---|
| 1205 | }
|
|---|
| 1206 |
|
|---|
| 1207 | typedef BOOL WINAPI FN_GetThreadPriorityBoost( HANDLE hThread, PBOOL pDisablePriorityBoost );
|
|---|
| 1208 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadPriorityBoost( HANDLE hThread, PBOOL pDisablePriorityBoost )
|
|---|
| 1209 | {
|
|---|
| 1210 | static FN_GetThreadPriorityBoost *pfn = 0;
|
|---|
| 1211 | if (!pfn)
|
|---|
| 1212 | kPrf2WrapResolve((void **)&pfn, "GetThreadPriorityBoost", &g_Kernel32);
|
|---|
| 1213 | return pfn( hThread, pDisablePriorityBoost );
|
|---|
| 1214 | }
|
|---|
| 1215 |
|
|---|
| 1216 | typedef int WINAPI FN_GetThreadPriority( HANDLE hThread );
|
|---|
| 1217 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetThreadPriority( HANDLE hThread )
|
|---|
| 1218 | {
|
|---|
| 1219 | static FN_GetThreadPriority *pfn = 0;
|
|---|
| 1220 | if (!pfn)
|
|---|
| 1221 | kPrf2WrapResolve((void **)&pfn, "GetThreadPriority", &g_Kernel32);
|
|---|
| 1222 | return pfn( hThread );
|
|---|
| 1223 | }
|
|---|
| 1224 |
|
|---|
| 1225 | typedef BOOL WINAPI FN_GetThreadTimes( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
|
|---|
| 1226 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadTimes( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
|
|---|
| 1227 | {
|
|---|
| 1228 | static FN_GetThreadTimes *pfn = 0;
|
|---|
| 1229 | if (!pfn)
|
|---|
| 1230 | kPrf2WrapResolve((void **)&pfn, "GetThreadTimes", &g_Kernel32);
|
|---|
| 1231 | return pfn( hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime );
|
|---|
| 1232 | }
|
|---|
| 1233 |
|
|---|
| 1234 | typedef BOOL WINAPI FN_GetThreadIOPendingFlag( HANDLE hThread, PBOOL lpIOIsPending );
|
|---|
| 1235 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadIOPendingFlag( HANDLE hThread, PBOOL lpIOIsPending )
|
|---|
| 1236 | {
|
|---|
| 1237 | static FN_GetThreadIOPendingFlag *pfn = 0;
|
|---|
| 1238 | if (!pfn)
|
|---|
| 1239 | kPrf2WrapResolve((void **)&pfn, "GetThreadIOPendingFlag", &g_Kernel32);
|
|---|
| 1240 | return pfn( hThread, lpIOIsPending );
|
|---|
| 1241 | }
|
|---|
| 1242 |
|
|---|
| 1243 | typedef VOID WINAPI FN_ExitThread( DWORD dwExitCode );
|
|---|
| 1244 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_ExitThread( DWORD dwExitCode )
|
|---|
| 1245 | {
|
|---|
| 1246 | static FN_ExitThread *pfn = 0;
|
|---|
| 1247 | if (!pfn)
|
|---|
| 1248 | kPrf2WrapResolve((void **)&pfn, "ExitThread", &g_Kernel32);
|
|---|
| 1249 | pfn( dwExitCode );
|
|---|
| 1250 | }
|
|---|
| 1251 |
|
|---|
| 1252 | typedef BOOL WINAPI FN_TerminateThread( HANDLE hThread, DWORD dwExitCode );
|
|---|
| 1253 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateThread( HANDLE hThread, DWORD dwExitCode )
|
|---|
| 1254 | {
|
|---|
| 1255 | static FN_TerminateThread *pfn = 0;
|
|---|
| 1256 | if (!pfn)
|
|---|
| 1257 | kPrf2WrapResolve((void **)&pfn, "TerminateThread", &g_Kernel32);
|
|---|
| 1258 | return pfn( hThread, dwExitCode );
|
|---|
| 1259 | }
|
|---|
| 1260 |
|
|---|
| 1261 | typedef BOOL WINAPI FN_GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode );
|
|---|
| 1262 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode )
|
|---|
| 1263 | {
|
|---|
| 1264 | static FN_GetExitCodeThread *pfn = 0;
|
|---|
| 1265 | if (!pfn)
|
|---|
| 1266 | kPrf2WrapResolve((void **)&pfn, "GetExitCodeThread", &g_Kernel32);
|
|---|
| 1267 | return pfn( hThread, lpExitCode );
|
|---|
| 1268 | }
|
|---|
| 1269 |
|
|---|
| 1270 | typedef BOOL WINAPI FN_GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry );
|
|---|
| 1271 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry )
|
|---|
| 1272 | {
|
|---|
| 1273 | static FN_GetThreadSelectorEntry *pfn = 0;
|
|---|
| 1274 | if (!pfn)
|
|---|
| 1275 | kPrf2WrapResolve((void **)&pfn, "GetThreadSelectorEntry", &g_Kernel32);
|
|---|
| 1276 | return pfn( hThread, dwSelector, lpSelectorEntry );
|
|---|
| 1277 | }
|
|---|
| 1278 |
|
|---|
| 1279 | typedef EXECUTION_STATE WINAPI FN_SetThreadExecutionState( EXECUTION_STATE esFlags );
|
|---|
| 1280 | __declspec(dllexport) EXECUTION_STATE WINAPI kPrf2Wrap_SetThreadExecutionState( EXECUTION_STATE esFlags )
|
|---|
| 1281 | {
|
|---|
| 1282 | static FN_SetThreadExecutionState *pfn = 0;
|
|---|
| 1283 | if (!pfn)
|
|---|
| 1284 | kPrf2WrapResolve((void **)&pfn, "SetThreadExecutionState", &g_Kernel32);
|
|---|
| 1285 | return pfn( esFlags );
|
|---|
| 1286 | }
|
|---|
| 1287 |
|
|---|
| 1288 | typedef DWORD WINAPI FN_GetLastError( VOID );
|
|---|
| 1289 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLastError( VOID )
|
|---|
| 1290 | {
|
|---|
| 1291 | static FN_GetLastError *pfn = 0;
|
|---|
| 1292 | if (!pfn)
|
|---|
| 1293 | kPrf2WrapResolve((void **)&pfn, "GetLastError", &g_Kernel32);
|
|---|
| 1294 | return pfn ();
|
|---|
| 1295 | }
|
|---|
| 1296 |
|
|---|
| 1297 | typedef VOID WINAPI FN_SetLastError( DWORD dwErrCode );
|
|---|
| 1298 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetLastError( DWORD dwErrCode )
|
|---|
| 1299 | {
|
|---|
| 1300 | static FN_SetLastError *pfn = 0;
|
|---|
| 1301 | if (!pfn)
|
|---|
| 1302 | kPrf2WrapResolve((void **)&pfn, "SetLastError", &g_Kernel32);
|
|---|
| 1303 | pfn( dwErrCode );
|
|---|
| 1304 | }
|
|---|
| 1305 |
|
|---|
| 1306 | typedef VOID WINAPI FN_RestoreLastError( DWORD dwErrCode );
|
|---|
| 1307 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_RestoreLastError( DWORD dwErrCode )
|
|---|
| 1308 | {
|
|---|
| 1309 | static FN_RestoreLastError *pfn = 0;
|
|---|
| 1310 | if (!pfn)
|
|---|
| 1311 | kPrf2WrapResolve((void **)&pfn, "RestoreLastError", &g_Kernel32);
|
|---|
| 1312 | pfn( dwErrCode );
|
|---|
| 1313 | }
|
|---|
| 1314 |
|
|---|
| 1315 | typedef BOOL WINAPI FN_GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait );
|
|---|
| 1316 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait )
|
|---|
| 1317 | {
|
|---|
| 1318 | static FN_GetOverlappedResult *pfn = 0;
|
|---|
| 1319 | if (!pfn)
|
|---|
| 1320 | kPrf2WrapResolve((void **)&pfn, "GetOverlappedResult", &g_Kernel32);
|
|---|
| 1321 | return pfn( hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait );
|
|---|
| 1322 | }
|
|---|
| 1323 |
|
|---|
| 1324 | typedef HANDLE WINAPI FN_CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads );
|
|---|
| 1325 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads )
|
|---|
| 1326 | {
|
|---|
| 1327 | static FN_CreateIoCompletionPort *pfn = 0;
|
|---|
| 1328 | if (!pfn)
|
|---|
| 1329 | kPrf2WrapResolve((void **)&pfn, "CreateIoCompletionPort", &g_Kernel32);
|
|---|
| 1330 | return pfn( FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads );
|
|---|
| 1331 | }
|
|---|
| 1332 |
|
|---|
| 1333 | typedef BOOL WINAPI FN_GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, PULONG_PTR lpCompletionKey, LPOVERLAPPED * lpOverlapped, DWORD dwMilliseconds );
|
|---|
| 1334 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, PULONG_PTR lpCompletionKey, LPOVERLAPPED * lpOverlapped, DWORD dwMilliseconds )
|
|---|
| 1335 | {
|
|---|
| 1336 | static FN_GetQueuedCompletionStatus *pfn = 0;
|
|---|
| 1337 | if (!pfn)
|
|---|
| 1338 | kPrf2WrapResolve((void **)&pfn, "GetQueuedCompletionStatus", &g_Kernel32);
|
|---|
| 1339 | return pfn( CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds );
|
|---|
| 1340 | }
|
|---|
| 1341 |
|
|---|
| 1342 | typedef BOOL WINAPI FN_PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped );
|
|---|
| 1343 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped )
|
|---|
| 1344 | {
|
|---|
| 1345 | static FN_PostQueuedCompletionStatus *pfn = 0;
|
|---|
| 1346 | if (!pfn)
|
|---|
| 1347 | kPrf2WrapResolve((void **)&pfn, "PostQueuedCompletionStatus", &g_Kernel32);
|
|---|
| 1348 | return pfn( CompletionPort, dwNumberOfBytesTransferred, dwCompletionKey, lpOverlapped );
|
|---|
| 1349 | }
|
|---|
| 1350 |
|
|---|
| 1351 | typedef UINT WINAPI FN_SetErrorMode( UINT uMode );
|
|---|
| 1352 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_SetErrorMode( UINT uMode )
|
|---|
| 1353 | {
|
|---|
| 1354 | static FN_SetErrorMode *pfn = 0;
|
|---|
| 1355 | if (!pfn)
|
|---|
| 1356 | kPrf2WrapResolve((void **)&pfn, "SetErrorMode", &g_Kernel32);
|
|---|
| 1357 | return pfn( uMode );
|
|---|
| 1358 | }
|
|---|
| 1359 |
|
|---|
| 1360 | typedef BOOL WINAPI FN_ReadProcessMemory( HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead );
|
|---|
| 1361 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadProcessMemory( HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead )
|
|---|
| 1362 | {
|
|---|
| 1363 | static FN_ReadProcessMemory *pfn = 0;
|
|---|
| 1364 | if (!pfn)
|
|---|
| 1365 | kPrf2WrapResolve((void **)&pfn, "ReadProcessMemory", &g_Kernel32);
|
|---|
| 1366 | return pfn( hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead );
|
|---|
| 1367 | }
|
|---|
| 1368 |
|
|---|
| 1369 | typedef BOOL WINAPI FN_WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten );
|
|---|
| 1370 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten )
|
|---|
| 1371 | {
|
|---|
| 1372 | static FN_WriteProcessMemory *pfn = 0;
|
|---|
| 1373 | if (!pfn)
|
|---|
| 1374 | kPrf2WrapResolve((void **)&pfn, "WriteProcessMemory", &g_Kernel32);
|
|---|
| 1375 | return pfn( hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten );
|
|---|
| 1376 | }
|
|---|
| 1377 |
|
|---|
| 1378 | typedef BOOL WINAPI FN_GetThreadContext( HANDLE hThread, LPCONTEXT lpContext );
|
|---|
| 1379 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadContext( HANDLE hThread, LPCONTEXT lpContext )
|
|---|
| 1380 | {
|
|---|
| 1381 | static FN_GetThreadContext *pfn = 0;
|
|---|
| 1382 | if (!pfn)
|
|---|
| 1383 | kPrf2WrapResolve((void **)&pfn, "GetThreadContext", &g_Kernel32);
|
|---|
| 1384 | return pfn( hThread, lpContext );
|
|---|
| 1385 | }
|
|---|
| 1386 |
|
|---|
| 1387 | typedef BOOL WINAPI FN_SetThreadContext( HANDLE hThread, CONST CONTEXT * lpContext );
|
|---|
| 1388 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadContext( HANDLE hThread, CONST CONTEXT * lpContext )
|
|---|
| 1389 | {
|
|---|
| 1390 | static FN_SetThreadContext *pfn = 0;
|
|---|
| 1391 | if (!pfn)
|
|---|
| 1392 | kPrf2WrapResolve((void **)&pfn, "SetThreadContext", &g_Kernel32);
|
|---|
| 1393 | return pfn( hThread, lpContext );
|
|---|
| 1394 | }
|
|---|
| 1395 |
|
|---|
| 1396 | typedef DWORD WINAPI FN_SuspendThread( HANDLE hThread );
|
|---|
| 1397 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SuspendThread( HANDLE hThread )
|
|---|
| 1398 | {
|
|---|
| 1399 | static FN_SuspendThread *pfn = 0;
|
|---|
| 1400 | if (!pfn)
|
|---|
| 1401 | kPrf2WrapResolve((void **)&pfn, "SuspendThread", &g_Kernel32);
|
|---|
| 1402 | return pfn( hThread );
|
|---|
| 1403 | }
|
|---|
| 1404 |
|
|---|
| 1405 | typedef DWORD WINAPI FN_ResumeThread( HANDLE hThread );
|
|---|
| 1406 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ResumeThread( HANDLE hThread )
|
|---|
| 1407 | {
|
|---|
| 1408 | static FN_ResumeThread *pfn = 0;
|
|---|
| 1409 | if (!pfn)
|
|---|
| 1410 | kPrf2WrapResolve((void **)&pfn, "ResumeThread", &g_Kernel32);
|
|---|
| 1411 | return pfn( hThread );
|
|---|
| 1412 | }
|
|---|
| 1413 |
|
|---|
| 1414 | typedef DWORD WINAPI FN_QueueUserAPC( PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData );
|
|---|
| 1415 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueueUserAPC( PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData )
|
|---|
| 1416 | {
|
|---|
| 1417 | static FN_QueueUserAPC *pfn = 0;
|
|---|
| 1418 | if (!pfn)
|
|---|
| 1419 | kPrf2WrapResolve((void **)&pfn, "QueueUserAPC", &g_Kernel32);
|
|---|
| 1420 | return pfn( pfnAPC, hThread, dwData );
|
|---|
| 1421 | }
|
|---|
| 1422 |
|
|---|
| 1423 | typedef BOOL WINAPI FN_IsDebuggerPresent( VOID );
|
|---|
| 1424 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDebuggerPresent( VOID )
|
|---|
| 1425 | {
|
|---|
| 1426 | static FN_IsDebuggerPresent *pfn = 0;
|
|---|
| 1427 | if (!pfn)
|
|---|
| 1428 | kPrf2WrapResolve((void **)&pfn, "IsDebuggerPresent", &g_Kernel32);
|
|---|
| 1429 | return pfn ();
|
|---|
| 1430 | }
|
|---|
| 1431 |
|
|---|
| 1432 | typedef BOOL WINAPI FN_CheckRemoteDebuggerPresent( HANDLE hProcess, PBOOL pbDebuggerPresent );
|
|---|
| 1433 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckRemoteDebuggerPresent( HANDLE hProcess, PBOOL pbDebuggerPresent )
|
|---|
| 1434 | {
|
|---|
| 1435 | static FN_CheckRemoteDebuggerPresent *pfn = 0;
|
|---|
| 1436 | if (!pfn)
|
|---|
| 1437 | kPrf2WrapResolve((void **)&pfn, "CheckRemoteDebuggerPresent", &g_Kernel32);
|
|---|
| 1438 | return pfn( hProcess, pbDebuggerPresent );
|
|---|
| 1439 | }
|
|---|
| 1440 |
|
|---|
| 1441 | typedef VOID WINAPI FN_DebugBreak( VOID );
|
|---|
| 1442 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_DebugBreak( VOID )
|
|---|
| 1443 | {
|
|---|
| 1444 | static FN_DebugBreak *pfn = 0;
|
|---|
| 1445 | if (!pfn)
|
|---|
| 1446 | kPrf2WrapResolve((void **)&pfn, "DebugBreak", &g_Kernel32);
|
|---|
| 1447 | pfn ();
|
|---|
| 1448 | }
|
|---|
| 1449 |
|
|---|
| 1450 | typedef BOOL WINAPI FN_WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds );
|
|---|
| 1451 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds )
|
|---|
| 1452 | {
|
|---|
| 1453 | static FN_WaitForDebugEvent *pfn = 0;
|
|---|
| 1454 | if (!pfn)
|
|---|
| 1455 | kPrf2WrapResolve((void **)&pfn, "WaitForDebugEvent", &g_Kernel32);
|
|---|
| 1456 | return pfn( lpDebugEvent, dwMilliseconds );
|
|---|
| 1457 | }
|
|---|
| 1458 |
|
|---|
| 1459 | typedef BOOL WINAPI FN_ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus );
|
|---|
| 1460 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus )
|
|---|
| 1461 | {
|
|---|
| 1462 | static FN_ContinueDebugEvent *pfn = 0;
|
|---|
| 1463 | if (!pfn)
|
|---|
| 1464 | kPrf2WrapResolve((void **)&pfn, "ContinueDebugEvent", &g_Kernel32);
|
|---|
| 1465 | return pfn( dwProcessId, dwThreadId, dwContinueStatus );
|
|---|
| 1466 | }
|
|---|
| 1467 |
|
|---|
| 1468 | typedef BOOL WINAPI FN_DebugActiveProcess( DWORD dwProcessId );
|
|---|
| 1469 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugActiveProcess( DWORD dwProcessId )
|
|---|
| 1470 | {
|
|---|
| 1471 | static FN_DebugActiveProcess *pfn = 0;
|
|---|
| 1472 | if (!pfn)
|
|---|
| 1473 | kPrf2WrapResolve((void **)&pfn, "DebugActiveProcess", &g_Kernel32);
|
|---|
| 1474 | return pfn( dwProcessId );
|
|---|
| 1475 | }
|
|---|
| 1476 |
|
|---|
| 1477 | typedef BOOL WINAPI FN_DebugActiveProcessStop( DWORD dwProcessId );
|
|---|
| 1478 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugActiveProcessStop( DWORD dwProcessId )
|
|---|
| 1479 | {
|
|---|
| 1480 | static FN_DebugActiveProcessStop *pfn = 0;
|
|---|
| 1481 | if (!pfn)
|
|---|
| 1482 | kPrf2WrapResolve((void **)&pfn, "DebugActiveProcessStop", &g_Kernel32);
|
|---|
| 1483 | return pfn( dwProcessId );
|
|---|
| 1484 | }
|
|---|
| 1485 |
|
|---|
| 1486 | typedef BOOL WINAPI FN_DebugSetProcessKillOnExit( BOOL KillOnExit );
|
|---|
| 1487 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugSetProcessKillOnExit( BOOL KillOnExit )
|
|---|
| 1488 | {
|
|---|
| 1489 | static FN_DebugSetProcessKillOnExit *pfn = 0;
|
|---|
| 1490 | if (!pfn)
|
|---|
| 1491 | kPrf2WrapResolve((void **)&pfn, "DebugSetProcessKillOnExit", &g_Kernel32);
|
|---|
| 1492 | return pfn( KillOnExit );
|
|---|
| 1493 | }
|
|---|
| 1494 |
|
|---|
| 1495 | typedef BOOL WINAPI FN_DebugBreakProcess( HANDLE Process );
|
|---|
| 1496 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugBreakProcess( HANDLE Process )
|
|---|
| 1497 | {
|
|---|
| 1498 | static FN_DebugBreakProcess *pfn = 0;
|
|---|
| 1499 | if (!pfn)
|
|---|
| 1500 | kPrf2WrapResolve((void **)&pfn, "DebugBreakProcess", &g_Kernel32);
|
|---|
| 1501 | return pfn( Process );
|
|---|
| 1502 | }
|
|---|
| 1503 |
|
|---|
| 1504 | typedef VOID WINAPI FN_InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
|
|---|
| 1505 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
|
|---|
| 1506 | {
|
|---|
| 1507 | static FN_InitializeCriticalSection *pfn = 0;
|
|---|
| 1508 | if (!pfn)
|
|---|
| 1509 | kPrf2WrapResolve((void **)&pfn, "InitializeCriticalSection", &g_Kernel32);
|
|---|
| 1510 | pfn( lpCriticalSection );
|
|---|
| 1511 | }
|
|---|
| 1512 |
|
|---|
| 1513 | typedef VOID WINAPI FN_EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
|
|---|
| 1514 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
|
|---|
| 1515 | {
|
|---|
| 1516 | static FN_EnterCriticalSection *pfn = 0;
|
|---|
| 1517 | if (!pfn)
|
|---|
| 1518 | kPrf2WrapResolve((void **)&pfn, "EnterCriticalSection", &g_Kernel32);
|
|---|
| 1519 | pfn( lpCriticalSection );
|
|---|
| 1520 | }
|
|---|
| 1521 |
|
|---|
| 1522 | typedef VOID WINAPI FN_LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
|
|---|
| 1523 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
|
|---|
| 1524 | {
|
|---|
| 1525 | static FN_LeaveCriticalSection *pfn = 0;
|
|---|
| 1526 | if (!pfn)
|
|---|
| 1527 | kPrf2WrapResolve((void **)&pfn, "LeaveCriticalSection", &g_Kernel32);
|
|---|
| 1528 | pfn( lpCriticalSection );
|
|---|
| 1529 | }
|
|---|
| 1530 |
|
|---|
| 1531 | typedef BOOL WINAPI FN_InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount );
|
|---|
| 1532 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount )
|
|---|
| 1533 | {
|
|---|
| 1534 | static FN_InitializeCriticalSectionAndSpinCount *pfn = 0;
|
|---|
| 1535 | if (!pfn)
|
|---|
| 1536 | kPrf2WrapResolve((void **)&pfn, "InitializeCriticalSectionAndSpinCount", &g_Kernel32);
|
|---|
| 1537 | return pfn( lpCriticalSection, dwSpinCount );
|
|---|
| 1538 | }
|
|---|
| 1539 |
|
|---|
| 1540 | typedef DWORD WINAPI FN_SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount );
|
|---|
| 1541 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount )
|
|---|
| 1542 | {
|
|---|
| 1543 | static FN_SetCriticalSectionSpinCount *pfn = 0;
|
|---|
| 1544 | if (!pfn)
|
|---|
| 1545 | kPrf2WrapResolve((void **)&pfn, "SetCriticalSectionSpinCount", &g_Kernel32);
|
|---|
| 1546 | return pfn( lpCriticalSection, dwSpinCount );
|
|---|
| 1547 | }
|
|---|
| 1548 |
|
|---|
| 1549 | typedef BOOL WINAPI FN_TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
|
|---|
| 1550 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
|
|---|
| 1551 | {
|
|---|
| 1552 | static FN_TryEnterCriticalSection *pfn = 0;
|
|---|
| 1553 | if (!pfn)
|
|---|
| 1554 | kPrf2WrapResolve((void **)&pfn, "TryEnterCriticalSection", &g_Kernel32);
|
|---|
| 1555 | return pfn( lpCriticalSection );
|
|---|
| 1556 | }
|
|---|
| 1557 |
|
|---|
| 1558 | typedef VOID WINAPI FN_DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
|
|---|
| 1559 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
|
|---|
| 1560 | {
|
|---|
| 1561 | static FN_DeleteCriticalSection *pfn = 0;
|
|---|
| 1562 | if (!pfn)
|
|---|
| 1563 | kPrf2WrapResolve((void **)&pfn, "DeleteCriticalSection", &g_Kernel32);
|
|---|
| 1564 | pfn( lpCriticalSection );
|
|---|
| 1565 | }
|
|---|
| 1566 |
|
|---|
| 1567 | typedef BOOL WINAPI FN_SetEvent( HANDLE hEvent );
|
|---|
| 1568 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEvent( HANDLE hEvent )
|
|---|
| 1569 | {
|
|---|
| 1570 | static FN_SetEvent *pfn = 0;
|
|---|
| 1571 | if (!pfn)
|
|---|
| 1572 | kPrf2WrapResolve((void **)&pfn, "SetEvent", &g_Kernel32);
|
|---|
| 1573 | return pfn( hEvent );
|
|---|
| 1574 | }
|
|---|
| 1575 |
|
|---|
| 1576 | typedef BOOL WINAPI FN_ResetEvent( HANDLE hEvent );
|
|---|
| 1577 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ResetEvent( HANDLE hEvent )
|
|---|
| 1578 | {
|
|---|
| 1579 | static FN_ResetEvent *pfn = 0;
|
|---|
| 1580 | if (!pfn)
|
|---|
| 1581 | kPrf2WrapResolve((void **)&pfn, "ResetEvent", &g_Kernel32);
|
|---|
| 1582 | return pfn( hEvent );
|
|---|
| 1583 | }
|
|---|
| 1584 |
|
|---|
| 1585 | typedef BOOL WINAPI FN_PulseEvent( HANDLE hEvent );
|
|---|
| 1586 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PulseEvent( HANDLE hEvent )
|
|---|
| 1587 | {
|
|---|
| 1588 | static FN_PulseEvent *pfn = 0;
|
|---|
| 1589 | if (!pfn)
|
|---|
| 1590 | kPrf2WrapResolve((void **)&pfn, "PulseEvent", &g_Kernel32);
|
|---|
| 1591 | return pfn( hEvent );
|
|---|
| 1592 | }
|
|---|
| 1593 |
|
|---|
| 1594 | typedef BOOL WINAPI FN_ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount );
|
|---|
| 1595 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount )
|
|---|
| 1596 | {
|
|---|
| 1597 | static FN_ReleaseSemaphore *pfn = 0;
|
|---|
| 1598 | if (!pfn)
|
|---|
| 1599 | kPrf2WrapResolve((void **)&pfn, "ReleaseSemaphore", &g_Kernel32);
|
|---|
| 1600 | return pfn( hSemaphore, lReleaseCount, lpPreviousCount );
|
|---|
| 1601 | }
|
|---|
| 1602 |
|
|---|
| 1603 | typedef BOOL WINAPI FN_ReleaseMutex( HANDLE hMutex );
|
|---|
| 1604 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReleaseMutex( HANDLE hMutex )
|
|---|
| 1605 | {
|
|---|
| 1606 | static FN_ReleaseMutex *pfn = 0;
|
|---|
| 1607 | if (!pfn)
|
|---|
| 1608 | kPrf2WrapResolve((void **)&pfn, "ReleaseMutex", &g_Kernel32);
|
|---|
| 1609 | return pfn( hMutex );
|
|---|
| 1610 | }
|
|---|
| 1611 |
|
|---|
| 1612 | typedef DWORD WINAPI FN_WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds );
|
|---|
| 1613 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds )
|
|---|
| 1614 | {
|
|---|
| 1615 | static FN_WaitForSingleObject *pfn = 0;
|
|---|
| 1616 | if (!pfn)
|
|---|
| 1617 | kPrf2WrapResolve((void **)&pfn, "WaitForSingleObject", &g_Kernel32);
|
|---|
| 1618 | return pfn( hHandle, dwMilliseconds );
|
|---|
| 1619 | }
|
|---|
| 1620 |
|
|---|
| 1621 | typedef DWORD WINAPI FN_WaitForMultipleObjects( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds );
|
|---|
| 1622 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForMultipleObjects( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds )
|
|---|
| 1623 | {
|
|---|
| 1624 | static FN_WaitForMultipleObjects *pfn = 0;
|
|---|
| 1625 | if (!pfn)
|
|---|
| 1626 | kPrf2WrapResolve((void **)&pfn, "WaitForMultipleObjects", &g_Kernel32);
|
|---|
| 1627 | return pfn( nCount, lpHandles, bWaitAll, dwMilliseconds );
|
|---|
| 1628 | }
|
|---|
| 1629 |
|
|---|
| 1630 | typedef VOID WINAPI FN_Sleep( DWORD dwMilliseconds );
|
|---|
| 1631 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_Sleep( DWORD dwMilliseconds )
|
|---|
| 1632 | {
|
|---|
| 1633 | static FN_Sleep *pfn = 0;
|
|---|
| 1634 | if (!pfn)
|
|---|
| 1635 | kPrf2WrapResolve((void **)&pfn, "Sleep", &g_Kernel32);
|
|---|
| 1636 | pfn( dwMilliseconds );
|
|---|
| 1637 | }
|
|---|
| 1638 |
|
|---|
| 1639 | typedef HGLOBAL WINAPI FN_LoadResource( HMODULE hModule, HRSRC hResInfo );
|
|---|
| 1640 | __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_LoadResource( HMODULE hModule, HRSRC hResInfo )
|
|---|
| 1641 | {
|
|---|
| 1642 | static FN_LoadResource *pfn = 0;
|
|---|
| 1643 | if (!pfn)
|
|---|
| 1644 | kPrf2WrapResolve((void **)&pfn, "LoadResource", &g_Kernel32);
|
|---|
| 1645 | return pfn( hModule, hResInfo );
|
|---|
| 1646 | }
|
|---|
| 1647 |
|
|---|
| 1648 | typedef DWORD WINAPI FN_SizeofResource( HMODULE hModule, HRSRC hResInfo );
|
|---|
| 1649 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SizeofResource( HMODULE hModule, HRSRC hResInfo )
|
|---|
| 1650 | {
|
|---|
| 1651 | static FN_SizeofResource *pfn = 0;
|
|---|
| 1652 | if (!pfn)
|
|---|
| 1653 | kPrf2WrapResolve((void **)&pfn, "SizeofResource", &g_Kernel32);
|
|---|
| 1654 | return pfn( hModule, hResInfo );
|
|---|
| 1655 | }
|
|---|
| 1656 |
|
|---|
| 1657 | typedef ATOM WINAPI FN_GlobalDeleteAtom( ATOM nAtom );
|
|---|
| 1658 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalDeleteAtom( ATOM nAtom )
|
|---|
| 1659 | {
|
|---|
| 1660 | static FN_GlobalDeleteAtom *pfn = 0;
|
|---|
| 1661 | if (!pfn)
|
|---|
| 1662 | kPrf2WrapResolve((void **)&pfn, "GlobalDeleteAtom", &g_Kernel32);
|
|---|
| 1663 | return pfn( nAtom );
|
|---|
| 1664 | }
|
|---|
| 1665 |
|
|---|
| 1666 | typedef BOOL WINAPI FN_InitAtomTable( DWORD nSize );
|
|---|
| 1667 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitAtomTable( DWORD nSize )
|
|---|
| 1668 | {
|
|---|
| 1669 | static FN_InitAtomTable *pfn = 0;
|
|---|
| 1670 | if (!pfn)
|
|---|
| 1671 | kPrf2WrapResolve((void **)&pfn, "InitAtomTable", &g_Kernel32);
|
|---|
| 1672 | return pfn( nSize );
|
|---|
| 1673 | }
|
|---|
| 1674 |
|
|---|
| 1675 | typedef ATOM WINAPI FN_DeleteAtom( ATOM nAtom );
|
|---|
| 1676 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_DeleteAtom( ATOM nAtom )
|
|---|
| 1677 | {
|
|---|
| 1678 | static FN_DeleteAtom *pfn = 0;
|
|---|
| 1679 | if (!pfn)
|
|---|
| 1680 | kPrf2WrapResolve((void **)&pfn, "DeleteAtom", &g_Kernel32);
|
|---|
| 1681 | return pfn( nAtom );
|
|---|
| 1682 | }
|
|---|
| 1683 |
|
|---|
| 1684 | typedef UINT WINAPI FN_SetHandleCount( UINT uNumber );
|
|---|
| 1685 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_SetHandleCount( UINT uNumber )
|
|---|
| 1686 | {
|
|---|
| 1687 | static FN_SetHandleCount *pfn = 0;
|
|---|
| 1688 | if (!pfn)
|
|---|
| 1689 | kPrf2WrapResolve((void **)&pfn, "SetHandleCount", &g_Kernel32);
|
|---|
| 1690 | return pfn( uNumber );
|
|---|
| 1691 | }
|
|---|
| 1692 |
|
|---|
| 1693 | typedef DWORD WINAPI FN_GetLogicalDrives( VOID );
|
|---|
| 1694 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDrives( VOID )
|
|---|
| 1695 | {
|
|---|
| 1696 | static FN_GetLogicalDrives *pfn = 0;
|
|---|
| 1697 | if (!pfn)
|
|---|
| 1698 | kPrf2WrapResolve((void **)&pfn, "GetLogicalDrives", &g_Kernel32);
|
|---|
| 1699 | return pfn ();
|
|---|
| 1700 | }
|
|---|
| 1701 |
|
|---|
| 1702 | typedef BOOL WINAPI FN_LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh );
|
|---|
| 1703 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
|
|---|
| 1704 | {
|
|---|
| 1705 | static FN_LockFile *pfn = 0;
|
|---|
| 1706 | if (!pfn)
|
|---|
| 1707 | kPrf2WrapResolve((void **)&pfn, "LockFile", &g_Kernel32);
|
|---|
| 1708 | return pfn( hFile, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh );
|
|---|
| 1709 | }
|
|---|
| 1710 |
|
|---|
| 1711 | typedef BOOL WINAPI FN_UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh );
|
|---|
| 1712 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
|
|---|
| 1713 | {
|
|---|
| 1714 | static FN_UnlockFile *pfn = 0;
|
|---|
| 1715 | if (!pfn)
|
|---|
| 1716 | kPrf2WrapResolve((void **)&pfn, "UnlockFile", &g_Kernel32);
|
|---|
| 1717 | return pfn( hFile, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh );
|
|---|
| 1718 | }
|
|---|
| 1719 |
|
|---|
| 1720 | typedef BOOL WINAPI FN_LockFileEx( HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped );
|
|---|
| 1721 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LockFileEx( HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped )
|
|---|
| 1722 | {
|
|---|
| 1723 | static FN_LockFileEx *pfn = 0;
|
|---|
| 1724 | if (!pfn)
|
|---|
| 1725 | kPrf2WrapResolve((void **)&pfn, "LockFileEx", &g_Kernel32);
|
|---|
| 1726 | return pfn( hFile, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped );
|
|---|
| 1727 | }
|
|---|
| 1728 |
|
|---|
| 1729 | typedef BOOL WINAPI FN_UnlockFileEx( HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped );
|
|---|
| 1730 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnlockFileEx( HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped )
|
|---|
| 1731 | {
|
|---|
| 1732 | static FN_UnlockFileEx *pfn = 0;
|
|---|
| 1733 | if (!pfn)
|
|---|
| 1734 | kPrf2WrapResolve((void **)&pfn, "UnlockFileEx", &g_Kernel32);
|
|---|
| 1735 | return pfn( hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, lpOverlapped );
|
|---|
| 1736 | }
|
|---|
| 1737 |
|
|---|
| 1738 | typedef BOOL WINAPI FN_GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation );
|
|---|
| 1739 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation )
|
|---|
| 1740 | {
|
|---|
| 1741 | static FN_GetFileInformationByHandle *pfn = 0;
|
|---|
| 1742 | if (!pfn)
|
|---|
| 1743 | kPrf2WrapResolve((void **)&pfn, "GetFileInformationByHandle", &g_Kernel32);
|
|---|
| 1744 | return pfn( hFile, lpFileInformation );
|
|---|
| 1745 | }
|
|---|
| 1746 |
|
|---|
| 1747 | typedef DWORD WINAPI FN_GetFileType( HANDLE hFile );
|
|---|
| 1748 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileType( HANDLE hFile )
|
|---|
| 1749 | {
|
|---|
| 1750 | static FN_GetFileType *pfn = 0;
|
|---|
| 1751 | if (!pfn)
|
|---|
| 1752 | kPrf2WrapResolve((void **)&pfn, "GetFileType", &g_Kernel32);
|
|---|
| 1753 | return pfn( hFile );
|
|---|
| 1754 | }
|
|---|
| 1755 |
|
|---|
| 1756 | typedef DWORD WINAPI FN_GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh );
|
|---|
| 1757 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh )
|
|---|
| 1758 | {
|
|---|
| 1759 | static FN_GetFileSize *pfn = 0;
|
|---|
| 1760 | if (!pfn)
|
|---|
| 1761 | kPrf2WrapResolve((void **)&pfn, "GetFileSize", &g_Kernel32);
|
|---|
| 1762 | return pfn( hFile, lpFileSizeHigh );
|
|---|
| 1763 | }
|
|---|
| 1764 |
|
|---|
| 1765 | typedef BOOL WINAPI FN_GetFileSizeEx( HANDLE hFile, PLARGE_INTEGER lpFileSize );
|
|---|
| 1766 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSizeEx( HANDLE hFile, PLARGE_INTEGER lpFileSize )
|
|---|
| 1767 | {
|
|---|
| 1768 | static FN_GetFileSizeEx *pfn = 0;
|
|---|
| 1769 | if (!pfn)
|
|---|
| 1770 | kPrf2WrapResolve((void **)&pfn, "GetFileSizeEx", &g_Kernel32);
|
|---|
| 1771 | return pfn( hFile, lpFileSize );
|
|---|
| 1772 | }
|
|---|
| 1773 |
|
|---|
| 1774 | typedef HANDLE WINAPI FN_GetStdHandle( DWORD nStdHandle );
|
|---|
| 1775 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetStdHandle( DWORD nStdHandle )
|
|---|
| 1776 | {
|
|---|
| 1777 | static FN_GetStdHandle *pfn = 0;
|
|---|
| 1778 | if (!pfn)
|
|---|
| 1779 | kPrf2WrapResolve((void **)&pfn, "GetStdHandle", &g_Kernel32);
|
|---|
| 1780 | return pfn( nStdHandle );
|
|---|
| 1781 | }
|
|---|
| 1782 |
|
|---|
| 1783 | typedef BOOL WINAPI FN_SetStdHandle( DWORD nStdHandle, HANDLE hHandle );
|
|---|
| 1784 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetStdHandle( DWORD nStdHandle, HANDLE hHandle )
|
|---|
| 1785 | {
|
|---|
| 1786 | static FN_SetStdHandle *pfn = 0;
|
|---|
| 1787 | if (!pfn)
|
|---|
| 1788 | kPrf2WrapResolve((void **)&pfn, "SetStdHandle", &g_Kernel32);
|
|---|
| 1789 | return pfn( nStdHandle, hHandle );
|
|---|
| 1790 | }
|
|---|
| 1791 |
|
|---|
| 1792 | typedef BOOL WINAPI FN_WriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped );
|
|---|
| 1793 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
|
|---|
| 1794 | {
|
|---|
| 1795 | static FN_WriteFile *pfn = 0;
|
|---|
| 1796 | if (!pfn)
|
|---|
| 1797 | kPrf2WrapResolve((void **)&pfn, "WriteFile", &g_Kernel32);
|
|---|
| 1798 | return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped );
|
|---|
| 1799 | }
|
|---|
| 1800 |
|
|---|
| 1801 | typedef BOOL WINAPI FN_ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped );
|
|---|
| 1802 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped )
|
|---|
| 1803 | {
|
|---|
| 1804 | static FN_ReadFile *pfn = 0;
|
|---|
| 1805 | if (!pfn)
|
|---|
| 1806 | kPrf2WrapResolve((void **)&pfn, "ReadFile", &g_Kernel32);
|
|---|
| 1807 | return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped );
|
|---|
| 1808 | }
|
|---|
| 1809 |
|
|---|
| 1810 | typedef BOOL WINAPI FN_FlushFileBuffers( HANDLE hFile );
|
|---|
| 1811 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushFileBuffers( HANDLE hFile )
|
|---|
| 1812 | {
|
|---|
| 1813 | static FN_FlushFileBuffers *pfn = 0;
|
|---|
| 1814 | if (!pfn)
|
|---|
| 1815 | kPrf2WrapResolve((void **)&pfn, "FlushFileBuffers", &g_Kernel32);
|
|---|
| 1816 | return pfn( hFile );
|
|---|
| 1817 | }
|
|---|
| 1818 |
|
|---|
| 1819 | typedef BOOL WINAPI FN_DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped );
|
|---|
| 1820 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped )
|
|---|
| 1821 | {
|
|---|
| 1822 | static FN_DeviceIoControl *pfn = 0;
|
|---|
| 1823 | if (!pfn)
|
|---|
| 1824 | kPrf2WrapResolve((void **)&pfn, "DeviceIoControl", &g_Kernel32);
|
|---|
| 1825 | return pfn( hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped );
|
|---|
| 1826 | }
|
|---|
| 1827 |
|
|---|
| 1828 | typedef BOOL WINAPI FN_RequestDeviceWakeup( HANDLE hDevice );
|
|---|
| 1829 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RequestDeviceWakeup( HANDLE hDevice )
|
|---|
| 1830 | {
|
|---|
| 1831 | static FN_RequestDeviceWakeup *pfn = 0;
|
|---|
| 1832 | if (!pfn)
|
|---|
| 1833 | kPrf2WrapResolve((void **)&pfn, "RequestDeviceWakeup", &g_Kernel32);
|
|---|
| 1834 | return pfn( hDevice );
|
|---|
| 1835 | }
|
|---|
| 1836 |
|
|---|
| 1837 | typedef BOOL WINAPI FN_CancelDeviceWakeupRequest( HANDLE hDevice );
|
|---|
| 1838 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelDeviceWakeupRequest( HANDLE hDevice )
|
|---|
| 1839 | {
|
|---|
| 1840 | static FN_CancelDeviceWakeupRequest *pfn = 0;
|
|---|
| 1841 | if (!pfn)
|
|---|
| 1842 | kPrf2WrapResolve((void **)&pfn, "CancelDeviceWakeupRequest", &g_Kernel32);
|
|---|
| 1843 | return pfn( hDevice );
|
|---|
| 1844 | }
|
|---|
| 1845 |
|
|---|
| 1846 | typedef BOOL WINAPI FN_GetDevicePowerState( HANDLE hDevice, BOOL * pfOn );
|
|---|
| 1847 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDevicePowerState( HANDLE hDevice, BOOL * pfOn )
|
|---|
| 1848 | {
|
|---|
| 1849 | static FN_GetDevicePowerState *pfn = 0;
|
|---|
| 1850 | if (!pfn)
|
|---|
| 1851 | kPrf2WrapResolve((void **)&pfn, "GetDevicePowerState", &g_Kernel32);
|
|---|
| 1852 | return pfn( hDevice, pfOn );
|
|---|
| 1853 | }
|
|---|
| 1854 |
|
|---|
| 1855 | typedef BOOL WINAPI FN_SetMessageWaitingIndicator( HANDLE hMsgIndicator, ULONG ulMsgCount );
|
|---|
| 1856 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetMessageWaitingIndicator( HANDLE hMsgIndicator, ULONG ulMsgCount )
|
|---|
| 1857 | {
|
|---|
| 1858 | static FN_SetMessageWaitingIndicator *pfn = 0;
|
|---|
| 1859 | if (!pfn)
|
|---|
| 1860 | kPrf2WrapResolve((void **)&pfn, "SetMessageWaitingIndicator", &g_Kernel32);
|
|---|
| 1861 | return pfn( hMsgIndicator, ulMsgCount );
|
|---|
| 1862 | }
|
|---|
| 1863 |
|
|---|
| 1864 | typedef BOOL WINAPI FN_SetEndOfFile( HANDLE hFile );
|
|---|
| 1865 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEndOfFile( HANDLE hFile )
|
|---|
| 1866 | {
|
|---|
| 1867 | static FN_SetEndOfFile *pfn = 0;
|
|---|
| 1868 | if (!pfn)
|
|---|
| 1869 | kPrf2WrapResolve((void **)&pfn, "SetEndOfFile", &g_Kernel32);
|
|---|
| 1870 | return pfn( hFile );
|
|---|
| 1871 | }
|
|---|
| 1872 |
|
|---|
| 1873 | typedef DWORD WINAPI FN_SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod );
|
|---|
| 1874 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod )
|
|---|
| 1875 | {
|
|---|
| 1876 | static FN_SetFilePointer *pfn = 0;
|
|---|
| 1877 | if (!pfn)
|
|---|
| 1878 | kPrf2WrapResolve((void **)&pfn, "SetFilePointer", &g_Kernel32);
|
|---|
| 1879 | return pfn( hFile, lDistanceToMove, lpDistanceToMoveHigh, dwMoveMethod );
|
|---|
| 1880 | }
|
|---|
| 1881 |
|
|---|
| 1882 | typedef BOOL WINAPI FN_SetFilePointerEx( HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod );
|
|---|
| 1883 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFilePointerEx( HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod )
|
|---|
| 1884 | {
|
|---|
| 1885 | static FN_SetFilePointerEx *pfn = 0;
|
|---|
| 1886 | if (!pfn)
|
|---|
| 1887 | kPrf2WrapResolve((void **)&pfn, "SetFilePointerEx", &g_Kernel32);
|
|---|
| 1888 | return pfn( hFile, liDistanceToMove, lpNewFilePointer, dwMoveMethod );
|
|---|
| 1889 | }
|
|---|
| 1890 |
|
|---|
| 1891 | typedef BOOL WINAPI FN_FindClose( HANDLE hFindFile );
|
|---|
| 1892 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindClose( HANDLE hFindFile )
|
|---|
| 1893 | {
|
|---|
| 1894 | static FN_FindClose *pfn = 0;
|
|---|
| 1895 | if (!pfn)
|
|---|
| 1896 | kPrf2WrapResolve((void **)&pfn, "FindClose", &g_Kernel32);
|
|---|
| 1897 | return pfn( hFindFile );
|
|---|
| 1898 | }
|
|---|
| 1899 |
|
|---|
| 1900 | typedef BOOL WINAPI FN_GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime );
|
|---|
| 1901 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime )
|
|---|
| 1902 | {
|
|---|
| 1903 | static FN_GetFileTime *pfn = 0;
|
|---|
| 1904 | if (!pfn)
|
|---|
| 1905 | kPrf2WrapResolve((void **)&pfn, "GetFileTime", &g_Kernel32);
|
|---|
| 1906 | return pfn( hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime );
|
|---|
| 1907 | }
|
|---|
| 1908 |
|
|---|
| 1909 | typedef BOOL WINAPI FN_SetFileTime( HANDLE hFile, CONST FILETIME * lpCreationTime, CONST FILETIME * lpLastAccessTime, CONST FILETIME * lpLastWriteTime );
|
|---|
| 1910 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileTime( HANDLE hFile, CONST FILETIME * lpCreationTime, CONST FILETIME * lpLastAccessTime, CONST FILETIME * lpLastWriteTime )
|
|---|
| 1911 | {
|
|---|
| 1912 | static FN_SetFileTime *pfn = 0;
|
|---|
| 1913 | if (!pfn)
|
|---|
| 1914 | kPrf2WrapResolve((void **)&pfn, "SetFileTime", &g_Kernel32);
|
|---|
| 1915 | return pfn( hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime );
|
|---|
| 1916 | }
|
|---|
| 1917 |
|
|---|
| 1918 | typedef BOOL WINAPI FN_SetFileValidData( HANDLE hFile, LONGLONG ValidDataLength );
|
|---|
| 1919 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileValidData( HANDLE hFile, LONGLONG ValidDataLength )
|
|---|
| 1920 | {
|
|---|
| 1921 | static FN_SetFileValidData *pfn = 0;
|
|---|
| 1922 | if (!pfn)
|
|---|
| 1923 | kPrf2WrapResolve((void **)&pfn, "SetFileValidData", &g_Kernel32);
|
|---|
| 1924 | return pfn( hFile, ValidDataLength );
|
|---|
| 1925 | }
|
|---|
| 1926 |
|
|---|
| 1927 | typedef BOOL WINAPI FN_SetFileShortNameA( HANDLE hFile, LPCSTR lpShortName );
|
|---|
| 1928 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileShortNameA( HANDLE hFile, LPCSTR lpShortName )
|
|---|
| 1929 | {
|
|---|
| 1930 | static FN_SetFileShortNameA *pfn = 0;
|
|---|
| 1931 | if (!pfn)
|
|---|
| 1932 | kPrf2WrapResolve((void **)&pfn, "SetFileShortNameA", &g_Kernel32);
|
|---|
| 1933 | return pfn( hFile, lpShortName );
|
|---|
| 1934 | }
|
|---|
| 1935 |
|
|---|
| 1936 | typedef BOOL WINAPI FN_SetFileShortNameW( HANDLE hFile, LPCWSTR lpShortName );
|
|---|
| 1937 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileShortNameW( HANDLE hFile, LPCWSTR lpShortName )
|
|---|
| 1938 | {
|
|---|
| 1939 | static FN_SetFileShortNameW *pfn = 0;
|
|---|
| 1940 | if (!pfn)
|
|---|
| 1941 | kPrf2WrapResolve((void **)&pfn, "SetFileShortNameW", &g_Kernel32);
|
|---|
| 1942 | return pfn( hFile, lpShortName );
|
|---|
| 1943 | }
|
|---|
| 1944 |
|
|---|
| 1945 | typedef BOOL WINAPI FN_CloseHandle( HANDLE hObject );
|
|---|
| 1946 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CloseHandle( HANDLE hObject )
|
|---|
| 1947 | {
|
|---|
| 1948 | static FN_CloseHandle *pfn = 0;
|
|---|
| 1949 | if (!pfn)
|
|---|
| 1950 | kPrf2WrapResolve((void **)&pfn, "CloseHandle", &g_Kernel32);
|
|---|
| 1951 | return pfn( hObject );
|
|---|
| 1952 | }
|
|---|
| 1953 |
|
|---|
| 1954 | typedef BOOL WINAPI FN_DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions );
|
|---|
| 1955 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions )
|
|---|
| 1956 | {
|
|---|
| 1957 | static FN_DuplicateHandle *pfn = 0;
|
|---|
| 1958 | if (!pfn)
|
|---|
| 1959 | kPrf2WrapResolve((void **)&pfn, "DuplicateHandle", &g_Kernel32);
|
|---|
| 1960 | return pfn( hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions );
|
|---|
| 1961 | }
|
|---|
| 1962 |
|
|---|
| 1963 | typedef BOOL WINAPI FN_GetHandleInformation( HANDLE hObject, LPDWORD lpdwFlags );
|
|---|
| 1964 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetHandleInformation( HANDLE hObject, LPDWORD lpdwFlags )
|
|---|
| 1965 | {
|
|---|
| 1966 | static FN_GetHandleInformation *pfn = 0;
|
|---|
| 1967 | if (!pfn)
|
|---|
| 1968 | kPrf2WrapResolve((void **)&pfn, "GetHandleInformation", &g_Kernel32);
|
|---|
| 1969 | return pfn( hObject, lpdwFlags );
|
|---|
| 1970 | }
|
|---|
| 1971 |
|
|---|
| 1972 | typedef BOOL WINAPI FN_SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags );
|
|---|
| 1973 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags )
|
|---|
| 1974 | {
|
|---|
| 1975 | static FN_SetHandleInformation *pfn = 0;
|
|---|
| 1976 | if (!pfn)
|
|---|
| 1977 | kPrf2WrapResolve((void **)&pfn, "SetHandleInformation", &g_Kernel32);
|
|---|
| 1978 | return pfn( hObject, dwMask, dwFlags );
|
|---|
| 1979 | }
|
|---|
| 1980 |
|
|---|
| 1981 | typedef DWORD WINAPI FN_LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock );
|
|---|
| 1982 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock )
|
|---|
| 1983 | {
|
|---|
| 1984 | static FN_LoadModule *pfn = 0;
|
|---|
| 1985 | if (!pfn)
|
|---|
| 1986 | kPrf2WrapResolve((void **)&pfn, "LoadModule", &g_Kernel32);
|
|---|
| 1987 | return pfn( lpModuleName, lpParameterBlock );
|
|---|
| 1988 | }
|
|---|
| 1989 |
|
|---|
| 1990 | typedef UINT WINAPI FN_WinExec( LPCSTR lpCmdLine, UINT uCmdShow );
|
|---|
| 1991 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_WinExec( LPCSTR lpCmdLine, UINT uCmdShow )
|
|---|
| 1992 | {
|
|---|
| 1993 | static FN_WinExec *pfn = 0;
|
|---|
| 1994 | if (!pfn)
|
|---|
| 1995 | kPrf2WrapResolve((void **)&pfn, "WinExec", &g_Kernel32);
|
|---|
| 1996 | return pfn( lpCmdLine, uCmdShow );
|
|---|
| 1997 | }
|
|---|
| 1998 |
|
|---|
| 1999 | typedef BOOL WINAPI FN_ClearCommBreak( HANDLE hFile );
|
|---|
| 2000 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearCommBreak( HANDLE hFile )
|
|---|
| 2001 | {
|
|---|
| 2002 | static FN_ClearCommBreak *pfn = 0;
|
|---|
| 2003 | if (!pfn)
|
|---|
| 2004 | kPrf2WrapResolve((void **)&pfn, "ClearCommBreak", &g_Kernel32);
|
|---|
| 2005 | return pfn( hFile );
|
|---|
| 2006 | }
|
|---|
| 2007 |
|
|---|
| 2008 | typedef BOOL WINAPI FN_ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat );
|
|---|
| 2009 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat )
|
|---|
| 2010 | {
|
|---|
| 2011 | static FN_ClearCommError *pfn = 0;
|
|---|
| 2012 | if (!pfn)
|
|---|
| 2013 | kPrf2WrapResolve((void **)&pfn, "ClearCommError", &g_Kernel32);
|
|---|
| 2014 | return pfn( hFile, lpErrors, lpStat );
|
|---|
| 2015 | }
|
|---|
| 2016 |
|
|---|
| 2017 | typedef BOOL WINAPI FN_SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue );
|
|---|
| 2018 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue )
|
|---|
| 2019 | {
|
|---|
| 2020 | static FN_SetupComm *pfn = 0;
|
|---|
| 2021 | if (!pfn)
|
|---|
| 2022 | kPrf2WrapResolve((void **)&pfn, "SetupComm", &g_Kernel32);
|
|---|
| 2023 | return pfn( hFile, dwInQueue, dwOutQueue );
|
|---|
| 2024 | }
|
|---|
| 2025 |
|
|---|
| 2026 | typedef BOOL WINAPI FN_EscapeCommFunction( HANDLE hFile, DWORD dwFunc );
|
|---|
| 2027 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EscapeCommFunction( HANDLE hFile, DWORD dwFunc )
|
|---|
| 2028 | {
|
|---|
| 2029 | static FN_EscapeCommFunction *pfn = 0;
|
|---|
| 2030 | if (!pfn)
|
|---|
| 2031 | kPrf2WrapResolve((void **)&pfn, "EscapeCommFunction", &g_Kernel32);
|
|---|
| 2032 | return pfn( hFile, dwFunc );
|
|---|
| 2033 | }
|
|---|
| 2034 |
|
|---|
| 2035 | typedef BOOL WINAPI FN_GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
|
|---|
| 2036 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
|
|---|
| 2037 | {
|
|---|
| 2038 | static FN_GetCommConfig *pfn = 0;
|
|---|
| 2039 | if (!pfn)
|
|---|
| 2040 | kPrf2WrapResolve((void **)&pfn, "GetCommConfig", &g_Kernel32);
|
|---|
| 2041 | return pfn( hCommDev, lpCC, lpdwSize );
|
|---|
| 2042 | }
|
|---|
| 2043 |
|
|---|
| 2044 | typedef BOOL WINAPI FN_GetCommMask( HANDLE hFile, LPDWORD lpEvtMask );
|
|---|
| 2045 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommMask( HANDLE hFile, LPDWORD lpEvtMask )
|
|---|
| 2046 | {
|
|---|
| 2047 | static FN_GetCommMask *pfn = 0;
|
|---|
| 2048 | if (!pfn)
|
|---|
| 2049 | kPrf2WrapResolve((void **)&pfn, "GetCommMask", &g_Kernel32);
|
|---|
| 2050 | return pfn( hFile, lpEvtMask );
|
|---|
| 2051 | }
|
|---|
| 2052 |
|
|---|
| 2053 | typedef BOOL WINAPI FN_GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp );
|
|---|
| 2054 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp )
|
|---|
| 2055 | {
|
|---|
| 2056 | static FN_GetCommProperties *pfn = 0;
|
|---|
| 2057 | if (!pfn)
|
|---|
| 2058 | kPrf2WrapResolve((void **)&pfn, "GetCommProperties", &g_Kernel32);
|
|---|
| 2059 | return pfn( hFile, lpCommProp );
|
|---|
| 2060 | }
|
|---|
| 2061 |
|
|---|
| 2062 | typedef BOOL WINAPI FN_GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat );
|
|---|
| 2063 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat )
|
|---|
| 2064 | {
|
|---|
| 2065 | static FN_GetCommModemStatus *pfn = 0;
|
|---|
| 2066 | if (!pfn)
|
|---|
| 2067 | kPrf2WrapResolve((void **)&pfn, "GetCommModemStatus", &g_Kernel32);
|
|---|
| 2068 | return pfn( hFile, lpModemStat );
|
|---|
| 2069 | }
|
|---|
| 2070 |
|
|---|
| 2071 | typedef BOOL WINAPI FN_GetCommState( HANDLE hFile, LPDCB lpDCB );
|
|---|
| 2072 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommState( HANDLE hFile, LPDCB lpDCB )
|
|---|
| 2073 | {
|
|---|
| 2074 | static FN_GetCommState *pfn = 0;
|
|---|
| 2075 | if (!pfn)
|
|---|
| 2076 | kPrf2WrapResolve((void **)&pfn, "GetCommState", &g_Kernel32);
|
|---|
| 2077 | return pfn( hFile, lpDCB );
|
|---|
| 2078 | }
|
|---|
| 2079 |
|
|---|
| 2080 | typedef BOOL WINAPI FN_GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts );
|
|---|
| 2081 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts )
|
|---|
| 2082 | {
|
|---|
| 2083 | static FN_GetCommTimeouts *pfn = 0;
|
|---|
| 2084 | if (!pfn)
|
|---|
| 2085 | kPrf2WrapResolve((void **)&pfn, "GetCommTimeouts", &g_Kernel32);
|
|---|
| 2086 | return pfn( hFile, lpCommTimeouts );
|
|---|
| 2087 | }
|
|---|
| 2088 |
|
|---|
| 2089 | typedef BOOL WINAPI FN_PurgeComm( HANDLE hFile, DWORD dwFlags );
|
|---|
| 2090 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PurgeComm( HANDLE hFile, DWORD dwFlags )
|
|---|
| 2091 | {
|
|---|
| 2092 | static FN_PurgeComm *pfn = 0;
|
|---|
| 2093 | if (!pfn)
|
|---|
| 2094 | kPrf2WrapResolve((void **)&pfn, "PurgeComm", &g_Kernel32);
|
|---|
| 2095 | return pfn( hFile, dwFlags );
|
|---|
| 2096 | }
|
|---|
| 2097 |
|
|---|
| 2098 | typedef BOOL WINAPI FN_SetCommBreak( HANDLE hFile );
|
|---|
| 2099 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommBreak( HANDLE hFile )
|
|---|
| 2100 | {
|
|---|
| 2101 | static FN_SetCommBreak *pfn = 0;
|
|---|
| 2102 | if (!pfn)
|
|---|
| 2103 | kPrf2WrapResolve((void **)&pfn, "SetCommBreak", &g_Kernel32);
|
|---|
| 2104 | return pfn( hFile );
|
|---|
| 2105 | }
|
|---|
| 2106 |
|
|---|
| 2107 | typedef BOOL WINAPI FN_SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize );
|
|---|
| 2108 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize )
|
|---|
| 2109 | {
|
|---|
| 2110 | static FN_SetCommConfig *pfn = 0;
|
|---|
| 2111 | if (!pfn)
|
|---|
| 2112 | kPrf2WrapResolve((void **)&pfn, "SetCommConfig", &g_Kernel32);
|
|---|
| 2113 | return pfn( hCommDev, lpCC, dwSize );
|
|---|
| 2114 | }
|
|---|
| 2115 |
|
|---|
| 2116 | typedef BOOL WINAPI FN_SetCommMask( HANDLE hFile, DWORD dwEvtMask );
|
|---|
| 2117 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommMask( HANDLE hFile, DWORD dwEvtMask )
|
|---|
| 2118 | {
|
|---|
| 2119 | static FN_SetCommMask *pfn = 0;
|
|---|
| 2120 | if (!pfn)
|
|---|
| 2121 | kPrf2WrapResolve((void **)&pfn, "SetCommMask", &g_Kernel32);
|
|---|
| 2122 | return pfn( hFile, dwEvtMask );
|
|---|
| 2123 | }
|
|---|
| 2124 |
|
|---|
| 2125 | typedef BOOL WINAPI FN_SetCommState( HANDLE hFile, LPDCB lpDCB );
|
|---|
| 2126 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommState( HANDLE hFile, LPDCB lpDCB )
|
|---|
| 2127 | {
|
|---|
| 2128 | static FN_SetCommState *pfn = 0;
|
|---|
| 2129 | if (!pfn)
|
|---|
| 2130 | kPrf2WrapResolve((void **)&pfn, "SetCommState", &g_Kernel32);
|
|---|
| 2131 | return pfn( hFile, lpDCB );
|
|---|
| 2132 | }
|
|---|
| 2133 |
|
|---|
| 2134 | typedef BOOL WINAPI FN_SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts );
|
|---|
| 2135 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts )
|
|---|
| 2136 | {
|
|---|
| 2137 | static FN_SetCommTimeouts *pfn = 0;
|
|---|
| 2138 | if (!pfn)
|
|---|
| 2139 | kPrf2WrapResolve((void **)&pfn, "SetCommTimeouts", &g_Kernel32);
|
|---|
| 2140 | return pfn( hFile, lpCommTimeouts );
|
|---|
| 2141 | }
|
|---|
| 2142 |
|
|---|
| 2143 | typedef BOOL WINAPI FN_TransmitCommChar( HANDLE hFile, char cChar );
|
|---|
| 2144 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TransmitCommChar( HANDLE hFile, char cChar )
|
|---|
| 2145 | {
|
|---|
| 2146 | static FN_TransmitCommChar *pfn = 0;
|
|---|
| 2147 | if (!pfn)
|
|---|
| 2148 | kPrf2WrapResolve((void **)&pfn, "TransmitCommChar", &g_Kernel32);
|
|---|
| 2149 | return pfn( hFile, cChar );
|
|---|
| 2150 | }
|
|---|
| 2151 |
|
|---|
| 2152 | typedef BOOL WINAPI FN_WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped );
|
|---|
| 2153 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped )
|
|---|
| 2154 | {
|
|---|
| 2155 | static FN_WaitCommEvent *pfn = 0;
|
|---|
| 2156 | if (!pfn)
|
|---|
| 2157 | kPrf2WrapResolve((void **)&pfn, "WaitCommEvent", &g_Kernel32);
|
|---|
| 2158 | return pfn( hFile, lpEvtMask, lpOverlapped );
|
|---|
| 2159 | }
|
|---|
| 2160 |
|
|---|
| 2161 | typedef DWORD WINAPI FN_SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate );
|
|---|
| 2162 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate )
|
|---|
| 2163 | {
|
|---|
| 2164 | static FN_SetTapePosition *pfn = 0;
|
|---|
| 2165 | if (!pfn)
|
|---|
| 2166 | kPrf2WrapResolve((void **)&pfn, "SetTapePosition", &g_Kernel32);
|
|---|
| 2167 | return pfn( hDevice, dwPositionMethod, dwPartition, dwOffsetLow, dwOffsetHigh, bImmediate );
|
|---|
| 2168 | }
|
|---|
| 2169 |
|
|---|
| 2170 | typedef DWORD WINAPI FN_GetTapePosition( HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh );
|
|---|
| 2171 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapePosition( HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh )
|
|---|
| 2172 | {
|
|---|
| 2173 | static FN_GetTapePosition *pfn = 0;
|
|---|
| 2174 | if (!pfn)
|
|---|
| 2175 | kPrf2WrapResolve((void **)&pfn, "GetTapePosition", &g_Kernel32);
|
|---|
| 2176 | return pfn( hDevice, dwPositionType, lpdwPartition, lpdwOffsetLow, lpdwOffsetHigh );
|
|---|
| 2177 | }
|
|---|
| 2178 |
|
|---|
| 2179 | typedef DWORD WINAPI FN_PrepareTape( HANDLE hDevice, DWORD dwOperation, BOOL bImmediate );
|
|---|
| 2180 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_PrepareTape( HANDLE hDevice, DWORD dwOperation, BOOL bImmediate )
|
|---|
| 2181 | {
|
|---|
| 2182 | static FN_PrepareTape *pfn = 0;
|
|---|
| 2183 | if (!pfn)
|
|---|
| 2184 | kPrf2WrapResolve((void **)&pfn, "PrepareTape", &g_Kernel32);
|
|---|
| 2185 | return pfn( hDevice, dwOperation, bImmediate );
|
|---|
| 2186 | }
|
|---|
| 2187 |
|
|---|
| 2188 | typedef DWORD WINAPI FN_EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate );
|
|---|
| 2189 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate )
|
|---|
| 2190 | {
|
|---|
| 2191 | static FN_EraseTape *pfn = 0;
|
|---|
| 2192 | if (!pfn)
|
|---|
| 2193 | kPrf2WrapResolve((void **)&pfn, "EraseTape", &g_Kernel32);
|
|---|
| 2194 | return pfn( hDevice, dwEraseType, bImmediate );
|
|---|
| 2195 | }
|
|---|
| 2196 |
|
|---|
| 2197 | typedef DWORD WINAPI FN_CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize );
|
|---|
| 2198 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize )
|
|---|
| 2199 | {
|
|---|
| 2200 | static FN_CreateTapePartition *pfn = 0;
|
|---|
| 2201 | if (!pfn)
|
|---|
| 2202 | kPrf2WrapResolve((void **)&pfn, "CreateTapePartition", &g_Kernel32);
|
|---|
| 2203 | return pfn( hDevice, dwPartitionMethod, dwCount, dwSize );
|
|---|
| 2204 | }
|
|---|
| 2205 |
|
|---|
| 2206 | typedef DWORD WINAPI FN_WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate );
|
|---|
| 2207 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate )
|
|---|
| 2208 | {
|
|---|
| 2209 | static FN_WriteTapemark *pfn = 0;
|
|---|
| 2210 | if (!pfn)
|
|---|
| 2211 | kPrf2WrapResolve((void **)&pfn, "WriteTapemark", &g_Kernel32);
|
|---|
| 2212 | return pfn( hDevice, dwTapemarkType, dwTapemarkCount, bImmediate );
|
|---|
| 2213 | }
|
|---|
| 2214 |
|
|---|
| 2215 | typedef DWORD WINAPI FN_GetTapeStatus( HANDLE hDevice );
|
|---|
| 2216 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapeStatus( HANDLE hDevice )
|
|---|
| 2217 | {
|
|---|
| 2218 | static FN_GetTapeStatus *pfn = 0;
|
|---|
| 2219 | if (!pfn)
|
|---|
| 2220 | kPrf2WrapResolve((void **)&pfn, "GetTapeStatus", &g_Kernel32);
|
|---|
| 2221 | return pfn( hDevice );
|
|---|
| 2222 | }
|
|---|
| 2223 |
|
|---|
| 2224 | typedef DWORD WINAPI FN_GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation );
|
|---|
| 2225 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation )
|
|---|
| 2226 | {
|
|---|
| 2227 | static FN_GetTapeParameters *pfn = 0;
|
|---|
| 2228 | if (!pfn)
|
|---|
| 2229 | kPrf2WrapResolve((void **)&pfn, "GetTapeParameters", &g_Kernel32);
|
|---|
| 2230 | return pfn( hDevice, dwOperation, lpdwSize, lpTapeInformation );
|
|---|
| 2231 | }
|
|---|
| 2232 |
|
|---|
| 2233 | typedef DWORD WINAPI FN_SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation );
|
|---|
| 2234 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation )
|
|---|
| 2235 | {
|
|---|
| 2236 | static FN_SetTapeParameters *pfn = 0;
|
|---|
| 2237 | if (!pfn)
|
|---|
| 2238 | kPrf2WrapResolve((void **)&pfn, "SetTapeParameters", &g_Kernel32);
|
|---|
| 2239 | return pfn( hDevice, dwOperation, lpTapeInformation );
|
|---|
| 2240 | }
|
|---|
| 2241 |
|
|---|
| 2242 | typedef BOOL WINAPI FN_Beep( DWORD dwFreq, DWORD dwDuration );
|
|---|
| 2243 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Beep( DWORD dwFreq, DWORD dwDuration )
|
|---|
| 2244 | {
|
|---|
| 2245 | static FN_Beep *pfn = 0;
|
|---|
| 2246 | if (!pfn)
|
|---|
| 2247 | kPrf2WrapResolve((void **)&pfn, "Beep", &g_Kernel32);
|
|---|
| 2248 | return pfn( dwFreq, dwDuration );
|
|---|
| 2249 | }
|
|---|
| 2250 |
|
|---|
| 2251 | typedef int WINAPI FN_MulDiv( int nNumber, int nNumerator, int nDenominator );
|
|---|
| 2252 | __declspec(dllexport) int WINAPI kPrf2Wrap_MulDiv( int nNumber, int nNumerator, int nDenominator )
|
|---|
| 2253 | {
|
|---|
| 2254 | static FN_MulDiv *pfn = 0;
|
|---|
| 2255 | if (!pfn)
|
|---|
| 2256 | kPrf2WrapResolve((void **)&pfn, "MulDiv", &g_Kernel32);
|
|---|
| 2257 | return pfn( nNumber, nNumerator, nDenominator );
|
|---|
| 2258 | }
|
|---|
| 2259 |
|
|---|
| 2260 | typedef VOID WINAPI FN_GetSystemTime( LPSYSTEMTIME lpSystemTime );
|
|---|
| 2261 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemTime( LPSYSTEMTIME lpSystemTime )
|
|---|
| 2262 | {
|
|---|
| 2263 | static FN_GetSystemTime *pfn = 0;
|
|---|
| 2264 | if (!pfn)
|
|---|
| 2265 | kPrf2WrapResolve((void **)&pfn, "GetSystemTime", &g_Kernel32);
|
|---|
| 2266 | pfn( lpSystemTime );
|
|---|
| 2267 | }
|
|---|
| 2268 |
|
|---|
| 2269 | typedef VOID WINAPI FN_GetSystemTimeAsFileTime( LPFILETIME lpSystemTimeAsFileTime );
|
|---|
| 2270 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemTimeAsFileTime( LPFILETIME lpSystemTimeAsFileTime )
|
|---|
| 2271 | {
|
|---|
| 2272 | static FN_GetSystemTimeAsFileTime *pfn = 0;
|
|---|
| 2273 | if (!pfn)
|
|---|
| 2274 | kPrf2WrapResolve((void **)&pfn, "GetSystemTimeAsFileTime", &g_Kernel32);
|
|---|
| 2275 | pfn( lpSystemTimeAsFileTime );
|
|---|
| 2276 | }
|
|---|
| 2277 |
|
|---|
| 2278 | typedef BOOL WINAPI FN_SetSystemTime( CONST SYSTEMTIME * lpSystemTime );
|
|---|
| 2279 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemTime( CONST SYSTEMTIME * lpSystemTime )
|
|---|
| 2280 | {
|
|---|
| 2281 | static FN_SetSystemTime *pfn = 0;
|
|---|
| 2282 | if (!pfn)
|
|---|
| 2283 | kPrf2WrapResolve((void **)&pfn, "SetSystemTime", &g_Kernel32);
|
|---|
| 2284 | return pfn( lpSystemTime );
|
|---|
| 2285 | }
|
|---|
| 2286 |
|
|---|
| 2287 | typedef VOID WINAPI FN_GetLocalTime( LPSYSTEMTIME lpSystemTime );
|
|---|
| 2288 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetLocalTime( LPSYSTEMTIME lpSystemTime )
|
|---|
| 2289 | {
|
|---|
| 2290 | static FN_GetLocalTime *pfn = 0;
|
|---|
| 2291 | if (!pfn)
|
|---|
| 2292 | kPrf2WrapResolve((void **)&pfn, "GetLocalTime", &g_Kernel32);
|
|---|
| 2293 | pfn( lpSystemTime );
|
|---|
| 2294 | }
|
|---|
| 2295 |
|
|---|
| 2296 | typedef BOOL WINAPI FN_SetLocalTime( CONST SYSTEMTIME * lpSystemTime );
|
|---|
| 2297 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocalTime( CONST SYSTEMTIME * lpSystemTime )
|
|---|
| 2298 | {
|
|---|
| 2299 | static FN_SetLocalTime *pfn = 0;
|
|---|
| 2300 | if (!pfn)
|
|---|
| 2301 | kPrf2WrapResolve((void **)&pfn, "SetLocalTime", &g_Kernel32);
|
|---|
| 2302 | return pfn( lpSystemTime );
|
|---|
| 2303 | }
|
|---|
| 2304 |
|
|---|
| 2305 | typedef VOID WINAPI FN_GetSystemInfo( LPSYSTEM_INFO lpSystemInfo );
|
|---|
| 2306 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemInfo( LPSYSTEM_INFO lpSystemInfo )
|
|---|
| 2307 | {
|
|---|
| 2308 | static FN_GetSystemInfo *pfn = 0;
|
|---|
| 2309 | if (!pfn)
|
|---|
| 2310 | kPrf2WrapResolve((void **)&pfn, "GetSystemInfo", &g_Kernel32);
|
|---|
| 2311 | pfn( lpSystemInfo );
|
|---|
| 2312 | }
|
|---|
| 2313 |
|
|---|
| 2314 | typedef BOOL WINAPI FN_SetSystemFileCacheSize( SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags );
|
|---|
| 2315 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemFileCacheSize( SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags )
|
|---|
| 2316 | {
|
|---|
| 2317 | static FN_SetSystemFileCacheSize *pfn = 0;
|
|---|
| 2318 | if (!pfn)
|
|---|
| 2319 | kPrf2WrapResolve((void **)&pfn, "SetSystemFileCacheSize", &g_Kernel32);
|
|---|
| 2320 | return pfn( MinimumFileCacheSize, MaximumFileCacheSize, Flags );
|
|---|
| 2321 | }
|
|---|
| 2322 |
|
|---|
| 2323 | typedef BOOL WINAPI FN_GetSystemFileCacheSize( PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags );
|
|---|
| 2324 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemFileCacheSize( PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags )
|
|---|
| 2325 | {
|
|---|
| 2326 | static FN_GetSystemFileCacheSize *pfn = 0;
|
|---|
| 2327 | if (!pfn)
|
|---|
| 2328 | kPrf2WrapResolve((void **)&pfn, "GetSystemFileCacheSize", &g_Kernel32);
|
|---|
| 2329 | return pfn( lpMinimumFileCacheSize, lpMaximumFileCacheSize, lpFlags );
|
|---|
| 2330 | }
|
|---|
| 2331 |
|
|---|
| 2332 | typedef BOOL WINAPI FN_GetSystemRegistryQuota( PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed );
|
|---|
| 2333 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemRegistryQuota( PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed )
|
|---|
| 2334 | {
|
|---|
| 2335 | static FN_GetSystemRegistryQuota *pfn = 0;
|
|---|
| 2336 | if (!pfn)
|
|---|
| 2337 | kPrf2WrapResolve((void **)&pfn, "GetSystemRegistryQuota", &g_Kernel32);
|
|---|
| 2338 | return pfn( pdwQuotaAllowed, pdwQuotaUsed );
|
|---|
| 2339 | }
|
|---|
| 2340 |
|
|---|
| 2341 | typedef BOOL WINAPI FN_GetSystemTimes( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
|
|---|
| 2342 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemTimes( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
|
|---|
| 2343 | {
|
|---|
| 2344 | static FN_GetSystemTimes *pfn = 0;
|
|---|
| 2345 | if (!pfn)
|
|---|
| 2346 | kPrf2WrapResolve((void **)&pfn, "GetSystemTimes", &g_Kernel32);
|
|---|
| 2347 | return pfn( lpIdleTime, lpKernelTime, lpUserTime );
|
|---|
| 2348 | }
|
|---|
| 2349 |
|
|---|
| 2350 | typedef VOID WINAPI FN_GetNativeSystemInfo( LPSYSTEM_INFO lpSystemInfo );
|
|---|
| 2351 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetNativeSystemInfo( LPSYSTEM_INFO lpSystemInfo )
|
|---|
| 2352 | {
|
|---|
| 2353 | static FN_GetNativeSystemInfo *pfn = 0;
|
|---|
| 2354 | if (!pfn)
|
|---|
| 2355 | kPrf2WrapResolve((void **)&pfn, "GetNativeSystemInfo", &g_Kernel32);
|
|---|
| 2356 | pfn( lpSystemInfo );
|
|---|
| 2357 | }
|
|---|
| 2358 |
|
|---|
| 2359 | typedef BOOL WINAPI FN_IsProcessorFeaturePresent( DWORD ProcessorFeature );
|
|---|
| 2360 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsProcessorFeaturePresent( DWORD ProcessorFeature )
|
|---|
| 2361 | {
|
|---|
| 2362 | static FN_IsProcessorFeaturePresent *pfn = 0;
|
|---|
| 2363 | if (!pfn)
|
|---|
| 2364 | kPrf2WrapResolve((void **)&pfn, "IsProcessorFeaturePresent", &g_Kernel32);
|
|---|
| 2365 | return pfn( ProcessorFeature );
|
|---|
| 2366 | }
|
|---|
| 2367 |
|
|---|
| 2368 | typedef BOOL WINAPI FN_SystemTimeToTzSpecificLocalTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime );
|
|---|
| 2369 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SystemTimeToTzSpecificLocalTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime )
|
|---|
| 2370 | {
|
|---|
| 2371 | static FN_SystemTimeToTzSpecificLocalTime *pfn = 0;
|
|---|
| 2372 | if (!pfn)
|
|---|
| 2373 | kPrf2WrapResolve((void **)&pfn, "SystemTimeToTzSpecificLocalTime", &g_Kernel32);
|
|---|
| 2374 | return pfn( lpTimeZoneInformation, lpUniversalTime, lpLocalTime );
|
|---|
| 2375 | }
|
|---|
| 2376 |
|
|---|
| 2377 | typedef BOOL WINAPI FN_TzSpecificLocalTimeToSystemTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpLocalTime, LPSYSTEMTIME lpUniversalTime );
|
|---|
| 2378 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TzSpecificLocalTimeToSystemTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpLocalTime, LPSYSTEMTIME lpUniversalTime )
|
|---|
| 2379 | {
|
|---|
| 2380 | static FN_TzSpecificLocalTimeToSystemTime *pfn = 0;
|
|---|
| 2381 | if (!pfn)
|
|---|
| 2382 | kPrf2WrapResolve((void **)&pfn, "TzSpecificLocalTimeToSystemTime", &g_Kernel32);
|
|---|
| 2383 | return pfn( lpTimeZoneInformation, lpLocalTime, lpUniversalTime );
|
|---|
| 2384 | }
|
|---|
| 2385 |
|
|---|
| 2386 | typedef DWORD WINAPI FN_GetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation );
|
|---|
| 2387 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation )
|
|---|
| 2388 | {
|
|---|
| 2389 | static FN_GetTimeZoneInformation *pfn = 0;
|
|---|
| 2390 | if (!pfn)
|
|---|
| 2391 | kPrf2WrapResolve((void **)&pfn, "GetTimeZoneInformation", &g_Kernel32);
|
|---|
| 2392 | return pfn( lpTimeZoneInformation );
|
|---|
| 2393 | }
|
|---|
| 2394 |
|
|---|
| 2395 | typedef BOOL WINAPI FN_SetTimeZoneInformation( CONST TIME_ZONE_INFORMATION * lpTimeZoneInformation );
|
|---|
| 2396 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetTimeZoneInformation( CONST TIME_ZONE_INFORMATION * lpTimeZoneInformation )
|
|---|
| 2397 | {
|
|---|
| 2398 | static FN_SetTimeZoneInformation *pfn = 0;
|
|---|
| 2399 | if (!pfn)
|
|---|
| 2400 | kPrf2WrapResolve((void **)&pfn, "SetTimeZoneInformation", &g_Kernel32);
|
|---|
| 2401 | return pfn( lpTimeZoneInformation );
|
|---|
| 2402 | }
|
|---|
| 2403 |
|
|---|
| 2404 | typedef BOOL WINAPI FN_SystemTimeToFileTime( CONST SYSTEMTIME * lpSystemTime, LPFILETIME lpFileTime );
|
|---|
| 2405 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SystemTimeToFileTime( CONST SYSTEMTIME * lpSystemTime, LPFILETIME lpFileTime )
|
|---|
| 2406 | {
|
|---|
| 2407 | static FN_SystemTimeToFileTime *pfn = 0;
|
|---|
| 2408 | if (!pfn)
|
|---|
| 2409 | kPrf2WrapResolve((void **)&pfn, "SystemTimeToFileTime", &g_Kernel32);
|
|---|
| 2410 | return pfn( lpSystemTime, lpFileTime );
|
|---|
| 2411 | }
|
|---|
| 2412 |
|
|---|
| 2413 | typedef BOOL WINAPI FN_FileTimeToLocalFileTime( CONST FILETIME * lpFileTime, LPFILETIME lpLocalFileTime );
|
|---|
| 2414 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToLocalFileTime( CONST FILETIME * lpFileTime, LPFILETIME lpLocalFileTime )
|
|---|
| 2415 | {
|
|---|
| 2416 | static FN_FileTimeToLocalFileTime *pfn = 0;
|
|---|
| 2417 | if (!pfn)
|
|---|
| 2418 | kPrf2WrapResolve((void **)&pfn, "FileTimeToLocalFileTime", &g_Kernel32);
|
|---|
| 2419 | return pfn( lpFileTime, lpLocalFileTime );
|
|---|
| 2420 | }
|
|---|
| 2421 |
|
|---|
| 2422 | typedef BOOL WINAPI FN_LocalFileTimeToFileTime( CONST FILETIME * lpLocalFileTime, LPFILETIME lpFileTime );
|
|---|
| 2423 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LocalFileTimeToFileTime( CONST FILETIME * lpLocalFileTime, LPFILETIME lpFileTime )
|
|---|
| 2424 | {
|
|---|
| 2425 | static FN_LocalFileTimeToFileTime *pfn = 0;
|
|---|
| 2426 | if (!pfn)
|
|---|
| 2427 | kPrf2WrapResolve((void **)&pfn, "LocalFileTimeToFileTime", &g_Kernel32);
|
|---|
| 2428 | return pfn( lpLocalFileTime, lpFileTime );
|
|---|
| 2429 | }
|
|---|
| 2430 |
|
|---|
| 2431 | typedef BOOL WINAPI FN_FileTimeToSystemTime( CONST FILETIME * lpFileTime, LPSYSTEMTIME lpSystemTime );
|
|---|
| 2432 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToSystemTime( CONST FILETIME * lpFileTime, LPSYSTEMTIME lpSystemTime )
|
|---|
| 2433 | {
|
|---|
| 2434 | static FN_FileTimeToSystemTime *pfn = 0;
|
|---|
| 2435 | if (!pfn)
|
|---|
| 2436 | kPrf2WrapResolve((void **)&pfn, "FileTimeToSystemTime", &g_Kernel32);
|
|---|
| 2437 | return pfn( lpFileTime, lpSystemTime );
|
|---|
| 2438 | }
|
|---|
| 2439 |
|
|---|
| 2440 | typedef LONG WINAPI FN_CompareFileTime( CONST FILETIME * lpFileTime1, CONST FILETIME * lpFileTime2 );
|
|---|
| 2441 | __declspec(dllexport) LONG WINAPI kPrf2Wrap_CompareFileTime( CONST FILETIME * lpFileTime1, CONST FILETIME * lpFileTime2 )
|
|---|
| 2442 | {
|
|---|
| 2443 | static FN_CompareFileTime *pfn = 0;
|
|---|
| 2444 | if (!pfn)
|
|---|
| 2445 | kPrf2WrapResolve((void **)&pfn, "CompareFileTime", &g_Kernel32);
|
|---|
| 2446 | return pfn( lpFileTime1, lpFileTime2 );
|
|---|
| 2447 | }
|
|---|
| 2448 |
|
|---|
| 2449 | typedef BOOL WINAPI FN_FileTimeToDosDateTime( CONST FILETIME * lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime );
|
|---|
| 2450 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToDosDateTime( CONST FILETIME * lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime )
|
|---|
| 2451 | {
|
|---|
| 2452 | static FN_FileTimeToDosDateTime *pfn = 0;
|
|---|
| 2453 | if (!pfn)
|
|---|
| 2454 | kPrf2WrapResolve((void **)&pfn, "FileTimeToDosDateTime", &g_Kernel32);
|
|---|
| 2455 | return pfn( lpFileTime, lpFatDate, lpFatTime );
|
|---|
| 2456 | }
|
|---|
| 2457 |
|
|---|
| 2458 | typedef BOOL WINAPI FN_DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime );
|
|---|
| 2459 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime )
|
|---|
| 2460 | {
|
|---|
| 2461 | static FN_DosDateTimeToFileTime *pfn = 0;
|
|---|
| 2462 | if (!pfn)
|
|---|
| 2463 | kPrf2WrapResolve((void **)&pfn, "DosDateTimeToFileTime", &g_Kernel32);
|
|---|
| 2464 | return pfn( wFatDate, wFatTime, lpFileTime );
|
|---|
| 2465 | }
|
|---|
| 2466 |
|
|---|
| 2467 | typedef DWORD WINAPI FN_GetTickCount( VOID );
|
|---|
| 2468 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTickCount( VOID )
|
|---|
| 2469 | {
|
|---|
| 2470 | static FN_GetTickCount *pfn = 0;
|
|---|
| 2471 | if (!pfn)
|
|---|
| 2472 | kPrf2WrapResolve((void **)&pfn, "GetTickCount", &g_Kernel32);
|
|---|
| 2473 | return pfn ();
|
|---|
| 2474 | }
|
|---|
| 2475 |
|
|---|
| 2476 | typedef BOOL WINAPI FN_SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled );
|
|---|
| 2477 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled )
|
|---|
| 2478 | {
|
|---|
| 2479 | static FN_SetSystemTimeAdjustment *pfn = 0;
|
|---|
| 2480 | if (!pfn)
|
|---|
| 2481 | kPrf2WrapResolve((void **)&pfn, "SetSystemTimeAdjustment", &g_Kernel32);
|
|---|
| 2482 | return pfn( dwTimeAdjustment, bTimeAdjustmentDisabled );
|
|---|
| 2483 | }
|
|---|
| 2484 |
|
|---|
| 2485 | typedef BOOL WINAPI FN_GetSystemTimeAdjustment( PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled );
|
|---|
| 2486 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemTimeAdjustment( PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled )
|
|---|
| 2487 | {
|
|---|
| 2488 | static FN_GetSystemTimeAdjustment *pfn = 0;
|
|---|
| 2489 | if (!pfn)
|
|---|
| 2490 | kPrf2WrapResolve((void **)&pfn, "GetSystemTimeAdjustment", &g_Kernel32);
|
|---|
| 2491 | return pfn( lpTimeAdjustment, lpTimeIncrement, lpTimeAdjustmentDisabled );
|
|---|
| 2492 | }
|
|---|
| 2493 |
|
|---|
| 2494 | typedef DWORD WINAPI FN_FormatMessageA( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list * Arguments );
|
|---|
| 2495 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FormatMessageA( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list * Arguments )
|
|---|
| 2496 | {
|
|---|
| 2497 | static FN_FormatMessageA *pfn = 0;
|
|---|
| 2498 | if (!pfn)
|
|---|
| 2499 | kPrf2WrapResolve((void **)&pfn, "FormatMessageA", &g_Kernel32);
|
|---|
| 2500 | return pfn( dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments );
|
|---|
| 2501 | }
|
|---|
| 2502 |
|
|---|
| 2503 | typedef DWORD WINAPI FN_FormatMessageW( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list * Arguments );
|
|---|
| 2504 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FormatMessageW( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list * Arguments )
|
|---|
| 2505 | {
|
|---|
| 2506 | static FN_FormatMessageW *pfn = 0;
|
|---|
| 2507 | if (!pfn)
|
|---|
| 2508 | kPrf2WrapResolve((void **)&pfn, "FormatMessageW", &g_Kernel32);
|
|---|
| 2509 | return pfn( dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments );
|
|---|
| 2510 | }
|
|---|
| 2511 |
|
|---|
| 2512 | typedef BOOL WINAPI FN_CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize );
|
|---|
| 2513 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize )
|
|---|
| 2514 | {
|
|---|
| 2515 | static FN_CreatePipe *pfn = 0;
|
|---|
| 2516 | if (!pfn)
|
|---|
| 2517 | kPrf2WrapResolve((void **)&pfn, "CreatePipe", &g_Kernel32);
|
|---|
| 2518 | return pfn( hReadPipe, hWritePipe, lpPipeAttributes, nSize );
|
|---|
| 2519 | }
|
|---|
| 2520 |
|
|---|
| 2521 | typedef BOOL WINAPI FN_ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped );
|
|---|
| 2522 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped )
|
|---|
| 2523 | {
|
|---|
| 2524 | static FN_ConnectNamedPipe *pfn = 0;
|
|---|
| 2525 | if (!pfn)
|
|---|
| 2526 | kPrf2WrapResolve((void **)&pfn, "ConnectNamedPipe", &g_Kernel32);
|
|---|
| 2527 | return pfn( hNamedPipe, lpOverlapped );
|
|---|
| 2528 | }
|
|---|
| 2529 |
|
|---|
| 2530 | typedef BOOL WINAPI FN_DisconnectNamedPipe( HANDLE hNamedPipe );
|
|---|
| 2531 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DisconnectNamedPipe( HANDLE hNamedPipe )
|
|---|
| 2532 | {
|
|---|
| 2533 | static FN_DisconnectNamedPipe *pfn = 0;
|
|---|
| 2534 | if (!pfn)
|
|---|
| 2535 | kPrf2WrapResolve((void **)&pfn, "DisconnectNamedPipe", &g_Kernel32);
|
|---|
| 2536 | return pfn( hNamedPipe );
|
|---|
| 2537 | }
|
|---|
| 2538 |
|
|---|
| 2539 | typedef BOOL WINAPI FN_SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout );
|
|---|
| 2540 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout )
|
|---|
| 2541 | {
|
|---|
| 2542 | static FN_SetNamedPipeHandleState *pfn = 0;
|
|---|
| 2543 | if (!pfn)
|
|---|
| 2544 | kPrf2WrapResolve((void **)&pfn, "SetNamedPipeHandleState", &g_Kernel32);
|
|---|
| 2545 | return pfn( hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout );
|
|---|
| 2546 | }
|
|---|
| 2547 |
|
|---|
| 2548 | typedef BOOL WINAPI FN_GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances );
|
|---|
| 2549 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances )
|
|---|
| 2550 | {
|
|---|
| 2551 | static FN_GetNamedPipeInfo *pfn = 0;
|
|---|
| 2552 | if (!pfn)
|
|---|
| 2553 | kPrf2WrapResolve((void **)&pfn, "GetNamedPipeInfo", &g_Kernel32);
|
|---|
| 2554 | return pfn( hNamedPipe, lpFlags, lpOutBufferSize, lpInBufferSize, lpMaxInstances );
|
|---|
| 2555 | }
|
|---|
| 2556 |
|
|---|
| 2557 | typedef BOOL WINAPI FN_PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage );
|
|---|
| 2558 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage )
|
|---|
| 2559 | {
|
|---|
| 2560 | static FN_PeekNamedPipe *pfn = 0;
|
|---|
| 2561 | if (!pfn)
|
|---|
| 2562 | kPrf2WrapResolve((void **)&pfn, "PeekNamedPipe", &g_Kernel32);
|
|---|
| 2563 | return pfn( hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage );
|
|---|
| 2564 | }
|
|---|
| 2565 |
|
|---|
| 2566 | typedef BOOL WINAPI FN_TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped );
|
|---|
| 2567 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped )
|
|---|
| 2568 | {
|
|---|
| 2569 | static FN_TransactNamedPipe *pfn = 0;
|
|---|
| 2570 | if (!pfn)
|
|---|
| 2571 | kPrf2WrapResolve((void **)&pfn, "TransactNamedPipe", &g_Kernel32);
|
|---|
| 2572 | return pfn( hNamedPipe, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, lpOverlapped );
|
|---|
| 2573 | }
|
|---|
| 2574 |
|
|---|
| 2575 | typedef HANDLE WINAPI FN_CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 2576 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 2577 | {
|
|---|
| 2578 | static FN_CreateMailslotA *pfn = 0;
|
|---|
| 2579 | if (!pfn)
|
|---|
| 2580 | kPrf2WrapResolve((void **)&pfn, "CreateMailslotA", &g_Kernel32);
|
|---|
| 2581 | return pfn( lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes );
|
|---|
| 2582 | }
|
|---|
| 2583 |
|
|---|
| 2584 | typedef HANDLE WINAPI FN_CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 2585 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 2586 | {
|
|---|
| 2587 | static FN_CreateMailslotW *pfn = 0;
|
|---|
| 2588 | if (!pfn)
|
|---|
| 2589 | kPrf2WrapResolve((void **)&pfn, "CreateMailslotW", &g_Kernel32);
|
|---|
| 2590 | return pfn( lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes );
|
|---|
| 2591 | }
|
|---|
| 2592 |
|
|---|
| 2593 | typedef BOOL WINAPI FN_GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout );
|
|---|
| 2594 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout )
|
|---|
| 2595 | {
|
|---|
| 2596 | static FN_GetMailslotInfo *pfn = 0;
|
|---|
| 2597 | if (!pfn)
|
|---|
| 2598 | kPrf2WrapResolve((void **)&pfn, "GetMailslotInfo", &g_Kernel32);
|
|---|
| 2599 | return pfn( hMailslot, lpMaxMessageSize, lpNextSize, lpMessageCount, lpReadTimeout );
|
|---|
| 2600 | }
|
|---|
| 2601 |
|
|---|
| 2602 | typedef BOOL WINAPI FN_SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout );
|
|---|
| 2603 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout )
|
|---|
| 2604 | {
|
|---|
| 2605 | static FN_SetMailslotInfo *pfn = 0;
|
|---|
| 2606 | if (!pfn)
|
|---|
| 2607 | kPrf2WrapResolve((void **)&pfn, "SetMailslotInfo", &g_Kernel32);
|
|---|
| 2608 | return pfn( hMailslot, lReadTimeout );
|
|---|
| 2609 | }
|
|---|
| 2610 |
|
|---|
| 2611 | typedef LPVOID WINAPI FN_MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap );
|
|---|
| 2612 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap )
|
|---|
| 2613 | {
|
|---|
| 2614 | static FN_MapViewOfFile *pfn = 0;
|
|---|
| 2615 | if (!pfn)
|
|---|
| 2616 | kPrf2WrapResolve((void **)&pfn, "MapViewOfFile", &g_Kernel32);
|
|---|
| 2617 | return pfn( hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap );
|
|---|
| 2618 | }
|
|---|
| 2619 |
|
|---|
| 2620 | typedef BOOL WINAPI FN_FlushViewOfFile( LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush );
|
|---|
| 2621 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushViewOfFile( LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush )
|
|---|
| 2622 | {
|
|---|
| 2623 | static FN_FlushViewOfFile *pfn = 0;
|
|---|
| 2624 | if (!pfn)
|
|---|
| 2625 | kPrf2WrapResolve((void **)&pfn, "FlushViewOfFile", &g_Kernel32);
|
|---|
| 2626 | return pfn( lpBaseAddress, dwNumberOfBytesToFlush );
|
|---|
| 2627 | }
|
|---|
| 2628 |
|
|---|
| 2629 | typedef BOOL WINAPI FN_UnmapViewOfFile( LPCVOID lpBaseAddress );
|
|---|
| 2630 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnmapViewOfFile( LPCVOID lpBaseAddress )
|
|---|
| 2631 | {
|
|---|
| 2632 | static FN_UnmapViewOfFile *pfn = 0;
|
|---|
| 2633 | if (!pfn)
|
|---|
| 2634 | kPrf2WrapResolve((void **)&pfn, "UnmapViewOfFile", &g_Kernel32);
|
|---|
| 2635 | return pfn( lpBaseAddress );
|
|---|
| 2636 | }
|
|---|
| 2637 |
|
|---|
| 2638 | typedef BOOL WINAPI FN_EncryptFileA( LPCSTR lpFileName );
|
|---|
| 2639 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EncryptFileA( LPCSTR lpFileName )
|
|---|
| 2640 | {
|
|---|
| 2641 | static FN_EncryptFileA *pfn = 0;
|
|---|
| 2642 | if (!pfn)
|
|---|
| 2643 | kPrf2WrapResolve((void **)&pfn, "EncryptFileA", &g_Kernel32);
|
|---|
| 2644 | return pfn( lpFileName );
|
|---|
| 2645 | }
|
|---|
| 2646 |
|
|---|
| 2647 | typedef BOOL WINAPI FN_EncryptFileW( LPCWSTR lpFileName );
|
|---|
| 2648 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EncryptFileW( LPCWSTR lpFileName )
|
|---|
| 2649 | {
|
|---|
| 2650 | static FN_EncryptFileW *pfn = 0;
|
|---|
| 2651 | if (!pfn)
|
|---|
| 2652 | kPrf2WrapResolve((void **)&pfn, "EncryptFileW", &g_Kernel32);
|
|---|
| 2653 | return pfn( lpFileName );
|
|---|
| 2654 | }
|
|---|
| 2655 |
|
|---|
| 2656 | typedef BOOL WINAPI FN_DecryptFileA( LPCSTR lpFileName, DWORD dwReserved );
|
|---|
| 2657 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DecryptFileA( LPCSTR lpFileName, DWORD dwReserved )
|
|---|
| 2658 | {
|
|---|
| 2659 | static FN_DecryptFileA *pfn = 0;
|
|---|
| 2660 | if (!pfn)
|
|---|
| 2661 | kPrf2WrapResolve((void **)&pfn, "DecryptFileA", &g_Kernel32);
|
|---|
| 2662 | return pfn( lpFileName, dwReserved );
|
|---|
| 2663 | }
|
|---|
| 2664 |
|
|---|
| 2665 | typedef BOOL WINAPI FN_DecryptFileW( LPCWSTR lpFileName, DWORD dwReserved );
|
|---|
| 2666 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DecryptFileW( LPCWSTR lpFileName, DWORD dwReserved )
|
|---|
| 2667 | {
|
|---|
| 2668 | static FN_DecryptFileW *pfn = 0;
|
|---|
| 2669 | if (!pfn)
|
|---|
| 2670 | kPrf2WrapResolve((void **)&pfn, "DecryptFileW", &g_Kernel32);
|
|---|
| 2671 | return pfn( lpFileName, dwReserved );
|
|---|
| 2672 | }
|
|---|
| 2673 |
|
|---|
| 2674 | typedef BOOL WINAPI FN_FileEncryptionStatusA( LPCSTR lpFileName, LPDWORD lpStatus );
|
|---|
| 2675 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileEncryptionStatusA( LPCSTR lpFileName, LPDWORD lpStatus )
|
|---|
| 2676 | {
|
|---|
| 2677 | static FN_FileEncryptionStatusA *pfn = 0;
|
|---|
| 2678 | if (!pfn)
|
|---|
| 2679 | kPrf2WrapResolve((void **)&pfn, "FileEncryptionStatusA", &g_Kernel32);
|
|---|
| 2680 | return pfn( lpFileName, lpStatus );
|
|---|
| 2681 | }
|
|---|
| 2682 |
|
|---|
| 2683 | typedef BOOL WINAPI FN_FileEncryptionStatusW( LPCWSTR lpFileName, LPDWORD lpStatus );
|
|---|
| 2684 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileEncryptionStatusW( LPCWSTR lpFileName, LPDWORD lpStatus )
|
|---|
| 2685 | {
|
|---|
| 2686 | static FN_FileEncryptionStatusW *pfn = 0;
|
|---|
| 2687 | if (!pfn)
|
|---|
| 2688 | kPrf2WrapResolve((void **)&pfn, "FileEncryptionStatusW", &g_Kernel32);
|
|---|
| 2689 | return pfn( lpFileName, lpStatus );
|
|---|
| 2690 | }
|
|---|
| 2691 |
|
|---|
| 2692 | typedef DWORD WINAPI FN_OpenEncryptedFileRawA( LPCSTR lpFileName, ULONG ulFlags, PVOID * pvContext );
|
|---|
| 2693 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_OpenEncryptedFileRawA( LPCSTR lpFileName, ULONG ulFlags, PVOID * pvContext )
|
|---|
| 2694 | {
|
|---|
| 2695 | static FN_OpenEncryptedFileRawA *pfn = 0;
|
|---|
| 2696 | if (!pfn)
|
|---|
| 2697 | kPrf2WrapResolve((void **)&pfn, "OpenEncryptedFileRawA", &g_Kernel32);
|
|---|
| 2698 | return pfn( lpFileName, ulFlags, pvContext );
|
|---|
| 2699 | }
|
|---|
| 2700 |
|
|---|
| 2701 | typedef DWORD WINAPI FN_OpenEncryptedFileRawW( LPCWSTR lpFileName, ULONG ulFlags, PVOID * pvContext );
|
|---|
| 2702 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_OpenEncryptedFileRawW( LPCWSTR lpFileName, ULONG ulFlags, PVOID * pvContext )
|
|---|
| 2703 | {
|
|---|
| 2704 | static FN_OpenEncryptedFileRawW *pfn = 0;
|
|---|
| 2705 | if (!pfn)
|
|---|
| 2706 | kPrf2WrapResolve((void **)&pfn, "OpenEncryptedFileRawW", &g_Kernel32);
|
|---|
| 2707 | return pfn( lpFileName, ulFlags, pvContext );
|
|---|
| 2708 | }
|
|---|
| 2709 |
|
|---|
| 2710 | typedef DWORD WINAPI FN_ReadEncryptedFileRaw( PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext );
|
|---|
| 2711 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ReadEncryptedFileRaw( PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext )
|
|---|
| 2712 | {
|
|---|
| 2713 | static FN_ReadEncryptedFileRaw *pfn = 0;
|
|---|
| 2714 | if (!pfn)
|
|---|
| 2715 | kPrf2WrapResolve((void **)&pfn, "ReadEncryptedFileRaw", &g_Kernel32);
|
|---|
| 2716 | return pfn( pfExportCallback, pvCallbackContext, pvContext );
|
|---|
| 2717 | }
|
|---|
| 2718 |
|
|---|
| 2719 | typedef DWORD WINAPI FN_WriteEncryptedFileRaw( PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext );
|
|---|
| 2720 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WriteEncryptedFileRaw( PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext )
|
|---|
| 2721 | {
|
|---|
| 2722 | static FN_WriteEncryptedFileRaw *pfn = 0;
|
|---|
| 2723 | if (!pfn)
|
|---|
| 2724 | kPrf2WrapResolve((void **)&pfn, "WriteEncryptedFileRaw", &g_Kernel32);
|
|---|
| 2725 | return pfn( pfImportCallback, pvCallbackContext, pvContext );
|
|---|
| 2726 | }
|
|---|
| 2727 |
|
|---|
| 2728 | typedef VOID WINAPI FN_CloseEncryptedFileRaw( PVOID pvContext );
|
|---|
| 2729 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_CloseEncryptedFileRaw( PVOID pvContext )
|
|---|
| 2730 | {
|
|---|
| 2731 | static FN_CloseEncryptedFileRaw *pfn = 0;
|
|---|
| 2732 | if (!pfn)
|
|---|
| 2733 | kPrf2WrapResolve((void **)&pfn, "CloseEncryptedFileRaw", &g_Kernel32);
|
|---|
| 2734 | pfn( pvContext );
|
|---|
| 2735 | }
|
|---|
| 2736 |
|
|---|
| 2737 | typedef int WINAPI FN_lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 );
|
|---|
| 2738 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 )
|
|---|
| 2739 | {
|
|---|
| 2740 | static FN_lstrcmpA *pfn = 0;
|
|---|
| 2741 | if (!pfn)
|
|---|
| 2742 | kPrf2WrapResolve((void **)&pfn, "lstrcmpA", &g_Kernel32);
|
|---|
| 2743 | return pfn( lpString1, lpString2 );
|
|---|
| 2744 | }
|
|---|
| 2745 |
|
|---|
| 2746 | typedef int WINAPI FN_lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 );
|
|---|
| 2747 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 )
|
|---|
| 2748 | {
|
|---|
| 2749 | static FN_lstrcmpW *pfn = 0;
|
|---|
| 2750 | if (!pfn)
|
|---|
| 2751 | kPrf2WrapResolve((void **)&pfn, "lstrcmpW", &g_Kernel32);
|
|---|
| 2752 | return pfn( lpString1, lpString2 );
|
|---|
| 2753 | }
|
|---|
| 2754 |
|
|---|
| 2755 | typedef int WINAPI FN_lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 );
|
|---|
| 2756 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 )
|
|---|
| 2757 | {
|
|---|
| 2758 | static FN_lstrcmpiA *pfn = 0;
|
|---|
| 2759 | if (!pfn)
|
|---|
| 2760 | kPrf2WrapResolve((void **)&pfn, "lstrcmpiA", &g_Kernel32);
|
|---|
| 2761 | return pfn( lpString1, lpString2 );
|
|---|
| 2762 | }
|
|---|
| 2763 |
|
|---|
| 2764 | typedef int WINAPI FN_lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 );
|
|---|
| 2765 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 )
|
|---|
| 2766 | {
|
|---|
| 2767 | static FN_lstrcmpiW *pfn = 0;
|
|---|
| 2768 | if (!pfn)
|
|---|
| 2769 | kPrf2WrapResolve((void **)&pfn, "lstrcmpiW", &g_Kernel32);
|
|---|
| 2770 | return pfn( lpString1, lpString2 );
|
|---|
| 2771 | }
|
|---|
| 2772 |
|
|---|
| 2773 | typedef LPSTR WINAPI FN_lstrcpynA( LPSTR lpString1, LPCSTR lpString2, int iMaxLength );
|
|---|
| 2774 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpynA( LPSTR lpString1, LPCSTR lpString2, int iMaxLength )
|
|---|
| 2775 | {
|
|---|
| 2776 | static FN_lstrcpynA *pfn = 0;
|
|---|
| 2777 | if (!pfn)
|
|---|
| 2778 | kPrf2WrapResolve((void **)&pfn, "lstrcpynA", &g_Kernel32);
|
|---|
| 2779 | return pfn( lpString1, lpString2, iMaxLength );
|
|---|
| 2780 | }
|
|---|
| 2781 |
|
|---|
| 2782 | typedef LPWSTR WINAPI FN_lstrcpynW( LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength );
|
|---|
| 2783 | __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcpynW( LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength )
|
|---|
| 2784 | {
|
|---|
| 2785 | static FN_lstrcpynW *pfn = 0;
|
|---|
| 2786 | if (!pfn)
|
|---|
| 2787 | kPrf2WrapResolve((void **)&pfn, "lstrcpynW", &g_Kernel32);
|
|---|
| 2788 | return pfn( lpString1, lpString2, iMaxLength );
|
|---|
| 2789 | }
|
|---|
| 2790 |
|
|---|
| 2791 | typedef LPSTR WINAPI FN_lstrcpyA( LPSTR lpString1, LPCSTR lpString2 );
|
|---|
| 2792 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpyA( LPSTR lpString1, LPCSTR lpString2 )
|
|---|
| 2793 | {
|
|---|
| 2794 | static FN_lstrcpyA *pfn = 0;
|
|---|
| 2795 | if (!pfn)
|
|---|
| 2796 | kPrf2WrapResolve((void **)&pfn, "lstrcpyA", &g_Kernel32);
|
|---|
| 2797 | return pfn( lpString1, lpString2 );
|
|---|
| 2798 | }
|
|---|
| 2799 |
|
|---|
| 2800 | typedef LPWSTR WINAPI FN_lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 );
|
|---|
| 2801 | __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 )
|
|---|
| 2802 | {
|
|---|
| 2803 | static FN_lstrcpyW *pfn = 0;
|
|---|
| 2804 | if (!pfn)
|
|---|
| 2805 | kPrf2WrapResolve((void **)&pfn, "lstrcpyW", &g_Kernel32);
|
|---|
| 2806 | return pfn( lpString1, lpString2 );
|
|---|
| 2807 | }
|
|---|
| 2808 |
|
|---|
| 2809 | typedef LPSTR WINAPI FN_lstrcatA( LPSTR lpString1, LPCSTR lpString2 );
|
|---|
| 2810 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcatA( LPSTR lpString1, LPCSTR lpString2 )
|
|---|
| 2811 | {
|
|---|
| 2812 | static FN_lstrcatA *pfn = 0;
|
|---|
| 2813 | if (!pfn)
|
|---|
| 2814 | kPrf2WrapResolve((void **)&pfn, "lstrcatA", &g_Kernel32);
|
|---|
| 2815 | return pfn( lpString1, lpString2 );
|
|---|
| 2816 | }
|
|---|
| 2817 |
|
|---|
| 2818 | typedef LPWSTR WINAPI FN_lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 );
|
|---|
| 2819 | __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 )
|
|---|
| 2820 | {
|
|---|
| 2821 | static FN_lstrcatW *pfn = 0;
|
|---|
| 2822 | if (!pfn)
|
|---|
| 2823 | kPrf2WrapResolve((void **)&pfn, "lstrcatW", &g_Kernel32);
|
|---|
| 2824 | return pfn( lpString1, lpString2 );
|
|---|
| 2825 | }
|
|---|
| 2826 |
|
|---|
| 2827 | typedef int WINAPI FN_lstrlenA( LPCSTR lpString );
|
|---|
| 2828 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlenA( LPCSTR lpString )
|
|---|
| 2829 | {
|
|---|
| 2830 | static FN_lstrlenA *pfn = 0;
|
|---|
| 2831 | if (!pfn)
|
|---|
| 2832 | kPrf2WrapResolve((void **)&pfn, "lstrlenA", &g_Kernel32);
|
|---|
| 2833 | return pfn( lpString );
|
|---|
| 2834 | }
|
|---|
| 2835 |
|
|---|
| 2836 | typedef int WINAPI FN_lstrlenW( LPCWSTR lpString );
|
|---|
| 2837 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlenW( LPCWSTR lpString )
|
|---|
| 2838 | {
|
|---|
| 2839 | static FN_lstrlenW *pfn = 0;
|
|---|
| 2840 | if (!pfn)
|
|---|
| 2841 | kPrf2WrapResolve((void **)&pfn, "lstrlenW", &g_Kernel32);
|
|---|
| 2842 | return pfn( lpString );
|
|---|
| 2843 | }
|
|---|
| 2844 |
|
|---|
| 2845 | typedef HFILE WINAPI FN_OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle );
|
|---|
| 2846 | __declspec(dllexport) HFILE WINAPI kPrf2Wrap_OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle )
|
|---|
| 2847 | {
|
|---|
| 2848 | static FN_OpenFile *pfn = 0;
|
|---|
| 2849 | if (!pfn)
|
|---|
| 2850 | kPrf2WrapResolve((void **)&pfn, "OpenFile", &g_Kernel32);
|
|---|
| 2851 | return pfn( lpFileName, lpReOpenBuff, uStyle );
|
|---|
| 2852 | }
|
|---|
| 2853 |
|
|---|
| 2854 | typedef HFILE WINAPI FN__lopen( LPCSTR lpPathName, int iReadWrite );
|
|---|
| 2855 | __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lopen( LPCSTR lpPathName, int iReadWrite )
|
|---|
| 2856 | {
|
|---|
| 2857 | static FN__lopen *pfn = 0;
|
|---|
| 2858 | if (!pfn)
|
|---|
| 2859 | kPrf2WrapResolve((void **)&pfn, "_lopen", &g_Kernel32);
|
|---|
| 2860 | return pfn( lpPathName, iReadWrite );
|
|---|
| 2861 | }
|
|---|
| 2862 |
|
|---|
| 2863 | typedef HFILE WINAPI FN__lcreat( LPCSTR lpPathName, int iAttribute );
|
|---|
| 2864 | __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lcreat( LPCSTR lpPathName, int iAttribute )
|
|---|
| 2865 | {
|
|---|
| 2866 | static FN__lcreat *pfn = 0;
|
|---|
| 2867 | if (!pfn)
|
|---|
| 2868 | kPrf2WrapResolve((void **)&pfn, "_lcreat", &g_Kernel32);
|
|---|
| 2869 | return pfn( lpPathName, iAttribute );
|
|---|
| 2870 | }
|
|---|
| 2871 |
|
|---|
| 2872 | typedef UINT WINAPI FN__lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes );
|
|---|
| 2873 | __declspec(dllexport) UINT WINAPI kPrf2Wrap__lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes )
|
|---|
| 2874 | {
|
|---|
| 2875 | static FN__lread *pfn = 0;
|
|---|
| 2876 | if (!pfn)
|
|---|
| 2877 | kPrf2WrapResolve((void **)&pfn, "_lread", &g_Kernel32);
|
|---|
| 2878 | return pfn( hFile, lpBuffer, uBytes );
|
|---|
| 2879 | }
|
|---|
| 2880 |
|
|---|
| 2881 | typedef UINT WINAPI FN__lwrite( HFILE hFile, LPCCH lpBuffer, UINT uBytes );
|
|---|
| 2882 | __declspec(dllexport) UINT WINAPI kPrf2Wrap__lwrite( HFILE hFile, LPCCH lpBuffer, UINT uBytes )
|
|---|
| 2883 | {
|
|---|
| 2884 | static FN__lwrite *pfn = 0;
|
|---|
| 2885 | if (!pfn)
|
|---|
| 2886 | kPrf2WrapResolve((void **)&pfn, "_lwrite", &g_Kernel32);
|
|---|
| 2887 | return pfn( hFile, lpBuffer, uBytes );
|
|---|
| 2888 | }
|
|---|
| 2889 |
|
|---|
| 2890 | typedef long WINAPI FN__hread( HFILE hFile, LPVOID lpBuffer, long lBytes );
|
|---|
| 2891 | __declspec(dllexport) long WINAPI kPrf2Wrap__hread( HFILE hFile, LPVOID lpBuffer, long lBytes )
|
|---|
| 2892 | {
|
|---|
| 2893 | static FN__hread *pfn = 0;
|
|---|
| 2894 | if (!pfn)
|
|---|
| 2895 | kPrf2WrapResolve((void **)&pfn, "_hread", &g_Kernel32);
|
|---|
| 2896 | return pfn( hFile, lpBuffer, lBytes );
|
|---|
| 2897 | }
|
|---|
| 2898 |
|
|---|
| 2899 | typedef long WINAPI FN__hwrite( HFILE hFile, LPCCH lpBuffer, long lBytes );
|
|---|
| 2900 | __declspec(dllexport) long WINAPI kPrf2Wrap__hwrite( HFILE hFile, LPCCH lpBuffer, long lBytes )
|
|---|
| 2901 | {
|
|---|
| 2902 | static FN__hwrite *pfn = 0;
|
|---|
| 2903 | if (!pfn)
|
|---|
| 2904 | kPrf2WrapResolve((void **)&pfn, "_hwrite", &g_Kernel32);
|
|---|
| 2905 | return pfn( hFile, lpBuffer, lBytes );
|
|---|
| 2906 | }
|
|---|
| 2907 |
|
|---|
| 2908 | typedef HFILE WINAPI FN__lclose( HFILE hFile );
|
|---|
| 2909 | __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lclose( HFILE hFile )
|
|---|
| 2910 | {
|
|---|
| 2911 | static FN__lclose *pfn = 0;
|
|---|
| 2912 | if (!pfn)
|
|---|
| 2913 | kPrf2WrapResolve((void **)&pfn, "_lclose", &g_Kernel32);
|
|---|
| 2914 | return pfn( hFile );
|
|---|
| 2915 | }
|
|---|
| 2916 |
|
|---|
| 2917 | typedef LONG WINAPI FN__llseek( HFILE hFile, LONG lOffset, int iOrigin );
|
|---|
| 2918 | __declspec(dllexport) LONG WINAPI kPrf2Wrap__llseek( HFILE hFile, LONG lOffset, int iOrigin )
|
|---|
| 2919 | {
|
|---|
| 2920 | static FN__llseek *pfn = 0;
|
|---|
| 2921 | if (!pfn)
|
|---|
| 2922 | kPrf2WrapResolve((void **)&pfn, "_llseek", &g_Kernel32);
|
|---|
| 2923 | return pfn( hFile, lOffset, iOrigin );
|
|---|
| 2924 | }
|
|---|
| 2925 |
|
|---|
| 2926 | typedef BOOL WINAPI FN_IsTextUnicode( CONST VOID * lpv, int iSize, LPINT lpiResult );
|
|---|
| 2927 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTextUnicode( CONST VOID * lpv, int iSize, LPINT lpiResult )
|
|---|
| 2928 | {
|
|---|
| 2929 | static FN_IsTextUnicode *pfn = 0;
|
|---|
| 2930 | if (!pfn)
|
|---|
| 2931 | kPrf2WrapResolve((void **)&pfn, "IsTextUnicode", &g_Kernel32);
|
|---|
| 2932 | return pfn( lpv, iSize, lpiResult );
|
|---|
| 2933 | }
|
|---|
| 2934 |
|
|---|
| 2935 | typedef DWORD WINAPI FN_FlsAlloc( PFLS_CALLBACK_FUNCTION lpCallback );
|
|---|
| 2936 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FlsAlloc( PFLS_CALLBACK_FUNCTION lpCallback )
|
|---|
| 2937 | {
|
|---|
| 2938 | static FN_FlsAlloc *pfn = 0;
|
|---|
| 2939 | if (!pfn)
|
|---|
| 2940 | kPrf2WrapResolve((void **)&pfn, "FlsAlloc", &g_Kernel32);
|
|---|
| 2941 | return pfn( lpCallback );
|
|---|
| 2942 | }
|
|---|
| 2943 |
|
|---|
| 2944 | typedef PVOID WINAPI FN_FlsGetValue( DWORD dwFlsIndex );
|
|---|
| 2945 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_FlsGetValue( DWORD dwFlsIndex )
|
|---|
| 2946 | {
|
|---|
| 2947 | static FN_FlsGetValue *pfn = 0;
|
|---|
| 2948 | if (!pfn)
|
|---|
| 2949 | kPrf2WrapResolve((void **)&pfn, "FlsGetValue", &g_Kernel32);
|
|---|
| 2950 | return pfn( dwFlsIndex );
|
|---|
| 2951 | }
|
|---|
| 2952 |
|
|---|
| 2953 | typedef BOOL WINAPI FN_FlsSetValue( DWORD dwFlsIndex, PVOID lpFlsData );
|
|---|
| 2954 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlsSetValue( DWORD dwFlsIndex, PVOID lpFlsData )
|
|---|
| 2955 | {
|
|---|
| 2956 | static FN_FlsSetValue *pfn = 0;
|
|---|
| 2957 | if (!pfn)
|
|---|
| 2958 | kPrf2WrapResolve((void **)&pfn, "FlsSetValue", &g_Kernel32);
|
|---|
| 2959 | return pfn( dwFlsIndex, lpFlsData );
|
|---|
| 2960 | }
|
|---|
| 2961 |
|
|---|
| 2962 | typedef BOOL WINAPI FN_FlsFree( DWORD dwFlsIndex );
|
|---|
| 2963 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlsFree( DWORD dwFlsIndex )
|
|---|
| 2964 | {
|
|---|
| 2965 | static FN_FlsFree *pfn = 0;
|
|---|
| 2966 | if (!pfn)
|
|---|
| 2967 | kPrf2WrapResolve((void **)&pfn, "FlsFree", &g_Kernel32);
|
|---|
| 2968 | return pfn( dwFlsIndex );
|
|---|
| 2969 | }
|
|---|
| 2970 |
|
|---|
| 2971 | typedef DWORD WINAPI FN_TlsAlloc( VOID );
|
|---|
| 2972 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_TlsAlloc( VOID )
|
|---|
| 2973 | {
|
|---|
| 2974 | static FN_TlsAlloc *pfn = 0;
|
|---|
| 2975 | if (!pfn)
|
|---|
| 2976 | kPrf2WrapResolve((void **)&pfn, "TlsAlloc", &g_Kernel32);
|
|---|
| 2977 | return pfn ();
|
|---|
| 2978 | }
|
|---|
| 2979 |
|
|---|
| 2980 | typedef LPVOID WINAPI FN_TlsGetValue( DWORD dwTlsIndex );
|
|---|
| 2981 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_TlsGetValue( DWORD dwTlsIndex )
|
|---|
| 2982 | {
|
|---|
| 2983 | static FN_TlsGetValue *pfn = 0;
|
|---|
| 2984 | if (!pfn)
|
|---|
| 2985 | kPrf2WrapResolve((void **)&pfn, "TlsGetValue", &g_Kernel32);
|
|---|
| 2986 | return pfn( dwTlsIndex );
|
|---|
| 2987 | }
|
|---|
| 2988 |
|
|---|
| 2989 | typedef BOOL WINAPI FN_TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue );
|
|---|
| 2990 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue )
|
|---|
| 2991 | {
|
|---|
| 2992 | static FN_TlsSetValue *pfn = 0;
|
|---|
| 2993 | if (!pfn)
|
|---|
| 2994 | kPrf2WrapResolve((void **)&pfn, "TlsSetValue", &g_Kernel32);
|
|---|
| 2995 | return pfn( dwTlsIndex, lpTlsValue );
|
|---|
| 2996 | }
|
|---|
| 2997 |
|
|---|
| 2998 | typedef BOOL WINAPI FN_TlsFree( DWORD dwTlsIndex );
|
|---|
| 2999 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TlsFree( DWORD dwTlsIndex )
|
|---|
| 3000 | {
|
|---|
| 3001 | static FN_TlsFree *pfn = 0;
|
|---|
| 3002 | if (!pfn)
|
|---|
| 3003 | kPrf2WrapResolve((void **)&pfn, "TlsFree", &g_Kernel32);
|
|---|
| 3004 | return pfn( dwTlsIndex );
|
|---|
| 3005 | }
|
|---|
| 3006 |
|
|---|
| 3007 | typedef DWORD WINAPI FN_SleepEx( DWORD dwMilliseconds, BOOL bAlertable );
|
|---|
| 3008 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SleepEx( DWORD dwMilliseconds, BOOL bAlertable )
|
|---|
| 3009 | {
|
|---|
| 3010 | static FN_SleepEx *pfn = 0;
|
|---|
| 3011 | if (!pfn)
|
|---|
| 3012 | kPrf2WrapResolve((void **)&pfn, "SleepEx", &g_Kernel32);
|
|---|
| 3013 | return pfn( dwMilliseconds, bAlertable );
|
|---|
| 3014 | }
|
|---|
| 3015 |
|
|---|
| 3016 | typedef DWORD WINAPI FN_WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable );
|
|---|
| 3017 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable )
|
|---|
| 3018 | {
|
|---|
| 3019 | static FN_WaitForSingleObjectEx *pfn = 0;
|
|---|
| 3020 | if (!pfn)
|
|---|
| 3021 | kPrf2WrapResolve((void **)&pfn, "WaitForSingleObjectEx", &g_Kernel32);
|
|---|
| 3022 | return pfn( hHandle, dwMilliseconds, bAlertable );
|
|---|
| 3023 | }
|
|---|
| 3024 |
|
|---|
| 3025 | typedef DWORD WINAPI FN_WaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable );
|
|---|
| 3026 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable )
|
|---|
| 3027 | {
|
|---|
| 3028 | static FN_WaitForMultipleObjectsEx *pfn = 0;
|
|---|
| 3029 | if (!pfn)
|
|---|
| 3030 | kPrf2WrapResolve((void **)&pfn, "WaitForMultipleObjectsEx", &g_Kernel32);
|
|---|
| 3031 | return pfn( nCount, lpHandles, bWaitAll, dwMilliseconds, bAlertable );
|
|---|
| 3032 | }
|
|---|
| 3033 |
|
|---|
| 3034 | typedef DWORD WINAPI FN_SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable );
|
|---|
| 3035 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable )
|
|---|
| 3036 | {
|
|---|
| 3037 | static FN_SignalObjectAndWait *pfn = 0;
|
|---|
| 3038 | if (!pfn)
|
|---|
| 3039 | kPrf2WrapResolve((void **)&pfn, "SignalObjectAndWait", &g_Kernel32);
|
|---|
| 3040 | return pfn( hObjectToSignal, hObjectToWaitOn, dwMilliseconds, bAlertable );
|
|---|
| 3041 | }
|
|---|
| 3042 |
|
|---|
| 3043 | typedef BOOL WINAPI FN_ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
|
|---|
| 3044 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
|
|---|
| 3045 | {
|
|---|
| 3046 | static FN_ReadFileEx *pfn = 0;
|
|---|
| 3047 | if (!pfn)
|
|---|
| 3048 | kPrf2WrapResolve((void **)&pfn, "ReadFileEx", &g_Kernel32);
|
|---|
| 3049 | return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine );
|
|---|
| 3050 | }
|
|---|
| 3051 |
|
|---|
| 3052 | typedef BOOL WINAPI FN_WriteFileEx( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
|
|---|
| 3053 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFileEx( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
|
|---|
| 3054 | {
|
|---|
| 3055 | static FN_WriteFileEx *pfn = 0;
|
|---|
| 3056 | if (!pfn)
|
|---|
| 3057 | kPrf2WrapResolve((void **)&pfn, "WriteFileEx", &g_Kernel32);
|
|---|
| 3058 | return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpOverlapped, lpCompletionRoutine );
|
|---|
| 3059 | }
|
|---|
| 3060 |
|
|---|
| 3061 | typedef BOOL WINAPI FN_BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext );
|
|---|
| 3062 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext )
|
|---|
| 3063 | {
|
|---|
| 3064 | static FN_BackupRead *pfn = 0;
|
|---|
| 3065 | if (!pfn)
|
|---|
| 3066 | kPrf2WrapResolve((void **)&pfn, "BackupRead", &g_Kernel32);
|
|---|
| 3067 | return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, bAbort, bProcessSecurity, lpContext );
|
|---|
| 3068 | }
|
|---|
| 3069 |
|
|---|
| 3070 | typedef BOOL WINAPI FN_BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID * lpContext );
|
|---|
| 3071 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID * lpContext )
|
|---|
| 3072 | {
|
|---|
| 3073 | static FN_BackupSeek *pfn = 0;
|
|---|
| 3074 | if (!pfn)
|
|---|
| 3075 | kPrf2WrapResolve((void **)&pfn, "BackupSeek", &g_Kernel32);
|
|---|
| 3076 | return pfn( hFile, dwLowBytesToSeek, dwHighBytesToSeek, lpdwLowByteSeeked, lpdwHighByteSeeked, lpContext );
|
|---|
| 3077 | }
|
|---|
| 3078 |
|
|---|
| 3079 | typedef BOOL WINAPI FN_BackupWrite( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext );
|
|---|
| 3080 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupWrite( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext )
|
|---|
| 3081 | {
|
|---|
| 3082 | static FN_BackupWrite *pfn = 0;
|
|---|
| 3083 | if (!pfn)
|
|---|
| 3084 | kPrf2WrapResolve((void **)&pfn, "BackupWrite", &g_Kernel32);
|
|---|
| 3085 | return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, bAbort, bProcessSecurity, lpContext );
|
|---|
| 3086 | }
|
|---|
| 3087 |
|
|---|
| 3088 | typedef BOOL WINAPI FN_ReadFileScatter( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped );
|
|---|
| 3089 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFileScatter( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped )
|
|---|
| 3090 | {
|
|---|
| 3091 | static FN_ReadFileScatter *pfn = 0;
|
|---|
| 3092 | if (!pfn)
|
|---|
| 3093 | kPrf2WrapResolve((void **)&pfn, "ReadFileScatter", &g_Kernel32);
|
|---|
| 3094 | return pfn( hFile, aSegmentArray, nNumberOfBytesToRead, lpReserved, lpOverlapped );
|
|---|
| 3095 | }
|
|---|
| 3096 |
|
|---|
| 3097 | typedef BOOL WINAPI FN_WriteFileGather( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped );
|
|---|
| 3098 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFileGather( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped )
|
|---|
| 3099 | {
|
|---|
| 3100 | static FN_WriteFileGather *pfn = 0;
|
|---|
| 3101 | if (!pfn)
|
|---|
| 3102 | kPrf2WrapResolve((void **)&pfn, "WriteFileGather", &g_Kernel32);
|
|---|
| 3103 | return pfn( hFile, aSegmentArray, nNumberOfBytesToWrite, lpReserved, lpOverlapped );
|
|---|
| 3104 | }
|
|---|
| 3105 |
|
|---|
| 3106 | typedef HANDLE WINAPI FN_CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName );
|
|---|
| 3107 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName )
|
|---|
| 3108 | {
|
|---|
| 3109 | static FN_CreateMutexA *pfn = 0;
|
|---|
| 3110 | if (!pfn)
|
|---|
| 3111 | kPrf2WrapResolve((void **)&pfn, "CreateMutexA", &g_Kernel32);
|
|---|
| 3112 | return pfn( lpMutexAttributes, bInitialOwner, lpName );
|
|---|
| 3113 | }
|
|---|
| 3114 |
|
|---|
| 3115 | typedef HANDLE WINAPI FN_CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName );
|
|---|
| 3116 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName )
|
|---|
| 3117 | {
|
|---|
| 3118 | static FN_CreateMutexW *pfn = 0;
|
|---|
| 3119 | if (!pfn)
|
|---|
| 3120 | kPrf2WrapResolve((void **)&pfn, "CreateMutexW", &g_Kernel32);
|
|---|
| 3121 | return pfn( lpMutexAttributes, bInitialOwner, lpName );
|
|---|
| 3122 | }
|
|---|
| 3123 |
|
|---|
| 3124 | typedef HANDLE WINAPI FN_OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
|
|---|
| 3125 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
|
|---|
| 3126 | {
|
|---|
| 3127 | static FN_OpenMutexA *pfn = 0;
|
|---|
| 3128 | if (!pfn)
|
|---|
| 3129 | kPrf2WrapResolve((void **)&pfn, "OpenMutexA", &g_Kernel32);
|
|---|
| 3130 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3131 | }
|
|---|
| 3132 |
|
|---|
| 3133 | typedef HANDLE WINAPI FN_OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
|
|---|
| 3134 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
|
|---|
| 3135 | {
|
|---|
| 3136 | static FN_OpenMutexW *pfn = 0;
|
|---|
| 3137 | if (!pfn)
|
|---|
| 3138 | kPrf2WrapResolve((void **)&pfn, "OpenMutexW", &g_Kernel32);
|
|---|
| 3139 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3140 | }
|
|---|
| 3141 |
|
|---|
| 3142 | typedef HANDLE WINAPI FN_CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName );
|
|---|
| 3143 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName )
|
|---|
| 3144 | {
|
|---|
| 3145 | static FN_CreateEventA *pfn = 0;
|
|---|
| 3146 | if (!pfn)
|
|---|
| 3147 | kPrf2WrapResolve((void **)&pfn, "CreateEventA", &g_Kernel32);
|
|---|
| 3148 | return pfn( lpEventAttributes, bManualReset, bInitialState, lpName );
|
|---|
| 3149 | }
|
|---|
| 3150 |
|
|---|
| 3151 | typedef HANDLE WINAPI FN_CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName );
|
|---|
| 3152 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName )
|
|---|
| 3153 | {
|
|---|
| 3154 | static FN_CreateEventW *pfn = 0;
|
|---|
| 3155 | if (!pfn)
|
|---|
| 3156 | kPrf2WrapResolve((void **)&pfn, "CreateEventW", &g_Kernel32);
|
|---|
| 3157 | return pfn( lpEventAttributes, bManualReset, bInitialState, lpName );
|
|---|
| 3158 | }
|
|---|
| 3159 |
|
|---|
| 3160 | typedef HANDLE WINAPI FN_OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
|
|---|
| 3161 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
|
|---|
| 3162 | {
|
|---|
| 3163 | static FN_OpenEventA *pfn = 0;
|
|---|
| 3164 | if (!pfn)
|
|---|
| 3165 | kPrf2WrapResolve((void **)&pfn, "OpenEventA", &g_Kernel32);
|
|---|
| 3166 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3167 | }
|
|---|
| 3168 |
|
|---|
| 3169 | typedef HANDLE WINAPI FN_OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
|
|---|
| 3170 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
|
|---|
| 3171 | {
|
|---|
| 3172 | static FN_OpenEventW *pfn = 0;
|
|---|
| 3173 | if (!pfn)
|
|---|
| 3174 | kPrf2WrapResolve((void **)&pfn, "OpenEventW", &g_Kernel32);
|
|---|
| 3175 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3176 | }
|
|---|
| 3177 |
|
|---|
| 3178 | typedef HANDLE WINAPI FN_CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName );
|
|---|
| 3179 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName )
|
|---|
| 3180 | {
|
|---|
| 3181 | static FN_CreateSemaphoreA *pfn = 0;
|
|---|
| 3182 | if (!pfn)
|
|---|
| 3183 | kPrf2WrapResolve((void **)&pfn, "CreateSemaphoreA", &g_Kernel32);
|
|---|
| 3184 | return pfn( lpSemaphoreAttributes, lInitialCount, lMaximumCount, lpName );
|
|---|
| 3185 | }
|
|---|
| 3186 |
|
|---|
| 3187 | typedef HANDLE WINAPI FN_CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName );
|
|---|
| 3188 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName )
|
|---|
| 3189 | {
|
|---|
| 3190 | static FN_CreateSemaphoreW *pfn = 0;
|
|---|
| 3191 | if (!pfn)
|
|---|
| 3192 | kPrf2WrapResolve((void **)&pfn, "CreateSemaphoreW", &g_Kernel32);
|
|---|
| 3193 | return pfn( lpSemaphoreAttributes, lInitialCount, lMaximumCount, lpName );
|
|---|
| 3194 | }
|
|---|
| 3195 |
|
|---|
| 3196 | typedef HANDLE WINAPI FN_OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
|
|---|
| 3197 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
|
|---|
| 3198 | {
|
|---|
| 3199 | static FN_OpenSemaphoreA *pfn = 0;
|
|---|
| 3200 | if (!pfn)
|
|---|
| 3201 | kPrf2WrapResolve((void **)&pfn, "OpenSemaphoreA", &g_Kernel32);
|
|---|
| 3202 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3203 | }
|
|---|
| 3204 |
|
|---|
| 3205 | typedef HANDLE WINAPI FN_OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
|
|---|
| 3206 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
|
|---|
| 3207 | {
|
|---|
| 3208 | static FN_OpenSemaphoreW *pfn = 0;
|
|---|
| 3209 | if (!pfn)
|
|---|
| 3210 | kPrf2WrapResolve((void **)&pfn, "OpenSemaphoreW", &g_Kernel32);
|
|---|
| 3211 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3212 | }
|
|---|
| 3213 |
|
|---|
| 3214 | typedef HANDLE WINAPI FN_CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName );
|
|---|
| 3215 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName )
|
|---|
| 3216 | {
|
|---|
| 3217 | static FN_CreateWaitableTimerA *pfn = 0;
|
|---|
| 3218 | if (!pfn)
|
|---|
| 3219 | kPrf2WrapResolve((void **)&pfn, "CreateWaitableTimerA", &g_Kernel32);
|
|---|
| 3220 | return pfn( lpTimerAttributes, bManualReset, lpTimerName );
|
|---|
| 3221 | }
|
|---|
| 3222 |
|
|---|
| 3223 | typedef HANDLE WINAPI FN_CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName );
|
|---|
| 3224 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName )
|
|---|
| 3225 | {
|
|---|
| 3226 | static FN_CreateWaitableTimerW *pfn = 0;
|
|---|
| 3227 | if (!pfn)
|
|---|
| 3228 | kPrf2WrapResolve((void **)&pfn, "CreateWaitableTimerW", &g_Kernel32);
|
|---|
| 3229 | return pfn( lpTimerAttributes, bManualReset, lpTimerName );
|
|---|
| 3230 | }
|
|---|
| 3231 |
|
|---|
| 3232 | typedef HANDLE WINAPI FN_OpenWaitableTimerA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName );
|
|---|
| 3233 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenWaitableTimerA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName )
|
|---|
| 3234 | {
|
|---|
| 3235 | static FN_OpenWaitableTimerA *pfn = 0;
|
|---|
| 3236 | if (!pfn)
|
|---|
| 3237 | kPrf2WrapResolve((void **)&pfn, "OpenWaitableTimerA", &g_Kernel32);
|
|---|
| 3238 | return pfn( dwDesiredAccess, bInheritHandle, lpTimerName );
|
|---|
| 3239 | }
|
|---|
| 3240 |
|
|---|
| 3241 | typedef HANDLE WINAPI FN_OpenWaitableTimerW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName );
|
|---|
| 3242 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenWaitableTimerW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName )
|
|---|
| 3243 | {
|
|---|
| 3244 | static FN_OpenWaitableTimerW *pfn = 0;
|
|---|
| 3245 | if (!pfn)
|
|---|
| 3246 | kPrf2WrapResolve((void **)&pfn, "OpenWaitableTimerW", &g_Kernel32);
|
|---|
| 3247 | return pfn( dwDesiredAccess, bInheritHandle, lpTimerName );
|
|---|
| 3248 | }
|
|---|
| 3249 |
|
|---|
| 3250 | typedef BOOL WINAPI FN_SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER * lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume );
|
|---|
| 3251 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER * lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume )
|
|---|
| 3252 | {
|
|---|
| 3253 | static FN_SetWaitableTimer *pfn = 0;
|
|---|
| 3254 | if (!pfn)
|
|---|
| 3255 | kPrf2WrapResolve((void **)&pfn, "SetWaitableTimer", &g_Kernel32);
|
|---|
| 3256 | return pfn( hTimer, lpDueTime, lPeriod, pfnCompletionRoutine, lpArgToCompletionRoutine, fResume );
|
|---|
| 3257 | }
|
|---|
| 3258 |
|
|---|
| 3259 | typedef BOOL WINAPI FN_CancelWaitableTimer( HANDLE hTimer );
|
|---|
| 3260 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelWaitableTimer( HANDLE hTimer )
|
|---|
| 3261 | {
|
|---|
| 3262 | static FN_CancelWaitableTimer *pfn = 0;
|
|---|
| 3263 | if (!pfn)
|
|---|
| 3264 | kPrf2WrapResolve((void **)&pfn, "CancelWaitableTimer", &g_Kernel32);
|
|---|
| 3265 | return pfn( hTimer );
|
|---|
| 3266 | }
|
|---|
| 3267 |
|
|---|
| 3268 | typedef HANDLE WINAPI FN_CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName );
|
|---|
| 3269 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName )
|
|---|
| 3270 | {
|
|---|
| 3271 | static FN_CreateFileMappingA *pfn = 0;
|
|---|
| 3272 | if (!pfn)
|
|---|
| 3273 | kPrf2WrapResolve((void **)&pfn, "CreateFileMappingA", &g_Kernel32);
|
|---|
| 3274 | return pfn( hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName );
|
|---|
| 3275 | }
|
|---|
| 3276 |
|
|---|
| 3277 | typedef HANDLE WINAPI FN_CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName );
|
|---|
| 3278 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName )
|
|---|
| 3279 | {
|
|---|
| 3280 | static FN_CreateFileMappingW *pfn = 0;
|
|---|
| 3281 | if (!pfn)
|
|---|
| 3282 | kPrf2WrapResolve((void **)&pfn, "CreateFileMappingW", &g_Kernel32);
|
|---|
| 3283 | return pfn( hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName );
|
|---|
| 3284 | }
|
|---|
| 3285 |
|
|---|
| 3286 | typedef HANDLE WINAPI FN_OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
|
|---|
| 3287 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
|
|---|
| 3288 | {
|
|---|
| 3289 | static FN_OpenFileMappingA *pfn = 0;
|
|---|
| 3290 | if (!pfn)
|
|---|
| 3291 | kPrf2WrapResolve((void **)&pfn, "OpenFileMappingA", &g_Kernel32);
|
|---|
| 3292 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3293 | }
|
|---|
| 3294 |
|
|---|
| 3295 | typedef HANDLE WINAPI FN_OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
|
|---|
| 3296 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
|
|---|
| 3297 | {
|
|---|
| 3298 | static FN_OpenFileMappingW *pfn = 0;
|
|---|
| 3299 | if (!pfn)
|
|---|
| 3300 | kPrf2WrapResolve((void **)&pfn, "OpenFileMappingW", &g_Kernel32);
|
|---|
| 3301 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 3302 | }
|
|---|
| 3303 |
|
|---|
| 3304 | typedef DWORD WINAPI FN_GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer );
|
|---|
| 3305 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer )
|
|---|
| 3306 | {
|
|---|
| 3307 | static FN_GetLogicalDriveStringsA *pfn = 0;
|
|---|
| 3308 | if (!pfn)
|
|---|
| 3309 | kPrf2WrapResolve((void **)&pfn, "GetLogicalDriveStringsA", &g_Kernel32);
|
|---|
| 3310 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 3311 | }
|
|---|
| 3312 |
|
|---|
| 3313 | typedef DWORD WINAPI FN_GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer );
|
|---|
| 3314 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer )
|
|---|
| 3315 | {
|
|---|
| 3316 | static FN_GetLogicalDriveStringsW *pfn = 0;
|
|---|
| 3317 | if (!pfn)
|
|---|
| 3318 | kPrf2WrapResolve((void **)&pfn, "GetLogicalDriveStringsW", &g_Kernel32);
|
|---|
| 3319 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 3320 | }
|
|---|
| 3321 |
|
|---|
| 3322 | typedef HANDLE WINAPI FN_CreateMemoryResourceNotification( MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType );
|
|---|
| 3323 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMemoryResourceNotification( MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType )
|
|---|
| 3324 | {
|
|---|
| 3325 | static FN_CreateMemoryResourceNotification *pfn = 0;
|
|---|
| 3326 | if (!pfn)
|
|---|
| 3327 | kPrf2WrapResolve((void **)&pfn, "CreateMemoryResourceNotification", &g_Kernel32);
|
|---|
| 3328 | return pfn( NotificationType );
|
|---|
| 3329 | }
|
|---|
| 3330 |
|
|---|
| 3331 | typedef BOOL WINAPI FN_QueryMemoryResourceNotification( HANDLE ResourceNotificationHandle, PBOOL ResourceState );
|
|---|
| 3332 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryMemoryResourceNotification( HANDLE ResourceNotificationHandle, PBOOL ResourceState )
|
|---|
| 3333 | {
|
|---|
| 3334 | static FN_QueryMemoryResourceNotification *pfn = 0;
|
|---|
| 3335 | if (!pfn)
|
|---|
| 3336 | kPrf2WrapResolve((void **)&pfn, "QueryMemoryResourceNotification", &g_Kernel32);
|
|---|
| 3337 | return pfn( ResourceNotificationHandle, ResourceState );
|
|---|
| 3338 | }
|
|---|
| 3339 |
|
|---|
| 3340 | typedef HMODULE WINAPI FN_LoadLibraryA( LPCSTR lpLibFileName );
|
|---|
| 3341 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryA( LPCSTR lpLibFileName )
|
|---|
| 3342 | {
|
|---|
| 3343 | static FN_LoadLibraryA *pfn = 0;
|
|---|
| 3344 | if (!pfn)
|
|---|
| 3345 | kPrf2WrapResolve((void **)&pfn, "LoadLibraryA", &g_Kernel32);
|
|---|
| 3346 | return pfn( lpLibFileName );
|
|---|
| 3347 | }
|
|---|
| 3348 |
|
|---|
| 3349 | typedef HMODULE WINAPI FN_LoadLibraryW( LPCWSTR lpLibFileName );
|
|---|
| 3350 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryW( LPCWSTR lpLibFileName )
|
|---|
| 3351 | {
|
|---|
| 3352 | static FN_LoadLibraryW *pfn = 0;
|
|---|
| 3353 | if (!pfn)
|
|---|
| 3354 | kPrf2WrapResolve((void **)&pfn, "LoadLibraryW", &g_Kernel32);
|
|---|
| 3355 | return pfn( lpLibFileName );
|
|---|
| 3356 | }
|
|---|
| 3357 |
|
|---|
| 3358 | typedef HMODULE WINAPI FN_LoadLibraryExA( LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags );
|
|---|
| 3359 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryExA( LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags )
|
|---|
| 3360 | {
|
|---|
| 3361 | static FN_LoadLibraryExA *pfn = 0;
|
|---|
| 3362 | if (!pfn)
|
|---|
| 3363 | kPrf2WrapResolve((void **)&pfn, "LoadLibraryExA", &g_Kernel32);
|
|---|
| 3364 | return pfn( lpLibFileName, hFile, dwFlags );
|
|---|
| 3365 | }
|
|---|
| 3366 |
|
|---|
| 3367 | typedef HMODULE WINAPI FN_LoadLibraryExW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags );
|
|---|
| 3368 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryExW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags )
|
|---|
| 3369 | {
|
|---|
| 3370 | static FN_LoadLibraryExW *pfn = 0;
|
|---|
| 3371 | if (!pfn)
|
|---|
| 3372 | kPrf2WrapResolve((void **)&pfn, "LoadLibraryExW", &g_Kernel32);
|
|---|
| 3373 | return pfn( lpLibFileName, hFile, dwFlags );
|
|---|
| 3374 | }
|
|---|
| 3375 |
|
|---|
| 3376 | typedef DWORD WINAPI FN_GetModuleFileNameA( HMODULE hModule, LPCH lpFilename, DWORD nSize );
|
|---|
| 3377 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetModuleFileNameA( HMODULE hModule, LPCH lpFilename, DWORD nSize )
|
|---|
| 3378 | {
|
|---|
| 3379 | static FN_GetModuleFileNameA *pfn = 0;
|
|---|
| 3380 | if (!pfn)
|
|---|
| 3381 | kPrf2WrapResolve((void **)&pfn, "GetModuleFileNameA", &g_Kernel32);
|
|---|
| 3382 | return pfn( hModule, lpFilename, nSize );
|
|---|
| 3383 | }
|
|---|
| 3384 |
|
|---|
| 3385 | typedef DWORD WINAPI FN_GetModuleFileNameW( HMODULE hModule, LPWCH lpFilename, DWORD nSize );
|
|---|
| 3386 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetModuleFileNameW( HMODULE hModule, LPWCH lpFilename, DWORD nSize )
|
|---|
| 3387 | {
|
|---|
| 3388 | static FN_GetModuleFileNameW *pfn = 0;
|
|---|
| 3389 | if (!pfn)
|
|---|
| 3390 | kPrf2WrapResolve((void **)&pfn, "GetModuleFileNameW", &g_Kernel32);
|
|---|
| 3391 | return pfn( hModule, lpFilename, nSize );
|
|---|
| 3392 | }
|
|---|
| 3393 |
|
|---|
| 3394 | typedef HMODULE WINAPI FN_GetModuleHandleA( LPCSTR lpModuleName );
|
|---|
| 3395 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_GetModuleHandleA( LPCSTR lpModuleName )
|
|---|
| 3396 | {
|
|---|
| 3397 | static FN_GetModuleHandleA *pfn = 0;
|
|---|
| 3398 | if (!pfn)
|
|---|
| 3399 | kPrf2WrapResolve((void **)&pfn, "GetModuleHandleA", &g_Kernel32);
|
|---|
| 3400 | return pfn( lpModuleName );
|
|---|
| 3401 | }
|
|---|
| 3402 |
|
|---|
| 3403 | typedef HMODULE WINAPI FN_GetModuleHandleW( LPCWSTR lpModuleName );
|
|---|
| 3404 | __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_GetModuleHandleW( LPCWSTR lpModuleName )
|
|---|
| 3405 | {
|
|---|
| 3406 | static FN_GetModuleHandleW *pfn = 0;
|
|---|
| 3407 | if (!pfn)
|
|---|
| 3408 | kPrf2WrapResolve((void **)&pfn, "GetModuleHandleW", &g_Kernel32);
|
|---|
| 3409 | return pfn( lpModuleName );
|
|---|
| 3410 | }
|
|---|
| 3411 |
|
|---|
| 3412 | typedef BOOL WINAPI FN_GetModuleHandleExA( DWORD dwFlags, LPCSTR lpModuleName, HMODULE * phModule );
|
|---|
| 3413 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetModuleHandleExA( DWORD dwFlags, LPCSTR lpModuleName, HMODULE * phModule )
|
|---|
| 3414 | {
|
|---|
| 3415 | static FN_GetModuleHandleExA *pfn = 0;
|
|---|
| 3416 | if (!pfn)
|
|---|
| 3417 | kPrf2WrapResolve((void **)&pfn, "GetModuleHandleExA", &g_Kernel32);
|
|---|
| 3418 | return pfn( dwFlags, lpModuleName, phModule );
|
|---|
| 3419 | }
|
|---|
| 3420 |
|
|---|
| 3421 | typedef BOOL WINAPI FN_GetModuleHandleExW( DWORD dwFlags, LPCWSTR lpModuleName, HMODULE * phModule );
|
|---|
| 3422 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetModuleHandleExW( DWORD dwFlags, LPCWSTR lpModuleName, HMODULE * phModule )
|
|---|
| 3423 | {
|
|---|
| 3424 | static FN_GetModuleHandleExW *pfn = 0;
|
|---|
| 3425 | if (!pfn)
|
|---|
| 3426 | kPrf2WrapResolve((void **)&pfn, "GetModuleHandleExW", &g_Kernel32);
|
|---|
| 3427 | return pfn( dwFlags, lpModuleName, phModule );
|
|---|
| 3428 | }
|
|---|
| 3429 |
|
|---|
| 3430 | typedef BOOL WINAPI FN_NeedCurrentDirectoryForExePathA( LPCSTR ExeName );
|
|---|
| 3431 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NeedCurrentDirectoryForExePathA( LPCSTR ExeName )
|
|---|
| 3432 | {
|
|---|
| 3433 | static FN_NeedCurrentDirectoryForExePathA *pfn = 0;
|
|---|
| 3434 | if (!pfn)
|
|---|
| 3435 | kPrf2WrapResolve((void **)&pfn, "NeedCurrentDirectoryForExePathA", &g_Kernel32);
|
|---|
| 3436 | return pfn( ExeName );
|
|---|
| 3437 | }
|
|---|
| 3438 |
|
|---|
| 3439 | typedef BOOL WINAPI FN_NeedCurrentDirectoryForExePathW( LPCWSTR ExeName );
|
|---|
| 3440 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NeedCurrentDirectoryForExePathW( LPCWSTR ExeName )
|
|---|
| 3441 | {
|
|---|
| 3442 | static FN_NeedCurrentDirectoryForExePathW *pfn = 0;
|
|---|
| 3443 | if (!pfn)
|
|---|
| 3444 | kPrf2WrapResolve((void **)&pfn, "NeedCurrentDirectoryForExePathW", &g_Kernel32);
|
|---|
| 3445 | return pfn( ExeName );
|
|---|
| 3446 | }
|
|---|
| 3447 |
|
|---|
| 3448 | typedef BOOL WINAPI FN_CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 3449 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 3450 | {
|
|---|
| 3451 | static FN_CreateProcessA *pfn = 0;
|
|---|
| 3452 | if (!pfn)
|
|---|
| 3453 | kPrf2WrapResolve((void **)&pfn, "CreateProcessA", &g_Kernel32);
|
|---|
| 3454 | return pfn( lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 3455 | }
|
|---|
| 3456 |
|
|---|
| 3457 | typedef BOOL WINAPI FN_CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 3458 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 3459 | {
|
|---|
| 3460 | static FN_CreateProcessW *pfn = 0;
|
|---|
| 3461 | if (!pfn)
|
|---|
| 3462 | kPrf2WrapResolve((void **)&pfn, "CreateProcessW", &g_Kernel32);
|
|---|
| 3463 | return pfn( lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 3464 | }
|
|---|
| 3465 |
|
|---|
| 3466 | typedef BOOL WINAPI FN_SetProcessShutdownParameters( DWORD dwLevel, DWORD dwFlags );
|
|---|
| 3467 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessShutdownParameters( DWORD dwLevel, DWORD dwFlags )
|
|---|
| 3468 | {
|
|---|
| 3469 | static FN_SetProcessShutdownParameters *pfn = 0;
|
|---|
| 3470 | if (!pfn)
|
|---|
| 3471 | kPrf2WrapResolve((void **)&pfn, "SetProcessShutdownParameters", &g_Kernel32);
|
|---|
| 3472 | return pfn( dwLevel, dwFlags );
|
|---|
| 3473 | }
|
|---|
| 3474 |
|
|---|
| 3475 | typedef BOOL WINAPI FN_GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags );
|
|---|
| 3476 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags )
|
|---|
| 3477 | {
|
|---|
| 3478 | static FN_GetProcessShutdownParameters *pfn = 0;
|
|---|
| 3479 | if (!pfn)
|
|---|
| 3480 | kPrf2WrapResolve((void **)&pfn, "GetProcessShutdownParameters", &g_Kernel32);
|
|---|
| 3481 | return pfn( lpdwLevel, lpdwFlags );
|
|---|
| 3482 | }
|
|---|
| 3483 |
|
|---|
| 3484 | typedef DWORD WINAPI FN_GetProcessVersion( DWORD ProcessId );
|
|---|
| 3485 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessVersion( DWORD ProcessId )
|
|---|
| 3486 | {
|
|---|
| 3487 | static FN_GetProcessVersion *pfn = 0;
|
|---|
| 3488 | if (!pfn)
|
|---|
| 3489 | kPrf2WrapResolve((void **)&pfn, "GetProcessVersion", &g_Kernel32);
|
|---|
| 3490 | return pfn( ProcessId );
|
|---|
| 3491 | }
|
|---|
| 3492 |
|
|---|
| 3493 | typedef VOID WINAPI FN_FatalAppExitA( UINT uAction, LPCSTR lpMessageText );
|
|---|
| 3494 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalAppExitA( UINT uAction, LPCSTR lpMessageText )
|
|---|
| 3495 | {
|
|---|
| 3496 | static FN_FatalAppExitA *pfn = 0;
|
|---|
| 3497 | if (!pfn)
|
|---|
| 3498 | kPrf2WrapResolve((void **)&pfn, "FatalAppExitA", &g_Kernel32);
|
|---|
| 3499 | pfn( uAction, lpMessageText );
|
|---|
| 3500 | }
|
|---|
| 3501 |
|
|---|
| 3502 | typedef VOID WINAPI FN_FatalAppExitW( UINT uAction, LPCWSTR lpMessageText );
|
|---|
| 3503 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalAppExitW( UINT uAction, LPCWSTR lpMessageText )
|
|---|
| 3504 | {
|
|---|
| 3505 | static FN_FatalAppExitW *pfn = 0;
|
|---|
| 3506 | if (!pfn)
|
|---|
| 3507 | kPrf2WrapResolve((void **)&pfn, "FatalAppExitW", &g_Kernel32);
|
|---|
| 3508 | pfn( uAction, lpMessageText );
|
|---|
| 3509 | }
|
|---|
| 3510 |
|
|---|
| 3511 | typedef VOID WINAPI FN_GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo );
|
|---|
| 3512 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo )
|
|---|
| 3513 | {
|
|---|
| 3514 | static FN_GetStartupInfoA *pfn = 0;
|
|---|
| 3515 | if (!pfn)
|
|---|
| 3516 | kPrf2WrapResolve((void **)&pfn, "GetStartupInfoA", &g_Kernel32);
|
|---|
| 3517 | pfn( lpStartupInfo );
|
|---|
| 3518 | }
|
|---|
| 3519 |
|
|---|
| 3520 | typedef VOID WINAPI FN_GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo );
|
|---|
| 3521 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo )
|
|---|
| 3522 | {
|
|---|
| 3523 | static FN_GetStartupInfoW *pfn = 0;
|
|---|
| 3524 | if (!pfn)
|
|---|
| 3525 | kPrf2WrapResolve((void **)&pfn, "GetStartupInfoW", &g_Kernel32);
|
|---|
| 3526 | pfn( lpStartupInfo );
|
|---|
| 3527 | }
|
|---|
| 3528 |
|
|---|
| 3529 | typedef LPSTR WINAPI FN_GetCommandLineA( VOID );
|
|---|
| 3530 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_GetCommandLineA( VOID )
|
|---|
| 3531 | {
|
|---|
| 3532 | static FN_GetCommandLineA *pfn = 0;
|
|---|
| 3533 | if (!pfn)
|
|---|
| 3534 | kPrf2WrapResolve((void **)&pfn, "GetCommandLineA", &g_Kernel32);
|
|---|
| 3535 | return pfn ();
|
|---|
| 3536 | }
|
|---|
| 3537 |
|
|---|
| 3538 | typedef LPWSTR WINAPI FN_GetCommandLineW( VOID );
|
|---|
| 3539 | __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_GetCommandLineW( VOID )
|
|---|
| 3540 | {
|
|---|
| 3541 | static FN_GetCommandLineW *pfn = 0;
|
|---|
| 3542 | if (!pfn)
|
|---|
| 3543 | kPrf2WrapResolve((void **)&pfn, "GetCommandLineW", &g_Kernel32);
|
|---|
| 3544 | return pfn ();
|
|---|
| 3545 | }
|
|---|
| 3546 |
|
|---|
| 3547 | typedef DWORD WINAPI FN_GetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize );
|
|---|
| 3548 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize )
|
|---|
| 3549 | {
|
|---|
| 3550 | static FN_GetEnvironmentVariableA *pfn = 0;
|
|---|
| 3551 | if (!pfn)
|
|---|
| 3552 | kPrf2WrapResolve((void **)&pfn, "GetEnvironmentVariableA", &g_Kernel32);
|
|---|
| 3553 | return pfn( lpName, lpBuffer, nSize );
|
|---|
| 3554 | }
|
|---|
| 3555 |
|
|---|
| 3556 | typedef DWORD WINAPI FN_GetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize );
|
|---|
| 3557 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize )
|
|---|
| 3558 | {
|
|---|
| 3559 | static FN_GetEnvironmentVariableW *pfn = 0;
|
|---|
| 3560 | if (!pfn)
|
|---|
| 3561 | kPrf2WrapResolve((void **)&pfn, "GetEnvironmentVariableW", &g_Kernel32);
|
|---|
| 3562 | return pfn( lpName, lpBuffer, nSize );
|
|---|
| 3563 | }
|
|---|
| 3564 |
|
|---|
| 3565 | typedef BOOL WINAPI FN_SetEnvironmentVariableA( LPCSTR lpName, LPCSTR lpValue );
|
|---|
| 3566 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentVariableA( LPCSTR lpName, LPCSTR lpValue )
|
|---|
| 3567 | {
|
|---|
| 3568 | static FN_SetEnvironmentVariableA *pfn = 0;
|
|---|
| 3569 | if (!pfn)
|
|---|
| 3570 | kPrf2WrapResolve((void **)&pfn, "SetEnvironmentVariableA", &g_Kernel32);
|
|---|
| 3571 | return pfn( lpName, lpValue );
|
|---|
| 3572 | }
|
|---|
| 3573 |
|
|---|
| 3574 | typedef BOOL WINAPI FN_SetEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpValue );
|
|---|
| 3575 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpValue )
|
|---|
| 3576 | {
|
|---|
| 3577 | static FN_SetEnvironmentVariableW *pfn = 0;
|
|---|
| 3578 | if (!pfn)
|
|---|
| 3579 | kPrf2WrapResolve((void **)&pfn, "SetEnvironmentVariableW", &g_Kernel32);
|
|---|
| 3580 | return pfn( lpName, lpValue );
|
|---|
| 3581 | }
|
|---|
| 3582 |
|
|---|
| 3583 | typedef DWORD WINAPI FN_ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize );
|
|---|
| 3584 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize )
|
|---|
| 3585 | {
|
|---|
| 3586 | static FN_ExpandEnvironmentStringsA *pfn = 0;
|
|---|
| 3587 | if (!pfn)
|
|---|
| 3588 | kPrf2WrapResolve((void **)&pfn, "ExpandEnvironmentStringsA", &g_Kernel32);
|
|---|
| 3589 | return pfn( lpSrc, lpDst, nSize );
|
|---|
| 3590 | }
|
|---|
| 3591 |
|
|---|
| 3592 | typedef DWORD WINAPI FN_ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize );
|
|---|
| 3593 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize )
|
|---|
| 3594 | {
|
|---|
| 3595 | static FN_ExpandEnvironmentStringsW *pfn = 0;
|
|---|
| 3596 | if (!pfn)
|
|---|
| 3597 | kPrf2WrapResolve((void **)&pfn, "ExpandEnvironmentStringsW", &g_Kernel32);
|
|---|
| 3598 | return pfn( lpSrc, lpDst, nSize );
|
|---|
| 3599 | }
|
|---|
| 3600 |
|
|---|
| 3601 | typedef DWORD WINAPI FN_GetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize );
|
|---|
| 3602 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize )
|
|---|
| 3603 | {
|
|---|
| 3604 | static FN_GetFirmwareEnvironmentVariableA *pfn = 0;
|
|---|
| 3605 | if (!pfn)
|
|---|
| 3606 | kPrf2WrapResolve((void **)&pfn, "GetFirmwareEnvironmentVariableA", &g_Kernel32);
|
|---|
| 3607 | return pfn( lpName, lpGuid, pBuffer, nSize );
|
|---|
| 3608 | }
|
|---|
| 3609 |
|
|---|
| 3610 | typedef DWORD WINAPI FN_GetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize );
|
|---|
| 3611 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize )
|
|---|
| 3612 | {
|
|---|
| 3613 | static FN_GetFirmwareEnvironmentVariableW *pfn = 0;
|
|---|
| 3614 | if (!pfn)
|
|---|
| 3615 | kPrf2WrapResolve((void **)&pfn, "GetFirmwareEnvironmentVariableW", &g_Kernel32);
|
|---|
| 3616 | return pfn( lpName, lpGuid, pBuffer, nSize );
|
|---|
| 3617 | }
|
|---|
| 3618 |
|
|---|
| 3619 | typedef BOOL WINAPI FN_SetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize );
|
|---|
| 3620 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize )
|
|---|
| 3621 | {
|
|---|
| 3622 | static FN_SetFirmwareEnvironmentVariableA *pfn = 0;
|
|---|
| 3623 | if (!pfn)
|
|---|
| 3624 | kPrf2WrapResolve((void **)&pfn, "SetFirmwareEnvironmentVariableA", &g_Kernel32);
|
|---|
| 3625 | return pfn( lpName, lpGuid, pValue, nSize );
|
|---|
| 3626 | }
|
|---|
| 3627 |
|
|---|
| 3628 | typedef BOOL WINAPI FN_SetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize );
|
|---|
| 3629 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize )
|
|---|
| 3630 | {
|
|---|
| 3631 | static FN_SetFirmwareEnvironmentVariableW *pfn = 0;
|
|---|
| 3632 | if (!pfn)
|
|---|
| 3633 | kPrf2WrapResolve((void **)&pfn, "SetFirmwareEnvironmentVariableW", &g_Kernel32);
|
|---|
| 3634 | return pfn( lpName, lpGuid, pValue, nSize );
|
|---|
| 3635 | }
|
|---|
| 3636 |
|
|---|
| 3637 | typedef VOID WINAPI FN_OutputDebugStringA( LPCSTR lpOutputString );
|
|---|
| 3638 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_OutputDebugStringA( LPCSTR lpOutputString )
|
|---|
| 3639 | {
|
|---|
| 3640 | static FN_OutputDebugStringA *pfn = 0;
|
|---|
| 3641 | if (!pfn)
|
|---|
| 3642 | kPrf2WrapResolve((void **)&pfn, "OutputDebugStringA", &g_Kernel32);
|
|---|
| 3643 | pfn( lpOutputString );
|
|---|
| 3644 | }
|
|---|
| 3645 |
|
|---|
| 3646 | typedef VOID WINAPI FN_OutputDebugStringW( LPCWSTR lpOutputString );
|
|---|
| 3647 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_OutputDebugStringW( LPCWSTR lpOutputString )
|
|---|
| 3648 | {
|
|---|
| 3649 | static FN_OutputDebugStringW *pfn = 0;
|
|---|
| 3650 | if (!pfn)
|
|---|
| 3651 | kPrf2WrapResolve((void **)&pfn, "OutputDebugStringW", &g_Kernel32);
|
|---|
| 3652 | pfn( lpOutputString );
|
|---|
| 3653 | }
|
|---|
| 3654 |
|
|---|
| 3655 | typedef HRSRC WINAPI FN_FindResourceA( HMODULE hModule, LPCSTR lpName, LPCSTR lpType );
|
|---|
| 3656 | __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceA( HMODULE hModule, LPCSTR lpName, LPCSTR lpType )
|
|---|
| 3657 | {
|
|---|
| 3658 | static FN_FindResourceA *pfn = 0;
|
|---|
| 3659 | if (!pfn)
|
|---|
| 3660 | kPrf2WrapResolve((void **)&pfn, "FindResourceA", &g_Kernel32);
|
|---|
| 3661 | return pfn( hModule, lpName, lpType );
|
|---|
| 3662 | }
|
|---|
| 3663 |
|
|---|
| 3664 | typedef HRSRC WINAPI FN_FindResourceW( HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType );
|
|---|
| 3665 | __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceW( HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType )
|
|---|
| 3666 | {
|
|---|
| 3667 | static FN_FindResourceW *pfn = 0;
|
|---|
| 3668 | if (!pfn)
|
|---|
| 3669 | kPrf2WrapResolve((void **)&pfn, "FindResourceW", &g_Kernel32);
|
|---|
| 3670 | return pfn( hModule, lpName, lpType );
|
|---|
| 3671 | }
|
|---|
| 3672 |
|
|---|
| 3673 | typedef HRSRC WINAPI FN_FindResourceExA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage );
|
|---|
| 3674 | __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceExA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage )
|
|---|
| 3675 | {
|
|---|
| 3676 | static FN_FindResourceExA *pfn = 0;
|
|---|
| 3677 | if (!pfn)
|
|---|
| 3678 | kPrf2WrapResolve((void **)&pfn, "FindResourceExA", &g_Kernel32);
|
|---|
| 3679 | return pfn( hModule, lpType, lpName, wLanguage );
|
|---|
| 3680 | }
|
|---|
| 3681 |
|
|---|
| 3682 | typedef HRSRC WINAPI FN_FindResourceExW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage );
|
|---|
| 3683 | __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceExW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage )
|
|---|
| 3684 | {
|
|---|
| 3685 | static FN_FindResourceExW *pfn = 0;
|
|---|
| 3686 | if (!pfn)
|
|---|
| 3687 | kPrf2WrapResolve((void **)&pfn, "FindResourceExW", &g_Kernel32);
|
|---|
| 3688 | return pfn( hModule, lpType, lpName, wLanguage );
|
|---|
| 3689 | }
|
|---|
| 3690 |
|
|---|
| 3691 | typedef BOOL WINAPI FN_EnumResourceTypesA( HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3692 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceTypesA( HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3693 | {
|
|---|
| 3694 | static FN_EnumResourceTypesA *pfn = 0;
|
|---|
| 3695 | if (!pfn)
|
|---|
| 3696 | kPrf2WrapResolve((void **)&pfn, "EnumResourceTypesA", &g_Kernel32);
|
|---|
| 3697 | return pfn( hModule, lpEnumFunc, lParam );
|
|---|
| 3698 | }
|
|---|
| 3699 |
|
|---|
| 3700 | typedef BOOL WINAPI FN_EnumResourceTypesW( HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3701 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceTypesW( HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3702 | {
|
|---|
| 3703 | static FN_EnumResourceTypesW *pfn = 0;
|
|---|
| 3704 | if (!pfn)
|
|---|
| 3705 | kPrf2WrapResolve((void **)&pfn, "EnumResourceTypesW", &g_Kernel32);
|
|---|
| 3706 | return pfn( hModule, lpEnumFunc, lParam );
|
|---|
| 3707 | }
|
|---|
| 3708 |
|
|---|
| 3709 | typedef BOOL WINAPI FN_EnumResourceNamesA( HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3710 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceNamesA( HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3711 | {
|
|---|
| 3712 | static FN_EnumResourceNamesA *pfn = 0;
|
|---|
| 3713 | if (!pfn)
|
|---|
| 3714 | kPrf2WrapResolve((void **)&pfn, "EnumResourceNamesA", &g_Kernel32);
|
|---|
| 3715 | return pfn( hModule, lpType, lpEnumFunc, lParam );
|
|---|
| 3716 | }
|
|---|
| 3717 |
|
|---|
| 3718 | typedef BOOL WINAPI FN_EnumResourceNamesW( HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3719 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceNamesW( HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3720 | {
|
|---|
| 3721 | static FN_EnumResourceNamesW *pfn = 0;
|
|---|
| 3722 | if (!pfn)
|
|---|
| 3723 | kPrf2WrapResolve((void **)&pfn, "EnumResourceNamesW", &g_Kernel32);
|
|---|
| 3724 | return pfn( hModule, lpType, lpEnumFunc, lParam );
|
|---|
| 3725 | }
|
|---|
| 3726 |
|
|---|
| 3727 | typedef BOOL WINAPI FN_EnumResourceLanguagesA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3728 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceLanguagesA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3729 | {
|
|---|
| 3730 | static FN_EnumResourceLanguagesA *pfn = 0;
|
|---|
| 3731 | if (!pfn)
|
|---|
| 3732 | kPrf2WrapResolve((void **)&pfn, "EnumResourceLanguagesA", &g_Kernel32);
|
|---|
| 3733 | return pfn( hModule, lpType, lpName, lpEnumFunc, lParam );
|
|---|
| 3734 | }
|
|---|
| 3735 |
|
|---|
| 3736 | typedef BOOL WINAPI FN_EnumResourceLanguagesW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam );
|
|---|
| 3737 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceLanguagesW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam )
|
|---|
| 3738 | {
|
|---|
| 3739 | static FN_EnumResourceLanguagesW *pfn = 0;
|
|---|
| 3740 | if (!pfn)
|
|---|
| 3741 | kPrf2WrapResolve((void **)&pfn, "EnumResourceLanguagesW", &g_Kernel32);
|
|---|
| 3742 | return pfn( hModule, lpType, lpName, lpEnumFunc, lParam );
|
|---|
| 3743 | }
|
|---|
| 3744 |
|
|---|
| 3745 | typedef HANDLE WINAPI FN_BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources );
|
|---|
| 3746 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources )
|
|---|
| 3747 | {
|
|---|
| 3748 | static FN_BeginUpdateResourceA *pfn = 0;
|
|---|
| 3749 | if (!pfn)
|
|---|
| 3750 | kPrf2WrapResolve((void **)&pfn, "BeginUpdateResourceA", &g_Kernel32);
|
|---|
| 3751 | return pfn( pFileName, bDeleteExistingResources );
|
|---|
| 3752 | }
|
|---|
| 3753 |
|
|---|
| 3754 | typedef HANDLE WINAPI FN_BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources );
|
|---|
| 3755 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources )
|
|---|
| 3756 | {
|
|---|
| 3757 | static FN_BeginUpdateResourceW *pfn = 0;
|
|---|
| 3758 | if (!pfn)
|
|---|
| 3759 | kPrf2WrapResolve((void **)&pfn, "BeginUpdateResourceW", &g_Kernel32);
|
|---|
| 3760 | return pfn( pFileName, bDeleteExistingResources );
|
|---|
| 3761 | }
|
|---|
| 3762 |
|
|---|
| 3763 | typedef BOOL WINAPI FN_UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb );
|
|---|
| 3764 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb )
|
|---|
| 3765 | {
|
|---|
| 3766 | static FN_UpdateResourceA *pfn = 0;
|
|---|
| 3767 | if (!pfn)
|
|---|
| 3768 | kPrf2WrapResolve((void **)&pfn, "UpdateResourceA", &g_Kernel32);
|
|---|
| 3769 | return pfn( hUpdate, lpType, lpName, wLanguage, lpData, cb );
|
|---|
| 3770 | }
|
|---|
| 3771 |
|
|---|
| 3772 | typedef BOOL WINAPI FN_UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb );
|
|---|
| 3773 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb )
|
|---|
| 3774 | {
|
|---|
| 3775 | static FN_UpdateResourceW *pfn = 0;
|
|---|
| 3776 | if (!pfn)
|
|---|
| 3777 | kPrf2WrapResolve((void **)&pfn, "UpdateResourceW", &g_Kernel32);
|
|---|
| 3778 | return pfn( hUpdate, lpType, lpName, wLanguage, lpData, cb );
|
|---|
| 3779 | }
|
|---|
| 3780 |
|
|---|
| 3781 | typedef BOOL WINAPI FN_EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard );
|
|---|
| 3782 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard )
|
|---|
| 3783 | {
|
|---|
| 3784 | static FN_EndUpdateResourceA *pfn = 0;
|
|---|
| 3785 | if (!pfn)
|
|---|
| 3786 | kPrf2WrapResolve((void **)&pfn, "EndUpdateResourceA", &g_Kernel32);
|
|---|
| 3787 | return pfn( hUpdate, fDiscard );
|
|---|
| 3788 | }
|
|---|
| 3789 |
|
|---|
| 3790 | typedef BOOL WINAPI FN_EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard );
|
|---|
| 3791 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard )
|
|---|
| 3792 | {
|
|---|
| 3793 | static FN_EndUpdateResourceW *pfn = 0;
|
|---|
| 3794 | if (!pfn)
|
|---|
| 3795 | kPrf2WrapResolve((void **)&pfn, "EndUpdateResourceW", &g_Kernel32);
|
|---|
| 3796 | return pfn( hUpdate, fDiscard );
|
|---|
| 3797 | }
|
|---|
| 3798 |
|
|---|
| 3799 | typedef ATOM WINAPI FN_GlobalAddAtomA( LPCSTR lpString );
|
|---|
| 3800 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalAddAtomA( LPCSTR lpString )
|
|---|
| 3801 | {
|
|---|
| 3802 | static FN_GlobalAddAtomA *pfn = 0;
|
|---|
| 3803 | if (!pfn)
|
|---|
| 3804 | kPrf2WrapResolve((void **)&pfn, "GlobalAddAtomA", &g_Kernel32);
|
|---|
| 3805 | return pfn( lpString );
|
|---|
| 3806 | }
|
|---|
| 3807 |
|
|---|
| 3808 | typedef ATOM WINAPI FN_GlobalAddAtomW( LPCWSTR lpString );
|
|---|
| 3809 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalAddAtomW( LPCWSTR lpString )
|
|---|
| 3810 | {
|
|---|
| 3811 | static FN_GlobalAddAtomW *pfn = 0;
|
|---|
| 3812 | if (!pfn)
|
|---|
| 3813 | kPrf2WrapResolve((void **)&pfn, "GlobalAddAtomW", &g_Kernel32);
|
|---|
| 3814 | return pfn( lpString );
|
|---|
| 3815 | }
|
|---|
| 3816 |
|
|---|
| 3817 | typedef ATOM WINAPI FN_GlobalFindAtomA( LPCSTR lpString );
|
|---|
| 3818 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalFindAtomA( LPCSTR lpString )
|
|---|
| 3819 | {
|
|---|
| 3820 | static FN_GlobalFindAtomA *pfn = 0;
|
|---|
| 3821 | if (!pfn)
|
|---|
| 3822 | kPrf2WrapResolve((void **)&pfn, "GlobalFindAtomA", &g_Kernel32);
|
|---|
| 3823 | return pfn( lpString );
|
|---|
| 3824 | }
|
|---|
| 3825 |
|
|---|
| 3826 | typedef ATOM WINAPI FN_GlobalFindAtomW( LPCWSTR lpString );
|
|---|
| 3827 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalFindAtomW( LPCWSTR lpString )
|
|---|
| 3828 | {
|
|---|
| 3829 | static FN_GlobalFindAtomW *pfn = 0;
|
|---|
| 3830 | if (!pfn)
|
|---|
| 3831 | kPrf2WrapResolve((void **)&pfn, "GlobalFindAtomW", &g_Kernel32);
|
|---|
| 3832 | return pfn( lpString );
|
|---|
| 3833 | }
|
|---|
| 3834 |
|
|---|
| 3835 | typedef UINT WINAPI FN_GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize );
|
|---|
| 3836 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize )
|
|---|
| 3837 | {
|
|---|
| 3838 | static FN_GlobalGetAtomNameA *pfn = 0;
|
|---|
| 3839 | if (!pfn)
|
|---|
| 3840 | kPrf2WrapResolve((void **)&pfn, "GlobalGetAtomNameA", &g_Kernel32);
|
|---|
| 3841 | return pfn( nAtom, lpBuffer, nSize );
|
|---|
| 3842 | }
|
|---|
| 3843 |
|
|---|
| 3844 | typedef UINT WINAPI FN_GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize );
|
|---|
| 3845 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize )
|
|---|
| 3846 | {
|
|---|
| 3847 | static FN_GlobalGetAtomNameW *pfn = 0;
|
|---|
| 3848 | if (!pfn)
|
|---|
| 3849 | kPrf2WrapResolve((void **)&pfn, "GlobalGetAtomNameW", &g_Kernel32);
|
|---|
| 3850 | return pfn( nAtom, lpBuffer, nSize );
|
|---|
| 3851 | }
|
|---|
| 3852 |
|
|---|
| 3853 | typedef ATOM WINAPI FN_AddAtomA( LPCSTR lpString );
|
|---|
| 3854 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_AddAtomA( LPCSTR lpString )
|
|---|
| 3855 | {
|
|---|
| 3856 | static FN_AddAtomA *pfn = 0;
|
|---|
| 3857 | if (!pfn)
|
|---|
| 3858 | kPrf2WrapResolve((void **)&pfn, "AddAtomA", &g_Kernel32);
|
|---|
| 3859 | return pfn( lpString );
|
|---|
| 3860 | }
|
|---|
| 3861 |
|
|---|
| 3862 | typedef ATOM WINAPI FN_AddAtomW( LPCWSTR lpString );
|
|---|
| 3863 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_AddAtomW( LPCWSTR lpString )
|
|---|
| 3864 | {
|
|---|
| 3865 | static FN_AddAtomW *pfn = 0;
|
|---|
| 3866 | if (!pfn)
|
|---|
| 3867 | kPrf2WrapResolve((void **)&pfn, "AddAtomW", &g_Kernel32);
|
|---|
| 3868 | return pfn( lpString );
|
|---|
| 3869 | }
|
|---|
| 3870 |
|
|---|
| 3871 | typedef ATOM WINAPI FN_FindAtomA( LPCSTR lpString );
|
|---|
| 3872 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_FindAtomA( LPCSTR lpString )
|
|---|
| 3873 | {
|
|---|
| 3874 | static FN_FindAtomA *pfn = 0;
|
|---|
| 3875 | if (!pfn)
|
|---|
| 3876 | kPrf2WrapResolve((void **)&pfn, "FindAtomA", &g_Kernel32);
|
|---|
| 3877 | return pfn( lpString );
|
|---|
| 3878 | }
|
|---|
| 3879 |
|
|---|
| 3880 | typedef ATOM WINAPI FN_FindAtomW( LPCWSTR lpString );
|
|---|
| 3881 | __declspec(dllexport) ATOM WINAPI kPrf2Wrap_FindAtomW( LPCWSTR lpString )
|
|---|
| 3882 | {
|
|---|
| 3883 | static FN_FindAtomW *pfn = 0;
|
|---|
| 3884 | if (!pfn)
|
|---|
| 3885 | kPrf2WrapResolve((void **)&pfn, "FindAtomW", &g_Kernel32);
|
|---|
| 3886 | return pfn( lpString );
|
|---|
| 3887 | }
|
|---|
| 3888 |
|
|---|
| 3889 | typedef UINT WINAPI FN_GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize );
|
|---|
| 3890 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize )
|
|---|
| 3891 | {
|
|---|
| 3892 | static FN_GetAtomNameA *pfn = 0;
|
|---|
| 3893 | if (!pfn)
|
|---|
| 3894 | kPrf2WrapResolve((void **)&pfn, "GetAtomNameA", &g_Kernel32);
|
|---|
| 3895 | return pfn( nAtom, lpBuffer, nSize );
|
|---|
| 3896 | }
|
|---|
| 3897 |
|
|---|
| 3898 | typedef UINT WINAPI FN_GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize );
|
|---|
| 3899 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize )
|
|---|
| 3900 | {
|
|---|
| 3901 | static FN_GetAtomNameW *pfn = 0;
|
|---|
| 3902 | if (!pfn)
|
|---|
| 3903 | kPrf2WrapResolve((void **)&pfn, "GetAtomNameW", &g_Kernel32);
|
|---|
| 3904 | return pfn( nAtom, lpBuffer, nSize );
|
|---|
| 3905 | }
|
|---|
| 3906 |
|
|---|
| 3907 | typedef UINT WINAPI FN_GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault );
|
|---|
| 3908 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault )
|
|---|
| 3909 | {
|
|---|
| 3910 | static FN_GetProfileIntA *pfn = 0;
|
|---|
| 3911 | if (!pfn)
|
|---|
| 3912 | kPrf2WrapResolve((void **)&pfn, "GetProfileIntA", &g_Kernel32);
|
|---|
| 3913 | return pfn( lpAppName, lpKeyName, nDefault );
|
|---|
| 3914 | }
|
|---|
| 3915 |
|
|---|
| 3916 | typedef UINT WINAPI FN_GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault );
|
|---|
| 3917 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault )
|
|---|
| 3918 | {
|
|---|
| 3919 | static FN_GetProfileIntW *pfn = 0;
|
|---|
| 3920 | if (!pfn)
|
|---|
| 3921 | kPrf2WrapResolve((void **)&pfn, "GetProfileIntW", &g_Kernel32);
|
|---|
| 3922 | return pfn( lpAppName, lpKeyName, nDefault );
|
|---|
| 3923 | }
|
|---|
| 3924 |
|
|---|
| 3925 | typedef DWORD WINAPI FN_GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize );
|
|---|
| 3926 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize )
|
|---|
| 3927 | {
|
|---|
| 3928 | static FN_GetProfileStringA *pfn = 0;
|
|---|
| 3929 | if (!pfn)
|
|---|
| 3930 | kPrf2WrapResolve((void **)&pfn, "GetProfileStringA", &g_Kernel32);
|
|---|
| 3931 | return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize );
|
|---|
| 3932 | }
|
|---|
| 3933 |
|
|---|
| 3934 | typedef DWORD WINAPI FN_GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize );
|
|---|
| 3935 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize )
|
|---|
| 3936 | {
|
|---|
| 3937 | static FN_GetProfileStringW *pfn = 0;
|
|---|
| 3938 | if (!pfn)
|
|---|
| 3939 | kPrf2WrapResolve((void **)&pfn, "GetProfileStringW", &g_Kernel32);
|
|---|
| 3940 | return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize );
|
|---|
| 3941 | }
|
|---|
| 3942 |
|
|---|
| 3943 | typedef BOOL WINAPI FN_WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString );
|
|---|
| 3944 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString )
|
|---|
| 3945 | {
|
|---|
| 3946 | static FN_WriteProfileStringA *pfn = 0;
|
|---|
| 3947 | if (!pfn)
|
|---|
| 3948 | kPrf2WrapResolve((void **)&pfn, "WriteProfileStringA", &g_Kernel32);
|
|---|
| 3949 | return pfn( lpAppName, lpKeyName, lpString );
|
|---|
| 3950 | }
|
|---|
| 3951 |
|
|---|
| 3952 | typedef BOOL WINAPI FN_WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString );
|
|---|
| 3953 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString )
|
|---|
| 3954 | {
|
|---|
| 3955 | static FN_WriteProfileStringW *pfn = 0;
|
|---|
| 3956 | if (!pfn)
|
|---|
| 3957 | kPrf2WrapResolve((void **)&pfn, "WriteProfileStringW", &g_Kernel32);
|
|---|
| 3958 | return pfn( lpAppName, lpKeyName, lpString );
|
|---|
| 3959 | }
|
|---|
| 3960 |
|
|---|
| 3961 | typedef DWORD WINAPI FN_GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize );
|
|---|
| 3962 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize )
|
|---|
| 3963 | {
|
|---|
| 3964 | static FN_GetProfileSectionA *pfn = 0;
|
|---|
| 3965 | if (!pfn)
|
|---|
| 3966 | kPrf2WrapResolve((void **)&pfn, "GetProfileSectionA", &g_Kernel32);
|
|---|
| 3967 | return pfn( lpAppName, lpReturnedString, nSize );
|
|---|
| 3968 | }
|
|---|
| 3969 |
|
|---|
| 3970 | typedef DWORD WINAPI FN_GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize );
|
|---|
| 3971 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize )
|
|---|
| 3972 | {
|
|---|
| 3973 | static FN_GetProfileSectionW *pfn = 0;
|
|---|
| 3974 | if (!pfn)
|
|---|
| 3975 | kPrf2WrapResolve((void **)&pfn, "GetProfileSectionW", &g_Kernel32);
|
|---|
| 3976 | return pfn( lpAppName, lpReturnedString, nSize );
|
|---|
| 3977 | }
|
|---|
| 3978 |
|
|---|
| 3979 | typedef BOOL WINAPI FN_WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString );
|
|---|
| 3980 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString )
|
|---|
| 3981 | {
|
|---|
| 3982 | static FN_WriteProfileSectionA *pfn = 0;
|
|---|
| 3983 | if (!pfn)
|
|---|
| 3984 | kPrf2WrapResolve((void **)&pfn, "WriteProfileSectionA", &g_Kernel32);
|
|---|
| 3985 | return pfn( lpAppName, lpString );
|
|---|
| 3986 | }
|
|---|
| 3987 |
|
|---|
| 3988 | typedef BOOL WINAPI FN_WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString );
|
|---|
| 3989 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString )
|
|---|
| 3990 | {
|
|---|
| 3991 | static FN_WriteProfileSectionW *pfn = 0;
|
|---|
| 3992 | if (!pfn)
|
|---|
| 3993 | kPrf2WrapResolve((void **)&pfn, "WriteProfileSectionW", &g_Kernel32);
|
|---|
| 3994 | return pfn( lpAppName, lpString );
|
|---|
| 3995 | }
|
|---|
| 3996 |
|
|---|
| 3997 | typedef UINT WINAPI FN_GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName );
|
|---|
| 3998 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName )
|
|---|
| 3999 | {
|
|---|
| 4000 | static FN_GetPrivateProfileIntA *pfn = 0;
|
|---|
| 4001 | if (!pfn)
|
|---|
| 4002 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileIntA", &g_Kernel32);
|
|---|
| 4003 | return pfn( lpAppName, lpKeyName, nDefault, lpFileName );
|
|---|
| 4004 | }
|
|---|
| 4005 |
|
|---|
| 4006 | typedef UINT WINAPI FN_GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName );
|
|---|
| 4007 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName )
|
|---|
| 4008 | {
|
|---|
| 4009 | static FN_GetPrivateProfileIntW *pfn = 0;
|
|---|
| 4010 | if (!pfn)
|
|---|
| 4011 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileIntW", &g_Kernel32);
|
|---|
| 4012 | return pfn( lpAppName, lpKeyName, nDefault, lpFileName );
|
|---|
| 4013 | }
|
|---|
| 4014 |
|
|---|
| 4015 | typedef DWORD WINAPI FN_GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName );
|
|---|
| 4016 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName )
|
|---|
| 4017 | {
|
|---|
| 4018 | static FN_GetPrivateProfileStringA *pfn = 0;
|
|---|
| 4019 | if (!pfn)
|
|---|
| 4020 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStringA", &g_Kernel32);
|
|---|
| 4021 | return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName );
|
|---|
| 4022 | }
|
|---|
| 4023 |
|
|---|
| 4024 | typedef DWORD WINAPI FN_GetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName );
|
|---|
| 4025 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName )
|
|---|
| 4026 | {
|
|---|
| 4027 | static FN_GetPrivateProfileStringW *pfn = 0;
|
|---|
| 4028 | if (!pfn)
|
|---|
| 4029 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStringW", &g_Kernel32);
|
|---|
| 4030 | return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName );
|
|---|
| 4031 | }
|
|---|
| 4032 |
|
|---|
| 4033 | typedef BOOL WINAPI FN_WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName );
|
|---|
| 4034 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName )
|
|---|
| 4035 | {
|
|---|
| 4036 | static FN_WritePrivateProfileStringA *pfn = 0;
|
|---|
| 4037 | if (!pfn)
|
|---|
| 4038 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStringA", &g_Kernel32);
|
|---|
| 4039 | return pfn( lpAppName, lpKeyName, lpString, lpFileName );
|
|---|
| 4040 | }
|
|---|
| 4041 |
|
|---|
| 4042 | typedef BOOL WINAPI FN_WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName );
|
|---|
| 4043 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName )
|
|---|
| 4044 | {
|
|---|
| 4045 | static FN_WritePrivateProfileStringW *pfn = 0;
|
|---|
| 4046 | if (!pfn)
|
|---|
| 4047 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStringW", &g_Kernel32);
|
|---|
| 4048 | return pfn( lpAppName, lpKeyName, lpString, lpFileName );
|
|---|
| 4049 | }
|
|---|
| 4050 |
|
|---|
| 4051 | typedef DWORD WINAPI FN_GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName );
|
|---|
| 4052 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName )
|
|---|
| 4053 | {
|
|---|
| 4054 | static FN_GetPrivateProfileSectionA *pfn = 0;
|
|---|
| 4055 | if (!pfn)
|
|---|
| 4056 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionA", &g_Kernel32);
|
|---|
| 4057 | return pfn( lpAppName, lpReturnedString, nSize, lpFileName );
|
|---|
| 4058 | }
|
|---|
| 4059 |
|
|---|
| 4060 | typedef DWORD WINAPI FN_GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName );
|
|---|
| 4061 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName )
|
|---|
| 4062 | {
|
|---|
| 4063 | static FN_GetPrivateProfileSectionW *pfn = 0;
|
|---|
| 4064 | if (!pfn)
|
|---|
| 4065 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionW", &g_Kernel32);
|
|---|
| 4066 | return pfn( lpAppName, lpReturnedString, nSize, lpFileName );
|
|---|
| 4067 | }
|
|---|
| 4068 |
|
|---|
| 4069 | typedef BOOL WINAPI FN_WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName );
|
|---|
| 4070 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName )
|
|---|
| 4071 | {
|
|---|
| 4072 | static FN_WritePrivateProfileSectionA *pfn = 0;
|
|---|
| 4073 | if (!pfn)
|
|---|
| 4074 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileSectionA", &g_Kernel32);
|
|---|
| 4075 | return pfn( lpAppName, lpString, lpFileName );
|
|---|
| 4076 | }
|
|---|
| 4077 |
|
|---|
| 4078 | typedef BOOL WINAPI FN_WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName );
|
|---|
| 4079 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName )
|
|---|
| 4080 | {
|
|---|
| 4081 | static FN_WritePrivateProfileSectionW *pfn = 0;
|
|---|
| 4082 | if (!pfn)
|
|---|
| 4083 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileSectionW", &g_Kernel32);
|
|---|
| 4084 | return pfn( lpAppName, lpString, lpFileName );
|
|---|
| 4085 | }
|
|---|
| 4086 |
|
|---|
| 4087 | typedef DWORD WINAPI FN_GetPrivateProfileSectionNamesA( LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName );
|
|---|
| 4088 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionNamesA( LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName )
|
|---|
| 4089 | {
|
|---|
| 4090 | static FN_GetPrivateProfileSectionNamesA *pfn = 0;
|
|---|
| 4091 | if (!pfn)
|
|---|
| 4092 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionNamesA", &g_Kernel32);
|
|---|
| 4093 | return pfn( lpszReturnBuffer, nSize, lpFileName );
|
|---|
| 4094 | }
|
|---|
| 4095 |
|
|---|
| 4096 | typedef DWORD WINAPI FN_GetPrivateProfileSectionNamesW( LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName );
|
|---|
| 4097 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionNamesW( LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName )
|
|---|
| 4098 | {
|
|---|
| 4099 | static FN_GetPrivateProfileSectionNamesW *pfn = 0;
|
|---|
| 4100 | if (!pfn)
|
|---|
| 4101 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionNamesW", &g_Kernel32);
|
|---|
| 4102 | return pfn( lpszReturnBuffer, nSize, lpFileName );
|
|---|
| 4103 | }
|
|---|
| 4104 |
|
|---|
| 4105 | typedef BOOL WINAPI FN_GetPrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile );
|
|---|
| 4106 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile )
|
|---|
| 4107 | {
|
|---|
| 4108 | static FN_GetPrivateProfileStructA *pfn = 0;
|
|---|
| 4109 | if (!pfn)
|
|---|
| 4110 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStructA", &g_Kernel32);
|
|---|
| 4111 | return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
|
|---|
| 4112 | }
|
|---|
| 4113 |
|
|---|
| 4114 | typedef BOOL WINAPI FN_GetPrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile );
|
|---|
| 4115 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile )
|
|---|
| 4116 | {
|
|---|
| 4117 | static FN_GetPrivateProfileStructW *pfn = 0;
|
|---|
| 4118 | if (!pfn)
|
|---|
| 4119 | kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStructW", &g_Kernel32);
|
|---|
| 4120 | return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
|
|---|
| 4121 | }
|
|---|
| 4122 |
|
|---|
| 4123 | typedef BOOL WINAPI FN_WritePrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile );
|
|---|
| 4124 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile )
|
|---|
| 4125 | {
|
|---|
| 4126 | static FN_WritePrivateProfileStructA *pfn = 0;
|
|---|
| 4127 | if (!pfn)
|
|---|
| 4128 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStructA", &g_Kernel32);
|
|---|
| 4129 | return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
|
|---|
| 4130 | }
|
|---|
| 4131 |
|
|---|
| 4132 | typedef BOOL WINAPI FN_WritePrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile );
|
|---|
| 4133 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile )
|
|---|
| 4134 | {
|
|---|
| 4135 | static FN_WritePrivateProfileStructW *pfn = 0;
|
|---|
| 4136 | if (!pfn)
|
|---|
| 4137 | kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStructW", &g_Kernel32);
|
|---|
| 4138 | return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
|
|---|
| 4139 | }
|
|---|
| 4140 |
|
|---|
| 4141 | typedef UINT WINAPI FN_GetDriveTypeA( LPCSTR lpRootPathName );
|
|---|
| 4142 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetDriveTypeA( LPCSTR lpRootPathName )
|
|---|
| 4143 | {
|
|---|
| 4144 | static FN_GetDriveTypeA *pfn = 0;
|
|---|
| 4145 | if (!pfn)
|
|---|
| 4146 | kPrf2WrapResolve((void **)&pfn, "GetDriveTypeA", &g_Kernel32);
|
|---|
| 4147 | return pfn( lpRootPathName );
|
|---|
| 4148 | }
|
|---|
| 4149 |
|
|---|
| 4150 | typedef UINT WINAPI FN_GetDriveTypeW( LPCWSTR lpRootPathName );
|
|---|
| 4151 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetDriveTypeW( LPCWSTR lpRootPathName )
|
|---|
| 4152 | {
|
|---|
| 4153 | static FN_GetDriveTypeW *pfn = 0;
|
|---|
| 4154 | if (!pfn)
|
|---|
| 4155 | kPrf2WrapResolve((void **)&pfn, "GetDriveTypeW", &g_Kernel32);
|
|---|
| 4156 | return pfn( lpRootPathName );
|
|---|
| 4157 | }
|
|---|
| 4158 |
|
|---|
| 4159 | typedef UINT WINAPI FN_GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize );
|
|---|
| 4160 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize )
|
|---|
| 4161 | {
|
|---|
| 4162 | static FN_GetSystemDirectoryA *pfn = 0;
|
|---|
| 4163 | if (!pfn)
|
|---|
| 4164 | kPrf2WrapResolve((void **)&pfn, "GetSystemDirectoryA", &g_Kernel32);
|
|---|
| 4165 | return pfn( lpBuffer, uSize );
|
|---|
| 4166 | }
|
|---|
| 4167 |
|
|---|
| 4168 | typedef UINT WINAPI FN_GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize );
|
|---|
| 4169 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize )
|
|---|
| 4170 | {
|
|---|
| 4171 | static FN_GetSystemDirectoryW *pfn = 0;
|
|---|
| 4172 | if (!pfn)
|
|---|
| 4173 | kPrf2WrapResolve((void **)&pfn, "GetSystemDirectoryW", &g_Kernel32);
|
|---|
| 4174 | return pfn( lpBuffer, uSize );
|
|---|
| 4175 | }
|
|---|
| 4176 |
|
|---|
| 4177 | typedef DWORD WINAPI FN_GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer );
|
|---|
| 4178 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer )
|
|---|
| 4179 | {
|
|---|
| 4180 | static FN_GetTempPathA *pfn = 0;
|
|---|
| 4181 | if (!pfn)
|
|---|
| 4182 | kPrf2WrapResolve((void **)&pfn, "GetTempPathA", &g_Kernel32);
|
|---|
| 4183 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4184 | }
|
|---|
| 4185 |
|
|---|
| 4186 | typedef DWORD WINAPI FN_GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer );
|
|---|
| 4187 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer )
|
|---|
| 4188 | {
|
|---|
| 4189 | static FN_GetTempPathW *pfn = 0;
|
|---|
| 4190 | if (!pfn)
|
|---|
| 4191 | kPrf2WrapResolve((void **)&pfn, "GetTempPathW", &g_Kernel32);
|
|---|
| 4192 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4193 | }
|
|---|
| 4194 |
|
|---|
| 4195 | typedef UINT WINAPI FN_GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName );
|
|---|
| 4196 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName )
|
|---|
| 4197 | {
|
|---|
| 4198 | static FN_GetTempFileNameA *pfn = 0;
|
|---|
| 4199 | if (!pfn)
|
|---|
| 4200 | kPrf2WrapResolve((void **)&pfn, "GetTempFileNameA", &g_Kernel32);
|
|---|
| 4201 | return pfn( lpPathName, lpPrefixString, uUnique, lpTempFileName );
|
|---|
| 4202 | }
|
|---|
| 4203 |
|
|---|
| 4204 | typedef UINT WINAPI FN_GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName );
|
|---|
| 4205 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName )
|
|---|
| 4206 | {
|
|---|
| 4207 | static FN_GetTempFileNameW *pfn = 0;
|
|---|
| 4208 | if (!pfn)
|
|---|
| 4209 | kPrf2WrapResolve((void **)&pfn, "GetTempFileNameW", &g_Kernel32);
|
|---|
| 4210 | return pfn( lpPathName, lpPrefixString, uUnique, lpTempFileName );
|
|---|
| 4211 | }
|
|---|
| 4212 |
|
|---|
| 4213 | typedef UINT WINAPI FN_GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize );
|
|---|
| 4214 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize )
|
|---|
| 4215 | {
|
|---|
| 4216 | static FN_GetWindowsDirectoryA *pfn = 0;
|
|---|
| 4217 | if (!pfn)
|
|---|
| 4218 | kPrf2WrapResolve((void **)&pfn, "GetWindowsDirectoryA", &g_Kernel32);
|
|---|
| 4219 | return pfn( lpBuffer, uSize );
|
|---|
| 4220 | }
|
|---|
| 4221 |
|
|---|
| 4222 | typedef UINT WINAPI FN_GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize );
|
|---|
| 4223 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize )
|
|---|
| 4224 | {
|
|---|
| 4225 | static FN_GetWindowsDirectoryW *pfn = 0;
|
|---|
| 4226 | if (!pfn)
|
|---|
| 4227 | kPrf2WrapResolve((void **)&pfn, "GetWindowsDirectoryW", &g_Kernel32);
|
|---|
| 4228 | return pfn( lpBuffer, uSize );
|
|---|
| 4229 | }
|
|---|
| 4230 |
|
|---|
| 4231 | typedef UINT WINAPI FN_GetSystemWindowsDirectoryA( LPSTR lpBuffer, UINT uSize );
|
|---|
| 4232 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWindowsDirectoryA( LPSTR lpBuffer, UINT uSize )
|
|---|
| 4233 | {
|
|---|
| 4234 | static FN_GetSystemWindowsDirectoryA *pfn = 0;
|
|---|
| 4235 | if (!pfn)
|
|---|
| 4236 | kPrf2WrapResolve((void **)&pfn, "GetSystemWindowsDirectoryA", &g_Kernel32);
|
|---|
| 4237 | return pfn( lpBuffer, uSize );
|
|---|
| 4238 | }
|
|---|
| 4239 |
|
|---|
| 4240 | typedef UINT WINAPI FN_GetSystemWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize );
|
|---|
| 4241 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize )
|
|---|
| 4242 | {
|
|---|
| 4243 | static FN_GetSystemWindowsDirectoryW *pfn = 0;
|
|---|
| 4244 | if (!pfn)
|
|---|
| 4245 | kPrf2WrapResolve((void **)&pfn, "GetSystemWindowsDirectoryW", &g_Kernel32);
|
|---|
| 4246 | return pfn( lpBuffer, uSize );
|
|---|
| 4247 | }
|
|---|
| 4248 |
|
|---|
| 4249 | typedef UINT WINAPI FN_GetSystemWow64DirectoryA( LPSTR lpBuffer, UINT uSize );
|
|---|
| 4250 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWow64DirectoryA( LPSTR lpBuffer, UINT uSize )
|
|---|
| 4251 | {
|
|---|
| 4252 | static FN_GetSystemWow64DirectoryA *pfn = 0;
|
|---|
| 4253 | if (!pfn)
|
|---|
| 4254 | kPrf2WrapResolve((void **)&pfn, "GetSystemWow64DirectoryA", &g_Kernel32);
|
|---|
| 4255 | return pfn( lpBuffer, uSize );
|
|---|
| 4256 | }
|
|---|
| 4257 |
|
|---|
| 4258 | typedef UINT WINAPI FN_GetSystemWow64DirectoryW( LPWSTR lpBuffer, UINT uSize );
|
|---|
| 4259 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWow64DirectoryW( LPWSTR lpBuffer, UINT uSize )
|
|---|
| 4260 | {
|
|---|
| 4261 | static FN_GetSystemWow64DirectoryW *pfn = 0;
|
|---|
| 4262 | if (!pfn)
|
|---|
| 4263 | kPrf2WrapResolve((void **)&pfn, "GetSystemWow64DirectoryW", &g_Kernel32);
|
|---|
| 4264 | return pfn( lpBuffer, uSize );
|
|---|
| 4265 | }
|
|---|
| 4266 |
|
|---|
| 4267 | typedef BOOLEAN WINAPI FN_Wow64EnableWow64FsRedirection( BOOLEAN Wow64FsEnableRedirection );
|
|---|
| 4268 | __declspec(dllexport) BOOLEAN WINAPI kPrf2Wrap_Wow64EnableWow64FsRedirection( BOOLEAN Wow64FsEnableRedirection )
|
|---|
| 4269 | {
|
|---|
| 4270 | static FN_Wow64EnableWow64FsRedirection *pfn = 0;
|
|---|
| 4271 | if (!pfn)
|
|---|
| 4272 | kPrf2WrapResolve((void **)&pfn, "Wow64EnableWow64FsRedirection", &g_Kernel32);
|
|---|
| 4273 | return pfn( Wow64FsEnableRedirection );
|
|---|
| 4274 | }
|
|---|
| 4275 |
|
|---|
| 4276 | typedef BOOL WINAPI FN_Wow64DisableWow64FsRedirection( PVOID * OldValue );
|
|---|
| 4277 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Wow64DisableWow64FsRedirection( PVOID * OldValue )
|
|---|
| 4278 | {
|
|---|
| 4279 | static FN_Wow64DisableWow64FsRedirection *pfn = 0;
|
|---|
| 4280 | if (!pfn)
|
|---|
| 4281 | kPrf2WrapResolve((void **)&pfn, "Wow64DisableWow64FsRedirection", &g_Kernel32);
|
|---|
| 4282 | return pfn( OldValue );
|
|---|
| 4283 | }
|
|---|
| 4284 |
|
|---|
| 4285 | typedef BOOL WINAPI FN_Wow64RevertWow64FsRedirection( PVOID OlValue );
|
|---|
| 4286 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Wow64RevertWow64FsRedirection( PVOID OlValue )
|
|---|
| 4287 | {
|
|---|
| 4288 | static FN_Wow64RevertWow64FsRedirection *pfn = 0;
|
|---|
| 4289 | if (!pfn)
|
|---|
| 4290 | kPrf2WrapResolve((void **)&pfn, "Wow64RevertWow64FsRedirection", &g_Kernel32);
|
|---|
| 4291 | return pfn( OlValue );
|
|---|
| 4292 | }
|
|---|
| 4293 |
|
|---|
| 4294 | typedef BOOL WINAPI FN_SetCurrentDirectoryA( LPCSTR lpPathName );
|
|---|
| 4295 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCurrentDirectoryA( LPCSTR lpPathName )
|
|---|
| 4296 | {
|
|---|
| 4297 | static FN_SetCurrentDirectoryA *pfn = 0;
|
|---|
| 4298 | if (!pfn)
|
|---|
| 4299 | kPrf2WrapResolve((void **)&pfn, "SetCurrentDirectoryA", &g_Kernel32);
|
|---|
| 4300 | return pfn( lpPathName );
|
|---|
| 4301 | }
|
|---|
| 4302 |
|
|---|
| 4303 | typedef BOOL WINAPI FN_SetCurrentDirectoryW( LPCWSTR lpPathName );
|
|---|
| 4304 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCurrentDirectoryW( LPCWSTR lpPathName )
|
|---|
| 4305 | {
|
|---|
| 4306 | static FN_SetCurrentDirectoryW *pfn = 0;
|
|---|
| 4307 | if (!pfn)
|
|---|
| 4308 | kPrf2WrapResolve((void **)&pfn, "SetCurrentDirectoryW", &g_Kernel32);
|
|---|
| 4309 | return pfn( lpPathName );
|
|---|
| 4310 | }
|
|---|
| 4311 |
|
|---|
| 4312 | typedef DWORD WINAPI FN_GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer );
|
|---|
| 4313 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer )
|
|---|
| 4314 | {
|
|---|
| 4315 | static FN_GetCurrentDirectoryA *pfn = 0;
|
|---|
| 4316 | if (!pfn)
|
|---|
| 4317 | kPrf2WrapResolve((void **)&pfn, "GetCurrentDirectoryA", &g_Kernel32);
|
|---|
| 4318 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4319 | }
|
|---|
| 4320 |
|
|---|
| 4321 | typedef DWORD WINAPI FN_GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer );
|
|---|
| 4322 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer )
|
|---|
| 4323 | {
|
|---|
| 4324 | static FN_GetCurrentDirectoryW *pfn = 0;
|
|---|
| 4325 | if (!pfn)
|
|---|
| 4326 | kPrf2WrapResolve((void **)&pfn, "GetCurrentDirectoryW", &g_Kernel32);
|
|---|
| 4327 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4328 | }
|
|---|
| 4329 |
|
|---|
| 4330 | typedef BOOL WINAPI FN_SetDllDirectoryA( LPCSTR lpPathName );
|
|---|
| 4331 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDllDirectoryA( LPCSTR lpPathName )
|
|---|
| 4332 | {
|
|---|
| 4333 | static FN_SetDllDirectoryA *pfn = 0;
|
|---|
| 4334 | if (!pfn)
|
|---|
| 4335 | kPrf2WrapResolve((void **)&pfn, "SetDllDirectoryA", &g_Kernel32);
|
|---|
| 4336 | return pfn( lpPathName );
|
|---|
| 4337 | }
|
|---|
| 4338 |
|
|---|
| 4339 | typedef BOOL WINAPI FN_SetDllDirectoryW( LPCWSTR lpPathName );
|
|---|
| 4340 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDllDirectoryW( LPCWSTR lpPathName )
|
|---|
| 4341 | {
|
|---|
| 4342 | static FN_SetDllDirectoryW *pfn = 0;
|
|---|
| 4343 | if (!pfn)
|
|---|
| 4344 | kPrf2WrapResolve((void **)&pfn, "SetDllDirectoryW", &g_Kernel32);
|
|---|
| 4345 | return pfn( lpPathName );
|
|---|
| 4346 | }
|
|---|
| 4347 |
|
|---|
| 4348 | typedef DWORD WINAPI FN_GetDllDirectoryA( DWORD nBufferLength, LPSTR lpBuffer );
|
|---|
| 4349 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetDllDirectoryA( DWORD nBufferLength, LPSTR lpBuffer )
|
|---|
| 4350 | {
|
|---|
| 4351 | static FN_GetDllDirectoryA *pfn = 0;
|
|---|
| 4352 | if (!pfn)
|
|---|
| 4353 | kPrf2WrapResolve((void **)&pfn, "GetDllDirectoryA", &g_Kernel32);
|
|---|
| 4354 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4355 | }
|
|---|
| 4356 |
|
|---|
| 4357 | typedef DWORD WINAPI FN_GetDllDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer );
|
|---|
| 4358 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetDllDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer )
|
|---|
| 4359 | {
|
|---|
| 4360 | static FN_GetDllDirectoryW *pfn = 0;
|
|---|
| 4361 | if (!pfn)
|
|---|
| 4362 | kPrf2WrapResolve((void **)&pfn, "GetDllDirectoryW", &g_Kernel32);
|
|---|
| 4363 | return pfn( nBufferLength, lpBuffer );
|
|---|
| 4364 | }
|
|---|
| 4365 |
|
|---|
| 4366 | typedef BOOL WINAPI FN_GetDiskFreeSpaceA( LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters );
|
|---|
| 4367 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceA( LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters )
|
|---|
| 4368 | {
|
|---|
| 4369 | static FN_GetDiskFreeSpaceA *pfn = 0;
|
|---|
| 4370 | if (!pfn)
|
|---|
| 4371 | kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceA", &g_Kernel32);
|
|---|
| 4372 | return pfn( lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters );
|
|---|
| 4373 | }
|
|---|
| 4374 |
|
|---|
| 4375 | typedef BOOL WINAPI FN_GetDiskFreeSpaceW( LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters );
|
|---|
| 4376 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceW( LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters )
|
|---|
| 4377 | {
|
|---|
| 4378 | static FN_GetDiskFreeSpaceW *pfn = 0;
|
|---|
| 4379 | if (!pfn)
|
|---|
| 4380 | kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceW", &g_Kernel32);
|
|---|
| 4381 | return pfn( lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters );
|
|---|
| 4382 | }
|
|---|
| 4383 |
|
|---|
| 4384 | typedef BOOL WINAPI FN_GetDiskFreeSpaceExA( LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes );
|
|---|
| 4385 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceExA( LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes )
|
|---|
| 4386 | {
|
|---|
| 4387 | static FN_GetDiskFreeSpaceExA *pfn = 0;
|
|---|
| 4388 | if (!pfn)
|
|---|
| 4389 | kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceExA", &g_Kernel32);
|
|---|
| 4390 | return pfn( lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes );
|
|---|
| 4391 | }
|
|---|
| 4392 |
|
|---|
| 4393 | typedef BOOL WINAPI FN_GetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes );
|
|---|
| 4394 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes )
|
|---|
| 4395 | {
|
|---|
| 4396 | static FN_GetDiskFreeSpaceExW *pfn = 0;
|
|---|
| 4397 | if (!pfn)
|
|---|
| 4398 | kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceExW", &g_Kernel32);
|
|---|
| 4399 | return pfn( lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes );
|
|---|
| 4400 | }
|
|---|
| 4401 |
|
|---|
| 4402 | typedef BOOL WINAPI FN_CreateDirectoryA( LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4403 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryA( LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4404 | {
|
|---|
| 4405 | static FN_CreateDirectoryA *pfn = 0;
|
|---|
| 4406 | if (!pfn)
|
|---|
| 4407 | kPrf2WrapResolve((void **)&pfn, "CreateDirectoryA", &g_Kernel32);
|
|---|
| 4408 | return pfn( lpPathName, lpSecurityAttributes );
|
|---|
| 4409 | }
|
|---|
| 4410 |
|
|---|
| 4411 | typedef BOOL WINAPI FN_CreateDirectoryW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4412 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4413 | {
|
|---|
| 4414 | static FN_CreateDirectoryW *pfn = 0;
|
|---|
| 4415 | if (!pfn)
|
|---|
| 4416 | kPrf2WrapResolve((void **)&pfn, "CreateDirectoryW", &g_Kernel32);
|
|---|
| 4417 | return pfn( lpPathName, lpSecurityAttributes );
|
|---|
| 4418 | }
|
|---|
| 4419 |
|
|---|
| 4420 | typedef BOOL WINAPI FN_CreateDirectoryExA( LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4421 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryExA( LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4422 | {
|
|---|
| 4423 | static FN_CreateDirectoryExA *pfn = 0;
|
|---|
| 4424 | if (!pfn)
|
|---|
| 4425 | kPrf2WrapResolve((void **)&pfn, "CreateDirectoryExA", &g_Kernel32);
|
|---|
| 4426 | return pfn( lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes );
|
|---|
| 4427 | }
|
|---|
| 4428 |
|
|---|
| 4429 | typedef BOOL WINAPI FN_CreateDirectoryExW( LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4430 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryExW( LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4431 | {
|
|---|
| 4432 | static FN_CreateDirectoryExW *pfn = 0;
|
|---|
| 4433 | if (!pfn)
|
|---|
| 4434 | kPrf2WrapResolve((void **)&pfn, "CreateDirectoryExW", &g_Kernel32);
|
|---|
| 4435 | return pfn( lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes );
|
|---|
| 4436 | }
|
|---|
| 4437 |
|
|---|
| 4438 | typedef BOOL WINAPI FN_RemoveDirectoryA( LPCSTR lpPathName );
|
|---|
| 4439 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RemoveDirectoryA( LPCSTR lpPathName )
|
|---|
| 4440 | {
|
|---|
| 4441 | static FN_RemoveDirectoryA *pfn = 0;
|
|---|
| 4442 | if (!pfn)
|
|---|
| 4443 | kPrf2WrapResolve((void **)&pfn, "RemoveDirectoryA", &g_Kernel32);
|
|---|
| 4444 | return pfn( lpPathName );
|
|---|
| 4445 | }
|
|---|
| 4446 |
|
|---|
| 4447 | typedef BOOL WINAPI FN_RemoveDirectoryW( LPCWSTR lpPathName );
|
|---|
| 4448 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RemoveDirectoryW( LPCWSTR lpPathName )
|
|---|
| 4449 | {
|
|---|
| 4450 | static FN_RemoveDirectoryW *pfn = 0;
|
|---|
| 4451 | if (!pfn)
|
|---|
| 4452 | kPrf2WrapResolve((void **)&pfn, "RemoveDirectoryW", &g_Kernel32);
|
|---|
| 4453 | return pfn( lpPathName );
|
|---|
| 4454 | }
|
|---|
| 4455 |
|
|---|
| 4456 | typedef DWORD WINAPI FN_GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart );
|
|---|
| 4457 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart )
|
|---|
| 4458 | {
|
|---|
| 4459 | static FN_GetFullPathNameA *pfn = 0;
|
|---|
| 4460 | if (!pfn)
|
|---|
| 4461 | kPrf2WrapResolve((void **)&pfn, "GetFullPathNameA", &g_Kernel32);
|
|---|
| 4462 | return pfn( lpFileName, nBufferLength, lpBuffer, lpFilePart );
|
|---|
| 4463 | }
|
|---|
| 4464 |
|
|---|
| 4465 | typedef DWORD WINAPI FN_GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart );
|
|---|
| 4466 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart )
|
|---|
| 4467 | {
|
|---|
| 4468 | static FN_GetFullPathNameW *pfn = 0;
|
|---|
| 4469 | if (!pfn)
|
|---|
| 4470 | kPrf2WrapResolve((void **)&pfn, "GetFullPathNameW", &g_Kernel32);
|
|---|
| 4471 | return pfn( lpFileName, nBufferLength, lpBuffer, lpFilePart );
|
|---|
| 4472 | }
|
|---|
| 4473 |
|
|---|
| 4474 | typedef BOOL WINAPI FN_DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath );
|
|---|
| 4475 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath )
|
|---|
| 4476 | {
|
|---|
| 4477 | static FN_DefineDosDeviceA *pfn = 0;
|
|---|
| 4478 | if (!pfn)
|
|---|
| 4479 | kPrf2WrapResolve((void **)&pfn, "DefineDosDeviceA", &g_Kernel32);
|
|---|
| 4480 | return pfn( dwFlags, lpDeviceName, lpTargetPath );
|
|---|
| 4481 | }
|
|---|
| 4482 |
|
|---|
| 4483 | typedef BOOL WINAPI FN_DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath );
|
|---|
| 4484 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath )
|
|---|
| 4485 | {
|
|---|
| 4486 | static FN_DefineDosDeviceW *pfn = 0;
|
|---|
| 4487 | if (!pfn)
|
|---|
| 4488 | kPrf2WrapResolve((void **)&pfn, "DefineDosDeviceW", &g_Kernel32);
|
|---|
| 4489 | return pfn( dwFlags, lpDeviceName, lpTargetPath );
|
|---|
| 4490 | }
|
|---|
| 4491 |
|
|---|
| 4492 | typedef DWORD WINAPI FN_QueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax );
|
|---|
| 4493 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax )
|
|---|
| 4494 | {
|
|---|
| 4495 | static FN_QueryDosDeviceA *pfn = 0;
|
|---|
| 4496 | if (!pfn)
|
|---|
| 4497 | kPrf2WrapResolve((void **)&pfn, "QueryDosDeviceA", &g_Kernel32);
|
|---|
| 4498 | return pfn( lpDeviceName, lpTargetPath, ucchMax );
|
|---|
| 4499 | }
|
|---|
| 4500 |
|
|---|
| 4501 | typedef DWORD WINAPI FN_QueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax );
|
|---|
| 4502 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax )
|
|---|
| 4503 | {
|
|---|
| 4504 | static FN_QueryDosDeviceW *pfn = 0;
|
|---|
| 4505 | if (!pfn)
|
|---|
| 4506 | kPrf2WrapResolve((void **)&pfn, "QueryDosDeviceW", &g_Kernel32);
|
|---|
| 4507 | return pfn( lpDeviceName, lpTargetPath, ucchMax );
|
|---|
| 4508 | }
|
|---|
| 4509 |
|
|---|
| 4510 | typedef HANDLE WINAPI FN_CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile );
|
|---|
| 4511 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile )
|
|---|
| 4512 | {
|
|---|
| 4513 | static FN_CreateFileA *pfn = 0;
|
|---|
| 4514 | if (!pfn)
|
|---|
| 4515 | kPrf2WrapResolve((void **)&pfn, "CreateFileA", &g_Kernel32);
|
|---|
| 4516 | return pfn( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
|
|---|
| 4517 | }
|
|---|
| 4518 |
|
|---|
| 4519 | typedef HANDLE WINAPI FN_CreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile );
|
|---|
| 4520 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile )
|
|---|
| 4521 | {
|
|---|
| 4522 | static FN_CreateFileW *pfn = 0;
|
|---|
| 4523 | if (!pfn)
|
|---|
| 4524 | kPrf2WrapResolve((void **)&pfn, "CreateFileW", &g_Kernel32);
|
|---|
| 4525 | return pfn( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
|
|---|
| 4526 | }
|
|---|
| 4527 |
|
|---|
| 4528 | typedef HANDLE WINAPI FN_ReOpenFile( HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes );
|
|---|
| 4529 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_ReOpenFile( HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes )
|
|---|
| 4530 | {
|
|---|
| 4531 | static FN_ReOpenFile *pfn = 0;
|
|---|
| 4532 | if (!pfn)
|
|---|
| 4533 | kPrf2WrapResolve((void **)&pfn, "ReOpenFile", &g_Kernel32);
|
|---|
| 4534 | return pfn( hOriginalFile, dwDesiredAccess, dwShareMode, dwFlagsAndAttributes );
|
|---|
| 4535 | }
|
|---|
| 4536 |
|
|---|
| 4537 | typedef BOOL WINAPI FN_SetFileAttributesA( LPCSTR lpFileName, DWORD dwFileAttributes );
|
|---|
| 4538 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileAttributesA( LPCSTR lpFileName, DWORD dwFileAttributes )
|
|---|
| 4539 | {
|
|---|
| 4540 | static FN_SetFileAttributesA *pfn = 0;
|
|---|
| 4541 | if (!pfn)
|
|---|
| 4542 | kPrf2WrapResolve((void **)&pfn, "SetFileAttributesA", &g_Kernel32);
|
|---|
| 4543 | return pfn( lpFileName, dwFileAttributes );
|
|---|
| 4544 | }
|
|---|
| 4545 |
|
|---|
| 4546 | typedef BOOL WINAPI FN_SetFileAttributesW( LPCWSTR lpFileName, DWORD dwFileAttributes );
|
|---|
| 4547 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileAttributesW( LPCWSTR lpFileName, DWORD dwFileAttributes )
|
|---|
| 4548 | {
|
|---|
| 4549 | static FN_SetFileAttributesW *pfn = 0;
|
|---|
| 4550 | if (!pfn)
|
|---|
| 4551 | kPrf2WrapResolve((void **)&pfn, "SetFileAttributesW", &g_Kernel32);
|
|---|
| 4552 | return pfn( lpFileName, dwFileAttributes );
|
|---|
| 4553 | }
|
|---|
| 4554 |
|
|---|
| 4555 | typedef DWORD WINAPI FN_GetFileAttributesA( LPCSTR lpFileName );
|
|---|
| 4556 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileAttributesA( LPCSTR lpFileName )
|
|---|
| 4557 | {
|
|---|
| 4558 | static FN_GetFileAttributesA *pfn = 0;
|
|---|
| 4559 | if (!pfn)
|
|---|
| 4560 | kPrf2WrapResolve((void **)&pfn, "GetFileAttributesA", &g_Kernel32);
|
|---|
| 4561 | return pfn( lpFileName );
|
|---|
| 4562 | }
|
|---|
| 4563 |
|
|---|
| 4564 | typedef DWORD WINAPI FN_GetFileAttributesW( LPCWSTR lpFileName );
|
|---|
| 4565 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileAttributesW( LPCWSTR lpFileName )
|
|---|
| 4566 | {
|
|---|
| 4567 | static FN_GetFileAttributesW *pfn = 0;
|
|---|
| 4568 | if (!pfn)
|
|---|
| 4569 | kPrf2WrapResolve((void **)&pfn, "GetFileAttributesW", &g_Kernel32);
|
|---|
| 4570 | return pfn( lpFileName );
|
|---|
| 4571 | }
|
|---|
| 4572 |
|
|---|
| 4573 | typedef BOOL WINAPI FN_GetFileAttributesExA( LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation );
|
|---|
| 4574 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileAttributesExA( LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation )
|
|---|
| 4575 | {
|
|---|
| 4576 | static FN_GetFileAttributesExA *pfn = 0;
|
|---|
| 4577 | if (!pfn)
|
|---|
| 4578 | kPrf2WrapResolve((void **)&pfn, "GetFileAttributesExA", &g_Kernel32);
|
|---|
| 4579 | return pfn( lpFileName, fInfoLevelId, lpFileInformation );
|
|---|
| 4580 | }
|
|---|
| 4581 |
|
|---|
| 4582 | typedef BOOL WINAPI FN_GetFileAttributesExW( LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation );
|
|---|
| 4583 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileAttributesExW( LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation )
|
|---|
| 4584 | {
|
|---|
| 4585 | static FN_GetFileAttributesExW *pfn = 0;
|
|---|
| 4586 | if (!pfn)
|
|---|
| 4587 | kPrf2WrapResolve((void **)&pfn, "GetFileAttributesExW", &g_Kernel32);
|
|---|
| 4588 | return pfn( lpFileName, fInfoLevelId, lpFileInformation );
|
|---|
| 4589 | }
|
|---|
| 4590 |
|
|---|
| 4591 | typedef DWORD WINAPI FN_GetCompressedFileSizeA( LPCSTR lpFileName, LPDWORD lpFileSizeHigh );
|
|---|
| 4592 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCompressedFileSizeA( LPCSTR lpFileName, LPDWORD lpFileSizeHigh )
|
|---|
| 4593 | {
|
|---|
| 4594 | static FN_GetCompressedFileSizeA *pfn = 0;
|
|---|
| 4595 | if (!pfn)
|
|---|
| 4596 | kPrf2WrapResolve((void **)&pfn, "GetCompressedFileSizeA", &g_Kernel32);
|
|---|
| 4597 | return pfn( lpFileName, lpFileSizeHigh );
|
|---|
| 4598 | }
|
|---|
| 4599 |
|
|---|
| 4600 | typedef DWORD WINAPI FN_GetCompressedFileSizeW( LPCWSTR lpFileName, LPDWORD lpFileSizeHigh );
|
|---|
| 4601 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCompressedFileSizeW( LPCWSTR lpFileName, LPDWORD lpFileSizeHigh )
|
|---|
| 4602 | {
|
|---|
| 4603 | static FN_GetCompressedFileSizeW *pfn = 0;
|
|---|
| 4604 | if (!pfn)
|
|---|
| 4605 | kPrf2WrapResolve((void **)&pfn, "GetCompressedFileSizeW", &g_Kernel32);
|
|---|
| 4606 | return pfn( lpFileName, lpFileSizeHigh );
|
|---|
| 4607 | }
|
|---|
| 4608 |
|
|---|
| 4609 | typedef BOOL WINAPI FN_DeleteFileA( LPCSTR lpFileName );
|
|---|
| 4610 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteFileA( LPCSTR lpFileName )
|
|---|
| 4611 | {
|
|---|
| 4612 | static FN_DeleteFileA *pfn = 0;
|
|---|
| 4613 | if (!pfn)
|
|---|
| 4614 | kPrf2WrapResolve((void **)&pfn, "DeleteFileA", &g_Kernel32);
|
|---|
| 4615 | return pfn( lpFileName );
|
|---|
| 4616 | }
|
|---|
| 4617 |
|
|---|
| 4618 | typedef BOOL WINAPI FN_DeleteFileW( LPCWSTR lpFileName );
|
|---|
| 4619 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteFileW( LPCWSTR lpFileName )
|
|---|
| 4620 | {
|
|---|
| 4621 | static FN_DeleteFileW *pfn = 0;
|
|---|
| 4622 | if (!pfn)
|
|---|
| 4623 | kPrf2WrapResolve((void **)&pfn, "DeleteFileW", &g_Kernel32);
|
|---|
| 4624 | return pfn( lpFileName );
|
|---|
| 4625 | }
|
|---|
| 4626 |
|
|---|
| 4627 | typedef BOOL WINAPI FN_CheckNameLegalDOS8Dot3A( LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal );
|
|---|
| 4628 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckNameLegalDOS8Dot3A( LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal )
|
|---|
| 4629 | {
|
|---|
| 4630 | static FN_CheckNameLegalDOS8Dot3A *pfn = 0;
|
|---|
| 4631 | if (!pfn)
|
|---|
| 4632 | kPrf2WrapResolve((void **)&pfn, "CheckNameLegalDOS8Dot3A", &g_Kernel32);
|
|---|
| 4633 | return pfn( lpName, lpOemName, OemNameSize, pbNameContainsSpaces , pbNameLegal );
|
|---|
| 4634 | }
|
|---|
| 4635 |
|
|---|
| 4636 | typedef BOOL WINAPI FN_CheckNameLegalDOS8Dot3W( LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal );
|
|---|
| 4637 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckNameLegalDOS8Dot3W( LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal )
|
|---|
| 4638 | {
|
|---|
| 4639 | static FN_CheckNameLegalDOS8Dot3W *pfn = 0;
|
|---|
| 4640 | if (!pfn)
|
|---|
| 4641 | kPrf2WrapResolve((void **)&pfn, "CheckNameLegalDOS8Dot3W", &g_Kernel32);
|
|---|
| 4642 | return pfn( lpName, lpOemName, OemNameSize, pbNameContainsSpaces , pbNameLegal );
|
|---|
| 4643 | }
|
|---|
| 4644 |
|
|---|
| 4645 | typedef HANDLE WINAPI FN_FindFirstFileExA( LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags );
|
|---|
| 4646 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileExA( LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags )
|
|---|
| 4647 | {
|
|---|
| 4648 | static FN_FindFirstFileExA *pfn = 0;
|
|---|
| 4649 | if (!pfn)
|
|---|
| 4650 | kPrf2WrapResolve((void **)&pfn, "FindFirstFileExA", &g_Kernel32);
|
|---|
| 4651 | return pfn( lpFileName, fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags );
|
|---|
| 4652 | }
|
|---|
| 4653 |
|
|---|
| 4654 | typedef HANDLE WINAPI FN_FindFirstFileExW( LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags );
|
|---|
| 4655 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileExW( LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags )
|
|---|
| 4656 | {
|
|---|
| 4657 | static FN_FindFirstFileExW *pfn = 0;
|
|---|
| 4658 | if (!pfn)
|
|---|
| 4659 | kPrf2WrapResolve((void **)&pfn, "FindFirstFileExW", &g_Kernel32);
|
|---|
| 4660 | return pfn( lpFileName, fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags );
|
|---|
| 4661 | }
|
|---|
| 4662 |
|
|---|
| 4663 | typedef HANDLE WINAPI FN_FindFirstFileA( LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData );
|
|---|
| 4664 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileA( LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData )
|
|---|
| 4665 | {
|
|---|
| 4666 | static FN_FindFirstFileA *pfn = 0;
|
|---|
| 4667 | if (!pfn)
|
|---|
| 4668 | kPrf2WrapResolve((void **)&pfn, "FindFirstFileA", &g_Kernel32);
|
|---|
| 4669 | return pfn( lpFileName, lpFindFileData );
|
|---|
| 4670 | }
|
|---|
| 4671 |
|
|---|
| 4672 | typedef HANDLE WINAPI FN_FindFirstFileW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData );
|
|---|
| 4673 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData )
|
|---|
| 4674 | {
|
|---|
| 4675 | static FN_FindFirstFileW *pfn = 0;
|
|---|
| 4676 | if (!pfn)
|
|---|
| 4677 | kPrf2WrapResolve((void **)&pfn, "FindFirstFileW", &g_Kernel32);
|
|---|
| 4678 | return pfn( lpFileName, lpFindFileData );
|
|---|
| 4679 | }
|
|---|
| 4680 |
|
|---|
| 4681 | typedef BOOL WINAPI FN_FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData );
|
|---|
| 4682 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData )
|
|---|
| 4683 | {
|
|---|
| 4684 | static FN_FindNextFileA *pfn = 0;
|
|---|
| 4685 | if (!pfn)
|
|---|
| 4686 | kPrf2WrapResolve((void **)&pfn, "FindNextFileA", &g_Kernel32);
|
|---|
| 4687 | return pfn( hFindFile, lpFindFileData );
|
|---|
| 4688 | }
|
|---|
| 4689 |
|
|---|
| 4690 | typedef BOOL WINAPI FN_FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData );
|
|---|
| 4691 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData )
|
|---|
| 4692 | {
|
|---|
| 4693 | static FN_FindNextFileW *pfn = 0;
|
|---|
| 4694 | if (!pfn)
|
|---|
| 4695 | kPrf2WrapResolve((void **)&pfn, "FindNextFileW", &g_Kernel32);
|
|---|
| 4696 | return pfn( hFindFile, lpFindFileData );
|
|---|
| 4697 | }
|
|---|
| 4698 |
|
|---|
| 4699 | typedef DWORD WINAPI FN_SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart );
|
|---|
| 4700 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart )
|
|---|
| 4701 | {
|
|---|
| 4702 | static FN_SearchPathA *pfn = 0;
|
|---|
| 4703 | if (!pfn)
|
|---|
| 4704 | kPrf2WrapResolve((void **)&pfn, "SearchPathA", &g_Kernel32);
|
|---|
| 4705 | return pfn( lpPath, lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
|
|---|
| 4706 | }
|
|---|
| 4707 |
|
|---|
| 4708 | typedef DWORD WINAPI FN_SearchPathW( LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart );
|
|---|
| 4709 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SearchPathW( LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart )
|
|---|
| 4710 | {
|
|---|
| 4711 | static FN_SearchPathW *pfn = 0;
|
|---|
| 4712 | if (!pfn)
|
|---|
| 4713 | kPrf2WrapResolve((void **)&pfn, "SearchPathW", &g_Kernel32);
|
|---|
| 4714 | return pfn( lpPath, lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
|
|---|
| 4715 | }
|
|---|
| 4716 |
|
|---|
| 4717 | typedef BOOL WINAPI FN_CopyFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists );
|
|---|
| 4718 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists )
|
|---|
| 4719 | {
|
|---|
| 4720 | static FN_CopyFileA *pfn = 0;
|
|---|
| 4721 | if (!pfn)
|
|---|
| 4722 | kPrf2WrapResolve((void **)&pfn, "CopyFileA", &g_Kernel32);
|
|---|
| 4723 | return pfn( lpExistingFileName, lpNewFileName, bFailIfExists );
|
|---|
| 4724 | }
|
|---|
| 4725 |
|
|---|
| 4726 | typedef BOOL WINAPI FN_CopyFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists );
|
|---|
| 4727 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists )
|
|---|
| 4728 | {
|
|---|
| 4729 | static FN_CopyFileW *pfn = 0;
|
|---|
| 4730 | if (!pfn)
|
|---|
| 4731 | kPrf2WrapResolve((void **)&pfn, "CopyFileW", &g_Kernel32);
|
|---|
| 4732 | return pfn( lpExistingFileName, lpNewFileName, bFailIfExists );
|
|---|
| 4733 | }
|
|---|
| 4734 |
|
|---|
| 4735 | typedef BOOL WINAPI FN_CopyFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags );
|
|---|
| 4736 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags )
|
|---|
| 4737 | {
|
|---|
| 4738 | static FN_CopyFileExA *pfn = 0;
|
|---|
| 4739 | if (!pfn)
|
|---|
| 4740 | kPrf2WrapResolve((void **)&pfn, "CopyFileExA", &g_Kernel32);
|
|---|
| 4741 | return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags );
|
|---|
| 4742 | }
|
|---|
| 4743 |
|
|---|
| 4744 | typedef BOOL WINAPI FN_CopyFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags );
|
|---|
| 4745 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags )
|
|---|
| 4746 | {
|
|---|
| 4747 | static FN_CopyFileExW *pfn = 0;
|
|---|
| 4748 | if (!pfn)
|
|---|
| 4749 | kPrf2WrapResolve((void **)&pfn, "CopyFileExW", &g_Kernel32);
|
|---|
| 4750 | return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags );
|
|---|
| 4751 | }
|
|---|
| 4752 |
|
|---|
| 4753 | typedef BOOL WINAPI FN_MoveFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName );
|
|---|
| 4754 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName )
|
|---|
| 4755 | {
|
|---|
| 4756 | static FN_MoveFileA *pfn = 0;
|
|---|
| 4757 | if (!pfn)
|
|---|
| 4758 | kPrf2WrapResolve((void **)&pfn, "MoveFileA", &g_Kernel32);
|
|---|
| 4759 | return pfn( lpExistingFileName, lpNewFileName );
|
|---|
| 4760 | }
|
|---|
| 4761 |
|
|---|
| 4762 | typedef BOOL WINAPI FN_MoveFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName );
|
|---|
| 4763 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName )
|
|---|
| 4764 | {
|
|---|
| 4765 | static FN_MoveFileW *pfn = 0;
|
|---|
| 4766 | if (!pfn)
|
|---|
| 4767 | kPrf2WrapResolve((void **)&pfn, "MoveFileW", &g_Kernel32);
|
|---|
| 4768 | return pfn( lpExistingFileName, lpNewFileName );
|
|---|
| 4769 | }
|
|---|
| 4770 |
|
|---|
| 4771 | typedef BOOL WINAPI FN_MoveFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags );
|
|---|
| 4772 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags )
|
|---|
| 4773 | {
|
|---|
| 4774 | static FN_MoveFileExA *pfn = 0;
|
|---|
| 4775 | if (!pfn)
|
|---|
| 4776 | kPrf2WrapResolve((void **)&pfn, "MoveFileExA", &g_Kernel32);
|
|---|
| 4777 | return pfn( lpExistingFileName, lpNewFileName, dwFlags );
|
|---|
| 4778 | }
|
|---|
| 4779 |
|
|---|
| 4780 | typedef BOOL WINAPI FN_MoveFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags );
|
|---|
| 4781 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags )
|
|---|
| 4782 | {
|
|---|
| 4783 | static FN_MoveFileExW *pfn = 0;
|
|---|
| 4784 | if (!pfn)
|
|---|
| 4785 | kPrf2WrapResolve((void **)&pfn, "MoveFileExW", &g_Kernel32);
|
|---|
| 4786 | return pfn( lpExistingFileName, lpNewFileName, dwFlags );
|
|---|
| 4787 | }
|
|---|
| 4788 |
|
|---|
| 4789 | typedef BOOL WINAPI FN_MoveFileWithProgressA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags );
|
|---|
| 4790 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileWithProgressA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags )
|
|---|
| 4791 | {
|
|---|
| 4792 | static FN_MoveFileWithProgressA *pfn = 0;
|
|---|
| 4793 | if (!pfn)
|
|---|
| 4794 | kPrf2WrapResolve((void **)&pfn, "MoveFileWithProgressA", &g_Kernel32);
|
|---|
| 4795 | return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, dwFlags );
|
|---|
| 4796 | }
|
|---|
| 4797 |
|
|---|
| 4798 | typedef BOOL WINAPI FN_MoveFileWithProgressW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags );
|
|---|
| 4799 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileWithProgressW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags )
|
|---|
| 4800 | {
|
|---|
| 4801 | static FN_MoveFileWithProgressW *pfn = 0;
|
|---|
| 4802 | if (!pfn)
|
|---|
| 4803 | kPrf2WrapResolve((void **)&pfn, "MoveFileWithProgressW", &g_Kernel32);
|
|---|
| 4804 | return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, dwFlags );
|
|---|
| 4805 | }
|
|---|
| 4806 |
|
|---|
| 4807 | typedef BOOL WINAPI FN_ReplaceFileA( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
|
|---|
| 4808 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFileA( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
|
|---|
| 4809 | {
|
|---|
| 4810 | static FN_ReplaceFileA *pfn = 0;
|
|---|
| 4811 | if (!pfn)
|
|---|
| 4812 | kPrf2WrapResolve((void **)&pfn, "ReplaceFileA", &g_Kernel32);
|
|---|
| 4813 | return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
|
|---|
| 4814 | }
|
|---|
| 4815 |
|
|---|
| 4816 | typedef BOOL WINAPI FN_ReplaceFileW( LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
|
|---|
| 4817 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFileW( LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
|
|---|
| 4818 | {
|
|---|
| 4819 | static FN_ReplaceFileW *pfn = 0;
|
|---|
| 4820 | if (!pfn)
|
|---|
| 4821 | kPrf2WrapResolve((void **)&pfn, "ReplaceFileW", &g_Kernel32);
|
|---|
| 4822 | return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
|
|---|
| 4823 | }
|
|---|
| 4824 |
|
|---|
| 4825 | typedef BOOL WINAPI FN_CreateHardLinkA( LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4826 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateHardLinkA( LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4827 | {
|
|---|
| 4828 | static FN_CreateHardLinkA *pfn = 0;
|
|---|
| 4829 | if (!pfn)
|
|---|
| 4830 | kPrf2WrapResolve((void **)&pfn, "CreateHardLinkA", &g_Kernel32);
|
|---|
| 4831 | return pfn( lpFileName, lpExistingFileName, lpSecurityAttributes );
|
|---|
| 4832 | }
|
|---|
| 4833 |
|
|---|
| 4834 | typedef BOOL WINAPI FN_CreateHardLinkW( LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4835 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateHardLinkW( LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4836 | {
|
|---|
| 4837 | static FN_CreateHardLinkW *pfn = 0;
|
|---|
| 4838 | if (!pfn)
|
|---|
| 4839 | kPrf2WrapResolve((void **)&pfn, "CreateHardLinkW", &g_Kernel32);
|
|---|
| 4840 | return pfn( lpFileName, lpExistingFileName, lpSecurityAttributes );
|
|---|
| 4841 | }
|
|---|
| 4842 |
|
|---|
| 4843 | typedef HANDLE WINAPI FN_FindFirstStreamW( LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags );
|
|---|
| 4844 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstStreamW( LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags )
|
|---|
| 4845 | {
|
|---|
| 4846 | static FN_FindFirstStreamW *pfn = 0;
|
|---|
| 4847 | if (!pfn)
|
|---|
| 4848 | kPrf2WrapResolve((void **)&pfn, "FindFirstStreamW", &g_Kernel32);
|
|---|
| 4849 | return pfn( lpFileName, InfoLevel, lpFindStreamData, dwFlags );
|
|---|
| 4850 | }
|
|---|
| 4851 |
|
|---|
| 4852 | typedef BOOL APIENTRY FN_FindNextStreamW( HANDLE hFindStream, LPVOID lpFindStreamData );
|
|---|
| 4853 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_FindNextStreamW( HANDLE hFindStream, LPVOID lpFindStreamData )
|
|---|
| 4854 | {
|
|---|
| 4855 | static FN_FindNextStreamW *pfn = 0;
|
|---|
| 4856 | if (!pfn)
|
|---|
| 4857 | kPrf2WrapResolve((void **)&pfn, "FindNextStreamW", &g_Kernel32);
|
|---|
| 4858 | return pfn( hFindStream, lpFindStreamData );
|
|---|
| 4859 | }
|
|---|
| 4860 |
|
|---|
| 4861 | typedef HANDLE WINAPI FN_CreateNamedPipeA( LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4862 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateNamedPipeA( LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4863 | {
|
|---|
| 4864 | static FN_CreateNamedPipeA *pfn = 0;
|
|---|
| 4865 | if (!pfn)
|
|---|
| 4866 | kPrf2WrapResolve((void **)&pfn, "CreateNamedPipeA", &g_Kernel32);
|
|---|
| 4867 | return pfn( lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes );
|
|---|
| 4868 | }
|
|---|
| 4869 |
|
|---|
| 4870 | typedef HANDLE WINAPI FN_CreateNamedPipeW( LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
|
|---|
| 4871 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateNamedPipeW( LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
|
|---|
| 4872 | {
|
|---|
| 4873 | static FN_CreateNamedPipeW *pfn = 0;
|
|---|
| 4874 | if (!pfn)
|
|---|
| 4875 | kPrf2WrapResolve((void **)&pfn, "CreateNamedPipeW", &g_Kernel32);
|
|---|
| 4876 | return pfn( lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes );
|
|---|
| 4877 | }
|
|---|
| 4878 |
|
|---|
| 4879 | typedef BOOL WINAPI FN_GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize );
|
|---|
| 4880 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize )
|
|---|
| 4881 | {
|
|---|
| 4882 | static FN_GetNamedPipeHandleStateA *pfn = 0;
|
|---|
| 4883 | if (!pfn)
|
|---|
| 4884 | kPrf2WrapResolve((void **)&pfn, "GetNamedPipeHandleStateA", &g_Kernel32);
|
|---|
| 4885 | return pfn( hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, lpUserName, nMaxUserNameSize );
|
|---|
| 4886 | }
|
|---|
| 4887 |
|
|---|
| 4888 | typedef BOOL WINAPI FN_GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize );
|
|---|
| 4889 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize )
|
|---|
| 4890 | {
|
|---|
| 4891 | static FN_GetNamedPipeHandleStateW *pfn = 0;
|
|---|
| 4892 | if (!pfn)
|
|---|
| 4893 | kPrf2WrapResolve((void **)&pfn, "GetNamedPipeHandleStateW", &g_Kernel32);
|
|---|
| 4894 | return pfn( hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, lpUserName, nMaxUserNameSize );
|
|---|
| 4895 | }
|
|---|
| 4896 |
|
|---|
| 4897 | typedef BOOL WINAPI FN_CallNamedPipeA( LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut );
|
|---|
| 4898 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CallNamedPipeA( LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut )
|
|---|
| 4899 | {
|
|---|
| 4900 | static FN_CallNamedPipeA *pfn = 0;
|
|---|
| 4901 | if (!pfn)
|
|---|
| 4902 | kPrf2WrapResolve((void **)&pfn, "CallNamedPipeA", &g_Kernel32);
|
|---|
| 4903 | return pfn( lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut );
|
|---|
| 4904 | }
|
|---|
| 4905 |
|
|---|
| 4906 | typedef BOOL WINAPI FN_CallNamedPipeW( LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut );
|
|---|
| 4907 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CallNamedPipeW( LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut )
|
|---|
| 4908 | {
|
|---|
| 4909 | static FN_CallNamedPipeW *pfn = 0;
|
|---|
| 4910 | if (!pfn)
|
|---|
| 4911 | kPrf2WrapResolve((void **)&pfn, "CallNamedPipeW", &g_Kernel32);
|
|---|
| 4912 | return pfn( lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut );
|
|---|
| 4913 | }
|
|---|
| 4914 |
|
|---|
| 4915 | typedef BOOL WINAPI FN_WaitNamedPipeA( LPCSTR lpNamedPipeName, DWORD nTimeOut );
|
|---|
| 4916 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitNamedPipeA( LPCSTR lpNamedPipeName, DWORD nTimeOut )
|
|---|
| 4917 | {
|
|---|
| 4918 | static FN_WaitNamedPipeA *pfn = 0;
|
|---|
| 4919 | if (!pfn)
|
|---|
| 4920 | kPrf2WrapResolve((void **)&pfn, "WaitNamedPipeA", &g_Kernel32);
|
|---|
| 4921 | return pfn( lpNamedPipeName, nTimeOut );
|
|---|
| 4922 | }
|
|---|
| 4923 |
|
|---|
| 4924 | typedef BOOL WINAPI FN_WaitNamedPipeW( LPCWSTR lpNamedPipeName, DWORD nTimeOut );
|
|---|
| 4925 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitNamedPipeW( LPCWSTR lpNamedPipeName, DWORD nTimeOut )
|
|---|
| 4926 | {
|
|---|
| 4927 | static FN_WaitNamedPipeW *pfn = 0;
|
|---|
| 4928 | if (!pfn)
|
|---|
| 4929 | kPrf2WrapResolve((void **)&pfn, "WaitNamedPipeW", &g_Kernel32);
|
|---|
| 4930 | return pfn( lpNamedPipeName, nTimeOut );
|
|---|
| 4931 | }
|
|---|
| 4932 |
|
|---|
| 4933 | typedef BOOL WINAPI FN_SetVolumeLabelA( LPCSTR lpRootPathName, LPCSTR lpVolumeName );
|
|---|
| 4934 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeLabelA( LPCSTR lpRootPathName, LPCSTR lpVolumeName )
|
|---|
| 4935 | {
|
|---|
| 4936 | static FN_SetVolumeLabelA *pfn = 0;
|
|---|
| 4937 | if (!pfn)
|
|---|
| 4938 | kPrf2WrapResolve((void **)&pfn, "SetVolumeLabelA", &g_Kernel32);
|
|---|
| 4939 | return pfn( lpRootPathName, lpVolumeName );
|
|---|
| 4940 | }
|
|---|
| 4941 |
|
|---|
| 4942 | typedef BOOL WINAPI FN_SetVolumeLabelW( LPCWSTR lpRootPathName, LPCWSTR lpVolumeName );
|
|---|
| 4943 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeLabelW( LPCWSTR lpRootPathName, LPCWSTR lpVolumeName )
|
|---|
| 4944 | {
|
|---|
| 4945 | static FN_SetVolumeLabelW *pfn = 0;
|
|---|
| 4946 | if (!pfn)
|
|---|
| 4947 | kPrf2WrapResolve((void **)&pfn, "SetVolumeLabelW", &g_Kernel32);
|
|---|
| 4948 | return pfn( lpRootPathName, lpVolumeName );
|
|---|
| 4949 | }
|
|---|
| 4950 |
|
|---|
| 4951 | typedef VOID WINAPI FN_SetFileApisToOEM( VOID );
|
|---|
| 4952 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetFileApisToOEM( VOID )
|
|---|
| 4953 | {
|
|---|
| 4954 | static FN_SetFileApisToOEM *pfn = 0;
|
|---|
| 4955 | if (!pfn)
|
|---|
| 4956 | kPrf2WrapResolve((void **)&pfn, "SetFileApisToOEM", &g_Kernel32);
|
|---|
| 4957 | pfn ();
|
|---|
| 4958 | }
|
|---|
| 4959 |
|
|---|
| 4960 | typedef VOID WINAPI FN_SetFileApisToANSI( VOID );
|
|---|
| 4961 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetFileApisToANSI( VOID )
|
|---|
| 4962 | {
|
|---|
| 4963 | static FN_SetFileApisToANSI *pfn = 0;
|
|---|
| 4964 | if (!pfn)
|
|---|
| 4965 | kPrf2WrapResolve((void **)&pfn, "SetFileApisToANSI", &g_Kernel32);
|
|---|
| 4966 | pfn ();
|
|---|
| 4967 | }
|
|---|
| 4968 |
|
|---|
| 4969 | typedef BOOL WINAPI FN_AreFileApisANSI( VOID );
|
|---|
| 4970 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreFileApisANSI( VOID )
|
|---|
| 4971 | {
|
|---|
| 4972 | static FN_AreFileApisANSI *pfn = 0;
|
|---|
| 4973 | if (!pfn)
|
|---|
| 4974 | kPrf2WrapResolve((void **)&pfn, "AreFileApisANSI", &g_Kernel32);
|
|---|
| 4975 | return pfn ();
|
|---|
| 4976 | }
|
|---|
| 4977 |
|
|---|
| 4978 | typedef BOOL WINAPI FN_GetVolumeInformationA( LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize );
|
|---|
| 4979 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeInformationA( LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize )
|
|---|
| 4980 | {
|
|---|
| 4981 | static FN_GetVolumeInformationA *pfn = 0;
|
|---|
| 4982 | if (!pfn)
|
|---|
| 4983 | kPrf2WrapResolve((void **)&pfn, "GetVolumeInformationA", &g_Kernel32);
|
|---|
| 4984 | return pfn( lpRootPathName, lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer, nFileSystemNameSize );
|
|---|
| 4985 | }
|
|---|
| 4986 |
|
|---|
| 4987 | typedef BOOL WINAPI FN_GetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize );
|
|---|
| 4988 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize )
|
|---|
| 4989 | {
|
|---|
| 4990 | static FN_GetVolumeInformationW *pfn = 0;
|
|---|
| 4991 | if (!pfn)
|
|---|
| 4992 | kPrf2WrapResolve((void **)&pfn, "GetVolumeInformationW", &g_Kernel32);
|
|---|
| 4993 | return pfn( lpRootPathName, lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer, nFileSystemNameSize );
|
|---|
| 4994 | }
|
|---|
| 4995 |
|
|---|
| 4996 | typedef BOOL WINAPI FN_CancelIo( HANDLE hFile );
|
|---|
| 4997 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelIo( HANDLE hFile )
|
|---|
| 4998 | {
|
|---|
| 4999 | static FN_CancelIo *pfn = 0;
|
|---|
| 5000 | if (!pfn)
|
|---|
| 5001 | kPrf2WrapResolve((void **)&pfn, "CancelIo", &g_Kernel32);
|
|---|
| 5002 | return pfn( hFile );
|
|---|
| 5003 | }
|
|---|
| 5004 |
|
|---|
| 5005 | typedef BOOL WINAPI FN_ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName );
|
|---|
| 5006 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
|
|---|
| 5007 | {
|
|---|
| 5008 | static FN_ClearEventLogA *pfn = 0;
|
|---|
| 5009 | if (!pfn)
|
|---|
| 5010 | kPrf2WrapResolve((void **)&pfn, "ClearEventLogA", &g_Kernel32);
|
|---|
| 5011 | return pfn( hEventLog, lpBackupFileName );
|
|---|
| 5012 | }
|
|---|
| 5013 |
|
|---|
| 5014 | typedef BOOL WINAPI FN_ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName );
|
|---|
| 5015 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
|
|---|
| 5016 | {
|
|---|
| 5017 | static FN_ClearEventLogW *pfn = 0;
|
|---|
| 5018 | if (!pfn)
|
|---|
| 5019 | kPrf2WrapResolve((void **)&pfn, "ClearEventLogW", &g_Kernel32);
|
|---|
| 5020 | return pfn( hEventLog, lpBackupFileName );
|
|---|
| 5021 | }
|
|---|
| 5022 |
|
|---|
| 5023 | typedef BOOL WINAPI FN_BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName );
|
|---|
| 5024 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
|
|---|
| 5025 | {
|
|---|
| 5026 | static FN_BackupEventLogA *pfn = 0;
|
|---|
| 5027 | if (!pfn)
|
|---|
| 5028 | kPrf2WrapResolve((void **)&pfn, "BackupEventLogA", &g_Kernel32);
|
|---|
| 5029 | return pfn( hEventLog, lpBackupFileName );
|
|---|
| 5030 | }
|
|---|
| 5031 |
|
|---|
| 5032 | typedef BOOL WINAPI FN_BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName );
|
|---|
| 5033 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
|
|---|
| 5034 | {
|
|---|
| 5035 | static FN_BackupEventLogW *pfn = 0;
|
|---|
| 5036 | if (!pfn)
|
|---|
| 5037 | kPrf2WrapResolve((void **)&pfn, "BackupEventLogW", &g_Kernel32);
|
|---|
| 5038 | return pfn( hEventLog, lpBackupFileName );
|
|---|
| 5039 | }
|
|---|
| 5040 |
|
|---|
| 5041 | typedef BOOL WINAPI FN_CloseEventLog( HANDLE hEventLog );
|
|---|
| 5042 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CloseEventLog( HANDLE hEventLog )
|
|---|
| 5043 | {
|
|---|
| 5044 | static FN_CloseEventLog *pfn = 0;
|
|---|
| 5045 | if (!pfn)
|
|---|
| 5046 | kPrf2WrapResolve((void **)&pfn, "CloseEventLog", &g_Kernel32);
|
|---|
| 5047 | return pfn( hEventLog );
|
|---|
| 5048 | }
|
|---|
| 5049 |
|
|---|
| 5050 | typedef BOOL WINAPI FN_DeregisterEventSource( HANDLE hEventLog );
|
|---|
| 5051 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeregisterEventSource( HANDLE hEventLog )
|
|---|
| 5052 | {
|
|---|
| 5053 | static FN_DeregisterEventSource *pfn = 0;
|
|---|
| 5054 | if (!pfn)
|
|---|
| 5055 | kPrf2WrapResolve((void **)&pfn, "DeregisterEventSource", &g_Kernel32);
|
|---|
| 5056 | return pfn( hEventLog );
|
|---|
| 5057 | }
|
|---|
| 5058 |
|
|---|
| 5059 | typedef BOOL WINAPI FN_NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent );
|
|---|
| 5060 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
|
|---|
| 5061 | {
|
|---|
| 5062 | static FN_NotifyChangeEventLog *pfn = 0;
|
|---|
| 5063 | if (!pfn)
|
|---|
| 5064 | kPrf2WrapResolve((void **)&pfn, "NotifyChangeEventLog", &g_Kernel32);
|
|---|
| 5065 | return pfn( hEventLog, hEvent );
|
|---|
| 5066 | }
|
|---|
| 5067 |
|
|---|
| 5068 | typedef BOOL WINAPI FN_GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords );
|
|---|
| 5069 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
|
|---|
| 5070 | {
|
|---|
| 5071 | static FN_GetNumberOfEventLogRecords *pfn = 0;
|
|---|
| 5072 | if (!pfn)
|
|---|
| 5073 | kPrf2WrapResolve((void **)&pfn, "GetNumberOfEventLogRecords", &g_Kernel32);
|
|---|
| 5074 | return pfn( hEventLog, NumberOfRecords );
|
|---|
| 5075 | }
|
|---|
| 5076 |
|
|---|
| 5077 | typedef BOOL WINAPI FN_GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord );
|
|---|
| 5078 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
|
|---|
| 5079 | {
|
|---|
| 5080 | static FN_GetOldestEventLogRecord *pfn = 0;
|
|---|
| 5081 | if (!pfn)
|
|---|
| 5082 | kPrf2WrapResolve((void **)&pfn, "GetOldestEventLogRecord", &g_Kernel32);
|
|---|
| 5083 | return pfn( hEventLog, OldestRecord );
|
|---|
| 5084 | }
|
|---|
| 5085 |
|
|---|
| 5086 | typedef HANDLE WINAPI FN_OpenEventLogA( LPCSTR lpUNCServerName, LPCSTR lpSourceName );
|
|---|
| 5087 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventLogA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
|
|---|
| 5088 | {
|
|---|
| 5089 | static FN_OpenEventLogA *pfn = 0;
|
|---|
| 5090 | if (!pfn)
|
|---|
| 5091 | kPrf2WrapResolve((void **)&pfn, "OpenEventLogA", &g_Kernel32);
|
|---|
| 5092 | return pfn( lpUNCServerName, lpSourceName );
|
|---|
| 5093 | }
|
|---|
| 5094 |
|
|---|
| 5095 | typedef HANDLE WINAPI FN_OpenEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName );
|
|---|
| 5096 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
|
|---|
| 5097 | {
|
|---|
| 5098 | static FN_OpenEventLogW *pfn = 0;
|
|---|
| 5099 | if (!pfn)
|
|---|
| 5100 | kPrf2WrapResolve((void **)&pfn, "OpenEventLogW", &g_Kernel32);
|
|---|
| 5101 | return pfn( lpUNCServerName, lpSourceName );
|
|---|
| 5102 | }
|
|---|
| 5103 |
|
|---|
| 5104 | typedef HANDLE WINAPI FN_RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName );
|
|---|
| 5105 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
|
|---|
| 5106 | {
|
|---|
| 5107 | static FN_RegisterEventSourceA *pfn = 0;
|
|---|
| 5108 | if (!pfn)
|
|---|
| 5109 | kPrf2WrapResolve((void **)&pfn, "RegisterEventSourceA", &g_Kernel32);
|
|---|
| 5110 | return pfn( lpUNCServerName, lpSourceName );
|
|---|
| 5111 | }
|
|---|
| 5112 |
|
|---|
| 5113 | typedef HANDLE WINAPI FN_RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName );
|
|---|
| 5114 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
|
|---|
| 5115 | {
|
|---|
| 5116 | static FN_RegisterEventSourceW *pfn = 0;
|
|---|
| 5117 | if (!pfn)
|
|---|
| 5118 | kPrf2WrapResolve((void **)&pfn, "RegisterEventSourceW", &g_Kernel32);
|
|---|
| 5119 | return pfn( lpUNCServerName, lpSourceName );
|
|---|
| 5120 | }
|
|---|
| 5121 |
|
|---|
| 5122 | typedef HANDLE WINAPI FN_OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName );
|
|---|
| 5123 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
|
|---|
| 5124 | {
|
|---|
| 5125 | static FN_OpenBackupEventLogA *pfn = 0;
|
|---|
| 5126 | if (!pfn)
|
|---|
| 5127 | kPrf2WrapResolve((void **)&pfn, "OpenBackupEventLogA", &g_Kernel32);
|
|---|
| 5128 | return pfn( lpUNCServerName, lpFileName );
|
|---|
| 5129 | }
|
|---|
| 5130 |
|
|---|
| 5131 | typedef HANDLE WINAPI FN_OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName );
|
|---|
| 5132 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
|
|---|
| 5133 | {
|
|---|
| 5134 | static FN_OpenBackupEventLogW *pfn = 0;
|
|---|
| 5135 | if (!pfn)
|
|---|
| 5136 | kPrf2WrapResolve((void **)&pfn, "OpenBackupEventLogW", &g_Kernel32);
|
|---|
| 5137 | return pfn( lpUNCServerName, lpFileName );
|
|---|
| 5138 | }
|
|---|
| 5139 |
|
|---|
| 5140 | typedef BOOL WINAPI FN_ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded );
|
|---|
| 5141 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded )
|
|---|
| 5142 | {
|
|---|
| 5143 | static FN_ReadEventLogA *pfn = 0;
|
|---|
| 5144 | if (!pfn)
|
|---|
| 5145 | kPrf2WrapResolve((void **)&pfn, "ReadEventLogA", &g_Kernel32);
|
|---|
| 5146 | return pfn( hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded );
|
|---|
| 5147 | }
|
|---|
| 5148 |
|
|---|
| 5149 | typedef BOOL WINAPI FN_ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded );
|
|---|
| 5150 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded )
|
|---|
| 5151 | {
|
|---|
| 5152 | static FN_ReadEventLogW *pfn = 0;
|
|---|
| 5153 | if (!pfn)
|
|---|
| 5154 | kPrf2WrapResolve((void **)&pfn, "ReadEventLogW", &g_Kernel32);
|
|---|
| 5155 | return pfn( hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded );
|
|---|
| 5156 | }
|
|---|
| 5157 |
|
|---|
| 5158 | typedef BOOL WINAPI FN_ReportEventA( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR * lpStrings, LPVOID lpRawData );
|
|---|
| 5159 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReportEventA( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR * lpStrings, LPVOID lpRawData )
|
|---|
| 5160 | {
|
|---|
| 5161 | static FN_ReportEventA *pfn = 0;
|
|---|
| 5162 | if (!pfn)
|
|---|
| 5163 | kPrf2WrapResolve((void **)&pfn, "ReportEventA", &g_Kernel32);
|
|---|
| 5164 | return pfn( hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData );
|
|---|
| 5165 | }
|
|---|
| 5166 |
|
|---|
| 5167 | typedef BOOL WINAPI FN_ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR * lpStrings, LPVOID lpRawData );
|
|---|
| 5168 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR * lpStrings, LPVOID lpRawData )
|
|---|
| 5169 | {
|
|---|
| 5170 | static FN_ReportEventW *pfn = 0;
|
|---|
| 5171 | if (!pfn)
|
|---|
| 5172 | kPrf2WrapResolve((void **)&pfn, "ReportEventW", &g_Kernel32);
|
|---|
| 5173 | return pfn( hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData );
|
|---|
| 5174 | }
|
|---|
| 5175 |
|
|---|
| 5176 | typedef BOOL WINAPI FN_GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded );
|
|---|
| 5177 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded )
|
|---|
| 5178 | {
|
|---|
| 5179 | static FN_GetEventLogInformation *pfn = 0;
|
|---|
| 5180 | if (!pfn)
|
|---|
| 5181 | kPrf2WrapResolve((void **)&pfn, "GetEventLogInformation", &g_Kernel32);
|
|---|
| 5182 | return pfn( hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded );
|
|---|
| 5183 | }
|
|---|
| 5184 |
|
|---|
| 5185 | typedef BOOL WINAPI FN_DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle );
|
|---|
| 5186 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle )
|
|---|
| 5187 | {
|
|---|
| 5188 | static FN_DuplicateToken *pfn = 0;
|
|---|
| 5189 | if (!pfn)
|
|---|
| 5190 | kPrf2WrapResolve((void **)&pfn, "DuplicateToken", &g_Kernel32);
|
|---|
| 5191 | return pfn( ExistingTokenHandle, ImpersonationLevel, DuplicateTokenHandle );
|
|---|
| 5192 | }
|
|---|
| 5193 |
|
|---|
| 5194 | typedef BOOL WINAPI FN_GetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
|
|---|
| 5195 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
|
|---|
| 5196 | {
|
|---|
| 5197 | static FN_GetKernelObjectSecurity *pfn = 0;
|
|---|
| 5198 | if (!pfn)
|
|---|
| 5199 | kPrf2WrapResolve((void **)&pfn, "GetKernelObjectSecurity", &g_Kernel32);
|
|---|
| 5200 | return pfn( Handle, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
|
|---|
| 5201 | }
|
|---|
| 5202 |
|
|---|
| 5203 | typedef BOOL WINAPI FN_ImpersonateNamedPipeClient( HANDLE hNamedPipe );
|
|---|
| 5204 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateNamedPipeClient( HANDLE hNamedPipe )
|
|---|
| 5205 | {
|
|---|
| 5206 | static FN_ImpersonateNamedPipeClient *pfn = 0;
|
|---|
| 5207 | if (!pfn)
|
|---|
| 5208 | kPrf2WrapResolve((void **)&pfn, "ImpersonateNamedPipeClient", &g_Kernel32);
|
|---|
| 5209 | return pfn( hNamedPipe );
|
|---|
| 5210 | }
|
|---|
| 5211 |
|
|---|
| 5212 | typedef BOOL WINAPI FN_ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel );
|
|---|
| 5213 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel )
|
|---|
| 5214 | {
|
|---|
| 5215 | static FN_ImpersonateSelf *pfn = 0;
|
|---|
| 5216 | if (!pfn)
|
|---|
| 5217 | kPrf2WrapResolve((void **)&pfn, "ImpersonateSelf", &g_Kernel32);
|
|---|
| 5218 | return pfn( ImpersonationLevel );
|
|---|
| 5219 | }
|
|---|
| 5220 |
|
|---|
| 5221 | typedef BOOL WINAPI FN_RevertToSelf( VOID );
|
|---|
| 5222 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RevertToSelf( VOID )
|
|---|
| 5223 | {
|
|---|
| 5224 | static FN_RevertToSelf *pfn = 0;
|
|---|
| 5225 | if (!pfn)
|
|---|
| 5226 | kPrf2WrapResolve((void **)&pfn, "RevertToSelf", &g_Kernel32);
|
|---|
| 5227 | return pfn ();
|
|---|
| 5228 | }
|
|---|
| 5229 |
|
|---|
| 5230 | typedef BOOL APIENTRY FN_SetThreadToken( PHANDLE Thread, HANDLE Token );
|
|---|
| 5231 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_SetThreadToken( PHANDLE Thread, HANDLE Token )
|
|---|
| 5232 | {
|
|---|
| 5233 | static FN_SetThreadToken *pfn = 0;
|
|---|
| 5234 | if (!pfn)
|
|---|
| 5235 | kPrf2WrapResolve((void **)&pfn, "SetThreadToken", &g_Kernel32);
|
|---|
| 5236 | return pfn( Thread, Token );
|
|---|
| 5237 | }
|
|---|
| 5238 |
|
|---|
| 5239 | typedef BOOL WINAPI FN_AccessCheck( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus );
|
|---|
| 5240 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheck( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus )
|
|---|
| 5241 | {
|
|---|
| 5242 | static FN_AccessCheck *pfn = 0;
|
|---|
| 5243 | if (!pfn)
|
|---|
| 5244 | kPrf2WrapResolve((void **)&pfn, "AccessCheck", &g_Kernel32);
|
|---|
| 5245 | return pfn( pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus );
|
|---|
| 5246 | }
|
|---|
| 5247 |
|
|---|
| 5248 | typedef BOOL WINAPI FN_AccessCheckByType( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus );
|
|---|
| 5249 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByType( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus )
|
|---|
| 5250 | {
|
|---|
| 5251 | static FN_AccessCheckByType *pfn = 0;
|
|---|
| 5252 | if (!pfn)
|
|---|
| 5253 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByType", &g_Kernel32);
|
|---|
| 5254 | return pfn( pSecurityDescriptor, PrincipalSelfSid, ClientToken, DesiredAccess, ObjectTypeList, ObjectTypeListLength, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus );
|
|---|
| 5255 | }
|
|---|
| 5256 |
|
|---|
| 5257 | typedef BOOL WINAPI FN_AccessCheckByTypeResultList( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList );
|
|---|
| 5258 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultList( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList )
|
|---|
| 5259 | {
|
|---|
| 5260 | static FN_AccessCheckByTypeResultList *pfn = 0;
|
|---|
| 5261 | if (!pfn)
|
|---|
| 5262 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultList", &g_Kernel32);
|
|---|
| 5263 | return pfn( pSecurityDescriptor, PrincipalSelfSid, ClientToken, DesiredAccess, ObjectTypeList, ObjectTypeListLength, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccessList, AccessStatusList );
|
|---|
| 5264 | }
|
|---|
| 5265 |
|
|---|
| 5266 | typedef BOOL WINAPI FN_OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle );
|
|---|
| 5267 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle )
|
|---|
| 5268 | {
|
|---|
| 5269 | static FN_OpenProcessToken *pfn = 0;
|
|---|
| 5270 | if (!pfn)
|
|---|
| 5271 | kPrf2WrapResolve((void **)&pfn, "OpenProcessToken", &g_Kernel32);
|
|---|
| 5272 | return pfn( ProcessHandle, DesiredAccess, TokenHandle );
|
|---|
| 5273 | }
|
|---|
| 5274 |
|
|---|
| 5275 | typedef BOOL WINAPI FN_OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle );
|
|---|
| 5276 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle )
|
|---|
| 5277 | {
|
|---|
| 5278 | static FN_OpenThreadToken *pfn = 0;
|
|---|
| 5279 | if (!pfn)
|
|---|
| 5280 | kPrf2WrapResolve((void **)&pfn, "OpenThreadToken", &g_Kernel32);
|
|---|
| 5281 | return pfn( ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle );
|
|---|
| 5282 | }
|
|---|
| 5283 |
|
|---|
| 5284 | typedef BOOL WINAPI FN_GetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength );
|
|---|
| 5285 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength )
|
|---|
| 5286 | {
|
|---|
| 5287 | static FN_GetTokenInformation *pfn = 0;
|
|---|
| 5288 | if (!pfn)
|
|---|
| 5289 | kPrf2WrapResolve((void **)&pfn, "GetTokenInformation", &g_Kernel32);
|
|---|
| 5290 | return pfn( TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength, ReturnLength );
|
|---|
| 5291 | }
|
|---|
| 5292 |
|
|---|
| 5293 | typedef BOOL WINAPI FN_SetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength );
|
|---|
| 5294 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength )
|
|---|
| 5295 | {
|
|---|
| 5296 | static FN_SetTokenInformation *pfn = 0;
|
|---|
| 5297 | if (!pfn)
|
|---|
| 5298 | kPrf2WrapResolve((void **)&pfn, "SetTokenInformation", &g_Kernel32);
|
|---|
| 5299 | return pfn( TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength );
|
|---|
| 5300 | }
|
|---|
| 5301 |
|
|---|
| 5302 | typedef BOOL WINAPI FN_AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength );
|
|---|
| 5303 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength )
|
|---|
| 5304 | {
|
|---|
| 5305 | static FN_AdjustTokenPrivileges *pfn = 0;
|
|---|
| 5306 | if (!pfn)
|
|---|
| 5307 | kPrf2WrapResolve((void **)&pfn, "AdjustTokenPrivileges", &g_Kernel32);
|
|---|
| 5308 | return pfn( TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength );
|
|---|
| 5309 | }
|
|---|
| 5310 |
|
|---|
| 5311 | typedef BOOL WINAPI FN_AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength );
|
|---|
| 5312 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength )
|
|---|
| 5313 | {
|
|---|
| 5314 | static FN_AdjustTokenGroups *pfn = 0;
|
|---|
| 5315 | if (!pfn)
|
|---|
| 5316 | kPrf2WrapResolve((void **)&pfn, "AdjustTokenGroups", &g_Kernel32);
|
|---|
| 5317 | return pfn( TokenHandle, ResetToDefault, NewState, BufferLength, PreviousState, ReturnLength );
|
|---|
| 5318 | }
|
|---|
| 5319 |
|
|---|
| 5320 | typedef BOOL WINAPI FN_PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult );
|
|---|
| 5321 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult )
|
|---|
| 5322 | {
|
|---|
| 5323 | static FN_PrivilegeCheck *pfn = 0;
|
|---|
| 5324 | if (!pfn)
|
|---|
| 5325 | kPrf2WrapResolve((void **)&pfn, "PrivilegeCheck", &g_Kernel32);
|
|---|
| 5326 | return pfn( ClientToken, RequiredPrivileges, pfResult );
|
|---|
| 5327 | }
|
|---|
| 5328 |
|
|---|
| 5329 | typedef BOOL WINAPI FN_AccessCheckAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
|
|---|
| 5330 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
|
|---|
| 5331 | {
|
|---|
| 5332 | static FN_AccessCheckAndAuditAlarmA *pfn = 0;
|
|---|
| 5333 | if (!pfn)
|
|---|
| 5334 | kPrf2WrapResolve((void **)&pfn, "AccessCheckAndAuditAlarmA", &g_Kernel32);
|
|---|
| 5335 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
|
|---|
| 5336 | }
|
|---|
| 5337 |
|
|---|
| 5338 | typedef BOOL WINAPI FN_AccessCheckAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
|
|---|
| 5339 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
|
|---|
| 5340 | {
|
|---|
| 5341 | static FN_AccessCheckAndAuditAlarmW *pfn = 0;
|
|---|
| 5342 | if (!pfn)
|
|---|
| 5343 | kPrf2WrapResolve((void **)&pfn, "AccessCheckAndAuditAlarmW", &g_Kernel32);
|
|---|
| 5344 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
|
|---|
| 5345 | }
|
|---|
| 5346 |
|
|---|
| 5347 | typedef BOOL WINAPI FN_AccessCheckByTypeAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
|
|---|
| 5348 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
|
|---|
| 5349 | {
|
|---|
| 5350 | static FN_AccessCheckByTypeAndAuditAlarmA *pfn = 0;
|
|---|
| 5351 | if (!pfn)
|
|---|
| 5352 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeAndAuditAlarmA", &g_Kernel32);
|
|---|
| 5353 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
|
|---|
| 5354 | }
|
|---|
| 5355 |
|
|---|
| 5356 | typedef BOOL WINAPI FN_AccessCheckByTypeAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
|
|---|
| 5357 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
|
|---|
| 5358 | {
|
|---|
| 5359 | static FN_AccessCheckByTypeAndAuditAlarmW *pfn = 0;
|
|---|
| 5360 | if (!pfn)
|
|---|
| 5361 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeAndAuditAlarmW", &g_Kernel32);
|
|---|
| 5362 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
|
|---|
| 5363 | }
|
|---|
| 5364 |
|
|---|
| 5365 | typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
|
|---|
| 5366 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
|
|---|
| 5367 | {
|
|---|
| 5368 | static FN_AccessCheckByTypeResultListAndAuditAlarmA *pfn = 0;
|
|---|
| 5369 | if (!pfn)
|
|---|
| 5370 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmA", &g_Kernel32);
|
|---|
| 5371 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
|
|---|
| 5372 | }
|
|---|
| 5373 |
|
|---|
| 5374 | typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
|
|---|
| 5375 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
|
|---|
| 5376 | {
|
|---|
| 5377 | static FN_AccessCheckByTypeResultListAndAuditAlarmW *pfn = 0;
|
|---|
| 5378 | if (!pfn)
|
|---|
| 5379 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmW", &g_Kernel32);
|
|---|
| 5380 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
|
|---|
| 5381 | }
|
|---|
| 5382 |
|
|---|
| 5383 | typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmByHandleA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
|
|---|
| 5384 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmByHandleA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
|
|---|
| 5385 | {
|
|---|
| 5386 | static FN_AccessCheckByTypeResultListAndAuditAlarmByHandleA *pfn = 0;
|
|---|
| 5387 | if (!pfn)
|
|---|
| 5388 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmByHandleA", &g_Kernel32);
|
|---|
| 5389 | return pfn( SubsystemName, HandleId, ClientToken, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
|
|---|
| 5390 | }
|
|---|
| 5391 |
|
|---|
| 5392 | typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmByHandleW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
|
|---|
| 5393 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmByHandleW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
|
|---|
| 5394 | {
|
|---|
| 5395 | static FN_AccessCheckByTypeResultListAndAuditAlarmByHandleW *pfn = 0;
|
|---|
| 5396 | if (!pfn)
|
|---|
| 5397 | kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmByHandleW", &g_Kernel32);
|
|---|
| 5398 | return pfn( SubsystemName, HandleId, ClientToken, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
|
|---|
| 5399 | }
|
|---|
| 5400 |
|
|---|
| 5401 | typedef BOOL WINAPI FN_ObjectOpenAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose );
|
|---|
| 5402 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectOpenAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose )
|
|---|
| 5403 | {
|
|---|
| 5404 | static FN_ObjectOpenAuditAlarmA *pfn = 0;
|
|---|
| 5405 | if (!pfn)
|
|---|
| 5406 | kPrf2WrapResolve((void **)&pfn, "ObjectOpenAuditAlarmA", &g_Kernel32);
|
|---|
| 5407 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose );
|
|---|
| 5408 | }
|
|---|
| 5409 |
|
|---|
| 5410 | typedef BOOL WINAPI FN_ObjectOpenAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose );
|
|---|
| 5411 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectOpenAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose )
|
|---|
| 5412 | {
|
|---|
| 5413 | static FN_ObjectOpenAuditAlarmW *pfn = 0;
|
|---|
| 5414 | if (!pfn)
|
|---|
| 5415 | kPrf2WrapResolve((void **)&pfn, "ObjectOpenAuditAlarmW", &g_Kernel32);
|
|---|
| 5416 | return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose );
|
|---|
| 5417 | }
|
|---|
| 5418 |
|
|---|
| 5419 | typedef BOOL WINAPI FN_ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
|
|---|
| 5420 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
|
|---|
| 5421 | {
|
|---|
| 5422 | static FN_ObjectPrivilegeAuditAlarmA *pfn = 0;
|
|---|
| 5423 | if (!pfn)
|
|---|
| 5424 | kPrf2WrapResolve((void **)&pfn, "ObjectPrivilegeAuditAlarmA", &g_Kernel32);
|
|---|
| 5425 | return pfn( SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted );
|
|---|
| 5426 | }
|
|---|
| 5427 |
|
|---|
| 5428 | typedef BOOL WINAPI FN_ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
|
|---|
| 5429 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
|
|---|
| 5430 | {
|
|---|
| 5431 | static FN_ObjectPrivilegeAuditAlarmW *pfn = 0;
|
|---|
| 5432 | if (!pfn)
|
|---|
| 5433 | kPrf2WrapResolve((void **)&pfn, "ObjectPrivilegeAuditAlarmW", &g_Kernel32);
|
|---|
| 5434 | return pfn( SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted );
|
|---|
| 5435 | }
|
|---|
| 5436 |
|
|---|
| 5437 | typedef BOOL WINAPI FN_ObjectCloseAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
|
|---|
| 5438 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectCloseAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
|
|---|
| 5439 | {
|
|---|
| 5440 | static FN_ObjectCloseAuditAlarmA *pfn = 0;
|
|---|
| 5441 | if (!pfn)
|
|---|
| 5442 | kPrf2WrapResolve((void **)&pfn, "ObjectCloseAuditAlarmA", &g_Kernel32);
|
|---|
| 5443 | return pfn( SubsystemName, HandleId, GenerateOnClose );
|
|---|
| 5444 | }
|
|---|
| 5445 |
|
|---|
| 5446 | typedef BOOL WINAPI FN_ObjectCloseAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
|
|---|
| 5447 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectCloseAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
|
|---|
| 5448 | {
|
|---|
| 5449 | static FN_ObjectCloseAuditAlarmW *pfn = 0;
|
|---|
| 5450 | if (!pfn)
|
|---|
| 5451 | kPrf2WrapResolve((void **)&pfn, "ObjectCloseAuditAlarmW", &g_Kernel32);
|
|---|
| 5452 | return pfn( SubsystemName, HandleId, GenerateOnClose );
|
|---|
| 5453 | }
|
|---|
| 5454 |
|
|---|
| 5455 | typedef BOOL WINAPI FN_ObjectDeleteAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
|
|---|
| 5456 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectDeleteAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
|
|---|
| 5457 | {
|
|---|
| 5458 | static FN_ObjectDeleteAuditAlarmA *pfn = 0;
|
|---|
| 5459 | if (!pfn)
|
|---|
| 5460 | kPrf2WrapResolve((void **)&pfn, "ObjectDeleteAuditAlarmA", &g_Kernel32);
|
|---|
| 5461 | return pfn( SubsystemName, HandleId, GenerateOnClose );
|
|---|
| 5462 | }
|
|---|
| 5463 |
|
|---|
| 5464 | typedef BOOL WINAPI FN_ObjectDeleteAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
|
|---|
| 5465 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectDeleteAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
|
|---|
| 5466 | {
|
|---|
| 5467 | static FN_ObjectDeleteAuditAlarmW *pfn = 0;
|
|---|
| 5468 | if (!pfn)
|
|---|
| 5469 | kPrf2WrapResolve((void **)&pfn, "ObjectDeleteAuditAlarmW", &g_Kernel32);
|
|---|
| 5470 | return pfn( SubsystemName, HandleId, GenerateOnClose );
|
|---|
| 5471 | }
|
|---|
| 5472 |
|
|---|
| 5473 | typedef BOOL WINAPI FN_PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
|
|---|
| 5474 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
|
|---|
| 5475 | {
|
|---|
| 5476 | static FN_PrivilegedServiceAuditAlarmA *pfn = 0;
|
|---|
| 5477 | if (!pfn)
|
|---|
| 5478 | kPrf2WrapResolve((void **)&pfn, "PrivilegedServiceAuditAlarmA", &g_Kernel32);
|
|---|
| 5479 | return pfn( SubsystemName, ServiceName, ClientToken, Privileges, AccessGranted );
|
|---|
| 5480 | }
|
|---|
| 5481 |
|
|---|
| 5482 | typedef BOOL WINAPI FN_PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
|
|---|
| 5483 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
|
|---|
| 5484 | {
|
|---|
| 5485 | static FN_PrivilegedServiceAuditAlarmW *pfn = 0;
|
|---|
| 5486 | if (!pfn)
|
|---|
| 5487 | kPrf2WrapResolve((void **)&pfn, "PrivilegedServiceAuditAlarmW", &g_Kernel32);
|
|---|
| 5488 | return pfn( SubsystemName, ServiceName, ClientToken, Privileges, AccessGranted );
|
|---|
| 5489 | }
|
|---|
| 5490 |
|
|---|
| 5491 | typedef BOOL WINAPI FN_IsWellKnownSid( PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType );
|
|---|
| 5492 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsWellKnownSid( PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType )
|
|---|
| 5493 | {
|
|---|
| 5494 | static FN_IsWellKnownSid *pfn = 0;
|
|---|
| 5495 | if (!pfn)
|
|---|
| 5496 | kPrf2WrapResolve((void **)&pfn, "IsWellKnownSid", &g_Kernel32);
|
|---|
| 5497 | return pfn( pSid, WellKnownSidType );
|
|---|
| 5498 | }
|
|---|
| 5499 |
|
|---|
| 5500 | typedef BOOL WINAPI FN_CreateWellKnownSid( WELL_KNOWN_SID_TYPE WellKnownSidType, PSID DomainSid, PSID pSid, DWORD * cbSid );
|
|---|
| 5501 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateWellKnownSid( WELL_KNOWN_SID_TYPE WellKnownSidType, PSID DomainSid, PSID pSid, DWORD * cbSid )
|
|---|
| 5502 | {
|
|---|
| 5503 | static FN_CreateWellKnownSid *pfn = 0;
|
|---|
| 5504 | if (!pfn)
|
|---|
| 5505 | kPrf2WrapResolve((void **)&pfn, "CreateWellKnownSid", &g_Kernel32);
|
|---|
| 5506 | return pfn( WellKnownSidType, DomainSid, pSid, cbSid );
|
|---|
| 5507 | }
|
|---|
| 5508 |
|
|---|
| 5509 | typedef BOOL WINAPI FN_EqualDomainSid( PSID pSid1, PSID pSid2, BOOL * pfEqual );
|
|---|
| 5510 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualDomainSid( PSID pSid1, PSID pSid2, BOOL * pfEqual )
|
|---|
| 5511 | {
|
|---|
| 5512 | static FN_EqualDomainSid *pfn = 0;
|
|---|
| 5513 | if (!pfn)
|
|---|
| 5514 | kPrf2WrapResolve((void **)&pfn, "EqualDomainSid", &g_Kernel32);
|
|---|
| 5515 | return pfn( pSid1, pSid2, pfEqual );
|
|---|
| 5516 | }
|
|---|
| 5517 |
|
|---|
| 5518 | typedef BOOL WINAPI FN_GetWindowsAccountDomainSid( PSID pSid, PSID pDomainSid, DWORD * cbDomainSid );
|
|---|
| 5519 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetWindowsAccountDomainSid( PSID pSid, PSID pDomainSid, DWORD * cbDomainSid )
|
|---|
| 5520 | {
|
|---|
| 5521 | static FN_GetWindowsAccountDomainSid *pfn = 0;
|
|---|
| 5522 | if (!pfn)
|
|---|
| 5523 | kPrf2WrapResolve((void **)&pfn, "GetWindowsAccountDomainSid", &g_Kernel32);
|
|---|
| 5524 | return pfn( pSid, pDomainSid, cbDomainSid );
|
|---|
| 5525 | }
|
|---|
| 5526 |
|
|---|
| 5527 | typedef BOOL WINAPI FN_IsValidSid( PSID pSid );
|
|---|
| 5528 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidSid( PSID pSid )
|
|---|
| 5529 | {
|
|---|
| 5530 | static FN_IsValidSid *pfn = 0;
|
|---|
| 5531 | if (!pfn)
|
|---|
| 5532 | kPrf2WrapResolve((void **)&pfn, "IsValidSid", &g_Kernel32);
|
|---|
| 5533 | return pfn( pSid );
|
|---|
| 5534 | }
|
|---|
| 5535 |
|
|---|
| 5536 | typedef BOOL WINAPI FN_EqualSid( PSID pSid1, PSID pSid2 );
|
|---|
| 5537 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualSid( PSID pSid1, PSID pSid2 )
|
|---|
| 5538 | {
|
|---|
| 5539 | static FN_EqualSid *pfn = 0;
|
|---|
| 5540 | if (!pfn)
|
|---|
| 5541 | kPrf2WrapResolve((void **)&pfn, "EqualSid", &g_Kernel32);
|
|---|
| 5542 | return pfn( pSid1, pSid2 );
|
|---|
| 5543 | }
|
|---|
| 5544 |
|
|---|
| 5545 | typedef BOOL WINAPI FN_EqualPrefixSid( PSID pSid1, PSID pSid2 );
|
|---|
| 5546 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualPrefixSid( PSID pSid1, PSID pSid2 )
|
|---|
| 5547 | {
|
|---|
| 5548 | static FN_EqualPrefixSid *pfn = 0;
|
|---|
| 5549 | if (!pfn)
|
|---|
| 5550 | kPrf2WrapResolve((void **)&pfn, "EqualPrefixSid", &g_Kernel32);
|
|---|
| 5551 | return pfn( pSid1, pSid2 );
|
|---|
| 5552 | }
|
|---|
| 5553 |
|
|---|
| 5554 | typedef DWORD WINAPI FN_GetSidLengthRequired( UCHAR nSubAuthorityCount );
|
|---|
| 5555 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSidLengthRequired( UCHAR nSubAuthorityCount )
|
|---|
| 5556 | {
|
|---|
| 5557 | static FN_GetSidLengthRequired *pfn = 0;
|
|---|
| 5558 | if (!pfn)
|
|---|
| 5559 | kPrf2WrapResolve((void **)&pfn, "GetSidLengthRequired", &g_Kernel32);
|
|---|
| 5560 | return pfn( nSubAuthorityCount );
|
|---|
| 5561 | }
|
|---|
| 5562 |
|
|---|
| 5563 | typedef BOOL WINAPI FN_AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID * pSid );
|
|---|
| 5564 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID * pSid )
|
|---|
| 5565 | {
|
|---|
| 5566 | static FN_AllocateAndInitializeSid *pfn = 0;
|
|---|
| 5567 | if (!pfn)
|
|---|
| 5568 | kPrf2WrapResolve((void **)&pfn, "AllocateAndInitializeSid", &g_Kernel32);
|
|---|
| 5569 | return pfn( pIdentifierAuthority, nSubAuthorityCount, nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3, nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7, pSid );
|
|---|
| 5570 | }
|
|---|
| 5571 |
|
|---|
| 5572 | typedef PVOID WINAPI FN_FreeSid( PSID pSid );
|
|---|
| 5573 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_FreeSid( PSID pSid )
|
|---|
| 5574 | {
|
|---|
| 5575 | static FN_FreeSid *pfn = 0;
|
|---|
| 5576 | if (!pfn)
|
|---|
| 5577 | kPrf2WrapResolve((void **)&pfn, "FreeSid", &g_Kernel32);
|
|---|
| 5578 | return pfn( pSid );
|
|---|
| 5579 | }
|
|---|
| 5580 |
|
|---|
| 5581 | typedef BOOL WINAPI FN_InitializeSid( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount );
|
|---|
| 5582 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeSid( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount )
|
|---|
| 5583 | {
|
|---|
| 5584 | static FN_InitializeSid *pfn = 0;
|
|---|
| 5585 | if (!pfn)
|
|---|
| 5586 | kPrf2WrapResolve((void **)&pfn, "InitializeSid", &g_Kernel32);
|
|---|
| 5587 | return pfn( Sid, pIdentifierAuthority, nSubAuthorityCount );
|
|---|
| 5588 | }
|
|---|
| 5589 |
|
|---|
| 5590 | typedef PSID_IDENTIFIER_AUTHORITY WINAPI FN_GetSidIdentifierAuthority( PSID pSid );
|
|---|
| 5591 | __declspec(dllexport) PSID_IDENTIFIER_AUTHORITY WINAPI kPrf2Wrap_GetSidIdentifierAuthority( PSID pSid )
|
|---|
| 5592 | {
|
|---|
| 5593 | static FN_GetSidIdentifierAuthority *pfn = 0;
|
|---|
| 5594 | if (!pfn)
|
|---|
| 5595 | kPrf2WrapResolve((void **)&pfn, "GetSidIdentifierAuthority", &g_Kernel32);
|
|---|
| 5596 | return pfn( pSid );
|
|---|
| 5597 | }
|
|---|
| 5598 |
|
|---|
| 5599 | typedef PDWORD WINAPI FN_GetSidSubAuthority( PSID pSid, DWORD nSubAuthority );
|
|---|
| 5600 | __declspec(dllexport) PDWORD WINAPI kPrf2Wrap_GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
|
|---|
| 5601 | {
|
|---|
| 5602 | static FN_GetSidSubAuthority *pfn = 0;
|
|---|
| 5603 | if (!pfn)
|
|---|
| 5604 | kPrf2WrapResolve((void **)&pfn, "GetSidSubAuthority", &g_Kernel32);
|
|---|
| 5605 | return pfn( pSid, nSubAuthority );
|
|---|
| 5606 | }
|
|---|
| 5607 |
|
|---|
| 5608 | typedef PUCHAR WINAPI FN_GetSidSubAuthorityCount( PSID pSid );
|
|---|
| 5609 | __declspec(dllexport) PUCHAR WINAPI kPrf2Wrap_GetSidSubAuthorityCount( PSID pSid )
|
|---|
| 5610 | {
|
|---|
| 5611 | static FN_GetSidSubAuthorityCount *pfn = 0;
|
|---|
| 5612 | if (!pfn)
|
|---|
| 5613 | kPrf2WrapResolve((void **)&pfn, "GetSidSubAuthorityCount", &g_Kernel32);
|
|---|
| 5614 | return pfn( pSid );
|
|---|
| 5615 | }
|
|---|
| 5616 |
|
|---|
| 5617 | typedef DWORD WINAPI FN_GetLengthSid( PSID pSid );
|
|---|
| 5618 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLengthSid( PSID pSid )
|
|---|
| 5619 | {
|
|---|
| 5620 | static FN_GetLengthSid *pfn = 0;
|
|---|
| 5621 | if (!pfn)
|
|---|
| 5622 | kPrf2WrapResolve((void **)&pfn, "GetLengthSid", &g_Kernel32);
|
|---|
| 5623 | return pfn( pSid );
|
|---|
| 5624 | }
|
|---|
| 5625 |
|
|---|
| 5626 | typedef BOOL WINAPI FN_CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid );
|
|---|
| 5627 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
|
|---|
| 5628 | {
|
|---|
| 5629 | static FN_CopySid *pfn = 0;
|
|---|
| 5630 | if (!pfn)
|
|---|
| 5631 | kPrf2WrapResolve((void **)&pfn, "CopySid", &g_Kernel32);
|
|---|
| 5632 | return pfn( nDestinationSidLength, pDestinationSid, pSourceSid );
|
|---|
| 5633 | }
|
|---|
| 5634 |
|
|---|
| 5635 | typedef BOOL WINAPI FN_AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess );
|
|---|
| 5636 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
|
|---|
| 5637 | {
|
|---|
| 5638 | static FN_AreAllAccessesGranted *pfn = 0;
|
|---|
| 5639 | if (!pfn)
|
|---|
| 5640 | kPrf2WrapResolve((void **)&pfn, "AreAllAccessesGranted", &g_Kernel32);
|
|---|
| 5641 | return pfn( GrantedAccess, DesiredAccess );
|
|---|
| 5642 | }
|
|---|
| 5643 |
|
|---|
| 5644 | typedef BOOL WINAPI FN_AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess );
|
|---|
| 5645 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
|
|---|
| 5646 | {
|
|---|
| 5647 | static FN_AreAnyAccessesGranted *pfn = 0;
|
|---|
| 5648 | if (!pfn)
|
|---|
| 5649 | kPrf2WrapResolve((void **)&pfn, "AreAnyAccessesGranted", &g_Kernel32);
|
|---|
| 5650 | return pfn( GrantedAccess, DesiredAccess );
|
|---|
| 5651 | }
|
|---|
| 5652 |
|
|---|
| 5653 | typedef VOID WINAPI FN_MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping );
|
|---|
| 5654 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping )
|
|---|
| 5655 | {
|
|---|
| 5656 | static FN_MapGenericMask *pfn = 0;
|
|---|
| 5657 | if (!pfn)
|
|---|
| 5658 | kPrf2WrapResolve((void **)&pfn, "MapGenericMask", &g_Kernel32);
|
|---|
| 5659 | pfn( AccessMask, GenericMapping );
|
|---|
| 5660 | }
|
|---|
| 5661 |
|
|---|
| 5662 | typedef BOOL WINAPI FN_IsValidAcl( PACL pAcl );
|
|---|
| 5663 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidAcl( PACL pAcl )
|
|---|
| 5664 | {
|
|---|
| 5665 | static FN_IsValidAcl *pfn = 0;
|
|---|
| 5666 | if (!pfn)
|
|---|
| 5667 | kPrf2WrapResolve((void **)&pfn, "IsValidAcl", &g_Kernel32);
|
|---|
| 5668 | return pfn( pAcl );
|
|---|
| 5669 | }
|
|---|
| 5670 |
|
|---|
| 5671 | typedef BOOL WINAPI FN_InitializeAcl( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision );
|
|---|
| 5672 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeAcl( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision )
|
|---|
| 5673 | {
|
|---|
| 5674 | static FN_InitializeAcl *pfn = 0;
|
|---|
| 5675 | if (!pfn)
|
|---|
| 5676 | kPrf2WrapResolve((void **)&pfn, "InitializeAcl", &g_Kernel32);
|
|---|
| 5677 | return pfn( pAcl, nAclLength, dwAclRevision );
|
|---|
| 5678 | }
|
|---|
| 5679 |
|
|---|
| 5680 | typedef BOOL WINAPI FN_GetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass );
|
|---|
| 5681 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass )
|
|---|
| 5682 | {
|
|---|
| 5683 | static FN_GetAclInformation *pfn = 0;
|
|---|
| 5684 | if (!pfn)
|
|---|
| 5685 | kPrf2WrapResolve((void **)&pfn, "GetAclInformation", &g_Kernel32);
|
|---|
| 5686 | return pfn( pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass );
|
|---|
| 5687 | }
|
|---|
| 5688 |
|
|---|
| 5689 | typedef BOOL WINAPI FN_SetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass );
|
|---|
| 5690 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass )
|
|---|
| 5691 | {
|
|---|
| 5692 | static FN_SetAclInformation *pfn = 0;
|
|---|
| 5693 | if (!pfn)
|
|---|
| 5694 | kPrf2WrapResolve((void **)&pfn, "SetAclInformation", &g_Kernel32);
|
|---|
| 5695 | return pfn( pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass );
|
|---|
| 5696 | }
|
|---|
| 5697 |
|
|---|
| 5698 | typedef BOOL WINAPI FN_AddAce( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength );
|
|---|
| 5699 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAce( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength )
|
|---|
| 5700 | {
|
|---|
| 5701 | static FN_AddAce *pfn = 0;
|
|---|
| 5702 | if (!pfn)
|
|---|
| 5703 | kPrf2WrapResolve((void **)&pfn, "AddAce", &g_Kernel32);
|
|---|
| 5704 | return pfn( pAcl, dwAceRevision, dwStartingAceIndex, pAceList, nAceListLength );
|
|---|
| 5705 | }
|
|---|
| 5706 |
|
|---|
| 5707 | typedef BOOL WINAPI FN_DeleteAce( PACL pAcl, DWORD dwAceIndex );
|
|---|
| 5708 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteAce( PACL pAcl, DWORD dwAceIndex )
|
|---|
| 5709 | {
|
|---|
| 5710 | static FN_DeleteAce *pfn = 0;
|
|---|
| 5711 | if (!pfn)
|
|---|
| 5712 | kPrf2WrapResolve((void **)&pfn, "DeleteAce", &g_Kernel32);
|
|---|
| 5713 | return pfn( pAcl, dwAceIndex );
|
|---|
| 5714 | }
|
|---|
| 5715 |
|
|---|
| 5716 | typedef BOOL WINAPI FN_GetAce( PACL pAcl, DWORD dwAceIndex, LPVOID * pAce );
|
|---|
| 5717 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetAce( PACL pAcl, DWORD dwAceIndex, LPVOID * pAce )
|
|---|
| 5718 | {
|
|---|
| 5719 | static FN_GetAce *pfn = 0;
|
|---|
| 5720 | if (!pfn)
|
|---|
| 5721 | kPrf2WrapResolve((void **)&pfn, "GetAce", &g_Kernel32);
|
|---|
| 5722 | return pfn( pAcl, dwAceIndex, pAce );
|
|---|
| 5723 | }
|
|---|
| 5724 |
|
|---|
| 5725 | typedef BOOL WINAPI FN_AddAccessAllowedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid );
|
|---|
| 5726 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid )
|
|---|
| 5727 | {
|
|---|
| 5728 | static FN_AddAccessAllowedAce *pfn = 0;
|
|---|
| 5729 | if (!pfn)
|
|---|
| 5730 | kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedAce", &g_Kernel32);
|
|---|
| 5731 | return pfn( pAcl, dwAceRevision, AccessMask, pSid );
|
|---|
| 5732 | }
|
|---|
| 5733 |
|
|---|
| 5734 | typedef BOOL WINAPI FN_AddAccessAllowedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid );
|
|---|
| 5735 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid )
|
|---|
| 5736 | {
|
|---|
| 5737 | static FN_AddAccessAllowedAceEx *pfn = 0;
|
|---|
| 5738 | if (!pfn)
|
|---|
| 5739 | kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedAceEx", &g_Kernel32);
|
|---|
| 5740 | return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, pSid );
|
|---|
| 5741 | }
|
|---|
| 5742 |
|
|---|
| 5743 | typedef BOOL WINAPI FN_AddAccessDeniedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid );
|
|---|
| 5744 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid )
|
|---|
| 5745 | {
|
|---|
| 5746 | static FN_AddAccessDeniedAce *pfn = 0;
|
|---|
| 5747 | if (!pfn)
|
|---|
| 5748 | kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedAce", &g_Kernel32);
|
|---|
| 5749 | return pfn( pAcl, dwAceRevision, AccessMask, pSid );
|
|---|
| 5750 | }
|
|---|
| 5751 |
|
|---|
| 5752 | typedef BOOL WINAPI FN_AddAccessDeniedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid );
|
|---|
| 5753 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid )
|
|---|
| 5754 | {
|
|---|
| 5755 | static FN_AddAccessDeniedAceEx *pfn = 0;
|
|---|
| 5756 | if (!pfn)
|
|---|
| 5757 | kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedAceEx", &g_Kernel32);
|
|---|
| 5758 | return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, pSid );
|
|---|
| 5759 | }
|
|---|
| 5760 |
|
|---|
| 5761 | typedef BOOL WINAPI FN_AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
|
|---|
| 5762 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
|
|---|
| 5763 | {
|
|---|
| 5764 | static FN_AddAuditAccessAce *pfn = 0;
|
|---|
| 5765 | if (!pfn)
|
|---|
| 5766 | kPrf2WrapResolve((void **)&pfn, "AddAuditAccessAce", &g_Kernel32);
|
|---|
| 5767 | return pfn( pAcl, dwAceRevision, dwAccessMask, pSid, bAuditSuccess, bAuditFailure );
|
|---|
| 5768 | }
|
|---|
| 5769 |
|
|---|
| 5770 | typedef BOOL WINAPI FN_AddAuditAccessAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
|
|---|
| 5771 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
|
|---|
| 5772 | {
|
|---|
| 5773 | static FN_AddAuditAccessAceEx *pfn = 0;
|
|---|
| 5774 | if (!pfn)
|
|---|
| 5775 | kPrf2WrapResolve((void **)&pfn, "AddAuditAccessAceEx", &g_Kernel32);
|
|---|
| 5776 | return pfn( pAcl, dwAceRevision, AceFlags, dwAccessMask, pSid, bAuditSuccess, bAuditFailure );
|
|---|
| 5777 | }
|
|---|
| 5778 |
|
|---|
| 5779 | typedef BOOL WINAPI FN_AddAccessAllowedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid );
|
|---|
| 5780 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid )
|
|---|
| 5781 | {
|
|---|
| 5782 | static FN_AddAccessAllowedObjectAce *pfn = 0;
|
|---|
| 5783 | if (!pfn)
|
|---|
| 5784 | kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedObjectAce", &g_Kernel32);
|
|---|
| 5785 | return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid );
|
|---|
| 5786 | }
|
|---|
| 5787 |
|
|---|
| 5788 | typedef BOOL WINAPI FN_AddAccessDeniedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid );
|
|---|
| 5789 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid )
|
|---|
| 5790 | {
|
|---|
| 5791 | static FN_AddAccessDeniedObjectAce *pfn = 0;
|
|---|
| 5792 | if (!pfn)
|
|---|
| 5793 | kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedObjectAce", &g_Kernel32);
|
|---|
| 5794 | return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid );
|
|---|
| 5795 | }
|
|---|
| 5796 |
|
|---|
| 5797 | typedef BOOL WINAPI FN_AddAuditAccessObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
|
|---|
| 5798 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
|
|---|
| 5799 | {
|
|---|
| 5800 | static FN_AddAuditAccessObjectAce *pfn = 0;
|
|---|
| 5801 | if (!pfn)
|
|---|
| 5802 | kPrf2WrapResolve((void **)&pfn, "AddAuditAccessObjectAce", &g_Kernel32);
|
|---|
| 5803 | return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid, bAuditSuccess, bAuditFailure );
|
|---|
| 5804 | }
|
|---|
| 5805 |
|
|---|
| 5806 | typedef BOOL WINAPI FN_FindFirstFreeAce( PACL pAcl, LPVOID * pAce );
|
|---|
| 5807 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindFirstFreeAce( PACL pAcl, LPVOID * pAce )
|
|---|
| 5808 | {
|
|---|
| 5809 | static FN_FindFirstFreeAce *pfn = 0;
|
|---|
| 5810 | if (!pfn)
|
|---|
| 5811 | kPrf2WrapResolve((void **)&pfn, "FindFirstFreeAce", &g_Kernel32);
|
|---|
| 5812 | return pfn( pAcl, pAce );
|
|---|
| 5813 | }
|
|---|
| 5814 |
|
|---|
| 5815 | typedef BOOL WINAPI FN_InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision );
|
|---|
| 5816 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision )
|
|---|
| 5817 | {
|
|---|
| 5818 | static FN_InitializeSecurityDescriptor *pfn = 0;
|
|---|
| 5819 | if (!pfn)
|
|---|
| 5820 | kPrf2WrapResolve((void **)&pfn, "InitializeSecurityDescriptor", &g_Kernel32);
|
|---|
| 5821 | return pfn( pSecurityDescriptor, dwRevision );
|
|---|
| 5822 | }
|
|---|
| 5823 |
|
|---|
| 5824 | typedef BOOL WINAPI FN_IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor );
|
|---|
| 5825 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor )
|
|---|
| 5826 | {
|
|---|
| 5827 | static FN_IsValidSecurityDescriptor *pfn = 0;
|
|---|
| 5828 | if (!pfn)
|
|---|
| 5829 | kPrf2WrapResolve((void **)&pfn, "IsValidSecurityDescriptor", &g_Kernel32);
|
|---|
| 5830 | return pfn( pSecurityDescriptor );
|
|---|
| 5831 | }
|
|---|
| 5832 |
|
|---|
| 5833 | typedef DWORD WINAPI FN_GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pSecurityDescriptor );
|
|---|
| 5834 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pSecurityDescriptor )
|
|---|
| 5835 | {
|
|---|
| 5836 | static FN_GetSecurityDescriptorLength *pfn = 0;
|
|---|
| 5837 | if (!pfn)
|
|---|
| 5838 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorLength", &g_Kernel32);
|
|---|
| 5839 | return pfn( pSecurityDescriptor );
|
|---|
| 5840 | }
|
|---|
| 5841 |
|
|---|
| 5842 | typedef BOOL WINAPI FN_GetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision );
|
|---|
| 5843 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision )
|
|---|
| 5844 | {
|
|---|
| 5845 | static FN_GetSecurityDescriptorControl *pfn = 0;
|
|---|
| 5846 | if (!pfn)
|
|---|
| 5847 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorControl", &g_Kernel32);
|
|---|
| 5848 | return pfn( pSecurityDescriptor, pControl, lpdwRevision );
|
|---|
| 5849 | }
|
|---|
| 5850 |
|
|---|
| 5851 | typedef BOOL WINAPI FN_SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet );
|
|---|
| 5852 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet )
|
|---|
| 5853 | {
|
|---|
| 5854 | static FN_SetSecurityDescriptorControl *pfn = 0;
|
|---|
| 5855 | if (!pfn)
|
|---|
| 5856 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorControl", &g_Kernel32);
|
|---|
| 5857 | return pfn( pSecurityDescriptor, ControlBitsOfInterest, ControlBitsToSet );
|
|---|
| 5858 | }
|
|---|
| 5859 |
|
|---|
| 5860 | typedef BOOL WINAPI FN_SetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted );
|
|---|
| 5861 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted )
|
|---|
| 5862 | {
|
|---|
| 5863 | static FN_SetSecurityDescriptorDacl *pfn = 0;
|
|---|
| 5864 | if (!pfn)
|
|---|
| 5865 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorDacl", &g_Kernel32);
|
|---|
| 5866 | return pfn( pSecurityDescriptor, bDaclPresent, pDacl, bDaclDefaulted );
|
|---|
| 5867 | }
|
|---|
| 5868 |
|
|---|
| 5869 | typedef BOOL WINAPI FN_GetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL * pDacl, LPBOOL lpbDaclDefaulted );
|
|---|
| 5870 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL * pDacl, LPBOOL lpbDaclDefaulted )
|
|---|
| 5871 | {
|
|---|
| 5872 | static FN_GetSecurityDescriptorDacl *pfn = 0;
|
|---|
| 5873 | if (!pfn)
|
|---|
| 5874 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorDacl", &g_Kernel32);
|
|---|
| 5875 | return pfn( pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted );
|
|---|
| 5876 | }
|
|---|
| 5877 |
|
|---|
| 5878 | typedef BOOL WINAPI FN_SetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted );
|
|---|
| 5879 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted )
|
|---|
| 5880 | {
|
|---|
| 5881 | static FN_SetSecurityDescriptorSacl *pfn = 0;
|
|---|
| 5882 | if (!pfn)
|
|---|
| 5883 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorSacl", &g_Kernel32);
|
|---|
| 5884 | return pfn( pSecurityDescriptor, bSaclPresent, pSacl, bSaclDefaulted );
|
|---|
| 5885 | }
|
|---|
| 5886 |
|
|---|
| 5887 | typedef BOOL WINAPI FN_GetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL * pSacl, LPBOOL lpbSaclDefaulted );
|
|---|
| 5888 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL * pSacl, LPBOOL lpbSaclDefaulted )
|
|---|
| 5889 | {
|
|---|
| 5890 | static FN_GetSecurityDescriptorSacl *pfn = 0;
|
|---|
| 5891 | if (!pfn)
|
|---|
| 5892 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorSacl", &g_Kernel32);
|
|---|
| 5893 | return pfn( pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted );
|
|---|
| 5894 | }
|
|---|
| 5895 |
|
|---|
| 5896 | typedef BOOL WINAPI FN_SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted );
|
|---|
| 5897 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted )
|
|---|
| 5898 | {
|
|---|
| 5899 | static FN_SetSecurityDescriptorOwner *pfn = 0;
|
|---|
| 5900 | if (!pfn)
|
|---|
| 5901 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorOwner", &g_Kernel32);
|
|---|
| 5902 | return pfn( pSecurityDescriptor, pOwner, bOwnerDefaulted );
|
|---|
| 5903 | }
|
|---|
| 5904 |
|
|---|
| 5905 | typedef BOOL WINAPI FN_GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pOwner, LPBOOL lpbOwnerDefaulted );
|
|---|
| 5906 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pOwner, LPBOOL lpbOwnerDefaulted )
|
|---|
| 5907 | {
|
|---|
| 5908 | static FN_GetSecurityDescriptorOwner *pfn = 0;
|
|---|
| 5909 | if (!pfn)
|
|---|
| 5910 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorOwner", &g_Kernel32);
|
|---|
| 5911 | return pfn( pSecurityDescriptor, pOwner, lpbOwnerDefaulted );
|
|---|
| 5912 | }
|
|---|
| 5913 |
|
|---|
| 5914 | typedef BOOL WINAPI FN_SetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted );
|
|---|
| 5915 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted )
|
|---|
| 5916 | {
|
|---|
| 5917 | static FN_SetSecurityDescriptorGroup *pfn = 0;
|
|---|
| 5918 | if (!pfn)
|
|---|
| 5919 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorGroup", &g_Kernel32);
|
|---|
| 5920 | return pfn( pSecurityDescriptor, pGroup, bGroupDefaulted );
|
|---|
| 5921 | }
|
|---|
| 5922 |
|
|---|
| 5923 | typedef BOOL WINAPI FN_GetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pGroup, LPBOOL lpbGroupDefaulted );
|
|---|
| 5924 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pGroup, LPBOOL lpbGroupDefaulted )
|
|---|
| 5925 | {
|
|---|
| 5926 | static FN_GetSecurityDescriptorGroup *pfn = 0;
|
|---|
| 5927 | if (!pfn)
|
|---|
| 5928 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorGroup", &g_Kernel32);
|
|---|
| 5929 | return pfn( pSecurityDescriptor, pGroup, lpbGroupDefaulted );
|
|---|
| 5930 | }
|
|---|
| 5931 |
|
|---|
| 5932 | typedef DWORD WINAPI FN_SetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl );
|
|---|
| 5933 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl )
|
|---|
| 5934 | {
|
|---|
| 5935 | static FN_SetSecurityDescriptorRMControl *pfn = 0;
|
|---|
| 5936 | if (!pfn)
|
|---|
| 5937 | kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorRMControl", &g_Kernel32);
|
|---|
| 5938 | return pfn( SecurityDescriptor, RMControl );
|
|---|
| 5939 | }
|
|---|
| 5940 |
|
|---|
| 5941 | typedef DWORD WINAPI FN_GetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl );
|
|---|
| 5942 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl )
|
|---|
| 5943 | {
|
|---|
| 5944 | static FN_GetSecurityDescriptorRMControl *pfn = 0;
|
|---|
| 5945 | if (!pfn)
|
|---|
| 5946 | kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorRMControl", &g_Kernel32);
|
|---|
| 5947 | return pfn( SecurityDescriptor, RMControl );
|
|---|
| 5948 | }
|
|---|
| 5949 |
|
|---|
| 5950 | typedef BOOL WINAPI FN_CreatePrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping );
|
|---|
| 5951 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping )
|
|---|
| 5952 | {
|
|---|
| 5953 | static FN_CreatePrivateObjectSecurity *pfn = 0;
|
|---|
| 5954 | if (!pfn)
|
|---|
| 5955 | kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurity", &g_Kernel32);
|
|---|
| 5956 | return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, IsDirectoryObject, Token, GenericMapping );
|
|---|
| 5957 | }
|
|---|
| 5958 |
|
|---|
| 5959 | typedef BOOL WINAPI FN_ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR * NewSecurityDescriptor, GUID * ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping );
|
|---|
| 5960 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR * NewSecurityDescriptor, GUID * ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping )
|
|---|
| 5961 | {
|
|---|
| 5962 | static FN_ConvertToAutoInheritPrivateObjectSecurity *pfn = 0;
|
|---|
| 5963 | if (!pfn)
|
|---|
| 5964 | kPrf2WrapResolve((void **)&pfn, "ConvertToAutoInheritPrivateObjectSecurity", &g_Kernel32);
|
|---|
| 5965 | return pfn( ParentDescriptor, CurrentSecurityDescriptor, NewSecurityDescriptor, ObjectType, IsDirectoryObject, GenericMapping );
|
|---|
| 5966 | }
|
|---|
| 5967 |
|
|---|
| 5968 | typedef BOOL WINAPI FN_CreatePrivateObjectSecurityEx( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping );
|
|---|
| 5969 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurityEx( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping )
|
|---|
| 5970 | {
|
|---|
| 5971 | static FN_CreatePrivateObjectSecurityEx *pfn = 0;
|
|---|
| 5972 | if (!pfn)
|
|---|
| 5973 | kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurityEx", &g_Kernel32);
|
|---|
| 5974 | return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, ObjectType, IsContainerObject, AutoInheritFlags, Token, GenericMapping );
|
|---|
| 5975 | }
|
|---|
| 5976 |
|
|---|
| 5977 | typedef BOOL WINAPI FN_CreatePrivateObjectSecurityWithMultipleInheritance( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * *ObjectTypes, ULONG GuidCount, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping );
|
|---|
| 5978 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurityWithMultipleInheritance( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * *ObjectTypes, ULONG GuidCount, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping )
|
|---|
| 5979 | {
|
|---|
| 5980 | static FN_CreatePrivateObjectSecurityWithMultipleInheritance *pfn = 0;
|
|---|
| 5981 | if (!pfn)
|
|---|
| 5982 | kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurityWithMultipleInheritance", &g_Kernel32);
|
|---|
| 5983 | return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, ObjectTypes, GuidCount, IsContainerObject, AutoInheritFlags, Token, GenericMapping );
|
|---|
| 5984 | }
|
|---|
| 5985 |
|
|---|
| 5986 | typedef BOOL WINAPI FN_SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token );
|
|---|
| 5987 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token )
|
|---|
| 5988 | {
|
|---|
| 5989 | static FN_SetPrivateObjectSecurity *pfn = 0;
|
|---|
| 5990 | if (!pfn)
|
|---|
| 5991 | kPrf2WrapResolve((void **)&pfn, "SetPrivateObjectSecurity", &g_Kernel32);
|
|---|
| 5992 | return pfn( SecurityInformation, ModificationDescriptor, ObjectsSecurityDescriptor, GenericMapping, Token );
|
|---|
| 5993 | }
|
|---|
| 5994 |
|
|---|
| 5995 | typedef BOOL WINAPI FN_SetPrivateObjectSecurityEx( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token );
|
|---|
| 5996 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPrivateObjectSecurityEx( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token )
|
|---|
| 5997 | {
|
|---|
| 5998 | static FN_SetPrivateObjectSecurityEx *pfn = 0;
|
|---|
| 5999 | if (!pfn)
|
|---|
| 6000 | kPrf2WrapResolve((void **)&pfn, "SetPrivateObjectSecurityEx", &g_Kernel32);
|
|---|
| 6001 | return pfn( SecurityInformation, ModificationDescriptor, ObjectsSecurityDescriptor, AutoInheritFlags, GenericMapping, Token );
|
|---|
| 6002 | }
|
|---|
| 6003 |
|
|---|
| 6004 | typedef BOOL WINAPI FN_GetPrivateObjectSecurity( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength );
|
|---|
| 6005 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateObjectSecurity( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength )
|
|---|
| 6006 | {
|
|---|
| 6007 | static FN_GetPrivateObjectSecurity *pfn = 0;
|
|---|
| 6008 | if (!pfn)
|
|---|
| 6009 | kPrf2WrapResolve((void **)&pfn, "GetPrivateObjectSecurity", &g_Kernel32);
|
|---|
| 6010 | return pfn( ObjectDescriptor, SecurityInformation, ResultantDescriptor, DescriptorLength, ReturnLength );
|
|---|
| 6011 | }
|
|---|
| 6012 |
|
|---|
| 6013 | typedef BOOL WINAPI FN_DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR * ObjectDescriptor );
|
|---|
| 6014 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR * ObjectDescriptor )
|
|---|
| 6015 | {
|
|---|
| 6016 | static FN_DestroyPrivateObjectSecurity *pfn = 0;
|
|---|
| 6017 | if (!pfn)
|
|---|
| 6018 | kPrf2WrapResolve((void **)&pfn, "DestroyPrivateObjectSecurity", &g_Kernel32);
|
|---|
| 6019 | return pfn( ObjectDescriptor );
|
|---|
| 6020 | }
|
|---|
| 6021 |
|
|---|
| 6022 | typedef BOOL WINAPI FN_MakeSelfRelativeSD( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength );
|
|---|
| 6023 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeSelfRelativeSD( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength )
|
|---|
| 6024 | {
|
|---|
| 6025 | static FN_MakeSelfRelativeSD *pfn = 0;
|
|---|
| 6026 | if (!pfn)
|
|---|
| 6027 | kPrf2WrapResolve((void **)&pfn, "MakeSelfRelativeSD", &g_Kernel32);
|
|---|
| 6028 | return pfn( pAbsoluteSecurityDescriptor, pSelfRelativeSecurityDescriptor, lpdwBufferLength );
|
|---|
| 6029 | }
|
|---|
| 6030 |
|
|---|
| 6031 | typedef BOOL WINAPI FN_MakeAbsoluteSD( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize );
|
|---|
| 6032 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeAbsoluteSD( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize )
|
|---|
| 6033 | {
|
|---|
| 6034 | static FN_MakeAbsoluteSD *pfn = 0;
|
|---|
| 6035 | if (!pfn)
|
|---|
| 6036 | kPrf2WrapResolve((void **)&pfn, "MakeAbsoluteSD", &g_Kernel32);
|
|---|
| 6037 | return pfn( pSelfRelativeSecurityDescriptor, pAbsoluteSecurityDescriptor, lpdwAbsoluteSecurityDescriptorSize, pDacl, lpdwDaclSize, pSacl, lpdwSaclSize, pOwner, lpdwOwnerSize, pPrimaryGroup, lpdwPrimaryGroupSize );
|
|---|
| 6038 | }
|
|---|
| 6039 |
|
|---|
| 6040 | typedef BOOL WINAPI FN_MakeAbsoluteSD2( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferSize );
|
|---|
| 6041 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeAbsoluteSD2( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferSize )
|
|---|
| 6042 | {
|
|---|
| 6043 | static FN_MakeAbsoluteSD2 *pfn = 0;
|
|---|
| 6044 | if (!pfn)
|
|---|
| 6045 | kPrf2WrapResolve((void **)&pfn, "MakeAbsoluteSD2", &g_Kernel32);
|
|---|
| 6046 | return pfn( pSelfRelativeSecurityDescriptor, lpdwBufferSize );
|
|---|
| 6047 | }
|
|---|
| 6048 |
|
|---|
| 6049 | typedef BOOL WINAPI FN_SetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor );
|
|---|
| 6050 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor )
|
|---|
| 6051 | {
|
|---|
| 6052 | static FN_SetFileSecurityA *pfn = 0;
|
|---|
| 6053 | if (!pfn)
|
|---|
| 6054 | kPrf2WrapResolve((void **)&pfn, "SetFileSecurityA", &g_Kernel32);
|
|---|
| 6055 | return pfn( lpFileName, SecurityInformation, pSecurityDescriptor );
|
|---|
| 6056 | }
|
|---|
| 6057 |
|
|---|
| 6058 | typedef BOOL WINAPI FN_SetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor );
|
|---|
| 6059 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor )
|
|---|
| 6060 | {
|
|---|
| 6061 | static FN_SetFileSecurityW *pfn = 0;
|
|---|
| 6062 | if (!pfn)
|
|---|
| 6063 | kPrf2WrapResolve((void **)&pfn, "SetFileSecurityW", &g_Kernel32);
|
|---|
| 6064 | return pfn( lpFileName, SecurityInformation, pSecurityDescriptor );
|
|---|
| 6065 | }
|
|---|
| 6066 |
|
|---|
| 6067 | typedef BOOL WINAPI FN_GetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
|
|---|
| 6068 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
|
|---|
| 6069 | {
|
|---|
| 6070 | static FN_GetFileSecurityA *pfn = 0;
|
|---|
| 6071 | if (!pfn)
|
|---|
| 6072 | kPrf2WrapResolve((void **)&pfn, "GetFileSecurityA", &g_Kernel32);
|
|---|
| 6073 | return pfn( lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
|
|---|
| 6074 | }
|
|---|
| 6075 |
|
|---|
| 6076 | typedef BOOL WINAPI FN_GetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
|
|---|
| 6077 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
|
|---|
| 6078 | {
|
|---|
| 6079 | static FN_GetFileSecurityW *pfn = 0;
|
|---|
| 6080 | if (!pfn)
|
|---|
| 6081 | kPrf2WrapResolve((void **)&pfn, "GetFileSecurityW", &g_Kernel32);
|
|---|
| 6082 | return pfn( lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
|
|---|
| 6083 | }
|
|---|
| 6084 |
|
|---|
| 6085 | typedef BOOL WINAPI FN_SetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor );
|
|---|
| 6086 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor )
|
|---|
| 6087 | {
|
|---|
| 6088 | static FN_SetKernelObjectSecurity *pfn = 0;
|
|---|
| 6089 | if (!pfn)
|
|---|
| 6090 | kPrf2WrapResolve((void **)&pfn, "SetKernelObjectSecurity", &g_Kernel32);
|
|---|
| 6091 | return pfn( Handle, SecurityInformation, SecurityDescriptor );
|
|---|
| 6092 | }
|
|---|
| 6093 |
|
|---|
| 6094 | typedef HANDLE WINAPI FN_FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter );
|
|---|
| 6095 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter )
|
|---|
| 6096 | {
|
|---|
| 6097 | static FN_FindFirstChangeNotificationA *pfn = 0;
|
|---|
| 6098 | if (!pfn)
|
|---|
| 6099 | kPrf2WrapResolve((void **)&pfn, "FindFirstChangeNotificationA", &g_Kernel32);
|
|---|
| 6100 | return pfn( lpPathName, bWatchSubtree, dwNotifyFilter );
|
|---|
| 6101 | }
|
|---|
| 6102 |
|
|---|
| 6103 | typedef HANDLE WINAPI FN_FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter );
|
|---|
| 6104 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter )
|
|---|
| 6105 | {
|
|---|
| 6106 | static FN_FindFirstChangeNotificationW *pfn = 0;
|
|---|
| 6107 | if (!pfn)
|
|---|
| 6108 | kPrf2WrapResolve((void **)&pfn, "FindFirstChangeNotificationW", &g_Kernel32);
|
|---|
| 6109 | return pfn( lpPathName, bWatchSubtree, dwNotifyFilter );
|
|---|
| 6110 | }
|
|---|
| 6111 |
|
|---|
| 6112 | typedef BOOL WINAPI FN_FindNextChangeNotification( HANDLE hChangeHandle );
|
|---|
| 6113 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextChangeNotification( HANDLE hChangeHandle )
|
|---|
| 6114 | {
|
|---|
| 6115 | static FN_FindNextChangeNotification *pfn = 0;
|
|---|
| 6116 | if (!pfn)
|
|---|
| 6117 | kPrf2WrapResolve((void **)&pfn, "FindNextChangeNotification", &g_Kernel32);
|
|---|
| 6118 | return pfn( hChangeHandle );
|
|---|
| 6119 | }
|
|---|
| 6120 |
|
|---|
| 6121 | typedef BOOL WINAPI FN_FindCloseChangeNotification( HANDLE hChangeHandle );
|
|---|
| 6122 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindCloseChangeNotification( HANDLE hChangeHandle )
|
|---|
| 6123 | {
|
|---|
| 6124 | static FN_FindCloseChangeNotification *pfn = 0;
|
|---|
| 6125 | if (!pfn)
|
|---|
| 6126 | kPrf2WrapResolve((void **)&pfn, "FindCloseChangeNotification", &g_Kernel32);
|
|---|
| 6127 | return pfn( hChangeHandle );
|
|---|
| 6128 | }
|
|---|
| 6129 |
|
|---|
| 6130 | typedef BOOL WINAPI FN_ReadDirectoryChangesW( HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
|
|---|
| 6131 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadDirectoryChangesW( HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
|
|---|
| 6132 | {
|
|---|
| 6133 | static FN_ReadDirectoryChangesW *pfn = 0;
|
|---|
| 6134 | if (!pfn)
|
|---|
| 6135 | kPrf2WrapResolve((void **)&pfn, "ReadDirectoryChangesW", &g_Kernel32);
|
|---|
| 6136 | return pfn( hDirectory, lpBuffer, nBufferLength, bWatchSubtree, dwNotifyFilter, lpBytesReturned, lpOverlapped, lpCompletionRoutine );
|
|---|
| 6137 | }
|
|---|
| 6138 |
|
|---|
| 6139 | typedef BOOL WINAPI FN_VirtualLock( LPVOID lpAddress, SIZE_T dwSize );
|
|---|
| 6140 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualLock( LPVOID lpAddress, SIZE_T dwSize )
|
|---|
| 6141 | {
|
|---|
| 6142 | static FN_VirtualLock *pfn = 0;
|
|---|
| 6143 | if (!pfn)
|
|---|
| 6144 | kPrf2WrapResolve((void **)&pfn, "VirtualLock", &g_Kernel32);
|
|---|
| 6145 | return pfn( lpAddress, dwSize );
|
|---|
| 6146 | }
|
|---|
| 6147 |
|
|---|
| 6148 | typedef BOOL WINAPI FN_VirtualUnlock( LPVOID lpAddress, SIZE_T dwSize );
|
|---|
| 6149 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualUnlock( LPVOID lpAddress, SIZE_T dwSize )
|
|---|
| 6150 | {
|
|---|
| 6151 | static FN_VirtualUnlock *pfn = 0;
|
|---|
| 6152 | if (!pfn)
|
|---|
| 6153 | kPrf2WrapResolve((void **)&pfn, "VirtualUnlock", &g_Kernel32);
|
|---|
| 6154 | return pfn( lpAddress, dwSize );
|
|---|
| 6155 | }
|
|---|
| 6156 |
|
|---|
| 6157 | typedef LPVOID WINAPI FN_MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress );
|
|---|
| 6158 | __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress )
|
|---|
| 6159 | {
|
|---|
| 6160 | static FN_MapViewOfFileEx *pfn = 0;
|
|---|
| 6161 | if (!pfn)
|
|---|
| 6162 | kPrf2WrapResolve((void **)&pfn, "MapViewOfFileEx", &g_Kernel32);
|
|---|
| 6163 | return pfn( hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap, lpBaseAddress );
|
|---|
| 6164 | }
|
|---|
| 6165 |
|
|---|
| 6166 | typedef BOOL WINAPI FN_SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass );
|
|---|
| 6167 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass )
|
|---|
| 6168 | {
|
|---|
| 6169 | static FN_SetPriorityClass *pfn = 0;
|
|---|
| 6170 | if (!pfn)
|
|---|
| 6171 | kPrf2WrapResolve((void **)&pfn, "SetPriorityClass", &g_Kernel32);
|
|---|
| 6172 | return pfn( hProcess, dwPriorityClass );
|
|---|
| 6173 | }
|
|---|
| 6174 |
|
|---|
| 6175 | typedef DWORD WINAPI FN_GetPriorityClass( HANDLE hProcess );
|
|---|
| 6176 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPriorityClass( HANDLE hProcess )
|
|---|
| 6177 | {
|
|---|
| 6178 | static FN_GetPriorityClass *pfn = 0;
|
|---|
| 6179 | if (!pfn)
|
|---|
| 6180 | kPrf2WrapResolve((void **)&pfn, "GetPriorityClass", &g_Kernel32);
|
|---|
| 6181 | return pfn( hProcess );
|
|---|
| 6182 | }
|
|---|
| 6183 |
|
|---|
| 6184 | typedef BOOL WINAPI FN_IsBadReadPtr( CONST VOID * lp, UINT_PTR ucb );
|
|---|
| 6185 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadReadPtr( CONST VOID * lp, UINT_PTR ucb )
|
|---|
| 6186 | {
|
|---|
| 6187 | static FN_IsBadReadPtr *pfn = 0;
|
|---|
| 6188 | if (!pfn)
|
|---|
| 6189 | kPrf2WrapResolve((void **)&pfn, "IsBadReadPtr", &g_Kernel32);
|
|---|
| 6190 | return pfn( lp, ucb );
|
|---|
| 6191 | }
|
|---|
| 6192 |
|
|---|
| 6193 | typedef BOOL WINAPI FN_IsBadWritePtr( LPVOID lp, UINT_PTR ucb );
|
|---|
| 6194 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadWritePtr( LPVOID lp, UINT_PTR ucb )
|
|---|
| 6195 | {
|
|---|
| 6196 | static FN_IsBadWritePtr *pfn = 0;
|
|---|
| 6197 | if (!pfn)
|
|---|
| 6198 | kPrf2WrapResolve((void **)&pfn, "IsBadWritePtr", &g_Kernel32);
|
|---|
| 6199 | return pfn( lp, ucb );
|
|---|
| 6200 | }
|
|---|
| 6201 |
|
|---|
| 6202 | typedef BOOL WINAPI FN_IsBadHugeReadPtr( CONST VOID * lp, UINT_PTR ucb );
|
|---|
| 6203 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadHugeReadPtr( CONST VOID * lp, UINT_PTR ucb )
|
|---|
| 6204 | {
|
|---|
| 6205 | static FN_IsBadHugeReadPtr *pfn = 0;
|
|---|
| 6206 | if (!pfn)
|
|---|
| 6207 | kPrf2WrapResolve((void **)&pfn, "IsBadHugeReadPtr", &g_Kernel32);
|
|---|
| 6208 | return pfn( lp, ucb );
|
|---|
| 6209 | }
|
|---|
| 6210 |
|
|---|
| 6211 | typedef BOOL WINAPI FN_IsBadHugeWritePtr( LPVOID lp, UINT_PTR ucb );
|
|---|
| 6212 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadHugeWritePtr( LPVOID lp, UINT_PTR ucb )
|
|---|
| 6213 | {
|
|---|
| 6214 | static FN_IsBadHugeWritePtr *pfn = 0;
|
|---|
| 6215 | if (!pfn)
|
|---|
| 6216 | kPrf2WrapResolve((void **)&pfn, "IsBadHugeWritePtr", &g_Kernel32);
|
|---|
| 6217 | return pfn( lp, ucb );
|
|---|
| 6218 | }
|
|---|
| 6219 |
|
|---|
| 6220 | typedef BOOL WINAPI FN_IsBadCodePtr( FARPROC lpfn );
|
|---|
| 6221 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadCodePtr( FARPROC lpfn )
|
|---|
| 6222 | {
|
|---|
| 6223 | static FN_IsBadCodePtr *pfn = 0;
|
|---|
| 6224 | if (!pfn)
|
|---|
| 6225 | kPrf2WrapResolve((void **)&pfn, "IsBadCodePtr", &g_Kernel32);
|
|---|
| 6226 | return pfn( lpfn );
|
|---|
| 6227 | }
|
|---|
| 6228 |
|
|---|
| 6229 | typedef BOOL WINAPI FN_IsBadStringPtrA( LPCSTR lpsz, UINT_PTR ucchMax );
|
|---|
| 6230 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadStringPtrA( LPCSTR lpsz, UINT_PTR ucchMax )
|
|---|
| 6231 | {
|
|---|
| 6232 | static FN_IsBadStringPtrA *pfn = 0;
|
|---|
| 6233 | if (!pfn)
|
|---|
| 6234 | kPrf2WrapResolve((void **)&pfn, "IsBadStringPtrA", &g_Kernel32);
|
|---|
| 6235 | return pfn( lpsz, ucchMax );
|
|---|
| 6236 | }
|
|---|
| 6237 |
|
|---|
| 6238 | typedef BOOL WINAPI FN_IsBadStringPtrW( LPCWSTR lpsz, UINT_PTR ucchMax );
|
|---|
| 6239 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadStringPtrW( LPCWSTR lpsz, UINT_PTR ucchMax )
|
|---|
| 6240 | {
|
|---|
| 6241 | static FN_IsBadStringPtrW *pfn = 0;
|
|---|
| 6242 | if (!pfn)
|
|---|
| 6243 | kPrf2WrapResolve((void **)&pfn, "IsBadStringPtrW", &g_Kernel32);
|
|---|
| 6244 | return pfn( lpsz, ucchMax );
|
|---|
| 6245 | }
|
|---|
| 6246 |
|
|---|
| 6247 | typedef BOOL WINAPI FN_LookupAccountSidA( LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
|
|---|
| 6248 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountSidA( LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
|
|---|
| 6249 | {
|
|---|
| 6250 | static FN_LookupAccountSidA *pfn = 0;
|
|---|
| 6251 | if (!pfn)
|
|---|
| 6252 | kPrf2WrapResolve((void **)&pfn, "LookupAccountSidA", &g_Kernel32);
|
|---|
| 6253 | return pfn( lpSystemName, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse );
|
|---|
| 6254 | }
|
|---|
| 6255 |
|
|---|
| 6256 | typedef BOOL WINAPI FN_LookupAccountSidW( LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
|
|---|
| 6257 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountSidW( LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
|
|---|
| 6258 | {
|
|---|
| 6259 | static FN_LookupAccountSidW *pfn = 0;
|
|---|
| 6260 | if (!pfn)
|
|---|
| 6261 | kPrf2WrapResolve((void **)&pfn, "LookupAccountSidW", &g_Kernel32);
|
|---|
| 6262 | return pfn( lpSystemName, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse );
|
|---|
| 6263 | }
|
|---|
| 6264 |
|
|---|
| 6265 | typedef BOOL WINAPI FN_LookupAccountNameA( LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
|
|---|
| 6266 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountNameA( LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
|
|---|
| 6267 | {
|
|---|
| 6268 | static FN_LookupAccountNameA *pfn = 0;
|
|---|
| 6269 | if (!pfn)
|
|---|
| 6270 | kPrf2WrapResolve((void **)&pfn, "LookupAccountNameA", &g_Kernel32);
|
|---|
| 6271 | return pfn( lpSystemName, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse );
|
|---|
| 6272 | }
|
|---|
| 6273 |
|
|---|
| 6274 | typedef BOOL WINAPI FN_LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
|
|---|
| 6275 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
|
|---|
| 6276 | {
|
|---|
| 6277 | static FN_LookupAccountNameW *pfn = 0;
|
|---|
| 6278 | if (!pfn)
|
|---|
| 6279 | kPrf2WrapResolve((void **)&pfn, "LookupAccountNameW", &g_Kernel32);
|
|---|
| 6280 | return pfn( lpSystemName, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse );
|
|---|
| 6281 | }
|
|---|
| 6282 |
|
|---|
| 6283 | typedef BOOL WINAPI FN_LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid );
|
|---|
| 6284 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid )
|
|---|
| 6285 | {
|
|---|
| 6286 | static FN_LookupPrivilegeValueA *pfn = 0;
|
|---|
| 6287 | if (!pfn)
|
|---|
| 6288 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeValueA", &g_Kernel32);
|
|---|
| 6289 | return pfn( lpSystemName, lpName, lpLuid );
|
|---|
| 6290 | }
|
|---|
| 6291 |
|
|---|
| 6292 | typedef BOOL WINAPI FN_LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid );
|
|---|
| 6293 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid )
|
|---|
| 6294 | {
|
|---|
| 6295 | static FN_LookupPrivilegeValueW *pfn = 0;
|
|---|
| 6296 | if (!pfn)
|
|---|
| 6297 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeValueW", &g_Kernel32);
|
|---|
| 6298 | return pfn( lpSystemName, lpName, lpLuid );
|
|---|
| 6299 | }
|
|---|
| 6300 |
|
|---|
| 6301 | typedef BOOL WINAPI FN_LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName );
|
|---|
| 6302 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName )
|
|---|
| 6303 | {
|
|---|
| 6304 | static FN_LookupPrivilegeNameA *pfn = 0;
|
|---|
| 6305 | if (!pfn)
|
|---|
| 6306 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeNameA", &g_Kernel32);
|
|---|
| 6307 | return pfn( lpSystemName, lpLuid, lpName, cchName );
|
|---|
| 6308 | }
|
|---|
| 6309 |
|
|---|
| 6310 | typedef BOOL WINAPI FN_LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName );
|
|---|
| 6311 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName )
|
|---|
| 6312 | {
|
|---|
| 6313 | static FN_LookupPrivilegeNameW *pfn = 0;
|
|---|
| 6314 | if (!pfn)
|
|---|
| 6315 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeNameW", &g_Kernel32);
|
|---|
| 6316 | return pfn( lpSystemName, lpLuid, lpName, cchName );
|
|---|
| 6317 | }
|
|---|
| 6318 |
|
|---|
| 6319 | typedef BOOL WINAPI FN_LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId );
|
|---|
| 6320 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId )
|
|---|
| 6321 | {
|
|---|
| 6322 | static FN_LookupPrivilegeDisplayNameA *pfn = 0;
|
|---|
| 6323 | if (!pfn)
|
|---|
| 6324 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeDisplayNameA", &g_Kernel32);
|
|---|
| 6325 | return pfn( lpSystemName, lpName, lpDisplayName, cchDisplayName, lpLanguageId );
|
|---|
| 6326 | }
|
|---|
| 6327 |
|
|---|
| 6328 | typedef BOOL WINAPI FN_LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId );
|
|---|
| 6329 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId )
|
|---|
| 6330 | {
|
|---|
| 6331 | static FN_LookupPrivilegeDisplayNameW *pfn = 0;
|
|---|
| 6332 | if (!pfn)
|
|---|
| 6333 | kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeDisplayNameW", &g_Kernel32);
|
|---|
| 6334 | return pfn( lpSystemName, lpName, lpDisplayName, cchDisplayName, lpLanguageId );
|
|---|
| 6335 | }
|
|---|
| 6336 |
|
|---|
| 6337 | typedef BOOL WINAPI FN_AllocateLocallyUniqueId( PLUID Luid );
|
|---|
| 6338 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateLocallyUniqueId( PLUID Luid )
|
|---|
| 6339 | {
|
|---|
| 6340 | static FN_AllocateLocallyUniqueId *pfn = 0;
|
|---|
| 6341 | if (!pfn)
|
|---|
| 6342 | kPrf2WrapResolve((void **)&pfn, "AllocateLocallyUniqueId", &g_Kernel32);
|
|---|
| 6343 | return pfn( Luid );
|
|---|
| 6344 | }
|
|---|
| 6345 |
|
|---|
| 6346 | typedef BOOL WINAPI FN_BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB );
|
|---|
| 6347 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB )
|
|---|
| 6348 | {
|
|---|
| 6349 | static FN_BuildCommDCBA *pfn = 0;
|
|---|
| 6350 | if (!pfn)
|
|---|
| 6351 | kPrf2WrapResolve((void **)&pfn, "BuildCommDCBA", &g_Kernel32);
|
|---|
| 6352 | return pfn( lpDef, lpDCB );
|
|---|
| 6353 | }
|
|---|
| 6354 |
|
|---|
| 6355 | typedef BOOL WINAPI FN_BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB );
|
|---|
| 6356 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB )
|
|---|
| 6357 | {
|
|---|
| 6358 | static FN_BuildCommDCBW *pfn = 0;
|
|---|
| 6359 | if (!pfn)
|
|---|
| 6360 | kPrf2WrapResolve((void **)&pfn, "BuildCommDCBW", &g_Kernel32);
|
|---|
| 6361 | return pfn( lpDef, lpDCB );
|
|---|
| 6362 | }
|
|---|
| 6363 |
|
|---|
| 6364 | typedef BOOL WINAPI FN_BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts );
|
|---|
| 6365 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
|
|---|
| 6366 | {
|
|---|
| 6367 | static FN_BuildCommDCBAndTimeoutsA *pfn = 0;
|
|---|
| 6368 | if (!pfn)
|
|---|
| 6369 | kPrf2WrapResolve((void **)&pfn, "BuildCommDCBAndTimeoutsA", &g_Kernel32);
|
|---|
| 6370 | return pfn( lpDef, lpDCB, lpCommTimeouts );
|
|---|
| 6371 | }
|
|---|
| 6372 |
|
|---|
| 6373 | typedef BOOL WINAPI FN_BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts );
|
|---|
| 6374 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
|
|---|
| 6375 | {
|
|---|
| 6376 | static FN_BuildCommDCBAndTimeoutsW *pfn = 0;
|
|---|
| 6377 | if (!pfn)
|
|---|
| 6378 | kPrf2WrapResolve((void **)&pfn, "BuildCommDCBAndTimeoutsW", &g_Kernel32);
|
|---|
| 6379 | return pfn( lpDef, lpDCB, lpCommTimeouts );
|
|---|
| 6380 | }
|
|---|
| 6381 |
|
|---|
| 6382 | typedef BOOL WINAPI FN_CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC );
|
|---|
| 6383 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
|
|---|
| 6384 | {
|
|---|
| 6385 | static FN_CommConfigDialogA *pfn = 0;
|
|---|
| 6386 | if (!pfn)
|
|---|
| 6387 | kPrf2WrapResolve((void **)&pfn, "CommConfigDialogA", &g_Kernel32);
|
|---|
| 6388 | return pfn( lpszName, hWnd, lpCC );
|
|---|
| 6389 | }
|
|---|
| 6390 |
|
|---|
| 6391 | typedef BOOL WINAPI FN_CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC );
|
|---|
| 6392 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
|
|---|
| 6393 | {
|
|---|
| 6394 | static FN_CommConfigDialogW *pfn = 0;
|
|---|
| 6395 | if (!pfn)
|
|---|
| 6396 | kPrf2WrapResolve((void **)&pfn, "CommConfigDialogW", &g_Kernel32);
|
|---|
| 6397 | return pfn( lpszName, hWnd, lpCC );
|
|---|
| 6398 | }
|
|---|
| 6399 |
|
|---|
| 6400 | typedef BOOL WINAPI FN_GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
|
|---|
| 6401 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
|
|---|
| 6402 | {
|
|---|
| 6403 | static FN_GetDefaultCommConfigA *pfn = 0;
|
|---|
| 6404 | if (!pfn)
|
|---|
| 6405 | kPrf2WrapResolve((void **)&pfn, "GetDefaultCommConfigA", &g_Kernel32);
|
|---|
| 6406 | return pfn( lpszName, lpCC, lpdwSize );
|
|---|
| 6407 | }
|
|---|
| 6408 |
|
|---|
| 6409 | typedef BOOL WINAPI FN_GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
|
|---|
| 6410 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
|
|---|
| 6411 | {
|
|---|
| 6412 | static FN_GetDefaultCommConfigW *pfn = 0;
|
|---|
| 6413 | if (!pfn)
|
|---|
| 6414 | kPrf2WrapResolve((void **)&pfn, "GetDefaultCommConfigW", &g_Kernel32);
|
|---|
| 6415 | return pfn( lpszName, lpCC, lpdwSize );
|
|---|
| 6416 | }
|
|---|
| 6417 |
|
|---|
| 6418 | typedef BOOL WINAPI FN_SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize );
|
|---|
| 6419 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
|
|---|
| 6420 | {
|
|---|
| 6421 | static FN_SetDefaultCommConfigA *pfn = 0;
|
|---|
| 6422 | if (!pfn)
|
|---|
| 6423 | kPrf2WrapResolve((void **)&pfn, "SetDefaultCommConfigA", &g_Kernel32);
|
|---|
| 6424 | return pfn( lpszName, lpCC, dwSize );
|
|---|
| 6425 | }
|
|---|
| 6426 |
|
|---|
| 6427 | typedef BOOL WINAPI FN_SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize );
|
|---|
| 6428 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
|
|---|
| 6429 | {
|
|---|
| 6430 | static FN_SetDefaultCommConfigW *pfn = 0;
|
|---|
| 6431 | if (!pfn)
|
|---|
| 6432 | kPrf2WrapResolve((void **)&pfn, "SetDefaultCommConfigW", &g_Kernel32);
|
|---|
| 6433 | return pfn( lpszName, lpCC, dwSize );
|
|---|
| 6434 | }
|
|---|
| 6435 |
|
|---|
| 6436 | typedef BOOL WINAPI FN_GetComputerNameA( LPSTR lpBuffer, LPDWORD nSize );
|
|---|
| 6437 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameA( LPSTR lpBuffer, LPDWORD nSize )
|
|---|
| 6438 | {
|
|---|
| 6439 | static FN_GetComputerNameA *pfn = 0;
|
|---|
| 6440 | if (!pfn)
|
|---|
| 6441 | kPrf2WrapResolve((void **)&pfn, "GetComputerNameA", &g_Kernel32);
|
|---|
| 6442 | return pfn( lpBuffer, nSize );
|
|---|
| 6443 | }
|
|---|
| 6444 |
|
|---|
| 6445 | typedef BOOL WINAPI FN_GetComputerNameW( LPWSTR lpBuffer, LPDWORD nSize );
|
|---|
| 6446 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameW( LPWSTR lpBuffer, LPDWORD nSize )
|
|---|
| 6447 | {
|
|---|
| 6448 | static FN_GetComputerNameW *pfn = 0;
|
|---|
| 6449 | if (!pfn)
|
|---|
| 6450 | kPrf2WrapResolve((void **)&pfn, "GetComputerNameW", &g_Kernel32);
|
|---|
| 6451 | return pfn( lpBuffer, nSize );
|
|---|
| 6452 | }
|
|---|
| 6453 |
|
|---|
| 6454 | typedef BOOL WINAPI FN_SetComputerNameA( LPCSTR lpComputerName );
|
|---|
| 6455 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameA( LPCSTR lpComputerName )
|
|---|
| 6456 | {
|
|---|
| 6457 | static FN_SetComputerNameA *pfn = 0;
|
|---|
| 6458 | if (!pfn)
|
|---|
| 6459 | kPrf2WrapResolve((void **)&pfn, "SetComputerNameA", &g_Kernel32);
|
|---|
| 6460 | return pfn( lpComputerName );
|
|---|
| 6461 | }
|
|---|
| 6462 |
|
|---|
| 6463 | typedef BOOL WINAPI FN_SetComputerNameW( LPCWSTR lpComputerName );
|
|---|
| 6464 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameW( LPCWSTR lpComputerName )
|
|---|
| 6465 | {
|
|---|
| 6466 | static FN_SetComputerNameW *pfn = 0;
|
|---|
| 6467 | if (!pfn)
|
|---|
| 6468 | kPrf2WrapResolve((void **)&pfn, "SetComputerNameW", &g_Kernel32);
|
|---|
| 6469 | return pfn( lpComputerName );
|
|---|
| 6470 | }
|
|---|
| 6471 |
|
|---|
| 6472 | typedef BOOL WINAPI FN_GetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize );
|
|---|
| 6473 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize )
|
|---|
| 6474 | {
|
|---|
| 6475 | static FN_GetComputerNameExA *pfn = 0;
|
|---|
| 6476 | if (!pfn)
|
|---|
| 6477 | kPrf2WrapResolve((void **)&pfn, "GetComputerNameExA", &g_Kernel32);
|
|---|
| 6478 | return pfn( NameType, lpBuffer, nSize );
|
|---|
| 6479 | }
|
|---|
| 6480 |
|
|---|
| 6481 | typedef BOOL WINAPI FN_GetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize );
|
|---|
| 6482 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize )
|
|---|
| 6483 | {
|
|---|
| 6484 | static FN_GetComputerNameExW *pfn = 0;
|
|---|
| 6485 | if (!pfn)
|
|---|
| 6486 | kPrf2WrapResolve((void **)&pfn, "GetComputerNameExW", &g_Kernel32);
|
|---|
| 6487 | return pfn( NameType, lpBuffer, nSize );
|
|---|
| 6488 | }
|
|---|
| 6489 |
|
|---|
| 6490 | typedef BOOL WINAPI FN_SetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer );
|
|---|
| 6491 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer )
|
|---|
| 6492 | {
|
|---|
| 6493 | static FN_SetComputerNameExA *pfn = 0;
|
|---|
| 6494 | if (!pfn)
|
|---|
| 6495 | kPrf2WrapResolve((void **)&pfn, "SetComputerNameExA", &g_Kernel32);
|
|---|
| 6496 | return pfn( NameType, lpBuffer );
|
|---|
| 6497 | }
|
|---|
| 6498 |
|
|---|
| 6499 | typedef BOOL WINAPI FN_SetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer );
|
|---|
| 6500 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer )
|
|---|
| 6501 | {
|
|---|
| 6502 | static FN_SetComputerNameExW *pfn = 0;
|
|---|
| 6503 | if (!pfn)
|
|---|
| 6504 | kPrf2WrapResolve((void **)&pfn, "SetComputerNameExW", &g_Kernel32);
|
|---|
| 6505 | return pfn( NameType, lpBuffer );
|
|---|
| 6506 | }
|
|---|
| 6507 |
|
|---|
| 6508 | typedef BOOL WINAPI FN_DnsHostnameToComputerNameA( LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize );
|
|---|
| 6509 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DnsHostnameToComputerNameA( LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize )
|
|---|
| 6510 | {
|
|---|
| 6511 | static FN_DnsHostnameToComputerNameA *pfn = 0;
|
|---|
| 6512 | if (!pfn)
|
|---|
| 6513 | kPrf2WrapResolve((void **)&pfn, "DnsHostnameToComputerNameA", &g_Kernel32);
|
|---|
| 6514 | return pfn( Hostname, ComputerName, nSize );
|
|---|
| 6515 | }
|
|---|
| 6516 |
|
|---|
| 6517 | typedef BOOL WINAPI FN_DnsHostnameToComputerNameW( LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize );
|
|---|
| 6518 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DnsHostnameToComputerNameW( LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize )
|
|---|
| 6519 | {
|
|---|
| 6520 | static FN_DnsHostnameToComputerNameW *pfn = 0;
|
|---|
| 6521 | if (!pfn)
|
|---|
| 6522 | kPrf2WrapResolve((void **)&pfn, "DnsHostnameToComputerNameW", &g_Kernel32);
|
|---|
| 6523 | return pfn( Hostname, ComputerName, nSize );
|
|---|
| 6524 | }
|
|---|
| 6525 |
|
|---|
| 6526 | typedef BOOL WINAPI FN_GetUserNameA( LPSTR lpBuffer, LPDWORD pcbBuffer );
|
|---|
| 6527 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetUserNameA( LPSTR lpBuffer, LPDWORD pcbBuffer )
|
|---|
| 6528 | {
|
|---|
| 6529 | static FN_GetUserNameA *pfn = 0;
|
|---|
| 6530 | if (!pfn)
|
|---|
| 6531 | kPrf2WrapResolve((void **)&pfn, "GetUserNameA", &g_Kernel32);
|
|---|
| 6532 | return pfn( lpBuffer, pcbBuffer );
|
|---|
| 6533 | }
|
|---|
| 6534 |
|
|---|
| 6535 | typedef BOOL WINAPI FN_GetUserNameW( LPWSTR lpBuffer, LPDWORD pcbBuffer );
|
|---|
| 6536 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetUserNameW( LPWSTR lpBuffer, LPDWORD pcbBuffer )
|
|---|
| 6537 | {
|
|---|
| 6538 | static FN_GetUserNameW *pfn = 0;
|
|---|
| 6539 | if (!pfn)
|
|---|
| 6540 | kPrf2WrapResolve((void **)&pfn, "GetUserNameW", &g_Kernel32);
|
|---|
| 6541 | return pfn( lpBuffer, pcbBuffer );
|
|---|
| 6542 | }
|
|---|
| 6543 |
|
|---|
| 6544 | typedef BOOL WINAPI FN_LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken );
|
|---|
| 6545 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken )
|
|---|
| 6546 | {
|
|---|
| 6547 | static FN_LogonUserA *pfn = 0;
|
|---|
| 6548 | if (!pfn)
|
|---|
| 6549 | kPrf2WrapResolve((void **)&pfn, "LogonUserA", &g_Kernel32);
|
|---|
| 6550 | return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken );
|
|---|
| 6551 | }
|
|---|
| 6552 |
|
|---|
| 6553 | typedef BOOL WINAPI FN_LogonUserW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken );
|
|---|
| 6554 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken )
|
|---|
| 6555 | {
|
|---|
| 6556 | static FN_LogonUserW *pfn = 0;
|
|---|
| 6557 | if (!pfn)
|
|---|
| 6558 | kPrf2WrapResolve((void **)&pfn, "LogonUserW", &g_Kernel32);
|
|---|
| 6559 | return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken );
|
|---|
| 6560 | }
|
|---|
| 6561 |
|
|---|
| 6562 | typedef BOOL WINAPI FN_LogonUserExA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits );
|
|---|
| 6563 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserExA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits )
|
|---|
| 6564 | {
|
|---|
| 6565 | static FN_LogonUserExA *pfn = 0;
|
|---|
| 6566 | if (!pfn)
|
|---|
| 6567 | kPrf2WrapResolve((void **)&pfn, "LogonUserExA", &g_Kernel32);
|
|---|
| 6568 | return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken, ppLogonSid, ppProfileBuffer, pdwProfileLength, pQuotaLimits );
|
|---|
| 6569 | }
|
|---|
| 6570 |
|
|---|
| 6571 | typedef BOOL WINAPI FN_LogonUserExW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits );
|
|---|
| 6572 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserExW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits )
|
|---|
| 6573 | {
|
|---|
| 6574 | static FN_LogonUserExW *pfn = 0;
|
|---|
| 6575 | if (!pfn)
|
|---|
| 6576 | kPrf2WrapResolve((void **)&pfn, "LogonUserExW", &g_Kernel32);
|
|---|
| 6577 | return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken, ppLogonSid, ppProfileBuffer, pdwProfileLength, pQuotaLimits );
|
|---|
| 6578 | }
|
|---|
| 6579 |
|
|---|
| 6580 | typedef BOOL WINAPI FN_ImpersonateLoggedOnUser( HANDLE hToken );
|
|---|
| 6581 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateLoggedOnUser( HANDLE hToken )
|
|---|
| 6582 | {
|
|---|
| 6583 | static FN_ImpersonateLoggedOnUser *pfn = 0;
|
|---|
| 6584 | if (!pfn)
|
|---|
| 6585 | kPrf2WrapResolve((void **)&pfn, "ImpersonateLoggedOnUser", &g_Kernel32);
|
|---|
| 6586 | return pfn( hToken );
|
|---|
| 6587 | }
|
|---|
| 6588 |
|
|---|
| 6589 | typedef BOOL WINAPI FN_CreateProcessAsUserA( HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 6590 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessAsUserA( HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 6591 | {
|
|---|
| 6592 | static FN_CreateProcessAsUserA *pfn = 0;
|
|---|
| 6593 | if (!pfn)
|
|---|
| 6594 | kPrf2WrapResolve((void **)&pfn, "CreateProcessAsUserA", &g_Kernel32);
|
|---|
| 6595 | return pfn( hToken, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 6596 | }
|
|---|
| 6597 |
|
|---|
| 6598 | typedef BOOL WINAPI FN_CreateProcessAsUserW( HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 6599 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessAsUserW( HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 6600 | {
|
|---|
| 6601 | static FN_CreateProcessAsUserW *pfn = 0;
|
|---|
| 6602 | if (!pfn)
|
|---|
| 6603 | kPrf2WrapResolve((void **)&pfn, "CreateProcessAsUserW", &g_Kernel32);
|
|---|
| 6604 | return pfn( hToken, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 6605 | }
|
|---|
| 6606 |
|
|---|
| 6607 | typedef BOOL WINAPI FN_CreateProcessWithLogonW( LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 6608 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessWithLogonW( LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 6609 | {
|
|---|
| 6610 | static FN_CreateProcessWithLogonW *pfn = 0;
|
|---|
| 6611 | if (!pfn)
|
|---|
| 6612 | kPrf2WrapResolve((void **)&pfn, "CreateProcessWithLogonW", &g_Kernel32);
|
|---|
| 6613 | return pfn( lpUsername, lpDomain, lpPassword, dwLogonFlags, lpApplicationName, lpCommandLine, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 6614 | }
|
|---|
| 6615 |
|
|---|
| 6616 | typedef BOOL WINAPI FN_CreateProcessWithTokenW( HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
|
|---|
| 6617 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessWithTokenW( HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
|
|---|
| 6618 | {
|
|---|
| 6619 | static FN_CreateProcessWithTokenW *pfn = 0;
|
|---|
| 6620 | if (!pfn)
|
|---|
| 6621 | kPrf2WrapResolve((void **)&pfn, "CreateProcessWithTokenW", &g_Kernel32);
|
|---|
| 6622 | return pfn( hToken, dwLogonFlags, lpApplicationName, lpCommandLine, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
|
|---|
| 6623 | }
|
|---|
| 6624 |
|
|---|
| 6625 | typedef BOOL APIENTRY FN_ImpersonateAnonymousToken( HANDLE ThreadHandle );
|
|---|
| 6626 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_ImpersonateAnonymousToken( HANDLE ThreadHandle )
|
|---|
| 6627 | {
|
|---|
| 6628 | static FN_ImpersonateAnonymousToken *pfn = 0;
|
|---|
| 6629 | if (!pfn)
|
|---|
| 6630 | kPrf2WrapResolve((void **)&pfn, "ImpersonateAnonymousToken", &g_Kernel32);
|
|---|
| 6631 | return pfn( ThreadHandle );
|
|---|
| 6632 | }
|
|---|
| 6633 |
|
|---|
| 6634 | typedef BOOL WINAPI FN_DuplicateTokenEx( HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken );
|
|---|
| 6635 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateTokenEx( HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken )
|
|---|
| 6636 | {
|
|---|
| 6637 | static FN_DuplicateTokenEx *pfn = 0;
|
|---|
| 6638 | if (!pfn)
|
|---|
| 6639 | kPrf2WrapResolve((void **)&pfn, "DuplicateTokenEx", &g_Kernel32);
|
|---|
| 6640 | return pfn( hExistingToken, dwDesiredAccess, lpTokenAttributes, ImpersonationLevel, TokenType, phNewToken );
|
|---|
| 6641 | }
|
|---|
| 6642 |
|
|---|
| 6643 | typedef BOOL APIENTRY FN_CreateRestrictedToken( HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle );
|
|---|
| 6644 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_CreateRestrictedToken( HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle )
|
|---|
| 6645 | {
|
|---|
| 6646 | static FN_CreateRestrictedToken *pfn = 0;
|
|---|
| 6647 | if (!pfn)
|
|---|
| 6648 | kPrf2WrapResolve((void **)&pfn, "CreateRestrictedToken", &g_Kernel32);
|
|---|
| 6649 | return pfn( ExistingTokenHandle, Flags, DisableSidCount, SidsToDisable, DeletePrivilegeCount, PrivilegesToDelete, RestrictedSidCount, SidsToRestrict, NewTokenHandle );
|
|---|
| 6650 | }
|
|---|
| 6651 |
|
|---|
| 6652 | typedef BOOL WINAPI FN_IsTokenRestricted( HANDLE TokenHandle );
|
|---|
| 6653 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTokenRestricted( HANDLE TokenHandle )
|
|---|
| 6654 | {
|
|---|
| 6655 | static FN_IsTokenRestricted *pfn = 0;
|
|---|
| 6656 | if (!pfn)
|
|---|
| 6657 | kPrf2WrapResolve((void **)&pfn, "IsTokenRestricted", &g_Kernel32);
|
|---|
| 6658 | return pfn( TokenHandle );
|
|---|
| 6659 | }
|
|---|
| 6660 |
|
|---|
| 6661 | typedef BOOL WINAPI FN_IsTokenUntrusted( HANDLE TokenHandle );
|
|---|
| 6662 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTokenUntrusted( HANDLE TokenHandle )
|
|---|
| 6663 | {
|
|---|
| 6664 | static FN_IsTokenUntrusted *pfn = 0;
|
|---|
| 6665 | if (!pfn)
|
|---|
| 6666 | kPrf2WrapResolve((void **)&pfn, "IsTokenUntrusted", &g_Kernel32);
|
|---|
| 6667 | return pfn( TokenHandle );
|
|---|
| 6668 | }
|
|---|
| 6669 |
|
|---|
| 6670 | typedef BOOL APIENTRY FN_CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember );
|
|---|
| 6671 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember )
|
|---|
| 6672 | {
|
|---|
| 6673 | static FN_CheckTokenMembership *pfn = 0;
|
|---|
| 6674 | if (!pfn)
|
|---|
| 6675 | kPrf2WrapResolve((void **)&pfn, "CheckTokenMembership", &g_Kernel32);
|
|---|
| 6676 | return pfn( TokenHandle, SidToCheck, IsMember );
|
|---|
| 6677 | }
|
|---|
| 6678 |
|
|---|
| 6679 | typedef BOOL WINAPI FN_RegisterWaitForSingleObject( PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags );
|
|---|
| 6680 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RegisterWaitForSingleObject( PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags )
|
|---|
| 6681 | {
|
|---|
| 6682 | static FN_RegisterWaitForSingleObject *pfn = 0;
|
|---|
| 6683 | if (!pfn)
|
|---|
| 6684 | kPrf2WrapResolve((void **)&pfn, "RegisterWaitForSingleObject", &g_Kernel32);
|
|---|
| 6685 | return pfn( phNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
|
|---|
| 6686 | }
|
|---|
| 6687 |
|
|---|
| 6688 | typedef HANDLE WINAPI FN_RegisterWaitForSingleObjectEx( HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags );
|
|---|
| 6689 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterWaitForSingleObjectEx( HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags )
|
|---|
| 6690 | {
|
|---|
| 6691 | static FN_RegisterWaitForSingleObjectEx *pfn = 0;
|
|---|
| 6692 | if (!pfn)
|
|---|
| 6693 | kPrf2WrapResolve((void **)&pfn, "RegisterWaitForSingleObjectEx", &g_Kernel32);
|
|---|
| 6694 | return pfn( hObject, Callback, Context, dwMilliseconds, dwFlags );
|
|---|
| 6695 | }
|
|---|
| 6696 |
|
|---|
| 6697 | typedef BOOL WINAPI FN_UnregisterWait( HANDLE WaitHandle );
|
|---|
| 6698 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnregisterWait( HANDLE WaitHandle )
|
|---|
| 6699 | {
|
|---|
| 6700 | static FN_UnregisterWait *pfn = 0;
|
|---|
| 6701 | if (!pfn)
|
|---|
| 6702 | kPrf2WrapResolve((void **)&pfn, "UnregisterWait", &g_Kernel32);
|
|---|
| 6703 | return pfn( WaitHandle );
|
|---|
| 6704 | }
|
|---|
| 6705 |
|
|---|
| 6706 | typedef BOOL WINAPI FN_UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent );
|
|---|
| 6707 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent )
|
|---|
| 6708 | {
|
|---|
| 6709 | static FN_UnregisterWaitEx *pfn = 0;
|
|---|
| 6710 | if (!pfn)
|
|---|
| 6711 | kPrf2WrapResolve((void **)&pfn, "UnregisterWaitEx", &g_Kernel32);
|
|---|
| 6712 | return pfn( WaitHandle, CompletionEvent );
|
|---|
| 6713 | }
|
|---|
| 6714 |
|
|---|
| 6715 | typedef BOOL WINAPI FN_QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags );
|
|---|
| 6716 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
|
|---|
| 6717 | {
|
|---|
| 6718 | static FN_QueueUserWorkItem *pfn = 0;
|
|---|
| 6719 | if (!pfn)
|
|---|
| 6720 | kPrf2WrapResolve((void **)&pfn, "QueueUserWorkItem", &g_Kernel32);
|
|---|
| 6721 | return pfn( Function, Context, Flags );
|
|---|
| 6722 | }
|
|---|
| 6723 |
|
|---|
| 6724 | typedef BOOL WINAPI FN_BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags );
|
|---|
| 6725 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags )
|
|---|
| 6726 | {
|
|---|
| 6727 | static FN_BindIoCompletionCallback *pfn = 0;
|
|---|
| 6728 | if (!pfn)
|
|---|
| 6729 | kPrf2WrapResolve((void **)&pfn, "BindIoCompletionCallback", &g_Kernel32);
|
|---|
| 6730 | return pfn( FileHandle, Function, Flags );
|
|---|
| 6731 | }
|
|---|
| 6732 |
|
|---|
| 6733 | typedef HANDLE WINAPI FN_CreateTimerQueue( VOID );
|
|---|
| 6734 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateTimerQueue( VOID )
|
|---|
| 6735 | {
|
|---|
| 6736 | static FN_CreateTimerQueue *pfn = 0;
|
|---|
| 6737 | if (!pfn)
|
|---|
| 6738 | kPrf2WrapResolve((void **)&pfn, "CreateTimerQueue", &g_Kernel32);
|
|---|
| 6739 | return pfn ();
|
|---|
| 6740 | }
|
|---|
| 6741 |
|
|---|
| 6742 | typedef BOOL WINAPI FN_CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags );
|
|---|
| 6743 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags )
|
|---|
| 6744 | {
|
|---|
| 6745 | static FN_CreateTimerQueueTimer *pfn = 0;
|
|---|
| 6746 | if (!pfn)
|
|---|
| 6747 | kPrf2WrapResolve((void **)&pfn, "CreateTimerQueueTimer", &g_Kernel32);
|
|---|
| 6748 | return pfn( phNewTimer, TimerQueue, Callback, Parameter, DueTime, Period, Flags );
|
|---|
| 6749 | }
|
|---|
| 6750 |
|
|---|
| 6751 | typedef BOOL WINAPI FN_ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period );
|
|---|
| 6752 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period )
|
|---|
| 6753 | {
|
|---|
| 6754 | static FN_ChangeTimerQueueTimer *pfn = 0;
|
|---|
| 6755 | if (!pfn)
|
|---|
| 6756 | kPrf2WrapResolve((void **)&pfn, "ChangeTimerQueueTimer", &g_Kernel32);
|
|---|
| 6757 | return pfn( TimerQueue, Timer, DueTime, Period );
|
|---|
| 6758 | }
|
|---|
| 6759 |
|
|---|
| 6760 | typedef BOOL WINAPI FN_DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent );
|
|---|
| 6761 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent )
|
|---|
| 6762 | {
|
|---|
| 6763 | static FN_DeleteTimerQueueTimer *pfn = 0;
|
|---|
| 6764 | if (!pfn)
|
|---|
| 6765 | kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueueTimer", &g_Kernel32);
|
|---|
| 6766 | return pfn( TimerQueue, Timer, CompletionEvent );
|
|---|
| 6767 | }
|
|---|
| 6768 |
|
|---|
| 6769 | typedef BOOL WINAPI FN_DeleteTimerQueueEx( HANDLE TimerQueue, HANDLE CompletionEvent );
|
|---|
| 6770 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueueEx( HANDLE TimerQueue, HANDLE CompletionEvent )
|
|---|
| 6771 | {
|
|---|
| 6772 | static FN_DeleteTimerQueueEx *pfn = 0;
|
|---|
| 6773 | if (!pfn)
|
|---|
| 6774 | kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueueEx", &g_Kernel32);
|
|---|
| 6775 | return pfn( TimerQueue, CompletionEvent );
|
|---|
| 6776 | }
|
|---|
| 6777 |
|
|---|
| 6778 | typedef HANDLE WINAPI FN_SetTimerQueueTimer( HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo );
|
|---|
| 6779 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_SetTimerQueueTimer( HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo )
|
|---|
| 6780 | {
|
|---|
| 6781 | static FN_SetTimerQueueTimer *pfn = 0;
|
|---|
| 6782 | if (!pfn)
|
|---|
| 6783 | kPrf2WrapResolve((void **)&pfn, "SetTimerQueueTimer", &g_Kernel32);
|
|---|
| 6784 | return pfn( TimerQueue, Callback, Parameter, DueTime, Period, PreferIo );
|
|---|
| 6785 | }
|
|---|
| 6786 |
|
|---|
| 6787 | typedef BOOL WINAPI FN_CancelTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer );
|
|---|
| 6788 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer )
|
|---|
| 6789 | {
|
|---|
| 6790 | static FN_CancelTimerQueueTimer *pfn = 0;
|
|---|
| 6791 | if (!pfn)
|
|---|
| 6792 | kPrf2WrapResolve((void **)&pfn, "CancelTimerQueueTimer", &g_Kernel32);
|
|---|
| 6793 | return pfn( TimerQueue, Timer );
|
|---|
| 6794 | }
|
|---|
| 6795 |
|
|---|
| 6796 | typedef BOOL WINAPI FN_DeleteTimerQueue( HANDLE TimerQueue );
|
|---|
| 6797 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueue( HANDLE TimerQueue )
|
|---|
| 6798 | {
|
|---|
| 6799 | static FN_DeleteTimerQueue *pfn = 0;
|
|---|
| 6800 | if (!pfn)
|
|---|
| 6801 | kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueue", &g_Kernel32);
|
|---|
| 6802 | return pfn( TimerQueue );
|
|---|
| 6803 | }
|
|---|
| 6804 |
|
|---|
| 6805 | typedef BOOL WINAPI FN_GetCurrentHwProfileA( LPHW_PROFILE_INFOA lpHwProfileInfo );
|
|---|
| 6806 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentHwProfileA( LPHW_PROFILE_INFOA lpHwProfileInfo )
|
|---|
| 6807 | {
|
|---|
| 6808 | static FN_GetCurrentHwProfileA *pfn = 0;
|
|---|
| 6809 | if (!pfn)
|
|---|
| 6810 | kPrf2WrapResolve((void **)&pfn, "GetCurrentHwProfileA", &g_Kernel32);
|
|---|
| 6811 | return pfn( lpHwProfileInfo );
|
|---|
| 6812 | }
|
|---|
| 6813 |
|
|---|
| 6814 | typedef BOOL WINAPI FN_GetCurrentHwProfileW( LPHW_PROFILE_INFOW lpHwProfileInfo );
|
|---|
| 6815 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentHwProfileW( LPHW_PROFILE_INFOW lpHwProfileInfo )
|
|---|
| 6816 | {
|
|---|
| 6817 | static FN_GetCurrentHwProfileW *pfn = 0;
|
|---|
| 6818 | if (!pfn)
|
|---|
| 6819 | kPrf2WrapResolve((void **)&pfn, "GetCurrentHwProfileW", &g_Kernel32);
|
|---|
| 6820 | return pfn( lpHwProfileInfo );
|
|---|
| 6821 | }
|
|---|
| 6822 |
|
|---|
| 6823 | typedef BOOL WINAPI FN_QueryPerformanceCounter( LARGE_INTEGER * lpPerformanceCount );
|
|---|
| 6824 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryPerformanceCounter( LARGE_INTEGER * lpPerformanceCount )
|
|---|
| 6825 | {
|
|---|
| 6826 | static FN_QueryPerformanceCounter *pfn = 0;
|
|---|
| 6827 | if (!pfn)
|
|---|
| 6828 | kPrf2WrapResolve((void **)&pfn, "QueryPerformanceCounter", &g_Kernel32);
|
|---|
| 6829 | return pfn( lpPerformanceCount );
|
|---|
| 6830 | }
|
|---|
| 6831 |
|
|---|
| 6832 | typedef BOOL WINAPI FN_QueryPerformanceFrequency( LARGE_INTEGER * lpFrequency );
|
|---|
| 6833 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryPerformanceFrequency( LARGE_INTEGER * lpFrequency )
|
|---|
| 6834 | {
|
|---|
| 6835 | static FN_QueryPerformanceFrequency *pfn = 0;
|
|---|
| 6836 | if (!pfn)
|
|---|
| 6837 | kPrf2WrapResolve((void **)&pfn, "QueryPerformanceFrequency", &g_Kernel32);
|
|---|
| 6838 | return pfn( lpFrequency );
|
|---|
| 6839 | }
|
|---|
| 6840 |
|
|---|
| 6841 | typedef BOOL WINAPI FN_GetVersionExA( LPOSVERSIONINFOA lpVersionInformation );
|
|---|
| 6842 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVersionExA( LPOSVERSIONINFOA lpVersionInformation )
|
|---|
| 6843 | {
|
|---|
| 6844 | static FN_GetVersionExA *pfn = 0;
|
|---|
| 6845 | if (!pfn)
|
|---|
| 6846 | kPrf2WrapResolve((void **)&pfn, "GetVersionExA", &g_Kernel32);
|
|---|
| 6847 | return pfn( lpVersionInformation );
|
|---|
| 6848 | }
|
|---|
| 6849 |
|
|---|
| 6850 | typedef BOOL WINAPI FN_GetVersionExW( LPOSVERSIONINFOW lpVersionInformation );
|
|---|
| 6851 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVersionExW( LPOSVERSIONINFOW lpVersionInformation )
|
|---|
| 6852 | {
|
|---|
| 6853 | static FN_GetVersionExW *pfn = 0;
|
|---|
| 6854 | if (!pfn)
|
|---|
| 6855 | kPrf2WrapResolve((void **)&pfn, "GetVersionExW", &g_Kernel32);
|
|---|
| 6856 | return pfn( lpVersionInformation );
|
|---|
| 6857 | }
|
|---|
| 6858 |
|
|---|
| 6859 | typedef BOOL WINAPI FN_VerifyVersionInfoA( LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask );
|
|---|
| 6860 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VerifyVersionInfoA( LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask )
|
|---|
| 6861 | {
|
|---|
| 6862 | static FN_VerifyVersionInfoA *pfn = 0;
|
|---|
| 6863 | if (!pfn)
|
|---|
| 6864 | kPrf2WrapResolve((void **)&pfn, "VerifyVersionInfoA", &g_Kernel32);
|
|---|
| 6865 | return pfn( lpVersionInformation, dwTypeMask, dwlConditionMask );
|
|---|
| 6866 | }
|
|---|
| 6867 |
|
|---|
| 6868 | typedef BOOL WINAPI FN_VerifyVersionInfoW( LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask );
|
|---|
| 6869 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VerifyVersionInfoW( LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask )
|
|---|
| 6870 | {
|
|---|
| 6871 | static FN_VerifyVersionInfoW *pfn = 0;
|
|---|
| 6872 | if (!pfn)
|
|---|
| 6873 | kPrf2WrapResolve((void **)&pfn, "VerifyVersionInfoW", &g_Kernel32);
|
|---|
| 6874 | return pfn( lpVersionInformation, dwTypeMask, dwlConditionMask );
|
|---|
| 6875 | }
|
|---|
| 6876 |
|
|---|
| 6877 | typedef BOOL WINAPI FN_GetSystemPowerStatus( LPSYSTEM_POWER_STATUS lpSystemPowerStatus );
|
|---|
| 6878 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemPowerStatus( LPSYSTEM_POWER_STATUS lpSystemPowerStatus )
|
|---|
| 6879 | {
|
|---|
| 6880 | static FN_GetSystemPowerStatus *pfn = 0;
|
|---|
| 6881 | if (!pfn)
|
|---|
| 6882 | kPrf2WrapResolve((void **)&pfn, "GetSystemPowerStatus", &g_Kernel32);
|
|---|
| 6883 | return pfn( lpSystemPowerStatus );
|
|---|
| 6884 | }
|
|---|
| 6885 |
|
|---|
| 6886 | typedef BOOL WINAPI FN_SetSystemPowerState( BOOL fSuspend, BOOL fForce );
|
|---|
| 6887 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemPowerState( BOOL fSuspend, BOOL fForce )
|
|---|
| 6888 | {
|
|---|
| 6889 | static FN_SetSystemPowerState *pfn = 0;
|
|---|
| 6890 | if (!pfn)
|
|---|
| 6891 | kPrf2WrapResolve((void **)&pfn, "SetSystemPowerState", &g_Kernel32);
|
|---|
| 6892 | return pfn( fSuspend, fForce );
|
|---|
| 6893 | }
|
|---|
| 6894 |
|
|---|
| 6895 | typedef BOOL WINAPI FN_AllocateUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray );
|
|---|
| 6896 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray )
|
|---|
| 6897 | {
|
|---|
| 6898 | static FN_AllocateUserPhysicalPages *pfn = 0;
|
|---|
| 6899 | if (!pfn)
|
|---|
| 6900 | kPrf2WrapResolve((void **)&pfn, "AllocateUserPhysicalPages", &g_Kernel32);
|
|---|
| 6901 | return pfn( hProcess, NumberOfPages, PageArray );
|
|---|
| 6902 | }
|
|---|
| 6903 |
|
|---|
| 6904 | typedef BOOL WINAPI FN_FreeUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray );
|
|---|
| 6905 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray )
|
|---|
| 6906 | {
|
|---|
| 6907 | static FN_FreeUserPhysicalPages *pfn = 0;
|
|---|
| 6908 | if (!pfn)
|
|---|
| 6909 | kPrf2WrapResolve((void **)&pfn, "FreeUserPhysicalPages", &g_Kernel32);
|
|---|
| 6910 | return pfn( hProcess, NumberOfPages, PageArray );
|
|---|
| 6911 | }
|
|---|
| 6912 |
|
|---|
| 6913 | typedef BOOL WINAPI FN_MapUserPhysicalPages( PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray );
|
|---|
| 6914 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MapUserPhysicalPages( PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray )
|
|---|
| 6915 | {
|
|---|
| 6916 | static FN_MapUserPhysicalPages *pfn = 0;
|
|---|
| 6917 | if (!pfn)
|
|---|
| 6918 | kPrf2WrapResolve((void **)&pfn, "MapUserPhysicalPages", &g_Kernel32);
|
|---|
| 6919 | return pfn( VirtualAddress, NumberOfPages, PageArray );
|
|---|
| 6920 | }
|
|---|
| 6921 |
|
|---|
| 6922 | typedef BOOL WINAPI FN_MapUserPhysicalPagesScatter( PVOID * VirtualAddresses, ULONG_PTR NumberOfPages, PULONG_PTR PageArray );
|
|---|
| 6923 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MapUserPhysicalPagesScatter( PVOID * VirtualAddresses, ULONG_PTR NumberOfPages, PULONG_PTR PageArray )
|
|---|
| 6924 | {
|
|---|
| 6925 | static FN_MapUserPhysicalPagesScatter *pfn = 0;
|
|---|
| 6926 | if (!pfn)
|
|---|
| 6927 | kPrf2WrapResolve((void **)&pfn, "MapUserPhysicalPagesScatter", &g_Kernel32);
|
|---|
| 6928 | return pfn( VirtualAddresses, NumberOfPages, PageArray );
|
|---|
| 6929 | }
|
|---|
| 6930 |
|
|---|
| 6931 | typedef HANDLE WINAPI FN_CreateJobObjectA( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName );
|
|---|
| 6932 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateJobObjectA( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName )
|
|---|
| 6933 | {
|
|---|
| 6934 | static FN_CreateJobObjectA *pfn = 0;
|
|---|
| 6935 | if (!pfn)
|
|---|
| 6936 | kPrf2WrapResolve((void **)&pfn, "CreateJobObjectA", &g_Kernel32);
|
|---|
| 6937 | return pfn( lpJobAttributes, lpName );
|
|---|
| 6938 | }
|
|---|
| 6939 |
|
|---|
| 6940 | typedef HANDLE WINAPI FN_CreateJobObjectW( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName );
|
|---|
| 6941 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateJobObjectW( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName )
|
|---|
| 6942 | {
|
|---|
| 6943 | static FN_CreateJobObjectW *pfn = 0;
|
|---|
| 6944 | if (!pfn)
|
|---|
| 6945 | kPrf2WrapResolve((void **)&pfn, "CreateJobObjectW", &g_Kernel32);
|
|---|
| 6946 | return pfn( lpJobAttributes, lpName );
|
|---|
| 6947 | }
|
|---|
| 6948 |
|
|---|
| 6949 | typedef HANDLE WINAPI FN_OpenJobObjectA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
|
|---|
| 6950 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenJobObjectA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
|
|---|
| 6951 | {
|
|---|
| 6952 | static FN_OpenJobObjectA *pfn = 0;
|
|---|
| 6953 | if (!pfn)
|
|---|
| 6954 | kPrf2WrapResolve((void **)&pfn, "OpenJobObjectA", &g_Kernel32);
|
|---|
| 6955 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 6956 | }
|
|---|
| 6957 |
|
|---|
| 6958 | typedef HANDLE WINAPI FN_OpenJobObjectW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
|
|---|
| 6959 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenJobObjectW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
|
|---|
| 6960 | {
|
|---|
| 6961 | static FN_OpenJobObjectW *pfn = 0;
|
|---|
| 6962 | if (!pfn)
|
|---|
| 6963 | kPrf2WrapResolve((void **)&pfn, "OpenJobObjectW", &g_Kernel32);
|
|---|
| 6964 | return pfn( dwDesiredAccess, bInheritHandle, lpName );
|
|---|
| 6965 | }
|
|---|
| 6966 |
|
|---|
| 6967 | typedef BOOL WINAPI FN_AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess );
|
|---|
| 6968 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess )
|
|---|
| 6969 | {
|
|---|
| 6970 | static FN_AssignProcessToJobObject *pfn = 0;
|
|---|
| 6971 | if (!pfn)
|
|---|
| 6972 | kPrf2WrapResolve((void **)&pfn, "AssignProcessToJobObject", &g_Kernel32);
|
|---|
| 6973 | return pfn( hJob, hProcess );
|
|---|
| 6974 | }
|
|---|
| 6975 |
|
|---|
| 6976 | typedef BOOL WINAPI FN_TerminateJobObject( HANDLE hJob, UINT uExitCode );
|
|---|
| 6977 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateJobObject( HANDLE hJob, UINT uExitCode )
|
|---|
| 6978 | {
|
|---|
| 6979 | static FN_TerminateJobObject *pfn = 0;
|
|---|
| 6980 | if (!pfn)
|
|---|
| 6981 | kPrf2WrapResolve((void **)&pfn, "TerminateJobObject", &g_Kernel32);
|
|---|
| 6982 | return pfn( hJob, uExitCode );
|
|---|
| 6983 | }
|
|---|
| 6984 |
|
|---|
| 6985 | typedef BOOL WINAPI FN_QueryInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength );
|
|---|
| 6986 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength )
|
|---|
| 6987 | {
|
|---|
| 6988 | static FN_QueryInformationJobObject *pfn = 0;
|
|---|
| 6989 | if (!pfn)
|
|---|
| 6990 | kPrf2WrapResolve((void **)&pfn, "QueryInformationJobObject", &g_Kernel32);
|
|---|
| 6991 | return pfn( hJob, JobObjectInformationClass, lpJobObjectInformation, cbJobObjectInformationLength, lpReturnLength );
|
|---|
| 6992 | }
|
|---|
| 6993 |
|
|---|
| 6994 | typedef BOOL WINAPI FN_SetInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength );
|
|---|
| 6995 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength )
|
|---|
| 6996 | {
|
|---|
| 6997 | static FN_SetInformationJobObject *pfn = 0;
|
|---|
| 6998 | if (!pfn)
|
|---|
| 6999 | kPrf2WrapResolve((void **)&pfn, "SetInformationJobObject", &g_Kernel32);
|
|---|
| 7000 | return pfn( hJob, JobObjectInformationClass, lpJobObjectInformation, cbJobObjectInformationLength );
|
|---|
| 7001 | }
|
|---|
| 7002 |
|
|---|
| 7003 | typedef BOOL WINAPI FN_IsProcessInJob( HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result );
|
|---|
| 7004 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsProcessInJob( HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result )
|
|---|
| 7005 | {
|
|---|
| 7006 | static FN_IsProcessInJob *pfn = 0;
|
|---|
| 7007 | if (!pfn)
|
|---|
| 7008 | kPrf2WrapResolve((void **)&pfn, "IsProcessInJob", &g_Kernel32);
|
|---|
| 7009 | return pfn( ProcessHandle, JobHandle, Result );
|
|---|
| 7010 | }
|
|---|
| 7011 |
|
|---|
| 7012 | typedef BOOL WINAPI FN_CreateJobSet( ULONG NumJob, PJOB_SET_ARRAY UserJobSet, ULONG Flags );
|
|---|
| 7013 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateJobSet( ULONG NumJob, PJOB_SET_ARRAY UserJobSet, ULONG Flags )
|
|---|
| 7014 | {
|
|---|
| 7015 | static FN_CreateJobSet *pfn = 0;
|
|---|
| 7016 | if (!pfn)
|
|---|
| 7017 | kPrf2WrapResolve((void **)&pfn, "CreateJobSet", &g_Kernel32);
|
|---|
| 7018 | return pfn( NumJob, UserJobSet, Flags );
|
|---|
| 7019 | }
|
|---|
| 7020 |
|
|---|
| 7021 | typedef PVOID WINAPI FN_AddVectoredExceptionHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler );
|
|---|
| 7022 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_AddVectoredExceptionHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler )
|
|---|
| 7023 | {
|
|---|
| 7024 | static FN_AddVectoredExceptionHandler *pfn = 0;
|
|---|
| 7025 | if (!pfn)
|
|---|
| 7026 | kPrf2WrapResolve((void **)&pfn, "AddVectoredExceptionHandler", &g_Kernel32);
|
|---|
| 7027 | return pfn( First, Handler );
|
|---|
| 7028 | }
|
|---|
| 7029 |
|
|---|
| 7030 | typedef ULONG WINAPI FN_RemoveVectoredExceptionHandler( PVOID Handle );
|
|---|
| 7031 | __declspec(dllexport) ULONG WINAPI kPrf2Wrap_RemoveVectoredExceptionHandler( PVOID Handle )
|
|---|
| 7032 | {
|
|---|
| 7033 | static FN_RemoveVectoredExceptionHandler *pfn = 0;
|
|---|
| 7034 | if (!pfn)
|
|---|
| 7035 | kPrf2WrapResolve((void **)&pfn, "RemoveVectoredExceptionHandler", &g_Kernel32);
|
|---|
| 7036 | return pfn( Handle );
|
|---|
| 7037 | }
|
|---|
| 7038 |
|
|---|
| 7039 | typedef PVOID WINAPI FN_AddVectoredContinueHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler );
|
|---|
| 7040 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_AddVectoredContinueHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler )
|
|---|
| 7041 | {
|
|---|
| 7042 | static FN_AddVectoredContinueHandler *pfn = 0;
|
|---|
| 7043 | if (!pfn)
|
|---|
| 7044 | kPrf2WrapResolve((void **)&pfn, "AddVectoredContinueHandler", &g_Kernel32);
|
|---|
| 7045 | return pfn( First, Handler );
|
|---|
| 7046 | }
|
|---|
| 7047 |
|
|---|
| 7048 | typedef ULONG WINAPI FN_RemoveVectoredContinueHandler( PVOID Handle );
|
|---|
| 7049 | __declspec(dllexport) ULONG WINAPI kPrf2Wrap_RemoveVectoredContinueHandler( PVOID Handle )
|
|---|
| 7050 | {
|
|---|
| 7051 | static FN_RemoveVectoredContinueHandler *pfn = 0;
|
|---|
| 7052 | if (!pfn)
|
|---|
| 7053 | kPrf2WrapResolve((void **)&pfn, "RemoveVectoredContinueHandler", &g_Kernel32);
|
|---|
| 7054 | return pfn( Handle );
|
|---|
| 7055 | }
|
|---|
| 7056 |
|
|---|
| 7057 | typedef HANDLE WINAPI FN_FindFirstVolumeA( LPSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7058 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeA( LPSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7059 | {
|
|---|
| 7060 | static FN_FindFirstVolumeA *pfn = 0;
|
|---|
| 7061 | if (!pfn)
|
|---|
| 7062 | kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeA", &g_Kernel32);
|
|---|
| 7063 | return pfn( lpszVolumeName, cchBufferLength );
|
|---|
| 7064 | }
|
|---|
| 7065 |
|
|---|
| 7066 | typedef HANDLE WINAPI FN_FindFirstVolumeW( LPWSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7067 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeW( LPWSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7068 | {
|
|---|
| 7069 | static FN_FindFirstVolumeW *pfn = 0;
|
|---|
| 7070 | if (!pfn)
|
|---|
| 7071 | kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeW", &g_Kernel32);
|
|---|
| 7072 | return pfn( lpszVolumeName, cchBufferLength );
|
|---|
| 7073 | }
|
|---|
| 7074 |
|
|---|
| 7075 | typedef BOOL WINAPI FN_FindNextVolumeA( HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7076 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeA( HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7077 | {
|
|---|
| 7078 | static FN_FindNextVolumeA *pfn = 0;
|
|---|
| 7079 | if (!pfn)
|
|---|
| 7080 | kPrf2WrapResolve((void **)&pfn, "FindNextVolumeA", &g_Kernel32);
|
|---|
| 7081 | return pfn( hFindVolume, lpszVolumeName, cchBufferLength );
|
|---|
| 7082 | }
|
|---|
| 7083 |
|
|---|
| 7084 | typedef BOOL WINAPI FN_FindNextVolumeW( HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7085 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeW( HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7086 | {
|
|---|
| 7087 | static FN_FindNextVolumeW *pfn = 0;
|
|---|
| 7088 | if (!pfn)
|
|---|
| 7089 | kPrf2WrapResolve((void **)&pfn, "FindNextVolumeW", &g_Kernel32);
|
|---|
| 7090 | return pfn( hFindVolume, lpszVolumeName, cchBufferLength );
|
|---|
| 7091 | }
|
|---|
| 7092 |
|
|---|
| 7093 | typedef BOOL WINAPI FN_FindVolumeClose( HANDLE hFindVolume );
|
|---|
| 7094 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindVolumeClose( HANDLE hFindVolume )
|
|---|
| 7095 | {
|
|---|
| 7096 | static FN_FindVolumeClose *pfn = 0;
|
|---|
| 7097 | if (!pfn)
|
|---|
| 7098 | kPrf2WrapResolve((void **)&pfn, "FindVolumeClose", &g_Kernel32);
|
|---|
| 7099 | return pfn( hFindVolume );
|
|---|
| 7100 | }
|
|---|
| 7101 |
|
|---|
| 7102 | typedef HANDLE WINAPI FN_FindFirstVolumeMountPointA( LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength );
|
|---|
| 7103 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeMountPointA( LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength )
|
|---|
| 7104 | {
|
|---|
| 7105 | static FN_FindFirstVolumeMountPointA *pfn = 0;
|
|---|
| 7106 | if (!pfn)
|
|---|
| 7107 | kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeMountPointA", &g_Kernel32);
|
|---|
| 7108 | return pfn( lpszRootPathName, lpszVolumeMountPoint, cchBufferLength );
|
|---|
| 7109 | }
|
|---|
| 7110 |
|
|---|
| 7111 | typedef HANDLE WINAPI FN_FindFirstVolumeMountPointW( LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength );
|
|---|
| 7112 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeMountPointW( LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength )
|
|---|
| 7113 | {
|
|---|
| 7114 | static FN_FindFirstVolumeMountPointW *pfn = 0;
|
|---|
| 7115 | if (!pfn)
|
|---|
| 7116 | kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeMountPointW", &g_Kernel32);
|
|---|
| 7117 | return pfn( lpszRootPathName, lpszVolumeMountPoint, cchBufferLength );
|
|---|
| 7118 | }
|
|---|
| 7119 |
|
|---|
| 7120 | typedef BOOL WINAPI FN_FindNextVolumeMountPointA( HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength );
|
|---|
| 7121 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeMountPointA( HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength )
|
|---|
| 7122 | {
|
|---|
| 7123 | static FN_FindNextVolumeMountPointA *pfn = 0;
|
|---|
| 7124 | if (!pfn)
|
|---|
| 7125 | kPrf2WrapResolve((void **)&pfn, "FindNextVolumeMountPointA", &g_Kernel32);
|
|---|
| 7126 | return pfn( hFindVolumeMountPoint, lpszVolumeMountPoint, cchBufferLength );
|
|---|
| 7127 | }
|
|---|
| 7128 |
|
|---|
| 7129 | typedef BOOL WINAPI FN_FindNextVolumeMountPointW( HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength );
|
|---|
| 7130 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeMountPointW( HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength )
|
|---|
| 7131 | {
|
|---|
| 7132 | static FN_FindNextVolumeMountPointW *pfn = 0;
|
|---|
| 7133 | if (!pfn)
|
|---|
| 7134 | kPrf2WrapResolve((void **)&pfn, "FindNextVolumeMountPointW", &g_Kernel32);
|
|---|
| 7135 | return pfn( hFindVolumeMountPoint, lpszVolumeMountPoint, cchBufferLength );
|
|---|
| 7136 | }
|
|---|
| 7137 |
|
|---|
| 7138 | typedef BOOL WINAPI FN_FindVolumeMountPointClose( HANDLE hFindVolumeMountPoint );
|
|---|
| 7139 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindVolumeMountPointClose( HANDLE hFindVolumeMountPoint )
|
|---|
| 7140 | {
|
|---|
| 7141 | static FN_FindVolumeMountPointClose *pfn = 0;
|
|---|
| 7142 | if (!pfn)
|
|---|
| 7143 | kPrf2WrapResolve((void **)&pfn, "FindVolumeMountPointClose", &g_Kernel32);
|
|---|
| 7144 | return pfn( hFindVolumeMountPoint );
|
|---|
| 7145 | }
|
|---|
| 7146 |
|
|---|
| 7147 | typedef BOOL WINAPI FN_SetVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName );
|
|---|
| 7148 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName )
|
|---|
| 7149 | {
|
|---|
| 7150 | static FN_SetVolumeMountPointA *pfn = 0;
|
|---|
| 7151 | if (!pfn)
|
|---|
| 7152 | kPrf2WrapResolve((void **)&pfn, "SetVolumeMountPointA", &g_Kernel32);
|
|---|
| 7153 | return pfn( lpszVolumeMountPoint, lpszVolumeName );
|
|---|
| 7154 | }
|
|---|
| 7155 |
|
|---|
| 7156 | typedef BOOL WINAPI FN_SetVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName );
|
|---|
| 7157 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName )
|
|---|
| 7158 | {
|
|---|
| 7159 | static FN_SetVolumeMountPointW *pfn = 0;
|
|---|
| 7160 | if (!pfn)
|
|---|
| 7161 | kPrf2WrapResolve((void **)&pfn, "SetVolumeMountPointW", &g_Kernel32);
|
|---|
| 7162 | return pfn( lpszVolumeMountPoint, lpszVolumeName );
|
|---|
| 7163 | }
|
|---|
| 7164 |
|
|---|
| 7165 | typedef BOOL WINAPI FN_DeleteVolumeMountPointA( LPCSTR lpszVolumeMountPoint );
|
|---|
| 7166 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteVolumeMountPointA( LPCSTR lpszVolumeMountPoint )
|
|---|
| 7167 | {
|
|---|
| 7168 | static FN_DeleteVolumeMountPointA *pfn = 0;
|
|---|
| 7169 | if (!pfn)
|
|---|
| 7170 | kPrf2WrapResolve((void **)&pfn, "DeleteVolumeMountPointA", &g_Kernel32);
|
|---|
| 7171 | return pfn( lpszVolumeMountPoint );
|
|---|
| 7172 | }
|
|---|
| 7173 |
|
|---|
| 7174 | typedef BOOL WINAPI FN_DeleteVolumeMountPointW( LPCWSTR lpszVolumeMountPoint );
|
|---|
| 7175 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteVolumeMountPointW( LPCWSTR lpszVolumeMountPoint )
|
|---|
| 7176 | {
|
|---|
| 7177 | static FN_DeleteVolumeMountPointW *pfn = 0;
|
|---|
| 7178 | if (!pfn)
|
|---|
| 7179 | kPrf2WrapResolve((void **)&pfn, "DeleteVolumeMountPointW", &g_Kernel32);
|
|---|
| 7180 | return pfn( lpszVolumeMountPoint );
|
|---|
| 7181 | }
|
|---|
| 7182 |
|
|---|
| 7183 | typedef BOOL WINAPI FN_GetVolumeNameForVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7184 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeNameForVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7185 | {
|
|---|
| 7186 | static FN_GetVolumeNameForVolumeMountPointA *pfn = 0;
|
|---|
| 7187 | if (!pfn)
|
|---|
| 7188 | kPrf2WrapResolve((void **)&pfn, "GetVolumeNameForVolumeMountPointA", &g_Kernel32);
|
|---|
| 7189 | return pfn( lpszVolumeMountPoint, lpszVolumeName, cchBufferLength );
|
|---|
| 7190 | }
|
|---|
| 7191 |
|
|---|
| 7192 | typedef BOOL WINAPI FN_GetVolumeNameForVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength );
|
|---|
| 7193 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeNameForVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength )
|
|---|
| 7194 | {
|
|---|
| 7195 | static FN_GetVolumeNameForVolumeMountPointW *pfn = 0;
|
|---|
| 7196 | if (!pfn)
|
|---|
| 7197 | kPrf2WrapResolve((void **)&pfn, "GetVolumeNameForVolumeMountPointW", &g_Kernel32);
|
|---|
| 7198 | return pfn( lpszVolumeMountPoint, lpszVolumeName, cchBufferLength );
|
|---|
| 7199 | }
|
|---|
| 7200 |
|
|---|
| 7201 | typedef BOOL WINAPI FN_GetVolumePathNameA( LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength );
|
|---|
| 7202 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNameA( LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength )
|
|---|
| 7203 | {
|
|---|
| 7204 | static FN_GetVolumePathNameA *pfn = 0;
|
|---|
| 7205 | if (!pfn)
|
|---|
| 7206 | kPrf2WrapResolve((void **)&pfn, "GetVolumePathNameA", &g_Kernel32);
|
|---|
| 7207 | return pfn( lpszFileName, lpszVolumePathName, cchBufferLength );
|
|---|
| 7208 | }
|
|---|
| 7209 |
|
|---|
| 7210 | typedef BOOL WINAPI FN_GetVolumePathNameW( LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength );
|
|---|
| 7211 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNameW( LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength )
|
|---|
| 7212 | {
|
|---|
| 7213 | static FN_GetVolumePathNameW *pfn = 0;
|
|---|
| 7214 | if (!pfn)
|
|---|
| 7215 | kPrf2WrapResolve((void **)&pfn, "GetVolumePathNameW", &g_Kernel32);
|
|---|
| 7216 | return pfn( lpszFileName, lpszVolumePathName, cchBufferLength );
|
|---|
| 7217 | }
|
|---|
| 7218 |
|
|---|
| 7219 | typedef BOOL WINAPI FN_GetVolumePathNamesForVolumeNameA( LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength );
|
|---|
| 7220 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNamesForVolumeNameA( LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength )
|
|---|
| 7221 | {
|
|---|
| 7222 | static FN_GetVolumePathNamesForVolumeNameA *pfn = 0;
|
|---|
| 7223 | if (!pfn)
|
|---|
| 7224 | kPrf2WrapResolve((void **)&pfn, "GetVolumePathNamesForVolumeNameA", &g_Kernel32);
|
|---|
| 7225 | return pfn( lpszVolumeName, lpszVolumePathNames, cchBufferLength, lpcchReturnLength );
|
|---|
| 7226 | }
|
|---|
| 7227 |
|
|---|
| 7228 | typedef BOOL WINAPI FN_GetVolumePathNamesForVolumeNameW( LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength );
|
|---|
| 7229 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNamesForVolumeNameW( LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength )
|
|---|
| 7230 | {
|
|---|
| 7231 | static FN_GetVolumePathNamesForVolumeNameW *pfn = 0;
|
|---|
| 7232 | if (!pfn)
|
|---|
| 7233 | kPrf2WrapResolve((void **)&pfn, "GetVolumePathNamesForVolumeNameW", &g_Kernel32);
|
|---|
| 7234 | return pfn( lpszVolumeName, lpszVolumePathNames, cchBufferLength, lpcchReturnLength );
|
|---|
| 7235 | }
|
|---|
| 7236 |
|
|---|
| 7237 | typedef HANDLE WINAPI FN_CreateActCtxA( PCACTCTXA pActCtx );
|
|---|
| 7238 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateActCtxA( PCACTCTXA pActCtx )
|
|---|
| 7239 | {
|
|---|
| 7240 | static FN_CreateActCtxA *pfn = 0;
|
|---|
| 7241 | if (!pfn)
|
|---|
| 7242 | kPrf2WrapResolve((void **)&pfn, "CreateActCtxA", &g_Kernel32);
|
|---|
| 7243 | return pfn( pActCtx );
|
|---|
| 7244 | }
|
|---|
| 7245 |
|
|---|
| 7246 | typedef HANDLE WINAPI FN_CreateActCtxW( PCACTCTXW pActCtx );
|
|---|
| 7247 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateActCtxW( PCACTCTXW pActCtx )
|
|---|
| 7248 | {
|
|---|
| 7249 | static FN_CreateActCtxW *pfn = 0;
|
|---|
| 7250 | if (!pfn)
|
|---|
| 7251 | kPrf2WrapResolve((void **)&pfn, "CreateActCtxW", &g_Kernel32);
|
|---|
| 7252 | return pfn( pActCtx );
|
|---|
| 7253 | }
|
|---|
| 7254 |
|
|---|
| 7255 | typedef VOID WINAPI FN_AddRefActCtx( HANDLE hActCtx );
|
|---|
| 7256 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_AddRefActCtx( HANDLE hActCtx )
|
|---|
| 7257 | {
|
|---|
| 7258 | static FN_AddRefActCtx *pfn = 0;
|
|---|
| 7259 | if (!pfn)
|
|---|
| 7260 | kPrf2WrapResolve((void **)&pfn, "AddRefActCtx", &g_Kernel32);
|
|---|
| 7261 | pfn( hActCtx );
|
|---|
| 7262 | }
|
|---|
| 7263 |
|
|---|
| 7264 | typedef VOID WINAPI FN_ReleaseActCtx( HANDLE hActCtx );
|
|---|
| 7265 | __declspec(dllexport) VOID WINAPI kPrf2Wrap_ReleaseActCtx( HANDLE hActCtx )
|
|---|
| 7266 | {
|
|---|
| 7267 | static FN_ReleaseActCtx *pfn = 0;
|
|---|
| 7268 | if (!pfn)
|
|---|
| 7269 | kPrf2WrapResolve((void **)&pfn, "ReleaseActCtx", &g_Kernel32);
|
|---|
| 7270 | pfn( hActCtx );
|
|---|
| 7271 | }
|
|---|
| 7272 |
|
|---|
| 7273 | typedef BOOL WINAPI FN_ZombifyActCtx( HANDLE hActCtx );
|
|---|
| 7274 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ZombifyActCtx( HANDLE hActCtx )
|
|---|
| 7275 | {
|
|---|
| 7276 | static FN_ZombifyActCtx *pfn = 0;
|
|---|
| 7277 | if (!pfn)
|
|---|
| 7278 | kPrf2WrapResolve((void **)&pfn, "ZombifyActCtx", &g_Kernel32);
|
|---|
| 7279 | return pfn( hActCtx );
|
|---|
| 7280 | }
|
|---|
| 7281 |
|
|---|
| 7282 | typedef BOOL WINAPI FN_ActivateActCtx( HANDLE hActCtx, ULONG_PTR * lpCookie );
|
|---|
| 7283 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ActivateActCtx( HANDLE hActCtx, ULONG_PTR * lpCookie )
|
|---|
| 7284 | {
|
|---|
| 7285 | static FN_ActivateActCtx *pfn = 0;
|
|---|
| 7286 | if (!pfn)
|
|---|
| 7287 | kPrf2WrapResolve((void **)&pfn, "ActivateActCtx", &g_Kernel32);
|
|---|
| 7288 | return pfn( hActCtx, lpCookie );
|
|---|
| 7289 | }
|
|---|
| 7290 |
|
|---|
| 7291 | typedef BOOL WINAPI FN_DeactivateActCtx( DWORD dwFlags, ULONG_PTR ulCookie );
|
|---|
| 7292 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeactivateActCtx( DWORD dwFlags, ULONG_PTR ulCookie )
|
|---|
| 7293 | {
|
|---|
| 7294 | static FN_DeactivateActCtx *pfn = 0;
|
|---|
| 7295 | if (!pfn)
|
|---|
| 7296 | kPrf2WrapResolve((void **)&pfn, "DeactivateActCtx", &g_Kernel32);
|
|---|
| 7297 | return pfn( dwFlags, ulCookie );
|
|---|
| 7298 | }
|
|---|
| 7299 |
|
|---|
| 7300 | typedef BOOL WINAPI FN_GetCurrentActCtx( HANDLE * lphActCtx );
|
|---|
| 7301 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentActCtx( HANDLE * lphActCtx )
|
|---|
| 7302 | {
|
|---|
| 7303 | static FN_GetCurrentActCtx *pfn = 0;
|
|---|
| 7304 | if (!pfn)
|
|---|
| 7305 | kPrf2WrapResolve((void **)&pfn, "GetCurrentActCtx", &g_Kernel32);
|
|---|
| 7306 | return pfn( lphActCtx );
|
|---|
| 7307 | }
|
|---|
| 7308 |
|
|---|
| 7309 | typedef BOOL WINAPI FN_FindActCtxSectionStringA( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
|
|---|
| 7310 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionStringA( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
|
|---|
| 7311 | {
|
|---|
| 7312 | static FN_FindActCtxSectionStringA *pfn = 0;
|
|---|
| 7313 | if (!pfn)
|
|---|
| 7314 | kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionStringA", &g_Kernel32);
|
|---|
| 7315 | return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpStringToFind, ReturnedData );
|
|---|
| 7316 | }
|
|---|
| 7317 |
|
|---|
| 7318 | typedef BOOL WINAPI FN_FindActCtxSectionStringW( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCWSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
|
|---|
| 7319 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionStringW( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCWSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
|
|---|
| 7320 | {
|
|---|
| 7321 | static FN_FindActCtxSectionStringW *pfn = 0;
|
|---|
| 7322 | if (!pfn)
|
|---|
| 7323 | kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionStringW", &g_Kernel32);
|
|---|
| 7324 | return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpStringToFind, ReturnedData );
|
|---|
| 7325 | }
|
|---|
| 7326 |
|
|---|
| 7327 | typedef BOOL WINAPI FN_FindActCtxSectionGuid( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, const GUID * lpGuidToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
|
|---|
| 7328 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionGuid( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, const GUID * lpGuidToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
|
|---|
| 7329 | {
|
|---|
| 7330 | static FN_FindActCtxSectionGuid *pfn = 0;
|
|---|
| 7331 | if (!pfn)
|
|---|
| 7332 | kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionGuid", &g_Kernel32);
|
|---|
| 7333 | return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpGuidToFind, ReturnedData );
|
|---|
| 7334 | }
|
|---|
| 7335 |
|
|---|
| 7336 | typedef BOOL WINAPI FN_QueryActCtxW( DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T * pcbWrittenOrRequired );
|
|---|
| 7337 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryActCtxW( DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T * pcbWrittenOrRequired )
|
|---|
| 7338 | {
|
|---|
| 7339 | static FN_QueryActCtxW *pfn = 0;
|
|---|
| 7340 | if (!pfn)
|
|---|
| 7341 | kPrf2WrapResolve((void **)&pfn, "QueryActCtxW", &g_Kernel32);
|
|---|
| 7342 | return pfn( dwFlags, hActCtx, pvSubInstance, ulInfoClass, pvBuffer, cbBuffer, pcbWrittenOrRequired );
|
|---|
| 7343 | }
|
|---|
| 7344 |
|
|---|
| 7345 | typedef BOOL WINAPI FN_ProcessIdToSessionId( DWORD dwProcessId, DWORD * pSessionId );
|
|---|
| 7346 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ProcessIdToSessionId( DWORD dwProcessId, DWORD * pSessionId )
|
|---|
| 7347 | {
|
|---|
| 7348 | static FN_ProcessIdToSessionId *pfn = 0;
|
|---|
| 7349 | if (!pfn)
|
|---|
| 7350 | kPrf2WrapResolve((void **)&pfn, "ProcessIdToSessionId", &g_Kernel32);
|
|---|
| 7351 | return pfn( dwProcessId, pSessionId );
|
|---|
| 7352 | }
|
|---|
| 7353 |
|
|---|
| 7354 | typedef DWORD WINAPI FN_WTSGetActiveConsoleSessionId( );
|
|---|
| 7355 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WTSGetActiveConsoleSessionId( )
|
|---|
| 7356 | {
|
|---|
| 7357 | static FN_WTSGetActiveConsoleSessionId *pfn = 0;
|
|---|
| 7358 | if (!pfn)
|
|---|
| 7359 | kPrf2WrapResolve((void **)&pfn, "WTSGetActiveConsoleSessionId", &g_Kernel32);
|
|---|
| 7360 | return pfn( );
|
|---|
| 7361 | }
|
|---|
| 7362 |
|
|---|
| 7363 | typedef BOOL WINAPI FN_IsWow64Process( HANDLE hProcess, PBOOL Wow64Process );
|
|---|
| 7364 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsWow64Process( HANDLE hProcess, PBOOL Wow64Process )
|
|---|
| 7365 | {
|
|---|
| 7366 | static FN_IsWow64Process *pfn = 0;
|
|---|
| 7367 | if (!pfn)
|
|---|
| 7368 | kPrf2WrapResolve((void **)&pfn, "IsWow64Process", &g_Kernel32);
|
|---|
| 7369 | return pfn( hProcess, Wow64Process );
|
|---|
| 7370 | }
|
|---|
| 7371 |
|
|---|
| 7372 | typedef BOOL WINAPI FN_GetLogicalProcessorInformation( PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength );
|
|---|
| 7373 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetLogicalProcessorInformation( PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength )
|
|---|
| 7374 | {
|
|---|
| 7375 | static FN_GetLogicalProcessorInformation *pfn = 0;
|
|---|
| 7376 | if (!pfn)
|
|---|
| 7377 | kPrf2WrapResolve((void **)&pfn, "GetLogicalProcessorInformation", &g_Kernel32);
|
|---|
| 7378 | return pfn( Buffer, ReturnedLength );
|
|---|
| 7379 | }
|
|---|
| 7380 |
|
|---|
| 7381 | typedef BOOL WINAPI FN_GetNumaHighestNodeNumber( PULONG HighestNodeNumber );
|
|---|
| 7382 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaHighestNodeNumber( PULONG HighestNodeNumber )
|
|---|
| 7383 | {
|
|---|
| 7384 | static FN_GetNumaHighestNodeNumber *pfn = 0;
|
|---|
| 7385 | if (!pfn)
|
|---|
| 7386 | kPrf2WrapResolve((void **)&pfn, "GetNumaHighestNodeNumber", &g_Kernel32);
|
|---|
| 7387 | return pfn( HighestNodeNumber );
|
|---|
| 7388 | }
|
|---|
| 7389 |
|
|---|
| 7390 | typedef BOOL WINAPI FN_GetNumaProcessorNode( UCHAR Processor, PUCHAR NodeNumber );
|
|---|
| 7391 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaProcessorNode( UCHAR Processor, PUCHAR NodeNumber )
|
|---|
| 7392 | {
|
|---|
| 7393 | static FN_GetNumaProcessorNode *pfn = 0;
|
|---|
| 7394 | if (!pfn)
|
|---|
| 7395 | kPrf2WrapResolve((void **)&pfn, "GetNumaProcessorNode", &g_Kernel32);
|
|---|
| 7396 | return pfn( Processor, NodeNumber );
|
|---|
| 7397 | }
|
|---|
| 7398 |
|
|---|
| 7399 | typedef BOOL WINAPI FN_GetNumaNodeProcessorMask( UCHAR Node, PULONGLONG ProcessorMask );
|
|---|
| 7400 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaNodeProcessorMask( UCHAR Node, PULONGLONG ProcessorMask )
|
|---|
| 7401 | {
|
|---|
| 7402 | static FN_GetNumaNodeProcessorMask *pfn = 0;
|
|---|
| 7403 | if (!pfn)
|
|---|
| 7404 | kPrf2WrapResolve((void **)&pfn, "GetNumaNodeProcessorMask", &g_Kernel32);
|
|---|
| 7405 | return pfn( Node, ProcessorMask );
|
|---|
| 7406 | }
|
|---|
| 7407 |
|
|---|
| 7408 | typedef BOOL WINAPI FN_GetNumaAvailableMemoryNode( UCHAR Node, PULONGLONG AvailableBytes );
|
|---|
| 7409 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaAvailableMemoryNode( UCHAR Node, PULONGLONG AvailableBytes )
|
|---|
| 7410 | {
|
|---|
| 7411 | static FN_GetNumaAvailableMemoryNode *pfn = 0;
|
|---|
| 7412 | if (!pfn)
|
|---|
| 7413 | kPrf2WrapResolve((void **)&pfn, "GetNumaAvailableMemoryNode", &g_Kernel32);
|
|---|
| 7414 | return pfn( Node, AvailableBytes );
|
|---|
| 7415 | }
|
|---|
| 7416 |
|
|---|
| 7417 | typedef BOOL WINAPI FN_PeekConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
|
|---|
| 7418 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
|
|---|
| 7419 | {
|
|---|
| 7420 | static FN_PeekConsoleInputA *pfn = 0;
|
|---|
| 7421 | if (!pfn)
|
|---|
| 7422 | kPrf2WrapResolve((void **)&pfn, "PeekConsoleInputA", &g_Kernel32);
|
|---|
| 7423 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
|
|---|
| 7424 | }
|
|---|
| 7425 |
|
|---|
| 7426 | typedef BOOL WINAPI FN_PeekConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
|
|---|
| 7427 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
|
|---|
| 7428 | {
|
|---|
| 7429 | static FN_PeekConsoleInputW *pfn = 0;
|
|---|
| 7430 | if (!pfn)
|
|---|
| 7431 | kPrf2WrapResolve((void **)&pfn, "PeekConsoleInputW", &g_Kernel32);
|
|---|
| 7432 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
|
|---|
| 7433 | }
|
|---|
| 7434 |
|
|---|
| 7435 | typedef BOOL WINAPI FN_ReadConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
|
|---|
| 7436 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
|
|---|
| 7437 | {
|
|---|
| 7438 | static FN_ReadConsoleInputA *pfn = 0;
|
|---|
| 7439 | if (!pfn)
|
|---|
| 7440 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleInputA", &g_Kernel32);
|
|---|
| 7441 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
|
|---|
| 7442 | }
|
|---|
| 7443 |
|
|---|
| 7444 | typedef BOOL WINAPI FN_ReadConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
|
|---|
| 7445 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
|
|---|
| 7446 | {
|
|---|
| 7447 | static FN_ReadConsoleInputW *pfn = 0;
|
|---|
| 7448 | if (!pfn)
|
|---|
| 7449 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleInputW", &g_Kernel32);
|
|---|
| 7450 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
|
|---|
| 7451 | }
|
|---|
| 7452 |
|
|---|
| 7453 | typedef BOOL WINAPI FN_WriteConsoleInputA( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten );
|
|---|
| 7454 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleInputA( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten )
|
|---|
| 7455 | {
|
|---|
| 7456 | static FN_WriteConsoleInputA *pfn = 0;
|
|---|
| 7457 | if (!pfn)
|
|---|
| 7458 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleInputA", &g_Kernel32);
|
|---|
| 7459 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten );
|
|---|
| 7460 | }
|
|---|
| 7461 |
|
|---|
| 7462 | typedef BOOL WINAPI FN_WriteConsoleInputW( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten );
|
|---|
| 7463 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleInputW( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten )
|
|---|
| 7464 | {
|
|---|
| 7465 | static FN_WriteConsoleInputW *pfn = 0;
|
|---|
| 7466 | if (!pfn)
|
|---|
| 7467 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleInputW", &g_Kernel32);
|
|---|
| 7468 | return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten );
|
|---|
| 7469 | }
|
|---|
| 7470 |
|
|---|
| 7471 | typedef BOOL WINAPI FN_ReadConsoleOutputA( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion );
|
|---|
| 7472 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputA( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion )
|
|---|
| 7473 | {
|
|---|
| 7474 | static FN_ReadConsoleOutputA *pfn = 0;
|
|---|
| 7475 | if (!pfn)
|
|---|
| 7476 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputA", &g_Kernel32);
|
|---|
| 7477 | return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion );
|
|---|
| 7478 | }
|
|---|
| 7479 |
|
|---|
| 7480 | typedef BOOL WINAPI FN_ReadConsoleOutputW( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion );
|
|---|
| 7481 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputW( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion )
|
|---|
| 7482 | {
|
|---|
| 7483 | static FN_ReadConsoleOutputW *pfn = 0;
|
|---|
| 7484 | if (!pfn)
|
|---|
| 7485 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputW", &g_Kernel32);
|
|---|
| 7486 | return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion );
|
|---|
| 7487 | }
|
|---|
| 7488 |
|
|---|
| 7489 | typedef BOOL WINAPI FN_WriteConsoleOutputA( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion );
|
|---|
| 7490 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputA( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion )
|
|---|
| 7491 | {
|
|---|
| 7492 | static FN_WriteConsoleOutputA *pfn = 0;
|
|---|
| 7493 | if (!pfn)
|
|---|
| 7494 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputA", &g_Kernel32);
|
|---|
| 7495 | return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion );
|
|---|
| 7496 | }
|
|---|
| 7497 |
|
|---|
| 7498 | typedef BOOL WINAPI FN_WriteConsoleOutputW( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion );
|
|---|
| 7499 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputW( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion )
|
|---|
| 7500 | {
|
|---|
| 7501 | static FN_WriteConsoleOutputW *pfn = 0;
|
|---|
| 7502 | if (!pfn)
|
|---|
| 7503 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputW", &g_Kernel32);
|
|---|
| 7504 | return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion );
|
|---|
| 7505 | }
|
|---|
| 7506 |
|
|---|
| 7507 | typedef BOOL WINAPI FN_ReadConsoleOutputCharacterA( IN HANDLE hConsoleOutput, OUT LPSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead );
|
|---|
| 7508 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputCharacterA( IN HANDLE hConsoleOutput, OUT LPSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead )
|
|---|
| 7509 | {
|
|---|
| 7510 | static FN_ReadConsoleOutputCharacterA *pfn = 0;
|
|---|
| 7511 | if (!pfn)
|
|---|
| 7512 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputCharacterA", &g_Kernel32);
|
|---|
| 7513 | return pfn( hConsoleOutput, lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead );
|
|---|
| 7514 | }
|
|---|
| 7515 |
|
|---|
| 7516 | typedef BOOL WINAPI FN_ReadConsoleOutputCharacterW( IN HANDLE hConsoleOutput, OUT LPWSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead );
|
|---|
| 7517 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputCharacterW( IN HANDLE hConsoleOutput, OUT LPWSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead )
|
|---|
| 7518 | {
|
|---|
| 7519 | static FN_ReadConsoleOutputCharacterW *pfn = 0;
|
|---|
| 7520 | if (!pfn)
|
|---|
| 7521 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputCharacterW", &g_Kernel32);
|
|---|
| 7522 | return pfn( hConsoleOutput, lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead );
|
|---|
| 7523 | }
|
|---|
| 7524 |
|
|---|
| 7525 | typedef BOOL WINAPI FN_ReadConsoleOutputAttribute( IN HANDLE hConsoleOutput, OUT LPWORD lpAttribute, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfAttrsRead );
|
|---|
| 7526 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputAttribute( IN HANDLE hConsoleOutput, OUT LPWORD lpAttribute, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfAttrsRead )
|
|---|
| 7527 | {
|
|---|
| 7528 | static FN_ReadConsoleOutputAttribute *pfn = 0;
|
|---|
| 7529 | if (!pfn)
|
|---|
| 7530 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputAttribute", &g_Kernel32);
|
|---|
| 7531 | return pfn( hConsoleOutput, lpAttribute, nLength, dwReadCoord, lpNumberOfAttrsRead );
|
|---|
| 7532 | }
|
|---|
| 7533 |
|
|---|
| 7534 | typedef BOOL WINAPI FN_WriteConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN LPCSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
|
|---|
| 7535 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN LPCSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
|
|---|
| 7536 | {
|
|---|
| 7537 | static FN_WriteConsoleOutputCharacterA *pfn = 0;
|
|---|
| 7538 | if (!pfn)
|
|---|
| 7539 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputCharacterA", &g_Kernel32);
|
|---|
| 7540 | return pfn( hConsoleOutput, lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
|
|---|
| 7541 | }
|
|---|
| 7542 |
|
|---|
| 7543 | typedef BOOL WINAPI FN_WriteConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN LPCWSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
|
|---|
| 7544 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN LPCWSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
|
|---|
| 7545 | {
|
|---|
| 7546 | static FN_WriteConsoleOutputCharacterW *pfn = 0;
|
|---|
| 7547 | if (!pfn)
|
|---|
| 7548 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputCharacterW", &g_Kernel32);
|
|---|
| 7549 | return pfn( hConsoleOutput, lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
|
|---|
| 7550 | }
|
|---|
| 7551 |
|
|---|
| 7552 | typedef BOOL WINAPI FN_WriteConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN CONST WORD * lpAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten );
|
|---|
| 7553 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN CONST WORD * lpAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten )
|
|---|
| 7554 | {
|
|---|
| 7555 | static FN_WriteConsoleOutputAttribute *pfn = 0;
|
|---|
| 7556 | if (!pfn)
|
|---|
| 7557 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputAttribute", &g_Kernel32);
|
|---|
| 7558 | return pfn( hConsoleOutput, lpAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten );
|
|---|
| 7559 | }
|
|---|
| 7560 |
|
|---|
| 7561 | typedef BOOL WINAPI FN_FillConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN CHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
|
|---|
| 7562 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN CHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
|
|---|
| 7563 | {
|
|---|
| 7564 | static FN_FillConsoleOutputCharacterA *pfn = 0;
|
|---|
| 7565 | if (!pfn)
|
|---|
| 7566 | kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputCharacterA", &g_Kernel32);
|
|---|
| 7567 | return pfn( hConsoleOutput, cCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
|
|---|
| 7568 | }
|
|---|
| 7569 |
|
|---|
| 7570 | typedef BOOL WINAPI FN_FillConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN WCHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
|
|---|
| 7571 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN WCHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
|
|---|
| 7572 | {
|
|---|
| 7573 | static FN_FillConsoleOutputCharacterW *pfn = 0;
|
|---|
| 7574 | if (!pfn)
|
|---|
| 7575 | kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputCharacterW", &g_Kernel32);
|
|---|
| 7576 | return pfn( hConsoleOutput, cCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
|
|---|
| 7577 | }
|
|---|
| 7578 |
|
|---|
| 7579 | typedef BOOL WINAPI FN_FillConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN WORD wAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten );
|
|---|
| 7580 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN WORD wAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten )
|
|---|
| 7581 | {
|
|---|
| 7582 | static FN_FillConsoleOutputAttribute *pfn = 0;
|
|---|
| 7583 | if (!pfn)
|
|---|
| 7584 | kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputAttribute", &g_Kernel32);
|
|---|
| 7585 | return pfn( hConsoleOutput, wAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten );
|
|---|
| 7586 | }
|
|---|
| 7587 |
|
|---|
| 7588 | typedef BOOL WINAPI FN_GetConsoleMode( IN HANDLE hConsoleHandle, OUT LPDWORD lpMode );
|
|---|
| 7589 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleMode( IN HANDLE hConsoleHandle, OUT LPDWORD lpMode )
|
|---|
| 7590 | {
|
|---|
| 7591 | static FN_GetConsoleMode *pfn = 0;
|
|---|
| 7592 | if (!pfn)
|
|---|
| 7593 | kPrf2WrapResolve((void **)&pfn, "GetConsoleMode", &g_Kernel32);
|
|---|
| 7594 | return pfn( hConsoleHandle, lpMode );
|
|---|
| 7595 | }
|
|---|
| 7596 |
|
|---|
| 7597 | typedef BOOL WINAPI FN_GetNumberOfConsoleInputEvents( IN HANDLE hConsoleInput, OUT LPDWORD lpNumberOfEvents );
|
|---|
| 7598 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfConsoleInputEvents( IN HANDLE hConsoleInput, OUT LPDWORD lpNumberOfEvents )
|
|---|
| 7599 | {
|
|---|
| 7600 | static FN_GetNumberOfConsoleInputEvents *pfn = 0;
|
|---|
| 7601 | if (!pfn)
|
|---|
| 7602 | kPrf2WrapResolve((void **)&pfn, "GetNumberOfConsoleInputEvents", &g_Kernel32);
|
|---|
| 7603 | return pfn( hConsoleInput, lpNumberOfEvents );
|
|---|
| 7604 | }
|
|---|
| 7605 |
|
|---|
| 7606 | typedef BOOL WINAPI FN_GetConsoleScreenBufferInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo );
|
|---|
| 7607 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleScreenBufferInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo )
|
|---|
| 7608 | {
|
|---|
| 7609 | static FN_GetConsoleScreenBufferInfo *pfn = 0;
|
|---|
| 7610 | if (!pfn)
|
|---|
| 7611 | kPrf2WrapResolve((void **)&pfn, "GetConsoleScreenBufferInfo", &g_Kernel32);
|
|---|
| 7612 | return pfn( hConsoleOutput, lpConsoleScreenBufferInfo );
|
|---|
| 7613 | }
|
|---|
| 7614 |
|
|---|
| 7615 | typedef COORD WINAPI FN_GetLargestConsoleWindowSize( IN HANDLE hConsoleOutput );
|
|---|
| 7616 | __declspec(dllexport) COORD WINAPI kPrf2Wrap_GetLargestConsoleWindowSize( IN HANDLE hConsoleOutput )
|
|---|
| 7617 | {
|
|---|
| 7618 | static FN_GetLargestConsoleWindowSize *pfn = 0;
|
|---|
| 7619 | if (!pfn)
|
|---|
| 7620 | kPrf2WrapResolve((void **)&pfn, "GetLargestConsoleWindowSize", &g_Kernel32);
|
|---|
| 7621 | return pfn( hConsoleOutput );
|
|---|
| 7622 | }
|
|---|
| 7623 |
|
|---|
| 7624 | typedef BOOL WINAPI FN_GetConsoleCursorInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_CURSOR_INFO lpConsoleCursorInfo );
|
|---|
| 7625 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleCursorInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_CURSOR_INFO lpConsoleCursorInfo )
|
|---|
| 7626 | {
|
|---|
| 7627 | static FN_GetConsoleCursorInfo *pfn = 0;
|
|---|
| 7628 | if (!pfn)
|
|---|
| 7629 | kPrf2WrapResolve((void **)&pfn, "GetConsoleCursorInfo", &g_Kernel32);
|
|---|
| 7630 | return pfn( hConsoleOutput, lpConsoleCursorInfo );
|
|---|
| 7631 | }
|
|---|
| 7632 |
|
|---|
| 7633 | typedef BOOL WINAPI FN_GetCurrentConsoleFont( IN HANDLE hConsoleOutput, IN BOOL bMaximumWindow, OUT PCONSOLE_FONT_INFO lpConsoleCurrentFont );
|
|---|
| 7634 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentConsoleFont( IN HANDLE hConsoleOutput, IN BOOL bMaximumWindow, OUT PCONSOLE_FONT_INFO lpConsoleCurrentFont )
|
|---|
| 7635 | {
|
|---|
| 7636 | static FN_GetCurrentConsoleFont *pfn = 0;
|
|---|
| 7637 | if (!pfn)
|
|---|
| 7638 | kPrf2WrapResolve((void **)&pfn, "GetCurrentConsoleFont", &g_Kernel32);
|
|---|
| 7639 | return pfn( hConsoleOutput, bMaximumWindow, lpConsoleCurrentFont );
|
|---|
| 7640 | }
|
|---|
| 7641 |
|
|---|
| 7642 | typedef COORD WINAPI FN_GetConsoleFontSize( IN HANDLE hConsoleOutput, IN DWORD nFont );
|
|---|
| 7643 | __declspec(dllexport) COORD WINAPI kPrf2Wrap_GetConsoleFontSize( IN HANDLE hConsoleOutput, IN DWORD nFont )
|
|---|
| 7644 | {
|
|---|
| 7645 | static FN_GetConsoleFontSize *pfn = 0;
|
|---|
| 7646 | if (!pfn)
|
|---|
| 7647 | kPrf2WrapResolve((void **)&pfn, "GetConsoleFontSize", &g_Kernel32);
|
|---|
| 7648 | return pfn( hConsoleOutput, nFont );
|
|---|
| 7649 | }
|
|---|
| 7650 |
|
|---|
| 7651 | typedef BOOL WINAPI FN_GetConsoleSelectionInfo( OUT PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo );
|
|---|
| 7652 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleSelectionInfo( OUT PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo )
|
|---|
| 7653 | {
|
|---|
| 7654 | static FN_GetConsoleSelectionInfo *pfn = 0;
|
|---|
| 7655 | if (!pfn)
|
|---|
| 7656 | kPrf2WrapResolve((void **)&pfn, "GetConsoleSelectionInfo", &g_Kernel32);
|
|---|
| 7657 | return pfn( lpConsoleSelectionInfo );
|
|---|
| 7658 | }
|
|---|
| 7659 |
|
|---|
| 7660 | typedef BOOL WINAPI FN_GetNumberOfConsoleMouseButtons( OUT LPDWORD lpNumberOfMouseButtons );
|
|---|
| 7661 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfConsoleMouseButtons( OUT LPDWORD lpNumberOfMouseButtons )
|
|---|
| 7662 | {
|
|---|
| 7663 | static FN_GetNumberOfConsoleMouseButtons *pfn = 0;
|
|---|
| 7664 | if (!pfn)
|
|---|
| 7665 | kPrf2WrapResolve((void **)&pfn, "GetNumberOfConsoleMouseButtons", &g_Kernel32);
|
|---|
| 7666 | return pfn( lpNumberOfMouseButtons );
|
|---|
| 7667 | }
|
|---|
| 7668 |
|
|---|
| 7669 | typedef BOOL WINAPI FN_SetConsoleMode( IN HANDLE hConsoleHandle, IN DWORD dwMode );
|
|---|
| 7670 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleMode( IN HANDLE hConsoleHandle, IN DWORD dwMode )
|
|---|
| 7671 | {
|
|---|
| 7672 | static FN_SetConsoleMode *pfn = 0;
|
|---|
| 7673 | if (!pfn)
|
|---|
| 7674 | kPrf2WrapResolve((void **)&pfn, "SetConsoleMode", &g_Kernel32);
|
|---|
| 7675 | return pfn( hConsoleHandle, dwMode );
|
|---|
| 7676 | }
|
|---|
| 7677 |
|
|---|
| 7678 | typedef BOOL WINAPI FN_SetConsoleActiveScreenBuffer( IN HANDLE hConsoleOutput );
|
|---|
| 7679 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleActiveScreenBuffer( IN HANDLE hConsoleOutput )
|
|---|
| 7680 | {
|
|---|
| 7681 | static FN_SetConsoleActiveScreenBuffer *pfn = 0;
|
|---|
| 7682 | if (!pfn)
|
|---|
| 7683 | kPrf2WrapResolve((void **)&pfn, "SetConsoleActiveScreenBuffer", &g_Kernel32);
|
|---|
| 7684 | return pfn( hConsoleOutput );
|
|---|
| 7685 | }
|
|---|
| 7686 |
|
|---|
| 7687 | typedef BOOL WINAPI FN_FlushConsoleInputBuffer( IN HANDLE hConsoleInput );
|
|---|
| 7688 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushConsoleInputBuffer( IN HANDLE hConsoleInput )
|
|---|
| 7689 | {
|
|---|
| 7690 | static FN_FlushConsoleInputBuffer *pfn = 0;
|
|---|
| 7691 | if (!pfn)
|
|---|
| 7692 | kPrf2WrapResolve((void **)&pfn, "FlushConsoleInputBuffer", &g_Kernel32);
|
|---|
| 7693 | return pfn( hConsoleInput );
|
|---|
| 7694 | }
|
|---|
| 7695 |
|
|---|
| 7696 | typedef BOOL WINAPI FN_SetConsoleScreenBufferSize( IN HANDLE hConsoleOutput, IN COORD dwSize );
|
|---|
| 7697 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleScreenBufferSize( IN HANDLE hConsoleOutput, IN COORD dwSize )
|
|---|
| 7698 | {
|
|---|
| 7699 | static FN_SetConsoleScreenBufferSize *pfn = 0;
|
|---|
| 7700 | if (!pfn)
|
|---|
| 7701 | kPrf2WrapResolve((void **)&pfn, "SetConsoleScreenBufferSize", &g_Kernel32);
|
|---|
| 7702 | return pfn( hConsoleOutput, dwSize );
|
|---|
| 7703 | }
|
|---|
| 7704 |
|
|---|
| 7705 | typedef BOOL WINAPI FN_SetConsoleCursorPosition( IN HANDLE hConsoleOutput, IN COORD dwCursorPosition );
|
|---|
| 7706 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursorPosition( IN HANDLE hConsoleOutput, IN COORD dwCursorPosition )
|
|---|
| 7707 | {
|
|---|
| 7708 | static FN_SetConsoleCursorPosition *pfn = 0;
|
|---|
| 7709 | if (!pfn)
|
|---|
| 7710 | kPrf2WrapResolve((void **)&pfn, "SetConsoleCursorPosition", &g_Kernel32);
|
|---|
| 7711 | return pfn( hConsoleOutput, dwCursorPosition );
|
|---|
| 7712 | }
|
|---|
| 7713 |
|
|---|
| 7714 | typedef BOOL WINAPI FN_SetConsoleCursorInfo( IN HANDLE hConsoleOutput, IN CONST CONSOLE_CURSOR_INFO * lpConsoleCursorInfo );
|
|---|
| 7715 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursorInfo( IN HANDLE hConsoleOutput, IN CONST CONSOLE_CURSOR_INFO * lpConsoleCursorInfo )
|
|---|
| 7716 | {
|
|---|
| 7717 | static FN_SetConsoleCursorInfo *pfn = 0;
|
|---|
| 7718 | if (!pfn)
|
|---|
| 7719 | kPrf2WrapResolve((void **)&pfn, "SetConsoleCursorInfo", &g_Kernel32);
|
|---|
| 7720 | return pfn( hConsoleOutput, lpConsoleCursorInfo );
|
|---|
| 7721 | }
|
|---|
| 7722 |
|
|---|
| 7723 | typedef BOOL WINAPI FN_ScrollConsoleScreenBufferA( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill );
|
|---|
| 7724 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ScrollConsoleScreenBufferA( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill )
|
|---|
| 7725 | {
|
|---|
| 7726 | static FN_ScrollConsoleScreenBufferA *pfn = 0;
|
|---|
| 7727 | if (!pfn)
|
|---|
| 7728 | kPrf2WrapResolve((void **)&pfn, "ScrollConsoleScreenBufferA", &g_Kernel32);
|
|---|
| 7729 | return pfn( hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill );
|
|---|
| 7730 | }
|
|---|
| 7731 |
|
|---|
| 7732 | typedef BOOL WINAPI FN_ScrollConsoleScreenBufferW( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill );
|
|---|
| 7733 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ScrollConsoleScreenBufferW( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill )
|
|---|
| 7734 | {
|
|---|
| 7735 | static FN_ScrollConsoleScreenBufferW *pfn = 0;
|
|---|
| 7736 | if (!pfn)
|
|---|
| 7737 | kPrf2WrapResolve((void **)&pfn, "ScrollConsoleScreenBufferW", &g_Kernel32);
|
|---|
| 7738 | return pfn( hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill );
|
|---|
| 7739 | }
|
|---|
| 7740 |
|
|---|
| 7741 | typedef BOOL WINAPI FN_SetConsoleWindowInfo( IN HANDLE hConsoleOutput, IN BOOL bAbsolute, IN CONST SMALL_RECT * lpConsoleWindow );
|
|---|
| 7742 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleWindowInfo( IN HANDLE hConsoleOutput, IN BOOL bAbsolute, IN CONST SMALL_RECT * lpConsoleWindow )
|
|---|
| 7743 | {
|
|---|
| 7744 | static FN_SetConsoleWindowInfo *pfn = 0;
|
|---|
| 7745 | if (!pfn)
|
|---|
| 7746 | kPrf2WrapResolve((void **)&pfn, "SetConsoleWindowInfo", &g_Kernel32);
|
|---|
| 7747 | return pfn( hConsoleOutput, bAbsolute, lpConsoleWindow );
|
|---|
| 7748 | }
|
|---|
| 7749 |
|
|---|
| 7750 | typedef BOOL WINAPI FN_SetConsoleTextAttribute( IN HANDLE hConsoleOutput, IN WORD wAttributes );
|
|---|
| 7751 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTextAttribute( IN HANDLE hConsoleOutput, IN WORD wAttributes )
|
|---|
| 7752 | {
|
|---|
| 7753 | static FN_SetConsoleTextAttribute *pfn = 0;
|
|---|
| 7754 | if (!pfn)
|
|---|
| 7755 | kPrf2WrapResolve((void **)&pfn, "SetConsoleTextAttribute", &g_Kernel32);
|
|---|
| 7756 | return pfn( hConsoleOutput, wAttributes );
|
|---|
| 7757 | }
|
|---|
| 7758 |
|
|---|
| 7759 | typedef BOOL WINAPI FN_SetConsoleCtrlHandler( IN PHANDLER_ROUTINE HandlerRoutine, IN BOOL Add );
|
|---|
| 7760 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCtrlHandler( IN PHANDLER_ROUTINE HandlerRoutine, IN BOOL Add )
|
|---|
| 7761 | {
|
|---|
| 7762 | static FN_SetConsoleCtrlHandler *pfn = 0;
|
|---|
| 7763 | if (!pfn)
|
|---|
| 7764 | kPrf2WrapResolve((void **)&pfn, "SetConsoleCtrlHandler", &g_Kernel32);
|
|---|
| 7765 | return pfn( HandlerRoutine, Add );
|
|---|
| 7766 | }
|
|---|
| 7767 |
|
|---|
| 7768 | typedef BOOL WINAPI FN_GenerateConsoleCtrlEvent( IN DWORD dwCtrlEvent, IN DWORD dwProcessGroupId );
|
|---|
| 7769 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GenerateConsoleCtrlEvent( IN DWORD dwCtrlEvent, IN DWORD dwProcessGroupId )
|
|---|
| 7770 | {
|
|---|
| 7771 | static FN_GenerateConsoleCtrlEvent *pfn = 0;
|
|---|
| 7772 | if (!pfn)
|
|---|
| 7773 | kPrf2WrapResolve((void **)&pfn, "GenerateConsoleCtrlEvent", &g_Kernel32);
|
|---|
| 7774 | return pfn( dwCtrlEvent, dwProcessGroupId );
|
|---|
| 7775 | }
|
|---|
| 7776 |
|
|---|
| 7777 | typedef BOOL WINAPI FN_AllocConsole( VOID );
|
|---|
| 7778 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocConsole( VOID )
|
|---|
| 7779 | {
|
|---|
| 7780 | static FN_AllocConsole *pfn = 0;
|
|---|
| 7781 | if (!pfn)
|
|---|
| 7782 | kPrf2WrapResolve((void **)&pfn, "AllocConsole", &g_Kernel32);
|
|---|
| 7783 | return pfn ();
|
|---|
| 7784 | }
|
|---|
| 7785 |
|
|---|
| 7786 | typedef BOOL WINAPI FN_FreeConsole( VOID );
|
|---|
| 7787 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeConsole( VOID )
|
|---|
| 7788 | {
|
|---|
| 7789 | static FN_FreeConsole *pfn = 0;
|
|---|
| 7790 | if (!pfn)
|
|---|
| 7791 | kPrf2WrapResolve((void **)&pfn, "FreeConsole", &g_Kernel32);
|
|---|
| 7792 | return pfn ();
|
|---|
| 7793 | }
|
|---|
| 7794 |
|
|---|
| 7795 | typedef BOOL WINAPI FN_AttachConsole( IN DWORD dwProcessId );
|
|---|
| 7796 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AttachConsole( IN DWORD dwProcessId )
|
|---|
| 7797 | {
|
|---|
| 7798 | static FN_AttachConsole *pfn = 0;
|
|---|
| 7799 | if (!pfn)
|
|---|
| 7800 | kPrf2WrapResolve((void **)&pfn, "AttachConsole", &g_Kernel32);
|
|---|
| 7801 | return pfn( dwProcessId );
|
|---|
| 7802 | }
|
|---|
| 7803 |
|
|---|
| 7804 | typedef DWORD WINAPI FN_GetConsoleTitleA( OUT LPSTR lpConsoleTitle, IN DWORD nSize );
|
|---|
| 7805 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetConsoleTitleA( OUT LPSTR lpConsoleTitle, IN DWORD nSize )
|
|---|
| 7806 | {
|
|---|
| 7807 | static FN_GetConsoleTitleA *pfn = 0;
|
|---|
| 7808 | if (!pfn)
|
|---|
| 7809 | kPrf2WrapResolve((void **)&pfn, "GetConsoleTitleA", &g_Kernel32);
|
|---|
| 7810 | return pfn( lpConsoleTitle, nSize );
|
|---|
| 7811 | }
|
|---|
| 7812 |
|
|---|
| 7813 | typedef DWORD WINAPI FN_GetConsoleTitleW( OUT LPWSTR lpConsoleTitle, IN DWORD nSize );
|
|---|
| 7814 | __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetConsoleTitleW( OUT LPWSTR lpConsoleTitle, IN DWORD nSize )
|
|---|
| 7815 | {
|
|---|
| 7816 | static FN_GetConsoleTitleW *pfn = 0;
|
|---|
| 7817 | if (!pfn)
|
|---|
| 7818 | kPrf2WrapResolve((void **)&pfn, "GetConsoleTitleW", &g_Kernel32);
|
|---|
| 7819 | return pfn( lpConsoleTitle, nSize );
|
|---|
| 7820 | }
|
|---|
| 7821 |
|
|---|
| 7822 | typedef BOOL WINAPI FN_SetConsoleTitleA( IN LPCSTR lpConsoleTitle );
|
|---|
| 7823 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTitleA( IN LPCSTR lpConsoleTitle )
|
|---|
| 7824 | {
|
|---|
| 7825 | static FN_SetConsoleTitleA *pfn = 0;
|
|---|
| 7826 | if (!pfn)
|
|---|
| 7827 | kPrf2WrapResolve((void **)&pfn, "SetConsoleTitleA", &g_Kernel32);
|
|---|
| 7828 | return pfn( lpConsoleTitle );
|
|---|
| 7829 | }
|
|---|
| 7830 |
|
|---|
| 7831 | typedef BOOL WINAPI FN_SetConsoleTitleW( IN LPCWSTR lpConsoleTitle );
|
|---|
| 7832 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTitleW( IN LPCWSTR lpConsoleTitle )
|
|---|
| 7833 | {
|
|---|
| 7834 | static FN_SetConsoleTitleW *pfn = 0;
|
|---|
| 7835 | if (!pfn)
|
|---|
| 7836 | kPrf2WrapResolve((void **)&pfn, "SetConsoleTitleW", &g_Kernel32);
|
|---|
| 7837 | return pfn( lpConsoleTitle );
|
|---|
| 7838 | }
|
|---|
| 7839 |
|
|---|
| 7840 | typedef BOOL WINAPI FN_ReadConsoleA( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved );
|
|---|
| 7841 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleA( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved )
|
|---|
| 7842 | {
|
|---|
| 7843 | static FN_ReadConsoleA *pfn = 0;
|
|---|
| 7844 | if (!pfn)
|
|---|
| 7845 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleA", &g_Kernel32);
|
|---|
| 7846 | return pfn( hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved );
|
|---|
| 7847 | }
|
|---|
| 7848 |
|
|---|
| 7849 | typedef BOOL WINAPI FN_ReadConsoleW( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved );
|
|---|
| 7850 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleW( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved )
|
|---|
| 7851 | {
|
|---|
| 7852 | static FN_ReadConsoleW *pfn = 0;
|
|---|
| 7853 | if (!pfn)
|
|---|
| 7854 | kPrf2WrapResolve((void **)&pfn, "ReadConsoleW", &g_Kernel32);
|
|---|
| 7855 | return pfn( hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved );
|
|---|
| 7856 | }
|
|---|
| 7857 |
|
|---|
| 7858 | typedef BOOL WINAPI FN_WriteConsoleA( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved );
|
|---|
| 7859 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleA( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved )
|
|---|
| 7860 | {
|
|---|
| 7861 | static FN_WriteConsoleA *pfn = 0;
|
|---|
| 7862 | if (!pfn)
|
|---|
| 7863 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleA", &g_Kernel32);
|
|---|
| 7864 | return pfn( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved );
|
|---|
| 7865 | }
|
|---|
| 7866 |
|
|---|
| 7867 | typedef BOOL WINAPI FN_WriteConsoleW( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved );
|
|---|
| 7868 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleW( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved )
|
|---|
| 7869 | {
|
|---|
| 7870 | static FN_WriteConsoleW *pfn = 0;
|
|---|
| 7871 | if (!pfn)
|
|---|
| 7872 | kPrf2WrapResolve((void **)&pfn, "WriteConsoleW", &g_Kernel32);
|
|---|
| 7873 | return pfn( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved );
|
|---|
| 7874 | }
|
|---|
| 7875 |
|
|---|
| 7876 | typedef HANDLE WINAPI FN_CreateConsoleScreenBuffer( IN DWORD dwDesiredAccess, IN DWORD dwShareMode, IN CONST SECURITY_ATTRIBUTES * lpSecurityAttributes, IN DWORD dwFlags, IN LPVOID lpScreenBufferData );
|
|---|
| 7877 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateConsoleScreenBuffer( IN DWORD dwDesiredAccess, IN DWORD dwShareMode, IN CONST SECURITY_ATTRIBUTES * lpSecurityAttributes, IN DWORD dwFlags, IN LPVOID lpScreenBufferData )
|
|---|
| 7878 | {
|
|---|
| 7879 | static FN_CreateConsoleScreenBuffer *pfn = 0;
|
|---|
| 7880 | if (!pfn)
|
|---|
| 7881 | kPrf2WrapResolve((void **)&pfn, "CreateConsoleScreenBuffer", &g_Kernel32);
|
|---|
| 7882 | return pfn( dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwFlags, lpScreenBufferData );
|
|---|
| 7883 | }
|
|---|
| 7884 |
|
|---|
| 7885 | typedef UINT WINAPI FN_GetConsoleCP( VOID );
|
|---|
| 7886 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetConsoleCP( VOID )
|
|---|
| 7887 | {
|
|---|
| 7888 | static FN_GetConsoleCP *pfn = 0;
|
|---|
| 7889 | if (!pfn)
|
|---|
| 7890 | kPrf2WrapResolve((void **)&pfn, "GetConsoleCP", &g_Kernel32);
|
|---|
| 7891 | return pfn ();
|
|---|
| 7892 | }
|
|---|
| 7893 |
|
|---|
| 7894 | typedef BOOL WINAPI FN_SetConsoleCP( IN UINT wCodePageID );
|
|---|
| 7895 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCP( IN UINT wCodePageID )
|
|---|
| 7896 | {
|
|---|
| 7897 | static FN_SetConsoleCP *pfn = 0;
|
|---|
| 7898 | if (!pfn)
|
|---|
| 7899 | kPrf2WrapResolve((void **)&pfn, "SetConsoleCP", &g_Kernel32);
|
|---|
| 7900 | return pfn( wCodePageID );
|
|---|
| 7901 | }
|
|---|
| 7902 |
|
|---|
| 7903 | typedef UINT WINAPI FN_GetConsoleOutputCP( VOID );
|
|---|
| 7904 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetConsoleOutputCP( VOID )
|
|---|
| 7905 | {
|
|---|
| 7906 | static FN_GetConsoleOutputCP *pfn = 0;
|
|---|
| 7907 | if (!pfn)
|
|---|
| 7908 | kPrf2WrapResolve((void **)&pfn, "GetConsoleOutputCP", &g_Kernel32);
|
|---|
| 7909 | return pfn ();
|
|---|
| 7910 | }
|
|---|
| 7911 |
|
|---|
| 7912 | typedef BOOL WINAPI FN_SetConsoleOutputCP( IN UINT wCodePageID );
|
|---|
| 7913 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleOutputCP( IN UINT wCodePageID )
|
|---|
| 7914 | {
|
|---|
| 7915 | static FN_SetConsoleOutputCP *pfn = 0;
|
|---|
| 7916 | if (!pfn)
|
|---|
| 7917 | kPrf2WrapResolve((void **)&pfn, "SetConsoleOutputCP", &g_Kernel32);
|
|---|
| 7918 | return pfn( wCodePageID );
|
|---|
| 7919 | }
|
|---|
| 7920 |
|
|---|
| 7921 | typedef BOOL APIENTRY FN_GetConsoleDisplayMode( OUT LPDWORD lpModeFlags );
|
|---|
| 7922 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetConsoleDisplayMode( OUT LPDWORD lpModeFlags )
|
|---|
| 7923 | {
|
|---|
| 7924 | static FN_GetConsoleDisplayMode *pfn = 0;
|
|---|
| 7925 | if (!pfn)
|
|---|
| 7926 | kPrf2WrapResolve((void **)&pfn, "GetConsoleDisplayMode", &g_Kernel32);
|
|---|
| 7927 | return pfn( lpModeFlags );
|
|---|
| 7928 | }
|
|---|
| 7929 |
|
|---|
| 7930 | typedef HWND APIENTRY FN_GetConsoleWindow( VOID );
|
|---|
| 7931 | __declspec(dllexport) HWND APIENTRY kPrf2Wrap_GetConsoleWindow( VOID )
|
|---|
| 7932 | {
|
|---|
| 7933 | static FN_GetConsoleWindow *pfn = 0;
|
|---|
| 7934 | if (!pfn)
|
|---|
| 7935 | kPrf2WrapResolve((void **)&pfn, "GetConsoleWindow", &g_Kernel32);
|
|---|
| 7936 | return pfn ();
|
|---|
| 7937 | }
|
|---|
| 7938 |
|
|---|
| 7939 | typedef DWORD APIENTRY FN_GetConsoleProcessList( OUT LPDWORD lpdwProcessList, IN DWORD dwProcessCount );
|
|---|
| 7940 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleProcessList( OUT LPDWORD lpdwProcessList, IN DWORD dwProcessCount )
|
|---|
| 7941 | {
|
|---|
| 7942 | static FN_GetConsoleProcessList *pfn = 0;
|
|---|
| 7943 | if (!pfn)
|
|---|
| 7944 | kPrf2WrapResolve((void **)&pfn, "GetConsoleProcessList", &g_Kernel32);
|
|---|
| 7945 | return pfn( lpdwProcessList, dwProcessCount );
|
|---|
| 7946 | }
|
|---|
| 7947 |
|
|---|
| 7948 | typedef BOOL APIENTRY FN_AddConsoleAliasA( IN LPSTR Source, IN LPSTR Target, IN LPSTR ExeName );
|
|---|
| 7949 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_AddConsoleAliasA( IN LPSTR Source, IN LPSTR Target, IN LPSTR ExeName )
|
|---|
| 7950 | {
|
|---|
| 7951 | static FN_AddConsoleAliasA *pfn = 0;
|
|---|
| 7952 | if (!pfn)
|
|---|
| 7953 | kPrf2WrapResolve((void **)&pfn, "AddConsoleAliasA", &g_Kernel32);
|
|---|
| 7954 | return pfn( Source, Target, ExeName );
|
|---|
| 7955 | }
|
|---|
| 7956 |
|
|---|
| 7957 | typedef BOOL APIENTRY FN_AddConsoleAliasW( IN LPWSTR Source, IN LPWSTR Target, IN LPWSTR ExeName );
|
|---|
| 7958 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_AddConsoleAliasW( IN LPWSTR Source, IN LPWSTR Target, IN LPWSTR ExeName )
|
|---|
| 7959 | {
|
|---|
| 7960 | static FN_AddConsoleAliasW *pfn = 0;
|
|---|
| 7961 | if (!pfn)
|
|---|
| 7962 | kPrf2WrapResolve((void **)&pfn, "AddConsoleAliasW", &g_Kernel32);
|
|---|
| 7963 | return pfn( Source, Target, ExeName );
|
|---|
| 7964 | }
|
|---|
| 7965 |
|
|---|
| 7966 | typedef DWORD APIENTRY FN_GetConsoleAliasA( IN LPSTR Source, OUT LPSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPSTR ExeName );
|
|---|
| 7967 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasA( IN LPSTR Source, OUT LPSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPSTR ExeName )
|
|---|
| 7968 | {
|
|---|
| 7969 | static FN_GetConsoleAliasA *pfn = 0;
|
|---|
| 7970 | if (!pfn)
|
|---|
| 7971 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasA", &g_Kernel32);
|
|---|
| 7972 | return pfn( Source, TargetBuffer, TargetBufferLength, ExeName );
|
|---|
| 7973 | }
|
|---|
| 7974 |
|
|---|
| 7975 | typedef DWORD APIENTRY FN_GetConsoleAliasW( IN LPWSTR Source, OUT LPWSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPWSTR ExeName );
|
|---|
| 7976 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasW( IN LPWSTR Source, OUT LPWSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPWSTR ExeName )
|
|---|
| 7977 | {
|
|---|
| 7978 | static FN_GetConsoleAliasW *pfn = 0;
|
|---|
| 7979 | if (!pfn)
|
|---|
| 7980 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasW", &g_Kernel32);
|
|---|
| 7981 | return pfn( Source, TargetBuffer, TargetBufferLength, ExeName );
|
|---|
| 7982 | }
|
|---|
| 7983 |
|
|---|
| 7984 | typedef DWORD APIENTRY FN_GetConsoleAliasesLengthA( IN LPSTR ExeName );
|
|---|
| 7985 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesLengthA( IN LPSTR ExeName )
|
|---|
| 7986 | {
|
|---|
| 7987 | static FN_GetConsoleAliasesLengthA *pfn = 0;
|
|---|
| 7988 | if (!pfn)
|
|---|
| 7989 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesLengthA", &g_Kernel32);
|
|---|
| 7990 | return pfn( ExeName );
|
|---|
| 7991 | }
|
|---|
| 7992 |
|
|---|
| 7993 | typedef DWORD APIENTRY FN_GetConsoleAliasesLengthW( IN LPWSTR ExeName );
|
|---|
| 7994 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesLengthW( IN LPWSTR ExeName )
|
|---|
| 7995 | {
|
|---|
| 7996 | static FN_GetConsoleAliasesLengthW *pfn = 0;
|
|---|
| 7997 | if (!pfn)
|
|---|
| 7998 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesLengthW", &g_Kernel32);
|
|---|
| 7999 | return pfn( ExeName );
|
|---|
| 8000 | }
|
|---|
| 8001 |
|
|---|
| 8002 | typedef DWORD APIENTRY FN_GetConsoleAliasExesLengthA( VOID );
|
|---|
| 8003 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesLengthA( VOID )
|
|---|
| 8004 | {
|
|---|
| 8005 | static FN_GetConsoleAliasExesLengthA *pfn = 0;
|
|---|
| 8006 | if (!pfn)
|
|---|
| 8007 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesLengthA", &g_Kernel32);
|
|---|
| 8008 | return pfn ();
|
|---|
| 8009 | }
|
|---|
| 8010 |
|
|---|
| 8011 | typedef DWORD APIENTRY FN_GetConsoleAliasExesLengthW( VOID );
|
|---|
| 8012 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesLengthW( VOID )
|
|---|
| 8013 | {
|
|---|
| 8014 | static FN_GetConsoleAliasExesLengthW *pfn = 0;
|
|---|
| 8015 | if (!pfn)
|
|---|
| 8016 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesLengthW", &g_Kernel32);
|
|---|
| 8017 | return pfn ();
|
|---|
| 8018 | }
|
|---|
| 8019 |
|
|---|
| 8020 | typedef DWORD APIENTRY FN_GetConsoleAliasesA( OUT LPSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPSTR ExeName );
|
|---|
| 8021 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesA( OUT LPSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPSTR ExeName )
|
|---|
| 8022 | {
|
|---|
| 8023 | static FN_GetConsoleAliasesA *pfn = 0;
|
|---|
| 8024 | if (!pfn)
|
|---|
| 8025 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesA", &g_Kernel32);
|
|---|
| 8026 | return pfn( AliasBuffer, AliasBufferLength, ExeName );
|
|---|
| 8027 | }
|
|---|
| 8028 |
|
|---|
| 8029 | typedef DWORD APIENTRY FN_GetConsoleAliasesW( OUT LPWSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPWSTR ExeName );
|
|---|
| 8030 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesW( OUT LPWSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPWSTR ExeName )
|
|---|
| 8031 | {
|
|---|
| 8032 | static FN_GetConsoleAliasesW *pfn = 0;
|
|---|
| 8033 | if (!pfn)
|
|---|
| 8034 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesW", &g_Kernel32);
|
|---|
| 8035 | return pfn( AliasBuffer, AliasBufferLength, ExeName );
|
|---|
| 8036 | }
|
|---|
| 8037 |
|
|---|
| 8038 | typedef DWORD APIENTRY FN_GetConsoleAliasExesA( OUT LPSTR ExeNameBuffer, IN DWORD ExeNameBufferLength );
|
|---|
| 8039 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesA( OUT LPSTR ExeNameBuffer, IN DWORD ExeNameBufferLength )
|
|---|
| 8040 | {
|
|---|
| 8041 | static FN_GetConsoleAliasExesA *pfn = 0;
|
|---|
| 8042 | if (!pfn)
|
|---|
| 8043 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesA", &g_Kernel32);
|
|---|
| 8044 | return pfn( ExeNameBuffer, ExeNameBufferLength );
|
|---|
| 8045 | }
|
|---|
| 8046 |
|
|---|
| 8047 | typedef DWORD APIENTRY FN_GetConsoleAliasExesW( OUT LPWSTR ExeNameBuffer, IN DWORD ExeNameBufferLength );
|
|---|
| 8048 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesW( OUT LPWSTR ExeNameBuffer, IN DWORD ExeNameBufferLength )
|
|---|
| 8049 | {
|
|---|
| 8050 | static FN_GetConsoleAliasExesW *pfn = 0;
|
|---|
| 8051 | if (!pfn)
|
|---|
| 8052 | kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesW", &g_Kernel32);
|
|---|
| 8053 | return pfn( ExeNameBuffer, ExeNameBufferLength );
|
|---|
| 8054 | }
|
|---|
| 8055 |
|
|---|
| 8056 | typedef BOOL WINAPI FN_IsValidCodePage( UINT CodePage );
|
|---|
| 8057 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidCodePage( UINT CodePage )
|
|---|
| 8058 | {
|
|---|
| 8059 | static FN_IsValidCodePage *pfn = 0;
|
|---|
| 8060 | if (!pfn)
|
|---|
| 8061 | kPrf2WrapResolve((void **)&pfn, "IsValidCodePage", &g_Kernel32);
|
|---|
| 8062 | return pfn( CodePage );
|
|---|
| 8063 | }
|
|---|
| 8064 |
|
|---|
| 8065 | typedef UINT WINAPI FN_GetACP( void );
|
|---|
| 8066 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetACP( void )
|
|---|
| 8067 | {
|
|---|
| 8068 | static FN_GetACP *pfn = 0;
|
|---|
| 8069 | if (!pfn)
|
|---|
| 8070 | kPrf2WrapResolve((void **)&pfn, "GetACP", &g_Kernel32);
|
|---|
| 8071 | return pfn ();
|
|---|
| 8072 | }
|
|---|
| 8073 |
|
|---|
| 8074 | typedef UINT WINAPI FN_GetOEMCP( void );
|
|---|
| 8075 | __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetOEMCP( void )
|
|---|
| 8076 | {
|
|---|
| 8077 | static FN_GetOEMCP *pfn = 0;
|
|---|
| 8078 | if (!pfn)
|
|---|
| 8079 | kPrf2WrapResolve((void **)&pfn, "GetOEMCP", &g_Kernel32);
|
|---|
| 8080 | return pfn ();
|
|---|
| 8081 | }
|
|---|
| 8082 |
|
|---|
| 8083 | typedef BOOL WINAPI FN_GetCPInfo( UINT CodePage, LPCPINFO lpCPInfo );
|
|---|
| 8084 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfo( UINT CodePage, LPCPINFO lpCPInfo )
|
|---|
| 8085 | {
|
|---|
| 8086 | static FN_GetCPInfo *pfn = 0;
|
|---|
| 8087 | if (!pfn)
|
|---|
| 8088 | kPrf2WrapResolve((void **)&pfn, "GetCPInfo", &g_Kernel32);
|
|---|
| 8089 | return pfn( CodePage, lpCPInfo );
|
|---|
| 8090 | }
|
|---|
| 8091 |
|
|---|
| 8092 | typedef BOOL WINAPI FN_GetCPInfoExA( UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx );
|
|---|
| 8093 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfoExA( UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx )
|
|---|
| 8094 | {
|
|---|
| 8095 | static FN_GetCPInfoExA *pfn = 0;
|
|---|
| 8096 | if (!pfn)
|
|---|
| 8097 | kPrf2WrapResolve((void **)&pfn, "GetCPInfoExA", &g_Kernel32);
|
|---|
| 8098 | return pfn( CodePage, dwFlags, lpCPInfoEx );
|
|---|
| 8099 | }
|
|---|
| 8100 |
|
|---|
| 8101 | typedef BOOL WINAPI FN_GetCPInfoExW( UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx );
|
|---|
| 8102 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfoExW( UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx )
|
|---|
| 8103 | {
|
|---|
| 8104 | static FN_GetCPInfoExW *pfn = 0;
|
|---|
| 8105 | if (!pfn)
|
|---|
| 8106 | kPrf2WrapResolve((void **)&pfn, "GetCPInfoExW", &g_Kernel32);
|
|---|
| 8107 | return pfn( CodePage, dwFlags, lpCPInfoEx );
|
|---|
| 8108 | }
|
|---|
| 8109 |
|
|---|
| 8110 | typedef BOOL WINAPI FN_IsDBCSLeadByte( BYTE TestChar );
|
|---|
| 8111 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDBCSLeadByte( BYTE TestChar )
|
|---|
| 8112 | {
|
|---|
| 8113 | static FN_IsDBCSLeadByte *pfn = 0;
|
|---|
| 8114 | if (!pfn)
|
|---|
| 8115 | kPrf2WrapResolve((void **)&pfn, "IsDBCSLeadByte", &g_Kernel32);
|
|---|
| 8116 | return pfn( TestChar );
|
|---|
| 8117 | }
|
|---|
| 8118 |
|
|---|
| 8119 | typedef BOOL WINAPI FN_IsDBCSLeadByteEx( UINT CodePage, BYTE TestChar );
|
|---|
| 8120 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDBCSLeadByteEx( UINT CodePage, BYTE TestChar )
|
|---|
| 8121 | {
|
|---|
| 8122 | static FN_IsDBCSLeadByteEx *pfn = 0;
|
|---|
| 8123 | if (!pfn)
|
|---|
| 8124 | kPrf2WrapResolve((void **)&pfn, "IsDBCSLeadByteEx", &g_Kernel32);
|
|---|
| 8125 | return pfn( CodePage, TestChar );
|
|---|
| 8126 | }
|
|---|
| 8127 |
|
|---|
| 8128 | typedef int WINAPI FN_MultiByteToWideChar( UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar );
|
|---|
| 8129 | __declspec(dllexport) int WINAPI kPrf2Wrap_MultiByteToWideChar( UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar )
|
|---|
| 8130 | {
|
|---|
| 8131 | static FN_MultiByteToWideChar *pfn = 0;
|
|---|
| 8132 | if (!pfn)
|
|---|
| 8133 | kPrf2WrapResolve((void **)&pfn, "MultiByteToWideChar", &g_Kernel32);
|
|---|
| 8134 | return pfn( CodePage, dwFlags, lpMultiByteStr, cbMultiByte, lpWideCharStr, cchWideChar );
|
|---|
| 8135 | }
|
|---|
| 8136 |
|
|---|
| 8137 | typedef int WINAPI FN_WideCharToMultiByte( UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar );
|
|---|
| 8138 | __declspec(dllexport) int WINAPI kPrf2Wrap_WideCharToMultiByte( UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar )
|
|---|
| 8139 | {
|
|---|
| 8140 | static FN_WideCharToMultiByte *pfn = 0;
|
|---|
| 8141 | if (!pfn)
|
|---|
| 8142 | kPrf2WrapResolve((void **)&pfn, "WideCharToMultiByte", &g_Kernel32);
|
|---|
| 8143 | return pfn( CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar );
|
|---|
| 8144 | }
|
|---|
| 8145 |
|
|---|
| 8146 | typedef int WINAPI FN_CompareStringA( LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2, int cchCount2 );
|
|---|
| 8147 | __declspec(dllexport) int WINAPI kPrf2Wrap_CompareStringA( LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2, int cchCount2 )
|
|---|
| 8148 | {
|
|---|
| 8149 | static FN_CompareStringA *pfn = 0;
|
|---|
| 8150 | if (!pfn)
|
|---|
| 8151 | kPrf2WrapResolve((void **)&pfn, "CompareStringA", &g_Kernel32);
|
|---|
| 8152 | return pfn( Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2 );
|
|---|
| 8153 | }
|
|---|
| 8154 |
|
|---|
| 8155 | typedef int WINAPI FN_CompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2 );
|
|---|
| 8156 | __declspec(dllexport) int WINAPI kPrf2Wrap_CompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2 )
|
|---|
| 8157 | {
|
|---|
| 8158 | static FN_CompareStringW *pfn = 0;
|
|---|
| 8159 | if (!pfn)
|
|---|
| 8160 | kPrf2WrapResolve((void **)&pfn, "CompareStringW", &g_Kernel32);
|
|---|
| 8161 | return pfn( Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2 );
|
|---|
| 8162 | }
|
|---|
| 8163 |
|
|---|
| 8164 | typedef int WINAPI FN_LCMapStringA( LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest );
|
|---|
| 8165 | __declspec(dllexport) int WINAPI kPrf2Wrap_LCMapStringA( LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest )
|
|---|
| 8166 | {
|
|---|
| 8167 | static FN_LCMapStringA *pfn = 0;
|
|---|
| 8168 | if (!pfn)
|
|---|
| 8169 | kPrf2WrapResolve((void **)&pfn, "LCMapStringA", &g_Kernel32);
|
|---|
| 8170 | return pfn( Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
|
|---|
| 8171 | }
|
|---|
| 8172 |
|
|---|
| 8173 | typedef int WINAPI FN_LCMapStringW( LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest );
|
|---|
| 8174 | __declspec(dllexport) int WINAPI kPrf2Wrap_LCMapStringW( LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest )
|
|---|
| 8175 | {
|
|---|
| 8176 | static FN_LCMapStringW *pfn = 0;
|
|---|
| 8177 | if (!pfn)
|
|---|
| 8178 | kPrf2WrapResolve((void **)&pfn, "LCMapStringW", &g_Kernel32);
|
|---|
| 8179 | return pfn( Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
|
|---|
| 8180 | }
|
|---|
| 8181 |
|
|---|
| 8182 | typedef int WINAPI FN_GetLocaleInfoA( LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData );
|
|---|
| 8183 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetLocaleInfoA( LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData )
|
|---|
| 8184 | {
|
|---|
| 8185 | static FN_GetLocaleInfoA *pfn = 0;
|
|---|
| 8186 | if (!pfn)
|
|---|
| 8187 | kPrf2WrapResolve((void **)&pfn, "GetLocaleInfoA", &g_Kernel32);
|
|---|
| 8188 | return pfn( Locale, LCType, lpLCData, cchData );
|
|---|
| 8189 | }
|
|---|
| 8190 |
|
|---|
| 8191 | typedef int WINAPI FN_GetLocaleInfoW( LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData );
|
|---|
| 8192 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetLocaleInfoW( LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData )
|
|---|
| 8193 | {
|
|---|
| 8194 | static FN_GetLocaleInfoW *pfn = 0;
|
|---|
| 8195 | if (!pfn)
|
|---|
| 8196 | kPrf2WrapResolve((void **)&pfn, "GetLocaleInfoW", &g_Kernel32);
|
|---|
| 8197 | return pfn( Locale, LCType, lpLCData, cchData );
|
|---|
| 8198 | }
|
|---|
| 8199 |
|
|---|
| 8200 | typedef BOOL WINAPI FN_SetLocaleInfoA( LCID Locale, LCTYPE LCType, LPCSTR lpLCData );
|
|---|
| 8201 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocaleInfoA( LCID Locale, LCTYPE LCType, LPCSTR lpLCData )
|
|---|
| 8202 | {
|
|---|
| 8203 | static FN_SetLocaleInfoA *pfn = 0;
|
|---|
| 8204 | if (!pfn)
|
|---|
| 8205 | kPrf2WrapResolve((void **)&pfn, "SetLocaleInfoA", &g_Kernel32);
|
|---|
| 8206 | return pfn( Locale, LCType, lpLCData );
|
|---|
| 8207 | }
|
|---|
| 8208 |
|
|---|
| 8209 | typedef BOOL WINAPI FN_SetLocaleInfoW( LCID Locale, LCTYPE LCType, LPCWSTR lpLCData );
|
|---|
| 8210 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocaleInfoW( LCID Locale, LCTYPE LCType, LPCWSTR lpLCData )
|
|---|
| 8211 | {
|
|---|
| 8212 | static FN_SetLocaleInfoW *pfn = 0;
|
|---|
| 8213 | if (!pfn)
|
|---|
| 8214 | kPrf2WrapResolve((void **)&pfn, "SetLocaleInfoW", &g_Kernel32);
|
|---|
| 8215 | return pfn( Locale, LCType, lpLCData );
|
|---|
| 8216 | }
|
|---|
| 8217 |
|
|---|
| 8218 | typedef int WINAPI FN_GetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue );
|
|---|
| 8219 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue )
|
|---|
| 8220 | {
|
|---|
| 8221 | static FN_GetCalendarInfoA *pfn = 0;
|
|---|
| 8222 | if (!pfn)
|
|---|
| 8223 | kPrf2WrapResolve((void **)&pfn, "GetCalendarInfoA", &g_Kernel32);
|
|---|
| 8224 | return pfn( Locale, Calendar, CalType, lpCalData, cchData, lpValue );
|
|---|
| 8225 | }
|
|---|
| 8226 |
|
|---|
| 8227 | typedef int WINAPI FN_GetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue );
|
|---|
| 8228 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue )
|
|---|
| 8229 | {
|
|---|
| 8230 | static FN_GetCalendarInfoW *pfn = 0;
|
|---|
| 8231 | if (!pfn)
|
|---|
| 8232 | kPrf2WrapResolve((void **)&pfn, "GetCalendarInfoW", &g_Kernel32);
|
|---|
| 8233 | return pfn( Locale, Calendar, CalType, lpCalData, cchData, lpValue );
|
|---|
| 8234 | }
|
|---|
| 8235 |
|
|---|
| 8236 | typedef BOOL WINAPI FN_SetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData );
|
|---|
| 8237 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData )
|
|---|
| 8238 | {
|
|---|
| 8239 | static FN_SetCalendarInfoA *pfn = 0;
|
|---|
| 8240 | if (!pfn)
|
|---|
| 8241 | kPrf2WrapResolve((void **)&pfn, "SetCalendarInfoA", &g_Kernel32);
|
|---|
| 8242 | return pfn( Locale, Calendar, CalType, lpCalData );
|
|---|
| 8243 | }
|
|---|
| 8244 |
|
|---|
| 8245 | typedef BOOL WINAPI FN_SetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData );
|
|---|
| 8246 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData )
|
|---|
| 8247 | {
|
|---|
| 8248 | static FN_SetCalendarInfoW *pfn = 0;
|
|---|
| 8249 | if (!pfn)
|
|---|
| 8250 | kPrf2WrapResolve((void **)&pfn, "SetCalendarInfoW", &g_Kernel32);
|
|---|
| 8251 | return pfn( Locale, Calendar, CalType, lpCalData );
|
|---|
| 8252 | }
|
|---|
| 8253 |
|
|---|
| 8254 | typedef int WINAPI FN_GetTimeFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCSTR lpFormat, LPSTR lpTimeStr, int cchTime );
|
|---|
| 8255 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetTimeFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCSTR lpFormat, LPSTR lpTimeStr, int cchTime )
|
|---|
| 8256 | {
|
|---|
| 8257 | static FN_GetTimeFormatA *pfn = 0;
|
|---|
| 8258 | if (!pfn)
|
|---|
| 8259 | kPrf2WrapResolve((void **)&pfn, "GetTimeFormatA", &g_Kernel32);
|
|---|
| 8260 | return pfn( Locale, dwFlags, lpTime, lpFormat, lpTimeStr, cchTime );
|
|---|
| 8261 | }
|
|---|
| 8262 |
|
|---|
| 8263 | typedef int WINAPI FN_GetTimeFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime );
|
|---|
| 8264 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetTimeFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime )
|
|---|
| 8265 | {
|
|---|
| 8266 | static FN_GetTimeFormatW *pfn = 0;
|
|---|
| 8267 | if (!pfn)
|
|---|
| 8268 | kPrf2WrapResolve((void **)&pfn, "GetTimeFormatW", &g_Kernel32);
|
|---|
| 8269 | return pfn( Locale, dwFlags, lpTime, lpFormat, lpTimeStr, cchTime );
|
|---|
| 8270 | }
|
|---|
| 8271 |
|
|---|
| 8272 | typedef int WINAPI FN_GetDateFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate );
|
|---|
| 8273 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetDateFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate )
|
|---|
| 8274 | {
|
|---|
| 8275 | static FN_GetDateFormatA *pfn = 0;
|
|---|
| 8276 | if (!pfn)
|
|---|
| 8277 | kPrf2WrapResolve((void **)&pfn, "GetDateFormatA", &g_Kernel32);
|
|---|
| 8278 | return pfn( Locale, dwFlags, lpDate, lpFormat, lpDateStr, cchDate );
|
|---|
| 8279 | }
|
|---|
| 8280 |
|
|---|
| 8281 | typedef int WINAPI FN_GetDateFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate );
|
|---|
| 8282 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetDateFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate )
|
|---|
| 8283 | {
|
|---|
| 8284 | static FN_GetDateFormatW *pfn = 0;
|
|---|
| 8285 | if (!pfn)
|
|---|
| 8286 | kPrf2WrapResolve((void **)&pfn, "GetDateFormatW", &g_Kernel32);
|
|---|
| 8287 | return pfn( Locale, dwFlags, lpDate, lpFormat, lpDateStr, cchDate );
|
|---|
| 8288 | }
|
|---|
| 8289 |
|
|---|
| 8290 | typedef int WINAPI FN_GetNumberFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST NUMBERFMTA * lpFormat, LPSTR lpNumberStr, int cchNumber );
|
|---|
| 8291 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetNumberFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST NUMBERFMTA * lpFormat, LPSTR lpNumberStr, int cchNumber )
|
|---|
| 8292 | {
|
|---|
| 8293 | static FN_GetNumberFormatA *pfn = 0;
|
|---|
| 8294 | if (!pfn)
|
|---|
| 8295 | kPrf2WrapResolve((void **)&pfn, "GetNumberFormatA", &g_Kernel32);
|
|---|
| 8296 | return pfn( Locale, dwFlags, lpValue, lpFormat, lpNumberStr, cchNumber );
|
|---|
| 8297 | }
|
|---|
| 8298 |
|
|---|
| 8299 | typedef int WINAPI FN_GetNumberFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST NUMBERFMTW * lpFormat, LPWSTR lpNumberStr, int cchNumber );
|
|---|
| 8300 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetNumberFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST NUMBERFMTW * lpFormat, LPWSTR lpNumberStr, int cchNumber )
|
|---|
| 8301 | {
|
|---|
| 8302 | static FN_GetNumberFormatW *pfn = 0;
|
|---|
| 8303 | if (!pfn)
|
|---|
| 8304 | kPrf2WrapResolve((void **)&pfn, "GetNumberFormatW", &g_Kernel32);
|
|---|
| 8305 | return pfn( Locale, dwFlags, lpValue, lpFormat, lpNumberStr, cchNumber );
|
|---|
| 8306 | }
|
|---|
| 8307 |
|
|---|
| 8308 | typedef int WINAPI FN_GetCurrencyFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST CURRENCYFMTA * lpFormat, LPSTR lpCurrencyStr, int cchCurrency );
|
|---|
| 8309 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetCurrencyFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST CURRENCYFMTA * lpFormat, LPSTR lpCurrencyStr, int cchCurrency )
|
|---|
| 8310 | {
|
|---|
| 8311 | static FN_GetCurrencyFormatA *pfn = 0;
|
|---|
| 8312 | if (!pfn)
|
|---|
| 8313 | kPrf2WrapResolve((void **)&pfn, "GetCurrencyFormatA", &g_Kernel32);
|
|---|
| 8314 | return pfn( Locale, dwFlags, lpValue, lpFormat, lpCurrencyStr, cchCurrency );
|
|---|
| 8315 | }
|
|---|
| 8316 |
|
|---|
| 8317 | typedef int WINAPI FN_GetCurrencyFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST CURRENCYFMTW * lpFormat, LPWSTR lpCurrencyStr, int cchCurrency );
|
|---|
| 8318 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetCurrencyFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST CURRENCYFMTW * lpFormat, LPWSTR lpCurrencyStr, int cchCurrency )
|
|---|
| 8319 | {
|
|---|
| 8320 | static FN_GetCurrencyFormatW *pfn = 0;
|
|---|
| 8321 | if (!pfn)
|
|---|
| 8322 | kPrf2WrapResolve((void **)&pfn, "GetCurrencyFormatW", &g_Kernel32);
|
|---|
| 8323 | return pfn( Locale, dwFlags, lpValue, lpFormat, lpCurrencyStr, cchCurrency );
|
|---|
| 8324 | }
|
|---|
| 8325 |
|
|---|
| 8326 | typedef BOOL WINAPI FN_EnumCalendarInfoA( CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType );
|
|---|
| 8327 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoA( CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType )
|
|---|
| 8328 | {
|
|---|
| 8329 | static FN_EnumCalendarInfoA *pfn = 0;
|
|---|
| 8330 | if (!pfn)
|
|---|
| 8331 | kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoA", &g_Kernel32);
|
|---|
| 8332 | return pfn( lpCalInfoEnumProc, Locale, Calendar, CalType );
|
|---|
| 8333 | }
|
|---|
| 8334 |
|
|---|
| 8335 | typedef BOOL WINAPI FN_EnumCalendarInfoW( CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType );
|
|---|
| 8336 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoW( CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType )
|
|---|
| 8337 | {
|
|---|
| 8338 | static FN_EnumCalendarInfoW *pfn = 0;
|
|---|
| 8339 | if (!pfn)
|
|---|
| 8340 | kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoW", &g_Kernel32);
|
|---|
| 8341 | return pfn( lpCalInfoEnumProc, Locale, Calendar, CalType );
|
|---|
| 8342 | }
|
|---|
| 8343 |
|
|---|
| 8344 | typedef BOOL WINAPI FN_EnumCalendarInfoExA( CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType );
|
|---|
| 8345 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoExA( CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType )
|
|---|
| 8346 | {
|
|---|
| 8347 | static FN_EnumCalendarInfoExA *pfn = 0;
|
|---|
| 8348 | if (!pfn)
|
|---|
| 8349 | kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoExA", &g_Kernel32);
|
|---|
| 8350 | return pfn( lpCalInfoEnumProcEx, Locale, Calendar, CalType );
|
|---|
| 8351 | }
|
|---|
| 8352 |
|
|---|
| 8353 | typedef BOOL WINAPI FN_EnumCalendarInfoExW( CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType );
|
|---|
| 8354 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoExW( CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType )
|
|---|
| 8355 | {
|
|---|
| 8356 | static FN_EnumCalendarInfoExW *pfn = 0;
|
|---|
| 8357 | if (!pfn)
|
|---|
| 8358 | kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoExW", &g_Kernel32);
|
|---|
| 8359 | return pfn( lpCalInfoEnumProcEx, Locale, Calendar, CalType );
|
|---|
| 8360 | }
|
|---|
| 8361 |
|
|---|
| 8362 | typedef BOOL WINAPI FN_EnumTimeFormatsA( TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags );
|
|---|
| 8363 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumTimeFormatsA( TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags )
|
|---|
| 8364 | {
|
|---|
| 8365 | static FN_EnumTimeFormatsA *pfn = 0;
|
|---|
| 8366 | if (!pfn)
|
|---|
| 8367 | kPrf2WrapResolve((void **)&pfn, "EnumTimeFormatsA", &g_Kernel32);
|
|---|
| 8368 | return pfn( lpTimeFmtEnumProc, Locale, dwFlags );
|
|---|
| 8369 | }
|
|---|
| 8370 |
|
|---|
| 8371 | typedef BOOL WINAPI FN_EnumTimeFormatsW( TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags );
|
|---|
| 8372 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumTimeFormatsW( TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags )
|
|---|
| 8373 | {
|
|---|
| 8374 | static FN_EnumTimeFormatsW *pfn = 0;
|
|---|
| 8375 | if (!pfn)
|
|---|
| 8376 | kPrf2WrapResolve((void **)&pfn, "EnumTimeFormatsW", &g_Kernel32);
|
|---|
| 8377 | return pfn( lpTimeFmtEnumProc, Locale, dwFlags );
|
|---|
| 8378 | }
|
|---|
| 8379 |
|
|---|
| 8380 | typedef BOOL WINAPI FN_EnumDateFormatsA( DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags );
|
|---|
| 8381 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsA( DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags )
|
|---|
| 8382 | {
|
|---|
| 8383 | static FN_EnumDateFormatsA *pfn = 0;
|
|---|
| 8384 | if (!pfn)
|
|---|
| 8385 | kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsA", &g_Kernel32);
|
|---|
| 8386 | return pfn( lpDateFmtEnumProc, Locale, dwFlags );
|
|---|
| 8387 | }
|
|---|
| 8388 |
|
|---|
| 8389 | typedef BOOL WINAPI FN_EnumDateFormatsW( DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags );
|
|---|
| 8390 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsW( DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags )
|
|---|
| 8391 | {
|
|---|
| 8392 | static FN_EnumDateFormatsW *pfn = 0;
|
|---|
| 8393 | if (!pfn)
|
|---|
| 8394 | kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsW", &g_Kernel32);
|
|---|
| 8395 | return pfn( lpDateFmtEnumProc, Locale, dwFlags );
|
|---|
| 8396 | }
|
|---|
| 8397 |
|
|---|
| 8398 | typedef BOOL WINAPI FN_EnumDateFormatsExA( DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags );
|
|---|
| 8399 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsExA( DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags )
|
|---|
| 8400 | {
|
|---|
| 8401 | static FN_EnumDateFormatsExA *pfn = 0;
|
|---|
| 8402 | if (!pfn)
|
|---|
| 8403 | kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsExA", &g_Kernel32);
|
|---|
| 8404 | return pfn( lpDateFmtEnumProcEx, Locale, dwFlags );
|
|---|
| 8405 | }
|
|---|
| 8406 |
|
|---|
| 8407 | typedef BOOL WINAPI FN_EnumDateFormatsExW( DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags );
|
|---|
| 8408 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsExW( DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags )
|
|---|
| 8409 | {
|
|---|
| 8410 | static FN_EnumDateFormatsExW *pfn = 0;
|
|---|
| 8411 | if (!pfn)
|
|---|
| 8412 | kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsExW", &g_Kernel32);
|
|---|
| 8413 | return pfn( lpDateFmtEnumProcEx, Locale, dwFlags );
|
|---|
| 8414 | }
|
|---|
| 8415 |
|
|---|
| 8416 | typedef BOOL WINAPI FN_IsValidLanguageGroup( LGRPID LanguageGroup, DWORD dwFlags );
|
|---|
| 8417 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidLanguageGroup( LGRPID LanguageGroup, DWORD dwFlags )
|
|---|
| 8418 | {
|
|---|
| 8419 | static FN_IsValidLanguageGroup *pfn = 0;
|
|---|
| 8420 | if (!pfn)
|
|---|
| 8421 | kPrf2WrapResolve((void **)&pfn, "IsValidLanguageGroup", &g_Kernel32);
|
|---|
| 8422 | return pfn( LanguageGroup, dwFlags );
|
|---|
| 8423 | }
|
|---|
| 8424 |
|
|---|
| 8425 | typedef BOOL WINAPI FN_GetNLSVersion( NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation );
|
|---|
| 8426 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNLSVersion( NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation )
|
|---|
| 8427 | {
|
|---|
| 8428 | static FN_GetNLSVersion *pfn = 0;
|
|---|
| 8429 | if (!pfn)
|
|---|
| 8430 | kPrf2WrapResolve((void **)&pfn, "GetNLSVersion", &g_Kernel32);
|
|---|
| 8431 | return pfn( Function, Locale, lpVersionInformation );
|
|---|
| 8432 | }
|
|---|
| 8433 |
|
|---|
| 8434 | typedef BOOL WINAPI FN_IsNLSDefinedString( NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr );
|
|---|
| 8435 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsNLSDefinedString( NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr )
|
|---|
| 8436 | {
|
|---|
| 8437 | static FN_IsNLSDefinedString *pfn = 0;
|
|---|
| 8438 | if (!pfn)
|
|---|
| 8439 | kPrf2WrapResolve((void **)&pfn, "IsNLSDefinedString", &g_Kernel32);
|
|---|
| 8440 | return pfn( Function, dwFlags, lpVersionInformation, lpString, cchStr );
|
|---|
| 8441 | }
|
|---|
| 8442 |
|
|---|
| 8443 | typedef BOOL WINAPI FN_IsValidLocale( LCID Locale, DWORD dwFlags );
|
|---|
| 8444 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidLocale( LCID Locale, DWORD dwFlags )
|
|---|
| 8445 | {
|
|---|
| 8446 | static FN_IsValidLocale *pfn = 0;
|
|---|
| 8447 | if (!pfn)
|
|---|
| 8448 | kPrf2WrapResolve((void **)&pfn, "IsValidLocale", &g_Kernel32);
|
|---|
| 8449 | return pfn( Locale, dwFlags );
|
|---|
| 8450 | }
|
|---|
| 8451 |
|
|---|
| 8452 | typedef int WINAPI FN_GetGeoInfoA( GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId );
|
|---|
| 8453 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetGeoInfoA( GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId )
|
|---|
| 8454 | {
|
|---|
| 8455 | static FN_GetGeoInfoA *pfn = 0;
|
|---|
| 8456 | if (!pfn)
|
|---|
| 8457 | kPrf2WrapResolve((void **)&pfn, "GetGeoInfoA", &g_Kernel32);
|
|---|
| 8458 | return pfn( Location, GeoType, lpGeoData, cchData, LangId );
|
|---|
| 8459 | }
|
|---|
| 8460 |
|
|---|
| 8461 | typedef int WINAPI FN_GetGeoInfoW( GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId );
|
|---|
| 8462 | __declspec(dllexport) int WINAPI kPrf2Wrap_GetGeoInfoW( GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId )
|
|---|
| 8463 | {
|
|---|
| 8464 | static FN_GetGeoInfoW *pfn = 0;
|
|---|
| 8465 | if (!pfn)
|
|---|
| 8466 | kPrf2WrapResolve((void **)&pfn, "GetGeoInfoW", &g_Kernel32);
|
|---|
| 8467 | return pfn( Location, GeoType, lpGeoData, cchData, LangId );
|
|---|
| 8468 | }
|
|---|
| 8469 |
|
|---|
| 8470 | typedef BOOL WINAPI FN_EnumSystemGeoID( GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc );
|
|---|
| 8471 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemGeoID( GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc )
|
|---|
| 8472 | {
|
|---|
| 8473 | static FN_EnumSystemGeoID *pfn = 0;
|
|---|
| 8474 | if (!pfn)
|
|---|
| 8475 | kPrf2WrapResolve((void **)&pfn, "EnumSystemGeoID", &g_Kernel32);
|
|---|
| 8476 | return pfn( GeoClass, ParentGeoId, lpGeoEnumProc );
|
|---|
| 8477 | }
|
|---|
| 8478 |
|
|---|
| 8479 | typedef GEOID WINAPI FN_GetUserGeoID( GEOCLASS GeoClass );
|
|---|
| 8480 | __declspec(dllexport) GEOID WINAPI kPrf2Wrap_GetUserGeoID( GEOCLASS GeoClass )
|
|---|
| 8481 | {
|
|---|
| 8482 | static FN_GetUserGeoID *pfn = 0;
|
|---|
| 8483 | if (!pfn)
|
|---|
| 8484 | kPrf2WrapResolve((void **)&pfn, "GetUserGeoID", &g_Kernel32);
|
|---|
| 8485 | return pfn( GeoClass );
|
|---|
| 8486 | }
|
|---|
| 8487 |
|
|---|
| 8488 | typedef BOOL WINAPI FN_SetUserGeoID( GEOID GeoId );
|
|---|
| 8489 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetUserGeoID( GEOID GeoId )
|
|---|
| 8490 | {
|
|---|
| 8491 | static FN_SetUserGeoID *pfn = 0;
|
|---|
| 8492 | if (!pfn)
|
|---|
| 8493 | kPrf2WrapResolve((void **)&pfn, "SetUserGeoID", &g_Kernel32);
|
|---|
| 8494 | return pfn( GeoId );
|
|---|
| 8495 | }
|
|---|
| 8496 |
|
|---|
| 8497 | typedef LCID WINAPI FN_ConvertDefaultLocale( LCID Locale );
|
|---|
| 8498 | __declspec(dllexport) LCID WINAPI kPrf2Wrap_ConvertDefaultLocale( LCID Locale )
|
|---|
| 8499 | {
|
|---|
| 8500 | static FN_ConvertDefaultLocale *pfn = 0;
|
|---|
| 8501 | if (!pfn)
|
|---|
| 8502 | kPrf2WrapResolve((void **)&pfn, "ConvertDefaultLocale", &g_Kernel32);
|
|---|
| 8503 | return pfn( Locale );
|
|---|
| 8504 | }
|
|---|
| 8505 |
|
|---|
| 8506 | typedef LCID WINAPI FN_GetThreadLocale( void );
|
|---|
| 8507 | __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetThreadLocale( void )
|
|---|
| 8508 | {
|
|---|
| 8509 | static FN_GetThreadLocale *pfn = 0;
|
|---|
| 8510 | if (!pfn)
|
|---|
| 8511 | kPrf2WrapResolve((void **)&pfn, "GetThreadLocale", &g_Kernel32);
|
|---|
| 8512 | return pfn ();
|
|---|
| 8513 | }
|
|---|
| 8514 |
|
|---|
| 8515 | typedef BOOL WINAPI FN_SetThreadLocale( LCID Locale );
|
|---|
| 8516 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadLocale( LCID Locale )
|
|---|
| 8517 | {
|
|---|
| 8518 | static FN_SetThreadLocale *pfn = 0;
|
|---|
| 8519 | if (!pfn)
|
|---|
| 8520 | kPrf2WrapResolve((void **)&pfn, "SetThreadLocale", &g_Kernel32);
|
|---|
| 8521 | return pfn( Locale );
|
|---|
| 8522 | }
|
|---|
| 8523 |
|
|---|
| 8524 | typedef LANGID WINAPI FN_GetSystemDefaultUILanguage( void );
|
|---|
| 8525 | __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetSystemDefaultUILanguage( void )
|
|---|
| 8526 | {
|
|---|
| 8527 | static FN_GetSystemDefaultUILanguage *pfn = 0;
|
|---|
| 8528 | if (!pfn)
|
|---|
| 8529 | kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultUILanguage", &g_Kernel32);
|
|---|
| 8530 | return pfn ();
|
|---|
| 8531 | }
|
|---|
| 8532 |
|
|---|
| 8533 | typedef LANGID WINAPI FN_GetUserDefaultUILanguage( void );
|
|---|
| 8534 | __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetUserDefaultUILanguage( void )
|
|---|
| 8535 | {
|
|---|
| 8536 | static FN_GetUserDefaultUILanguage *pfn = 0;
|
|---|
| 8537 | if (!pfn)
|
|---|
| 8538 | kPrf2WrapResolve((void **)&pfn, "GetUserDefaultUILanguage", &g_Kernel32);
|
|---|
| 8539 | return pfn ();
|
|---|
| 8540 | }
|
|---|
| 8541 |
|
|---|
| 8542 | typedef LANGID WINAPI FN_GetSystemDefaultLangID( void );
|
|---|
| 8543 | __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetSystemDefaultLangID( void )
|
|---|
| 8544 | {
|
|---|
| 8545 | static FN_GetSystemDefaultLangID *pfn = 0;
|
|---|
| 8546 | if (!pfn)
|
|---|
| 8547 | kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultLangID", &g_Kernel32);
|
|---|
| 8548 | return pfn ();
|
|---|
| 8549 | }
|
|---|
| 8550 |
|
|---|
| 8551 | typedef LANGID WINAPI FN_GetUserDefaultLangID( void );
|
|---|
| 8552 | __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetUserDefaultLangID( void )
|
|---|
| 8553 | {
|
|---|
| 8554 | static FN_GetUserDefaultLangID *pfn = 0;
|
|---|
| 8555 | if (!pfn)
|
|---|
| 8556 | kPrf2WrapResolve((void **)&pfn, "GetUserDefaultLangID", &g_Kernel32);
|
|---|
| 8557 | return pfn ();
|
|---|
| 8558 | }
|
|---|
| 8559 |
|
|---|
| 8560 | typedef LCID WINAPI FN_GetSystemDefaultLCID( void );
|
|---|
| 8561 | __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetSystemDefaultLCID( void )
|
|---|
| 8562 | {
|
|---|
| 8563 | static FN_GetSystemDefaultLCID *pfn = 0;
|
|---|
| 8564 | if (!pfn)
|
|---|
| 8565 | kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultLCID", &g_Kernel32);
|
|---|
| 8566 | return pfn ();
|
|---|
| 8567 | }
|
|---|
| 8568 |
|
|---|
| 8569 | typedef LCID WINAPI FN_GetUserDefaultLCID( void );
|
|---|
| 8570 | __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetUserDefaultLCID( void )
|
|---|
| 8571 | {
|
|---|
| 8572 | static FN_GetUserDefaultLCID *pfn = 0;
|
|---|
| 8573 | if (!pfn)
|
|---|
| 8574 | kPrf2WrapResolve((void **)&pfn, "GetUserDefaultLCID", &g_Kernel32);
|
|---|
| 8575 | return pfn ();
|
|---|
| 8576 | }
|
|---|
| 8577 |
|
|---|
| 8578 | typedef BOOL WINAPI FN_GetStringTypeExA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
|
|---|
| 8579 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeExA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
|
|---|
| 8580 | {
|
|---|
| 8581 | static FN_GetStringTypeExA *pfn = 0;
|
|---|
| 8582 | if (!pfn)
|
|---|
| 8583 | kPrf2WrapResolve((void **)&pfn, "GetStringTypeExA", &g_Kernel32);
|
|---|
| 8584 | return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
|
|---|
| 8585 | }
|
|---|
| 8586 |
|
|---|
| 8587 | typedef BOOL WINAPI FN_GetStringTypeExW( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
|
|---|
| 8588 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeExW( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
|
|---|
| 8589 | {
|
|---|
| 8590 | static FN_GetStringTypeExW *pfn = 0;
|
|---|
| 8591 | if (!pfn)
|
|---|
| 8592 | kPrf2WrapResolve((void **)&pfn, "GetStringTypeExW", &g_Kernel32);
|
|---|
| 8593 | return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
|
|---|
| 8594 | }
|
|---|
| 8595 |
|
|---|
| 8596 | typedef BOOL WINAPI FN_GetStringTypeA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
|
|---|
| 8597 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
|
|---|
| 8598 | {
|
|---|
| 8599 | static FN_GetStringTypeA *pfn = 0;
|
|---|
| 8600 | if (!pfn)
|
|---|
| 8601 | kPrf2WrapResolve((void **)&pfn, "GetStringTypeA", &g_Kernel32);
|
|---|
| 8602 | return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
|
|---|
| 8603 | }
|
|---|
| 8604 |
|
|---|
| 8605 | typedef BOOL WINAPI FN_GetStringTypeW( DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
|
|---|
| 8606 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeW( DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
|
|---|
| 8607 | {
|
|---|
| 8608 | static FN_GetStringTypeW *pfn = 0;
|
|---|
| 8609 | if (!pfn)
|
|---|
| 8610 | kPrf2WrapResolve((void **)&pfn, "GetStringTypeW", &g_Kernel32);
|
|---|
| 8611 | return pfn( dwInfoType, lpSrcStr, cchSrc, lpCharType );
|
|---|
| 8612 | }
|
|---|
| 8613 |
|
|---|
| 8614 | typedef int WINAPI FN_FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest );
|
|---|
| 8615 | __declspec(dllexport) int WINAPI kPrf2Wrap_FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest )
|
|---|
| 8616 | {
|
|---|
| 8617 | static FN_FoldStringA *pfn = 0;
|
|---|
| 8618 | if (!pfn)
|
|---|
| 8619 | kPrf2WrapResolve((void **)&pfn, "FoldStringA", &g_Kernel32);
|
|---|
| 8620 | return pfn( dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
|
|---|
| 8621 | }
|
|---|
| 8622 |
|
|---|
| 8623 | typedef int WINAPI FN_FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest );
|
|---|
| 8624 | __declspec(dllexport) int WINAPI kPrf2Wrap_FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest )
|
|---|
| 8625 | {
|
|---|
| 8626 | static FN_FoldStringW *pfn = 0;
|
|---|
| 8627 | if (!pfn)
|
|---|
| 8628 | kPrf2WrapResolve((void **)&pfn, "FoldStringW", &g_Kernel32);
|
|---|
| 8629 | return pfn( dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
|
|---|
| 8630 | }
|
|---|
| 8631 |
|
|---|
| 8632 | typedef BOOL WINAPI FN_EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8633 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8634 | {
|
|---|
| 8635 | static FN_EnumSystemLanguageGroupsA *pfn = 0;
|
|---|
| 8636 | if (!pfn)
|
|---|
| 8637 | kPrf2WrapResolve((void **)&pfn, "EnumSystemLanguageGroupsA", &g_Kernel32);
|
|---|
| 8638 | return pfn( lpLanguageGroupEnumProc, dwFlags, lParam );
|
|---|
| 8639 | }
|
|---|
| 8640 |
|
|---|
| 8641 | typedef BOOL WINAPI FN_EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8642 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8643 | {
|
|---|
| 8644 | static FN_EnumSystemLanguageGroupsW *pfn = 0;
|
|---|
| 8645 | if (!pfn)
|
|---|
| 8646 | kPrf2WrapResolve((void **)&pfn, "EnumSystemLanguageGroupsW", &g_Kernel32);
|
|---|
| 8647 | return pfn( lpLanguageGroupEnumProc, dwFlags, lParam );
|
|---|
| 8648 | }
|
|---|
| 8649 |
|
|---|
| 8650 | typedef BOOL WINAPI FN_EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8651 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8652 | {
|
|---|
| 8653 | static FN_EnumLanguageGroupLocalesA *pfn = 0;
|
|---|
| 8654 | if (!pfn)
|
|---|
| 8655 | kPrf2WrapResolve((void **)&pfn, "EnumLanguageGroupLocalesA", &g_Kernel32);
|
|---|
| 8656 | return pfn( lpLangGroupLocaleEnumProc, LanguageGroup, dwFlags, lParam );
|
|---|
| 8657 | }
|
|---|
| 8658 |
|
|---|
| 8659 | typedef BOOL WINAPI FN_EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8660 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8661 | {
|
|---|
| 8662 | static FN_EnumLanguageGroupLocalesW *pfn = 0;
|
|---|
| 8663 | if (!pfn)
|
|---|
| 8664 | kPrf2WrapResolve((void **)&pfn, "EnumLanguageGroupLocalesW", &g_Kernel32);
|
|---|
| 8665 | return pfn( lpLangGroupLocaleEnumProc, LanguageGroup, dwFlags, lParam );
|
|---|
| 8666 | }
|
|---|
| 8667 |
|
|---|
| 8668 | typedef BOOL WINAPI FN_EnumUILanguagesA( UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8669 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumUILanguagesA( UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8670 | {
|
|---|
| 8671 | static FN_EnumUILanguagesA *pfn = 0;
|
|---|
| 8672 | if (!pfn)
|
|---|
| 8673 | kPrf2WrapResolve((void **)&pfn, "EnumUILanguagesA", &g_Kernel32);
|
|---|
| 8674 | return pfn( lpUILanguageEnumProc, dwFlags, lParam );
|
|---|
| 8675 | }
|
|---|
| 8676 |
|
|---|
| 8677 | typedef BOOL WINAPI FN_EnumUILanguagesW( UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam );
|
|---|
| 8678 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumUILanguagesW( UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam )
|
|---|
| 8679 | {
|
|---|
| 8680 | static FN_EnumUILanguagesW *pfn = 0;
|
|---|
| 8681 | if (!pfn)
|
|---|
| 8682 | kPrf2WrapResolve((void **)&pfn, "EnumUILanguagesW", &g_Kernel32);
|
|---|
| 8683 | return pfn( lpUILanguageEnumProc, dwFlags, lParam );
|
|---|
| 8684 | }
|
|---|
| 8685 |
|
|---|
| 8686 | typedef BOOL WINAPI FN_EnumSystemLocalesA( LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags );
|
|---|
| 8687 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLocalesA( LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags )
|
|---|
| 8688 | {
|
|---|
| 8689 | static FN_EnumSystemLocalesA *pfn = 0;
|
|---|
| 8690 | if (!pfn)
|
|---|
| 8691 | kPrf2WrapResolve((void **)&pfn, "EnumSystemLocalesA", &g_Kernel32);
|
|---|
| 8692 | return pfn( lpLocaleEnumProc, dwFlags );
|
|---|
| 8693 | }
|
|---|
| 8694 |
|
|---|
| 8695 | typedef BOOL WINAPI FN_EnumSystemLocalesW( LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags );
|
|---|
| 8696 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLocalesW( LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags )
|
|---|
| 8697 | {
|
|---|
| 8698 | static FN_EnumSystemLocalesW *pfn = 0;
|
|---|
| 8699 | if (!pfn)
|
|---|
| 8700 | kPrf2WrapResolve((void **)&pfn, "EnumSystemLocalesW", &g_Kernel32);
|
|---|
| 8701 | return pfn( lpLocaleEnumProc, dwFlags );
|
|---|
| 8702 | }
|
|---|
| 8703 |
|
|---|
| 8704 | typedef BOOL WINAPI FN_EnumSystemCodePagesA( CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags );
|
|---|
| 8705 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemCodePagesA( CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags )
|
|---|
| 8706 | {
|
|---|
| 8707 | static FN_EnumSystemCodePagesA *pfn = 0;
|
|---|
| 8708 | if (!pfn)
|
|---|
| 8709 | kPrf2WrapResolve((void **)&pfn, "EnumSystemCodePagesA", &g_Kernel32);
|
|---|
| 8710 | return pfn( lpCodePageEnumProc, dwFlags );
|
|---|
| 8711 | }
|
|---|
| 8712 |
|
|---|
| 8713 | typedef BOOL WINAPI FN_EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags );
|
|---|
| 8714 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags )
|
|---|
| 8715 | {
|
|---|
| 8716 | static FN_EnumSystemCodePagesW *pfn = 0;
|
|---|
| 8717 | if (!pfn)
|
|---|
| 8718 | kPrf2WrapResolve((void **)&pfn, "EnumSystemCodePagesW", &g_Kernel32);
|
|---|
| 8719 | return pfn( lpCodePageEnumProc, dwFlags );
|
|---|
| 8720 | }
|
|---|
| 8721 |
|
|---|
| 8722 | typedef DWORD APIENTRY FN_VerFindFileA( DWORD uFlags, LPSTR szFileName, LPSTR szWinDir, LPSTR szAppDir, LPSTR szCurDir, PUINT lpuCurDirLen, LPSTR szDestDir, PUINT lpuDestDirLen );
|
|---|
| 8723 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerFindFileA( DWORD uFlags, LPSTR szFileName, LPSTR szWinDir, LPSTR szAppDir, LPSTR szCurDir, PUINT lpuCurDirLen, LPSTR szDestDir, PUINT lpuDestDirLen )
|
|---|
| 8724 | {
|
|---|
| 8725 | static FN_VerFindFileA *pfn = 0;
|
|---|
| 8726 | if (!pfn)
|
|---|
| 8727 | kPrf2WrapResolve((void **)&pfn, "VerFindFileA", &g_Kernel32);
|
|---|
| 8728 | return pfn( uFlags, szFileName, szWinDir, szAppDir, szCurDir, lpuCurDirLen, szDestDir, lpuDestDirLen );
|
|---|
| 8729 | }
|
|---|
| 8730 |
|
|---|
| 8731 | typedef DWORD APIENTRY FN_VerFindFileW( DWORD uFlags, LPWSTR szFileName, LPWSTR szWinDir, LPWSTR szAppDir, LPWSTR szCurDir, PUINT lpuCurDirLen, LPWSTR szDestDir, PUINT lpuDestDirLen );
|
|---|
| 8732 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerFindFileW( DWORD uFlags, LPWSTR szFileName, LPWSTR szWinDir, LPWSTR szAppDir, LPWSTR szCurDir, PUINT lpuCurDirLen, LPWSTR szDestDir, PUINT lpuDestDirLen )
|
|---|
| 8733 | {
|
|---|
| 8734 | static FN_VerFindFileW *pfn = 0;
|
|---|
| 8735 | if (!pfn)
|
|---|
| 8736 | kPrf2WrapResolve((void **)&pfn, "VerFindFileW", &g_Kernel32);
|
|---|
| 8737 | return pfn( uFlags, szFileName, szWinDir, szAppDir, szCurDir, lpuCurDirLen, szDestDir, lpuDestDirLen );
|
|---|
| 8738 | }
|
|---|
| 8739 |
|
|---|
| 8740 | typedef DWORD APIENTRY FN_VerInstallFileA( DWORD uFlags, LPSTR szSrcFileName, LPSTR szDestFileName, LPSTR szSrcDir, LPSTR szDestDir, LPSTR szCurDir, LPSTR szTmpFile, PUINT lpuTmpFileLen );
|
|---|
| 8741 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerInstallFileA( DWORD uFlags, LPSTR szSrcFileName, LPSTR szDestFileName, LPSTR szSrcDir, LPSTR szDestDir, LPSTR szCurDir, LPSTR szTmpFile, PUINT lpuTmpFileLen )
|
|---|
| 8742 | {
|
|---|
| 8743 | static FN_VerInstallFileA *pfn = 0;
|
|---|
| 8744 | if (!pfn)
|
|---|
| 8745 | kPrf2WrapResolve((void **)&pfn, "VerInstallFileA", &g_Kernel32);
|
|---|
| 8746 | return pfn( uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile, lpuTmpFileLen );
|
|---|
| 8747 | }
|
|---|
| 8748 |
|
|---|
| 8749 | typedef DWORD APIENTRY FN_VerInstallFileW( DWORD uFlags, LPWSTR szSrcFileName, LPWSTR szDestFileName, LPWSTR szSrcDir, LPWSTR szDestDir, LPWSTR szCurDir, LPWSTR szTmpFile, PUINT lpuTmpFileLen );
|
|---|
| 8750 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerInstallFileW( DWORD uFlags, LPWSTR szSrcFileName, LPWSTR szDestFileName, LPWSTR szSrcDir, LPWSTR szDestDir, LPWSTR szCurDir, LPWSTR szTmpFile, PUINT lpuTmpFileLen )
|
|---|
| 8751 | {
|
|---|
| 8752 | static FN_VerInstallFileW *pfn = 0;
|
|---|
| 8753 | if (!pfn)
|
|---|
| 8754 | kPrf2WrapResolve((void **)&pfn, "VerInstallFileW", &g_Kernel32);
|
|---|
| 8755 | return pfn( uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile, lpuTmpFileLen );
|
|---|
| 8756 | }
|
|---|
| 8757 |
|
|---|
| 8758 | typedef DWORD APIENTRY FN_GetFileVersionInfoSizeA( LPCSTR lptstrFilename, LPDWORD lpdwHandle );
|
|---|
| 8759 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetFileVersionInfoSizeA( LPCSTR lptstrFilename, LPDWORD lpdwHandle )
|
|---|
| 8760 | {
|
|---|
| 8761 | static FN_GetFileVersionInfoSizeA *pfn = 0;
|
|---|
| 8762 | if (!pfn)
|
|---|
| 8763 | kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoSizeA", &g_Kernel32);
|
|---|
| 8764 | return pfn( lptstrFilename, lpdwHandle );
|
|---|
| 8765 | }
|
|---|
| 8766 |
|
|---|
| 8767 | typedef DWORD APIENTRY FN_GetFileVersionInfoSizeW( LPCWSTR lptstrFilename, LPDWORD lpdwHandle );
|
|---|
| 8768 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetFileVersionInfoSizeW( LPCWSTR lptstrFilename, LPDWORD lpdwHandle )
|
|---|
| 8769 | {
|
|---|
| 8770 | static FN_GetFileVersionInfoSizeW *pfn = 0;
|
|---|
| 8771 | if (!pfn)
|
|---|
| 8772 | kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoSizeW", &g_Kernel32);
|
|---|
| 8773 | return pfn( lptstrFilename, lpdwHandle );
|
|---|
| 8774 | }
|
|---|
| 8775 |
|
|---|
| 8776 | typedef BOOL APIENTRY FN_GetFileVersionInfoA( LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData );
|
|---|
| 8777 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetFileVersionInfoA( LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData )
|
|---|
| 8778 | {
|
|---|
| 8779 | static FN_GetFileVersionInfoA *pfn = 0;
|
|---|
| 8780 | if (!pfn)
|
|---|
| 8781 | kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoA", &g_Kernel32);
|
|---|
| 8782 | return pfn( lptstrFilename, dwHandle, dwLen, lpData );
|
|---|
| 8783 | }
|
|---|
| 8784 |
|
|---|
| 8785 | typedef BOOL APIENTRY FN_GetFileVersionInfoW( LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData );
|
|---|
| 8786 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetFileVersionInfoW( LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData )
|
|---|
| 8787 | {
|
|---|
| 8788 | static FN_GetFileVersionInfoW *pfn = 0;
|
|---|
| 8789 | if (!pfn)
|
|---|
| 8790 | kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoW", &g_Kernel32);
|
|---|
| 8791 | return pfn( lptstrFilename, dwHandle, dwLen, lpData );
|
|---|
| 8792 | }
|
|---|
| 8793 |
|
|---|
| 8794 | typedef DWORD APIENTRY FN_VerLanguageNameA( DWORD wLang, LPSTR szLang, DWORD nSize );
|
|---|
| 8795 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerLanguageNameA( DWORD wLang, LPSTR szLang, DWORD nSize )
|
|---|
| 8796 | {
|
|---|
| 8797 | static FN_VerLanguageNameA *pfn = 0;
|
|---|
| 8798 | if (!pfn)
|
|---|
| 8799 | kPrf2WrapResolve((void **)&pfn, "VerLanguageNameA", &g_Kernel32);
|
|---|
| 8800 | return pfn( wLang, szLang, nSize );
|
|---|
| 8801 | }
|
|---|
| 8802 |
|
|---|
| 8803 | typedef DWORD APIENTRY FN_VerLanguageNameW( DWORD wLang, LPWSTR szLang, DWORD nSize );
|
|---|
| 8804 | __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerLanguageNameW( DWORD wLang, LPWSTR szLang, DWORD nSize )
|
|---|
| 8805 | {
|
|---|
| 8806 | static FN_VerLanguageNameW *pfn = 0;
|
|---|
| 8807 | if (!pfn)
|
|---|
| 8808 | kPrf2WrapResolve((void **)&pfn, "VerLanguageNameW", &g_Kernel32);
|
|---|
| 8809 | return pfn( wLang, szLang, nSize );
|
|---|
| 8810 | }
|
|---|
| 8811 |
|
|---|
| 8812 | typedef BOOL APIENTRY FN_VerQueryValueA( const LPVOID pBlock, LPSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen );
|
|---|
| 8813 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_VerQueryValueA( const LPVOID pBlock, LPSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen )
|
|---|
| 8814 | {
|
|---|
| 8815 | static FN_VerQueryValueA *pfn = 0;
|
|---|
| 8816 | if (!pfn)
|
|---|
| 8817 | kPrf2WrapResolve((void **)&pfn, "VerQueryValueA", &g_Kernel32);
|
|---|
| 8818 | return pfn( pBlock, lpSubBlock, lplpBuffer, puLen );
|
|---|
| 8819 | }
|
|---|
| 8820 |
|
|---|
| 8821 | typedef BOOL APIENTRY FN_VerQueryValueW( const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen );
|
|---|
| 8822 | __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_VerQueryValueW( const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen )
|
|---|
| 8823 | {
|
|---|
| 8824 | static FN_VerQueryValueW *pfn = 0;
|
|---|
| 8825 | if (!pfn)
|
|---|
| 8826 | kPrf2WrapResolve((void **)&pfn, "VerQueryValueW", &g_Kernel32);
|
|---|
| 8827 | return pfn( pBlock, lpSubBlock, lplpBuffer, puLen );
|
|---|
| 8828 | }
|
|---|
| 8829 |
|
|---|
| 8830 | typedef VOID __cdecl FN_RtlRestoreContext( IN PCONTEXT ContextRecord, IN struct _EXCEPTION_RECORD * ExceptionRecord );
|
|---|
| 8831 | __declspec(dllexport) VOID __cdecl kPrf2Wrap_RtlRestoreContext( IN PCONTEXT ContextRecord, IN struct _EXCEPTION_RECORD * ExceptionRecord )
|
|---|
| 8832 | {
|
|---|
| 8833 | static FN_RtlRestoreContext *pfn = 0;
|
|---|
| 8834 | if (!pfn)
|
|---|
| 8835 | kPrf2WrapResolve((void **)&pfn, "RtlRestoreContext", &g_Kernel32);
|
|---|
| 8836 | pfn( ContextRecord, ExceptionRecord );
|
|---|
| 8837 | }
|
|---|
| 8838 |
|
|---|
| 8839 | typedef BOOLEAN __cdecl FN_RtlAddFunctionTable( IN PRUNTIME_FUNCTION FunctionTable, IN DWORD EntryCount, IN DWORD64 BaseAddress );
|
|---|
| 8840 | __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlAddFunctionTable( IN PRUNTIME_FUNCTION FunctionTable, IN DWORD EntryCount, IN DWORD64 BaseAddress )
|
|---|
| 8841 | {
|
|---|
| 8842 | static FN_RtlAddFunctionTable *pfn = 0;
|
|---|
| 8843 | if (!pfn)
|
|---|
| 8844 | kPrf2WrapResolve((void **)&pfn, "RtlAddFunctionTable", &g_Kernel32);
|
|---|
| 8845 | return pfn( FunctionTable, EntryCount, BaseAddress );
|
|---|
| 8846 | }
|
|---|
| 8847 |
|
|---|
| 8848 | typedef BOOLEAN __cdecl FN_RtlInstallFunctionTableCallback( IN DWORD64 TableIdentifier, IN DWORD64 BaseAddress, IN DWORD Length, IN PGET_RUNTIME_FUNCTION_CALLBACK Callback, IN PVOID Context, IN PCWSTR OutOfProcessCallbackDll );
|
|---|
| 8849 | __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlInstallFunctionTableCallback( IN DWORD64 TableIdentifier, IN DWORD64 BaseAddress, IN DWORD Length, IN PGET_RUNTIME_FUNCTION_CALLBACK Callback, IN PVOID Context, IN PCWSTR OutOfProcessCallbackDll )
|
|---|
| 8850 | {
|
|---|
| 8851 | static FN_RtlInstallFunctionTableCallback *pfn = 0;
|
|---|
| 8852 | if (!pfn)
|
|---|
| 8853 | kPrf2WrapResolve((void **)&pfn, "RtlInstallFunctionTableCallback", &g_Kernel32);
|
|---|
| 8854 | return pfn( TableIdentifier, BaseAddress, Length, Callback, Context, OutOfProcessCallbackDll );
|
|---|
| 8855 | }
|
|---|
| 8856 |
|
|---|
| 8857 | typedef BOOLEAN __cdecl FN_RtlDeleteFunctionTable( IN PRUNTIME_FUNCTION FunctionTable );
|
|---|
| 8858 | __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlDeleteFunctionTable( IN PRUNTIME_FUNCTION FunctionTable )
|
|---|
| 8859 | {
|
|---|
| 8860 | static FN_RtlDeleteFunctionTable *pfn = 0;
|
|---|
| 8861 | if (!pfn)
|
|---|
| 8862 | kPrf2WrapResolve((void **)&pfn, "RtlDeleteFunctionTable", &g_Kernel32);
|
|---|
| 8863 | return pfn( FunctionTable );
|
|---|
| 8864 | }
|
|---|
| 8865 |
|
|---|
| 8866 | typedef VOID NTAPI FN_RtlInitializeSListHead( IN PSLIST_HEADER ListHead );
|
|---|
| 8867 | __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlInitializeSListHead( IN PSLIST_HEADER ListHead )
|
|---|
| 8868 | {
|
|---|
| 8869 | static FN_RtlInitializeSListHead *pfn = 0;
|
|---|
| 8870 | if (!pfn)
|
|---|
| 8871 | kPrf2WrapResolve((void **)&pfn, "RtlInitializeSListHead", &g_Kernel32);
|
|---|
| 8872 | pfn( ListHead );
|
|---|
| 8873 | }
|
|---|
| 8874 |
|
|---|
| 8875 | typedef PSLIST_ENTRY NTAPI FN_RtlFirstEntrySList( IN const SLIST_HEADER * ListHead );
|
|---|
| 8876 | __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlFirstEntrySList( IN const SLIST_HEADER * ListHead )
|
|---|
| 8877 | {
|
|---|
| 8878 | static FN_RtlFirstEntrySList *pfn = 0;
|
|---|
| 8879 | if (!pfn)
|
|---|
| 8880 | kPrf2WrapResolve((void **)&pfn, "RtlFirstEntrySList", &g_Kernel32);
|
|---|
| 8881 | return pfn( ListHead );
|
|---|
| 8882 | }
|
|---|
| 8883 |
|
|---|
| 8884 | typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedPopEntrySList( IN PSLIST_HEADER ListHead );
|
|---|
| 8885 | __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedPopEntrySList( IN PSLIST_HEADER ListHead )
|
|---|
| 8886 | {
|
|---|
| 8887 | static FN_RtlInterlockedPopEntrySList *pfn = 0;
|
|---|
| 8888 | if (!pfn)
|
|---|
| 8889 | kPrf2WrapResolve((void **)&pfn, "RtlInterlockedPopEntrySList", &g_Kernel32);
|
|---|
| 8890 | return pfn( ListHead );
|
|---|
| 8891 | }
|
|---|
| 8892 |
|
|---|
| 8893 | typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedPushEntrySList( IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry );
|
|---|
| 8894 | __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedPushEntrySList( IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry )
|
|---|
| 8895 | {
|
|---|
| 8896 | static FN_RtlInterlockedPushEntrySList *pfn = 0;
|
|---|
| 8897 | if (!pfn)
|
|---|
| 8898 | kPrf2WrapResolve((void **)&pfn, "RtlInterlockedPushEntrySList", &g_Kernel32);
|
|---|
| 8899 | return pfn( ListHead, ListEntry );
|
|---|
| 8900 | }
|
|---|
| 8901 |
|
|---|
| 8902 | typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedFlushSList( IN PSLIST_HEADER ListHead );
|
|---|
| 8903 | __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedFlushSList( IN PSLIST_HEADER ListHead )
|
|---|
| 8904 | {
|
|---|
| 8905 | static FN_RtlInterlockedFlushSList *pfn = 0;
|
|---|
| 8906 | if (!pfn)
|
|---|
| 8907 | kPrf2WrapResolve((void **)&pfn, "RtlInterlockedFlushSList", &g_Kernel32);
|
|---|
| 8908 | return pfn( ListHead );
|
|---|
| 8909 | }
|
|---|
| 8910 |
|
|---|
| 8911 | typedef WORD NTAPI FN_RtlQueryDepthSList( IN PSLIST_HEADER ListHead );
|
|---|
| 8912 | __declspec(dllexport) WORD NTAPI kPrf2Wrap_RtlQueryDepthSList( IN PSLIST_HEADER ListHead )
|
|---|
| 8913 | {
|
|---|
| 8914 | static FN_RtlQueryDepthSList *pfn = 0;
|
|---|
| 8915 | if (!pfn)
|
|---|
| 8916 | kPrf2WrapResolve((void **)&pfn, "RtlQueryDepthSList", &g_Kernel32);
|
|---|
| 8917 | return pfn( ListHead );
|
|---|
| 8918 | }
|
|---|
| 8919 |
|
|---|
| 8920 | typedef VOID NTAPI FN_RtlCaptureContext( OUT PCONTEXT ContextRecord );
|
|---|
| 8921 | __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlCaptureContext( OUT PCONTEXT ContextRecord )
|
|---|
| 8922 | {
|
|---|
| 8923 | static FN_RtlCaptureContext *pfn = 0;
|
|---|
| 8924 | if (!pfn)
|
|---|
| 8925 | kPrf2WrapResolve((void **)&pfn, "RtlCaptureContext", &g_Kernel32);
|
|---|
| 8926 | pfn( ContextRecord );
|
|---|
| 8927 | }
|
|---|
| 8928 |
|
|---|
| 8929 | typedef SIZE_T NTAPI FN_RtlCompareMemory( const VOID * Source1, const VOID * Source2, SIZE_T Length );
|
|---|
| 8930 | __declspec(dllexport) SIZE_T NTAPI kPrf2Wrap_RtlCompareMemory( const VOID * Source1, const VOID * Source2, SIZE_T Length )
|
|---|
| 8931 | {
|
|---|
| 8932 | static FN_RtlCompareMemory *pfn = 0;
|
|---|
| 8933 | if (!pfn)
|
|---|
| 8934 | kPrf2WrapResolve((void **)&pfn, "RtlCompareMemory", &g_Kernel32);
|
|---|
| 8935 | return pfn( Source1, Source2, Length );
|
|---|
| 8936 | }
|
|---|
| 8937 |
|
|---|
| 8938 | typedef ULONGLONG NTAPI FN_VerSetConditionMask( IN ULONGLONG ConditionMask, IN DWORD TypeMask, IN BYTE Condition );
|
|---|
| 8939 | __declspec(dllexport) ULONGLONG NTAPI kPrf2Wrap_VerSetConditionMask( IN ULONGLONG ConditionMask, IN DWORD TypeMask, IN BYTE Condition )
|
|---|
| 8940 | {
|
|---|
| 8941 | static FN_VerSetConditionMask *pfn = 0;
|
|---|
| 8942 | if (!pfn)
|
|---|
| 8943 | kPrf2WrapResolve((void **)&pfn, "VerSetConditionMask", &g_Kernel32);
|
|---|
| 8944 | return pfn( ConditionMask, TypeMask, Condition );
|
|---|
| 8945 | }
|
|---|
| 8946 |
|
|---|
| 8947 | typedef DWORD NTAPI FN_RtlSetHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, IN PVOID HeapInformation , IN SIZE_T HeapInformationLength );
|
|---|
| 8948 | __declspec(dllexport) DWORD NTAPI kPrf2Wrap_RtlSetHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, IN PVOID HeapInformation , IN SIZE_T HeapInformationLength )
|
|---|
| 8949 | {
|
|---|
| 8950 | static FN_RtlSetHeapInformation *pfn = 0;
|
|---|
| 8951 | if (!pfn)
|
|---|
| 8952 | kPrf2WrapResolve((void **)&pfn, "RtlSetHeapInformation", &g_Kernel32);
|
|---|
| 8953 | return pfn( HeapHandle, HeapInformationClass, HeapInformation , HeapInformationLength );
|
|---|
| 8954 | }
|
|---|
| 8955 |
|
|---|
| 8956 | typedef DWORD NTAPI FN_RtlQueryHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, OUT PVOID HeapInformation , IN SIZE_T HeapInformationLength , OUT PSIZE_T ReturnLength );
|
|---|
| 8957 | __declspec(dllexport) DWORD NTAPI kPrf2Wrap_RtlQueryHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, OUT PVOID HeapInformation , IN SIZE_T HeapInformationLength , OUT PSIZE_T ReturnLength )
|
|---|
| 8958 | {
|
|---|
| 8959 | static FN_RtlQueryHeapInformation *pfn = 0;
|
|---|
| 8960 | if (!pfn)
|
|---|
| 8961 | kPrf2WrapResolve((void **)&pfn, "RtlQueryHeapInformation", &g_Kernel32);
|
|---|
| 8962 | return pfn( HeapHandle, HeapInformationClass, HeapInformation , HeapInformationLength , ReturnLength );
|
|---|
| 8963 | }
|
|---|
| 8964 |
|
|---|
| 8965 | typedef HANDLE WINAPI FN_CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID );
|
|---|
| 8966 | __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID )
|
|---|
| 8967 | {
|
|---|
| 8968 | static FN_CreateToolhelp32Snapshot *pfn = 0;
|
|---|
| 8969 | if (!pfn)
|
|---|
| 8970 | kPrf2WrapResolve((void **)&pfn, "CreateToolhelp32Snapshot", &g_Kernel32);
|
|---|
| 8971 | return pfn( dwFlags, th32ProcessID );
|
|---|
| 8972 | }
|
|---|
| 8973 |
|
|---|
| 8974 | typedef BOOL WINAPI FN_Heap32ListFirst( HANDLE hSnapshot, LPHEAPLIST32 lphl );
|
|---|
| 8975 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32ListFirst( HANDLE hSnapshot, LPHEAPLIST32 lphl )
|
|---|
| 8976 | {
|
|---|
| 8977 | static FN_Heap32ListFirst *pfn = 0;
|
|---|
| 8978 | if (!pfn)
|
|---|
| 8979 | kPrf2WrapResolve((void **)&pfn, "Heap32ListFirst", &g_Kernel32);
|
|---|
| 8980 | return pfn( hSnapshot, lphl );
|
|---|
| 8981 | }
|
|---|
| 8982 |
|
|---|
| 8983 | typedef BOOL WINAPI FN_Heap32ListNext( HANDLE hSnapshot, LPHEAPLIST32 lphl );
|
|---|
| 8984 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32ListNext( HANDLE hSnapshot, LPHEAPLIST32 lphl )
|
|---|
| 8985 | {
|
|---|
| 8986 | static FN_Heap32ListNext *pfn = 0;
|
|---|
| 8987 | if (!pfn)
|
|---|
| 8988 | kPrf2WrapResolve((void **)&pfn, "Heap32ListNext", &g_Kernel32);
|
|---|
| 8989 | return pfn( hSnapshot, lphl );
|
|---|
| 8990 | }
|
|---|
| 8991 |
|
|---|
| 8992 | typedef BOOL WINAPI FN_Heap32First( LPHEAPENTRY32 lphe, DWORD th32ProcessID, ULONG_PTR th32HeapID );
|
|---|
| 8993 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32First( LPHEAPENTRY32 lphe, DWORD th32ProcessID, ULONG_PTR th32HeapID )
|
|---|
| 8994 | {
|
|---|
| 8995 | static FN_Heap32First *pfn = 0;
|
|---|
| 8996 | if (!pfn)
|
|---|
| 8997 | kPrf2WrapResolve((void **)&pfn, "Heap32First", &g_Kernel32);
|
|---|
| 8998 | return pfn( lphe, th32ProcessID, th32HeapID );
|
|---|
| 8999 | }
|
|---|
| 9000 |
|
|---|
| 9001 | typedef BOOL WINAPI FN_Heap32Next( LPHEAPENTRY32 lphe );
|
|---|
| 9002 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32Next( LPHEAPENTRY32 lphe )
|
|---|
| 9003 | {
|
|---|
| 9004 | static FN_Heap32Next *pfn = 0;
|
|---|
| 9005 | if (!pfn)
|
|---|
| 9006 | kPrf2WrapResolve((void **)&pfn, "Heap32Next", &g_Kernel32);
|
|---|
| 9007 | return pfn( lphe );
|
|---|
| 9008 | }
|
|---|
| 9009 |
|
|---|
| 9010 | typedef BOOL WINAPI FN_Toolhelp32ReadProcessMemory( DWORD th32ProcessID, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T cbRead, SIZE_T * lpNumberOfBytesRead );
|
|---|
| 9011 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Toolhelp32ReadProcessMemory( DWORD th32ProcessID, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T cbRead, SIZE_T * lpNumberOfBytesRead )
|
|---|
| 9012 | {
|
|---|
| 9013 | static FN_Toolhelp32ReadProcessMemory *pfn = 0;
|
|---|
| 9014 | if (!pfn)
|
|---|
| 9015 | kPrf2WrapResolve((void **)&pfn, "Toolhelp32ReadProcessMemory", &g_Kernel32);
|
|---|
| 9016 | return pfn( th32ProcessID, lpBaseAddress, lpBuffer, cbRead, lpNumberOfBytesRead );
|
|---|
| 9017 | }
|
|---|
| 9018 |
|
|---|
| 9019 | typedef BOOL WINAPI FN_Process32FirstW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe );
|
|---|
| 9020 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32FirstW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe )
|
|---|
| 9021 | {
|
|---|
| 9022 | static FN_Process32FirstW *pfn = 0;
|
|---|
| 9023 | if (!pfn)
|
|---|
| 9024 | kPrf2WrapResolve((void **)&pfn, "Process32FirstW", &g_Kernel32);
|
|---|
| 9025 | return pfn( hSnapshot, lppe );
|
|---|
| 9026 | }
|
|---|
| 9027 |
|
|---|
| 9028 | typedef BOOL WINAPI FN_Process32NextW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe );
|
|---|
| 9029 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32NextW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe )
|
|---|
| 9030 | {
|
|---|
| 9031 | static FN_Process32NextW *pfn = 0;
|
|---|
| 9032 | if (!pfn)
|
|---|
| 9033 | kPrf2WrapResolve((void **)&pfn, "Process32NextW", &g_Kernel32);
|
|---|
| 9034 | return pfn( hSnapshot, lppe );
|
|---|
| 9035 | }
|
|---|
| 9036 |
|
|---|
| 9037 | typedef BOOL WINAPI FN_Process32First( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );
|
|---|
| 9038 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32First( HANDLE hSnapshot, LPPROCESSENTRY32 lppe )
|
|---|
| 9039 | {
|
|---|
| 9040 | static FN_Process32First *pfn = 0;
|
|---|
| 9041 | if (!pfn)
|
|---|
| 9042 | kPrf2WrapResolve((void **)&pfn, "Process32First", &g_Kernel32);
|
|---|
| 9043 | return pfn( hSnapshot, lppe );
|
|---|
| 9044 | }
|
|---|
| 9045 |
|
|---|
| 9046 | typedef BOOL WINAPI FN_Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );
|
|---|
| 9047 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe )
|
|---|
| 9048 | {
|
|---|
| 9049 | static FN_Process32Next *pfn = 0;
|
|---|
| 9050 | if (!pfn)
|
|---|
| 9051 | kPrf2WrapResolve((void **)&pfn, "Process32Next", &g_Kernel32);
|
|---|
| 9052 | return pfn( hSnapshot, lppe );
|
|---|
| 9053 | }
|
|---|
| 9054 |
|
|---|
| 9055 | typedef BOOL WINAPI FN_Thread32First( HANDLE hSnapshot, LPTHREADENTRY32 lpte );
|
|---|
| 9056 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Thread32First( HANDLE hSnapshot, LPTHREADENTRY32 lpte )
|
|---|
| 9057 | {
|
|---|
| 9058 | static FN_Thread32First *pfn = 0;
|
|---|
| 9059 | if (!pfn)
|
|---|
| 9060 | kPrf2WrapResolve((void **)&pfn, "Thread32First", &g_Kernel32);
|
|---|
| 9061 | return pfn( hSnapshot, lpte );
|
|---|
| 9062 | }
|
|---|
| 9063 |
|
|---|
| 9064 | typedef BOOL WINAPI FN_Thread32Next( HANDLE hSnapshot, LPTHREADENTRY32 lpte );
|
|---|
| 9065 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Thread32Next( HANDLE hSnapshot, LPTHREADENTRY32 lpte )
|
|---|
| 9066 | {
|
|---|
| 9067 | static FN_Thread32Next *pfn = 0;
|
|---|
| 9068 | if (!pfn)
|
|---|
| 9069 | kPrf2WrapResolve((void **)&pfn, "Thread32Next", &g_Kernel32);
|
|---|
| 9070 | return pfn( hSnapshot, lpte );
|
|---|
| 9071 | }
|
|---|
| 9072 |
|
|---|
| 9073 | typedef BOOL WINAPI FN_Module32FirstW( HANDLE hSnapshot, LPMODULEENTRY32W lpme );
|
|---|
| 9074 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32FirstW( HANDLE hSnapshot, LPMODULEENTRY32W lpme )
|
|---|
| 9075 | {
|
|---|
| 9076 | static FN_Module32FirstW *pfn = 0;
|
|---|
| 9077 | if (!pfn)
|
|---|
| 9078 | kPrf2WrapResolve((void **)&pfn, "Module32FirstW", &g_Kernel32);
|
|---|
| 9079 | return pfn( hSnapshot, lpme );
|
|---|
| 9080 | }
|
|---|
| 9081 |
|
|---|
| 9082 | typedef BOOL WINAPI FN_Module32NextW( HANDLE hSnapshot, LPMODULEENTRY32W lpme );
|
|---|
| 9083 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32NextW( HANDLE hSnapshot, LPMODULEENTRY32W lpme )
|
|---|
| 9084 | {
|
|---|
| 9085 | static FN_Module32NextW *pfn = 0;
|
|---|
| 9086 | if (!pfn)
|
|---|
| 9087 | kPrf2WrapResolve((void **)&pfn, "Module32NextW", &g_Kernel32);
|
|---|
| 9088 | return pfn( hSnapshot, lpme );
|
|---|
| 9089 | }
|
|---|
| 9090 |
|
|---|
| 9091 | typedef BOOL WINAPI FN_Module32First( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
|
|---|
| 9092 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32First( HANDLE hSnapshot, LPMODULEENTRY32 lpme )
|
|---|
| 9093 | {
|
|---|
| 9094 | static FN_Module32First *pfn = 0;
|
|---|
| 9095 | if (!pfn)
|
|---|
| 9096 | kPrf2WrapResolve((void **)&pfn, "Module32First", &g_Kernel32);
|
|---|
| 9097 | return pfn( hSnapshot, lpme );
|
|---|
| 9098 | }
|
|---|
| 9099 |
|
|---|
| 9100 | typedef BOOL WINAPI FN_Module32Next( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
|
|---|
| 9101 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32Next( HANDLE hSnapshot, LPMODULEENTRY32 lpme )
|
|---|
| 9102 | {
|
|---|
| 9103 | static FN_Module32Next *pfn = 0;
|
|---|
| 9104 | if (!pfn)
|
|---|
| 9105 | kPrf2WrapResolve((void **)&pfn, "Module32Next", &g_Kernel32);
|
|---|
| 9106 | return pfn( hSnapshot, lpme );
|
|---|
| 9107 | }
|
|---|
| 9108 |
|
|---|
| 9109 | typedef BOOL WINAPI FN_ReplaceFile( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
|
|---|
| 9110 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFile( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
|
|---|
| 9111 | {
|
|---|
| 9112 | static FN_ReplaceFile *pfn = 0;
|
|---|
| 9113 | if (!pfn)
|
|---|
| 9114 | kPrf2WrapResolve((void **)&pfn, "ReplaceFile", &g_Kernel32);
|
|---|
| 9115 | return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
|
|---|
| 9116 | }
|
|---|
| 9117 |
|
|---|
| 9118 | typedef BOOL WINAPI FN_SetConsoleCursor( PVOID pvUnknown1, PVOID pvUnknown2 );
|
|---|
| 9119 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursor( PVOID pvUnknown1, PVOID pvUnknown2 )
|
|---|
| 9120 | {
|
|---|
| 9121 | static FN_SetConsoleCursor *pfn = 0;
|
|---|
| 9122 | if (!pfn)
|
|---|
| 9123 | kPrf2WrapResolve((void **)&pfn, "SetConsoleCursor", &g_Kernel32);
|
|---|
| 9124 | return pfn( pvUnknown1, pvUnknown2 );
|
|---|
| 9125 | }
|
|---|
| 9126 |
|
|---|
| 9127 | typedef LPCH WINAPI FN_GetEnvironmentStringsA( VOID );
|
|---|
| 9128 | __declspec(dllexport) LPCH WINAPI kPrf2Wrap_GetEnvironmentStringsA( VOID )
|
|---|
| 9129 | {
|
|---|
| 9130 | static FN_GetEnvironmentStringsA *pfn = 0;
|
|---|
| 9131 | if (!pfn)
|
|---|
| 9132 | kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStringsA", &g_Kernel32);
|
|---|
| 9133 | return pfn ();
|
|---|
| 9134 | }
|
|---|
| 9135 |
|
|---|
| 9136 | typedef BOOL WINAPI FN_GetBinaryType( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
|
|---|
| 9137 | __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryType( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
|
|---|
| 9138 | {
|
|---|
| 9139 | static FN_GetBinaryType *pfn = 0;
|
|---|
| 9140 | if (!pfn)
|
|---|
| 9141 | kPrf2WrapResolve((void **)&pfn, "GetBinaryType", &g_Kernel32);
|
|---|
| 9142 | return pfn( lpApplicationName, lpBinaryType );
|
|---|
| 9143 | }
|
|---|
| 9144 |
|
|---|
| 9145 | typedef WORD NTAPI FN_RtlCaptureStackBackTrace( DWORD FramesToSkip, DWORD FramesToCapture, PVOID * BackTrace, PDWORD BackTraceHash );
|
|---|
| 9146 | __declspec(dllexport) WORD NTAPI kPrf2Wrap_RtlCaptureStackBackTrace( DWORD FramesToSkip, DWORD FramesToCapture, PVOID * BackTrace, PDWORD BackTraceHash )
|
|---|
| 9147 | {
|
|---|
| 9148 | static FN_RtlCaptureStackBackTrace *pfn = 0;
|
|---|
| 9149 | if (!pfn)
|
|---|
| 9150 | kPrf2WrapResolve((void **)&pfn, "RtlCaptureStackBackTrace", &g_Kernel32);
|
|---|
| 9151 | return pfn( FramesToSkip, FramesToCapture, BackTrace, BackTraceHash );
|
|---|
| 9152 | }
|
|---|
| 9153 |
|
|---|
| 9154 | typedef PVOID FN_RtlFillMemory( PVOID pv, int ch, SIZE_T cb );
|
|---|
| 9155 | __declspec(dllexport) PVOID kPrf2Wrap_RtlFillMemory( PVOID pv, int ch, SIZE_T cb )
|
|---|
| 9156 | {
|
|---|
| 9157 | static FN_RtlFillMemory *pfn = 0;
|
|---|
| 9158 | if (!pfn)
|
|---|
| 9159 | kPrf2WrapResolve((void **)&pfn, "RtlFillMemory", &g_Kernel32);
|
|---|
| 9160 | return pfn( pv, ch, cb );
|
|---|
| 9161 | }
|
|---|
| 9162 |
|
|---|
| 9163 | typedef PVOID FN_RtlZeroMemory( PVOID pv, SIZE_T cb );
|
|---|
| 9164 | __declspec(dllexport) PVOID kPrf2Wrap_RtlZeroMemory( PVOID pv, SIZE_T cb )
|
|---|
| 9165 | {
|
|---|
| 9166 | static FN_RtlZeroMemory *pfn = 0;
|
|---|
| 9167 | if (!pfn)
|
|---|
| 9168 | kPrf2WrapResolve((void **)&pfn, "RtlZeroMemory", &g_Kernel32);
|
|---|
| 9169 | return pfn( pv, cb );
|
|---|
| 9170 | }
|
|---|
| 9171 |
|
|---|
| 9172 | typedef PVOID FN_RtlMoveMemory( PVOID pvDst, PVOID pvSrc, SIZE_T cb );
|
|---|
| 9173 | __declspec(dllexport) PVOID kPrf2Wrap_RtlMoveMemory( PVOID pvDst, PVOID pvSrc, SIZE_T cb )
|
|---|
| 9174 | {
|
|---|
| 9175 | static FN_RtlMoveMemory *pfn = 0;
|
|---|
| 9176 | if (!pfn)
|
|---|
| 9177 | kPrf2WrapResolve((void **)&pfn, "RtlMoveMemory", &g_Kernel32);
|
|---|
| 9178 | return pfn( pvDst, pvSrc, cb );
|
|---|
| 9179 | }
|
|---|
| 9180 |
|
|---|
| 9181 | typedef VOID NTAPI FN_RtlUnwind( PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue );
|
|---|
| 9182 | __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlUnwind( PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue )
|
|---|
| 9183 | {
|
|---|
| 9184 | static FN_RtlUnwind *pfn = 0;
|
|---|
| 9185 | if (!pfn)
|
|---|
| 9186 | kPrf2WrapResolve((void **)&pfn, "RtlUnwind", &g_Kernel32);
|
|---|
| 9187 | pfn( TargetFrame, TargetIp, ExceptionRecord, ReturnValue );
|
|---|
| 9188 | }
|
|---|
| 9189 |
|
|---|
| 9190 | typedef VOID NTAPI FN_RtlUnwindEx( FRAME_POINTERS TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PUNWIND_HISTORY_TABLE HistoryTable );
|
|---|
| 9191 | __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlUnwindEx( FRAME_POINTERS TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PUNWIND_HISTORY_TABLE HistoryTable )
|
|---|
| 9192 | {
|
|---|
| 9193 | static FN_RtlUnwindEx *pfn = 0;
|
|---|
| 9194 | if (!pfn)
|
|---|
| 9195 | kPrf2WrapResolve((void **)&pfn, "RtlUnwindEx", &g_Kernel32);
|
|---|
| 9196 | pfn( TargetFrame, TargetIp, ExceptionRecord, ReturnValue, ContextRecord, HistoryTable );
|
|---|
| 9197 | }
|
|---|
| 9198 |
|
|---|
| 9199 | typedef ULONGLONG WINAPI FN_RtlVirtualUnwind( ULONG HandlerType, ULONGLONG ImageBase, ULONGLONG ControlPC, PRUNTIME_FUNCTION FunctionEntry, PCONTEXT ContextRecord, PBOOLEAN InFunction, PFRAME_POINTERS EstablisherFrame, PKNONVOLATILE_CONTEXT_POINTERS ContextPointers );
|
|---|
| 9200 | __declspec(dllexport) ULONGLONG WINAPI kPrf2Wrap_RtlVirtualUnwind( ULONG HandlerType, ULONGLONG ImageBase, ULONGLONG ControlPC, PRUNTIME_FUNCTION FunctionEntry, PCONTEXT ContextRecord, PBOOLEAN InFunction, PFRAME_POINTERS EstablisherFrame, PKNONVOLATILE_CONTEXT_POINTERS ContextPointers )
|
|---|
| 9201 | {
|
|---|
| 9202 | static FN_RtlVirtualUnwind *pfn = 0;
|
|---|
| 9203 | if (!pfn)
|
|---|
| 9204 | kPrf2WrapResolve((void **)&pfn, "RtlVirtualUnwind", &g_Kernel32);
|
|---|
| 9205 | return pfn( HandlerType, ImageBase, ControlPC, FunctionEntry, ContextRecord, InFunction, EstablisherFrame, ContextPointers );
|
|---|
| 9206 | }
|
|---|
| 9207 |
|
|---|
| 9208 | typedef PVOID WINAPI FN_RtlPcToFileHeader( PVOID PcValue, PVOID * BaseOfImage );
|
|---|
| 9209 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_RtlPcToFileHeader( PVOID PcValue, PVOID * BaseOfImage )
|
|---|
| 9210 | {
|
|---|
| 9211 | static FN_RtlPcToFileHeader *pfn = 0;
|
|---|
| 9212 | if (!pfn)
|
|---|
| 9213 | kPrf2WrapResolve((void **)&pfn, "RtlPcToFileHeader", &g_Kernel32);
|
|---|
| 9214 | return pfn( PcValue, BaseOfImage );
|
|---|
| 9215 | }
|
|---|
| 9216 |
|
|---|
| 9217 | typedef PVOID WINAPI FN_RtlLookupFunctionEntry( ULONGLONG ControlPC, PULONGLONG ImageBase, PULONGLONG TargetGp );
|
|---|
| 9218 | __declspec(dllexport) PVOID WINAPI kPrf2Wrap_RtlLookupFunctionEntry( ULONGLONG ControlPC, PULONGLONG ImageBase, PULONGLONG TargetGp )
|
|---|
| 9219 | {
|
|---|
| 9220 | static FN_RtlLookupFunctionEntry *pfn = 0;
|
|---|
| 9221 | if (!pfn)
|
|---|
| 9222 | kPrf2WrapResolve((void **)&pfn, "RtlLookupFunctionEntry", &g_Kernel32);
|
|---|
| 9223 | return pfn( ControlPC, ImageBase, TargetGp );
|
|---|
| 9224 | }
|
|---|
| 9225 |
|
|---|
| 9226 | typedef void WINAPI FN_RtlRaiseException(PEXCEPTION_RECORD pXcpRec);
|
|---|
| 9227 | __declspec(dllexport) void WINAPI kPrf2Wrap_RtlRaiseException(PEXCEPTION_RECORD pXcpRec)
|
|---|
| 9228 | {
|
|---|
| 9229 | static FN_RtlRaiseException *pfn = 0;
|
|---|
| 9230 | if (!pfn)
|
|---|
| 9231 | kPrf2WrapResolve((void **)&pfn, "RtlRaiseException", &g_Kernel32);
|
|---|
| 9232 | pfn( pXcpRec);
|
|---|
| 9233 | }
|
|---|
| 9234 |
|
|---|
| 9235 | typedef int WINAPI FN_uaw_lstrcmpW( LPCUWSTR lpString1, LPCUWSTR lpString2 );
|
|---|
| 9236 | __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrcmpW( LPCUWSTR lpString1, LPCUWSTR lpString2 )
|
|---|
| 9237 | {
|
|---|
| 9238 | static FN_uaw_lstrcmpW *pfn = 0;
|
|---|
| 9239 | if (!pfn)
|
|---|
| 9240 | kPrf2WrapResolve((void **)&pfn, "uaw_lstrcmpW", &g_Kernel32);
|
|---|
| 9241 | return pfn( lpString1, lpString2 );
|
|---|
| 9242 | }
|
|---|
| 9243 |
|
|---|
| 9244 | typedef int WINAPI FN_uaw_lstrcmpiW( LPCUWSTR lpString1, LPCUWSTR lpString2 );
|
|---|
| 9245 | __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrcmpiW( LPCUWSTR lpString1, LPCUWSTR lpString2 )
|
|---|
| 9246 | {
|
|---|
| 9247 | static FN_uaw_lstrcmpiW *pfn = 0;
|
|---|
| 9248 | if (!pfn)
|
|---|
| 9249 | kPrf2WrapResolve((void **)&pfn, "uaw_lstrcmpiW", &g_Kernel32);
|
|---|
| 9250 | return pfn( lpString1, lpString2 );
|
|---|
| 9251 | }
|
|---|
| 9252 |
|
|---|
| 9253 | typedef int WINAPI FN_uaw_lstrlenW( LPCUWSTR lpString );
|
|---|
| 9254 | __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrlenW( LPCUWSTR lpString )
|
|---|
| 9255 | {
|
|---|
| 9256 | static FN_uaw_lstrlenW *pfn = 0;
|
|---|
| 9257 | if (!pfn)
|
|---|
| 9258 | kPrf2WrapResolve((void **)&pfn, "uaw_lstrlenW", &g_Kernel32);
|
|---|
| 9259 | return pfn( lpString );
|
|---|
| 9260 | }
|
|---|
| 9261 |
|
|---|
| 9262 | typedef LPUWSTR WINAPI FN_uaw_wcschr( LPCUWSTR lpString, WCHAR wc );
|
|---|
| 9263 | __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcschr( LPCUWSTR lpString, WCHAR wc )
|
|---|
| 9264 | {
|
|---|
| 9265 | static FN_uaw_wcschr *pfn = 0;
|
|---|
| 9266 | if (!pfn)
|
|---|
| 9267 | kPrf2WrapResolve((void **)&pfn, "uaw_wcschr", &g_Kernel32);
|
|---|
| 9268 | return pfn( lpString, wc );
|
|---|
| 9269 | }
|
|---|
| 9270 |
|
|---|
| 9271 | typedef LPUWSTR WINAPI FN_uaw_wcscpy( LPUWSTR lpDst, LPCUWSTR lpSrc );
|
|---|
| 9272 | __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcscpy( LPUWSTR lpDst, LPCUWSTR lpSrc )
|
|---|
| 9273 | {
|
|---|
| 9274 | static FN_uaw_wcscpy *pfn = 0;
|
|---|
| 9275 | if (!pfn)
|
|---|
| 9276 | kPrf2WrapResolve((void **)&pfn, "uaw_wcscpy", &g_Kernel32);
|
|---|
| 9277 | return pfn( lpDst, lpSrc );
|
|---|
| 9278 | }
|
|---|
| 9279 |
|
|---|
| 9280 | typedef int WINAPI FN_uaw_wcsicmp( LPCUWSTR lp1, LPCUWSTR lp2 );
|
|---|
| 9281 | __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_wcsicmp( LPCUWSTR lp1, LPCUWSTR lp2 )
|
|---|
| 9282 | {
|
|---|
| 9283 | static FN_uaw_wcsicmp *pfn = 0;
|
|---|
| 9284 | if (!pfn)
|
|---|
| 9285 | kPrf2WrapResolve((void **)&pfn, "uaw_wcsicmp", &g_Kernel32);
|
|---|
| 9286 | return pfn( lp1, lp2 );
|
|---|
| 9287 | }
|
|---|
| 9288 |
|
|---|
| 9289 | typedef SIZE_T WINAPI FN_uaw_wcslen( LPCUWSTR lp1 );
|
|---|
| 9290 | __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_uaw_wcslen( LPCUWSTR lp1 )
|
|---|
| 9291 | {
|
|---|
| 9292 | static FN_uaw_wcslen *pfn = 0;
|
|---|
| 9293 | if (!pfn)
|
|---|
| 9294 | kPrf2WrapResolve((void **)&pfn, "uaw_wcslen", &g_Kernel32);
|
|---|
| 9295 | return pfn( lp1 );
|
|---|
| 9296 | }
|
|---|
| 9297 |
|
|---|
| 9298 | typedef LPUWSTR WINAPI FN_uaw_wcsrchr( LPCUWSTR lpString, WCHAR wc );
|
|---|
| 9299 | __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcsrchr( LPCUWSTR lpString, WCHAR wc )
|
|---|
| 9300 | {
|
|---|
| 9301 | static FN_uaw_wcsrchr *pfn = 0;
|
|---|
| 9302 | if (!pfn)
|
|---|
| 9303 | kPrf2WrapResolve((void **)&pfn, "uaw_wcsrchr", &g_Kernel32);
|
|---|
| 9304 | return pfn( lpString, wc );
|
|---|
| 9305 | }
|
|---|
| 9306 |
|
|---|
| 9307 | typedef LPSTR WINAPI FN_lstrcat( LPSTR lpString1, LPCSTR lpString2 );
|
|---|
| 9308 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcat( LPSTR lpString1, LPCSTR lpString2 )
|
|---|
| 9309 | {
|
|---|
| 9310 | static FN_lstrcat *pfn = 0;
|
|---|
| 9311 | if (!pfn)
|
|---|
| 9312 | kPrf2WrapResolve((void **)&pfn, "lstrcat", &g_Kernel32);
|
|---|
| 9313 | return pfn( lpString1, lpString2 );
|
|---|
| 9314 | }
|
|---|
| 9315 |
|
|---|
| 9316 | typedef int WINAPI FN_lstrcmp( LPCSTR lpString1, LPCSTR lpString2 );
|
|---|
| 9317 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmp( LPCSTR lpString1, LPCSTR lpString2 )
|
|---|
| 9318 | {
|
|---|
| 9319 | static FN_lstrcmp *pfn = 0;
|
|---|
| 9320 | if (!pfn)
|
|---|
| 9321 | kPrf2WrapResolve((void **)&pfn, "lstrcmp", &g_Kernel32);
|
|---|
| 9322 | return pfn( lpString1, lpString2 );
|
|---|
| 9323 | }
|
|---|
| 9324 |
|
|---|
| 9325 | typedef int WINAPI FN_lstrcmpi( LPCSTR lpString1, LPCSTR lpString2 );
|
|---|
| 9326 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpi( LPCSTR lpString1, LPCSTR lpString2 )
|
|---|
| 9327 | {
|
|---|
| 9328 | static FN_lstrcmpi *pfn = 0;
|
|---|
| 9329 | if (!pfn)
|
|---|
| 9330 | kPrf2WrapResolve((void **)&pfn, "lstrcmpi", &g_Kernel32);
|
|---|
| 9331 | return pfn( lpString1, lpString2 );
|
|---|
| 9332 | }
|
|---|
| 9333 |
|
|---|
| 9334 | typedef LPSTR WINAPI FN_lstrcpy( LPSTR lpString1, LPCSTR lpString2 );
|
|---|
| 9335 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpy( LPSTR lpString1, LPCSTR lpString2 )
|
|---|
| 9336 | {
|
|---|
| 9337 | static FN_lstrcpy *pfn = 0;
|
|---|
| 9338 | if (!pfn)
|
|---|
| 9339 | kPrf2WrapResolve((void **)&pfn, "lstrcpy", &g_Kernel32);
|
|---|
| 9340 | return pfn( lpString1, lpString2 );
|
|---|
| 9341 | }
|
|---|
| 9342 |
|
|---|
| 9343 | typedef LPSTR WINAPI FN_lstrcpyn( LPSTR lpString1, LPCSTR lpString2, int iMaxLength );
|
|---|
| 9344 | __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpyn( LPSTR lpString1, LPCSTR lpString2, int iMaxLength )
|
|---|
| 9345 | {
|
|---|
| 9346 | static FN_lstrcpyn *pfn = 0;
|
|---|
| 9347 | if (!pfn)
|
|---|
| 9348 | kPrf2WrapResolve((void **)&pfn, "lstrcpyn", &g_Kernel32);
|
|---|
| 9349 | return pfn( lpString1, lpString2, iMaxLength );
|
|---|
| 9350 | }
|
|---|
| 9351 |
|
|---|
| 9352 | typedef int WINAPI FN_lstrlen( LPCSTR lpString );
|
|---|
| 9353 | __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlen( LPCSTR lpString )
|
|---|
| 9354 | {
|
|---|
| 9355 | static FN_lstrlen *pfn = 0;
|
|---|
| 9356 | if (!pfn)
|
|---|
| 9357 | kPrf2WrapResolve((void **)&pfn, "lstrlen", &g_Kernel32);
|
|---|
| 9358 | return pfn( lpString );
|
|---|
| 9359 | }
|
|---|
| 9360 |
|
|---|