4 4 * Windows API header module * 5 5 * * 6 6 * Translated from MinGW API for MS-Windows 3.10 * 7 7 * * 8 8 * Placed into public domain * 9 9 \***********************************************************************/ 10 10 module win32.winbase; 11 -pragma(lib, "kernel32.lib"); 11 +pragma(lib, "kernel32"); 12 12 13 13 /** 14 14 Translation Notes: 15 15 The following macros are obsolete, and have no effect. 16 16 17 17 LockSegment(w), MakeProcInstance(p, i), UnlockResource(h), UnlockSegment(w) 18 18 FreeModule(m), FreeProcInstance(p), GetFreeSpace(w), DefineHandleTable(w) ................................................................................ 63 63 /+ 64 64 //-------------------------------------- 65 65 // These functions are problematic 66 66 67 67 version(UseNtoSKernel) {}else { 68 68 /* CAREFUL: These are exported from ntoskrnl.exe and declared in winddk.h 69 69 as __fastcall functions, but are exported from kernel32.dll as __stdcall */ 70 - static if (_WIN32_WINNT >= 0x0501) { 70 + static if (_WIN32_WINNT >= 0x501) { 71 71 VOID InitializeSListHead(PSLIST_HEADER); 72 72 } 73 73 LONG InterlockedCompareExchange(LPLONG, LONG, LONG); 74 74 // PVOID WINAPI InterlockedCompareExchangePointer(PVOID*, PVOID, PVOID); 75 75 (PVOID)InterlockedCompareExchange((LPLONG)(d) (PVOID)InterlockedCompareExchange((LPLONG)(d), (LONG)(e), (LONG)(c)) 76 76 LONG InterlockedDecrement(LPLONG); 77 77 LONG InterlockedExchange(LPLONG, LONG); 78 78 // PVOID WINAPI InterlockedExchangePointer(PVOID*, PVOID); 79 79 (PVOID)InterlockedExchange((LPLONG)((PVOID)InterlockedExchange((LPLONG)(t), (LONG)(v)) 80 80 LONG InterlockedExchangeAdd(LPLONG, LONG); 81 81 82 - static if (_WIN32_WINNT >= 0x0501) { 82 + static if (_WIN32_WINNT >= 0x501) { 83 83 PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER); 84 84 } 85 85 LONG InterlockedIncrement(LPLONG); 86 - static if (_WIN32_WINNT >= 0x0501) { 86 + static if (_WIN32_WINNT >= 0x501) { 87 87 PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER); 88 88 PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER, PSLIST_ENTRY); 89 89 } 90 90 } // #endif // __USE_NTOSKRNL__ 91 91 //-------------------------------------- 92 92 +/ 93 93 ................................................................................ 176 176 PARITY_ODD = 0x0200, 177 177 PARITY_EVEN = 0x0400, 178 178 PARITY_MARK = 0x0800, 179 179 PARITY_SPACE = 0x1000 180 180 } 181 181 182 182 // used by dwServiceMask 183 -const SP_SERIALCOMM = 1; 183 +enum SP_SERIALCOMM = 1; 184 184 185 185 struct COMMPROP { 186 186 WORD wPacketLength; 187 187 WORD wPacketVersion; 188 188 DWORD dwServiceMask; 189 189 DWORD dwReserved1; 190 190 DWORD dwMaxTxQueue; ................................................................................ 376 376 FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000, 377 377 FILE_FLAG_DELETE_ON_CLOSE = 0x04000000, 378 378 FILE_FLAG_BACKUP_SEMANTICS = 0x02000000, 379 379 FILE_FLAG_POSIX_SEMANTICS = 0x01000000, 380 380 FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000, 381 381 FILE_FLAG_OPEN_NO_RECALL = 0x00100000; 382 382 383 -static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) { 383 +static if (_WIN32_WINNT >= 0x500) { 384 384 const DWORD FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000; 385 385 } 386 386 387 387 // for CreateFile() 388 388 const DWORD 389 389 SECURITY_ANONYMOUS = SECURITY_IMPERSONATION_LEVEL.SecurityAnonymous<<16, 390 390 SECURITY_IDENTIFICATION = SECURITY_IMPERSONATION_LEVEL.SecurityIdentification<<16, ................................................................................ 454 454 455 455 enum : DWORD { 456 456 STD_INPUT_HANDLE = 0xFFFFFFF6, 457 457 STD_OUTPUT_HANDLE = 0xFFFFFFF5, 458 458 STD_ERROR_HANDLE = 0xFFFFFFF4 459 459 } 460 460 461 -const HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1); 461 +enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1); 462 462 463 463 enum : DWORD { 464 464 GET_TAPE_MEDIA_INFORMATION = 0, 465 465 GET_TAPE_DRIVE_INFORMATION = 1 466 466 } 467 467 468 468 enum : DWORD { ................................................................................ 865 865 const DWORD INVALID_FILE_SIZE = 0xFFFFFFFF; 866 866 867 867 const DWORD TLS_OUT_OF_INDEXES = 0xFFFFFFFF; 868 868 869 869 // GetWriteWatch() 870 870 const DWORD WRITE_WATCH_FLAG_RESET = 1; 871 871 872 -static if (_WIN32_WINNT_ONLY) { 873 - // for LogonUser() 874 - enum : DWORD { 875 - LOGON32_LOGON_INTERACTIVE = 2, 876 - LOGON32_LOGON_NETWORK = 3, 877 - LOGON32_LOGON_BATCH = 4, 878 - LOGON32_LOGON_SERVICE = 5, 879 - LOGON32_LOGON_UNLOCK = 7 880 - } 872 +// for LogonUser() 873 +enum : DWORD { 874 + LOGON32_LOGON_INTERACTIVE = 2, 875 + LOGON32_LOGON_NETWORK = 3, 876 + LOGON32_LOGON_BATCH = 4, 877 + LOGON32_LOGON_SERVICE = 5, 878 + LOGON32_LOGON_UNLOCK = 7 879 +} 881 880 882 - // for LogonUser() 881 +// for LogonUser() 882 +enum : DWORD { 883 + LOGON32_PROVIDER_DEFAULT, 884 + LOGON32_PROVIDER_WINNT35, 885 + LOGON32_PROVIDER_WINNT40, 886 + LOGON32_PROVIDER_WINNT50 887 +} 888 + 889 +// for MoveFileEx() 890 +const DWORD 891 + MOVEFILE_REPLACE_EXISTING = 1, 892 + MOVEFILE_COPY_ALLOWED = 2, 893 + MOVEFILE_DELAY_UNTIL_REBOOT = 4, 894 + MOVEFILE_WRITE_THROUGH = 8; 895 + 896 +// DefineDosDevice() 897 +const DWORD 898 + DDD_RAW_TARGET_PATH = 1, 899 + DDD_REMOVE_DEFINITION = 2, 900 + DDD_EXACT_MATCH_ON_REMOVE = 4; 901 + 902 +static if (_WIN32_WINNT >= 0x500) { 883 903 enum : DWORD { 884 - LOGON32_PROVIDER_DEFAULT, 885 - LOGON32_PROVIDER_WINNT35, 886 - LOGON32_PROVIDER_WINNT40, 887 - LOGON32_PROVIDER_WINNT50 904 + LOGON32_LOGON_NETWORK_CLEARTEXT = 8, 905 + LOGON32_LOGON_NEW_CREDENTIALS = 9 888 906 } 889 907 890 - // for MoveFileEx() 908 + // ReplaceFile() 909 + const DWORD 910 + REPLACEFILE_WRITE_THROUGH = 1, 911 + REPLACEFILE_IGNORE_MERGE_ERRORS = 2; 912 +} 913 + 914 +static if (_WIN32_WINNT >= 0x501) { 915 + const DWORD 916 + GET_MODULE_HANDLE_EX_FLAG_PIN = 1, 917 + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2, 918 + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 4; 919 + 920 + // for ACTCTX 891 921 const DWORD 892 - MOVEFILE_REPLACE_EXISTING = 1, 893 - MOVEFILE_COPY_ALLOWED = 2, 894 - MOVEFILE_DELAY_UNTIL_REBOOT = 4, 895 - MOVEFILE_WRITE_THROUGH = 8; 922 + ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01, 923 + ACTCTX_FLAG_LANGID_VALID = 0x02, 924 + ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 0x04, 925 + ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x08, 926 + ACTCTX_FLAG_SET_PROCESS_DEFAULT = 0x10, 927 + ACTCTX_FLAG_APPLICATION_NAME_VALID = 0x20, 928 + ACTCTX_FLAG_HMODULE_VALID = 0x80; 896 929 897 - // DefineDosDevice() 930 + // DeactivateActCtx() 931 + const DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1; 932 + // FindActCtxSectionString() 933 + const DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX = 1; 934 + // QueryActCtxW() 898 935 const DWORD 899 - DDD_RAW_TARGET_PATH = 1, 900 - DDD_REMOVE_DEFINITION = 2, 901 - DDD_EXACT_MATCH_ON_REMOVE = 4; 936 + QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX = 0x04, 937 + QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE = 0x08, 938 + QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS = 0x10; 902 939 903 - static if (_WIN32_WINNT >= 0x500) { 904 - enum : DWORD { 905 - LOGON32_LOGON_NETWORK_CLEARTEXT = 8, 906 - LOGON32_LOGON_NEW_CREDENTIALS = 9 907 - } 908 - 909 - // ReplaceFile() 910 - const DWORD 911 - REPLACEFILE_WRITE_THROUGH = 1, 912 - REPLACEFILE_IGNORE_MERGE_ERRORS = 2; 913 - } 914 - 915 - static if (_WIN32_WINNT >= 0x501) { 916 - const DWORD 917 - GET_MODULE_HANDLE_EX_FLAG_PIN = 1, 918 - GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2, 919 - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 4; 920 - 921 - // for ACTCTX 922 - const DWORD 923 - ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01, 924 - ACTCTX_FLAG_LANGID_VALID = 0x02, 925 - ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 0x04, 926 - ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x08, 927 - ACTCTX_FLAG_SET_PROCESS_DEFAULT = 0x10, 928 - ACTCTX_FLAG_APPLICATION_NAME_VALID = 0x20, 929 - ACTCTX_FLAG_HMODULE_VALID = 0x80; 930 - 931 - // DeactivateActCtx() 932 - const DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1; 933 - // FindActCtxSectionString() 934 - const DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX = 1; 935 - // QueryActCtxW() 936 - const DWORD 937 - QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX = 0x04, 938 - QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE = 0x08, 939 - QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS = 0x10; 940 - 941 - enum { 942 - LOGON_WITH_PROFILE = 1, 943 - LOGON_NETCREDENTIALS_ONLY 944 - } 940 + enum { 941 + LOGON_WITH_PROFILE = 1, 942 + LOGON_NETCREDENTIALS_ONLY 945 943 } 946 944 } 947 945 948 946 // ---- 949 947 950 948 struct FILETIME { 951 949 DWORD dwLowDateTime; ................................................................................ 1264 1262 WORD wHour; 1265 1263 WORD wMinute; 1266 1264 WORD wSecond; 1267 1265 WORD wMilliseconds; 1268 1266 } 1269 1267 alias SYSTEMTIME* LPSYSTEMTIME; 1270 1268 1271 -static if (_WIN32_WINDOWS >= 0x410) { 1272 - struct WIN32_FILE_ATTRIBUTE_DATA { 1273 - DWORD dwFileAttributes; 1274 - FILETIME ftCreationTime; 1275 - FILETIME ftLastAccessTime; 1276 - FILETIME ftLastWriteTime; 1277 - DWORD nFileSizeHigh; 1278 - DWORD nFileSizeLow; 1279 - } 1280 - alias WIN32_FILE_ATTRIBUTE_DATA* LPWIN32_FILE_ATTRIBUTE_DATA; 1269 +struct WIN32_FILE_ATTRIBUTE_DATA { 1270 + DWORD dwFileAttributes; 1271 + FILETIME ftCreationTime; 1272 + FILETIME ftLastAccessTime; 1273 + FILETIME ftLastWriteTime; 1274 + DWORD nFileSizeHigh; 1275 + DWORD nFileSizeLow; 1281 1276 } 1277 +alias WIN32_FILE_ATTRIBUTE_DATA* LPWIN32_FILE_ATTRIBUTE_DATA; 1282 1278 1283 1279 struct WIN32_FIND_DATAA { 1284 1280 DWORD dwFileAttributes; 1285 1281 FILETIME ftCreationTime; 1286 1282 FILETIME ftLastAccessTime; 1287 1283 FILETIME ftLastWriteTime; 1288 1284 DWORD nFileSizeHigh; ................................................................................ 1316 1312 WCHAR[MAX_PATH] cFileName; 1317 1313 // #ifndef _WIN32_WCE 1318 1314 WCHAR[14] cAlternateFileName; 1319 1315 // #endif 1320 1316 } 1321 1317 alias WIN32_FIND_DATAW* PWIN32_FIND_DATAW, LPWIN32_FIND_DATAW; 1322 1318 1323 -static if (_WIN32_WINNT_ONLY) { 1324 - struct WIN32_STREAM_ID { 1325 - DWORD dwStreamId; 1326 - DWORD dwStreamAttributes; 1327 - LARGE_INTEGER Size; 1328 - DWORD dwStreamNameSize; 1329 - WCHAR _cStreamName; 1330 - 1331 - WCHAR* cStreamName() { return &_cStreamName; } 1332 - } 1333 - alias WIN32_STREAM_ID* LPWIN32_STREAM_ID; 1334 - 1335 - enum FINDEX_INFO_LEVELS { 1336 - FindExInfoStandard, 1337 - FindExInfoMaxInfoLevel 1338 - } 1339 - 1340 - enum FINDEX_SEARCH_OPS { 1341 - FindExSearchNameMatch, 1342 - FindExSearchLimitToDirectories, 1343 - FindExSearchLimitToDevices, 1344 - FindExSearchMaxSearchOp 1345 - } 1346 - 1347 - enum ACL_INFORMATION_CLASS { 1348 - AclRevisionInformation = 1, 1349 - AclSizeInformation 1350 - } 1351 - 1352 - struct HW_PROFILE_INFOA { 1353 - DWORD dwDockInfo; 1354 - CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid; 1355 - CHAR[MAX_PROFILE_LEN] szHwProfileName; 1356 - } 1357 - alias HW_PROFILE_INFOA* LPHW_PROFILE_INFOA; 1358 - 1359 - struct HW_PROFILE_INFOW { 1360 - DWORD dwDockInfo; 1361 - WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid; 1362 - WCHAR[MAX_PROFILE_LEN] szHwProfileName; 1363 - } 1364 - alias HW_PROFILE_INFOW* LPHW_PROFILE_INFOW; 1365 -} 1319 +struct WIN32_STREAM_ID { 1320 + DWORD dwStreamId; 1321 + DWORD dwStreamAttributes; 1322 + LARGE_INTEGER Size; 1323 + DWORD dwStreamNameSize; 1324 + WCHAR _cStreamName; 1325 + 1326 + WCHAR* cStreamName() { return &_cStreamName; } 1327 +} 1328 +alias WIN32_STREAM_ID* LPWIN32_STREAM_ID; 1329 + 1330 +enum FINDEX_INFO_LEVELS { 1331 + FindExInfoStandard, 1332 + FindExInfoMaxInfoLevel 1333 +} 1334 + 1335 +enum FINDEX_SEARCH_OPS { 1336 + FindExSearchNameMatch, 1337 + FindExSearchLimitToDirectories, 1338 + FindExSearchLimitToDevices, 1339 + FindExSearchMaxSearchOp 1340 +} 1341 + 1342 +enum ACL_INFORMATION_CLASS { 1343 + AclRevisionInformation = 1, 1344 + AclSizeInformation 1345 +} 1346 + 1347 +struct HW_PROFILE_INFOA { 1348 + DWORD dwDockInfo; 1349 + CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid; 1350 + CHAR[MAX_PROFILE_LEN] szHwProfileName; 1351 +} 1352 +alias HW_PROFILE_INFOA* LPHW_PROFILE_INFOA; 1353 + 1354 +struct HW_PROFILE_INFOW { 1355 + DWORD dwDockInfo; 1356 + WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid; 1357 + WCHAR[MAX_PROFILE_LEN] szHwProfileName; 1358 +} 1359 +alias HW_PROFILE_INFOW* LPHW_PROFILE_INFOW; 1366 1360 1367 1361 /* ??? MSDN documents this only for Windows CE/Mobile, but it's used by 1368 1362 * GetFileAttributesEx, which is in desktop Windows. 1369 1363 */ 1370 1364 enum GET_FILEEX_INFO_LEVELS { 1371 1365 GetFileExInfoStandard, 1372 1366 GetFileExMaxInfoLevel ................................................................................ 1379 1373 WORD wProcessorArchitecture; 1380 1374 WORD wReserved; 1381 1375 } 1382 1376 } 1383 1377 DWORD dwPageSize; 1384 1378 PVOID lpMinimumApplicationAddress; 1385 1379 PVOID lpMaximumApplicationAddress; 1386 - DWORD dwActiveProcessorMask; 1380 + DWORD_PTR dwActiveProcessorMask; 1387 1381 DWORD dwNumberOfProcessors; 1388 1382 DWORD dwProcessorType; 1389 1383 DWORD dwAllocationGranularity; 1390 1384 WORD wProcessorLevel; 1391 1385 WORD wProcessorRevision; 1392 1386 } 1393 1387 alias SYSTEM_INFO* LPSYSTEM_INFO; 1394 1388 1395 -static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) { 1389 +static if (_WIN32_WINNT >= 0x500) { 1396 1390 struct SYSTEM_POWER_STATUS { 1397 1391 BYTE ACLineStatus; 1398 1392 BYTE BatteryFlag; 1399 1393 BYTE BatteryLifePercent; 1400 1394 BYTE Reserved1; 1401 1395 DWORD BatteryLifeTime; 1402 1396 DWORD BatteryFullLifeTime; ................................................................................ 1565 1559 USHORT wProcessorArchitecture; 1566 1560 LANGID wLangId; 1567 1561 LPCSTR lpAssemblyDirectory; 1568 1562 LPCSTR lpResourceName; 1569 1563 LPCSTR lpApplicationName; 1570 1564 HMODULE hModule; 1571 1565 } 1572 - alias ACTCTXA* PACTCTXA; 1573 - alias CPtr!(ACTCTXA) PCACTCTXA; 1566 + alias ACTCTXA* PACTCTXA; 1567 + alias const(ACTCTXA)* PCACTCTXA; 1574 1568 1575 1569 struct ACTCTXW { 1576 1570 ULONG cbSize = this.sizeof; 1577 1571 DWORD dwFlags; 1578 1572 LPCWSTR lpSource; 1579 1573 USHORT wProcessorArchitecture; 1580 1574 LANGID wLangId; 1581 1575 LPCWSTR lpAssemblyDirectory; 1582 1576 LPCWSTR lpResourceName; 1583 1577 LPCWSTR lpApplicationName; 1584 1578 HMODULE hModule; 1585 1579 } 1586 - alias ACTCTXW* PACTCTXW; 1587 - alias CPtr!(ACTCTXW) PCACTCTXW; 1580 + alias ACTCTXW* PACTCTXW; 1581 + alias const(ACTCTXW)* PCACTCTXW; 1588 1582 1589 1583 struct ACTCTX_SECTION_KEYED_DATA { 1590 1584 ULONG cbSize = this.sizeof; 1591 1585 ULONG ulDataFormatVersion; 1592 1586 PVOID lpData; 1593 1587 ULONG ulLength; 1594 1588 PVOID lpSectionGlobalData; 1595 1589 ULONG ulSectionGlobalDataLength; 1596 1590 PVOID lpSectionBase; 1597 1591 ULONG ulSectionTotalLength; 1598 1592 HANDLE hActCtx; 1599 1593 HANDLE ulAssemblyRosterIndex; 1600 1594 } 1601 - alias ACTCTX_SECTION_KEYED_DATA* PACTCTX_SECTION_KEYED_DATA; 1602 - alias CPtr!(ACTCTX_SECTION_KEYED_DATA) PCACTCTX_SECTION_KEYED_DATA; 1595 + alias ACTCTX_SECTION_KEYED_DATA* PACTCTX_SECTION_KEYED_DATA; 1596 + alias const(ACTCTX_SECTION_KEYED_DATA)* PCACTCTX_SECTION_KEYED_DATA; 1603 1597 1604 1598 enum MEMORY_RESOURCE_NOTIFICATION_TYPE { 1605 1599 LowMemoryResourceNotification, 1606 1600 HighMemoryResourceNotification 1607 1601 } 1608 1602 1609 -} // (_WIN32_WINNT >= 0x0501) 1603 +} // (_WIN32_WINNT >= 0x501) 1610 1604 1611 -static if (WINVER >= 0x410) { 1605 +static if (_WIN32_WINNT >= 0x410) { 1612 1606 /* apparently used only by SetThreadExecutionState (Win2000+) 1613 1607 * and DDK functions (version compatibility not established) 1614 1608 */ 1615 1609 alias DWORD EXECUTION_STATE; 1616 1610 } 1617 1611 1618 1612 // Callbacks ................................................................................ 1631 1625 alias void function(DWORD, DWORD, LPOVERLAPPED) LPOVERLAPPED_COMPLETION_ROUTINE; 1632 1626 alias LONG function(LPEXCEPTION_POINTERS) PTOP_LEVEL_EXCEPTION_FILTER; 1633 1627 alias PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER; 1634 1628 1635 1629 alias void function(ULONG_PTR) PAPCFUNC; 1636 1630 alias void function(PVOID, DWORD, DWORD) PTIMERAPCROUTINE; 1637 1631 1638 - static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) { 1632 + static if (_WIN32_WINNT >= 0x500) { 1639 1633 alias void function(PVOID, BOOLEAN) WAITORTIMERCALLBACK; 1640 1634 } 1641 1635 } 1642 1636 1643 -LPTSTR MAKEINTATOM(short i) { 1644 - return cast(LPTSTR) i; 1637 +LPTSTR MAKEINTATOM()(ushort i) { 1638 + return cast(LPTSTR) cast(size_t) i; 1645 1639 } 1646 1640 1647 1641 extern (Windows) { 1648 1642 ATOM AddAtomA(LPCSTR); 1649 1643 ATOM AddAtomW(LPCWSTR); 1650 1644 BOOL AreFileApisANSI(); 1651 1645 BOOL Beep(DWORD, DWORD); ................................................................................ 1660 1654 BOOL CancelDeviceWakeupRequest(HANDLE); 1661 1655 BOOL CheckTokenMembership(HANDLE, PSID, PBOOL); 1662 1656 BOOL ClearCommBreak(HANDLE); 1663 1657 BOOL ClearCommError(HANDLE, PDWORD, LPCOMSTAT); 1664 1658 BOOL CloseHandle(HANDLE); 1665 1659 BOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG); 1666 1660 BOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG); 1667 - LONG CompareFileTime(CPtr!(FILETIME), CPtr!(FILETIME)); 1661 + LONG CompareFileTime(const(FILETIME)*, const(FILETIME)*); 1668 1662 BOOL ContinueDebugEvent(DWORD, DWORD, DWORD); 1669 1663 BOOL CopyFileA(LPCSTR, LPCSTR, BOOL); 1670 1664 BOOL CopyFileW(LPCWSTR, LPCWSTR, BOOL); 1671 1665 BOOL CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD); 1672 1666 BOOL CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD); 1673 1667 1674 1668 /+ FIXME ................................................................................ 1676 1670 alias memcpy RtlCopyMemory; 1677 1671 1678 1672 void RtlFillMemory(PVOID dest, SIZE_T len, BYTE fill) { 1679 1673 memset(dest, fill, len); 1680 1674 } 1681 1675 1682 1676 void RtlZeroMemory(PVOID dest, SIZE_T len) { 1683 - RtlFillMemory(dest, len , 0); 1677 + RtlFillMemory(dest, len, 0); 1684 1678 } 1685 1679 1686 1680 alias RtlMoveMemory MoveMemory; 1687 1681 alias RtlCopyMemory CopyMemory; 1688 1682 alias RtlFillMemory FillMemory; 1689 1683 alias RtlZeroMemory ZeroMemory; 1690 1684 +/ ................................................................................ 1729 1723 void ExitProcess(UINT); // Never returns 1730 1724 void ExitThread(DWORD); // Never returns 1731 1725 DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD); 1732 1726 DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD); 1733 1727 void FatalAppExitA(UINT, LPCSTR); 1734 1728 void FatalAppExitW(UINT, LPCWSTR); 1735 1729 void FatalExit(int); 1736 - BOOL FileTimeToDosDateTime(CPtr!(FILETIME) , LPWORD, LPWORD); 1737 - BOOL FileTimeToLocalFileTime(CPtr!(FILETIME) , LPFILETIME); 1738 - BOOL FileTimeToSystemTime(CPtr!(FILETIME) , LPSYSTEMTIME); 1730 + BOOL FileTimeToDosDateTime(const(FILETIME)*, LPWORD, LPWORD); 1731 + BOOL FileTimeToLocalFileTime(const(FILETIME)*, LPFILETIME); 1732 + BOOL FileTimeToSystemTime(const(FILETIME)*, LPSYSTEMTIME); 1739 1733 ATOM FindAtomA(LPCSTR); 1740 1734 ATOM FindAtomW(LPCWSTR); 1741 1735 BOOL FindClose(HANDLE); 1742 1736 BOOL FindCloseChangeNotification(HANDLE); 1743 1737 HANDLE FindFirstChangeNotificationA(LPCSTR, BOOL, DWORD); 1744 1738 HANDLE FindFirstChangeNotificationW(LPCWSTR, BOOL, DWORD); 1745 1739 HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATAA); ................................................................................ 1890 1884 BOOL InitAtomTable(DWORD); 1891 1885 VOID InitializeCriticalSection(LPCRITICAL_SECTION); 1892 1886 /* ??? The next two are allegedly obsolete and "supported only for 1893 1887 * backward compatibility with the 16-bit Windows API". Yet the 1894 1888 * replacements IsBadReadPtr and IsBadWritePtr are apparently Win2000+ 1895 1889 * only. Where's the mistake? 1896 1890 */ 1897 - BOOL IsBadHugeReadPtr(PCVOID, UINT); 1898 - BOOL IsBadHugeWritePtr(PVOID, UINT); 1899 - BOOL IsBadReadPtr(PCVOID, UINT); 1900 - BOOL IsBadStringPtrA(LPCSTR, UINT); 1901 - BOOL IsBadStringPtrW(LPCWSTR, UINT); 1902 - BOOL IsBadWritePtr(PVOID, UINT); 1891 + BOOL IsBadHugeReadPtr(PCVOID, UINT_PTR); 1892 + BOOL IsBadHugeWritePtr(PVOID, UINT_PTR); 1893 + BOOL IsBadReadPtr(PCVOID, UINT_PTR); 1894 + BOOL IsBadStringPtrA(LPCSTR, UINT_PTR); 1895 + BOOL IsBadStringPtrW(LPCWSTR, UINT_PTR); 1896 + BOOL IsBadWritePtr(PVOID, UINT_PTR); 1903 1897 void LeaveCriticalSection(LPCRITICAL_SECTION); 1904 1898 HINSTANCE LoadLibraryA(LPCSTR); 1905 1899 HINSTANCE LoadLibraryW(LPCWSTR); 1906 1900 HINSTANCE LoadLibraryExA(LPCSTR, HANDLE, DWORD); 1907 1901 HINSTANCE LoadLibraryExW(LPCWSTR, HANDLE, DWORD); 1908 1902 DWORD LoadModule(LPCSTR, PVOID); 1909 1903 HGLOBAL LoadResource(HINSTANCE, HRSRC); 1910 - BOOL LocalFileTimeToFileTime(CPtr!(FILETIME) , LPFILETIME); 1904 + BOOL LocalFileTimeToFileTime(const(FILETIME)*, LPFILETIME); 1911 1905 BOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); 1912 1906 PVOID LockResource(HGLOBAL); 1913 1907 1914 1908 LPSTR lstrcatA(LPSTR, LPCSTR); 1915 1909 LPWSTR lstrcatW(LPWSTR, LPCWSTR); 1916 1910 int lstrcmpA(LPCSTR, LPCSTR); 1917 1911 int lstrcmpiA(LPCSTR, LPCSTR); ................................................................................ 1939 1933 void OutputDebugStringW(LPCWSTR); 1940 1934 BOOL PeekNamedPipe(HANDLE, PVOID, DWORD, PDWORD, PDWORD, PDWORD); 1941 1935 BOOL PulseEvent(HANDLE); 1942 1936 BOOL PurgeComm(HANDLE, DWORD); 1943 1937 BOOL QueryPerformanceCounter(PLARGE_INTEGER); 1944 1938 BOOL QueryPerformanceFrequency(PLARGE_INTEGER); 1945 1939 DWORD QueueUserAPC(PAPCFUNC, HANDLE, ULONG_PTR); 1946 - void RaiseException(DWORD, DWORD, DWORD, CPtr!(DWORD)); 1940 + void RaiseException(DWORD, DWORD, DWORD, const(DWORD)*); 1947 1941 BOOL ReadFile(HANDLE, PVOID, DWORD, PDWORD, LPOVERLAPPED); 1948 1942 BOOL ReadFileEx(HANDLE, PVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); 1949 - BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, DWORD, PDWORD); 1943 + BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, SIZE_T, SIZE_T*); 1950 1944 BOOL ReleaseMutex(HANDLE); 1951 1945 BOOL ReleaseSemaphore(HANDLE, LONG, LPLONG); 1952 1946 BOOL RemoveDirectoryA(LPCSTR); 1953 1947 BOOL RemoveDirectoryW(LPCWSTR); 1954 1948 /* In MinGW: 1955 1949 #ifdef _WIN32_WCE 1956 1950 extern BOOL ResetEvent(HANDLE); ................................................................................ 1986 1980 */ 1987 1981 BOOL SetEvent(HANDLE); 1988 1982 VOID SetFileApisToANSI(); 1989 1983 VOID SetFileApisToOEM(); 1990 1984 BOOL SetFileAttributesA(LPCSTR, DWORD); 1991 1985 BOOL SetFileAttributesW(LPCWSTR, DWORD); 1992 1986 DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD); 1993 - BOOL SetFileTime(HANDLE, CPtr!(FILETIME), CPtr!(FILETIME), CPtr!(FILETIME)); 1987 + BOOL SetFileTime(HANDLE, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*); 1994 1988 deprecated UINT SetHandleCount(UINT); 1995 1989 void SetLastError(DWORD); 1996 1990 void SetLastErrorEx(DWORD, DWORD); 1997 - BOOL SetLocalTime(CPtr!(SYSTEMTIME)); 1991 + BOOL SetLocalTime(const(SYSTEMTIME)*); 1998 1992 BOOL SetMailslotInfo(HANDLE, DWORD); 1999 1993 BOOL SetNamedPipeHandleState(HANDLE, PDWORD, PDWORD, PDWORD); 2000 1994 BOOL SetPriorityClass(HANDLE, DWORD); 2001 1995 BOOL SetStdHandle(DWORD, HANDLE); 2002 - BOOL SetSystemTime(CPtr!(SYSTEMTIME)); 1996 + BOOL SetSystemTime(const(SYSTEMTIME)*); 2003 1997 DWORD SetThreadAffinityMask(HANDLE, DWORD); 2004 - BOOL SetThreadContext(HANDLE, CPtr!(CONTEXT)); 1998 + BOOL SetThreadContext(HANDLE, const(CONTEXT)*); 2005 1999 BOOL SetThreadPriority(HANDLE, int); 2006 - BOOL SetTimeZoneInformation(CPtr!(TIME_ZONE_INFORMATION)); 2000 + BOOL SetTimeZoneInformation(const(TIME_ZONE_INFORMATION)*); 2007 2001 LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER); 2008 2002 BOOL SetupComm(HANDLE, DWORD, DWORD); 2009 2003 BOOL SetVolumeLabelA(LPCSTR, LPCSTR); 2010 2004 BOOL SetVolumeLabelW(LPCWSTR, LPCWSTR); 2011 2005 2012 2006 DWORD SizeofResource(HINSTANCE, HRSRC); 2013 2007 void Sleep(DWORD); 2014 2008 DWORD SleepEx(DWORD, BOOL); 2015 2009 DWORD SuspendThread(HANDLE); 2016 - BOOL SystemTimeToFileTime(CPtr!(SYSTEMTIME), LPFILETIME); 2010 + BOOL SystemTimeToFileTime(const(SYSTEMTIME)*, LPFILETIME); 2017 2011 BOOL TerminateProcess(HANDLE, UINT); 2018 2012 BOOL TerminateThread(HANDLE, DWORD); 2019 2013 DWORD TlsAlloc(); 2020 2014 BOOL TlsFree(DWORD); 2021 2015 PVOID TlsGetValue(DWORD); 2022 2016 BOOL TlsSetValue(DWORD, PVOID); 2023 2017 BOOL TransactNamedPipe(HANDLE, PVOID, DWORD, PVOID, DWORD, PDWORD, LPOVERLAPPED); 2024 2018 BOOL TransmitCommChar(HANDLE, char); 2025 2019 LONG UnhandledExceptionFilter(LPEXCEPTION_POINTERS); 2026 2020 BOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); 2027 2021 BOOL WaitCommEvent(HANDLE, PDWORD, LPOVERLAPPED); 2028 2022 BOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD); 2029 - DWORD WaitForMultipleObjects(DWORD, CPtr!(HANDLE), BOOL, DWORD); 2030 - DWORD WaitForMultipleObjectsEx(DWORD, CPtr!(HANDLE), BOOL, DWORD, BOOL); 2023 + DWORD WaitForMultipleObjects(DWORD, const(HANDLE)*, BOOL, DWORD); 2024 + DWORD WaitForMultipleObjectsEx(DWORD, const(HANDLE)*, BOOL, DWORD, BOOL); 2031 2025 DWORD WaitForSingleObject(HANDLE, DWORD); 2032 2026 DWORD WaitForSingleObjectEx(HANDLE, DWORD, BOOL); 2033 2027 BOOL WaitNamedPipeA(LPCSTR, DWORD); 2034 2028 BOOL WaitNamedPipeW(LPCWSTR, DWORD); 2035 2029 // undocumented on MSDN 2036 2030 BOOL WinLoadTrustProvider(GUID*); 2037 2031 BOOL WriteFile(HANDLE, PCVOID, DWORD, PDWORD, LPOVERLAPPED); ................................................................................ 2086 2080 BOOL VirtualFreeEx(HANDLE, PVOID, DWORD, DWORD); 2087 2081 BOOL VirtualLock(PVOID, DWORD); 2088 2082 BOOL VirtualProtect(PVOID, DWORD, DWORD, PDWORD); 2089 2083 BOOL VirtualProtectEx(HANDLE, PVOID, DWORD, DWORD, PDWORD); 2090 2084 DWORD VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD); 2091 2085 DWORD VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD); 2092 2086 BOOL VirtualUnlock(PVOID, DWORD); 2093 - 2094 - static if (_WIN32_WINDOWS >= 0x600) { 2087 +// not in MinGW 4.0 - ??? 2088 + static if (_WIN32_WINNT >= 0x600) { 2095 2089 BOOL CancelIoEx(HANDLE, LPOVERLAPPED); 2096 2090 } 2097 2091 2098 - static if (_WIN32_WINDOWS >= 0x410) { 2099 - BOOL CancelIo(HANDLE); 2100 - BOOL CancelWaitableTimer(HANDLE); 2101 - PVOID ConvertThreadToFiber(PVOID); 2102 - LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID); 2103 - HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR); 2104 - HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR); 2105 - void DeleteFiber(PVOID); 2106 - BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID); 2107 - BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID); 2108 - DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD); 2109 - DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD); 2110 - BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD); 2111 - BOOL IsDebuggerPresent(); 2112 - HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR); 2113 - HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR); 2114 - DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD); 2115 - DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD); 2116 - BOOL SetWaitableTimer(HANDLE, CPtr!(LARGE_INTEGER), LONG, PTIMERAPCROUTINE, PVOID, BOOL); 2117 - void SwitchToFiber(PVOID); 2118 - } 2119 - 2120 - static if (WINVER >= 0x500) { 2092 + BOOL CancelIo(HANDLE); 2093 + BOOL CancelWaitableTimer(HANDLE); 2094 + PVOID ConvertThreadToFiber(PVOID); 2095 + LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID); 2096 + HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR); 2097 + HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR); 2098 + void DeleteFiber(PVOID); 2099 + BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID); 2100 + BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID); 2101 + DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD); 2102 + DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD); 2103 + BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD); 2104 + BOOL IsDebuggerPresent(); 2105 + HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR); 2106 + HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR); 2107 + DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD); 2108 + DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD); 2109 + BOOL SetWaitableTimer(HANDLE, const(LARGE_INTEGER)*, LONG, PTIMERAPCROUTINE, PVOID, BOOL); 2110 + void SwitchToFiber(PVOID); 2111 + 2112 + static if (_WIN32_WINNT >= 0x500) { 2121 2113 HANDLE OpenThread(DWORD, BOOL, DWORD); 2122 2114 } 2123 2115 2124 - static if (_WIN32_WINNT_ONLY) { 2125 - BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL); 2126 - BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); 2127 - BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); 2128 - BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID); 2129 - BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID); 2130 - BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD); 2131 - BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL); 2132 - BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD); 2133 - BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 2134 - BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*); 2135 - BOOL AllocateLocallyUniqueId(PLUID); 2136 - BOOL AreAllAccessesGranted(DWORD, DWORD); 2137 - BOOL AreAnyAccessesGranted(DWORD, DWORD); 2138 - BOOL BackupEventLogA(HANDLE, LPCSTR); 2139 - BOOL BackupEventLogW(HANDLE, LPCWSTR); 2140 - BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); 2141 - BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*); 2142 - BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); 2143 - BOOL ClearEventLogA(HANDLE, LPCSTR); 2144 - BOOL ClearEventLogW(HANDLE, LPCWSTR); 2145 - BOOL CloseEventLog(HANDLE); 2146 - BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED); 2147 - BOOL CopySid(DWORD, PSID, PSID); 2148 - HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); 2149 - HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); 2150 - BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING); 2151 - BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION); 2152 - BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); 2153 - HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); 2154 - DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD); 2155 - BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR); 2156 - BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR); 2157 - BOOL DeleteAce(PACL, DWORD); 2158 - BOOL DeregisterEventSource(HANDLE); 2159 - BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*); 2160 - BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED); 2161 - BOOL DisconnectNamedPipe(HANDLE); 2162 - BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE); 2163 - BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE); 2164 - BOOL EqualPrefixSid(PSID, PSID); 2165 - BOOL EqualSid(PSID, PSID); 2166 - DWORD EraseTape(HANDLE, DWORD, BOOL); 2167 - HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); 2168 - HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); 2169 - BOOL FindFirstFreeAce(PACL, PVOID*); 2170 - PVOID FreeSid(PSID); 2171 - BOOL GetAce(PACL, DWORD, LPVOID*); 2172 - BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); 2173 - BOOL GetBinaryTypeA(LPCSTR, PDWORD); 2174 - BOOL GetBinaryTypeW(LPCWSTR, PDWORD); 2175 - DWORD GetCompressedFileSizeA(LPCSTR, PDWORD); 2176 - DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD); 2177 - BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA); 2178 - BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW); 2179 - BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2180 - BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2181 - BOOL GetHandleInformation(HANDLE, PDWORD); 2182 - BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2183 - DWORD GetLengthSid(PSID); 2184 - BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD); 2185 - BOOL GetOldestEventLogRecord(HANDLE, PDWORD); 2186 - BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2187 - BOOL GetProcessPriorityBoost(HANDLE, PBOOL); 2188 - BOOL GetProcessShutdownParameters(PDWORD, PDWORD); 2189 - BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); 2190 - HWINSTA GetProcessWindowStation(); 2191 - BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T); 2192 - BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD); 2193 - BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD); 2194 - BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); 2195 - BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); 2196 - DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR); 2197 - BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); 2198 - BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); 2199 - PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID); 2200 - DWORD GetSidLengthRequired(UCHAR); 2201 - PDWORD GetSidSubAuthority(PSID, DWORD); 2202 - PUCHAR GetSidSubAuthorityCount(PSID); 2203 - DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID); 2204 - DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD); 2205 - DWORD GetTapeStatus(HANDLE); 2206 - BOOL GetThreadPriorityBoost(HANDLE, PBOOL); 2207 - BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); 2208 - BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD); 2209 - BOOL ImpersonateLoggedOnUser(HANDLE); 2210 - BOOL ImpersonateNamedPipeClient(HANDLE); 2211 - BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL); 2212 - BOOL InitializeAcl(PACL, DWORD, DWORD); 2213 - DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD); 2214 - BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD); 2215 - BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE); 2216 - BOOL IsProcessorFeaturePresent(DWORD); 2217 - BOOL IsTextUnicode(PCVOID, int, LPINT); 2218 - BOOL IsValidAcl(PACL); 2219 - BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR); 2220 - BOOL IsValidSid(PSID); 2221 - BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED); 2222 - BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE); 2223 - BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE); 2224 - BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); 2225 - BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); 2226 - BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); 2227 - BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); 2228 - BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD); 2229 - BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD); 2230 - BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD); 2231 - BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD); 2232 - BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID); 2233 - BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID); 2234 - BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD); 2235 - BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD); 2236 - VOID MapGenericMask(PDWORD, PGENERIC_MAPPING); 2237 - BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD); 2238 - BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD); 2239 - BOOL NotifyChangeEventLog(HANDLE, HANDLE); 2240 - BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL); 2241 - BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL); 2242 - BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL); 2243 - BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL); 2244 - BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); 2245 - BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); 2246 - BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); 2247 - BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); 2248 - HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR); 2249 - HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR); 2250 - HANDLE OpenEventLogA(LPCSTR, LPCSTR); 2251 - HANDLE OpenEventLogW(LPCWSTR, LPCWSTR); 2252 - BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE); 2253 - BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE); 2254 - BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED); 2255 - DWORD PrepareTape(HANDLE, DWORD, BOOL); 2256 - BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL); 2257 - BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL); 2258 - BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL); 2259 - BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); 2260 - BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); 2261 - BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); 2262 - BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); 2263 - HANDLE RegisterEventSourceA (LPCSTR, LPCSTR); 2264 - HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR); 2265 - BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID); 2266 - BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID); 2267 - BOOL RevertToSelf(); 2268 - BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); 2269 - BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2270 - BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2271 - BOOL SetHandleInformation(HANDLE, DWORD, DWORD); 2272 - BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2273 - BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR* , PGENERIC_MAPPING, HANDLE); 2274 - BOOL SetProcessAffinityMask(HANDLE, DWORD); 2275 - BOOL SetProcessPriorityBoost(HANDLE, BOOL); 2276 - BOOL SetProcessShutdownParameters(DWORD, DWORD); 2277 - BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T); 2278 - BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); 2279 - BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL); 2280 - BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL); 2281 - BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); 2282 - BOOL SetSystemTimeAdjustment(DWORD, BOOL); 2283 - DWORD SetTapeParameters(HANDLE, DWORD, PVOID); 2284 - DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL); 2285 - BOOL SetThreadPriorityBoost(HANDLE, BOOL); 2286 - BOOL SetThreadToken(PHANDLE, HANDLE); 2287 - BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD); 2288 - DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL); 2289 - BOOL SwitchToThread(); 2290 - BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME); 2291 - BOOL TryEnterCriticalSection(LPCRITICAL_SECTION); 2292 - BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED); 2293 - BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD); 2294 - BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD); 2295 - BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); 2296 - DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL); 2297 - 2298 - static if (_WIN32_WINNT >= 0x500) { 2299 - BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID); 2300 - BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID); 2301 - PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER); 2302 - BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); 2303 - BOOL AssignProcessToJobObject(HANDLE, HANDLE); 2304 - BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG); 2305 - LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID); 2306 - HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR); 2307 - HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR); 2308 - BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES); 2309 - BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); 2310 - HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR); 2311 - HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR); 2312 - BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); 2313 - HANDLE CreateTimerQueue(); 2314 - BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG); 2315 - BOOL DeleteTimerQueue(HANDLE); 2316 - BOOL DeleteTimerQueueEx(HANDLE, HANDLE); 2317 - BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE); 2318 - BOOL DeleteVolumeMountPointA(LPCSTR); 2319 - BOOL DeleteVolumeMountPointW(LPCWSTR); 2320 - BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD); 2321 - BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD); 2322 - BOOL EncryptFileA(LPCSTR); 2323 - BOOL EncryptFileW(LPCWSTR); 2324 - BOOL FileEncryptionStatusA(LPCSTR, LPDWORD); 2325 - BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD); 2326 - HANDLE FindFirstVolumeA(LPCSTR, DWORD); 2327 - HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD); 2328 - HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD); 2329 - HANDLE FindFirstVolumeW(LPCWSTR, DWORD); 2330 - BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD); 2331 - BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD); 2332 - BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD); 2333 - BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD); 2334 - BOOL FindVolumeClose(HANDLE); 2335 - BOOL FindVolumeMountPointClose(HANDLE); 2336 - BOOL FlushViewOfFile(PCVOID, DWORD); 2337 - BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); 2338 - BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD); 2339 - BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD); 2340 - BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER); 2341 - BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*); 2342 - BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*); 2343 - HANDLE GetProcessHeap(); 2344 - DWORD GetProcessHeaps(DWORD, PHANDLE); 2345 - BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS); 2346 - BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS); 2347 - UINT GetSystemWindowsDirectoryA(LPSTR, UINT); 2348 - UINT GetSystemWindowsDirectoryW(LPWSTR, UINT); 2349 - BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD); 2350 - BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD); 2351 - BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD); 2352 - BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD); 2353 - BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX); 2354 - BOOL IsBadCodePtr(FARPROC); 2355 - BOOL IsSystemResumeAutomatic(); 2356 - BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR); 2357 - BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR); 2358 - PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD); 2359 - PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, PVOID); 2360 - HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR); 2361 - HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR); 2362 - BOOL ProcessIdToSessionId(DWORD, DWORD*); 2363 - BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD); 2364 - ULONG RemoveVectoredExceptionHandler(PVOID); 2365 - BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID); 2366 - BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID); 2367 - BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR); 2368 - BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR); 2369 - BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD); 2370 - BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD); 2371 - BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL); 2372 - BOOL SetSystemPowerState(BOOL, BOOL); 2373 - EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE); 2374 - DWORD SetThreadIdealProcessor(HANDLE, DWORD); 2375 - BOOL SetVolumeMountPointA(LPCSTR, LPCSTR); 2376 - BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR); 2377 - BOOL TerminateJobObject(HANDLE, UINT); 2378 - BOOL UnmapViewOfFile(PVOID); 2379 - BOOL UnregisterWait(HANDLE); 2380 - BOOL UnregisterWaitEx(HANDLE, HANDLE); 2381 - BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG); 2382 - BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG); 2383 - } 2384 - 2385 - static if (_WIN32_WINNT >= 0x501) { 2386 - BOOL ActivateActCtx(HANDLE, ULONG_PTR*); 2387 - void AddRefActCtx(HANDLE); 2388 - BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL); 2389 - BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL); 2390 - BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL); 2391 - BOOL ConvertFiberToThread(); 2392 - HANDLE CreateActCtxA(PCACTCTXA); 2393 - HANDLE CreateActCtxW(PCACTCTXW); 2394 - HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE); 2395 - BOOL DeactivateActCtx(DWORD, ULONG_PTR); 2396 - BOOL DebugActiveProcessStop(DWORD); 2397 - BOOL DebugBreakProcess(HANDLE); 2398 - BOOL DebugSetProcessKillOnExit(BOOL); 2399 - BOOL FindActCtxSectionGuid(DWORD, CPtr!(GUID), ULONG, CPtr!(GUID), 2400 - PACTCTX_SECTION_KEYED_DATA); 2401 - BOOL FindActCtxSectionStringA(DWORD, CPtr!(GUID), ULONG, LPCSTR, 2402 - PACTCTX_SECTION_KEYED_DATA); 2403 - BOOL FindActCtxSectionStringW(DWORD, CPtr!(GUID), ULONG, LPCWSTR, 2404 - PACTCTX_SECTION_KEYED_DATA); 2405 - BOOL GetCurrentActCtx(HANDLE*); 2406 - VOID GetNativeSystemInfo(LPSYSTEM_INFO); 2407 - BOOL GetProcessHandleCount(HANDLE, PDWORD); 2408 - BOOL GetSystemRegistryQuota(PDWORD, PDWORD); 2409 - BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME); 2410 - UINT GetSystemWow64DirectoryA(LPSTR, UINT); 2411 - UINT GetSystemWow64DirectoryW(LPWSTR, UINT); 2412 - BOOL GetThreadIOPendingFlag(HANDLE, PBOOL); 2413 - BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD); 2414 - BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD); 2415 - UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG); 2416 - BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T); 2417 - BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T); 2418 - BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL); 2419 - BOOL IsWow64Process(HANDLE, PBOOL); 2420 - BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*); 2421 - BOOL QueryMemoryResourceNotification(HANDLE, PBOOL); 2422 - void ReleaseActCtx(HANDLE); 2423 - UINT ResetWriteWatch(LPVOID, SIZE_T); 2424 - BOOL SetFileShortNameA(HANDLE, LPCSTR); 2425 - BOOL SetFileShortNameW(HANDLE, LPCWSTR); 2426 - BOOL SetFileValidData(HANDLE, LONGLONG); 2427 - BOOL ZombifyActCtx(HANDLE); 2428 - } 2429 - 2430 - static if (_WIN32_WINNT >= 0x502) { 2431 - DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); 2432 - DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); 2433 - DWORD GetDllDirectoryA(DWORD, LPSTR); 2434 - DWORD GetDllDirectoryW(DWORD, LPWSTR); 2435 - DWORD GetProcessId(HANDLE); 2436 - HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD); 2437 - BOOL SetDllDirectoryA(LPCSTR); 2438 - BOOL SetDllDirectoryW(LPCWSTR); 2439 - BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); 2440 - BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); 2441 - } 2116 + BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL); 2117 + BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); 2118 + BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); 2119 + BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID); 2120 + BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID); 2121 + BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD); 2122 + BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL); 2123 + BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD); 2124 + BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 2125 + BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*); 2126 + BOOL AllocateLocallyUniqueId(PLUID); 2127 + BOOL AreAllAccessesGranted(DWORD, DWORD); 2128 + BOOL AreAnyAccessesGranted(DWORD, DWORD); 2129 + BOOL BackupEventLogA(HANDLE, LPCSTR); 2130 + BOOL BackupEventLogW(HANDLE, LPCWSTR); 2131 + BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); 2132 + BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*); 2133 + BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); 2134 + BOOL ClearEventLogA(HANDLE, LPCSTR); 2135 + BOOL ClearEventLogW(HANDLE, LPCWSTR); 2136 + BOOL CloseEventLog(HANDLE); 2137 + BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED); 2138 + BOOL CopySid(DWORD, PSID, PSID); 2139 + HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); 2140 + HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); 2141 + BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING); 2142 + BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION); 2143 + BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); 2144 + HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); 2145 + DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD); 2146 + BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR); 2147 + BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR); 2148 + BOOL DeleteAce(PACL, DWORD); 2149 + BOOL DeregisterEventSource(HANDLE); 2150 + BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*); 2151 + BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED); 2152 + BOOL DisconnectNamedPipe(HANDLE); 2153 + BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE); 2154 + BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE); 2155 + BOOL EqualPrefixSid(PSID, PSID); 2156 + BOOL EqualSid(PSID, PSID); 2157 + DWORD EraseTape(HANDLE, DWORD, BOOL); 2158 + HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); 2159 + HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); 2160 + BOOL FindFirstFreeAce(PACL, PVOID*); 2161 + PVOID FreeSid(PSID); 2162 + BOOL GetAce(PACL, DWORD, LPVOID*); 2163 + BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); 2164 + BOOL GetBinaryTypeA(LPCSTR, PDWORD); 2165 + BOOL GetBinaryTypeW(LPCWSTR, PDWORD); 2166 + DWORD GetCompressedFileSizeA(LPCSTR, PDWORD); 2167 + DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD); 2168 + BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA); 2169 + BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW); 2170 + BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2171 + BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2172 + BOOL GetHandleInformation(HANDLE, PDWORD); 2173 + BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2174 + DWORD GetLengthSid(PSID); 2175 + BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD); 2176 + BOOL GetOldestEventLogRecord(HANDLE, PDWORD); 2177 + BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); 2178 + BOOL GetProcessPriorityBoost(HANDLE, PBOOL); 2179 + BOOL GetProcessShutdownParameters(PDWORD, PDWORD); 2180 + BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); 2181 + HWINSTA GetProcessWindowStation(); 2182 + BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T); 2183 + BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD); 2184 + BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD); 2185 + BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); 2186 + BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); 2187 + DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR); 2188 + BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); 2189 + BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); 2190 + PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID); 2191 + DWORD GetSidLengthRequired(UCHAR); 2192 + PDWORD GetSidSubAuthority(PSID, DWORD); 2193 + PUCHAR GetSidSubAuthorityCount(PSID); 2194 + DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID); 2195 + DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD); 2196 + DWORD GetTapeStatus(HANDLE); 2197 + BOOL GetThreadPriorityBoost(HANDLE, PBOOL); 2198 + BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); 2199 + BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD); 2200 + BOOL ImpersonateLoggedOnUser(HANDLE); 2201 + BOOL ImpersonateNamedPipeClient(HANDLE); 2202 + BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL); 2203 + BOOL InitializeAcl(PACL, DWORD, DWORD); 2204 + DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD); 2205 + BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD); 2206 + BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE); 2207 + BOOL IsProcessorFeaturePresent(DWORD); 2208 + BOOL IsTextUnicode(PCVOID, int, LPINT); 2209 + BOOL IsValidAcl(PACL); 2210 + BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR); 2211 + BOOL IsValidSid(PSID); 2212 + BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED); 2213 + BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE); 2214 + BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE); 2215 + BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); 2216 + BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); 2217 + BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); 2218 + BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); 2219 + BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD); 2220 + BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD); 2221 + BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD); 2222 + BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD); 2223 + BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID); 2224 + BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID); 2225 + BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD); 2226 + BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD); 2227 + VOID MapGenericMask(PDWORD, PGENERIC_MAPPING); 2228 + BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD); 2229 + BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD); 2230 + BOOL NotifyChangeEventLog(HANDLE, HANDLE); 2231 + BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL); 2232 + BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL); 2233 + BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL); 2234 + BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL); 2235 + BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); 2236 + BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); 2237 + BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); 2238 + BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); 2239 + HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR); 2240 + HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR); 2241 + HANDLE OpenEventLogA(LPCSTR, LPCSTR); 2242 + HANDLE OpenEventLogW(LPCWSTR, LPCWSTR); 2243 + BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE); 2244 + BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE); 2245 + BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED); 2246 + DWORD PrepareTape(HANDLE, DWORD, BOOL); 2247 + BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL); 2248 + BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL); 2249 + BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL); 2250 + BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); 2251 + BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); 2252 + BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); 2253 + BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); 2254 + HANDLE RegisterEventSourceA (LPCSTR, LPCSTR); 2255 + HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR); 2256 + BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID); 2257 + BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID); 2258 + BOOL RevertToSelf(); 2259 + BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); 2260 + BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2261 + BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2262 + BOOL SetHandleInformation(HANDLE, DWORD, DWORD); 2263 + BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); 2264 + BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE); 2265 + BOOL SetProcessAffinityMask(HANDLE, DWORD); 2266 + BOOL SetProcessPriorityBoost(HANDLE, BOOL); 2267 + BOOL SetProcessShutdownParameters(DWORD, DWORD); 2268 + BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T); 2269 + BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); 2270 + BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL); 2271 + BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL); 2272 + BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); 2273 + BOOL SetSystemTimeAdjustment(DWORD, BOOL); 2274 + DWORD SetTapeParameters(HANDLE, DWORD, PVOID); 2275 + DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL); 2276 + BOOL SetThreadPriorityBoost(HANDLE, BOOL); 2277 + BOOL SetThreadToken(PHANDLE, HANDLE); 2278 + BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD); 2279 + DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL); 2280 + BOOL SwitchToThread(); 2281 + BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME); 2282 + BOOL TryEnterCriticalSection(LPCRITICAL_SECTION); 2283 + BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED); 2284 + BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD); 2285 + BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD); 2286 + BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); 2287 + DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL); 2288 + 2289 + static if (_WIN32_WINNT >= 0x500) { 2290 + BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID); 2291 + BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID); 2292 + PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER); 2293 + BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); 2294 + BOOL AssignProcessToJobObject(HANDLE, HANDLE); 2295 + BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG); 2296 + LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID); 2297 + HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR); 2298 + HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR); 2299 + BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES); 2300 + BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); 2301 + HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR); 2302 + HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR); 2303 + BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); 2304 + HANDLE CreateTimerQueue(); 2305 + BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG); 2306 + BOOL DeleteTimerQueue(HANDLE); 2307 + BOOL DeleteTimerQueueEx(HANDLE, HANDLE); 2308 + BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE); 2309 + BOOL DeleteVolumeMountPointA(LPCSTR); 2310 + BOOL DeleteVolumeMountPointW(LPCWSTR); 2311 + BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD); 2312 + BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD); 2313 + BOOL EncryptFileA(LPCSTR); 2314 + BOOL EncryptFileW(LPCWSTR); 2315 + BOOL FileEncryptionStatusA(LPCSTR, LPDWORD); 2316 + BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD); 2317 + HANDLE FindFirstVolumeA(LPCSTR, DWORD); 2318 + HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD); 2319 + HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD); 2320 + HANDLE FindFirstVolumeW(LPCWSTR, DWORD); 2321 + BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD); 2322 + BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD); 2323 + BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD); 2324 + BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD); 2325 + BOOL FindVolumeClose(HANDLE); 2326 + BOOL FindVolumeMountPointClose(HANDLE); 2327 + BOOL FlushViewOfFile(PCVOID, DWORD); 2328 + BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); 2329 + BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD); 2330 + BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD); 2331 + BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER); 2332 + BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*); 2333 + BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*); 2334 + HANDLE GetProcessHeap(); 2335 + DWORD GetProcessHeaps(DWORD, PHANDLE); 2336 + BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS); 2337 + BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS); 2338 + UINT GetSystemWindowsDirectoryA(LPSTR, UINT); 2339 + UINT GetSystemWindowsDirectoryW(LPWSTR, UINT); 2340 + BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD); 2341 + BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD); 2342 + BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD); 2343 + BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD); 2344 + BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX); 2345 + BOOL IsBadCodePtr(FARPROC); 2346 + BOOL IsSystemResumeAutomatic(); 2347 + BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR); 2348 + BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR); 2349 + PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD); 2350 + PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, PVOID); 2351 + HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR); 2352 + HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR); 2353 + BOOL ProcessIdToSessionId(DWORD, DWORD*); 2354 + BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD); 2355 + ULONG RemoveVectoredExceptionHandler(PVOID); 2356 + BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID); 2357 + BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID); 2358 + BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR); 2359 + BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR); 2360 + BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD); 2361 + BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD); 2362 + BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL); 2363 + BOOL SetSystemPowerState(BOOL, BOOL); 2364 + EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE); 2365 + DWORD SetThreadIdealProcessor(HANDLE, DWORD); 2366 + BOOL SetVolumeMountPointA(LPCSTR, LPCSTR); 2367 + BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR); 2368 + BOOL TerminateJobObject(HANDLE, UINT); 2369 + BOOL UnmapViewOfFile(PVOID); 2370 + BOOL UnregisterWait(HANDLE); 2371 + BOOL UnregisterWaitEx(HANDLE, HANDLE); 2372 + BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG); 2373 + BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG); 2374 + } 2375 + 2376 + static if (_WIN32_WINNT >= 0x501) { 2377 + BOOL ActivateActCtx(HANDLE, ULONG_PTR*); 2378 + void AddRefActCtx(HANDLE); 2379 + BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL); 2380 + BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL); 2381 + BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL); 2382 + BOOL ConvertFiberToThread(); 2383 + HANDLE CreateActCtxA(PCACTCTXA); 2384 + HANDLE CreateActCtxW(PCACTCTXW); 2385 + HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE); 2386 + BOOL DeactivateActCtx(DWORD, ULONG_PTR); 2387 + BOOL DebugActiveProcessStop(DWORD); 2388 + BOOL DebugBreakProcess(HANDLE); 2389 + BOOL DebugSetProcessKillOnExit(BOOL); 2390 + BOOL FindActCtxSectionGuid(DWORD, const(GUID)*, ULONG, const(GUID)*, 2391 + PACTCTX_SECTION_KEYED_DATA); 2392 + BOOL FindActCtxSectionStringA(DWORD, const(GUID)*, ULONG, LPCSTR, 2393 + PACTCTX_SECTION_KEYED_DATA); 2394 + BOOL FindActCtxSectionStringW(DWORD, const(GUID)*, ULONG, LPCWSTR, 2395 + PACTCTX_SECTION_KEYED_DATA); 2396 + BOOL GetCurrentActCtx(HANDLE*); 2397 + VOID GetNativeSystemInfo(LPSYSTEM_INFO); 2398 + BOOL GetProcessHandleCount(HANDLE, PDWORD); 2399 + BOOL GetSystemRegistryQuota(PDWORD, PDWORD); 2400 + BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME); 2401 + UINT GetSystemWow64DirectoryA(LPSTR, UINT); 2402 + UINT GetSystemWow64DirectoryW(LPWSTR, UINT); 2403 + BOOL GetThreadIOPendingFlag(HANDLE, PBOOL); 2404 + BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD); 2405 + BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD); 2406 + UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG); 2407 + BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T); 2408 + BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T); 2409 + BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL); 2410 + BOOL IsWow64Process(HANDLE, PBOOL); 2411 + BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*); 2412 + BOOL QueryMemoryResourceNotification(HANDLE, PBOOL); 2413 + void ReleaseActCtx(HANDLE); 2414 + UINT ResetWriteWatch(LPVOID, SIZE_T); 2415 + BOOL SetFileShortNameA(HANDLE, LPCSTR); 2416 + BOOL SetFileShortNameW(HANDLE, LPCWSTR); 2417 + BOOL SetFileValidData(HANDLE, LONGLONG); 2418 + BOOL ZombifyActCtx(HANDLE); 2419 + } 2420 + 2421 + static if (_WIN32_WINNT >= 0x502) { 2422 + DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); 2423 + DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); 2424 + DWORD GetDllDirectoryA(DWORD, LPSTR); 2425 + DWORD GetDllDirectoryW(DWORD, LPWSTR); 2426 + DWORD GetThreadId(HANDLE); 2427 + DWORD GetProcessId(HANDLE); 2428 + HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD); 2429 + BOOL SetDllDirectoryA(LPCSTR); 2430 + BOOL SetDllDirectoryW(LPCWSTR); 2431 + BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); 2432 + BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); 2442 2433 } 2443 2434 2444 2435 // ??? 2445 2436 static if (_WIN32_WINNT >= 0x510) { 2446 2437 VOID RestoreLastError(DWORD); 2447 2438 } 2448 2439 } 2449 2440 2450 - 2441 +mixin DECLARE_AW!("STARTUPINFO"); 2451 2442 version (Unicode) { 2452 - alias STARTUPINFOW STARTUPINFO; 2443 + //alias STARTUPINFOW STARTUPINFO; 2453 2444 alias WIN32_FIND_DATAW WIN32_FIND_DATA; 2454 2445 alias ENUMRESLANGPROCW ENUMRESLANGPROC; 2455 2446 alias ENUMRESNAMEPROCW ENUMRESNAMEPROC; 2456 2447 alias ENUMRESTYPEPROCW ENUMRESTYPEPROC; 2457 2448 alias AddAtomW AddAtom; 2458 2449 alias BeginUpdateResourceW BeginUpdateResource; 2459 2450 alias BuildCommDCBW BuildCommDCB; ................................................................................ 2545 2536 alias SetVolumeLabelW SetVolumeLabel; 2546 2537 alias WaitNamedPipeW WaitNamedPipe; 2547 2538 alias WritePrivateProfileSectionW WritePrivateProfileSection; 2548 2539 alias WritePrivateProfileStringW WritePrivateProfileString; 2549 2540 alias WritePrivateProfileStructW WritePrivateProfileStruct; 2550 2541 alias WriteProfileSectionW WriteProfileSection; 2551 2542 alias WriteProfileStringW WriteProfileString; 2543 + alias CreateWaitableTimerW CreateWaitableTimer; 2544 + alias GetFileAttributesExW GetFileAttributesEx; 2545 + alias GetLongPathNameW GetLongPathName; 2546 + alias QueryDosDeviceW QueryDosDevice; 2547 + 2548 + alias HW_PROFILE_INFOW HW_PROFILE_INFO; 2549 + alias AccessCheckAndAuditAlarmW AccessCheckAndAuditAlarm; 2550 + alias BackupEventLogW BackupEventLog; 2551 + alias ClearEventLogW ClearEventLog; 2552 + alias CreateNamedPipeW CreateNamedPipe; 2553 + alias CreateProcessAsUserW CreateProcessAsUser; 2554 + alias DefineDosDeviceW DefineDosDevice; 2555 + alias FindFirstFileExW FindFirstFileEx; 2556 + alias GetBinaryTypeW GetBinaryType; 2557 + alias GetCompressedFileSizeW GetCompressedFileSize; 2558 + alias GetFileSecurityW GetFileSecurity; 2559 + alias LogonUserW LogonUser; 2560 + alias LookupAccountNameW LookupAccountName; 2561 + alias LookupAccountSidW LookupAccountSid; 2562 + alias LookupPrivilegeDisplayNameW LookupPrivilegeDisplayName; 2563 + alias LookupPrivilegeNameW LookupPrivilegeName; 2564 + alias LookupPrivilegeValueW LookupPrivilegeValue; 2565 + alias MoveFileExW MoveFileEx; 2566 + alias ObjectCloseAuditAlarmW ObjectCloseAuditAlarm; 2567 + alias ObjectDeleteAuditAlarmW ObjectDeleteAuditAlarm; 2568 + alias ObjectOpenAuditAlarmW ObjectOpenAuditAlarm; 2569 + alias ObjectPrivilegeAuditAlarmW ObjectPrivilegeAuditAlarm; 2570 + alias OpenBackupEventLogW OpenBackupEventLog; 2571 + alias OpenEventLogW OpenEventLog; 2572 + alias PrivilegedServiceAuditAlarmW PrivilegedServiceAuditAlarm; 2573 + alias ReadEventLogW ReadEventLog; 2574 + alias RegisterEventSourceW RegisterEventSource; 2575 + alias ReportEventW ReportEvent; 2576 + alias SetFileSecurityW SetFileSecurity; 2577 + alias UpdateResourceW UpdateResource; 2552 2578 2553 - static if (_WIN32_WINDOWS >= 0x410) { 2554 - alias CreateWaitableTimerW CreateWaitableTimer; 2555 - alias GetFileAttributesExW GetFileAttributesEx; 2556 - alias GetLongPathNameW GetLongPathName; 2557 - alias QueryDosDeviceW QueryDosDevice; 2579 + static if (_WIN32_WINNT >= 0x500) { 2580 + alias CreateFileMappingW CreateFileMapping; 2581 + alias CreateHardLinkW CreateHardLink; 2582 + alias CreateJobObjectW CreateJobObject; 2583 + alias DeleteVolumeMountPointW DeleteVolumeMountPoint; 2584 + alias DnsHostnameToComputerNameW DnsHostnameToComputerName; 2585 + alias EncryptFileW EncryptFile; 2586 + alias FileEncryptionStatusW FileEncryptionStatus; 2587 + alias FindFirstVolumeW FindFirstVolume; 2588 + alias FindFirstVolumeMountPointW FindFirstVolumeMountPoint; 2589 + alias FindNextVolumeW FindNextVolume; 2590 + alias FindNextVolumeMountPointW FindNextVolumeMountPoint; 2591 + alias GetModuleHandleExW GetModuleHandleEx; 2592 + alias GetSystemWindowsDirectoryW GetSystemWindowsDirectory; 2593 + alias GetVolumeNameForVolumeMountPointW GetVolumeNameForVolumeMountPoint; 2594 + alias GetVolumePathNameW GetVolumePathName; 2595 + alias OpenFileMappingW OpenFileMapping; 2596 + alias ReplaceFileW ReplaceFile; 2597 + alias SetVolumeMountPointW SetVolumeMountPoint; 2598 + alias VerifyVersionInfoW VerifyVersionInfo; 2558 2599 } 2559 2600 2560 - static if (_WIN32_WINNT_ONLY) { 2561 - alias HW_PROFILE_INFOW HW_PROFILE_INFO; 2562 - alias AccessCheckAndAuditAlarmW AccessCheckAndAuditAlarm; 2563 - alias BackupEventLogW BackupEventLog; 2564 - alias ClearEventLogW ClearEventLog; 2565 - alias CreateNamedPipeW CreateNamedPipe; 2566 - alias CreateProcessAsUserW CreateProcessAsUser; 2567 - alias DefineDosDeviceW DefineDosDevice; 2568 - alias FindFirstFileExW FindFirstFileEx; 2569 - alias GetBinaryTypeW GetBinaryType; 2570 - alias GetCompressedFileSizeW GetCompressedFileSize; 2571 - alias GetFileSecurityW GetFileSecurity; 2572 - alias LogonUserW LogonUser; 2573 - alias LookupAccountNameW LookupAccountName; 2574 - alias LookupAccountSidW LookupAccountSid; 2575 - alias LookupPrivilegeDisplayNameW LookupPrivilegeDisplayName; 2576 - alias LookupPrivilegeNameW LookupPrivilegeName; 2577 - alias LookupPrivilegeValueW LookupPrivilegeValue; 2578 - alias MoveFileExW MoveFileEx; 2579 - alias ObjectCloseAuditAlarmW ObjectCloseAuditAlarm; 2580 - alias ObjectDeleteAuditAlarmW ObjectDeleteAuditAlarm; 2581 - alias ObjectOpenAuditAlarmW ObjectOpenAuditAlarm; 2582 - alias ObjectPrivilegeAuditAlarmW ObjectPrivilegeAuditAlarm; 2583 - alias OpenBackupEventLogW OpenBackupEventLog; 2584 - alias OpenEventLogW OpenEventLog; 2585 - alias PrivilegedServiceAuditAlarmW PrivilegedServiceAuditAlarm; 2586 - alias ReadEventLogW ReadEventLog; 2587 - alias RegisterEventSourceW RegisterEventSource; 2588 - alias ReportEventW ReportEvent; 2589 - alias SetFileSecurityW SetFileSecurity; 2590 - alias UpdateResourceW UpdateResource; 2601 + static if (_WIN32_WINNT >= 0x501) { 2602 + alias ACTCTXW ACTCTX; 2603 + alias CheckNameLegalDOS8Dot3W CheckNameLegalDOS8Dot3; 2604 + alias CreateActCtxW CreateActCtx; 2605 + alias FindActCtxSectionStringW FindActCtxSectionString; 2606 + alias GetSystemWow64DirectoryW GetSystemWow64Directory; 2607 + alias GetVolumePathNamesForVolumeNameW GetVolumePathNamesForVolumeName; 2608 + alias SetFileShortNameW SetFileShortName; 2609 + } 2591 2610 2592 - static if (_WIN32_WINNT >= 0x500) { 2593 - alias CreateFileMappingW CreateFileMapping; 2594 - alias CreateHardLinkW CreateHardLink; 2595 - alias CreateJobObjectW CreateJobObject; 2596 - alias DeleteVolumeMountPointW DeleteVolumeMountPoint; 2597 - alias DnsHostnameToComputerNameW DnsHostnameToComputerName; 2598 - alias EncryptFileW EncryptFile; 2599 - alias FileEncryptionStatusW FileEncryptionStatus; 2600 - alias FindFirstVolumeW FindFirstVolume; 2601 - alias FindFirstVolumeMountPointW FindFirstVolumeMountPoint; 2602 - alias FindNextVolumeW FindNextVolume; 2603 - alias FindNextVolumeMountPointW FindNextVolumeMountPoint; 2604 - alias GetModuleHandleExW GetModuleHandleEx; 2605 - alias GetSystemWindowsDirectoryW GetSystemWindowsDirectory; 2606 - alias GetVolumeNameForVolumeMountPointW GetVolumeNameForVolumeMountPoint; 2607 - alias GetVolumePathNameW GetVolumePathName; 2608 - alias OpenFileMappingW OpenFileMapping; 2609 - alias ReplaceFileW ReplaceFile; 2610 - alias SetVolumeMountPointW SetVolumeMountPoint; 2611 - alias VerifyVersionInfoW VerifyVersionInfo; 2612 - } 2613 - 2614 - static if (_WIN32_WINNT >= 0x501) { 2615 - alias ACTCTXW ACTCTX; 2616 - alias CheckNameLegalDOS8Dot3W CheckNameLegalDOS8Dot3; 2617 - alias CreateActCtxW CreateActCtx; 2618 - alias FindActCtxSectionStringW FindActCtxSectionString; 2619 - alias GetSystemWow64DirectoryW GetSystemWow64Directory; 2620 - alias GetVolumePathNamesForVolumeNameW GetVolumePathNamesForVolumeName; 2621 - alias SetFileShortNameW SetFileShortName; 2622 - } 2623 - 2624 - static if (_WIN32_WINNT >= 0x502) { 2625 - alias SetFirmwareEnvironmentVariableW SetFirmwareEnvironmentVariable; 2626 - alias SetDllDirectoryW SetDllDirectory; 2627 - alias GetDllDirectoryW GetDllDirectory; 2628 - } 2611 + static if (_WIN32_WINNT >= 0x502) { 2612 + alias SetFirmwareEnvironmentVariableW SetFirmwareEnvironmentVariable; 2613 + alias SetDllDirectoryW SetDllDirectory; 2614 + alias GetDllDirectoryW GetDllDirectory; 2629 2615 } 2630 2616 2631 2617 } else { 2632 - alias STARTUPINFOA STARTUPINFO; 2618 + //alias STARTUPINFOA STARTUPINFO; 2633 2619 alias WIN32_FIND_DATAA WIN32_FIND_DATA; 2634 2620 alias ENUMRESLANGPROCW ENUMRESLANGPROC; 2635 2621 alias ENUMRESNAMEPROCW ENUMRESNAMEPROC; 2636 2622 alias ENUMRESTYPEPROCW ENUMRESTYPEPROC; 2637 2623 alias AddAtomA AddAtom; 2638 2624 alias BeginUpdateResourceA BeginUpdateResource; 2639 2625 alias BuildCommDCBA BuildCommDCB; ................................................................................ 2724 2710 alias SetVolumeLabelA SetVolumeLabel; 2725 2711 alias WaitNamedPipeA WaitNamedPipe; 2726 2712 alias WritePrivateProfileSectionA WritePrivateProfileSection; 2727 2713 alias WritePrivateProfileStringA WritePrivateProfileString; 2728 2714 alias WritePrivateProfileStructA WritePrivateProfileStruct; 2729 2715 alias WriteProfileSectionA WriteProfileSection; 2730 2716 alias WriteProfileStringA WriteProfileString; 2717 + alias CreateWaitableTimerA CreateWaitableTimer; 2718 + alias GetFileAttributesExA GetFileAttributesEx; 2719 + alias GetLongPathNameA GetLongPathName; 2720 + alias QueryDosDeviceA QueryDosDevice; 2721 + 2722 + alias HW_PROFILE_INFOA HW_PROFILE_INFO; 2723 + alias AccessCheckAndAuditAlarmA AccessCheckAndAuditAlarm; 2724 + alias BackupEventLogA BackupEventLog; 2725 + alias ClearEventLogA ClearEventLog; 2726 + alias CreateNamedPipeA CreateNamedPipe; 2727 + alias CreateProcessAsUserA CreateProcessAsUser; 2728 + alias DefineDosDeviceA DefineDosDevice; 2729 + alias FindFirstFileExA FindFirstFileEx; 2730 + alias GetBinaryTypeA GetBinaryType; 2731 + alias GetCompressedFileSizeA GetCompressedFileSize; 2732 + alias GetFileSecurityA GetFileSecurity; 2733 + alias LogonUserA LogonUser; 2734 + alias LookupAccountNameA LookupAccountName; 2735 + alias LookupAccountSidA LookupAccountSid; 2736 + alias LookupPrivilegeDisplayNameA LookupPrivilegeDisplayName; 2737 + alias LookupPrivilegeNameA LookupPrivilegeName; 2738 + alias LookupPrivilegeValueA LookupPrivilegeValue; 2739 + alias MoveFileExA MoveFileEx; 2740 + alias ObjectCloseAuditAlarmA ObjectCloseAuditAlarm; 2741 + alias ObjectDeleteAuditAlarmA ObjectDeleteAuditAlarm; 2742 + alias ObjectOpenAuditAlarmA ObjectOpenAuditAlarm; 2743 + alias ObjectPrivilegeAuditAlarmA ObjectPrivilegeAuditAlarm; 2744 + alias OpenBackupEventLogA OpenBackupEventLog; 2745 + alias OpenEventLogA OpenEventLog; 2746 + alias PrivilegedServiceAuditAlarmA PrivilegedServiceAuditAlarm; 2747 + alias ReadEventLogA ReadEventLog; 2748 + alias RegisterEventSourceA RegisterEventSource; 2749 + alias ReportEventA ReportEvent; 2750 + alias SetFileSecurityA SetFileSecurity; 2751 + alias UpdateResourceA UpdateResource; 2731 2752 2732 - static if (_WIN32_WINDOWS >= 0x410) { 2733 - alias CreateWaitableTimerA CreateWaitableTimer; 2734 - alias GetFileAttributesExA GetFileAttributesEx; 2735 - alias GetLongPathNameA GetLongPathName; 2736 - alias QueryDosDeviceA QueryDosDevice; 2753 + static if (_WIN32_WINNT >= 0x500) { 2754 + alias CreateFileMappingA CreateFileMapping; 2755 + alias CreateHardLinkA CreateHardLink; 2756 + alias CreateJobObjectA CreateJobObject; 2757 + alias DeleteVolumeMountPointA DeleteVolumeMountPoint; 2758 + alias DnsHostnameToComputerNameA DnsHostnameToComputerName; 2759 + alias EncryptFileA EncryptFile; 2760 + alias FileEncryptionStatusA FileEncryptionStatus; 2761 + alias FindFirstVolumeA FindFirstVolume; 2762 + alias FindFirstVolumeMountPointA FindFirstVolumeMountPoint; 2763 + alias FindNextVolumeA FindNextVolume; 2764 + alias FindNextVolumeMountPointA FindNextVolumeMountPoint; 2765 + alias GetModuleHandleExA GetModuleHandleEx; 2766 + alias GetSystemWindowsDirectoryA GetSystemWindowsDirectory; 2767 + alias GetVolumeNameForVolumeMountPointA GetVolumeNameForVolumeMountPoint; 2768 + alias GetVolumePathNameA GetVolumePathName; 2769 + alias OpenFileMappingA OpenFileMapping; 2770 + alias ReplaceFileA ReplaceFile; 2771 + alias SetVolumeMountPointA SetVolumeMountPoint; 2772 + alias VerifyVersionInfoA VerifyVersionInfo; 2737 2773 } 2738 2774 2739 - static if (_WIN32_WINNT_ONLY) { 2740 - alias HW_PROFILE_INFOA HW_PROFILE_INFO; 2741 - alias AccessCheckAndAuditAlarmA AccessCheckAndAuditAlarm; 2742 - alias BackupEventLogA BackupEventLog; 2743 - alias ClearEventLogA ClearEventLog; 2744 - alias CreateNamedPipeA CreateNamedPipe; 2745 - alias CreateProcessAsUserA CreateProcessAsUser; 2746 - alias DefineDosDeviceA DefineDosDevice; 2747 - alias FindFirstFileExA FindFirstFileEx; 2748 - alias GetBinaryTypeA GetBinaryType; 2749 - alias GetCompressedFileSizeA GetCompressedFileSize; 2750 - alias GetFileSecurityA GetFileSecurity; 2751 - alias LogonUserA LogonUser; 2752 - alias LookupAccountNameA LookupAccountName; 2753 - alias LookupAccountSidA LookupAccountSid; 2754 - alias LookupPrivilegeDisplayNameA LookupPrivilegeDisplayName; 2755 - alias LookupPrivilegeNameA LookupPrivilegeName; 2756 - alias LookupPrivilegeValueA LookupPrivilegeValue; 2757 - alias MoveFileExA MoveFileEx; 2758 - alias ObjectCloseAuditAlarmA ObjectCloseAuditAlarm; 2759 - alias ObjectDeleteAuditAlarmA ObjectDeleteAuditAlarm; 2760 - alias ObjectOpenAuditAlarmA ObjectOpenAuditAlarm; 2761 - alias ObjectPrivilegeAuditAlarmA ObjectPrivilegeAuditAlarm; 2762 - alias OpenBackupEventLogA OpenBackupEventLog; 2763 - alias OpenEventLogA OpenEventLog; 2764 - alias PrivilegedServiceAuditAlarmA PrivilegedServiceAuditAlarm; 2765 - alias ReadEventLogA ReadEventLog; 2766 - alias RegisterEventSourceA RegisterEventSource; 2767 - alias ReportEventA ReportEvent; 2768 - alias SetFileSecurityA SetFileSecurity; 2769 - alias UpdateResourceA UpdateResource; 2775 + static if (_WIN32_WINNT >= 0x501) { 2776 + alias ACTCTXA ACTCTX; 2777 + alias CheckNameLegalDOS8Dot3A CheckNameLegalDOS8Dot3; 2778 + alias CreateActCtxA CreateActCtx; 2779 + alias FindActCtxSectionStringA FindActCtxSectionString; 2780 + alias GetSystemWow64DirectoryA GetSystemWow64Directory; 2781 + alias GetVolumePathNamesForVolumeNameA GetVolumePathNamesForVolumeName; 2782 + alias SetFileShortNameA SetFileShortName; 2783 + } 2770 2784 2771 - static if (_WIN32_WINNT >= 0x500) { 2772 - alias CreateFileMappingA CreateFileMapping; 2773 - alias CreateHardLinkA CreateHardLink; 2774 - alias CreateJobObjectA CreateJobObject; 2775 - alias DeleteVolumeMountPointA DeleteVolumeMountPoint; 2776 - alias DnsHostnameToComputerNameA DnsHostnameToComputerName; 2777 - alias EncryptFileA EncryptFile; 2778 - alias FileEncryptionStatusA FileEncryptionStatus; 2779 - alias FindFirstVolumeA FindFirstVolume; 2780 - alias FindFirstVolumeMountPointA FindFirstVolumeMountPoint; 2781 - alias FindNextVolumeA FindNextVolume; 2782 - alias FindNextVolumeMountPointA FindNextVolumeMountPoint; 2783 - alias GetModuleHandleExA GetModuleHandleEx; 2784 - alias GetSystemWindowsDirectoryA GetSystemWindowsDirectory; 2785 - alias GetVolumeNameForVolumeMountPointA GetVolumeNameForVolumeMountPoint; 2786 - alias GetVolumePathNameA GetVolumePathName; 2787 - alias OpenFileMappingA OpenFileMapping; 2788 - alias ReplaceFileA ReplaceFile; 2789 - alias SetVolumeMountPointA SetVolumeMountPoint; 2790 - alias VerifyVersionInfoA VerifyVersionInfo; 2791 - } 2792 - 2793 - static if (_WIN32_WINNT >= 0x501) { 2794 - alias ACTCTXA ACTCTX; 2795 - alias CheckNameLegalDOS8Dot3A CheckNameLegalDOS8Dot3; 2796 - alias CreateActCtxA CreateActCtx; 2797 - alias FindActCtxSectionStringA FindActCtxSectionString; 2798 - alias GetSystemWow64DirectoryA GetSystemWow64Directory; 2799 - alias GetVolumePathNamesForVolumeNameA GetVolumePathNamesForVolumeName; 2800 - alias SetFileShortNameA SetFileShortName; 2801 - } 2802 - 2803 - static if (_WIN32_WINNT >= 0x502) { 2804 - alias GetDllDirectoryA GetDllDirectory; 2805 - alias SetDllDirectoryA SetDllDirectory; 2806 - alias SetFirmwareEnvironmentVariableA SetFirmwareEnvironmentVariable; 2807 - } 2785 + static if (_WIN32_WINNT >= 0x502) { 2786 + alias GetDllDirectoryA GetDllDirectory; 2787 + alias SetDllDirectoryA SetDllDirectory; 2788 + alias SetFirmwareEnvironmentVariableA SetFirmwareEnvironmentVariable; 2808 2789 } 2809 2790 } 2810 2791 2811 2792 alias STARTUPINFO* LPSTARTUPINFO; 2812 2793 alias WIN32_FIND_DATA* LPWIN32_FIND_DATA; 2813 2794 2814 -static if (_WIN32_WINNT_ONLY) { 2815 - alias HW_PROFILE_INFO* LPHW_PROFILE_INFO; 2795 +alias HW_PROFILE_INFO* LPHW_PROFILE_INFO; 2816 2796 2817 - static if (_WIN32_WINNT >= 0x501) { 2818 - alias ACTCTX* PACTCTX, PCACTCTX; 2819 - } 2797 +static if (_WIN32_WINNT >= 0x501) { 2798 + alias ACTCTX* PACTCTX, PCACTCTX; 2820 2799 }