1 typedef PVOID WINAPI FN_EncodePointer( PVOID Ptr );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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);
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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);
kPrf2Wrap_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);
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap__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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
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)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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
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)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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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( );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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);
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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 );
kPrf2Wrap_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
9361