ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

RtlNtStatusToDosError: Added new NT status to error codes mapping, 

added missed definitions of the used constants, created unit test for
subset of the mappings.
This commit is contained in:
Andriy Palamarchuk 2002-09-09 19:25:29 +00:00 committed by Alexandre Julliard
parent 8fce1a4c8e
commit 442f5f56d1
6 changed files with 2254 additions and 469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1445
dlls/ntdll/error.c
View File

File diff suppressed because it is too large Load Diff

1
dlls/ntdll/tests/.cvsignore
View File

@ -1,4 +1,5 @@
Makefile Makefile
error.ok
ntdll_test.exe.spec.c ntdll_test.exe.spec.c
rtlbitmap.ok rtlbitmap.ok
testlist.c testlist.c

1
dlls/ntdll/tests/Makefile.in
View File

@ -6,6 +6,7 @@ TESTDLL = ntdll.dll
IMPORTS = ntdll IMPORTS = ntdll
CTESTS = \ CTESTS = \
error.c \
rtlbitmap.c rtlbitmap.c
@MAKE_TEST_RULES@ @MAKE_TEST_RULES@

913
dlls/ntdll/tests/error.c Normal file
View File

@ -0,0 +1,913 @@
/*
* Unit tests for RtlNtStatusToDosError function
*
* Copyright (c) 2002 Andriy Palamarchuk
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "winbase.h"
#include "winerror.h"
#include "rpcnterr.h"
#include "ntddk.h"
#include "ntsecapi.h"
#include "wine/test.h"
#include <stdio.h>
ULONG (*statustodoserror)(NTSTATUS Status);
void prepare_test(void)
{
HMODULE ntdll;
ntdll = LoadLibraryA("ntdll.dll");
statustodoserror = (ULONG (*)(NTSTATUS Status)) GetProcAddress(ntdll, "RtlNtStatusToDosError");
ok((int)statustodoserror, "Null Pointer to RtlNtStatusToDosError");
}
void cmp_call(long int win_nt, long int win32, char *message)
{
char buf[1000];
long int err;
err = statustodoserror(win_nt);
sprintf(buf, "%s Winnt: %lx, Expected error: %ld, error: %ld \n",
message, win_nt, win32, err);
ok(err == win32, buf);
}
void cmp_call2(long int win_nt, long int win32, char *message)
{
char buf[1000];
long int err;
err = statustodoserror(win_nt);
sprintf(buf, "%s Winnt: %lx, Expected error: %ld, error: %ld \n",
message, win_nt, win32, err);
ok((err == win32) || (err == ERROR_MR_MID_NOT_FOUND), buf);
}
#define cmp(status, error) cmp_call(status, error, \
"Test for nt status " #status " and error " #error " failed.")
#define cmp2(status, error) cmp_call2(status, error, \
"Test for nt status " #status " and error " #error " failed.")
void run_error_tests(void)
{
prepare_test();
cmp(STATUS_DATATYPE_MISALIGNMENT, ERROR_NOACCESS);
cmp(STATUS_ACCESS_VIOLATION, ERROR_NOACCESS);
cmp2(STATUS_DATATYPE_MISALIGNMENT_ERROR, ERROR_NOACCESS);
cmp(STATUS_CTL_FILE_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(STATUS_PORT_ALREADY_SET, ERROR_INVALID_PARAMETER);
cmp(STATUS_SECTION_NOT_IMAGE, ERROR_INVALID_PARAMETER);
cmp(STATUS_BAD_WORKING_SET_LIMIT, ERROR_INVALID_PARAMETER);
cmp(STATUS_WORKING_SET_LIMIT_RANGE, ERROR_INVALID_PARAMETER);
cmp(STATUS_INCOMPATIBLE_FILE_MAP, ERROR_INVALID_PARAMETER);
cmp(STATUS_PORT_DISCONNECTED, ERROR_INVALID_HANDLE);
cmp(STATUS_NOT_LOCKED, ERROR_NOT_LOCKED);
cmp(STATUS_NOT_MAPPED_VIEW, ERROR_INVALID_ADDRESS);
cmp(STATUS_UNABLE_TO_FREE_VM, ERROR_INVALID_PARAMETER);
cmp(STATUS_UNABLE_TO_DELETE_SECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_MORE_PROCESSING_REQUIRED, ERROR_MORE_DATA);
cmp(STATUS_INVALID_CID, ERROR_INVALID_PARAMETER);
cmp(STATUS_STACK_OVERFLOW, ERROR_STACK_OVERFLOW);
cmp(STATUS_BAD_INITIAL_STACK, ERROR_STACK_OVERFLOW);
cmp(STATUS_INVALID_VOLUME_LABEL, ERROR_LABEL_TOO_LONG);
cmp(STATUS_SECTION_NOT_EXTENDED, ERROR_OUTOFMEMORY);
cmp(STATUS_NOT_MAPPED_DATA, ERROR_INVALID_ADDRESS);
cmp2(STATUS_NO_LDT, ERROR_INVALID_THREAD_ID);
cmp(STATUS_INFO_LENGTH_MISMATCH, ERROR_BAD_LENGTH);
cmp(STATUS_INVALID_INFO_CLASS, ERROR_INVALID_PARAMETER);
cmp(STATUS_SUSPEND_COUNT_EXCEEDED, ERROR_SIGNAL_REFUSED);
cmp(STATUS_NOTIFY_ENUM_DIR, ERROR_NOTIFY_ENUM_DIR);
cmp(STATUS_REGISTRY_RECOVERED, ERROR_REGISTRY_RECOVERED);
cmp(STATUS_REGISTRY_IO_FAILED, ERROR_REGISTRY_IO_FAILED);
cmp(STATUS_NOT_REGISTRY_FILE, ERROR_NOT_REGISTRY_FILE);
cmp(STATUS_KEY_DELETED, ERROR_KEY_DELETED);
cmp(STATUS_NO_LOG_SPACE, ERROR_NO_LOG_SPACE);
cmp(STATUS_KEY_HAS_CHILDREN, ERROR_KEY_HAS_CHILDREN);
cmp(STATUS_CHILD_MUST_BE_VOLATILE, ERROR_CHILD_MUST_BE_VOLATILE);
cmp(STATUS_REGISTRY_CORRUPT, ERROR_BADDB);
cmp(STATUS_DLL_NOT_FOUND, ERROR_MOD_NOT_FOUND);
cmp(STATUS_DLL_INIT_FAILED, ERROR_DLL_INIT_FAILED);
cmp2(STATUS_INVALID_IMPORT_OF_NON_DLL, ERROR_INVALID_IMPORT_OF_NON_DLL);
cmp(STATUS_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
cmp(STATUS_DRIVER_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
cmp2(STATUS_DRIVER_UNABLE_TO_LOAD, ERROR_BAD_DRIVER);
cmp(STATUS_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
cmp(STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
cmp(STATUS_PENDING, ERROR_IO_PENDING);
cmp(STATUS_MORE_ENTRIES, ERROR_MORE_DATA);
cmp(STATUS_INTEGER_OVERFLOW, ERROR_ARITHMETIC_OVERFLOW);
cmp(STATUS_BUFFER_OVERFLOW, ERROR_MORE_DATA);
cmp(STATUS_NO_MORE_FILES, ERROR_NO_MORE_FILES);
cmp(STATUS_NO_INHERITANCE, ERROR_NO_INHERITANCE);
cmp(STATUS_NO_MORE_EAS, ERROR_NO_MORE_ITEMS);
cmp(STATUS_NO_MORE_ENTRIES, ERROR_NO_MORE_ITEMS);
cmp(STATUS_GUIDS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
cmp(STATUS_AGENTS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
cmp(STATUS_UNSUCCESSFUL, ERROR_GEN_FAILURE);
cmp(STATUS_TOO_MANY_LINKS, ERROR_TOO_MANY_LINKS);
cmp(STATUS_NOT_IMPLEMENTED, ERROR_INVALID_FUNCTION);
cmp(STATUS_ILLEGAL_FUNCTION, ERROR_INVALID_FUNCTION);
cmp(STATUS_IN_PAGE_ERROR, ERROR_SWAPERROR);
cmp(STATUS_PAGEFILE_QUOTA, ERROR_PAGEFILE_QUOTA);
cmp(STATUS_COMMITMENT_LIMIT, ERROR_COMMITMENT_LIMIT);
cmp(STATUS_SECTION_TOO_BIG, ERROR_NOT_ENOUGH_MEMORY);
cmp(RPC_NT_SS_IN_NULL_CONTEXT, ERROR_INVALID_HANDLE);
cmp(RPC_NT_INVALID_BINDING, ERROR_INVALID_HANDLE);
cmp(STATUS_INVALID_HANDLE, ERROR_INVALID_HANDLE);
cmp(STATUS_OBJECT_TYPE_MISMATCH, ERROR_INVALID_HANDLE);
cmp(STATUS_FILE_CLOSED, ERROR_INVALID_HANDLE);
cmp(STATUS_INVALID_PORT_HANDLE, ERROR_INVALID_HANDLE);
cmp(STATUS_HANDLE_NOT_CLOSABLE, ERROR_INVALID_HANDLE);
cmp(STATUS_NOT_COMMITTED, ERROR_INVALID_ADDRESS);
cmp(STATUS_PARTIAL_COPY, ERROR_PARTIAL_COPY);
cmp(STATUS_LPC_REPLY_LOST, ERROR_INTERNAL_ERROR);
cmp(STATUS_INVALID_PARAMETER, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_1, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_2, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_3, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_4, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_5, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_6, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_7, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_8, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_9, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_10, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_11, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_12, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_MIX, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PAGE_PROTECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_SECTION_PROTECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_RESOURCE_DATA_NOT_FOUND, ERROR_RESOURCE_DATA_NOT_FOUND);
cmp(STATUS_RESOURCE_TYPE_NOT_FOUND, ERROR_RESOURCE_TYPE_NOT_FOUND);
cmp(STATUS_RESOURCE_NAME_NOT_FOUND, ERROR_RESOURCE_NAME_NOT_FOUND);
cmp(STATUS_RESOURCE_LANG_NOT_FOUND, ERROR_RESOURCE_LANG_NOT_FOUND);
cmp(STATUS_NO_SUCH_DEVICE, ERROR_FILE_NOT_FOUND);
cmp(STATUS_NO_SUCH_FILE, ERROR_FILE_NOT_FOUND);
cmp(STATUS_INVALID_DEVICE_REQUEST, ERROR_INVALID_FUNCTION);
cmp2(STATUS_VOLUME_NOT_UPGRADED, ERROR_INVALID_FUNCTION);
cmp(STATUS_END_OF_FILE, ERROR_HANDLE_EOF);
cmp(STATUS_FILE_FORCED_CLOSED, ERROR_HANDLE_EOF);
cmp(STATUS_WRONG_VOLUME, ERROR_WRONG_DISK);
cmp(STATUS_NO_MEDIA, ERROR_NO_MEDIA_IN_DRIVE);
cmp(STATUS_NO_MEDIA_IN_DEVICE, ERROR_NOT_READY);
cmp(STATUS_VOLUME_DISMOUNTED, ERROR_NOT_READY);
cmp(STATUS_NONEXISTENT_SECTOR, ERROR_SECTOR_NOT_FOUND);
cmp(STATUS_WORKING_SET_QUOTA, ERROR_WORKING_SET_QUOTA);
cmp(STATUS_NO_MEMORY, ERROR_NOT_ENOUGH_MEMORY);
cmp(STATUS_CONFLICTING_ADDRESSES, ERROR_INVALID_ADDRESS);
cmp(STATUS_INVALID_SYSTEM_SERVICE, ERROR_INVALID_FUNCTION);
cmp(STATUS_THREAD_IS_TERMINATING, ERROR_ACCESS_DENIED);
cmp(STATUS_PROCESS_IS_TERMINATING, ERROR_ACCESS_DENIED);
cmp(STATUS_INVALID_LOCK_SEQUENCE, ERROR_ACCESS_DENIED);
cmp(STATUS_INVALID_VIEW_SIZE, ERROR_ACCESS_DENIED);
cmp(STATUS_ALREADY_COMMITTED, ERROR_ACCESS_DENIED);
cmp(STATUS_ACCESS_DENIED, ERROR_ACCESS_DENIED);
cmp(STATUS_FILE_IS_A_DIRECTORY, ERROR_ACCESS_DENIED);
cmp(STATUS_CANNOT_DELETE, ERROR_ACCESS_DENIED);
cmp(STATUS_INVALID_COMPUTER_NAME, ERROR_INVALID_COMPUTERNAME);
cmp(STATUS_FILE_DELETED, ERROR_ACCESS_DENIED);
cmp2(STATUS_FILE_RENAMED, ERROR_ACCESS_DENIED);
cmp(STATUS_DELETE_PENDING, ERROR_ACCESS_DENIED);
cmp(STATUS_PORT_CONNECTION_REFUSED, ERROR_ACCESS_DENIED);
cmp(STATUS_NO_SUCH_PRIVILEGE, ERROR_NO_SUCH_PRIVILEGE);
cmp(STATUS_PRIVILEGE_NOT_HELD, ERROR_PRIVILEGE_NOT_HELD);
cmp(STATUS_CANNOT_IMPERSONATE, ERROR_CANNOT_IMPERSONATE);
cmp(STATUS_LOGON_FAILURE, ERROR_LOGON_FAILURE);
cmp2(STATUS_MUTUAL_AUTHENTICATION_FAILED, ERROR_MUTUAL_AUTH_FAILED);
cmp2(STATUS_TIME_DIFFERENCE_AT_DC, ERROR_TIME_SKEW);
cmp2(STATUS_PKINIT_FAILURE, ERROR_PKINIT_FAILURE);
cmp2(STATUS_SMARTCARD_SUBSYSTEM_FAILURE, ERROR_SMARTCARD_SUBSYSTEM_FAILURE);
cmp2(STATUS_DOWNGRADE_DETECTED, ERROR_DOWNGRADE_DETECTED);
cmp2(STATUS_SMARTCARD_CERT_REVOKED, SEC_E_SMARTCARD_CERT_REVOKED);
cmp2(STATUS_ISSUING_CA_UNTRUSTED, SEC_E_ISSUING_CA_UNTRUSTED);
cmp2(STATUS_REVOCATION_OFFLINE_C, SEC_E_REVOCATION_OFFLINE_C);
cmp2(STATUS_PKINIT_CLIENT_FAILURE, SEC_E_PKINIT_CLIENT_FAILURE);
cmp2(STATUS_SMARTCARD_CERT_EXPIRED, SEC_E_SMARTCARD_CERT_EXPIRED);
cmp2(STATUS_NO_KERB_KEY, SEC_E_NO_KERB_KEY);
cmp2(STATUS_CURRENT_DOMAIN_NOT_ALLOWED, ERROR_CURRENT_DOMAIN_NOT_ALLOWED);
cmp2(STATUS_SMARTCARD_WRONG_PIN, SCARD_W_WRONG_CHV);
cmp2(STATUS_SMARTCARD_CARD_BLOCKED, SCARD_W_CHV_BLOCKED);
cmp2(STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED,SCARD_W_CARD_NOT_AUTHENTICATED);
cmp2(STATUS_SMARTCARD_NO_CARD, SCARD_E_NO_SMARTCARD);
cmp2(STATUS_SMARTCARD_NO_KEY_CONTAINER, NTE_NO_KEY);
cmp2(STATUS_SMARTCARD_NO_CERTIFICATE, SCARD_E_NO_SUCH_CERTIFICATE);
cmp2(STATUS_SMARTCARD_NO_KEYSET, NTE_BAD_KEYSET);
cmp2(STATUS_SMARTCARD_IO_ERROR, SCARD_E_COMM_DATA_LOST);
cmp(STATUS_ACCOUNT_RESTRICTION, ERROR_ACCOUNT_RESTRICTION);
cmp(STATUS_INVALID_LOGON_HOURS, ERROR_INVALID_LOGON_HOURS);
cmp(STATUS_INVALID_WORKSTATION, ERROR_INVALID_WORKSTATION);
cmp(STATUS_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
cmp(STATUS_UNABLE_TO_DECOMMIT_VM, ERROR_INVALID_ADDRESS);
cmp(STATUS_DISK_CORRUPT_ERROR, ERROR_DISK_CORRUPT);
cmp(STATUS_FT_MISSING_MEMBER, ERROR_IO_DEVICE);
cmp(STATUS_FT_ORPHANING, ERROR_IO_DEVICE);
cmp(STATUS_VARIABLE_NOT_FOUND, ERROR_ENVVAR_NOT_FOUND);
cmp(STATUS_OBJECT_NAME_INVALID, ERROR_INVALID_NAME);
cmp(STATUS_OBJECT_NAME_NOT_FOUND, ERROR_FILE_NOT_FOUND);
cmp(STATUS_OBJECT_NAME_COLLISION, ERROR_ALREADY_EXISTS);
cmp(STATUS_OBJECT_PATH_INVALID, ERROR_BAD_PATHNAME);
cmp(STATUS_OBJECT_PATH_NOT_FOUND, ERROR_PATH_NOT_FOUND);
cmp(STATUS_DFS_EXIT_PATH_FOUND, ERROR_PATH_NOT_FOUND);
cmp2(STATUS_DFS_UNAVAILABLE, ERROR_CONNECTION_UNAVAIL);
cmp(STATUS_OBJECT_PATH_SYNTAX_BAD, ERROR_BAD_PATHNAME);
cmp(STATUS_NAME_TOO_LONG, ERROR_FILENAME_EXCED_RANGE);
cmp(STATUS_DATA_OVERRUN, ERROR_IO_DEVICE);
cmp(STATUS_DATA_LATE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DATA_ERROR, ERROR_CRC);
cmp(STATUS_CRC_ERROR, ERROR_CRC);
cmp(STATUS_SHARING_VIOLATION, ERROR_SHARING_VIOLATION);
cmp(STATUS_QUOTA_EXCEEDED, ERROR_NOT_ENOUGH_QUOTA);
cmp(STATUS_MUTANT_NOT_OWNED, ERROR_NOT_OWNER);
cmp(STATUS_SEMAPHORE_LIMIT_EXCEEDED, ERROR_TOO_MANY_POSTS);
cmp(STATUS_DISK_FULL, ERROR_DISK_FULL);
cmp(STATUS_LOCK_NOT_GRANTED, ERROR_LOCK_VIOLATION);
cmp(STATUS_FILE_LOCK_CONFLICT, ERROR_LOCK_VIOLATION);
cmp(STATUS_NOT_A_DIRECTORY, ERROR_DIRECTORY);
cmp2(STATUS_CANNOT_MAKE, ERROR_CANNOT_MAKE);
cmp(STATUS_UNKNOWN_REVISION, ERROR_UNKNOWN_REVISION);
cmp(STATUS_REVISION_MISMATCH, ERROR_REVISION_MISMATCH);
cmp(STATUS_INVALID_OWNER, ERROR_INVALID_OWNER);
cmp(STATUS_INVALID_PRIMARY_GROUP, ERROR_INVALID_PRIMARY_GROUP);
cmp(STATUS_NO_IMPERSONATION_TOKEN, ERROR_NO_IMPERSONATION_TOKEN);
cmp(STATUS_CANT_DISABLE_MANDATORY, ERROR_CANT_DISABLE_MANDATORY);
cmp(STATUS_NO_LOGON_SERVERS, ERROR_NO_LOGON_SERVERS);
cmp(STATUS_DOMAIN_CONTROLLER_NOT_FOUND, ERROR_DOMAIN_CONTROLLER_NOT_FOUND);
cmp(STATUS_NO_SUCH_LOGON_SESSION, ERROR_NO_SUCH_LOGON_SESSION);
cmp(STATUS_INVALID_ACCOUNT_NAME, ERROR_INVALID_ACCOUNT_NAME);
cmp(STATUS_USER_EXISTS, ERROR_USER_EXISTS);
cmp(STATUS_NO_SUCH_USER, ERROR_NO_SUCH_USER);
cmp(STATUS_GROUP_EXISTS, ERROR_GROUP_EXISTS);
cmp(STATUS_NO_SUCH_GROUP, ERROR_NO_SUCH_GROUP);
cmp(STATUS_SPECIAL_GROUP, ERROR_SPECIAL_GROUP);
cmp(STATUS_MEMBER_IN_GROUP, ERROR_MEMBER_IN_GROUP);
cmp(STATUS_MEMBER_NOT_IN_GROUP, ERROR_MEMBER_NOT_IN_GROUP);
cmp(STATUS_LAST_ADMIN, ERROR_LAST_ADMIN);
cmp(STATUS_WRONG_PASSWORD, ERROR_INVALID_PASSWORD);
cmp(STATUS_WRONG_PASSWORD_CORE, ERROR_INVALID_PASSWORD);
cmp(STATUS_ILL_FORMED_PASSWORD, ERROR_ILL_FORMED_PASSWORD);
cmp(STATUS_PASSWORD_RESTRICTION, ERROR_PASSWORD_RESTRICTION);
cmp(STATUS_PASSWORD_EXPIRED, ERROR_PASSWORD_EXPIRED);
cmp(STATUS_PASSWORD_MUST_CHANGE, ERROR_PASSWORD_MUST_CHANGE);
cmp(STATUS_ACCOUNT_DISABLED, ERROR_ACCOUNT_DISABLED);
cmp(STATUS_ACCOUNT_LOCKED_OUT, ERROR_ACCOUNT_LOCKED_OUT);
cmp(STATUS_NONE_MAPPED, ERROR_NONE_MAPPED);
cmp(STATUS_TOO_MANY_LUIDS_REQUESTED, ERROR_TOO_MANY_LUIDS_REQUESTED);
cmp(STATUS_LUIDS_EXHAUSTED, ERROR_LUIDS_EXHAUSTED);
cmp(STATUS_INVALID_SUB_AUTHORITY, ERROR_INVALID_SUB_AUTHORITY);
cmp(STATUS_INVALID_ACL, ERROR_INVALID_ACL);
cmp(STATUS_INVALID_SID, ERROR_INVALID_SID);
cmp(STATUS_INVALID_SECURITY_DESCR, ERROR_INVALID_SECURITY_DESCR);
cmp(STATUS_PROCEDURE_NOT_FOUND, ERROR_PROC_NOT_FOUND);
cmp(STATUS_BAD_INITIAL_PC, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_FILE_FOR_SECTION, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_IMAGE_MP_UP_MISMATCH, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_NOT_MZ, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_IMAGE_CHECKSUM_MISMATCH, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_PROTECT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_LE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_NE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_WIN_16, ERROR_BAD_EXE_FORMAT);
cmp2(STATUS_INVALID_IMAGE_WIN_32, ERROR_BAD_EXE_FORMAT);
cmp2(STATUS_INVALID_IMAGE_WIN_64, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_NO_TOKEN, ERROR_NO_TOKEN);
cmp(STATUS_RANGE_NOT_LOCKED, ERROR_NOT_LOCKED);
cmp(STATUS_SERVER_DISABLED, ERROR_SERVER_DISABLED);
cmp(STATUS_SERVER_NOT_DISABLED, ERROR_SERVER_NOT_DISABLED);
cmp(STATUS_INVALID_ID_AUTHORITY, ERROR_INVALID_ID_AUTHORITY);
cmp(STATUS_ALLOTTED_SPACE_EXCEEDED, ERROR_ALLOTTED_SPACE_EXCEEDED);
cmp(STATUS_TOO_MANY_PAGING_FILES, ERROR_NOT_ENOUGH_MEMORY);
cmp(STATUS_INSUFFICIENT_RESOURCES, ERROR_NO_SYSTEM_RESOURCES);
cmp(STATUS_INSUFF_SERVER_RESOURCES, ERROR_NOT_ENOUGH_SERVER_MEMORY);
cmp(STATUS_FILE_INVALID, ERROR_FILE_INVALID);
cmp(STATUS_MAPPED_FILE_SIZE_ZERO, ERROR_FILE_INVALID);
cmp(STATUS_DEVICE_PAPER_EMPTY, ERROR_OUT_OF_PAPER);
cmp(STATUS_DEVICE_POWERED_OFF, ERROR_NOT_READY);
cmp(STATUS_DEVICE_OFF_LINE, ERROR_NOT_READY);
cmp(STATUS_DEVICE_DATA_ERROR, ERROR_CRC);
cmp(STATUS_DEVICE_NOT_READY, ERROR_NOT_READY);
cmp(STATUS_DEVICE_NOT_CONNECTED, ERROR_NOT_READY);
cmp(STATUS_DEVICE_POWER_FAILURE, ERROR_NOT_READY);
cmp2(STATUS_NOT_FOUND, ERROR_NOT_FOUND);
cmp2(STATUS_NO_MATCH, ERROR_NO_MATCH);
cmp2(STATUS_PROPSET_NOT_FOUND, ERROR_SET_NOT_FOUND);
cmp(STATUS_DEVICE_BUSY, ERROR_BUSY);
cmp(STATUS_FREE_VM_NOT_AT_BASE, ERROR_INVALID_ADDRESS);
cmp(STATUS_MEMORY_NOT_ALLOCATED, ERROR_INVALID_ADDRESS);
cmp(STATUS_NOT_SAME_DEVICE, ERROR_NOT_SAME_DEVICE);
cmp(STATUS_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(STATUS_REMOTE_NOT_LISTENING, ERROR_REM_NOT_LIST);
cmp(STATUS_DUPLICATE_NAME, ERROR_DUP_NAME);
cmp(STATUS_BAD_NETWORK_PATH, ERROR_BAD_NETPATH);
cmp(STATUS_NETWORK_BUSY, ERROR_NETWORK_BUSY);
cmp2(STATUS_ONLY_IF_CONNECTED, ERROR_ONLY_IF_CONNECTED);
cmp(STATUS_DEVICE_DOES_NOT_EXIST, ERROR_DEV_NOT_EXIST);
cmp(STATUS_TOO_MANY_COMMANDS, ERROR_TOO_MANY_CMDS);
cmp(STATUS_ADAPTER_HARDWARE_ERROR, ERROR_ADAP_HDW_ERR);
cmp(STATUS_REDIRECTOR_NOT_STARTED, ERROR_PATH_NOT_FOUND);
cmp(STATUS_INVALID_EA_NAME, ERROR_INVALID_EA_NAME);
cmp(STATUS_EA_LIST_INCONSISTENT, ERROR_EA_LIST_INCONSISTENT);
cmp(STATUS_EA_TOO_LARGE, ERROR_EA_LIST_INCONSISTENT);
cmp(STATUS_INVALID_EA_FLAG, ERROR_EA_LIST_INCONSISTENT);
cmp2(STATUS_EAS_NOT_SUPPORTED, ERROR_EAS_NOT_SUPPORTED);
cmp(STATUS_FILE_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
cmp(STATUS_EA_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
cmp(STATUS_NONEXISTENT_EA_ENTRY, ERROR_FILE_CORRUPT);
cmp(STATUS_NO_EAS_ON_FILE, ERROR_FILE_CORRUPT);
cmp2(STATUS_NOT_A_REPARSE_POINT, ERROR_NOT_A_REPARSE_POINT);
cmp2(STATUS_IO_REPARSE_TAG_INVALID, ERROR_REPARSE_TAG_INVALID);
cmp2(STATUS_IO_REPARSE_TAG_MISMATCH, ERROR_REPARSE_TAG_MISMATCH);
cmp2(STATUS_IO_REPARSE_TAG_NOT_HANDLED, ERROR_CANT_ACCESS_FILE);
cmp2(STATUS_REPARSE_POINT_NOT_RESOLVED, ERROR_CANT_RESOLVE_FILENAME);
cmp2(STATUS_DIRECTORY_IS_A_REPARSE_POINT, ERROR_BAD_PATHNAME);
cmp2(STATUS_REPARSE_ATTRIBUTE_CONFLICT, ERROR_REPARSE_ATTRIBUTE_CONFLICT);
cmp2(STATUS_IO_REPARSE_DATA_INVALID, ERROR_INVALID_REPARSE_DATA);
cmp2(STATUS_FILE_IS_OFFLINE, ERROR_FILE_OFFLINE);
cmp2(STATUS_REMOTE_STORAGE_NOT_ACTIVE, ERROR_REMOTE_STORAGE_NOT_ACTIVE);
cmp2(STATUS_REMOTE_STORAGE_MEDIA_ERROR, ERROR_REMOTE_STORAGE_MEDIA_ERROR);
cmp2(STATUS_NO_TRACKING_SERVICE, ERROR_NO_TRACKING_SERVICE);
cmp2(STATUS_JOURNAL_DELETE_IN_PROGRESS, ERROR_JOURNAL_DELETE_IN_PROGRESS);
cmp2(STATUS_JOURNAL_NOT_ACTIVE, ERROR_JOURNAL_NOT_ACTIVE);
cmp2(STATUS_JOURNAL_ENTRY_DELETED, ERROR_JOURNAL_ENTRY_DELETED);
cmp(STATUS_INVALID_NETWORK_RESPONSE, ERROR_BAD_NET_RESP);
cmp(STATUS_USER_SESSION_DELETED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_UNEXPECTED_NETWORK_ERROR, ERROR_UNEXP_NET_ERR);
cmp(STATUS_BAD_REMOTE_ADAPTER, ERROR_BAD_REM_ADAP);
cmp(STATUS_PRINT_QUEUE_FULL, ERROR_PRINTQ_FULL);
cmp(STATUS_NO_SPOOL_SPACE, ERROR_NO_SPOOL_SPACE);
cmp(STATUS_PRINT_CANCELLED, ERROR_PRINT_CANCELLED);
cmp(STATUS_NETWORK_NAME_DELETED, ERROR_NETNAME_DELETED);
cmp(STATUS_NETWORK_ACCESS_DENIED, ERROR_NETWORK_ACCESS_DENIED);
cmp(STATUS_BAD_DEVICE_TYPE, ERROR_BAD_DEV_TYPE);
cmp(STATUS_BAD_NETWORK_NAME, ERROR_BAD_NET_NAME);
cmp(STATUS_TOO_MANY_NAMES, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_GUIDS_REQUESTED, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_ADDRESSES, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_NODES, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_SESSIONS, ERROR_TOO_MANY_SESS);
cmp(STATUS_SHARING_PAUSED, ERROR_SHARING_PAUSED);
cmp(STATUS_REQUEST_NOT_ACCEPTED, ERROR_REQ_NOT_ACCEP);
cmp(STATUS_REDIRECTOR_PAUSED, ERROR_REDIR_PAUSED);
cmp(STATUS_NET_WRITE_FAULT, ERROR_NET_WRITE_FAULT);
cmp(STATUS_VIRTUAL_CIRCUIT_CLOSED, ERROR_VC_DISCONNECTED);
cmp(STATUS_INVALID_PIPE_STATE, ERROR_BAD_PIPE);
cmp(STATUS_INVALID_READ_MODE, ERROR_BAD_PIPE);
cmp(STATUS_PIPE_CLOSING, ERROR_NO_DATA);
cmp(STATUS_PIPE_EMPTY, ERROR_NO_DATA);
cmp(STATUS_PIPE_CONNECTED, ERROR_PIPE_CONNECTED);
cmp(STATUS_PIPE_DISCONNECTED, ERROR_PIPE_NOT_CONNECTED);
cmp(STATUS_PIPE_LISTENING, ERROR_PIPE_LISTENING);
cmp(STATUS_PIPE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
cmp(STATUS_INSTANCE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
cmp(STATUS_PIPE_BUSY, ERROR_PIPE_BUSY);
cmp(STATUS_PIPE_BROKEN, ERROR_BROKEN_PIPE);
cmp(STATUS_DIRECTORY_NOT_EMPTY, ERROR_DIR_NOT_EMPTY);
cmp(STATUS_TOO_MANY_OPENED_FILES, ERROR_TOO_MANY_OPEN_FILES);
cmp(STATUS_IO_TIMEOUT, ERROR_SEM_TIMEOUT);
cmp(STATUS_CANCELLED, ERROR_OPERATION_ABORTED);
cmp(STATUS_UNRECOGNIZED_MEDIA, ERROR_UNRECOGNIZED_MEDIA);
cmp(STATUS_INVALID_LEVEL, ERROR_INVALID_LEVEL);
cmp(STATUS_UNRECOGNIZED_VOLUME, ERROR_UNRECOGNIZED_VOLUME);
cmp(STATUS_MEDIA_WRITE_PROTECTED, ERROR_WRITE_PROTECT);
cmp(STATUS_TOO_LATE, ERROR_WRITE_PROTECT);
cmp(STATUS_SUCCESS, NO_ERROR);
cmp(STATUS_FULLSCREEN_MODE, ERROR_FULLSCREEN_MODE);
cmp(STATUS_END_OF_MEDIA, ERROR_END_OF_MEDIA);
cmp(STATUS_EOM_OVERFLOW, ERROR_EOM_OVERFLOW);
cmp(STATUS_BEGINNING_OF_MEDIA, ERROR_BEGINNING_OF_MEDIA);
cmp(STATUS_MEDIA_CHANGED, ERROR_MEDIA_CHANGED);
cmp(STATUS_BUS_RESET, ERROR_BUS_RESET);
cmp(STATUS_FILEMARK_DETECTED, ERROR_FILEMARK_DETECTED);
cmp(STATUS_SETMARK_DETECTED, ERROR_SETMARK_DETECTED);
cmp(STATUS_NO_DATA_DETECTED, ERROR_NO_DATA_DETECTED);
cmp(STATUS_PARTITION_FAILURE, ERROR_PARTITION_FAILURE);
cmp(STATUS_INVALID_BLOCK_LENGTH, ERROR_INVALID_BLOCK_LENGTH);
cmp(STATUS_DEVICE_NOT_PARTITIONED, ERROR_DEVICE_NOT_PARTITIONED);
cmp(STATUS_UNABLE_TO_LOCK_MEDIA, ERROR_UNABLE_TO_LOCK_MEDIA);
cmp(STATUS_UNABLE_TO_UNLOAD_MEDIA, ERROR_UNABLE_TO_UNLOAD_MEDIA);
cmp(STATUS_UNMAPPABLE_CHARACTER, ERROR_NO_UNICODE_TRANSLATION);
cmp(STATUS_NOT_ALL_ASSIGNED, ERROR_NOT_ALL_ASSIGNED);
cmp(STATUS_SOME_NOT_MAPPED, ERROR_SOME_NOT_MAPPED);
cmp(STATUS_NO_QUOTAS_FOR_ACCOUNT, ERROR_NO_QUOTAS_FOR_ACCOUNT);
cmp(STATUS_LOCAL_USER_SESSION_KEY, ERROR_LOCAL_USER_SESSION_KEY);
cmp(STATUS_NULL_LM_PASSWORD, ERROR_NULL_LM_PASSWORD);
cmp(STATUS_BAD_INHERITANCE_ACL, ERROR_BAD_INHERITANCE_ACL);
cmp(STATUS_INVALID_GROUP_ATTRIBUTES, ERROR_INVALID_GROUP_ATTRIBUTES);
cmp(STATUS_BAD_IMPERSONATION_LEVEL, ERROR_BAD_IMPERSONATION_LEVEL);
cmp(STATUS_CANT_OPEN_ANONYMOUS, ERROR_CANT_OPEN_ANONYMOUS);
cmp(STATUS_BAD_VALIDATION_CLASS, ERROR_BAD_VALIDATION_CLASS);
cmp(STATUS_BAD_TOKEN_TYPE, ERROR_BAD_TOKEN_TYPE);
cmp2(STATUS_BAD_MASTER_BOOT_RECORD, ERROR_INVALID_PARAMETER);
cmp(STATUS_NO_SECURITY_ON_OBJECT, ERROR_NO_SECURITY_ON_OBJECT);
cmp(STATUS_CANT_ACCESS_DOMAIN_INFO, ERROR_CANT_ACCESS_DOMAIN_INFO);
cmp(STATUS_INVALID_SERVER_STATE, ERROR_INVALID_SERVER_STATE);
cmp(STATUS_INVALID_DOMAIN_STATE, ERROR_INVALID_DOMAIN_STATE);
cmp(STATUS_INVALID_DOMAIN_ROLE, ERROR_INVALID_DOMAIN_ROLE);
cmp(STATUS_NO_SUCH_DOMAIN, ERROR_NO_SUCH_DOMAIN);
cmp(STATUS_DOMAIN_EXISTS, ERROR_DOMAIN_EXISTS);
cmp(STATUS_DOMAIN_LIMIT_EXCEEDED, ERROR_DOMAIN_LIMIT_EXCEEDED);
cmp2(STATUS_OPLOCK_NOT_GRANTED, ERROR_OPLOCK_NOT_GRANTED);
cmp2(STATUS_INVALID_OPLOCK_PROTOCOL, ERROR_INVALID_OPLOCK_PROTOCOL);
cmp(STATUS_INTERNAL_DB_CORRUPTION, ERROR_INTERNAL_DB_CORRUPTION);
cmp(STATUS_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
cmp(STATUS_GENERIC_NOT_MAPPED, ERROR_GENERIC_NOT_MAPPED);
cmp(STATUS_BAD_DESCRIPTOR_FORMAT, ERROR_BAD_DESCRIPTOR_FORMAT);
cmp(STATUS_NOT_LOGON_PROCESS, ERROR_NOT_LOGON_PROCESS);
cmp(STATUS_LOGON_SESSION_EXISTS, ERROR_LOGON_SESSION_EXISTS);
cmp(STATUS_NO_SUCH_PACKAGE, ERROR_NO_SUCH_PACKAGE);
cmp(STATUS_BAD_LOGON_SESSION_STATE, ERROR_BAD_LOGON_SESSION_STATE);
cmp(STATUS_LOGON_SESSION_COLLISION, ERROR_LOGON_SESSION_COLLISION);
cmp(STATUS_INVALID_LOGON_TYPE, ERROR_INVALID_LOGON_TYPE);
cmp(STATUS_RXACT_INVALID_STATE, ERROR_RXACT_INVALID_STATE);
cmp(STATUS_RXACT_COMMIT_FAILURE, ERROR_RXACT_COMMIT_FAILURE);
cmp(STATUS_SPECIAL_ACCOUNT, ERROR_SPECIAL_ACCOUNT);
cmp(STATUS_SPECIAL_USER, ERROR_SPECIAL_USER);
cmp(STATUS_MEMBERS_PRIMARY_GROUP, ERROR_MEMBERS_PRIMARY_GROUP);
cmp(STATUS_TOKEN_ALREADY_IN_USE, ERROR_TOKEN_ALREADY_IN_USE);
cmp(STATUS_NO_SUCH_ALIAS, ERROR_NO_SUCH_ALIAS);
cmp(STATUS_MEMBER_NOT_IN_ALIAS, ERROR_MEMBER_NOT_IN_ALIAS);
cmp(STATUS_MEMBER_IN_ALIAS, ERROR_MEMBER_IN_ALIAS);
cmp(STATUS_ALIAS_EXISTS, ERROR_ALIAS_EXISTS);
cmp(STATUS_LOGON_NOT_GRANTED, ERROR_LOGON_NOT_GRANTED);
cmp(STATUS_TOO_MANY_SECRETS, ERROR_TOO_MANY_SECRETS);
cmp(STATUS_SECRET_TOO_LONG, ERROR_SECRET_TOO_LONG);
cmp(STATUS_INTERNAL_DB_ERROR, ERROR_INTERNAL_DB_ERROR);
cmp(STATUS_TOO_MANY_CONTEXT_IDS, ERROR_TOO_MANY_CONTEXT_IDS);
cmp(STATUS_LOGON_TYPE_NOT_GRANTED, ERROR_LOGON_TYPE_NOT_GRANTED);
cmp(STATUS_NT_CROSS_ENCRYPTION_REQUIRED, ERROR_NT_CROSS_ENCRYPTION_REQUIRED);
cmp(STATUS_NO_SUCH_MEMBER, ERROR_NO_SUCH_MEMBER);
cmp(STATUS_INVALID_MEMBER, ERROR_INVALID_MEMBER);
cmp(STATUS_TOO_MANY_SIDS, ERROR_TOO_MANY_SIDS);
cmp(STATUS_LM_CROSS_ENCRYPTION_REQUIRED, ERROR_LM_CROSS_ENCRYPTION_REQUIRED);
/* Commented out to supress warning. Works.
cmp(STATUS_MESSAGE_NOT_FOUND, ERROR_MR_MID_NOT_FOUND);*/
cmp(STATUS_LOCAL_DISCONNECT, ERROR_NETNAME_DELETED);
cmp(STATUS_REMOTE_DISCONNECT, ERROR_NETNAME_DELETED);
cmp(STATUS_REMOTE_RESOURCES, ERROR_REM_NOT_LIST);
cmp(STATUS_LINK_FAILED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_LINK_TIMEOUT, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_CONNECTION, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_ADDRESS, ERROR_UNEXP_NET_ERR);
cmp(STATUS_IO_DEVICE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DEVICE_PROTOCOL_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DRIVER_INTERNAL_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_INVALID_DEVICE_STATE, ERROR_BAD_COMMAND);
cmp(STATUS_DEVICE_CONFIGURATION_ERROR, ERROR_INVALID_PARAMETER);
cmp2(STATUS_SOURCE_ELEMENT_EMPTY, ERROR_SOURCE_ELEMENT_EMPTY);
cmp2(STATUS_DESTINATION_ELEMENT_FULL, ERROR_DESTINATION_ELEMENT_FULL);
cmp2(STATUS_ILLEGAL_ELEMENT_ADDRESS, ERROR_ILLEGAL_ELEMENT_ADDRESS);
cmp2(STATUS_MAGAZINE_NOT_PRESENT, ERROR_MAGAZINE_NOT_PRESENT);
cmp2(STATUS_REINITIALIZATION_NEEDED, ERROR_DEVICE_REINITIALIZATION_NEEDED);
cmp2(STATUS_DEVICE_REQUIRES_CLEANING, ERROR_DEVICE_REQUIRES_CLEANING);
cmp2(STATUS_DEVICE_DOOR_OPEN, ERROR_DEVICE_DOOR_OPEN);
cmp2(STATUS_TRANSPORT_FULL, ERROR_TRANSPORT_FULL);
cmp2(STATUS_CLEANER_CARTRIDGE_INSTALLED, ERROR_CLEANER_CARTRIDGE_INSTALLED);
cmp2(STATUS_REG_NAT_CONSUMPTION, ERROR_REG_NAT_CONSUMPTION);
cmp2(STATUS_ENCRYPTION_FAILED, ERROR_ACCESS_DENIED);
cmp2(STATUS_DECRYPTION_FAILED, ERROR_ACCESS_DENIED);
cmp2(STATUS_NO_RECOVERY_POLICY, ERROR_ACCESS_DENIED);
cmp2(STATUS_NO_EFS, ERROR_ACCESS_DENIED);
cmp2(STATUS_WRONG_EFS, ERROR_ACCESS_DENIED);
cmp2(STATUS_NO_USER_KEYS, ERROR_ACCESS_DENIED);
cmp2(STATUS_FILE_NOT_ENCRYPTED, ERROR_FILE_NOT_ENCRYPTED);
cmp2(STATUS_NOT_EXPORT_FORMAT, ERROR_NOT_EXPORT_FORMAT);
cmp2(STATUS_FILE_ENCRYPTED, ERROR_FILE_ENCRYPTED);
cmp2(STATUS_EFS_ALG_BLOB_TOO_BIG, ERROR_EFS_ALG_BLOB_TOO_BIG);
cmp(STATUS_INVALID_USER_BUFFER, ERROR_INVALID_USER_BUFFER);
cmp(STATUS_SERIAL_NO_DEVICE_INITED, ERROR_SERIAL_NO_DEVICE);
cmp(STATUS_SHARED_IRQ_BUSY, ERROR_IRQ_BUSY);
cmp(STATUS_SERIAL_MORE_WRITES, ERROR_MORE_WRITES);
cmp(STATUS_SERIAL_COUNTER_TIMEOUT, ERROR_COUNTER_TIMEOUT);
cmp(STATUS_FLOPPY_ID_MARK_NOT_FOUND, ERROR_FLOPPY_ID_MARK_NOT_FOUND);
cmp(STATUS_FLOPPY_WRONG_CYLINDER, ERROR_FLOPPY_WRONG_CYLINDER);
cmp(STATUS_FLOPPY_UNKNOWN_ERROR, ERROR_FLOPPY_UNKNOWN_ERROR);
cmp(STATUS_FLOPPY_BAD_REGISTERS, ERROR_FLOPPY_BAD_REGISTERS);
cmp(STATUS_DISK_RECALIBRATE_FAILED, ERROR_DISK_RECALIBRATE_FAILED);
cmp(STATUS_DISK_OPERATION_FAILED, ERROR_DISK_OPERATION_FAILED);
cmp(STATUS_DISK_RESET_FAILED, ERROR_DISK_RESET_FAILED);
cmp(STATUS_EVENTLOG_FILE_CORRUPT, ERROR_EVENTLOG_FILE_CORRUPT);
cmp(STATUS_EVENTLOG_CANT_START, ERROR_EVENTLOG_CANT_START);
cmp(STATUS_NETLOGON_NOT_STARTED, ERROR_NETLOGON_NOT_STARTED);
cmp(STATUS_ACCOUNT_EXPIRED, ERROR_ACCOUNT_EXPIRED);
cmp(STATUS_NETWORK_CREDENTIAL_CONFLICT, ERROR_SESSION_CREDENTIAL_CONFLICT);
cmp(STATUS_REMOTE_SESSION_LIMIT, ERROR_REMOTE_SESSION_LIMIT_EXCEEDED);
cmp(STATUS_INVALID_BUFFER_SIZE, ERROR_INVALID_USER_BUFFER);
cmp(STATUS_INVALID_ADDRESS_COMPONENT, ERROR_INVALID_NETNAME);
cmp(STATUS_INVALID_ADDRESS_WILDCARD, ERROR_INVALID_NETNAME);
cmp(STATUS_ADDRESS_ALREADY_EXISTS, ERROR_DUP_NAME);
cmp(STATUS_ADDRESS_CLOSED, ERROR_NETNAME_DELETED);
cmp(STATUS_CONNECTION_DISCONNECTED, ERROR_NETNAME_DELETED);
cmp(STATUS_CONNECTION_RESET, ERROR_NETNAME_DELETED);
cmp(STATUS_TRANSACTION_ABORTED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_TIMED_OUT, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_NO_RELEASE, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_NO_MATCH, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_RESPONDED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_INVALID_ID, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_INVALID_TYPE, ERROR_UNEXP_NET_ERR);
cmp(STATUS_NOT_SERVER_SESSION, ERROR_NOT_SUPPORTED);
cmp(STATUS_NOT_CLIENT_SESSION, ERROR_NOT_SUPPORTED);
cmp(STATUS_USER_MAPPED_FILE, ERROR_USER_MAPPED_FILE);
cmp(STATUS_PLUGPLAY_NO_DEVICE, ERROR_SERVICE_DISABLED);
cmp2(STATUS_WMI_GUID_NOT_FOUND, ERROR_WMI_GUID_NOT_FOUND);
cmp2(STATUS_WMI_INSTANCE_NOT_FOUND, ERROR_WMI_INSTANCE_NOT_FOUND);
cmp2(STATUS_WMI_ITEMID_NOT_FOUND, ERROR_WMI_ITEMID_NOT_FOUND);
cmp2(STATUS_WMI_TRY_AGAIN, ERROR_WMI_TRY_AGAIN);
cmp2(STATUS_WMI_READ_ONLY, ERROR_WMI_READ_ONLY);
cmp2(STATUS_WMI_SET_FAILURE, ERROR_WMI_SET_FAILURE);
cmp2(STATUS_WMI_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp2(STATUS_WMI_GUID_DISCONNECTED, ERROR_WMI_GUID_DISCONNECTED);
cmp2(STATUS_WMI_ALREADY_DISABLED, ERROR_WMI_ALREADY_DISABLED);
cmp2(STATUS_WMI_ALREADY_ENABLED, ERROR_WMI_ALREADY_ENABLED);
cmp2(STATUS_COPY_PROTECTION_FAILURE, STG_E_STATUS_COPY_PROTECTION_FAILURE);
cmp2(STATUS_CSS_AUTHENTICATION_FAILURE, STG_E_CSS_AUTHENTICATION_FAILURE);
cmp2(STATUS_CSS_KEY_NOT_PRESENT, STG_E_CSS_KEY_NOT_PRESENT);
cmp2(STATUS_CSS_KEY_NOT_ESTABLISHED, STG_E_CSS_KEY_NOT_ESTABLISHED);
cmp2(STATUS_CSS_SCRAMBLED_SECTOR, STG_E_CSS_SCRAMBLED_SECTOR);
cmp2(STATUS_CSS_REGION_MISMATCH, STG_E_CSS_REGION_MISMATCH);
cmp2(STATUS_CSS_RESETS_EXHAUSTED, STG_E_RESETS_EXHAUSTED);
cmp(RPC_NT_SERVER_UNAVAILABLE, RPC_S_SERVER_UNAVAILABLE);
cmp(RPC_NT_INVALID_STRING_BINDING, RPC_S_INVALID_STRING_BINDING);
cmp(RPC_NT_WRONG_KIND_OF_BINDING, RPC_S_WRONG_KIND_OF_BINDING);
cmp(RPC_NT_PROTSEQ_NOT_SUPPORTED, RPC_S_PROTSEQ_NOT_SUPPORTED);
cmp(RPC_NT_INVALID_RPC_PROTSEQ, RPC_S_INVALID_RPC_PROTSEQ);
cmp(RPC_NT_INVALID_STRING_UUID, RPC_S_INVALID_STRING_UUID);
cmp(RPC_NT_INVALID_ENDPOINT_FORMAT, RPC_S_INVALID_ENDPOINT_FORMAT);
cmp(RPC_NT_INVALID_NET_ADDR, RPC_S_INVALID_NET_ADDR);
cmp(RPC_NT_NO_ENDPOINT_FOUND, RPC_S_NO_ENDPOINT_FOUND);
cmp(RPC_NT_INVALID_TIMEOUT, RPC_S_INVALID_TIMEOUT);
cmp(RPC_NT_OBJECT_NOT_FOUND, RPC_S_OBJECT_NOT_FOUND);
cmp(RPC_NT_ALREADY_REGISTERED, RPC_S_ALREADY_REGISTERED);
cmp(RPC_NT_TYPE_ALREADY_REGISTERED, RPC_S_TYPE_ALREADY_REGISTERED);
cmp(RPC_NT_ALREADY_LISTENING, RPC_S_ALREADY_LISTENING);
cmp(RPC_NT_NO_PROTSEQS_REGISTERED, RPC_S_NO_PROTSEQS_REGISTERED);
cmp(RPC_NT_NOT_LISTENING, RPC_S_NOT_LISTENING);
cmp(RPC_NT_UNKNOWN_MGR_TYPE, RPC_S_UNKNOWN_MGR_TYPE);
cmp(RPC_NT_UNKNOWN_IF, RPC_S_UNKNOWN_IF);
cmp(RPC_NT_NO_BINDINGS, RPC_S_NO_BINDINGS);
cmp(RPC_NT_NO_MORE_BINDINGS, RPC_S_NO_MORE_BINDINGS);
cmp(RPC_NT_NO_PROTSEQS, RPC_S_NO_PROTSEQS);
cmp(RPC_NT_CANT_CREATE_ENDPOINT, RPC_S_CANT_CREATE_ENDPOINT);
cmp(RPC_NT_OUT_OF_RESOURCES, RPC_S_OUT_OF_RESOURCES);
cmp(RPC_NT_SERVER_TOO_BUSY, RPC_S_SERVER_TOO_BUSY);
cmp(RPC_NT_INVALID_NETWORK_OPTIONS, RPC_S_INVALID_NETWORK_OPTIONS);
cmp(RPC_NT_NO_CALL_ACTIVE, RPC_S_NO_CALL_ACTIVE);
cmp(RPC_NT_CALL_FAILED, RPC_S_CALL_FAILED);
cmp(RPC_NT_CALL_FAILED_DNE, RPC_S_CALL_FAILED_DNE);
cmp(RPC_NT_PROTOCOL_ERROR, RPC_S_PROTOCOL_ERROR);
cmp(RPC_NT_UNSUPPORTED_TRANS_SYN, RPC_S_UNSUPPORTED_TRANS_SYN);
cmp(RPC_NT_UNSUPPORTED_TYPE, RPC_S_UNSUPPORTED_TYPE);
cmp(RPC_NT_INVALID_TAG, RPC_S_INVALID_TAG);
cmp(RPC_NT_INVALID_BOUND, RPC_S_INVALID_BOUND);
cmp(RPC_NT_NO_ENTRY_NAME, RPC_S_NO_ENTRY_NAME);
cmp(RPC_NT_INVALID_NAME_SYNTAX, RPC_S_INVALID_NAME_SYNTAX);
cmp(RPC_NT_UNSUPPORTED_NAME_SYNTAX, RPC_S_UNSUPPORTED_NAME_SYNTAX);
cmp(RPC_NT_UUID_NO_ADDRESS, RPC_S_UUID_NO_ADDRESS);
cmp(RPC_NT_DUPLICATE_ENDPOINT, RPC_S_DUPLICATE_ENDPOINT);
cmp(RPC_NT_UNKNOWN_AUTHN_TYPE, RPC_S_UNKNOWN_AUTHN_TYPE);
cmp(RPC_NT_MAX_CALLS_TOO_SMALL, RPC_S_MAX_CALLS_TOO_SMALL);
cmp(RPC_NT_STRING_TOO_LONG, RPC_S_STRING_TOO_LONG);
cmp(RPC_NT_PROTSEQ_NOT_FOUND, RPC_S_PROTSEQ_NOT_FOUND);
cmp(RPC_NT_PROCNUM_OUT_OF_RANGE, RPC_S_PROCNUM_OUT_OF_RANGE);
cmp(RPC_NT_BINDING_HAS_NO_AUTH, RPC_S_BINDING_HAS_NO_AUTH);
cmp(RPC_NT_UNKNOWN_AUTHN_SERVICE, RPC_S_UNKNOWN_AUTHN_SERVICE);
cmp(RPC_NT_UNKNOWN_AUTHN_LEVEL, RPC_S_UNKNOWN_AUTHN_LEVEL);
cmp(RPC_NT_INVALID_AUTH_IDENTITY, RPC_S_INVALID_AUTH_IDENTITY);
cmp(RPC_NT_UNKNOWN_AUTHZ_SERVICE, RPC_S_UNKNOWN_AUTHZ_SERVICE);
cmp(EPT_NT_INVALID_ENTRY, EPT_S_INVALID_ENTRY);
cmp(EPT_NT_CANT_PERFORM_OP, EPT_S_CANT_PERFORM_OP);
cmp(EPT_NT_NOT_REGISTERED, EPT_S_NOT_REGISTERED);
cmp(RPC_NT_NOTHING_TO_EXPORT, RPC_S_NOTHING_TO_EXPORT);
cmp(RPC_NT_INCOMPLETE_NAME, RPC_S_INCOMPLETE_NAME);
cmp(RPC_NT_INVALID_VERS_OPTION, RPC_S_INVALID_VERS_OPTION);
cmp(RPC_NT_NO_MORE_MEMBERS, RPC_S_NO_MORE_MEMBERS);
cmp(RPC_NT_NOT_ALL_OBJS_UNEXPORTED, RPC_S_NOT_ALL_OBJS_UNEXPORTED);
cmp(RPC_NT_INTERFACE_NOT_FOUND, RPC_S_INTERFACE_NOT_FOUND);
cmp(RPC_NT_ENTRY_ALREADY_EXISTS, RPC_S_ENTRY_ALREADY_EXISTS);
cmp(RPC_NT_ENTRY_NOT_FOUND, RPC_S_ENTRY_NOT_FOUND);
cmp(RPC_NT_NAME_SERVICE_UNAVAILABLE, RPC_S_NAME_SERVICE_UNAVAILABLE);
cmp(RPC_NT_INVALID_NAF_ID, RPC_S_INVALID_NAF_ID);
cmp(RPC_NT_CANNOT_SUPPORT, RPC_S_CANNOT_SUPPORT);
cmp(RPC_NT_NO_CONTEXT_AVAILABLE, RPC_S_NO_CONTEXT_AVAILABLE);
cmp(RPC_NT_INTERNAL_ERROR, RPC_S_INTERNAL_ERROR);
cmp(RPC_NT_ZERO_DIVIDE, RPC_S_ZERO_DIVIDE);
cmp(RPC_NT_ADDRESS_ERROR, RPC_S_ADDRESS_ERROR);
cmp(RPC_NT_FP_DIV_ZERO, RPC_S_FP_DIV_ZERO);
cmp(RPC_NT_FP_UNDERFLOW, RPC_S_FP_UNDERFLOW);
cmp(RPC_NT_FP_OVERFLOW, RPC_S_FP_OVERFLOW);
cmp(RPC_NT_NO_MORE_ENTRIES, RPC_X_NO_MORE_ENTRIES);
cmp(RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, RPC_X_SS_CHAR_TRANS_OPEN_FAIL);
cmp(RPC_NT_SS_CHAR_TRANS_SHORT_FILE, RPC_X_SS_CHAR_TRANS_SHORT_FILE);
cmp(RPC_NT_SS_CONTEXT_MISMATCH, ERROR_INVALID_HANDLE);
cmp(RPC_NT_SS_CONTEXT_DAMAGED, RPC_X_SS_CONTEXT_DAMAGED);
cmp(RPC_NT_SS_HANDLES_MISMATCH, RPC_X_SS_HANDLES_MISMATCH);
cmp(RPC_NT_SS_CANNOT_GET_CALL_HANDLE, RPC_X_SS_CANNOT_GET_CALL_HANDLE);
cmp(RPC_NT_NULL_REF_POINTER, RPC_X_NULL_REF_POINTER);
cmp(RPC_NT_ENUM_VALUE_OUT_OF_RANGE, RPC_X_ENUM_VALUE_OUT_OF_RANGE);
cmp(RPC_NT_BYTE_COUNT_TOO_SMALL, RPC_X_BYTE_COUNT_TOO_SMALL);
cmp(RPC_NT_BAD_STUB_DATA, RPC_X_BAD_STUB_DATA);
cmp(RPC_NT_INVALID_OBJECT, RPC_S_INVALID_OBJECT);
cmp(STATUS_NO_TRUST_LSA_SECRET, ERROR_NO_TRUST_LSA_SECRET);
cmp(STATUS_NO_TRUST_SAM_ACCOUNT, ERROR_NO_TRUST_SAM_ACCOUNT);
cmp(STATUS_TRUSTED_DOMAIN_FAILURE, ERROR_TRUSTED_DOMAIN_FAILURE);
cmp(STATUS_TRUSTED_RELATIONSHIP_FAILURE, ERROR_TRUSTED_RELATIONSHIP_FAILURE);
cmp(STATUS_TRUST_FAILURE, ERROR_TRUST_FAILURE);
cmp(RPC_NT_CALL_IN_PROGRESS, RPC_S_CALL_IN_PROGRESS);
cmp(STATUS_LOG_FILE_FULL, ERROR_LOG_FILE_FULL);
cmp(STATUS_EVENTLOG_FILE_CHANGED, ERROR_EVENTLOG_FILE_CHANGED);
cmp(STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT);
cmp(STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT);
cmp(STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, ERROR_NOLOGON_SERVER_TRUST_ACCOUNT);
cmp(STATUS_DOMAIN_TRUST_INCONSISTENT, ERROR_DOMAIN_TRUST_INCONSISTENT);
cmp(STATUS_NO_USER_SESSION_KEY, ERROR_NO_USER_SESSION_KEY);
cmp(STATUS_POSSIBLE_DEADLOCK, ERROR_POSSIBLE_DEADLOCK);
cmp(STATUS_IMAGE_ALREADY_LOADED, ERROR_SERVICE_ALREADY_RUNNING);
cmp(RPC_NT_GROUP_MEMBER_NOT_FOUND, RPC_S_GROUP_MEMBER_NOT_FOUND);
cmp(RPC_NT_NO_INTERFACES, RPC_S_NO_INTERFACES);
cmp(RPC_NT_CALL_CANCELLED, RPC_S_CALL_CANCELLED);
cmp(RPC_NT_BINDING_INCOMPLETE, RPC_S_BINDING_INCOMPLETE);
cmp(RPC_NT_COMM_FAILURE, RPC_S_COMM_FAILURE);
cmp(RPC_NT_UNSUPPORTED_AUTHN_LEVEL, RPC_S_UNSUPPORTED_AUTHN_LEVEL);
cmp(RPC_NT_NO_PRINC_NAME, RPC_S_NO_PRINC_NAME);
cmp(RPC_NT_NOT_RPC_ERROR, RPC_S_NOT_RPC_ERROR);
cmp(RPC_NT_UUID_LOCAL_ONLY, RPC_S_UUID_LOCAL_ONLY);
cmp(RPC_NT_SEC_PKG_ERROR, RPC_S_SEC_PKG_ERROR);
cmp(RPC_NT_NOT_CANCELLED, RPC_S_NOT_CANCELLED);
cmp(RPC_NT_INVALID_ES_ACTION, RPC_X_INVALID_ES_ACTION);
cmp(RPC_NT_WRONG_ES_VERSION, RPC_X_WRONG_ES_VERSION);
cmp(RPC_NT_WRONG_STUB_VERSION, RPC_X_WRONG_STUB_VERSION);
cmp(RPC_NT_INVALID_PIPE_OBJECT, RPC_X_INVALID_PIPE_OBJECT);
cmp(RPC_NT_INVALID_PIPE_OPERATION, RPC_X_INVALID_PIPE_OPERATION);
cmp(RPC_NT_WRONG_PIPE_VERSION, RPC_X_WRONG_PIPE_VERSION);
cmp(EPT_NT_CANT_CREATE, EPT_S_CANT_CREATE);
cmp(RPC_NT_SEND_INCOMPLETE, RPC_S_SEND_INCOMPLETE);
cmp2(RPC_NT_INVALID_ASYNC_HANDLE, RPC_S_INVALID_ASYNC_HANDLE);
cmp2(RPC_NT_INVALID_ASYNC_CALL, RPC_S_INVALID_ASYNC_CALL);
cmp2(RPC_NT_PIPE_CLOSED, RPC_X_PIPE_CLOSED);
cmp2(RPC_NT_PIPE_EMPTY, RPC_X_PIPE_EMPTY);
cmp2(RPC_NT_PIPE_DISCIPLINE_ERROR, RPC_X_PIPE_DISCIPLINE_ERROR);
cmp(STATUS_NO_BROWSER_SERVERS_FOUND, ERROR_NO_BROWSER_SERVERS_FOUND);
cmp(STATUS_MAPPED_ALIGNMENT, ERROR_MAPPED_ALIGNMENT);
cmp(STATUS_CONNECTION_IN_USE, ERROR_DEVICE_IN_USE);
cmp(STATUS_VERIFY_REQUIRED, ERROR_MEDIA_CHANGED);
cmp(STATUS_ALREADY_DISCONNECTED, ERROR_ACTIVE_CONNECTIONS);
cmp(STATUS_CONNECTION_REFUSED, ERROR_CONNECTION_REFUSED);
cmp(STATUS_GRACEFUL_DISCONNECT, ERROR_GRACEFUL_DISCONNECT);
cmp(STATUS_ADDRESS_ALREADY_ASSOCIATED, ERROR_ADDRESS_ALREADY_ASSOCIATED);
cmp(STATUS_ADDRESS_NOT_ASSOCIATED, ERROR_ADDRESS_NOT_ASSOCIATED);
cmp(STATUS_CONNECTION_INVALID, ERROR_CONNECTION_INVALID);
cmp(STATUS_CONNECTION_ACTIVE, ERROR_CONNECTION_ACTIVE);
cmp(STATUS_NETWORK_UNREACHABLE, ERROR_NETWORK_UNREACHABLE);
cmp(STATUS_HOST_UNREACHABLE, ERROR_HOST_UNREACHABLE);
cmp2(STATUS_HOST_DOWN, ERROR_HOST_DOWN);
cmp(STATUS_PROTOCOL_UNREACHABLE, ERROR_PROTOCOL_UNREACHABLE);
cmp(STATUS_PORT_UNREACHABLE, ERROR_PORT_UNREACHABLE);
cmp(STATUS_REQUEST_ABORTED, ERROR_REQUEST_ABORTED);
cmp(STATUS_CONNECTION_ABORTED, ERROR_CONNECTION_ABORTED);
cmp(STATUS_CONNECTION_COUNT_LIMIT, ERROR_CONNECTION_COUNT_LIMIT);
cmp(STATUS_PATH_NOT_COVERED, ERROR_HOST_UNREACHABLE);
cmp(STATUS_LOGIN_TIME_RESTRICTION, ERROR_LOGIN_TIME_RESTRICTION);
cmp(STATUS_LOGIN_WKSTA_RESTRICTION, ERROR_LOGIN_WKSTA_RESTRICTION);
cmp(STATUS_LICENSE_QUOTA_EXCEEDED, ERROR_LICENSE_QUOTA_EXCEEDED);
cmp(STATUS_RESOURCE_NOT_OWNED, ERROR_NOT_OWNER);
cmp(STATUS_DUPLICATE_OBJECTID, STATUS_DUPLICATE_OBJECTID);
cmp(STATUS_OBJECTID_EXISTS, STATUS_OBJECTID_EXISTS);
cmp2(STATUS_OBJECTID_NOT_FOUND, ERROR_FILE_NOT_FOUND);
cmp2(STATUS_MFT_TOO_FRAGMENTED, ERROR_DISK_TOO_FRAGMENTED);
cmp(SEC_E_INSUFFICIENT_MEMORY, ERROR_NO_SYSTEM_RESOURCES);
cmp(SEC_E_INVALID_HANDLE, ERROR_INVALID_HANDLE);
cmp(SEC_E_UNSUPPORTED_FUNCTION, ERROR_INVALID_FUNCTION);
cmp(SEC_E_TARGET_UNKNOWN, ERROR_BAD_NETPATH);
cmp(SEC_E_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
cmp(SEC_E_SECPKG_NOT_FOUND, ERROR_NO_SUCH_PACKAGE);
cmp(SEC_E_NOT_OWNER, ERROR_NOT_OWNER);
cmp(SEC_E_CANNOT_INSTALL, ERROR_NO_SUCH_PACKAGE);
cmp(SEC_E_INVALID_TOKEN, ERROR_INVALID_PARAMETER);
cmp(SEC_E_CANNOT_PACK, ERROR_INVALID_PARAMETER);
cmp(SEC_E_QOP_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(SEC_E_NO_IMPERSONATION, ERROR_CANNOT_IMPERSONATE);
cmp2(SEC_E_MULTIPLE_ACCOUNTS, ERROR_CANNOT_IMPERSONATE);
cmp(SEC_E_LOGON_DENIED, ERROR_LOGON_FAILURE);
cmp(SEC_E_UNKNOWN_CREDENTIALS, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_INCOMPLETE_CREDENTIALS, ERROR_INVALID_PARAMETER);
cmp(SEC_E_NO_CREDENTIALS, ERROR_NO_SUCH_LOGON_SESSION);
cmp(SEC_E_MESSAGE_ALTERED, ERROR_ACCESS_DENIED);
cmp(SEC_E_OUT_OF_SEQUENCE, ERROR_ACCESS_DENIED);
cmp(SEC_E_NO_AUTHENTICATING_AUTHORITY, ERROR_NO_LOGON_SERVERS);
cmp(SEC_E_BAD_PKGID, ERROR_NO_SUCH_PACKAGE);
cmp2(SEC_E_WRONG_PRINCIPAL, ERROR_WRONG_TARGET_NAME);
cmp2(SEC_E_INCOMPLETE_MESSAGE, ERROR_INVALID_USER_BUFFER);
cmp2(SEC_E_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
cmp2(SEC_E_UNTRUSTED_ROOT, ERROR_TRUST_FAILURE);
cmp2(SEC_E_ILLEGAL_MESSAGE, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_CERT_UNKNOWN, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_CERT_EXPIRED, ERROR_PASSWORD_EXPIRED);
cmp2(SEC_E_ENCRYPT_FAILURE, ERROR_ENCRYPTION_FAILED);
cmp2(SEC_E_DECRYPT_FAILURE, ERROR_DECRYPTION_FAILED);
cmp2(SEC_E_ALGORITHM_MISMATCH, ERROR_INVALID_FUNCTION);
cmp2(SEC_E_CONTEXT_EXPIRED, ERROR_CONTEXT_EXPIRED);
cmp2(STATUS_BAD_BINDINGS, SEC_E_BAD_BINDINGS);
cmp2(TRUST_E_CERT_SIGNATURE, ERROR_MUTUAL_AUTH_FAILED);
cmp2(CRYPT_E_REVOKED, ERROR_MUTUAL_AUTH_FAILED);
cmp2(CRYPT_E_NO_REVOCATION_CHECK, ERROR_MUTUAL_AUTH_FAILED);
cmp2(CRYPT_E_REVOCATION_OFFLINE, ERROR_MUTUAL_AUTH_FAILED);
cmp2(STATUS_SHUTDOWN_IN_PROGRESS, ERROR_SHUTDOWN_IN_PROGRESS);
cmp2(STATUS_SERVER_SHUTDOWN_IN_PROGRESS, ERROR_SERVER_SHUTDOWN_IN_PROGRESS);
cmp2(STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY);
cmp2(STATUS_DS_NO_ATTRIBUTE_OR_VALUE, ERROR_DS_NO_ATTRIBUTE_OR_VALUE);
cmp2(STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, ERROR_DS_INVALID_ATTRIBUTE_SYNTAX);
cmp2(STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED);
cmp2(STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS);
cmp2(STATUS_DS_BUSY, ERROR_DS_BUSY);
cmp2(STATUS_DS_UNAVAILABLE, ERROR_DS_UNAVAILABLE);
cmp2(STATUS_DS_NO_RIDS_ALLOCATED, ERROR_DS_NO_RIDS_ALLOCATED);
cmp2(STATUS_DS_NO_MORE_RIDS, ERROR_DS_NO_MORE_RIDS);
cmp2(STATUS_DS_INCORRECT_ROLE_OWNER, ERROR_DS_INCORRECT_ROLE_OWNER);
cmp2(STATUS_DS_RIDMGR_INIT_ERROR, ERROR_DS_RIDMGR_INIT_ERROR);
cmp2(STATUS_DS_OBJ_CLASS_VIOLATION, ERROR_DS_OBJ_CLASS_VIOLATION);
cmp2(STATUS_DS_CANT_ON_NON_LEAF, ERROR_DS_CANT_ON_NON_LEAF);
cmp2(STATUS_DS_CANT_ON_RDN, ERROR_DS_CANT_ON_RDN);
cmp2(STATUS_DS_CROSS_DOM_MOVE_FAILED, ERROR_DS_CROSS_DOM_MOVE_ERROR);
cmp2(STATUS_DS_GC_NOT_AVAILABLE, ERROR_DS_GC_NOT_AVAILABLE);
cmp2(STATUS_DS_CANT_MOD_OBJ_CLASS, ERROR_DS_CANT_MOD_OBJ_CLASS);
cmp2(STATUS_DS_ADMIN_LIMIT_EXCEEDED, ERROR_DS_ADMIN_LIMIT_EXCEEDED);
cmp2(STATUS_DIRECTORY_SERVICE_REQUIRED, ERROR_DS_DS_REQUIRED);
cmp2(STATUS_DS_SAM_INIT_FAILURE, ERROR_DS_SAM_INIT_FAILURE);
cmp2(STATUS_DS_CANT_START, ERROR_DS_CANT_START);
cmp2(STATUS_DS_INIT_FAILURE, ERROR_DS_INIT_FAILURE);
cmp2(STATUS_SAM_INIT_FAILURE, ERROR_SAM_INIT_FAILURE);
cmp2(STATUS_DS_SENSITIVE_GROUP_VIOLATION, ERROR_DS_SENSITIVE_GROUP_VIOLATION);
cmp2(STATUS_DS_CANT_MOD_PRIMARYGROUPID, ERROR_DS_CANT_MOD_PRIMARYGROUPID);
cmp2(STATUS_DS_INVALID_GROUP_TYPE, ERROR_DS_INVALID_GROUP_TYPE);
cmp2(STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN);
cmp2(STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER);
cmp2(STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER);
cmp2(STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER);
cmp2(STATUS_DS_HAVE_PRIMARY_MEMBERS, ERROR_DS_HAVE_PRIMARY_MEMBERS);
cmp2(STATUS_DS_GC_REQUIRED, ERROR_DS_GC_REQUIRED);
cmp2(STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY);
cmp2(STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS);
cmp2(STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED,ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED);
cmp2(STATUS_SAM_NEED_BOOTKEY_PASSWORD, ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD);
cmp2(STATUS_SAM_NEED_BOOTKEY_FLOPPY, ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY);
cmp2(STATUS_DS_INIT_FAILURE_CONSOLE, ERROR_DS_INIT_FAILURE_CONSOLE);
cmp2(STATUS_DS_SAM_INIT_FAILURE_CONSOLE, ERROR_DS_SAM_INIT_FAILURE_CONSOLE);
cmp2(STATUS_UNFINISHED_CONTEXT_DELETED, SEC_E_UNFINISHED_CONTEXT_DELETED);
cmp2(STATUS_NO_TGT_REPLY, SEC_E_NO_TGT_REPLY);
cmp2(STATUS_NO_IP_ADDRESSES, SEC_E_NO_IP_ADDRESSES);
cmp2(STATUS_WRONG_CREDENTIAL_HANDLE, SEC_E_WRONG_CREDENTIAL_HANDLE);
cmp2(STATUS_CRYPTO_SYSTEM_INVALID, SEC_E_CRYPTO_SYSTEM_INVALID);
cmp2(STATUS_MAX_REFERRALS_EXCEEDED, SEC_E_MAX_REFERRALS_EXCEEDED);
cmp2(STATUS_MUST_BE_KDC, SEC_E_MUST_BE_KDC);
cmp2(STATUS_STRONG_CRYPTO_NOT_SUPPORTED, SEC_E_STRONG_CRYPTO_NOT_SUPPORTED);
cmp2(STATUS_TOO_MANY_PRINCIPALS, SEC_E_TOO_MANY_PRINCIPALS);
cmp2(STATUS_NO_PA_DATA, SEC_E_NO_PA_DATA);
cmp2(STATUS_PKINIT_NAME_MISMATCH, SEC_E_PKINIT_NAME_MISMATCH);
cmp2(STATUS_SMARTCARD_LOGON_REQUIRED, SEC_E_SMARTCARD_LOGON_REQUIRED);
cmp2(STATUS_KDC_INVALID_REQUEST, SEC_E_KDC_INVALID_REQUEST);
cmp2(STATUS_KDC_UNABLE_TO_REFER, SEC_E_KDC_UNABLE_TO_REFER);
cmp2(STATUS_KDC_UNKNOWN_ETYPE, SEC_E_KDC_UNKNOWN_ETYPE);
cmp2(STATUS_UNSUPPORTED_PREAUTH, SEC_E_UNSUPPORTED_PREAUTH);
cmp2(STATUS_SHARED_POLICY, ERROR_SHARED_POLICY);
cmp2(STATUS_POLICY_OBJECT_NOT_FOUND, ERROR_POLICY_OBJECT_NOT_FOUND);
cmp2(STATUS_POLICY_ONLY_IN_DS, ERROR_POLICY_ONLY_IN_DS);
cmp2(STATUS_DEVICE_REMOVED, ERROR_DEVICE_REMOVED);
cmp2(STATUS_RETRY, ERROR_RETRY);
cmp2(STATUS_NOT_SUPPORTED_ON_SBS, ERROR_NOT_SUPPORTED_ON_SBS);
cmp2(STATUS_DRIVER_BLOCKED_CRITICAL, ERROR_DRIVER_BLOCKED);
cmp2(STATUS_DRIVER_BLOCKED, ERROR_DRIVER_BLOCKED);
cmp2(STATUS_PRENT4_MACHINE_ACCOUNT, ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4);
cmp2(STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER,ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER);
cmp2(STATUS_DS_SHUTTING_DOWN, ERROR_DS_SHUTTING_DOWN);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PATH, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_FAIL_CHECK, ERROR_INVALID_PARAMETER);
cmp2(STATUS_CTX_CLOSE_PENDING, ERROR_CTX_CLOSE_PENDING);
cmp2(STATUS_CTX_NO_OUTBUF, ERROR_CTX_NO_OUTBUF);
cmp2(STATUS_CTX_MODEM_INF_NOT_FOUND, ERROR_CTX_MODEM_INF_NOT_FOUND);
cmp2(STATUS_CTX_INVALID_MODEMNAME, ERROR_CTX_INVALID_MODEMNAME);
cmp2(STATUS_CTX_RESPONSE_ERROR, ERROR_CTX_MODEM_RESPONSE_ERROR);
cmp2(STATUS_CTX_MODEM_RESPONSE_TIMEOUT, ERROR_CTX_MODEM_RESPONSE_TIMEOUT);
cmp2(STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, ERROR_CTX_MODEM_RESPONSE_NO_CARRIER);
cmp2(STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE);
cmp2(STATUS_CTX_MODEM_RESPONSE_BUSY, ERROR_CTX_MODEM_RESPONSE_BUSY);
cmp2(STATUS_CTX_MODEM_RESPONSE_VOICE, ERROR_CTX_MODEM_RESPONSE_VOICE);
cmp2(STATUS_CTX_TD_ERROR, ERROR_CTX_TD_ERROR);
cmp2(STATUS_CTX_WINSTATION_NAME_INVALID, ERROR_CTX_WINSTATION_NAME_INVALID);
cmp2(STATUS_CTX_WINSTATION_NOT_FOUND, ERROR_CTX_WINSTATION_NOT_FOUND);
cmp2(STATUS_CTX_WINSTATION_NAME_COLLISION, ERROR_CTX_WINSTATION_ALREADY_EXISTS);
cmp2(STATUS_CTX_WINSTATION_BUSY, ERROR_CTX_WINSTATION_BUSY);
cmp2(STATUS_CTX_GRAPHICS_INVALID, ERROR_CTX_GRAPHICS_INVALID);
cmp2(STATUS_CTX_BAD_VIDEO_MODE, ERROR_CTX_BAD_VIDEO_MODE);
cmp2(STATUS_CTX_NOT_CONSOLE, ERROR_CTX_NOT_CONSOLE);
cmp2(STATUS_CTX_CLIENT_QUERY_TIMEOUT, ERROR_CTX_CLIENT_QUERY_TIMEOUT);
cmp2(STATUS_CTX_CONSOLE_DISCONNECT, ERROR_CTX_CONSOLE_DISCONNECT);
cmp2(STATUS_CTX_CONSOLE_CONNECT, ERROR_CTX_CONSOLE_CONNECT);
cmp2(STATUS_CTX_SHADOW_DENIED, ERROR_CTX_SHADOW_DENIED);
cmp2(STATUS_CTX_SHADOW_INVALID, ERROR_CTX_SHADOW_INVALID);
cmp2(STATUS_CTX_SHADOW_DISABLED, ERROR_CTX_SHADOW_DISABLED);
cmp2(STATUS_CTX_WINSTATION_ACCESS_DENIED, ERROR_CTX_WINSTATION_ACCESS_DENIED);
cmp2(STATUS_CTX_INVALID_PD, ERROR_CTX_INVALID_PD);
cmp2(STATUS_CTX_PD_NOT_FOUND, ERROR_CTX_PD_NOT_FOUND);
cmp2(STATUS_CTX_INVALID_WD, ERROR_CTX_INVALID_WD);
cmp2(STATUS_CTX_WD_NOT_FOUND, ERROR_CTX_WD_NOT_FOUND);
cmp2(STATUS_CTX_CLIENT_LICENSE_IN_USE, ERROR_CTX_CLIENT_LICENSE_IN_USE);
cmp2(STATUS_CTX_CLIENT_LICENSE_NOT_SET, ERROR_CTX_CLIENT_LICENSE_NOT_SET);
cmp2(STATUS_CTX_LICENSE_NOT_AVAILABLE, ERROR_CTX_LICENSE_NOT_AVAILABLE);
cmp2(STATUS_CTX_LICENSE_CLIENT_INVALID, ERROR_CTX_LICENSE_CLIENT_INVALID);
cmp2(STATUS_CTX_LICENSE_EXPIRED, ERROR_CTX_LICENSE_EXPIRED);
cmp2(STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE);
cmp2(STATUS_CTX_SHADOW_NOT_RUNNING, ERROR_CTX_SHADOW_NOT_RUNNING);
cmp2(STATUS_LICENSE_VIOLATION, ERROR_CTX_LICENSE_NOT_AVAILABLE);
/* FIXME - unknown STATUS values
cmp(STATUS_ENDPOINT_CLOSED, ERROR_DEV_NOT_EXIST);
cmp(STATUS_DISCONNECTED, ERROR_DEV_NOT_EXIST);
cmp(STATUS_NONEXISTENT_NET_NAME, ERROR_DEV_NOT_EXIST); */
cmp2(STATUS_NETWORK_SESSION_EXPIRED, ERROR_NO_USER_SESSION_KEY);
cmp2(STATUS_FILES_OPEN, ERROR_OPEN_FILES);
cmp2(STATUS_SXS_SECTION_NOT_FOUND, ERROR_SXS_SECTION_NOT_FOUND);
cmp2(STATUS_SXS_CANT_GEN_ACTCTX, ERROR_SXS_CANT_GEN_ACTCTX);
cmp2(STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, ERROR_SXS_INVALID_ACTCTXDATA_FORMAT);
cmp2(STATUS_SXS_ASSEMBLY_NOT_FOUND, ERROR_SXS_ASSEMBLY_NOT_FOUND);
cmp2(STATUS_SXS_MANIFEST_FORMAT_ERROR, ERROR_SXS_MANIFEST_FORMAT_ERROR);
cmp2(STATUS_SXS_MANIFEST_PARSE_ERROR, ERROR_SXS_MANIFEST_PARSE_ERROR);
cmp2(STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, ERROR_SXS_ACTIVATION_CONTEXT_DISABLED);
cmp2(STATUS_SXS_KEY_NOT_FOUND, ERROR_SXS_KEY_NOT_FOUND);
cmp2(STATUS_SXS_WRONG_SECTION_TYPE, ERROR_SXS_WRONG_SECTION_TYPE);
cmp2(STATUS_SXS_THREAD_QUERIES_DISABLED, ERROR_SXS_THREAD_QUERIES_DISABLED);
cmp2(STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET);
cmp2(STATUS_REDIRECTOR_STARTED, ERROR_SERVICE_ALREADY_RUNNING);
cmp2(STATUS_AUDITING_DISABLED, ERROR_AUDITING_DISABLED);
cmp2(STATUS_CLUSTER_NODE_ALREADY_UP, ERROR_CLUSTER_NODE_ALREADY_UP);
cmp2(STATUS_CLUSTER_NODE_ALREADY_DOWN, ERROR_CLUSTER_NODE_ALREADY_DOWN);
cmp2(STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, ERROR_CLUSTER_NETWORK_ALREADY_ONLINE);
cmp2(STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE);
cmp2(STATUS_CLUSTER_NODE_ALREADY_MEMBER, ERROR_CLUSTER_NODE_ALREADY_MEMBER);
cmp2(STATUS_CLUSTER_INVALID_NODE, ERROR_CLUSTER_INVALID_NODE);
cmp2(STATUS_CLUSTER_NODE_EXISTS, ERROR_CLUSTER_NODE_EXISTS);
cmp2(STATUS_CLUSTER_JOIN_IN_PROGRESS, ERROR_CLUSTER_JOIN_IN_PROGRESS);
cmp2(STATUS_CLUSTER_NODE_NOT_FOUND, ERROR_CLUSTER_NODE_NOT_FOUND);
cmp2(STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND);
cmp2(STATUS_CLUSTER_NETWORK_EXISTS, ERROR_CLUSTER_NETWORK_EXISTS);
cmp2(STATUS_CLUSTER_NETWORK_NOT_FOUND, ERROR_CLUSTER_NETWORK_NOT_FOUND);
cmp2(STATUS_CLUSTER_NETINTERFACE_EXISTS, ERROR_CLUSTER_NETINTERFACE_EXISTS);
cmp2(STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, ERROR_CLUSTER_NETINTERFACE_NOT_FOUND);
cmp2(STATUS_CLUSTER_INVALID_REQUEST, ERROR_CLUSTER_INVALID_REQUEST);
cmp2(STATUS_CLUSTER_INVALID_NETWORK_PROVIDER,ERROR_CLUSTER_INVALID_NETWORK_PROVIDER);
cmp2(STATUS_CLUSTER_NODE_DOWN, ERROR_CLUSTER_NODE_DOWN);
cmp2(STATUS_CLUSTER_NODE_UNREACHABLE, ERROR_CLUSTER_NODE_UNREACHABLE);
cmp2(STATUS_CLUSTER_NODE_NOT_MEMBER, ERROR_CLUSTER_NODE_NOT_MEMBER);
cmp2(STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS);
cmp2(STATUS_CLUSTER_INVALID_NETWORK, ERROR_CLUSTER_INVALID_NETWORK);
cmp2(STATUS_CLUSTER_NODE_UP, ERROR_CLUSTER_NODE_UP);
cmp2(STATUS_CLUSTER_NODE_PAUSED, ERROR_CLUSTER_NODE_PAUSED);
cmp2(STATUS_CLUSTER_NODE_NOT_PAUSED, ERROR_CLUSTER_NODE_NOT_PAUSED);
cmp2(STATUS_CLUSTER_NO_SECURITY_CONTEXT, ERROR_CLUSTER_NO_SECURITY_CONTEXT);
cmp2(STATUS_CLUSTER_NETWORK_NOT_INTERNAL, ERROR_CLUSTER_NETWORK_NOT_INTERNAL);
}
/* FIXME!!! this test checks only mappings, defined by MSDN:
http://support.microsoft.com/default.aspx?scid=KB;EN-US;q113996&
It is necessary to add other mappings and to test them up to Windows XP.
*/
/* Some Windows NT statuses are not processed in NT 4.0.
Tests allow RtlNtStatusToDosError to return ERROR_MR_MID_NOT_FOUND
for these constants. Check is done with cmp2 call */
START_TEST(error)
{
OSVERSIONINFOA version;
/* run these tests only on NT platform, version 4 or later */
version.dwOSVersionInfoSize = sizeof(version);
if (GetVersionExA(&version) &&
(version.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
(version.dwMajorVersion >= 4))
{
run_error_tests();
}
}
#undef cmp
#undef cmp2

111
include/winerror.h
View File

@ -263,6 +263,7 @@ extern int WIN32_LastError;
#define ERROR_PARTIAL_COPY 299 #define ERROR_PARTIAL_COPY 299
#define ERROR_OPLOCK_NOT_GRANTED 300 #define ERROR_OPLOCK_NOT_GRANTED 300
#define ERROR_INVALID_OPLOCK_PROTOCOL 301 #define ERROR_INVALID_OPLOCK_PROTOCOL 301
#define ERROR_DISK_TOO_FRAGMENTED 302
#define ERROR_MR_MID_NOT_FOUND 317 #define ERROR_MR_MID_NOT_FOUND 317
#define ERROR_INVALID_ADDRESS 487 #define ERROR_INVALID_ADDRESS 487
#define ERROR_ARITHMETIC_OVERFLOW 534 #define ERROR_ARITHMETIC_OVERFLOW 534
@ -451,6 +452,20 @@ extern int WIN32_LastError;
#define ERROR_OVERRIDE_NOCHANGES 1252 #define ERROR_OVERRIDE_NOCHANGES 1252
#define ERROR_BAD_USER_PROFILE 1253 #define ERROR_BAD_USER_PROFILE 1253
#define ERROR_NOT_SUPPORTED_ON_SBS 1254 #define ERROR_NOT_SUPPORTED_ON_SBS 1254
#define ERROR_SERVER_SHUTDOWN_IN_PROGRESS 1255
#define ERROR_HOST_DOWN 1256
#define ERROR_ACCESS_DISABLED_BY_POLICY 1260
#define ERROR_REG_NAT_CONSUMPTION 1261
#define ERROR_PKINIT_FAILURE 1263
#define ERROR_SMARTCARD_SUBSYSTEM_FAILURE 1264
#define ERROR_DOWNGRADE_DETECTED 1265
#define SEC_E_SMARTCARD_CERT_REVOKED 1266
#define SEC_E_ISSUING_CA_UNTRUSTED 1267
#define SEC_E_REVOCATION_OFFLINE_C 1268
#define SEC_E_PKINIT_CLIENT_FAILURE 1269
#define SEC_E_SMARTCARD_CERT_EXPIRED 1270
#define ERROR_DRIVER_BLOCKED 1275
#define ERROR_INVALID_IMPORT_OF_NON_DLL 1276
#define ERROR_NOT_ALL_ASSIGNED 1300 #define ERROR_NOT_ALL_ASSIGNED 1300
#define ERROR_SOME_NOT_MAPPED 1301 #define ERROR_SOME_NOT_MAPPED 1301
#define ERROR_NO_QUOTAS_FOR_ACCOUNT 1302 #define ERROR_NO_QUOTAS_FOR_ACCOUNT 1302
@ -549,6 +564,7 @@ extern int WIN32_LastError;
#define ERROR_WRONG_TARGET_NAME 1396 #define ERROR_WRONG_TARGET_NAME 1396
#define ERROR_MUTUAL_AUTH_FAILED 1397 #define ERROR_MUTUAL_AUTH_FAILED 1397
#define ERROR_TIME_SKEW 1398 #define ERROR_TIME_SKEW 1398
#define ERROR_CURRENT_DOMAIN_NOT_ALLOWED 1399
#define ERROR_INVALID_WINDOW_HANDLE 1400 #define ERROR_INVALID_WINDOW_HANDLE 1400
#define ERROR_INVALID_MENU_HANDLE 1401 #define ERROR_INVALID_MENU_HANDLE 1401
#define ERROR_INVALID_CURSOR_HANDLE 1402 #define ERROR_INVALID_CURSOR_HANDLE 1402
@ -817,6 +833,7 @@ extern int WIN32_LastError;
#define RPC_S_PRF_ELT_NOT_REMOVED 1927 #define RPC_S_PRF_ELT_NOT_REMOVED 1927
#define RPC_S_GRP_ELT_NOT_ADDED 1928 #define RPC_S_GRP_ELT_NOT_ADDED 1928
#define RPC_S_GRP_ELT_NOT_REMOVED 1929 #define RPC_S_GRP_ELT_NOT_REMOVED 1929
#define ERROR_CONTEXT_EXPIRED 1931
#define ERROR_INVALID_PIXEL_FORMAT 2000 #define ERROR_INVALID_PIXEL_FORMAT 2000
#define ERROR_BAD_DRIVER 2001 #define ERROR_BAD_DRIVER 2001
#define ERROR_INVALID_WINDOW_STYLE 2002 #define ERROR_INVALID_WINDOW_STYLE 2002
@ -918,6 +935,7 @@ extern int WIN32_LastError;
#define ERROR_VOLUME_CONTAINS_SYS_FILES 4337 #define ERROR_VOLUME_CONTAINS_SYS_FILES 4337
#define ERROR_INDIGENOUS_TYPE 4338 #define ERROR_INDIGENOUS_TYPE 4338
#define ERROR_NO_SUPPORTING_DRIVES 4339 #define ERROR_NO_SUPPORTING_DRIVES 4339
#define ERROR_CLEANER_CARTRIDGE_INSTALLED 4340
#define ERROR_FILE_OFFLINE 4350 #define ERROR_FILE_OFFLINE 4350
#define ERROR_REMOTE_STORAGE_NOT_ACTIVE 4351 #define ERROR_REMOTE_STORAGE_NOT_ACTIVE 4351
#define ERROR_REMOTE_STORAGE_MEDIA_ERROR 4352 #define ERROR_REMOTE_STORAGE_MEDIA_ERROR 4352
@ -1027,6 +1045,7 @@ extern int WIN32_LastError;
#define ERROR_FILE_READ_ONLY 6009 #define ERROR_FILE_READ_ONLY 6009
#define ERROR_DIR_EFS_DISALLOWED 6010 #define ERROR_DIR_EFS_DISALLOWED 6010
#define ERROR_EFS_SERVER_NOT_TRUSTED 6011 #define ERROR_EFS_SERVER_NOT_TRUSTED 6011
#define ERROR_EFS_ALG_BLOB_TOO_BIG 6013
#define ERROR_NO_BROWSER_SERVERS_FOUND 6118 #define ERROR_NO_BROWSER_SERVERS_FOUND 6118
#define SCHED_E_SERVICE_NOT_LOCALSYSTEM 6200 #define SCHED_E_SERVICE_NOT_LOCALSYSTEM 6200
#define ERROR_CTX_WINSTATION_NAME_INVALID 7001 #define ERROR_CTX_WINSTATION_NAME_INVALID 7001
@ -1066,6 +1085,8 @@ extern int WIN32_LastError;
#define ERROR_CTX_LICENSE_NOT_AVAILABLE 7054 #define ERROR_CTX_LICENSE_NOT_AVAILABLE 7054
#define ERROR_CTX_LICENSE_CLIENT_INVALID 7055 #define ERROR_CTX_LICENSE_CLIENT_INVALID 7055
#define ERROR_CTX_LICENSE_EXPIRED 7056 #define ERROR_CTX_LICENSE_EXPIRED 7056
#define ERROR_CTX_SHADOW_NOT_RUNNING 7057
#define ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE 7058
#define FRS_ERR_INVALID_API_SEQUENCE 8001 #define FRS_ERR_INVALID_API_SEQUENCE 8001
#define FRS_ERR_STARTING_SERVICE 8002 #define FRS_ERR_STARTING_SERVICE 8002
#define FRS_ERR_STOPPING_SERVICE 8003 #define FRS_ERR_STOPPING_SERVICE 8003
@ -1401,6 +1422,10 @@ extern int WIN32_LastError;
#define ERROR_DS_MUST_BE_RUN_ON_DST_DC 8558 #define ERROR_DS_MUST_BE_RUN_ON_DST_DC 8558
#define ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER 8559 #define ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER 8559
#define ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ 8560 #define ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ 8560
#define ERROR_DS_INIT_FAILURE_CONSOLE 8561
#define ERROR_DS_SAM_INIT_FAILURE_CONSOLE 8562
#define ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4 8572
#define ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER 8578
#define DNS_ERROR_RCODE_FORMAT_ERROR 9001 #define DNS_ERROR_RCODE_FORMAT_ERROR 9001
#define DNS_ERROR_RCODE_SERVER_FAILURE 9002 #define DNS_ERROR_RCODE_SERVER_FAILURE 9002
#define DNS_ERROR_RCODE_NAME_ERROR 9003 #define DNS_ERROR_RCODE_NAME_ERROR 9003
@ -1478,6 +1503,20 @@ extern int WIN32_LastError;
#define DNS_STATUS_CONTINUE_NEEDED 9801 #define DNS_STATUS_CONTINUE_NEEDED 9801
#define DNS_ERROR_NO_TCPIP 9851 #define DNS_ERROR_NO_TCPIP 9851
#define DNS_ERROR_NO_DNS_SERVERS 9852 #define DNS_ERROR_NO_DNS_SERVERS 9852
#define ERROR_SXS_SECTION_NOT_FOUND 14000
#define ERROR_SXS_CANT_GEN_ACTCTX 14001
#define ERROR_SXS_INVALID_ACTCTXDATA_FORMAT 14002
#define ERROR_SXS_ASSEMBLY_NOT_FOUND 14003
#define ERROR_SXS_MANIFEST_FORMAT_ERROR 14004
#define ERROR_SXS_MANIFEST_PARSE_ERROR 14005
#define ERROR_SXS_ACTIVATION_CONTEXT_DISABLED 14006
#define ERROR_SXS_KEY_NOT_FOUND 14007
#define ERROR_SXS_WRONG_SECTION_TYPE 14009
#define ERROR_SXS_THREAD_QUERIES_DISABLED 14010
#define ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET 14011
#define ERROR_AUDITING_DISABLED 0xC0090001L
#define ERROR_ALL_SIDS_FILTERED 0xC0090002L
/* HRESULT values for OLE, SHELL and other Interface stuff */ /* HRESULT values for OLE, SHELL and other Interface stuff */
/* the codes 4000-40ff are reserved for OLE */ /* the codes 4000-40ff are reserved for OLE */
@ -1656,6 +1695,14 @@ extern int WIN32_LastError;
#define STG_E_NOTFILEBASEDSTORAGE 0x80030107L #define STG_E_NOTFILEBASEDSTORAGE 0x80030107L
#define STG_E_EXTANTMARSHALLINGS 0x80030108L #define STG_E_EXTANTMARSHALLINGS 0x80030108L
#define STG_E_STATUS_COPY_PROTECTION_FAILURE 0x80030305L
#define STG_E_CSS_AUTHENTICATION_FAILURE 0x80030306L
#define STG_E_CSS_KEY_NOT_PRESENT 0x80030307L
#define STG_E_CSS_KEY_NOT_ESTABLISHED 0x80030308L
#define STG_E_CSS_SCRAMBLED_SECTOR 0x80030309L
#define STG_E_CSS_REGION_MISMATCH 0x8003030AL
#define STG_E_RESETS_EXHAUSTED 0x8003030BL
#define OLE_S_FIRST 0x00040000L #define OLE_S_FIRST 0x00040000L
#define OLE_S_USEREG 0x00040000L #define OLE_S_USEREG 0x00040000L
#define OLE_S_STATIC 0x00040001L #define OLE_S_STATIC 0x00040001L
@ -1957,5 +2004,69 @@ extern int WIN32_LastError;
#define NTE_SYS_ERR 0x80090021L #define NTE_SYS_ERR 0x80090021L
#define NTE_OP_OK 0 #define NTE_OP_OK 0
#define SEC_E_INSUFFICIENT_MEMORY 0x80090300L
#define SEC_E_INVALID_HANDLE 0x80090301L
#define SEC_E_UNSUPPORTED_FUNCTION 0x80090302L
#define SEC_E_TARGET_UNKNOWN 0x80090303L
#define SEC_E_INTERNAL_ERROR 0x80090304L
#define SEC_E_SECPKG_NOT_FOUND 0x80090305L
#define SEC_E_NOT_OWNER 0x80090306L
#define SEC_E_CANNOT_INSTALL 0x80090307L
#define SEC_E_INVALID_TOKEN 0x80090308L
#define SEC_E_CANNOT_PACK 0x80090309L
#define SEC_E_QOP_NOT_SUPPORTED 0x8009030AL
#define SEC_E_NO_IMPERSONATION 0x8009030BL
#define SEC_E_LOGON_DENIED 0x8009030CL
#define SEC_E_UNKNOWN_CREDENTIALS 0x8009030DL
#define SEC_E_NO_CREDENTIALS 0x8009030EL
#define SEC_E_MESSAGE_ALTERED 0x8009030FL
#define SEC_E_OUT_OF_SEQUENCE 0x80090310L
#define SEC_E_NO_AUTHENTICATING_AUTHORITY 0x80090311L
#define SEC_E_BAD_PKGID 0x80090316L
#define SEC_E_CONTEXT_EXPIRED 0x80090317L
#define SEC_E_INCOMPLETE_MESSAGE 0x80090318L
#define SEC_E_INCOMPLETE_CREDENTIALS 0x80090320L
#define SEC_E_BUFFER_TOO_SMALL 0x80090321L
#define SEC_E_WRONG_PRINCIPAL 0x80090322L
#define SEC_E_UNTRUSTED_ROOT 0x80090325L
#define SEC_E_ILLEGAL_MESSAGE 0x80090326L
#define SEC_E_CERT_UNKNOWN 0x80090327L
#define SEC_E_CERT_EXPIRED 0x80090328L
#define SEC_E_ENCRYPT_FAILURE 0x80090329L
#define SEC_E_DECRYPT_FAILURE 0x80090330L
#define SEC_E_ALGORITHM_MISMATCH 0x80090331L
#define SEC_E_UNFINISHED_CONTEXT_DELETED 0x80090333L
#define SEC_E_NO_TGT_REPLY 0x80090334L
#define SEC_E_NO_IP_ADDRESSES 0x80090335L
#define SEC_E_WRONG_CREDENTIAL_HANDLE 0x80090336L
#define SEC_E_CRYPTO_SYSTEM_INVALID 0x80090337L
#define SEC_E_MAX_REFERRALS_EXCEEDED 0x80090338L
#define SEC_E_MUST_BE_KDC 0x80090339L
#define SEC_E_STRONG_CRYPTO_NOT_SUPPORTED 0x8009033AL
#define SEC_E_TOO_MANY_PRINCIPALS 0x8009033BL
#define SEC_E_NO_PA_DATA 0x8009033CL
#define SEC_E_PKINIT_NAME_MISMATCH 0x8009033DL
#define SEC_E_SMARTCARD_LOGON_REQUIRED 0x8009033EL
#define SEC_E_KDC_INVALID_REQUEST 0x80090340L
#define SEC_E_KDC_UNABLE_TO_REFER 0x80090341L
#define SEC_E_KDC_UNKNOWN_ETYPE 0x80090342L
#define SEC_E_UNSUPPORTED_PREAUTH 0x80090343L
#define SEC_E_BAD_BINDINGS 0x80090346L
#define SEC_E_MULTIPLE_ACCOUNTS 0x80090347L
#define SEC_E_NO_KERB_KEY 0x80090348L
#define CRYPT_E_REVOKED 0x80092010L
#define CRYPT_E_NO_REVOCATION_CHECK 0x80092012L
#define CRYPT_E_REVOCATION_OFFLINE 0x80092013L
#define TRUST_E_CERT_SIGNATURE 0x80096004L
/* Smart card management error codes */
#define SCARD_E_NO_SMARTCARD 0x8010000CL
#define SCARD_E_NO_SUCH_CERTIFICATE 0x8010002CL
#define SCARD_E_COMM_DATA_LOST 0x8010002FL
#define SCARD_W_WRONG_CHV 0x8010006BL
#define SCARD_W_CHV_BLOCKED 0x8010006CL
#define SCARD_W_CARD_NOT_AUTHENTICATED 0x8010006FL
#endif /* __WINE_WINERROR_H */ #endif /* __WINE_WINERROR_H */

252
include/winnt.h
View File

@ -1492,6 +1492,7 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_CRASH_DUMP 0x00000116 #define STATUS_CRASH_DUMP 0x00000116
#define STATUS_BUFFER_ALL_ZEROS 0x00000117 #define STATUS_BUFFER_ALL_ZEROS 0x00000117
#define STATUS_REPARSE_OBJECT 0x00000118 #define STATUS_REPARSE_OBJECT 0x00000118
#define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY 0x00000121
#define STATUS_THREAD_WAS_SUSPENDED 0x40000001 #define STATUS_THREAD_WAS_SUSPENDED 0x40000001
#define STATUS_WORKING_SET_LIMIT_RANGE 0x40000002 #define STATUS_WORKING_SET_LIMIT_RANGE 0x40000002
@ -1530,6 +1531,9 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE 0x40000023 #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE 0x40000023
#define STATUS_NO_YIELD_PERFORMED 0x40000024 #define STATUS_NO_YIELD_PERFORMED 0x40000024
#define STATUS_TIMER_RESUME_IGNORED 0x40000025 #define STATUS_TIMER_RESUME_IGNORED 0x40000025
#define STATUS_DS_SHUTTING_DOWN 0x40000370
#define RPC_NT_SEND_INCOMPLETE 0x400200AF
#define STATUS_GUARD_PAGE_VIOLATION 0x80000001 #define STATUS_GUARD_PAGE_VIOLATION 0x80000001
#define STATUS_DATATYPE_MISALIGNMENT 0x80000002 #define STATUS_DATATYPE_MISALIGNMENT 0x80000002
@ -1567,6 +1571,16 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_SERVER_HAS_OPEN_HANDLES 0x80000024 #define STATUS_SERVER_HAS_OPEN_HANDLES 0x80000024
#define STATUS_ALREADY_DISCONNECTED 0x80000025 #define STATUS_ALREADY_DISCONNECTED 0x80000025
#define STATUS_LONGJUMP 0x80000026 #define STATUS_LONGJUMP 0x80000026
#define STATUS_CLEANER_CARTRIDGE_INSTALLED 0x80000027
#define STATUS_DEVICE_REQUIRES_CLEANING 0x80000288
#define STATUS_DEVICE_DOOR_OPEN 0x80000289
#define STATUS_CLUSTER_NODE_ALREADY_UP 0x80130001
#define STATUS_CLUSTER_NODE_ALREADY_DOWN 0x80130002
#define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE 0x80130003
#define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE 0x80130004
#define STATUS_CLUSTER_NODE_ALREADY_MEMBER 0x80130005
#define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_UNSUCCESSFUL 0xC0000001
#define STATUS_NOT_IMPLEMENTED 0xC0000002 #define STATUS_NOT_IMPLEMENTED 0xC0000002
@ -1625,7 +1639,7 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_DEVICE_ALREADY_ATTACHED 0xC0000038 #define STATUS_DEVICE_ALREADY_ATTACHED 0xC0000038
#define STATUS_OBJECT_PATH_INVALID 0xC0000039 #define STATUS_OBJECT_PATH_INVALID 0xC0000039
#define STATUS_OBJECT_PATH_NOT_FOUND 0xC000003A #define STATUS_OBJECT_PATH_NOT_FOUND 0xC000003A
#define STATUS_PATH_SYNTAX_BAD 0xC000003B #define STATUS_OBJECT_PATH_SYNTAX_BAD 0xC000003B
#define STATUS_DATA_OVERRUN 0xC000003C #define STATUS_DATA_OVERRUN 0xC000003C
#define STATUS_DATA_LATE_ERROR 0xC000003D #define STATUS_DATA_LATE_ERROR 0xC000003D
#define STATUS_DATA_ERROR 0xC000003E #define STATUS_DATA_ERROR 0xC000003E
@ -1650,8 +1664,8 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_NONEXISTENT_EA_ENTRY 0xC0000051 #define STATUS_NONEXISTENT_EA_ENTRY 0xC0000051
#define STATUS_NO_EAS_ON_FILE 0xC0000052 #define STATUS_NO_EAS_ON_FILE 0xC0000052
#define STATUS_EA_CORRUPT_ERROR 0xC0000053 #define STATUS_EA_CORRUPT_ERROR 0xC0000053
#define STATUS_LOCK_NOT_GRANTED 0xC0000054 /* FIXME: not sure */ #define STATUS_FILE_LOCK_CONFLICT 0xC0000054
#define STATUS_FILE_LOCK_CONFLICT 0xC0000055 /* FIXME: not sure */ #define STATUS_LOCK_NOT_GRANTED 0xC0000055
#define STATUS_DELETE_PENDING 0xC0000056 #define STATUS_DELETE_PENDING 0xC0000056
#define STATUS_CTL_FILE_NOT_SUPPORTED 0xC0000057 #define STATUS_CTL_FILE_NOT_SUPPORTED 0xC0000057
#define STATUS_UNKNOWN_REVISION 0xC0000058 #define STATUS_UNKNOWN_REVISION 0xC0000058
@ -1820,6 +1834,7 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_REDIRECTOR_NOT_STARTED 0xC00000FB #define STATUS_REDIRECTOR_NOT_STARTED 0xC00000FB
#define STATUS_REDIRECTOR_STARTED 0xC00000FC #define STATUS_REDIRECTOR_STARTED 0xC00000FC
#define STATUS_STACK_OVERFLOW 0xC00000FD #define STATUS_STACK_OVERFLOW 0xC00000FD
#define STATUS_NO_SUCH_PACKAGE 0xC00000FE
#define STATUS_BAD_FUNCTION_TABLE 0xC00000FF #define STATUS_BAD_FUNCTION_TABLE 0xC00000FF
#define STATUS_VARIABLE_NOT_FOUND 0xC0000100 #define STATUS_VARIABLE_NOT_FOUND 0xC0000100
#define STATUS_DIRECTORY_NOT_EMPTY 0xC0000101 #define STATUS_DIRECTORY_NOT_EMPTY 0xC0000101
@ -2080,6 +2095,160 @@ static DWORD __builtin_return_address(int p_iDepth)
#define STATUS_VOLUME_DISMOUNTED 0xC000026E #define STATUS_VOLUME_DISMOUNTED 0xC000026E
#define STATUS_WX86_INTERNAL_ERROR 0xC000026F #define STATUS_WX86_INTERNAL_ERROR 0xC000026F
#define STATUS_WX86_FLOAT_STACK_CHECK 0xC0000270 #define STATUS_WX86_FLOAT_STACK_CHECK 0xC0000270
#define STATUS_NO_MATCH 0xC0000272
#define STATUS_NOT_A_REPARSE_POINT 0xC0000275
#define STATUS_IO_REPARSE_TAG_INVALID 0xC0000276
#define STATUS_IO_REPARSE_TAG_MISMATCH 0xC0000277
#define STATUS_IO_REPARSE_DATA_INVALID 0xC0000278
#define STATUS_IO_REPARSE_TAG_NOT_HANDLED 0xC0000279
#define STATUS_REPARSE_POINT_NOT_RESOLVED 0xC0000280
#define STATUS_DIRECTORY_IS_A_REPARSE_POINT 0xC0000281
#define STATUS_SOURCE_ELEMENT_EMPTY 0xC0000283
#define STATUS_DESTINATION_ELEMENT_FULL 0xC0000284
#define STATUS_ILLEGAL_ELEMENT_ADDRESS 0xC0000285
#define STATUS_MAGAZINE_NOT_PRESENT 0xC0000286
#define STATUS_REINITIALIZATION_NEEDED 0xC0000287
#define STATUS_ENCRYPTION_FAILED 0xC000028A
#define STATUS_DECRYPTION_FAILED 0xC000028B
#define STATUS_NO_RECOVERY_POLICY 0xC000028D
#define STATUS_NO_EFS 0xC000028E
#define STATUS_WRONG_EFS 0xC000028F
#define STATUS_NO_USER_KEYS 0xC0000290
#define STATUS_FILE_NOT_ENCRYPTED 0xC0000291
#define STATUS_NOT_EXPORT_FORMAT 0xC0000292
#define STATUS_FILE_ENCRYPTED 0xC0000293
#define STATUS_WMI_GUID_NOT_FOUND 0xC0000295
#define STATUS_WMI_INSTANCE_NOT_FOUND 0xC0000296
#define STATUS_WMI_ITEMID_NOT_FOUND 0xC0000297
#define STATUS_WMI_TRY_AGAIN 0xC0000298
#define STATUS_SHARED_POLICY 0xC0000299
#define STATUS_POLICY_OBJECT_NOT_FOUND 0xC000029A
#define STATUS_POLICY_ONLY_IN_DS 0xC000029B
#define STATUS_VOLUME_NOT_UPGRADED 0xC000029C
#define STATUS_REMOTE_STORAGE_NOT_ACTIVE 0xC000029D
#define STATUS_REMOTE_STORAGE_MEDIA_ERROR 0xC000029E
#define STATUS_NO_TRACKING_SERVICE 0xC000029F
#define STATUS_DS_NO_ATTRIBUTE_OR_VALUE 0xC00002A1
#define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX 0xC00002A2
#define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED 0xC00002A3
#define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS 0xC00002A4
#define STATUS_DS_BUSY 0xC00002A5
#define STATUS_DS_UNAVAILABLE 0xC00002A6
#define STATUS_DS_NO_RIDS_ALLOCATED 0xC00002A7
#define STATUS_DS_NO_MORE_RIDS 0xC00002A8
#define STATUS_DS_INCORRECT_ROLE_OWNER 0xC00002A9
#define STATUS_DS_RIDMGR_INIT_ERROR 0xC00002AA
#define STATUS_DS_OBJ_CLASS_VIOLATION 0xC00002AB
#define STATUS_DS_CANT_ON_NON_LEAF 0xC00002AC
#define STATUS_DS_CANT_ON_RDN 0xC00002AD
#define STATUS_DS_CANT_MOD_OBJ_CLASS 0xC00002AE
#define STATUS_DS_CROSS_DOM_MOVE_FAILED 0xC00002AF
#define STATUS_DS_GC_NOT_AVAILABLE 0xC00002B0
#define STATUS_DIRECTORY_SERVICE_REQUIRED 0xC00002B1
#define STATUS_REPARSE_ATTRIBUTE_CONFLICT 0xC00002B2
#define STATUS_DEVICE_REMOVED 0xC00002B6
#define STATUS_JOURNAL_DELETE_IN_PROGRESS 0xC00002B7
#define STATUS_JOURNAL_NOT_ACTIVE 0xC00002B8
#define STATUS_DS_ADMIN_LIMIT_EXCEEDED 0xC00002C1
#define STATUS_MUTUAL_AUTHENTICATION_FAILED 0xC00002C3
#define STATUS_DATATYPE_MISALIGNMENT_ERROR 0xC00002C5
#define STATUS_WMI_READ_ONLY 0xC00002C6
#define STATUS_WMI_SET_FAILURE 0xC00002C7
#define STATUS_REG_NAT_CONSUMPTION 0xC00002C9
#define STATUS_TRANSPORT_FULL 0xC00002CA
#define STATUS_DS_SAM_INIT_FAILURE 0xC00002CB
#define STATUS_ONLY_IF_CONNECTED 0xC00002CC
#define STATUS_DS_SENSITIVE_GROUP_VIOLATION 0xC00002CD
#define STATUS_JOURNAL_ENTRY_DELETED 0xC00002CF
#define STATUS_DS_CANT_MOD_PRIMARYGROUPID 0xC00002D0
#define STATUS_DS_INVALID_GROUP_TYPE 0xC00002D4
#define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN 0xC00002D5
#define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN 0xC00002D6
#define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER 0xC00002D7
#define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER 0xC00002D8
#define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER 0xC00002D9
#define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER 0xC00002DA
#define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER 0xC00002DB
#define STATUS_DS_HAVE_PRIMARY_MEMBERS 0xC00002DC
#define STATUS_WMI_NOT_SUPPORTED 0xC00002DD
#define STATUS_SAM_NEED_BOOTKEY_PASSWORD 0xC00002DF
#define STATUS_SAM_NEED_BOOTKEY_FLOPPY 0xC00002E0
#define STATUS_DS_CANT_START 0xC00002E1
#define STATUS_DS_INIT_FAILURE 0xC00002E2
#define STATUS_SAM_INIT_FAILURE 0xC00002E3
#define STATUS_DS_GC_REQUIRED 0xC00002E4
#define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY 0xC00002E5
#define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS 0xC00002E6
#define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED 0xC00002E7
#define STATUS_CURRENT_DOMAIN_NOT_ALLOWED 0xC00002E9
#define STATUS_CANNOT_MAKE 0xC00002EA
#define STATUS_DS_INIT_FAILURE_CONSOLE 0xC00002EC
#define STATUS_DS_SAM_INIT_FAILURE_CONSOLE 0xC00002ED
#define STATUS_UNFINISHED_CONTEXT_DELETED 0xC00002EE
#define STATUS_NO_TGT_REPLY 0xC00002EF
#define STATUS_OBJECTID_NOT_FOUND 0xC00002F0
#define STATUS_NO_IP_ADDRESSES 0xC00002F1
#define STATUS_WRONG_CREDENTIAL_HANDLE 0xC00002F2
#define STATUS_CRYPTO_SYSTEM_INVALID 0xC00002F3
#define STATUS_MAX_REFERRALS_EXCEEDED 0xC00002F4
#define STATUS_MUST_BE_KDC 0xC00002F5
#define STATUS_STRONG_CRYPTO_NOT_SUPPORTED 0xC00002F6
#define STATUS_TOO_MANY_PRINCIPALS 0xC00002F7
#define STATUS_NO_PA_DATA 0xC00002F8
#define STATUS_PKINIT_NAME_MISMATCH 0xC00002F9
#define STATUS_SMARTCARD_LOGON_REQUIRED 0xC00002FA
#define STATUS_KDC_INVALID_REQUEST 0xC00002FB
#define STATUS_KDC_UNABLE_TO_REFER 0xC00002FC
#define STATUS_KDC_UNKNOWN_ETYPE 0xC00002FD
#define STATUS_SHUTDOWN_IN_PROGRESS 0xC00002FE
#define STATUS_SERVER_SHUTDOWN_IN_PROGRESS 0xC00002FF
#define STATUS_NOT_SUPPORTED_ON_SBS 0xC0000300
#define STATUS_WMI_GUID_DISCONNECTED 0xC0000301
#define STATUS_WMI_ALREADY_DISABLED 0xC0000302
#define STATUS_WMI_ALREADY_ENABLED 0xC0000303
#define STATUS_MFT_TOO_FRAGMENTED 0xC0000304
#define STATUS_COPY_PROTECTION_FAILURE 0xC0000305
#define STATUS_CSS_AUTHENTICATION_FAILURE 0xC0000306
#define STATUS_CSS_KEY_NOT_PRESENT 0xC0000307
#define STATUS_CSS_KEY_NOT_ESTABLISHED 0xC0000308
#define STATUS_CSS_SCRAMBLED_SECTOR 0xC0000309
#define STATUS_CSS_REGION_MISMATCH 0xC000030A
#define STATUS_CSS_RESETS_EXHAUSTED 0xC000030B
#define STATUS_PKINIT_FAILURE 0xC0000320
#define STATUS_SMARTCARD_SUBSYSTEM_FAILURE 0xC0000321
#define STATUS_NO_KERB_KEY 0xC0000322
#define STATUS_HOST_DOWN 0xC0000350
#define STATUS_UNSUPPORTED_PREAUTH 0xC0000351
#define STATUS_EFS_ALG_BLOB_TOO_BIG 0xC0000352
#define STATUS_AUDITING_DISABLED 0xC0000356
#define STATUS_PRENT4_MACHINE_ACCOUNT 0xC0000357
#define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER 0xC0000358
#define STATUS_INVALID_IMAGE_WIN_32 0xC0000359
#define STATUS_INVALID_IMAGE_WIN_64 0xC000035A
#define STATUS_BAD_BINDINGS 0xC000035B
#define STATUS_NETWORK_SESSION_EXPIRED 0xC000035C
#define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT 0xC0000361
#define STATUS_ACCESS_DISABLED_BY_POLICY_PATH 0xC0000362
#define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER 0xC0000363
#define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER 0xC0000364
#define STATUS_DRIVER_BLOCKED_CRITICAL 0xC000036B
#define STATUS_DRIVER_BLOCKED 0xC000036C
#define STATUS_INVALID_IMPORT_OF_NON_DLL 0xC000036F
#define STATUS_SMARTCARD_WRONG_PIN 0xC0000380
#define STATUS_SMARTCARD_CARD_BLOCKED 0xC0000381
#define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED 0xC0000382
#define STATUS_SMARTCARD_NO_CARD 0xC0000383
#define STATUS_SMARTCARD_NO_KEY_CONTAINER 0xC0000384
#define STATUS_SMARTCARD_NO_CERTIFICATE 0xC0000385
#define STATUS_SMARTCARD_NO_KEYSET 0xC0000386
#define STATUS_SMARTCARD_IO_ERROR 0xC0000387
#define STATUS_DOWNGRADE_DETECTED 0xC0000388
#define STATUS_SMARTCARD_CERT_REVOKED 0xC0000389
#define STATUS_ISSUING_CA_UNTRUSTED 0xC000038A
#define STATUS_REVOCATION_OFFLINE_C 0xC000038B
#define STATUS_PKINIT_CLIENT_FAILURE 0xC000038C
#define STATUS_SMARTCARD_CERT_EXPIRED 0xC000038D
#define STATUS_WOW_ASSERTION 0xC0009898 #define STATUS_WOW_ASSERTION 0xC0009898
#define RPC_NT_INVALID_STRING_BINDING 0xC0020001 #define RPC_NT_INVALID_STRING_BINDING 0xC0020001
#define RPC_NT_WRONG_KIND_OF_BINDING 0xC0020002 #define RPC_NT_WRONG_KIND_OF_BINDING 0xC0020002
@ -2183,7 +2352,82 @@ static DWORD __builtin_return_address(int p_iDepth)
#define RPC_NT_INVALID_PIPE_OBJECT 0xC003005C #define RPC_NT_INVALID_PIPE_OBJECT 0xC003005C
#define RPC_NT_INVALID_PIPE_OPERATION 0xC003005D #define RPC_NT_INVALID_PIPE_OPERATION 0xC003005D
#define RPC_NT_WRONG_PIPE_VERSION 0xC003005E #define RPC_NT_WRONG_PIPE_VERSION 0xC003005E
#define RPC_NT_SEND_INCOMPLETE 0x400200AF #define RPC_NT_INVALID_ASYNC_HANDLE 0xC0020062
#define RPC_NT_INVALID_ASYNC_CALL 0xC0020063
#define RPC_NT_PIPE_CLOSED 0xC003005F
#define RPC_NT_PIPE_DISCIPLINE_ERROR 0xC0030060
#define RPC_NT_PIPE_EMPTY 0xC0030061
#define STATUS_CTX_WINSTATION_NAME_INVALID 0xC00A0001
#define STATUS_CTX_INVALID_PD 0xC00A0002
#define STATUS_CTX_PD_NOT_FOUND 0xC00A0003
#define STATUS_CTX_CLOSE_PENDING 0xC00A0006
#define STATUS_CTX_NO_OUTBUF 0xC00A0007
#define STATUS_CTX_MODEM_INF_NOT_FOUND 0xC00A0008
#define STATUS_CTX_INVALID_MODEMNAME 0xC00A0009
#define STATUS_CTX_RESPONSE_ERROR 0xC00A000A
#define STATUS_CTX_MODEM_RESPONSE_TIMEOUT 0xC00A000B
#define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER 0xC00A000C
#define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE 0xC00A000D
#define STATUS_CTX_MODEM_RESPONSE_BUSY 0xC00A000E
#define STATUS_CTX_MODEM_RESPONSE_VOICE 0xC00A000F
#define STATUS_CTX_TD_ERROR 0xC00A0010
#define STATUS_CTX_LICENSE_CLIENT_INVALID 0xC00A0012
#define STATUS_CTX_LICENSE_NOT_AVAILABLE 0xC00A0013
#define STATUS_CTX_LICENSE_EXPIRED 0xC00A0014
#define STATUS_CTX_WINSTATION_NOT_FOUND 0xC00A0015
#define STATUS_CTX_WINSTATION_NAME_COLLISION 0xC00A0016
#define STATUS_CTX_WINSTATION_BUSY 0xC00A0017
#define STATUS_CTX_BAD_VIDEO_MODE 0xC00A0018
#define STATUS_CTX_GRAPHICS_INVALID 0xC00A0022
#define STATUS_CTX_NOT_CONSOLE 0xC00A0024
#define STATUS_CTX_CLIENT_QUERY_TIMEOUT 0xC00A0026
#define STATUS_CTX_CONSOLE_DISCONNECT 0xC00A0027
#define STATUS_CTX_CONSOLE_CONNECT 0xC00A0028
#define STATUS_CTX_SHADOW_DENIED 0xC00A002A
#define STATUS_CTX_WINSTATION_ACCESS_DENIED 0xC00A002B
#define STATUS_CTX_INVALID_WD 0xC00A002E
#define STATUS_CTX_WD_NOT_FOUND 0xC00A002F
#define STATUS_CTX_SHADOW_INVALID 0xC00A0030
#define STATUS_CTX_SHADOW_DISABLED 0xC00A0031
#define STATUS_CTX_CLIENT_LICENSE_NOT_SET 0xC00A0033
#define STATUS_CTX_CLIENT_LICENSE_IN_USE 0xC00A0034
#define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE 0xC00A0035
#define STATUS_CTX_SHADOW_NOT_RUNNING 0xC00A0036
#define STATUS_CLUSTER_INVALID_NODE 0xC0130001
#define STATUS_CLUSTER_NODE_EXISTS 0xC0130002
#define STATUS_CLUSTER_JOIN_IN_PROGRESS 0xC0130003
#define STATUS_CLUSTER_NODE_NOT_FOUND 0xC0130004
#define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND 0xC0130005
#define STATUS_CLUSTER_NETWORK_EXISTS 0xC0130006
#define STATUS_CLUSTER_NETWORK_NOT_FOUND 0xC0130007
#define STATUS_CLUSTER_NETINTERFACE_EXISTS 0xC0130008
#define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND 0xC0130009
#define STATUS_CLUSTER_INVALID_REQUEST 0xC013000A
#define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER 0xC013000B
#define STATUS_CLUSTER_NODE_DOWN 0xC013000C
#define STATUS_CLUSTER_NODE_UNREACHABLE 0xC013000D
#define STATUS_CLUSTER_NODE_NOT_MEMBER 0xC013000E
#define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS 0xC013000F
#define STATUS_CLUSTER_INVALID_NETWORK 0xC0130010
#define STATUS_CLUSTER_NODE_UP 0xC0130012
#define STATUS_CLUSTER_NODE_PAUSED 0xC0130013
#define STATUS_CLUSTER_NODE_NOT_PAUSED 0xC0130014
#define STATUS_CLUSTER_NO_SECURITY_CONTEXT 0xC0130015
#define STATUS_CLUSTER_NETWORK_NOT_INTERNAL 0xC0130016
#define STATUS_SXS_SECTION_NOT_FOUND 0xC0150001
#define STATUS_SXS_CANT_GEN_ACTCTX 0xC0150002
#define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT 0xC0150003
#define STATUS_SXS_ASSEMBLY_NOT_FOUND 0xC0150004
#define STATUS_SXS_MANIFEST_FORMAT_ERROR 0xC0150005
#define STATUS_SXS_MANIFEST_PARSE_ERROR 0xC0150006
#define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED 0xC0150007
#define STATUS_SXS_KEY_NOT_FOUND 0xC0150008
#define STATUS_SXS_WRONG_SECTION_TYPE 0xC015000A
#define STATUS_SXS_THREAD_QUERIES_DISABLED 0xC015000B
#define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET 0xC015000E
#define MAXIMUM_WAIT_OBJECTS 64 #define MAXIMUM_WAIT_OBJECTS 64
#define MAXIMUM_SUSPEND_COUNT 127 #define MAXIMUM_SUSPEND_COUNT 127