#include <stdlib.h>
|
|
#include "il2cpp-config.h"
|
|
#include "os/Messages.h"
|
|
#define N_ELEMENTS(e) \
|
(sizeof (e) / sizeof ((e)[0]))
|
|
namespace il2cpp
|
{
|
namespace os
|
{
|
ErrorDesc common_messages[] =
|
{
|
{ kErrorCodeSuccess, "Success" },
|
{ kErrorCodeFileNotFound, "Cannot find the specified file" },
|
{ kErrorCodePathNotFound, "Cannot find the specified file" },
|
{ kErrorCodeTooManyOpenFiles, "Too many open files" },
|
{ kErrorCodeAccessDenied, "Access denied" },
|
{ kErrorCodeInvalidHandle, "Invalid handle" },
|
{ kErrorInvalidData, "Invalid data" },
|
{ kErrorOutofmemory, "Out of memory" },
|
{ kErrorCodeNotSameDevice, "Not same device" },
|
{ kErrorCodeNoMoreFiles, "No more files" },
|
{ kErrorBadLength, "Bad length" },
|
{ kErrorCodeGenFailure, "General failure" },
|
{ kErrorCodeSharingViolation, "Sharing violation" },
|
{ kErrorCodeLockViolation, "Lock violation" },
|
{ kErrorNotSupported, "Operation not supported" },
|
{ kErrorCodeInvalidParameter, "Invalid parameter" },
|
{ kErrorCallNotImplemented, "Call not implemented" },
|
{ kErrorCodeInvalidName, "Invalid name" },
|
{ kErrorProcNotFound, "Process not found" },
|
{ kErrorCodeAlreadyExists, "Already exists" },
|
{ kErrorDirectory, "Is a directory" },
|
{ kErrorCodeEncryptionFailed, "Encryption failed" },
|
{ kWSAeintr, "interrupted" },
|
{ kWSAebadf, "Bad file number" },
|
{ kWSAeacces, "Access denied" },
|
{ kWSAefault, "Bad address" },
|
{ kWSAeinval, "Invalid arguments" },
|
{ kWSAemfile, "Too many open files" },
|
{ kWSAewouldblock, "Operation on non-blocking socket would block" },
|
{ kWSAeinprogress, "Operation in progress" },
|
{ kWSAealready, "Operation already in progress" },
|
{ kWSAenotsock, "The descriptor is not a socket" },
|
{ kWSAedestaddrreq, "Destination address required" },
|
{ kWSAemsgsize, "Message too long" },
|
{ kWSAeprototype, "Protocol wrong type for socket" },
|
{ kWSAenoprotoopt, "Protocol option not supported" },
|
{ kWSAeprotonosupport, "Protocol not supported" },
|
{ kWSAesocktnosupport, "Socket not supported" },
|
{ kWSAeopnotsupp, "Operation not supported" },
|
{ kWSAepfnosupport, "Protocol family not supported" },
|
{ kWSAeafnosupport, "An address incompatible with the requested protocol was used" },
|
{ kWSAeaddrinuse, "Address already in use" },
|
{ kWSAeaddrnotavail, "The requested address is not valid in this context" },
|
{ kWSAenetdown, "Network subsystem is down" },
|
{ kWSAenetunreach, "Network is unreachable" },
|
{ kWSAenetreset, "Connection broken, keep-alive detected a problem" },
|
{ kWSAeconnaborted, "An established connection was aborted in your host machine." },
|
{ kWSAeconnreset, "Connection reset by peer" },
|
{ kWSAenobufs, "Not enough buffer space is available" },
|
{ kWSAeisconn, "Socket is already connected" },
|
{ kWSAenotconn, "The socket is not connected" },
|
{ kWSAeshutdown, "The socket has been shut down" },
|
{ kWSAetoomanyrefs, "Too many references: cannot splice" },
|
{ kWSAetimedout, "Connection timed out" },
|
{ kWSAeconnrefused, "Connection refused" },
|
{ kWSAeloop, "Too many symbolic links encountered" },
|
{ kWSAenametoolong, "File name too long" },
|
{ kWSAehostdown, "Host is down" },
|
{ kWSAehostunreach, "No route to host" },
|
{ kWSAenotempty, "Directory not empty" },
|
{ kWSAeproclim, "EPROCLIM" },
|
{ kWSAeusers, "Too many users" },
|
{ kWSAedquot, "Quota exceeded" },
|
{ kWSAestale, "Stale NFS file handle" },
|
{ kWSAeremote, "Object is remote" },
|
{ kWSAsysnotready, "SYSNOTREADY" },
|
{ kWSAvernotsupported, "VERNOTSUPPORTED" },
|
{ kWSAnotinitialised, "Winsock not initialised" },
|
{ kWSAediscon, "EDISCON" },
|
{ kWSAenomore, "ENOMORE" },
|
{ kWSAecancelled, "Operation canceled" },
|
{ kWSAeinvalidproctable, "EINVALIDPROCTABLE" },
|
{ kWSAeinvalidprovider, "EINVALIDPROVIDER" },
|
{ kWSAeproviderfailedinit, "EPROVIDERFAILEDINIT" },
|
{ kWSAsyscallfailure, "System call failed" },
|
{ kWSAserviceNotFound, "SERVICE_NOT_FOUND" },
|
{ kWSAtypeNotFound, "TYPE_NOT_FOUND" },
|
{ kWSAENoMore, "E_NO_MORE" },
|
{ kWSAECancelled, "E_CANCELLED" },
|
{ kWSAerefused, "EREFUSED" },
|
{ kWSAhostNotFound, "No such host is known" },
|
{ kWSAtryAgain, "A temporary error occurred on an authoritative name server. Try again later." },
|
{ kWSAnoRecovery, "No recovery" },
|
{ kWSAnoData, "No data" },
|
};
|
|
#ifndef IL2CPP_DISABLE_FULL_MESSAGES
|
ErrorDesc messages[] =
|
{
|
{ kErrorInvalidFunction, "Invalid function" },
|
{ kErrorArenaTrashed, "Arena trashed" },
|
{ kErrorNotEnoughMemory, "Not enough memory" },
|
{ kErrorInvalidBlock, "Invalid block" },
|
{ kErrorBadEnvironment, "Bad environment" },
|
{ kErrorBadFormat, "Bad format" },
|
{ kErrorInvalidAccess, "Invalid access" },
|
{ kErrorInvalidDrive, "Invalid drive" },
|
{ kErrorCurrentDirectory, "Current directory" },
|
{ kErrorWriteProtect, "Write protect" },
|
{ kErrorBadUnit, "Bad unit" },
|
{ kErrorNotReady, "Not ready" },
|
{ kErrorBadCommand, "Bad command" },
|
{ kErrorCrc, "CRC" },
|
{ kErrorSeek, "Seek" },
|
{ kErrorNotDosDisk, "Not DOS disk" },
|
{ kErrorSectorNotFound, "Sector not found" },
|
{ kErrorOutOfPaper, "Out of paper" },
|
{ kErrorWriteFault, "Write fault" },
|
{ kErrorReadFault, "Read fault" },
|
{ kErrorWrongDisk, "Wrong disk" },
|
{ kErrorSharingBufferExceeded, "Sharing buffer exceeded" },
|
{ kErrorHandleEof, "Handle EOF" },
|
{ kErrorHandleDiskFull, "Handle disk full" },
|
{ kErrorRemNotList, "Rem not list" },
|
{ kErrorDupName, "Duplicate name" },
|
{ kErrorBadNetpath, "Bad netpath" },
|
{ kErrorNetworkBusy, "Network busy" },
|
{ kErrorDevNotExist, "Device does not exist" },
|
{ kErrorTooManyCmds, "Too many commands" },
|
{ kErrorAdapHdwErr, "ADAP HDW error" },
|
{ kErrorBadNetResp, "Bad net response" },
|
{ kErrorUnexpNetErr, "Unexpected net error" },
|
{ kErrorBadRemAdap, "Bad rem adap" },
|
{ kErrorPrintqFull, "Print queue full" },
|
{ kErrorNoSpoolSpace, "No spool space" },
|
{ kErrorPrintCancelled, "Print cancelled" },
|
{ kErrorNetnameDeleted, "Netname deleted" },
|
{ kErrorNetworkAccessDenied, "Network access denied" },
|
{ kErrorBadDevType, "Bad device type" },
|
{ kErrorBadNetName, "Bad net name" },
|
{ kErrorTooManyNames, "Too many names" },
|
{ kErrorTooManySess, "Too many sessions" },
|
{ kErrorSharingPaused, "Sharing paused" },
|
{ kErrorReqNotAccep, "Req not accep" },
|
{ kErrorRedirPaused, "Redir paused" },
|
{ kErrorFileExists, "File exists" },
|
{ kErrorCannotMake, "Cannot make" },
|
{ kErrorFailI24, "Fail i24" },
|
{ kErrorOutOfStructures, "Out of structures" },
|
{ kErrorAlreadyAssigned, "Already assigned" },
|
{ kErrorInvalidPassword, "Invalid password" },
|
{ kErrorNetWriteFault, "Net write fault" },
|
{ kErrorNoProcSlots, "No proc slots" },
|
{ kErrorTooManySemaphores, "Too many semaphores" },
|
{ kErrorExclSemAlreadyOwned, "Exclusive semaphore already owned" },
|
{ kErrorSemIsSet, "Semaphore is set" },
|
{ kErrorTooManySemRequests, "Too many semaphore requests" },
|
{ kErrorInvalidAtInterruptTime, "Invalid at interrupt time" },
|
{ kErrorSemOwnerDied, "Semaphore owner died" },
|
{ kErrorSemUserLimit, "Semaphore user limit" },
|
{ kErrorDiskChange, "Disk change" },
|
{ kErrorDriveLocked, "Drive locked" },
|
{ kErrorBrokenPipe, "Broken pipe" },
|
{ kErrorOpenFailed, "Open failed" },
|
{ kErrorBufferOverflow, "Buffer overflow" },
|
{ kErrorDiskFull, "Disk full" },
|
{ kErrorNoMoreSearchHandles, "No more search handles" },
|
{ kErrorInvalidTargetHandle, "Invalid target handle" },
|
{ kErrorInvalidCategory, "Invalid category" },
|
{ kErrorInvalidVerifySwitch, "Invalid verify switch" },
|
{ kErrorBadDriverLevel, "Bad driver level" },
|
{ kErrorSemTimeout, "Semaphore timeout" },
|
{ kErrorInsufficientBuffer, "Insufficient buffer" },
|
{ kErrorInvalidLevel, "Invalid level" },
|
{ kErrorNoVolumeLabel, "No volume label" },
|
{ kErrorModNotFound, "Module not found" },
|
{ kErrorWaitNoChildren, "Wait no children" },
|
{ kErrorChildNotComplete, "Child not complete" },
|
{ kErrorDirectAccessHandle, "Direct access handle" },
|
{ kErrorNegativeSeek, "Negative seek" },
|
{ kErrorSeekOnDevice, "Seek on device" },
|
{ kErrorIsJoinTarget, "Is join target" },
|
{ kErrorIsJoined, "Is joined" },
|
{ kErrorIsSubsted, "Is substed" },
|
{ kErrorNotJoined, "Not joined" },
|
{ kErrorNotSubsted, "Not substed" },
|
{ kErrorJoinToJoin, "Join to join" },
|
{ kErrorSubstToSubst, "Subst to subst" },
|
{ kErrorJoinToSubst, "Join to subst" },
|
{ kErrorSubstToJoin, "Subst to join" },
|
{ kErrorBusyDrive, "Busy drive" },
|
{ kErrorSameDrive, "Same drive" },
|
{ kErrorDirNotRoot, "Directory not root" },
|
{ kErrorDirNotEmpty, "Directory not empty" },
|
{ kErrorIsSubstPath, "Is subst path" },
|
{ kErrorIsJoinPath, "Is join path" },
|
{ kErrorPathBusy, "Path busy" },
|
{ kErrorIsSubstTarget, "Is subst target" },
|
{ kErrorSystemTrace, "System trace" },
|
{ kErrorInvalidEventCount, "Invalid event count" },
|
{ kErrorTooManyMuxwaiters, "Too many muxwaiters" },
|
{ kErrorInvalidListFormat, "Invalid list format" },
|
{ kErrorLabelTooLong, "Label too long" },
|
{ kErrorTooManyTcbs, "Too many TCBs" },
|
{ kErrorSignalRefused, "Signal refused" },
|
{ kErrorDiscarded, "Discarded" },
|
{ kErrorNotLocked, "Not locked" },
|
{ kErrorBadThreadidAddr, "Bad thread ID addr" },
|
{ kErrorBadArguments, "Bad arguments" },
|
{ kErrorBadPathname, "Bad pathname" },
|
{ kErrorSignalPending, "Signal pending" },
|
{ kErrorMaxThrdsReached, "Max thrds reached" },
|
{ kErrorLockFailed, "Lock failed" },
|
{ kErrorBusy, "Busy" },
|
{ kErrorCancelViolation, "Cancel violation" },
|
{ kErrorAtomicLocksNotSupported, "Atomic locks not supported" },
|
{ kErrorInvalidSegmentNumber, "Invalid segment number" },
|
{ kErrorInvalidOrdinal, "Invalid ordinal" },
|
{ kErrorInvalidFlagNumber, "Invalid flag number" },
|
{ kErrorSemNotFound, "Sem not found" },
|
{ kErrorInvalidStartingCodeseg, "Invalid starting codeseg" },
|
{ kErrorInvalidStackseg, "Invalid stackseg" },
|
{ kErrorInvalidModuletype, "Invalid moduletype" },
|
{ kErrorInvalidExeSignature, "Invalid exe signature" },
|
{ kErrorExeMarkedInvalid, "Exe marked invalid" },
|
{ kErrorBadExeFormat, "Bad exe format" },
|
{ kErrorIteratedDataExceeds64k, "Iterated data exceeds 64k (and that should be enough for anybody!)" },
|
{ kErrorInvalidMinallocsize, "Invalid minallocsize" },
|
{ kErrorDynlinkFromInvalidRing, "Dynlink from invalid ring" },
|
{ kErrorIoplNotEnabled, "IOPL not enabled" },
|
{ kErrorInvalidSegdpl, "Invalid segdpl" },
|
{ kErrorAutodatasegExceeds64k, "Autodataseg exceeds 64k" },
|
{ kErrorRing2segMustBeMovable, "Ring2seg must be movable" },
|
{ kErrorRelocChainXeedsSeglim, "Reloc chain exceeds seglim" },
|
{ kErrorInfloopInRelocChain, "Infloop in reloc chain" },
|
{ kErrorEnvvarNotFound, "Env var not found" },
|
{ kErrorNoSignalSent, "No signal sent" },
|
{ kErrorFilenameExcedRange, "Filename exceeds range" },
|
{ kErrorRing2StackInUse, "Ring2 stack in use" },
|
{ kErrorMetaExpansionTooLong, "Meta expansion too long" },
|
{ kErrorInvalidSignalNumber, "Invalid signal number" },
|
{ kErrorThread1Inactive, "Thread 1 inactive" },
|
{ kErrorLocked, "Locked" },
|
{ kErrorTooManyModules, "Too many modules" },
|
{ kErrorNestingNotAllowed, "Nesting not allowed" },
|
{ kErrorExeMachineTypeMismatch, "Exe machine type mismatch" },
|
{ kErrorBadPipe, "Bad pipe" },
|
{ kErrorPipeBusy, "Pipe busy" },
|
{ kErrorNoData, "No data" },
|
{ kErrorPipeNotConnected, "Pipe not connected" },
|
{ kErrorMoreData, "More data" },
|
{ kErrorVcDisconnected, "VC disconnected" },
|
{ kErrorInvalidEaName, "Invalid EA name" },
|
{ kErrorEaListInconsistent, "EA list inconsistent" },
|
{ kWaitTimeout, "Wait timeout" },
|
{ kErrorNoMoreItems, "No more items" },
|
{ kErrorCannotCopy, "Cannot copy" },
|
{ kErrorEasDidntFit, "EAS didnt fit" },
|
{ kErrorEaFileCorrupt, "EA file corrupt" },
|
{ kErrorEaTableFull, "EA table full" },
|
{ kErrorInvalidEaHandle, "Invalid EA handle" },
|
{ kErrorEasNotSupported, "EAs not supported" },
|
{ kErrorNotOwner, "Not owner" },
|
{ kErrorTooManyPosts, "Too many posts" },
|
{ kErrorPartialCopy, "Partial copy" },
|
{ kErrorOplockNotGranted, "Oplock not granted" },
|
{ kErrorInvalidOplockProtocol, "Invalid oplock protocol" },
|
{ kErrorDiskTooFragmented, "Disk too fragmented" },
|
{ kErrorDeletePending, "Delete pending" },
|
{ kErrorMrMidNotFound, "Mr Mid not found" },
|
{ kErrorInvalidAddress, "Invalid address" },
|
{ kErrorArithmeticOverflow, "Arithmetic overflow" },
|
{ kErrorPipeConnected, "Pipe connected" },
|
{ kErrorPipeListening, "Pipe listening" },
|
{ kErrorEaAccessDenied, "EA access denied" },
|
{ kErrorOperationAborted, "Operation aborted" },
|
{ kErrorIoIncomplete, "IO incomplete" },
|
{ kErrorIoPending, "IO pending" },
|
{ kErrorNoaccess, "No access" },
|
{ kErrorSwaperror, "Swap error" },
|
{ kErrorStackOverflow, "Stack overflow" },
|
{ kErrorInvalidMessage, "Invalid message" },
|
{ kErrorCanNotComplete, "Can not complete" },
|
{ kErrorInvalidFlags, "Invalid flags" },
|
{ kErrorUnrecognizedVolume, "Unrecognised volume" },
|
{ kErrorFileInvalid, "File invalid" },
|
{ kErrorFullscreenMode, "Full screen mode" },
|
{ kErrorNoToken, "No token" },
|
{ kErrorBaddb, "Bad DB" },
|
{ kErrorBadkey, "Bad key" },
|
{ kErrorCantopen, "Can't open" },
|
{ kErrorCantread, "Can't read" },
|
{ kErrorCantwrite, "Can't write" },
|
{ kErrorRegistryRecovered, "Registry recovered" },
|
{ kErrorRegistryCorrupt, "Registry corrupt" },
|
{ kErrorRegistryIoFailed, "Registry IO failed" },
|
{ kErrorNotRegistryFile, "Not registry file" },
|
{ kErrorKeyDeleted, "Key deleted" },
|
{ kErrorNoLogSpace, "No log space" },
|
{ kErrorKeyHasChildren, "Key has children" },
|
{ kErrorChildMustBeVolatile, "Child must be volatile" },
|
{ kErrorNotifyEnumDir, "Notify enum dir" },
|
{ kErrorDependentServicesRunning, "Dependent services running" },
|
{ kErrorInvalidServiceControl, "Invalid service control" },
|
{ kErrorServiceRequestTimeout, "Service request timeout" },
|
{ kErrorServiceNoThread, "Service no thread" },
|
{ kErrorServiceDatabaseLocked, "Service database locked" },
|
{ kErrorServiceAlreadyRunning, "Service already running" },
|
{ kErrorInvalidServiceAccount, "Invalid service account" },
|
{ kErrorServiceDisabled, "Service disabled" },
|
{ kErrorCircularDependency, "Circular dependency" },
|
{ kErrorServiceDoesNotExist, "Service does not exist" },
|
{ kErrorServiceCannotAcceptCtrl, "Service cannot accept ctrl" },
|
{ kErrorServiceNotActive, "Service not active" },
|
{ kErrorFailedServiceControllerConnect, "Failed service controller connect" },
|
{ kErrorExceptionInService, "Exception in service" },
|
{ kErrorDatabaseDoesNotExist, "Database does not exist" },
|
{ kErrorServiceSpecificError, "Service specific error" },
|
{ kErrorProcessAborted, "Process aborted" },
|
{ kErrorServiceDependencyFail, "Service dependency fail" },
|
{ kErrorServiceLogonFailed, "Service logon failed" },
|
{ kErrorServiceStartHang, "Service start hang" },
|
{ kErrorInvalidServiceLock, "Invalid service lock" },
|
{ kErrorServiceMarkedForDelete, "Service marked for delete" },
|
{ kErrorServiceExists, "Service exists" },
|
{ kErrorAlreadyRunningLkg, "Already running lkg" },
|
{ kErrorServiceDependencyDeleted, "Service dependency deleted" },
|
{ kErrorBootAlreadyAccepted, "Boot already accepted" },
|
{ kErrorServiceNeverStarted, "Service never started" },
|
{ kErrorDuplicateServiceName, "Duplicate service name" },
|
{ kErrorDifferentServiceAccount, "Different service account" },
|
{ kErrorCannotDetectDriverFailure, "Cannot detect driver failure" },
|
{ kErrorCannotDetectProcessAbort, "Cannot detect process abort" },
|
{ kErrorNoRecoveryProgram, "No recovery program" },
|
{ kErrorServiceNotInExe, "Service not in exe" },
|
{ kErrorNotSafebootService, "Not safeboot service" },
|
{ kErrorEndOfMedia, "End of media" },
|
{ kErrorFilemarkDetected, "Filemark detected" },
|
{ kErrorBeginningOfMedia, "Beginning of media" },
|
{ kErrorSetmarkDetected, "Setmark detected" },
|
{ kErrorNoDataDetected, "No data detected" },
|
{ kErrorPartitionFailure, "Partition failure" },
|
{ kErrorInvalidBlockLength, "Invalid block length" },
|
{ kErrorDeviceNotPartitioned, "Device not partitioned" },
|
{ kErrorUnableToLockMedia, "Unable to lock media" },
|
{ kErrorUnableToUnloadMedia, "Unable to unload media" },
|
{ kErrorMediaChanged, "Media changed" },
|
{ kErrorBusReset, "Bus reset" },
|
{ kErrorNoMediaInDrive, "No media in drive" },
|
{ kErrorNoUnicodeTranslation, "No unicode translation" },
|
{ kErrorDllInitFailed, "DLL init failed" },
|
{ kErrorShutdownInProgress, "Shutdown in progress" },
|
{ kErrorNoShutdownInProgress, "No shutdown in progress" },
|
{ kErrorIoDevice, "IO device" },
|
{ kErrorSerialNoDevice, "Serial IO device" },
|
{ kErrorIrqBusy, "IRQ busy" },
|
{ kErrorMoreWrites, "More writes" },
|
{ kErrorCounterTimeout, "Counter timeout" },
|
{ kErrorFloppyIdMarkNotFound, "Floppy ID mark not found" },
|
{ kErrorFloppyWrongCylinder, "Floppy wrong cylinder" },
|
{ kErrorFloppyUnknownError, "Floppy unknown error" },
|
{ kErrorFloppyBadRegisters, "Floppy bad registers" },
|
{ kErrorDiskRecalibrateFailed, "Disk recalibrate failed" },
|
{ kErrorDiskOperationFailed, "Disk operation failed" },
|
{ kErrorDiskResetFailed, "Disk reset failed" },
|
{ kErrorEomOverflow, "EOM overflow" },
|
{ kErrorNotEnoughServerMemory, "Not enough server memory" },
|
{ kErrorPossibleDeadlock, "Possible deadlock" },
|
{ kErrorMappedAlignment, "Mapped alignment" },
|
{ kErrorSetPowerStateVetoed, "Set power state vetoed" },
|
{ kErrorSetPowerStateFailed, "Set power state failed" },
|
{ kErrorTooManyLinks, "Too many links" },
|
{ kErrorOldWinVersion, "Old win version" },
|
{ kErrorAppWrongOs, "App wrong OS" },
|
{ kErrorSingleInstanceApp, "Single instance app" },
|
{ kErrorRmodeApp, "Rmode app" },
|
{ kErrorInvalidDll, "Invalid DLL" },
|
{ kErrorNoAssociation, "No association" },
|
{ kErrorDdeFail, "DDE fail" },
|
{ kErrorDllNotFound, "DLL not found" },
|
{ kErrorNoMoreUserHandles, "No more user handles" },
|
{ kErrorMessageSyncOnly, "Message sync only" },
|
{ kErrorSourceElementEmpty, "Source element empty" },
|
{ kErrorDestinationElementFull, "Destination element full" },
|
{ kErrorIllegalElementAddress, "Illegal element address" },
|
{ kErrorMagazineNotPresent, "Magazine not present" },
|
{ kErrorDeviceReinitializationNeeded, "Device reinitialization needed" },
|
{ kErrorDeviceRequiresCleaning, "Device requires cleaning" },
|
{ kErrorDeviceDoorOpen, "Device door open" },
|
{ kErrorDeviceNotConnected, "Device not connected" },
|
{ kErrorNotFound, "Not found" },
|
{ kErrorNoMatch, "No match" },
|
{ kErrorSetNotFound, "Set not found" },
|
{ kErrorPointNotFound, "Point not found" },
|
{ kErrorNoTrackingService, "No tracking service" },
|
{ kErrorNoVolumeId, "No volume ID" },
|
{ kErrorUnableToRemoveReplaced, "Unable to remove replaced" },
|
{ kErrorUnableToMoveReplacement, "Unable to move replacement" },
|
{ kErrorUnableToMoveReplacement2, "Unable to move replacement 2" },
|
{ kErrorJournalDeleteInProgress, "Journal delete in progress" },
|
{ kErrorJournalNotActive, "Journal not active" },
|
{ kErrorPotentialFileFound, "Potential file found" },
|
{ kErrorJournalEntryDeleted, "Journal entry deleted" },
|
{ kErrorBadDevice, "Bad device" },
|
{ kErrorConnectionUnavail, "Connection unavail" },
|
{ kErrorDeviceAlreadyRemembered, "Device already remembered" },
|
{ kErrorNoNetOrBadPath, "No net or bad path" },
|
{ kErrorBadProvider, "Bad provider" },
|
{ kErrorCannotOpenProfile, "Cannot open profile" },
|
{ kErrorBadProfile, "Bad profile" },
|
{ kErrorNotContainer, "Not container" },
|
{ kErrorExtendedError, "Extended error" },
|
{ kErrorInvalidGroupname, "Invalid group name" },
|
{ kErrorInvalidComputername, "Invalid computer name" },
|
{ kErrorInvalidEventname, "Invalid event name" },
|
{ kErrorInvalidDomainname, "Invalid domain name" },
|
{ kErrorInvalidServicename, "Invalid service name" },
|
{ kErrorInvalidNetname, "Invalid net name" },
|
{ kErrorInvalidSharename, "Invalid share name" },
|
{ kErrorInvalidPasswordname, "Invalid password name" },
|
{ kErrorInvalidMessagename, "Invalid message name" },
|
{ kErrorInvalidMessagedest, "Invalid message dest" },
|
{ kErrorSessionCredentialConflict, "Session credential conflict" },
|
{ kErrorRemoteSessionLimitExceeded, "Remote session limit exceeded" },
|
{ kErrorDupDomainname, "Dup domain name" },
|
{ kErrorNoNetwork, "No network" },
|
{ kErrorCancelled, "Cancelled" },
|
{ kErrorUserMappedFile, "User mapped file" },
|
{ kErrorConnectionRefused, "Connection refused" },
|
{ kErrorGracefulDisconnect, "Graceful disconnect" },
|
{ kErrorAddressAlreadyAssociated, "Address already associated" },
|
{ kErrorAddressNotAssociated, "Address not associated" },
|
{ kErrorConnectionInvalid, "Connected invalid" },
|
{ kErrorConnectionActive, "Connection active" },
|
{ kErrorNetworkUnreachable, "Network unreachable" },
|
{ kErrorHostUnreachable, "Host unreachable" },
|
{ kErrorProtocolUnreachable, "Protocol unreachable" },
|
{ kErrorPortUnreachable, "Port unreachable" },
|
{ kErrorRequestAborted, "Request aborted" },
|
{ kErrorConnectionAborted, "Connection aborted" },
|
{ kErrorRetry, "Retry" },
|
{ kErrorConnectionCountLimit, "Connection count limit" },
|
{ kErrorLoginTimeRestriction, "Login time restriction" },
|
{ kErrorLoginWkstaRestriction, "Login wksta restriction" },
|
{ kErrorIncorrectAddress, "Incorrect address" },
|
{ kErrorAlreadyRegistered, "Already registered" },
|
{ kErrorServiceNotFound, "Service not found" },
|
{ kErrorNotAuthenticated, "Not authenticated" },
|
{ kErrorNotLoggedOn, "Not logged on" },
|
{ kErrorContinue, "Continue" },
|
{ kErrorAlreadyInitialized, "Already initialised" },
|
{ kErrorNoMoreDevices, "No more devices" },
|
{ kErrorNoSuchSite, "No such site" },
|
{ kErrorDomainControllerExists, "Domain controller exists" },
|
{ kErrorOnlyIfConnected, "Only if connected" },
|
{ kErrorOverrideNochanges, "Override no changes" },
|
{ kErrorBadUserProfile, "Bad user profile" },
|
{ kErrorNotSupportedOnSbs, "Not supported on SBS" },
|
{ kErrorServerShutdownInProgress, "Server shutdown in progress" },
|
{ kErrorHostDown, "Host down" },
|
{ kErrorNonAccountSid, "Non account sid" },
|
{ kErrorNonDomainSid, "Non domain sid" },
|
{ kErrorApphelpBlock, "Apphelp block" },
|
{ kErrorAccessDisabledByPolicy, "Access disabled by policy" },
|
{ kErrorRegNatConsumption, "Reg nat consumption" },
|
{ kErrorCscshareOffline, "CSC share offline" },
|
{ kErrorPkinitFailure, "PK init failure" },
|
{ kErrorSmartcardSubsystemFailure, "Smartcard subsystem failure" },
|
{ kErrorDowngradeDetected, "Downgrade detected" },
|
{ kSecESmartcardCertRevoked, "Smartcard cert revoked" },
|
{ kSecEIssuingCaUntrusted, "Issuing CA untrusted" },
|
{ kSecERevocationOfflineC, "Revocation offline" },
|
{ kSecEPkinitClientFailur, "PK init client failure" },
|
{ kSecESmartcardCertExpired, "Smartcard cert expired" },
|
{ kErrorMachineLocked, "Machine locked" },
|
{ kErrorCallbackSuppliedInvalidData, "Callback supplied invalid data" },
|
{ kErrorSyncForegroundRefreshRequired, "Sync foreground refresh required" },
|
{ kErrorDriverBlocked, "Driver blocked" },
|
{ kErrorInvalidImportOfNonDll, "Invalid import of non DLL" },
|
{ kErrorNotAllAssigned, "Not all assigned" },
|
{ kErrorSomeNotMapped, "Some not mapped" },
|
{ kErrorNoQuotasForAccount, "No quotas for account" },
|
{ kErrorLocalUserSessionKey, "Local user session key" },
|
{ kErrorNullLmPassword, "Null LM password" },
|
{ kErrorUnknownRevision, "Unknown revision" },
|
{ kErrorRevisionMismatch, "Revision mismatch" },
|
{ kErrorInvalidOwner, "Invalid owner" },
|
{ kErrorInvalidPrimaryGroup, "Invalid primary group" },
|
{ kErrorNoImpersonationToken, "No impersonation token" },
|
{ kErrorCantDisableMandatory, "Can't disable mandatory" },
|
{ kErrorNoLogonServers, "No logon servers" },
|
{ kErrorNoSuchLogonSession, "No such logon session" },
|
{ kErrorNoSuchPrivilege, "No such privilege" },
|
{ kErrorPrivilegeNotHeld, "Privilege not held" },
|
{ kErrorInvalidAccountName, "Invalid account name" },
|
{ kErrorUserExists, "User exists" },
|
{ kErrorNoSuchUser, "No such user" },
|
{ kErrorGroupExists, "Group exists" },
|
{ kErrorNoSuchGroup, "No such group" },
|
{ kErrorMemberInGroup, "Member in group" },
|
{ kErrorMemberNotInGroup, "Member not in group" },
|
{ kErrorLastAdmin, "Last admin" },
|
{ kErrorWrongPassword, "Wrong password" },
|
{ kErrorIllFormedPassword, "Ill formed password" },
|
{ kErrorPasswordRestriction, "Password restriction" },
|
{ kErrorLogonFailure, "Logon failure" },
|
{ kErrorAccountRestriction, "Account restriction" },
|
{ kErrorInvalidLogonHours, "Invalid logon hours" },
|
{ kErrorInvalidWorkstation, "Invalid workstation" },
|
{ kErrorPasswordExpired, "Password expired" },
|
{ kErrorAccountDisabled, "Account disabled" },
|
{ kErrorNoneMapped, "None mapped" },
|
{ kErrorTooManyLuidsRequested, "Too many LUIDs requested" },
|
{ kErrorLuidsExhausted, "LUIDs exhausted" },
|
{ kErrorInvalidSubAuthority, "Invalid sub authority" },
|
{ kErrorInvalidAcl, "Invalid ACL" },
|
{ kErrorInvalidSid, "Invalid SID" },
|
{ kErrorInvalidSecurityDescr, "Invalid security descr" },
|
{ kErrorBadInheritanceAcl, "Bad inheritance ACL" },
|
{ kErrorServerDisabled, "Server disabled" },
|
{ kErrorServerNotDisabled, "Server not disabled" },
|
{ kErrorInvalidIdAuthority, "Invalid ID authority" },
|
{ kErrorAllottedSpaceExceeded, "Allotted space exceeded" },
|
{ kErrorInvalidGroupAttributes, "Invalid group attributes" },
|
{ kErrorBadImpersonationLevel, "Bad impersonation level" },
|
{ kErrorCantOpenAnonymous, "Can't open anonymous" },
|
{ kErrorBadValidationClass, "Bad validation class" },
|
{ kErrorBadTokenType, "Bad token type" },
|
{ kErrorNoSecurityOnObject, "No security on object" },
|
{ kErrorCantAccessDomainInfo, "Can't access domain info" },
|
{ kErrorInvalidServerState, "Invalid server state" },
|
{ kErrorInvalidDomainState, "Invalid domain state" },
|
{ kErrorInvalidDomainRole, "Invalid domain role" },
|
{ kErrorNoSuchDomain, "No such domain" },
|
{ kErrorDomainExists, "Domain exists" },
|
{ kErrorDomainLimitExceeded, "Domain limit exceeded" },
|
{ kErrorInternalDbCorruption, "Internal DB corruption" },
|
{ kErrorInternalError, "Internal error" },
|
{ kErrorGenericNotMapped, "Generic not mapped" },
|
{ kErrorBadDescriptorFormat, "Bad descriptor format" },
|
{ kErrorNotLogonProcess, "Not logon process" },
|
{ kErrorLogonSessionExists, "Logon session exists" },
|
{ kErrorNoSuchPackage, "No such package" },
|
{ kErrorBadLogonSessionState, "Bad logon session state" },
|
{ kErrorLogonSessionCollision, "Logon session collision" },
|
{ kErrorInvalidLogonType, "Invalid logon type" },
|
{ kErrorCannotImpersonate, "Cannot impersonate" },
|
{ kErrorRxactInvalidState, "Rxact invalid state" },
|
{ kErrorRxactCommitFailure, "Rxact commit failure" },
|
{ kErrorSpecialAccount, "Special account" },
|
{ kErrorSpecialGroup, "Special group" },
|
{ kErrorSpecialUser, "Special user" },
|
{ kErrorMembersPrimaryGroup, "Members primary group" },
|
{ kErrorTokenAlreadyInUse, "Token already in use" },
|
{ kErrorNoSuchAlias, "No such alias" },
|
{ kErrorMemberNotInAlias, "Member not in alias" },
|
{ kErrorMemberInAlias, "Member in alias" },
|
{ kErrorAliasExists, "Alias exists" },
|
{ kErrorLogonNotGranted, "Logon not granted" },
|
{ kErrorTooManySecrets, "Too many secrets" },
|
{ kErrorSecretTooLong, "Secret too long" },
|
{ kErrorInternalDbError, "Internal DB error" },
|
{ kErrorTooManyContextIds, "Too many context IDs" },
|
{ kErrorLogonTypeNotGranted, "Logon type not granted" },
|
{ kErrorNtCrossEncryptionRequired, "NT cross encryption required" },
|
{ kErrorNoSuchMember, "No such member" },
|
{ kErrorInvalidMember, "Invalid member" },
|
{ kErrorTooManySids, "Too many SIDs" },
|
{ kErrorLmCrossEncryptionRequired, "LM cross encryption required" },
|
{ kErrorNoInheritance, "No inheritance" },
|
{ kErrorFileCorrupt, "File corrupt" },
|
{ kErrorDiskCorrupt, "Disk corrupt" },
|
{ kErrorNoUserSessionKey, "No user session key" },
|
{ kErrorLicenseQuotaExceeded, "Licence quota exceeded" },
|
{ kErrorWrongTargetName, "Wrong target name" },
|
{ kErrorMutualAuthFailed, "Mutual auth failed" },
|
{ kErrorTimeSkew, "Time skew" },
|
{ kErrorCurrentDomainNotAllowed, "Current domain not allowed" },
|
{ kErrorInvalidWindowHandle, "Invalid window handle" },
|
{ kErrorInvalidMenuHandle, "Invalid menu handle" },
|
{ kErrorInvalidCursorHandle, "Invalid cursor handle" },
|
{ kErrorInvalidAccelHandle, "Invalid accel handle" },
|
{ kErrorInvalidHookHandle, "Invalid hook handle" },
|
{ kErrorInvalidDwpHandle, "Invalid DWP handle" },
|
{ kErrorTlwWithWschild, "TLW with wschild" },
|
{ kErrorCannotFindWndClass, "Cannot find WND class" },
|
{ kErrorWindowOfOtherThread, "Window of other thread" },
|
{ kErrorHotkeyAlreadyRegistered, "Hotkey already registered" },
|
{ kErrorClassAlreadyExists, "Class already exists" },
|
{ kErrorClassDoesNotExist, "Class does not exist" },
|
{ kErrorClassHasWindows, "Class has windows" },
|
{ kErrorInvalidIndex, "Invalid index" },
|
{ kErrorInvalidIconHandle, "Invalid icon handle" },
|
{ kErrorPrivateDialogIndex, "Private dialog index" },
|
{ kErrorListboxIdNotFound, "Listbox ID not found" },
|
{ kErrorNoWildcardCharacters, "No wildcard characters" },
|
{ kErrorClipboardNotOpen, "Clipboard not open" },
|
{ kErrorHotkeyNotRegistered, "Hotkey not registered" },
|
{ kErrorWindowNotDialog, "Window not dialog" },
|
{ kErrorControlIdNotFound, "Control ID not found" },
|
{ kErrorInvalidComboboxMessage, "Invalid combobox message" },
|
{ kErrorWindowNotCombobox, "Window not combobox" },
|
{ kErrorInvalidEditHeight, "Invalid edit height" },
|
{ kErrorDcNotFound, "DC not found" },
|
{ kErrorInvalidHookFilter, "Invalid hook filter" },
|
{ kErrorInvalidFilterProc, "Invalid filter proc" },
|
{ kErrorHookNeedsHmod, "Hook needs HMOD" },
|
{ kErrorGlobalOnlyHook, "Global only hook" },
|
{ kErrorJournalHookSet, "Journal hook set" },
|
{ kErrorHookNotInstalled, "Hook not installed" },
|
{ kErrorInvalidLbMessage, "Invalid LB message" },
|
{ kErrorSetcountOnBadLb, "Setcount on bad LB" },
|
{ kErrorLbWithoutTabstops, "LB without tabstops" },
|
{ kErrorDestroyObjectOfOtherThread, "Destroy object of other thread" },
|
{ kErrorChildWindowMenu, "Child window menu" },
|
{ kErrorNoSystemMenu, "No system menu" },
|
{ kErrorInvalidMsgboxStyle, "Invalid msgbox style" },
|
{ kErrorInvalidSpiValue, "Invalid SPI value" },
|
{ kErrorScreenAlreadyLocked, "Screen already locked" },
|
{ kErrorHwndsHaveDiffParent, "HWNDs have different parent" },
|
{ kErrorNotChildWindow, "Not child window" },
|
{ kErrorInvalidGwCommand, "Invalid GW command" },
|
{ kErrorInvalidThreadId, "Invalid thread ID" },
|
{ kErrorNonMdichildWindow, "Non MDI child window" },
|
{ kErrorPopupAlreadyActive, "Popup already active" },
|
{ kErrorNoScrollbars, "No scrollbars" },
|
{ kErrorInvalidScrollbarRange, "Invalid scrollbar range" },
|
{ kErrorInvalidShowwinCommand, "Invalid showwin command" },
|
{ kErrorNoSystemResources, "No system resources" },
|
{ kErrorNonpagedSystemResources, "Nonpaged system resources" },
|
{ kErrorPagedSystemResources, "Paged system resources" },
|
{ kErrorWorkingSetQuota, "Working set quota" },
|
{ kErrorPagefileQuota, "Pagefile quota" },
|
{ kErrorCommitmentLimit, "Commitment limit" },
|
{ kErrorMenuItemNotFound, "Menu item not found" },
|
{ kErrorInvalidKeyboardHandle, "Invalid keyboard handle" },
|
{ kErrorHookTypeNotAllowed, "Hook type not allowed" },
|
{ kErrorRequiresInteractiveWindowstation, "Requires interactive windowstation" },
|
{ kErrorTimeout, "Timeout" },
|
{ kErrorInvalidMonitorHandle, "Invalid monitor handle" },
|
{ kErrorEventlogFileCorrupt, "Eventlog file corrupt" },
|
{ kErrorEventlogCantStart, "Eventlog can't start" },
|
{ kErrorLogFileFull, "Log file full" },
|
{ kErrorEventlogFileChanged, "Eventlog file changed" },
|
{ kErrorInstallServiceFailure, "Install service failure" },
|
{ kErrorInstallUserexit, "Install userexit" },
|
{ kErrorInstallFailure, "Install failure" },
|
{ kErrorInstallSuspend, "Install suspend" },
|
{ kErrorUnknownProduct, "Unknown product" },
|
{ kErrorUnknownFeature, "Unknown feature" },
|
{ kErrorUnknownComponent, "Unknown component" },
|
{ kErrorUnknownProperty, "Unknown property" },
|
{ kErrorInvalidHandleState, "Invalid handle state" },
|
{ kErrorBadConfiguration, "Bad configuration" },
|
{ kErrorIndexAbsent, "Index absent" },
|
{ kErrorInstallSourceAbsent, "Install source absent" },
|
{ kErrorInstallPackageVersion, "Install package version" },
|
{ kErrorProductUninstalled, "Product uninstalled" },
|
{ kErrorBadQuerySyntax, "Bad query syntax" },
|
{ kErrorInvalidField, "Invalid field" },
|
{ kErrorDeviceRemoved, "Device removed" },
|
{ kErrorInstallAlreadyRunning, "Install already running" },
|
{ kErrorInstallPackageOpenFailed, "Install package open failed" },
|
{ kErrorInstallPackageInvalid, "Install package invalid" },
|
{ kErrorInstallUiFailure, "Install UI failure" },
|
{ kErrorInstallLogFailure, "Install log failure" },
|
{ kErrorInstallLanguageUnsupported, "Install language unsupported" },
|
{ kErrorInstallTransformFailure, "Install transform failure" },
|
{ kErrorInstallPackageRejected, "Install package rejected" },
|
{ kErrorFunctionNotCalled, "Function not called" },
|
{ kErrorFunctionFailed, "Function failed" },
|
{ kErrorInvalidTable, "Invalid table" },
|
{ kErrorDatatypeMismatch, "Datatype mismatch" },
|
{ kErrorUnsupportedType, "Unsupported type" },
|
{ kErrorCreateFailed, "Create failed" },
|
{ kErrorInstallTempUnwritable, "Install temp unwritable" },
|
{ kErrorInstallPlatformUnsupported, "Install platform unsupported" },
|
{ kErrorInstallNotused, "Install notused" },
|
{ kErrorPatchPackageOpenFailed, "Patch package open failed" },
|
{ kErrorPatchPackageInvalid, "Patch package invalid" },
|
{ kErrorPatchPackageUnsupported, "Patch package unsupported" },
|
{ kErrorProductVersion, "Product version" },
|
{ kErrorInvalidCommandLine, "Invalid command line" },
|
{ kErrorInstallRemoteDisallowed, "Install remote disallowed" },
|
{ kErrorSuccessRebootInitiated, "Success reboot initiated" },
|
{ kErrorPatchTargetNotFound, "Patch target not found" },
|
{ kErrorPatchPackageRejected, "Patch package rejected" },
|
{ kErrorInstallTransformRejected, "Install transform rejected" },
|
{ kRpcSInvalidStringBinding, "RPC S Invalid string binding" },
|
{ kRpcSWrongKindOfBinding, "RPC S Wrong kind of binding" },
|
{ kRpcSInvalidBinding, "RPC S Invalid binding" },
|
{ kRpcSProtseqNotSupported, "RPC S Protseq not supported" },
|
{ kRpcSInvalidRpcProtseq, "RPC S Invalid RPC protseq" },
|
{ kRpcSInvalidStringUuid, "RPC S Invalid string UUID" },
|
{ kRpcSInvalidEndpointFormat, "RPC S Invalid endpoint format" },
|
{ kRpcSInvalidNetAddr, "RPC S Invalid net addr" },
|
{ kRpcSNoEndpointFound, "RPC S No endpoint found" },
|
{ kRpcSInvalidTimeout, "RPC S Invalid timeout" },
|
{ kRpcSObjectNotFound, "RPC S Object not found" },
|
{ kRpcSAlreadyRegistered, "RPC S Already registered" },
|
{ kRpcSTypeAlreadyRegistered, "RPC S Type already registered" },
|
{ kRpcSAlreadyListening, "RPC S Already listening" },
|
{ kRpcSNoProtseqsRegistered, "RPC S Not protseqs registered" },
|
{ kRpcSNotListening, "RPC S Not listening" },
|
{ kRpcSUnknownMgrType, "RPC S Unknown mgr type" },
|
{ kRpcSUnknownIf, "RPC S Unknown IF" },
|
{ kRpcSNoBindings, "RPC S No bindings" },
|
{ kRpcSNoProtseqs, "RPC S Not protseqs" },
|
{ kRpcSCantCreateEndpoint, "RPC S Can't create endpoint" },
|
{ kRpcSOutOfResources, "RPC S Out of resources" },
|
{ kRpcSServerUnavailable, "RPC S Server unavailable" },
|
{ kRpcSServerTooBusy, "RPC S Server too busy" },
|
{ kRpcSInvalidNetworkOptions, "RPC S Invalid network options" },
|
{ kRpcSNoCallActive, "RPC S No call active" },
|
{ kRpcSCallFailed, "RPC S Call failed" },
|
{ kRpcSCallFailedDne, "RPC S Call failed DNE" },
|
{ kRpcSProtocolError, "RPC S Protocol error" },
|
{ kRpcSUnsupportedTransSyn, "RPC S Unsupported trans syn" },
|
{ kRpcSUnsupportedType, "RPC S Unsupported type" },
|
{ kRpcSInvalidTag, "RPC S Invalid tag" },
|
{ kRpcSInvalidBound, "RPC S Invalid bound" },
|
{ kRpcSNoEntryName, "RPC S No entry name" },
|
{ kRpcSInvalidNameSyntax, "RPC S Invalid name syntax" },
|
{ kRpcSUnsupportedNameSyntax, "RPC S Unsupported name syntax" },
|
{ kRpcSUuidNoAddress, "RPC S UUID no address" },
|
{ kRpcSDuplicateEndpoint, "RPC S Duplicate endpoint" },
|
{ kRpcSUnknownAuthnType, "RPC S Unknown authn type" },
|
{ kRpcSMaxCallsTooSmall, "RPC S Max calls too small" },
|
{ kRpcSStringTooLong, "RPC S String too long" },
|
{ kRpcSProtseqNotFound, "RPC S Protseq not found" },
|
{ kRpcSProcnumOutOfRange, "RPC S Procnum out of range" },
|
{ kRpcSBindingHasNoAuth, "RPC S Binding has no auth" },
|
{ kRpcSUnknownAuthnService, "RPC S Unknown authn service" },
|
{ kRpcSUnknownAuthnLevel, "RPC S Unknown authn level" },
|
{ kRpcSInvalidAuthIdentity, "RPC S Invalid auth identity" },
|
{ kRpcSUnknownAuthzService, "RPC S Unknown authz service" },
|
{ kEptSInvalidEntry, "EPT S Invalid entry" },
|
{ kEptSCantPerformOp, "EPT S Can't perform op" },
|
{ kEptSNotRegistered, "EPT S Not registered" },
|
{ kRpcSNothingToExport, "RPC S Nothing to export" },
|
{ kRpcSIncompleteName, "RPC S Incomplete name" },
|
{ kRpcSInvalidVersOption, "RPC S Invalid vers option" },
|
{ kRpcSNoMoreMembers, "RPC S No more members" },
|
{ kRpcSNotAllObjsUnexported, "RPC S Not all objs unexported" },
|
{ kRpcSInterfaceNotFound, "RPC S Interface not found" },
|
{ kRpcSEntryAlreadyExists, "RPC S Entry already exists" },
|
{ kRpcSEntryNotFound, "RPC S Entry not found" },
|
{ kRpcSNameServiceUnavailable, "RPC S Name service unavailable" },
|
{ kRpcSInvalidNafId, "RPC S Invalid naf ID" },
|
{ kRpcSCannotSupport, "RPC S Cannot support" },
|
{ kRpcSNoContextAvailable, "RPC S No context available" },
|
{ kRpcSInternalError, "RPC S Internal error" },
|
{ kRpcSZeroDivide, "RPC S Zero divide" },
|
{ kRpcSAddressError, "RPC S Address error" },
|
{ kRpcSFpDivZero, "RPC S FP div zero" },
|
{ kRpcSFpUnderflow, "RPC S FP Underflow" },
|
{ kRpcSFpOverflow, "RPC S Overflow" },
|
{ kRpcXNoMoreEntries, "RPC X No more entries" },
|
{ kRpcXSsCharTransOpenFail, "RPC X SS char trans open fail" },
|
{ kRpcXSsCharTransShortFile, "RPC X SS char trans short file" },
|
{ kRpcXSsInNullContext, "RPC S SS in null context" },
|
{ kRpcXSsContextDamaged, "RPC X SS context damaged" },
|
{ kRpcXSsHandlesMismatch, "RPC X SS handles mismatch" },
|
{ kRpcXSsCannotGetCallHandle, "RPC X SS cannot get call handle" },
|
{ kRpcXNullRefPointer, "RPC X Null ref pointer" },
|
{ kRpcXEnumValueOutOfRange, "RPC X enum value out of range" },
|
{ kRpcXByteCountTooSmall, "RPC X byte count too small" },
|
{ kRpcXBadStubData, "RPC X bad stub data" },
|
{ kErrorInvalidUserBuffer, "Invalid user buffer" },
|
{ kErrorUnrecognizedMedia, "Unrecognised media" },
|
{ kErrorNoTrustLsaSecret, "No trust lsa secret" },
|
{ kErrorNoTrustSamAccount, "No trust sam account" },
|
{ kErrorTrustedDomainFailure, "Trusted domain failure" },
|
{ kErrorTrustedRelationshipFailure, "Trusted relationship failure" },
|
{ kErrorTrustFailure, "Trust failure" },
|
{ kRpcSCallInProgress, "RPC S call in progress" },
|
{ kErrorNetlogonNotStarted, "Error netlogon not started" },
|
{ kErrorAccountExpired, "Account expired" },
|
{ kErrorRedirectorHasOpenHandles, "Redirector has open handles" },
|
{ kErrorPrinterDriverAlreadyInstalled, "Printer driver already installed" },
|
{ kErrorUnknownPort, "Unknown port" },
|
{ kErrorUnknownPrinterDriver, "Unknown printer driver" },
|
{ kErrorUnknownPrintprocessor, "Unknown printprocessor" },
|
{ kErrorInvalidSeparatorFile, "Invalid separator file" },
|
{ kErrorInvalidPriority, "Invalid priority" },
|
{ kErrorInvalidPrinterName, "Invalid printer name" },
|
{ kErrorPrinterAlreadyExists, "Printer already exists" },
|
{ kErrorInvalidPrinterCommand, "Invalid printer command" },
|
{ kErrorInvalidDatatype, "Invalid datatype" },
|
{ kErrorInvalidEnvironment, "Invalid environment" },
|
{ kRpcSNoMoreBindings, "RPC S no more bindings" },
|
{ kErrorNologonInterdomainTrustAccount, "Nologon interdomain trust account" },
|
{ kErrorNologonWorkstationTrustAccount, "Nologon workstation trust account" },
|
{ kErrorNologonServerTrustAccount, "Nologon server trust account" },
|
{ kErrorDomainTrustInconsistent, "Domain trust inconsistent" },
|
{ kErrorServerHasOpenHandles, "Server has open handles" },
|
{ kErrorResourceDataNotFound, "Resource data not found" },
|
{ kErrorResourceTypeNotFound, "Resource type not found" },
|
{ kErrorResourceNameNotFound, "Resource name not found" },
|
{ kErrorResourceLangNotFound, "Resource lang not found" },
|
{ kErrorNotEnoughQuota, "Not enough quota" },
|
{ kRpcSNoInterfaces, "RPC S no interfaces" },
|
{ kRpcSCallCancelled, "RPC S Call cancelled" },
|
{ kRpcSBindingIncomplete, "RPC S Binding incomplete" },
|
{ kRpcSCommFailure, "RPC S Comm failure" },
|
{ kRpcSUnsupportedAuthnLevel, "RPC S Unsupported authn level" },
|
{ kRpcSNoPrincName, "RPC S No princ name" },
|
{ kRpcSNotRpcError, "RPC S Not RPC error" },
|
{ kRpcSUuidLocalOnly, "RPC U UUID local only" },
|
{ kRpcSSecPkgError, "RPC S Sec pkg error" },
|
{ kRpcSNotCancelled, "RPC S Not cancelled" },
|
{ kRpcXInvalidEsAction, "RPC X Invalid ES action" },
|
{ kRpcXWrongEsVersion, "RPC X Wrong ES version" },
|
{ kRpcXWrongStubVersion, "RPC X Wrong stub version" },
|
{ kRpcXInvalidPipeObject, "RPC X Invalid pipe object" },
|
{ kRpcXWrongPipeOrder, "RPC X Wrong pipe order" },
|
{ kRpcXWrongPipeVersion, "RPC X Wrong pipe version" },
|
{ kRpcSGroupMemberNotFound, "RPC S group member not found" },
|
{ kEptSCantCreate, "EPT S Can't create" },
|
{ kRpcSInvalidObject, "RPC S Invalid object" },
|
{ kErrorInvalidTime, "Invalid time" },
|
{ kErrorInvalidFormName, "Invalid form name" },
|
{ kErrorInvalidFormSize, "Invalid form size" },
|
{ kErrorAlreadyWaiting, "Already waiting" },
|
{ kErrorPrinterDeleted, "Printer deleted" },
|
{ kErrorInvalidPrinterState, "Invalid printer state" },
|
{ kErrorPasswordMustChange, "Password must change" },
|
{ kErrorDomainControllerNotFound, "Domain controller not found" },
|
{ kErrorAccountLockedOut, "Account locked out" },
|
{ kOrInvalidOxid, "OR Invalid OXID" },
|
{ kOrInvalidOid, "OR Invalid OID" },
|
{ kOrInvalidSet, "OR Invalid set" },
|
{ kRpcSSendIncomplete, "RPC S Send incomplete" },
|
{ kRpcSInvalidAsyncHandle, "RPC S Invalid async handle" },
|
{ kRpcSInvalidAsyncCall, "RPC S Invalid async call" },
|
{ kRpcXPipeClosed, "RPC X Pipe closed" },
|
{ kRpcXPipeDisciplineError, "RPC X Pipe discipline error" },
|
{ kRpcXPipeEmpty, "RPC X Pipe empty" },
|
{ kErrorNoSitename, "No sitename" },
|
{ kErrorCantAccessFile, "Can't access file" },
|
{ kErrorCantResolveFilename, "Can't resolve filename" },
|
{ kRpcSEntryTypeMismatch, "RPC S Entry type mismatch" },
|
{ kRpcSNotAllObjsExported, "RPC S Not all objs exported" },
|
{ kRpcSInterfaceNotExported, "RPC S Interface not exported" },
|
{ kRpcSProfileNotAdded, "RPC S Profile not added" },
|
{ kRpcSPrfEltNotAdded, "RPC S PRF ELT not added" },
|
{ kRpcSPrfEltNotRemoved, "RPC S PRF ELT not removed" },
|
{ kRpcSGrpEltNotAdded, "RPC S GRP ELT not added" },
|
{ kRpcSGrpEltNotRemoved, "RPC S GRP ELT not removed" },
|
{ kErrorKmDriverBlocked, "KM driver blocked" },
|
{ kErrorContextExpired, "Context expired" },
|
{ kErrorInvalidPixelFormat, "Invalid pixel format" },
|
{ kErrorBadDriver, "Bad driver" },
|
{ kErrorInvalidWindowStyle, "Invalid window style" },
|
{ kErrorMetafileNotSupported, "Metafile not supported" },
|
{ kErrorTransformNotSupported, "Transform not supported" },
|
{ kErrorClippingNotSupported, "Clipping not supported" },
|
{ kErrorInvalidCmm, "Invalid CMM" },
|
{ kErrorInvalidProfile, "Invalid profile" },
|
{ kErrorTagNotFound, "Tag not found" },
|
{ kErrorTagNotPresent, "Tag not present" },
|
{ kErrorDuplicateTag, "Duplicate tag" },
|
{ kErrorProfileNotAssociatedWithDevice, "Profile not associated with device" },
|
{ kErrorProfileNotFound, "Profile not found" },
|
{ kErrorInvalidColorspace, "Invalid colorspace" },
|
{ kErrorIcmNotEnabled, "ICM not enabled" },
|
{ kErrorDeletingIcmXform, "Deleting ICM xform" },
|
{ kErrorInvalidTransform, "Invalid transform" },
|
{ kErrorColorspaceMismatch, "Colorspace mismatch" },
|
{ kErrorInvalidColorindex, "Invalid colorindex" },
|
{ kErrorConnectedOtherPassword, "Connected other password" },
|
{ kErrorConnectedOtherPasswordDefault, "Connected other password default" },
|
{ kErrorBadUsername, "Bad username" },
|
{ kErrorNotConnected, "Not connected" },
|
{ kErrorOpenFiles, "Open files" },
|
{ kErrorActiveConnections, "Active connections" },
|
{ kErrorDeviceInUse, "Device in use" },
|
{ kErrorUnknownPrintMonitor, "Unknown print monitor" },
|
{ kErrorPrinterDriverInUse, "Printer driver in use" },
|
{ kErrorSpoolFileNotFound, "Spool file not found" },
|
{ kErrorSplNoStartdoc, "SPL no startdoc" },
|
{ kErrorSplNoAddjob, "SPL no addjob" },
|
{ kErrorPrintProcessorAlreadyInstalled, "Print processor already installed" },
|
{ kErrorPrintMonitorAlreadyInstalled, "Print monitor already installed" },
|
{ kErrorInvalidPrintMonitor, "Invalid print monitor" },
|
{ kErrorPrintMonitorInUse, "Print monitor in use" },
|
{ kErrorPrinterHasJobsQueued, "Printer has jobs queued" },
|
{ kErrorSuccessRebootRequired, "Success reboot required" },
|
{ kErrorSuccessRestartRequired, "Success restart required" },
|
{ kErrorPrinterNotFound, "Printer not found" },
|
{ kErrorPrinterDriverWarned, "Printer driver warned" },
|
{ kErrorPrinterDriverBlocked, "Printer driver blocked" },
|
{ kErrorWinsInternal, "Wins internal" },
|
{ kErrorCanNotDelLocalWins, "Can not del local wins" },
|
{ kErrorStaticInit, "Static init" },
|
{ kErrorIncBackup, "Inc backup" },
|
{ kErrorFullBackup, "Full backup" },
|
{ kErrorRecNonExistent, "Rec not existent" },
|
{ kErrorRplNotAllowed, "RPL not allowed" },
|
{ kErrorDhcpAddressConflict, "DHCP address conflict" },
|
{ kErrorWmiGuidNotFound, "WMU GUID not found" },
|
{ kErrorWmiInstanceNotFound, "WMI instance not found" },
|
{ kErrorWmiItemidNotFound, "WMI ItemID not found" },
|
{ kErrorWmiTryAgain, "WMI try again" },
|
{ kErrorWmiDpNotFound, "WMI DP not found" },
|
{ kErrorWmiUnresolvedInstanceRef, "WMI unresolved instance ref" },
|
{ kErrorWmiAlreadyEnabled, "WMU already enabled" },
|
{ kErrorWmiGuidDisconnected, "WMU GUID disconnected" },
|
{ kErrorWmiServerUnavailable, "WMI server unavailable" },
|
{ kErrorWmiDpFailed, "WMI DP failed" },
|
{ kErrorWmiInvalidMof, "WMI invalid MOF" },
|
{ kErrorWmiInvalidReginfo, "WMI invalid reginfo" },
|
{ kErrorWmiAlreadyDisabled, "WMI already disabled" },
|
{ kErrorWmiReadOnly, "WMI read only" },
|
{ kErrorWmiSetFailure, "WMI set failure" },
|
{ kErrorInvalidMedia, "Invalid media" },
|
{ kErrorInvalidLibrary, "Invalid library" },
|
{ kErrorInvalidMediaPool, "Invalid media pool" },
|
{ kErrorDriveMediaMismatch, "Drive media mismatch" },
|
{ kErrorMediaOffline, "Media offline" },
|
{ kErrorLibraryOffline, "Library offline" },
|
{ kErrorEmpty, "Empty" },
|
{ kErrorNotEmpty, "Not empty" },
|
{ kErrorMediaUnavailable, "Media unavailable" },
|
{ kErrorResourceDisabled, "Resource disabled" },
|
{ kErrorInvalidCleaner, "Invalid cleaner" },
|
{ kErrorUnableToClean, "Unable to clean" },
|
{ kErrorObjectNotFound, "Object not found" },
|
{ kErrorDatabaseFailure, "Database failure" },
|
{ kErrorDatabaseFull, "Database full" },
|
{ kErrorMediaIncompatible, "Media incompatible" },
|
{ kErrorResourceNotPresent, "Resource not present" },
|
{ kErrorInvalidOperation, "Invalid operation" },
|
{ kErrorMediaNotAvailable, "Media not available" },
|
{ kErrorDeviceNotAvailable, "Device not available" },
|
{ kErrorRequestRefused, "Request refused" },
|
{ kErrorInvalidDriveObject, "Invalid drive object" },
|
{ kErrorLibraryFull, "Library full" },
|
{ kErrorMediumNotAccessible, "Medium not accessible" },
|
{ kErrorUnableToLoadMedium, "Unable to load medium" },
|
{ kErrorUnableToInventoryDrive, "Unable to inventory drive" },
|
{ kErrorUnableToInventorySlot, "Unable to inventory slot" },
|
{ kErrorUnableToInventoryTransport, "Unable to inventory transport" },
|
{ kErrorTransportFull, "Transport full" },
|
{ kErrorControllingIeport, "Controlling ieport" },
|
{ kErrorUnableToEjectMountedMedia, "Unable to eject mounted media" },
|
{ kErrorCleanerSlotSet, "Cleaner slot set" },
|
{ kErrorCleanerSlotNotSet, "Cleaner slot not set" },
|
{ kErrorCleanerCartridgeSpent, "Cleaner cartridge spent" },
|
{ kErrorUnexpectedOmid, "Unexpected omid" },
|
{ kErrorCantDeleteLastItem, "Can't delete last item" },
|
{ kErrorMessageExceedsMaxSize, "Message exceeds max size" },
|
{ kErrorVolumeContainsSysFiles, "Volume contains sys files" },
|
{ kErrorIndigenousType, "Indigenous type" },
|
{ kErrorNoSupportingDrives, "No supporting drives" },
|
{ kErrorCleanerCartridgeInstalled, "Cleaner cartridge installed" },
|
{ kErrorFileOffline, "Fill offline" },
|
{ kErrorRemoteStorageNotActive, "Remote storage not active" },
|
{ kErrorRemoteStorageMediaError, "Remote storage media error" },
|
{ kErrorNotAReparsePoint, "Not a reparse point" },
|
{ kErrorReparseAttributeConflict, "Reparse attribute conflict" },
|
{ kErrorInvalidReparseData, "Invalid reparse data" },
|
{ kErrorReparseTagInvalid, "Reparse tag invalid" },
|
{ kErrorReparseTagMismatch, "Reparse tag mismatch" },
|
{ kErrorVolumeNotSisEnabled, "Volume not sis enabled" },
|
{ kErrorDependentResourceExists, "Dependent resource exists" },
|
{ kErrorDependencyNotFound, "Dependency not found" },
|
{ kErrorDependencyAlreadyExists, "Dependency already exists" },
|
{ kErrorResourceNotOnline, "Resource not online" },
|
{ kErrorHostNodeNotAvailable, "Host node not available" },
|
{ kErrorResourceNotAvailable, "Resource not available" },
|
{ kErrorResourceNotFound, "Resource not found" },
|
{ kErrorShutdownCluster, "Shutdown cluster" },
|
{ kErrorCantEvictActiveNode, "Can't evict active node" },
|
{ kErrorObjectAlreadyExists, "Object already exists" },
|
{ kErrorObjectInList, "Object in list" },
|
{ kErrorGroupNotAvailable, "Group not available" },
|
{ kErrorGroupNotFound, "Group not found" },
|
{ kErrorGroupNotOnline, "Group not online" },
|
{ kErrorHostNodeNotResourceOwner, "Host node not resource owner" },
|
{ kErrorHostNodeNotGroupOwner, "Host node not group owner" },
|
{ kErrorResmonCreateFailed, "Resmon create failed" },
|
{ kErrorResmonOnlineFailed, "Resmon online failed" },
|
{ kErrorResourceOnline, "Resource online" },
|
{ kErrorQuorumResource, "Quorum resource" },
|
{ kErrorNotQuorumCapable, "Not quorum capable" },
|
{ kErrorClusterShuttingDown, "Cluster shutting down" },
|
{ kErrorInvalidState, "Invalid state" },
|
{ kErrorResourcePropertiesStored, "Resource properties stored" },
|
{ kErrorNotQuorumClass, "Not quorum class" },
|
{ kErrorCoreResource, "Core resource" },
|
{ kErrorQuorumResourceOnlineFailed, "Quorum resource online failed" },
|
{ kErrorQuorumlogOpenFailed, "Quorumlog open failed" },
|
{ kErrorClusterlogCorrupt, "Clusterlog corrupt" },
|
{ kErrorClusterlogRecordExceedsMaxsize, "Clusterlog record exceeds maxsize" },
|
{ kErrorClusterlogExceedsMaxsize, "Clusterlog exceeds maxsize" },
|
{ kErrorClusterlogChkpointNotFound, "Clusterlog chkpoint not found" },
|
{ kErrorClusterlogNotEnoughSpace, "Clusterlog not enough space" },
|
{ kErrorQuorumOwnerAlive, "Quorum owner alive" },
|
{ kErrorNetworkNotAvailable, "Network not available" },
|
{ kErrorNodeNotAvailable, "Node not available" },
|
{ kErrorAllNodesNotAvailable, "All nodes not available" },
|
{ kErrorResourceFailed, "Resource failed" },
|
{ kErrorClusterInvalidNode, "Cluster invalid node" },
|
{ kErrorClusterNodeExists, "Cluster node exists" },
|
{ kErrorClusterJoinInProgress, "Cluster join in progress" },
|
{ kErrorClusterNodeNotFound, "Cluster node not found" },
|
{ kErrorClusterLocalNodeNotFound, "Cluster local node not found" },
|
{ kErrorClusterNetworkExists, "Cluster network exists" },
|
{ kErrorClusterNetworkNotFound, "Cluster network not found" },
|
{ kErrorClusterNetinterfaceExists, "Cluster netinterface exists" },
|
{ kErrorClusterNetinterfaceNotFound, "Cluster netinterface not found" },
|
{ kErrorClusterInvalidRequest, "Cluster invalid request" },
|
{ kErrorClusterInvalidNetworkProvider, "Cluster invalid network provider" },
|
{ kErrorClusterNodeDown, "Cluster node down" },
|
{ kErrorClusterNodeUnreachable, "Cluster node unreachable" },
|
{ kErrorClusterNodeNotMember, "Cluster node not member" },
|
{ kErrorClusterJoinNotInProgress, "Cluster join not in progress" },
|
{ kErrorClusterInvalidNetwork, "Cluster invalid network" },
|
{ kErrorClusterNodeUp, "Cluster node up" },
|
{ kErrorClusterIpaddrInUse, "Cluster ipaddr in use" },
|
{ kErrorClusterNodeNotPaused, "Cluster node not paused" },
|
{ kErrorClusterNoSecurityContext, "Cluster no security context" },
|
{ kErrorClusterNetworkNotInternal, "Cluster network not internal" },
|
{ kErrorClusterNodeAlreadyUp, "Cluster node already up" },
|
{ kErrorClusterNodeAlreadyDown, "Cluster node already down" },
|
{ kErrorClusterNetworkAlreadyOnline, "Cluster network already online" },
|
{ kErrorClusterNetworkAlreadyOffline, "Cluster network already offline" },
|
{ kErrorClusterNodeAlreadyMember, "Cluster node already member" },
|
{ kErrorClusterLastInternalNetwork, "Cluster last internal network" },
|
{ kErrorClusterNetworkHasDependents, "Cluster network has dependents" },
|
{ kErrorInvalidOperationOnQuorum, "Invalid operation on quorum" },
|
{ kErrorDependencyNotAllowed, "Dependency not allowed" },
|
{ kErrorClusterNodePaused, "Cluster node paused" },
|
{ kErrorNodeCantHostResource, "Node can't host resource" },
|
{ kErrorClusterNodeNotReady, "Cluster node not ready" },
|
{ kErrorClusterNodeShuttingDown, "Cluster node shutting down" },
|
{ kErrorClusterJoinAborted, "Cluster join aborted" },
|
{ kErrorClusterIncompatibleVersions, "Cluster incompatible versions" },
|
{ kErrorClusterMaxnumOfResourcesExceeded, "Cluster maxnum of resources exceeded" },
|
{ kErrorClusterSystemConfigChanged, "Cluster system config changed" },
|
{ kErrorClusterResourceTypeNotFound, "Cluster resource type not found" },
|
{ kErrorClusterRestypeNotSupported, "Cluster restype not supported" },
|
{ kErrorClusterResnameNotFound, "Cluster resname not found" },
|
{ kErrorClusterNoRpcPackagesRegistered, "Cluster no RPC packages registered" },
|
{ kErrorClusterOwnerNotInPreflist, "Cluster owner not in preflist" },
|
{ kErrorClusterDatabaseSeqmismatch, "Cluster database seqmismatch" },
|
{ kErrorResmonInvalidState, "Resmon invalid state" },
|
{ kErrorClusterGumNotLocker, "Cluster gum not locker" },
|
{ kErrorQuorumDiskNotFound, "Quorum disk not found" },
|
{ kErrorDatabaseBackupCorrupt, "Database backup corrupt" },
|
{ kErrorClusterNodeAlreadyHasDfsRoot, "Cluster node already has DFS root" },
|
{ kErrorResourcePropertyUnchangeable, "Resource property unchangeable" },
|
{ kErrorClusterMembershipInvalidState, "Cluster membership invalid state" },
|
{ kErrorClusterQuorumlogNotFound, "Cluster quorumlog not found" },
|
{ kErrorClusterMembershipHalt, "Cluster membership halt" },
|
{ kErrorClusterInstanceIdMismatch, "Cluster instance ID mismatch" },
|
{ kErrorClusterNetworkNotFoundForIp, "Cluster network not found for IP" },
|
{ kErrorClusterPropertyDataTypeMismatch, "Cluster property data type mismatch" },
|
{ kErrorClusterEvictWithoutCleanup, "Cluster evict without cleanup" },
|
{ kErrorClusterParameterMismatch, "Cluster parameter mismatch" },
|
{ kErrorNodeCannotBeClustered, "Node cannot be clustered" },
|
{ kErrorClusterWrongOsVersion, "Cluster wrong OS version" },
|
{ kErrorClusterCantCreateDupClusterName, "Cluster can't create dup cluster name" },
|
{ kErrorDecryptionFailed, "Decryption failed" },
|
{ kErrorFileEncrypted, "File encrypted" },
|
{ kErrorNoRecoveryPolicy, "No recovery policy" },
|
{ kErrorNoEfs, "No EFS" },
|
{ kErrorWrongEfs, "Wrong EFS" },
|
{ kErrorNoUserKeys, "No user keys" },
|
{ kErrorFileNotEncrypted, "File not encryped" },
|
{ kErrorNotExportFormat, "Not export format" },
|
{ kErrorFileReadOnly, "File read only" },
|
{ kErrorDirEfsDisallowed, "Dir EFS disallowed" },
|
{ kErrorEfsServerNotTrusted, "EFS server not trusted" },
|
{ kErrorBadRecoveryPolicy, "Bad recovery policy" },
|
{ kErrorEfsAlgBlobTooBig, "ETS alg blob too big" },
|
{ kErrorVolumeNotSupportEfs, "Volume not support EFS" },
|
{ kErrorEfsDisabled, "EFS disabled" },
|
{ kErrorEfsVersionNotSupport, "EFS version not support" },
|
{ kErrorNoBrowserServersFound, "No browser servers found" },
|
{ kSchedEServiceNotLocalsystem, "Sched E service not localsystem" },
|
{ kErrorCtxWinstationNameInvalid, "Ctx winstation name invalid" },
|
{ kErrorCtxInvalidPd, "Ctx invalid PD" },
|
{ kErrorCtxPdNotFound, "Ctx PD not found" },
|
{ kErrorCtxWdNotFound, "Ctx WD not found" },
|
{ kErrorCtxCannotMakeEventlogEntry, "Ctx cannot make eventlog entry" },
|
{ kErrorCtxServiceNameCollision, "Ctx service name collision" },
|
{ kErrorCtxClosePending, "Ctx close pending" },
|
{ kErrorCtxNoOutbuf, "Ctx no outbuf" },
|
{ kErrorCtxModemInfNotFound, "Ctx modem inf not found" },
|
{ kErrorCtxInvalidModemname, "Ctx invalid modemname" },
|
{ kErrorCtxModemResponseError, "Ctx modem response error" },
|
{ kErrorCtxModemResponseTimeout, "Ctx modem response timeout" },
|
{ kErrorCtxModemResponseNoCarrier, "Ctx modem response no carrier" },
|
{ kErrorCtxModemResponseNoDialtone, "Ctx modem response no dial tone" },
|
{ kErrorCtxModemResponseBusy, "Ctx modem response busy" },
|
{ kErrorCtxModemResponseVoice, "Ctx modem response voice" },
|
{ kErrorCtxTdError, "Ctx TD error" },
|
{ kErrorCtxWinstationNotFound, "Ctx winstation not found" },
|
{ kErrorCtxWinstationAlreadyExists, "Ctx winstation already exists" },
|
{ kErrorCtxWinstationBusy, "Ctx winstation busy" },
|
{ kErrorCtxBadVideoMode, "Ctx bad video mode" },
|
{ kErrorCtxGraphicsInvalid, "Ctx graphics invalid" },
|
{ kErrorCtxLogonDisabled, "Ctx logon disabled" },
|
{ kErrorCtxNotConsole, "Ctx not console" },
|
{ kErrorCtxClientQueryTimeout, "Ctx client query timeout" },
|
{ kErrorCtxConsoleDisconnect, "Ctx console disconnect" },
|
{ kErrorCtxConsoleConnect, "Ctx console connect" },
|
{ kErrorCtxShadowDenied, "Ctx shadow denied" },
|
{ kErrorCtxWinstationAccessDenied, "Ctx winstation access denied" },
|
{ kErrorCtxInvalidWd, "Ctx invalid WD" },
|
{ kErrorCtxShadowInvalid, "Ctx shadow invalid" },
|
{ kErrorCtxShadowDisabled, "Ctx shadow disabled" },
|
{ kErrorCtxClientLicenseInUse, "Ctx client licence in use" },
|
{ kErrorCtxClientLicenseNotSet, "Ctx client licence not set" },
|
{ kErrorCtxLicenseNotAvailable, "Ctx licence not available" },
|
{ kErrorCtxLicenseClientInvalid, "Ctx licence client invalid" },
|
{ kErrorCtxLicenseExpired, "Ctx licence expired" },
|
{ kErrorCtxShadowNotRunning, "Ctx shadow not running" },
|
{ kErrorCtxShadowEndedByModeChange, "Ctx shadow ended by mode change" },
|
{ kFrsErrInvalidApiSequence, "FRS err invalid API sequence" },
|
{ kFrsErrStartingService, "FRS err starting service" },
|
{ kFrsErrStoppingService, "FRS err stopping service" },
|
{ kFrsErrInternalApi, "FRS err internal API" },
|
{ kFrsErrInternal, "FRS err internal" },
|
{ kFrsErrServiceComm, "FRS err service comm" },
|
{ kFrsErrInsufficientPriv, "FRS err insufficient priv" },
|
{ kFrsErrAuthentication, "FRS err authentication" },
|
{ kFrsErrParentInsufficientPriv, "FRS err parent insufficient priv" },
|
{ kFrsErrParentAuthentication, "FRS err parent authentication" },
|
{ kFrsErrChildToParentComm, "FRS err child to parent comm" },
|
{ kFrsErrParentToChildComm, "FRS err parent to child comm" },
|
{ kFrsErrSysvolPopulate, "FRS err sysvol populate" },
|
{ kFrsErrSysvolPopulateTimeout, "FRS err sysvol populate timeout" },
|
{ kFrsErrSysvolIsBusy, "FRS err sysvol is busy" },
|
{ kFrsErrSysvolDemote, "FRS err sysvol demote" },
|
{ kFrsErrInvalidServiceParameter, "FRS err invalid service parameter" },
|
{ kErrorDsNotInstalled, "DS not installed" },
|
{ kErrorDsMembershipEvaluatedLocally, "DS membership evaluated locally" },
|
{ kErrorDsNoAttributeOrValue, "DS no attribute or value" },
|
{ kErrorDsInvalidAttributeSyntax, "DS invalid attribute syntax" },
|
{ kErrorDsAttributeTypeUndefined, "DS attribute type undefined" },
|
{ kErrorDsAttributeOrValueExists, "DS attribute or value exists" },
|
{ kErrorDsBusy, "DS busy" },
|
{ kErrorDsUnavailable, "DS unavailable" },
|
{ kErrorDsNoRidsAllocated, "DS no rids allocated" },
|
{ kErrorDsNoMoreRids, "DS no more rids" },
|
{ kErrorDsIncorrectRoleOwner, "DS incorrect role owner" },
|
{ kErrorDsRidmgrInitError, "DS ridmgr init error" },
|
{ kErrorDsObjClassViolation, "DS obj class violation" },
|
{ kErrorDsCantOnNonLeaf, "DS can't on non leaf" },
|
{ kErrorDsCantOnRdn, "DS can't on rnd" },
|
{ kErrorDsCantModObjClass, "DS can't mod obj class" },
|
{ kErrorDsCrossDomMoveError, "DS cross dom move error" },
|
{ kErrorDsGcNotAvailable, "DS GC not available" },
|
{ kErrorSharedPolicy, "Shared policy" },
|
{ kErrorPolicyObjectNotFound, "Policy object not found" },
|
{ kErrorPolicyOnlyInDs, "Policy only in DS" },
|
{ kErrorPromotionActive, "Promotion active" },
|
{ kErrorNoPromotionActive, "No promotion active" },
|
{ kErrorDsOperationsError, "DS operations error" },
|
{ kErrorDsProtocolError, "DS protocol error" },
|
{ kErrorDsTimelimitExceeded, "DS timelimit exceeded" },
|
{ kErrorDsSizelimitExceeded, "DS sizelimit exceeded" },
|
{ kErrorDsAdminLimitExceeded, "DS admin limit exceeded" },
|
{ kErrorDsCompareFalse, "DS compare false" },
|
{ kErrorDsCompareTrue, "DS compare true" },
|
{ kErrorDsAuthMethodNotSupported, "DS auth method not supported" },
|
{ kErrorDsStrongAuthRequired, "DS strong auth required" },
|
{ kErrorDsInappropriateAuth, "DS inappropriate auth" },
|
{ kErrorDsAuthUnknown, "DS auth unknown" },
|
{ kErrorDsReferral, "DS referral" },
|
{ kErrorDsUnavailableCritExtension, "DS unavailable crit extension" },
|
{ kErrorDsConfidentialityRequired, "DS confidentiality required" },
|
{ kErrorDsInappropriateMatching, "DS inappropriate matching" },
|
{ kErrorDsConstraintViolation, "DS constraint violation" },
|
{ kErrorDsNoSuchObject, "DS no such object" },
|
{ kErrorDsAliasProblem, "DS alias problem" },
|
{ kErrorDsInvalidDnSyntax, "DS invalid dn syntax" },
|
{ kErrorDsIsLeaf, "DS is leaf" },
|
{ kErrorDsAliasDerefProblem, "DS alias deref problem" },
|
{ kErrorDsUnwillingToPerform, "DS unwilling to perform" },
|
{ kErrorDsLoopDetect, "DS loop detect" },
|
{ kErrorDsNamingViolation, "DS naming violation" },
|
{ kErrorDsObjectResultsTooLarge, "DS object results too large" },
|
{ kErrorDsAffectsMultipleDsas, "DS affects multiple dsas" },
|
{ kErrorDsServerDown, "DS server down" },
|
{ kErrorDsLocalError, "DS local error" },
|
{ kErrorDsEncodingError, "DS encoding error" },
|
{ kErrorDsDecodingError, "DS decoding error" },
|
{ kErrorDsFilterUnknown, "DS filter unknown" },
|
{ kErrorDsParamError, "DS param error" },
|
{ kErrorDsNotSupported, "DS not supported" },
|
{ kErrorDsNoResultsReturned, "DS no results returned" },
|
{ kErrorDsControlNotFound, "DS control not found" },
|
{ kErrorDsClientLoop, "DS client loop" },
|
{ kErrorDsReferralLimitExceeded, "DS referral limit exceeded" },
|
{ kErrorDsSortControlMissing, "DS sort control missing" },
|
{ kErrorDsOffsetRangeError, "DS offset range error" },
|
{ kErrorDsRootMustBeNc, "DS root must be nc" },
|
{ kErrorDsAddReplicaInhibited, "DS and replica inhibited" },
|
{ kErrorDsAttNotDefInSchema, "DS att not def in schema" },
|
{ kErrorDsMaxObjSizeExceeded, "DS max obj size exceeded" },
|
{ kErrorDsObjStringNameExists, "DS obj string name exists" },
|
{ kErrorDsNoRdnDefinedInSchema, "DS no rdn defined in schema" },
|
{ kErrorDsRdnDoesntMatchSchema, "DS rdn doesn't match schema" },
|
{ kErrorDsNoRequestedAttsFound, "DS no requested atts found" },
|
{ kErrorDsUserBufferToSmall, "DS user buffer too small" },
|
{ kErrorDsAttIsNotOnObj, "DS att is not on obj" },
|
{ kErrorDsIllegalModOperation, "DS illegal mod operation" },
|
{ kErrorDsObjTooLarge, "DS obj too large" },
|
{ kErrorDsBadInstanceType, "DS bad instance type" },
|
{ kErrorDsMasterdsaRequired, "DS masterdsa required" },
|
{ kErrorDsObjectClassRequired, "DS object class required" },
|
{ kErrorDsMissingRequiredAtt, "DS missing required att" },
|
{ kErrorDsAttNotDefForClass, "DS att not def for class" },
|
{ kErrorDsAttAlreadyExists, "DS att already exists" },
|
{ kErrorDsCantAddAttValues, "DS can't add att values" },
|
{ kErrorDsSingleValueConstraint, "DS single value constraint" },
|
{ kErrorDsRangeConstraint, "DS range constraint" },
|
{ kErrorDsAttValAlreadyExists, "DS att val already exists" },
|
{ kErrorDsCantRemMissingAtt, "DS can't rem missing att" },
|
{ kErrorDsCantRemMissingAttVal, "DS can't rem missing att val" },
|
{ kErrorDsRootCantBeSubref, "DS root can't be subref" },
|
{ kErrorDsNoChaining, "DS no chaining" },
|
{ kErrorDsNoChainedEval, "DS no chained eval" },
|
{ kErrorDsNoParentObject, "DS no parent object" },
|
{ kErrorDsParentIsAnAlias, "DS parent is an alias" },
|
{ kErrorDsCantMixMasterAndReps, "DS can't mix master and reps" },
|
{ kErrorDsChildrenExist, "DS children exist" },
|
{ kErrorDsObjNotFound, "DS obj not found" },
|
{ kErrorDsAliasedObjMissing, "DS aliased obj missing" },
|
{ kErrorDsBadNameSyntax, "DS bad name syntax" },
|
{ kErrorDsAliasPointsToAlias, "DS alias points to alias" },
|
{ kErrorDsCantDerefAlias, "DS can't redef alias" },
|
{ kErrorDsOutOfScope, "DS out of scope" },
|
{ kErrorDsObjectBeingRemoved, "DS object being removed" },
|
{ kErrorDsCantDeleteDsaObj, "DS can't delete dsa obj" },
|
{ kErrorDsGenericError, "DS generic error" },
|
{ kErrorDsDsaMustBeIntMaster, "DS dsa must be int master" },
|
{ kErrorDsClassNotDsa, "DS class not dsa" },
|
{ kErrorDsInsuffAccessRights, "DS insuff access rights" },
|
{ kErrorDsIllegalSuperior, "DS illegal superior" },
|
{ kErrorDsAttributeOwnedBySam, "DS attribute owned by sam" },
|
{ kErrorDsNameTooManyParts, "DS name too many parts" },
|
{ kErrorDsNameTooLong, "DS name too long" },
|
{ kErrorDsNameValueTooLong, "DS name value too long" },
|
{ kErrorDsNameUnparseable, "DS name unparseable" },
|
{ kErrorDsNameTypeUnknown, "DS name type unknown" },
|
{ kErrorDsNotAnObject, "DS not an object" },
|
{ kErrorDsSecDescTooShort, "DS sec desc too short" },
|
{ kErrorDsSecDescInvalid, "DS sec desc invalid" },
|
{ kErrorDsNoDeletedName, "DS no deleted name" },
|
{ kErrorDsSubrefMustHaveParent, "DS subref must have parent" },
|
{ kErrorDsNcnameMustBeNc, "DS ncname must be nc" },
|
{ kErrorDsCantAddSystemOnly, "DS can't add system only" },
|
{ kErrorDsClassMustBeConcrete, "DS class must be concrete" },
|
{ kErrorDsInvalidDmd, "DS invalid dmd" },
|
{ kErrorDsObjGuidExists, "DS obj GUID exists" },
|
{ kErrorDsNotOnBacklink, "DS not on backlink" },
|
{ kErrorDsNoCrossrefForNc, "DS no crossref for nc" },
|
{ kErrorDsShuttingDown, "DS shutting down" },
|
{ kErrorDsUnknownOperation, "DS unknown operation" },
|
{ kErrorDsInvalidRoleOwner, "DS invalid role owner" },
|
{ kErrorDsCouldntContactFsmo, "DS couldn't contact fsmo" },
|
{ kErrorDsCrossNcDnRename, "DS cross nc dn rename" },
|
{ kErrorDsCantModSystemOnly, "DS can't mod system only" },
|
{ kErrorDsReplicatorOnly, "DS replicator only" },
|
{ kErrorDsObjClassNotDefined, "DS obj class not defined" },
|
{ kErrorDsObjClassNotSubclass, "DS obj class not subclass" },
|
{ kErrorDsNameReferenceInvalid, "DS name reference invalid" },
|
{ kErrorDsCrossRefExists, "DS cross ref exists" },
|
{ kErrorDsCantDelMasterCrossref, "DS can't del master crossref" },
|
{ kErrorDsSubtreeNotifyNotNcHead, "DS subtree notify not nc head" },
|
{ kErrorDsNotifyFilterTooComplex, "DS notify filter too complex" },
|
{ kErrorDsDupRdn, "DS dup rdn" },
|
{ kErrorDsDupOid, "DS dup oid" },
|
{ kErrorDsDupMapiId, "DS dup mapi ID" },
|
{ kErrorDsDupSchemaIdGuid, "DS dup schema ID GUID" },
|
{ kErrorDsDupLdapDisplayName, "DS dup LDAP display name" },
|
{ kErrorDsSemanticAttTest, "DS semantic att test" },
|
{ kErrorDsSyntaxMismatch, "DS syntax mismatch" },
|
{ kErrorDsExistsInMustHave, "DS exists in must have" },
|
{ kErrorDsExistsInMayHave, "DS exists in may have" },
|
{ kErrorDsNonexistentMayHave, "DS nonexistent may have" },
|
{ kErrorDsNonexistentMustHave, "DS nonexistent must have" },
|
{ kErrorDsAuxClsTestFail, "DS aux cls test fail" },
|
{ kErrorDsNonexistentPossSup, "DS nonexistent poss sup" },
|
{ kErrorDsSubClsTestFail, "DS sub cls test fail" },
|
{ kErrorDsBadRdnAttIdSyntax, "DS bad rdn att ID syntax" },
|
{ kErrorDsExistsInAuxCls, "DS exists in aux cls" },
|
{ kErrorDsExistsInSubCls, "DS exists in sub cls" },
|
{ kErrorDsExistsInPossSup, "DS exists in poss sup" },
|
{ kErrorDsRecalcschemaFailed, "DS recalcschema failed" },
|
{ kErrorDsTreeDeleteNotFinished, "DS tree delete not finished" },
|
{ kErrorDsCantDelete, "DS can't delete" },
|
{ kErrorDsAttSchemaReqId, "DS att schema req ID" },
|
{ kErrorDsBadAttSchemaSyntax, "DS bad att schema syntax" },
|
{ kErrorDsCantCacheAtt, "DS can't cache att" },
|
{ kErrorDsCantCacheClass, "DS can't cache class" },
|
{ kErrorDsCantRemoveAttCache, "DS can't remove att cache" },
|
{ kErrorDsCantRemoveClassCache, "DS can't remove class cache" },
|
{ kErrorDsCantRetrieveDn, "DS can't retrieve DN" },
|
{ kErrorDsMissingSupref, "DS missing supref" },
|
{ kErrorDsCantRetrieveInstance, "DS can't retrieve instance" },
|
{ kErrorDsCodeInconsistency, "DS code inconsistency" },
|
{ kErrorDsDatabaseError, "DS database error" },
|
{ kErrorDsGovernsidMissing, "DS governsid missing" },
|
{ kErrorDsMissingExpectedAtt, "DS missing expected att" },
|
{ kErrorDsNcnameMissingCrRef, "DS ncname missing cr ref" },
|
{ kErrorDsSecurityCheckingError, "DS security checking error" },
|
{ kErrorDsSchemaNotLoaded, "DS schema not loaded" },
|
{ kErrorDsSchemaAllocFailed, "DS schema alloc failed" },
|
{ kErrorDsAttSchemaReqSyntax, "DS att schema req syntax" },
|
{ kErrorDsGcverifyError, "DS gcverify error" },
|
{ kErrorDsDraSchemaMismatch, "DS dra schema mismatch" },
|
{ kErrorDsCantFindDsaObj, "DS can't find dsa obj" },
|
{ kErrorDsCantFindExpectedNc, "DS can't find expected nc" },
|
{ kErrorDsCantFindNcInCache, "DS can't find nc in cache" },
|
{ kErrorDsCantRetrieveChild, "DS can't retrieve child" },
|
{ kErrorDsSecurityIllegalModify, "DS security illegal modify" },
|
{ kErrorDsCantReplaceHiddenRec, "DS can't replace hidden rec" },
|
{ kErrorDsBadHierarchyFile, "DS bad hierarchy file" },
|
{ kErrorDsBuildHierarchyTableFailed, "DS build hierarchy table failed" },
|
{ kErrorDsConfigParamMissing, "DS config param missing" },
|
{ kErrorDsCountingAbIndicesFailed, "DS counting ab indices failed" },
|
{ kErrorDsHierarchyTableMallocFailed, "DS hierarchy table malloc failed" },
|
{ kErrorDsInternalFailure, "DS internal failure" },
|
{ kErrorDsUnknownError, "DS unknown error" },
|
{ kErrorDsRootRequiresClassTop, "DS root requires class top" },
|
{ kErrorDsRefusingFsmoRoles, "DS refusing fmso roles" },
|
{ kErrorDsMissingFsmoSettings, "DS missing fmso settings" },
|
{ kErrorDsUnableToSurrenderRoles, "DS unable to surrender roles" },
|
{ kErrorDsDraGeneric, "DS dra generic" },
|
{ kErrorDsDraInvalidParameter, "DS dra invalid parameter" },
|
{ kErrorDsDraBusy, "DS dra busy" },
|
{ kErrorDsDraBadDn, "DS dra bad dn" },
|
{ kErrorDsDraBadNc, "DS dra bad nc" },
|
{ kErrorDsDraDnExists, "DS dra dn exists" },
|
{ kErrorDsDraInternalError, "DS dra internal error" },
|
{ kErrorDsDraInconsistentDit, "DS dra inconsistent dit" },
|
{ kErrorDsDraConnectionFailed, "DS dra connection failed" },
|
{ kErrorDsDraBadInstanceType, "DS dra bad instance type" },
|
{ kErrorDsDraOutOfMem, "DS dra out of mem" },
|
{ kErrorDsDraMailProblem, "DS dra mail problem" },
|
{ kErrorDsDraRefAlreadyExists, "DS dra ref already exists" },
|
{ kErrorDsDraRefNotFound, "DS dra ref not found" },
|
{ kErrorDsDraObjIsRepSource, "DS dra obj is rep source" },
|
{ kErrorDsDraDbError, "DS dra db error" },
|
{ kErrorDsDraNoReplica, "DS dra no replica" },
|
{ kErrorDsDraAccessDenied, "DS dra access denied" },
|
{ kErrorDsDraNotSupported, "DS dra not supported" },
|
{ kErrorDsDraRpcCancelled, "DS dra RPC cancelled" },
|
{ kErrorDsDraSourceDisabled, "DS dra source disabled" },
|
{ kErrorDsDraSinkDisabled, "DS dra sink disabled" },
|
{ kErrorDsDraNameCollision, "DS dra name collision" },
|
{ kErrorDsDraSourceReinstalled, "DS dra source reinstalled" },
|
{ kErrorDsDraMissingParent, "DS dra missing parent" },
|
{ kErrorDsDraPreempted, "DS dra preempted" },
|
{ kErrorDsDraAbandonSync, "DS dra abandon sync" },
|
{ kErrorDsDraShutdown, "DS dra shutdown" },
|
{ kErrorDsDraIncompatiblePartialSet, "DS dra incompatible partial set" },
|
{ kErrorDsDraSourceIsPartialReplica, "DS dra source is partial replica" },
|
{ kErrorDsDraExtnConnectionFailed, "DS dra extn connection failed" },
|
{ kErrorDsInstallSchemaMismatch, "DS install schema mismatch" },
|
{ kErrorDsDupLinkId, "DS dup link ID" },
|
{ kErrorDsNameErrorResolving, "DS name error resolving" },
|
{ kErrorDsNameErrorNotFound, "DS name error not found" },
|
{ kErrorDsNameErrorNotUnique, "DS name error not unique" },
|
{ kErrorDsNameErrorNoMapping, "DS name error no mapping" },
|
{ kErrorDsNameErrorDomainOnly, "DS name error domain only" },
|
{ kErrorDsNameErrorNoSyntacticalMapping, "DS name error no syntactical mapping" },
|
{ kErrorDsConstructedAttMod, "DS constructed att mod" },
|
{ kErrorDsWrongOmObjClass, "DS wrong om obj class" },
|
{ kErrorDsDraReplPending, "DS dra repl pending" },
|
{ kErrorDsDsRequired, "DS ds required" },
|
{ kErrorDsInvalidLdapDisplayName, "DS invalid LDAP display name" },
|
{ kErrorDsNonBaseSearch, "DS non base search" },
|
{ kErrorDsCantRetrieveAtts, "DS can't retrieve atts" },
|
{ kErrorDsBacklinkWithoutLink, "DS backlink without link" },
|
{ kErrorDsEpochMismatch, "DS epoch mismatch" },
|
{ kErrorDsSrcNameMismatch, "DS src name mismatch" },
|
{ kErrorDsSrcAndDstNcIdentical, "DS src and dst nc identical" },
|
{ kErrorDsDstNcMismatch, "DS dst nc mismatch" },
|
{ kErrorDsNotAuthoritiveForDstNc, "DS not authoritive for dst nc" },
|
{ kErrorDsSrcGuidMismatch, "DS src GUID mismatch" },
|
{ kErrorDsCantMoveDeletedObject, "DS can't move deleted object" },
|
{ kErrorDsPdcOperationInProgress, "DS pdc operation in progress" },
|
{ kErrorDsCrossDomainCleanupReqd, "DS cross domain cleanup reqd" },
|
{ kErrorDsIllegalXdomMoveOperation, "DS illegal xdom move operation" },
|
{ kErrorDsCantWithAcctGroupMembershps, "DS can't with acct group membershps" },
|
{ kErrorDsNcMustHaveNcParent, "DS nc must have nc parent" },
|
{ kErrorDsDstDomainNotNative, "DS dst domain not native" },
|
{ kErrorDsMissingInfrastructureContainer, "DS missing infrastructure container" },
|
{ kErrorDsCantMoveAccountGroup, "DS can't move account group" },
|
{ kErrorDsCantMoveResourceGroup, "DS can't move resource group" },
|
{ kErrorDsInvalidSearchFlag, "DS invalid search flag" },
|
{ kErrorDsNoTreeDeleteAboveNc, "DS no tree delete above nc" },
|
{ kErrorDsCouldntLockTreeForDelete, "DS couldn't lock tree for delete" },
|
{ kErrorDsCouldntIdentifyObjectsForTreeDelete, "DS couldn't identify objects for tree delete" },
|
{ kErrorDsSamInitFailure, "DS sam init failure" },
|
{ kErrorDsSensitiveGroupViolation, "DS sensitive group violation" },
|
{ kErrorDsCantModPrimarygroupid, "DS can't mod primarygroupid" },
|
{ kErrorDsIllegalBaseSchemaMod, "DS illegal base schema mod" },
|
{ kErrorDsNonsafeSchemaChange, "DS nonsafe schema change" },
|
{ kErrorDsSchemaUpdateDisallowed, "DS schema update disallowed" },
|
{ kErrorDsCantCreateUnderSchema, "DS can't create under schema" },
|
{ kErrorDsInstallNoSrcSchVersion, "DS install no src sch version" },
|
{ kErrorDsInstallNoSchVersionInInifile, "DS install no sch version in inifile" },
|
{ kErrorDsInvalidGroupType, "DS invalid group type" },
|
{ kErrorDsNoNestGlobalgroupInMixeddomain, "DS no nest globalgroup in mixeddomain" },
|
{ kErrorDsNoNestLocalgroupInMixeddomain, "DS no nest localgroup in mixeddomain" },
|
{ kErrorDsGlobalCantHaveLocalMember, "DS global can't have local member" },
|
{ kErrorDsGlobalCantHaveUniversalMember, "DS global can't have universal member" },
|
{ kErrorDsUniversalCantHaveLocalMember, "DS universal can't have local member" },
|
{ kErrorDsGlobalCantHaveCrossdomainMember, "DS global can't have crossdomain member" },
|
{ kErrorDsLocalCantHaveCrossdomainLocalMember, "DS local can't have crossdomain local member" },
|
{ kErrorDsHavePrimaryMembers, "DS have primary members" },
|
{ kErrorDsStringSdConversionFailed, "DS string sd conversion failed" },
|
{ kErrorDsNamingMasterGc, "DS naming master gc" },
|
{ kErrorDsLookupFailure, "DS lookup failure" },
|
{ kErrorDsCouldntUpdateSpns, "DS couldn't update spns" },
|
{ kErrorDsCantRetrieveSd, "DS can't retrieve sd" },
|
{ kErrorDsKeyNotUnique, "DS key not unique" },
|
{ kErrorDsWrongLinkedAttSyntax, "DS wrong linked att syntax" },
|
{ kErrorDsSamNeedBootkeyPassword, "DS sam need bootkey password" },
|
{ kErrorDsSamNeedBootkeyFloppy, "DS sam need bootkey floppy" },
|
{ kErrorDsCantStart, "DS can't start" },
|
{ kErrorDsInitFailure, "DS init failure" },
|
{ kErrorDsNoPktPrivacyOnConnection, "DS no pkt privacy on connection" },
|
{ kErrorDsSourceDomainInForest, "DS source domain in forest" },
|
{ kErrorDsDestinationDomainNotInForest, "DS destination domain not in forest" },
|
{ kErrorDsDestinationAuditingNotEnabled, "DS destination auditing not enabled" },
|
{ kErrorDsCantFindDcForSrcDomain, "DS can't find dc for src domain" },
|
{ kErrorDsSrcObjNotGroupOrUser, "DS src obj not group or user" },
|
{ kErrorDsSrcSidExistsInForest, "DS src sid exists in forest" },
|
{ kErrorDsSrcAndDstObjectClassMismatch, "DS src and dst object class mismatch" },
|
{ kErrorSamInitFailure, "Sam init failure" },
|
{ kErrorDsDraSchemaInfoShip, "DS dra schema info ship" },
|
{ kErrorDsDraSchemaConflict, "DS dra schema conflict" },
|
{ kErrorDsDraEarlierSchemaConlict, "DS dra earlier schema conflict" },
|
{ kErrorDsDraObjNcMismatch, "DS dra obj nc mismatch" },
|
{ kErrorDsNcStillHasDsas, "DS nc still has dsas" },
|
{ kErrorDsGcRequired, "DS gc required" },
|
{ kErrorDsLocalMemberOfLocalOnly, "DS local member of local only" },
|
{ kErrorDsNoFpoInUniversalGroups, "DS no fpo in universal groups" },
|
{ kErrorDsCantAddToGc, "DS can't add to gc" },
|
{ kErrorDsNoCheckpointWithPdc, "DS no checkpoint with pdc" },
|
{ kErrorDsSourceAuditingNotEnabled, "DS source auditing not enabled" },
|
{ kErrorDsCantCreateInNondomainNc, "DS can't create in nondomain nc" },
|
{ kErrorDsInvalidNameForSpn, "DS invalid name for spn" },
|
{ kErrorDsFilterUsesContructedAttrs, "DS filter uses constructed attrs" },
|
{ kErrorDsUnicodepwdNotInQuotes, "DS unicodepwd not in quotes" },
|
{ kErrorDsMachineAccountQuotaExceeded, "DS machine account quota exceeded" },
|
{ kErrorDsMustBeRunOnDstDc, "DS must be run on dst dc" },
|
{ kErrorDsSrcDcMustBeSp4OrGreater, "DS src dc must be sp4 or greater" },
|
{ kErrorDsCantTreeDeleteCriticalObj, "DS can't tree delete critical obj" },
|
{ kErrorDsInitFailureConsole, "DS init failure console" },
|
{ kErrorDsSamInitFailureConsole, "DS sam init failure console" },
|
{ kErrorDsForestVersionTooHigh, "DS forest version too high" },
|
{ kErrorDsDomainVersionTooHigh, "DS domain version too high" },
|
{ kErrorDsForestVersionTooLow, "DS forest version too low" },
|
{ kErrorDsDomainVersionTooLow, "DS domain version too low" },
|
{ kErrorDsIncompatibleVersion, "DS incompatible version" },
|
{ kErrorDsLowDsaVersion, "DS low dsa version" },
|
{ kErrorDsNoBehaviorVersionInMixeddomain, "DS no behaviour version in mixeddomain" },
|
{ kErrorDsNotSupportedSortOrder, "DS not supported sort order" },
|
{ kErrorDsNameNotUnique, "DS name not unique" },
|
{ kErrorDsMachineAccountCreatedPrent4, "DS machine account created prent4" },
|
{ kErrorDsOutOfVersionStore, "DS out of version store" },
|
{ kErrorDsIncompatibleControlsUsed, "DS incompatible controls used" },
|
{ kErrorDsNoRefDomain, "DS no ref domain" },
|
{ kErrorDsReservedLinkId, "DS reserved link ID" },
|
{ kErrorDsLinkIdNotAvailable, "DS link ID not available" },
|
{ kErrorDsAgCantHaveUniversalMember, "DS ag can't have universal member" },
|
{ kErrorDsModifydnDisallowedByInstanceType, "DS modifydn disallowed by instance type" },
|
{ kErrorDsNoObjectMoveInSchemaNc, "DS no object move in schema nc" },
|
{ kErrorDsModifydnDisallowedByFlag, "DS modifydn disallowed by flag" },
|
{ kErrorDsModifydnWrongGrandparent, "DS modifydn wrong grandparent" },
|
{ kErrorDsNameErrorTrustReferral, "DS name error trust referral" },
|
{ kErrorNotSupportedOnStandardServer, "Not supported on standard server" },
|
{ kErrorDsCantAccessRemotePartOfAd, "DS can't access remote part of ad" },
|
{ kErrorDsCrImpossibleToValidate, "DS cr impossible to validate" },
|
{ kErrorDsThreadLimitExceeded, "DS thread limit exceeded" },
|
{ kErrorDsNotClosest, "DS not closest" },
|
{ kErrorDsCantDeriveSpnWithoutServerRef, "DS can't derive spn without server ref" },
|
{ kErrorDsSingleUserModeFailed, "DS single user mode failed" },
|
{ kErrorDsNtdscriptSyntaxError, "DS ntdscript syntax error" },
|
{ kErrorDsNtdscriptProcessError, "DS ntdscript process error" },
|
{ kErrorDsDifferentReplEpochs, "DS different repl epochs" },
|
{ kErrorDsDrsExtensionsChanged, "DS drs extensions changed" },
|
{ kErrorDsReplicaSetChangeNotAllowedOnDisabledCr, "DS replica set change not allowed on disabled cr" },
|
{ kErrorDsNoMsdsIntid, "DS no msds intid" },
|
{ kErrorDsDupMsdsIntid, "DS dup msds intid" },
|
{ kErrorDsExistsInRdnattid, "DS exists in rdnattid" },
|
{ kErrorDsAuthorizationFailed, "DS authorisation failed" },
|
{ kErrorDsInvalidScript, "DS invalid script" },
|
{ kErrorDsRemoteCrossrefOpFailed, "DS remote crossref op failed" },
|
{ kDnsErrorRcodeFormatError, "DNS error rcode format error" },
|
{ kDnsErrorRcodeServerFailure, "DNS error rcode server failure" },
|
{ kDnsErrorRcodeNameError, "DNS error rcode name error" },
|
{ kDnsErrorRcodeNotImplemented, "DNS error rcode not implemented" },
|
{ kDnsErrorRcodeRefused, "DNS error rcode refused" },
|
{ kDnsErrorRcodeYxdomain, "DNS error rcode yxdomain" },
|
{ kDnsErrorRcodeYxrrset, "DNS error rcode yxrrset" },
|
{ kDnsErrorRcodeNxrrset, "DNS error rcode nxrrset" },
|
{ kDnsErrorRcodeNotauth, "DNS error rcode notauth" },
|
{ kDnsErrorRcodeNotzone, "DNS error rcode notzone" },
|
{ kDnsErrorRcodeBadsig, "DNS error rcode badsig" },
|
{ kDnsErrorRcodeBadkey, "DNS error rcode badkey" },
|
{ kDnsErrorRcodeBadtime, "DNS error rcode badtime" },
|
{ kDnsInfoNoRecords, "DNS info no records" },
|
{ kDnsErrorBadPacket, "DNS error bad packet" },
|
{ kDnsErrorNoPacket, "DNS error no packet" },
|
{ kDnsErrorRcode, "DNS error rcode" },
|
{ kDnsErrorUnsecurePacket, "DNS error unsecure packet" },
|
{ kDnsErrorInvalidType, "DNS error invalid type" },
|
{ kDnsErrorInvalidIpAddress, "DNS error invalid IP address" },
|
{ kDnsErrorInvalidProperty, "DNS error invalid property" },
|
{ kDnsErrorTryAgainLater, "DNS error try again later" },
|
{ kDnsErrorNotUnique, "DNS error not unique" },
|
{ kDnsErrorNonRfcName, "DNS error non RFC name" },
|
{ kDnsStatusFqdn, "DNS status FQDN" },
|
{ kDnsStatusDottedName, "DNS status dotted name" },
|
{ kDnsStatusSinglePartName, "DNS status single part name" },
|
{ kDnsErrorInvalidNameChar, "DNS error invalid name char" },
|
{ kDnsErrorNumericName, "DNS error numeric name" },
|
{ kDnsErrorNotAllowedOnRootServer, "DNS error not allowed on root server" },
|
{ kDnsErrorZoneDoesNotExist, "DNS error zone does not exist" },
|
{ kDnsErrorNoZoneInfo, "DNS error not zone info" },
|
{ kDnsErrorInvalidZoneOperation, "DNS error invalid zone operation" },
|
{ kDnsErrorZoneConfigurationError, "DNS error zone configuration error" },
|
{ kDnsErrorZoneHasNoSoaRecord, "DNS error zone has not SOA record" },
|
{ kDnsErrorZoneHasNoNsRecords, "DNS error zone has no NS records" },
|
{ kDnsErrorZoneLocked, "DNS error zone locked" },
|
{ kDnsErrorZoneCreationFailed, "DNS error zone creation failed" },
|
{ kDnsErrorZoneAlreadyExists, "DNS error zone already exists" },
|
{ kDnsErrorAutozoneAlreadyExists, "DNS error autozone already exists" },
|
{ kDnsErrorInvalidZoneType, "DNS error invalid zone type" },
|
{ kDnsErrorSecondaryRequiresMasterIp, "DNS error secondary requires master IP" },
|
{ kDnsErrorZoneNotSecondary, "DNS error zone not secondary" },
|
{ kDnsErrorNeedSecondaryAddresses, "DNS error need secondary addresses" },
|
{ kDnsErrorWinsInitFailed, "DNS error wins init failed" },
|
{ kDnsErrorNeedWinsServers, "DNS error need wins servers" },
|
{ kDnsErrorNbstatInitFailed, "DNS error nbstat init failed" },
|
{ kDnsErrorSoaDeleteInvalid, "DNS error SOA delete invalid" },
|
{ kDnsErrorForwarderAlreadyExists, "DNS error forwarder already exists" },
|
{ kDnsErrorZoneRequiresMasterIp, "DNS error zone requires master IP" },
|
{ kDnsErrorZoneIsShutdown, "DNS error zone is shutdown" },
|
{ kDnsErrorPrimaryRequiresDatafile, "DNS error primary requires datafile" },
|
{ kDnsErrorInvalidDatafileName, "DNS error invalid datafile name" },
|
{ kDnsErrorDatafileOpenFailure, "DNS error datafile open failure" },
|
{ kDnsErrorFileWritebackFailed, "DNS error file writeback failed" },
|
{ kDnsErrorDatafileParsing, "DNS error datafile parsing" },
|
{ kDnsErrorRecordDoesNotExist, "DNS error record does not exist" },
|
{ kDnsErrorRecordFormat, "DNS error record format" },
|
{ kDnsErrorNodeCreationFailed, "DNS error node creation failed" },
|
{ kDnsErrorUnknownRecordType, "DNS error unknown record type" },
|
{ kDnsErrorRecordTimedOut, "DNS error record timed out" },
|
{ kDnsErrorNameNotInZone, "DNS error name not in zone" },
|
{ kDnsErrorCnameLoop, "DNS error CNAME loop" },
|
{ kDnsErrorNodeIsCname, "DNS error node is CNAME" },
|
{ kDnsErrorCnameCollision, "DNS error CNAME collision" },
|
{ kDnsErrorRecordOnlyAtZoneRoot, "DNS error record only at zone root" },
|
{ kDnsErrorRecordAlreadyExists, "DNS error record already exists" },
|
{ kDnsErrorSecondaryData, "DNS error secondary data" },
|
{ kDnsErrorNoCreateCacheData, "DNS error no create cache data" },
|
{ kDnsErrorNameDoesNotExist, "DNS error name does not exist" },
|
{ kDnsWarningPtrCreateFailed, "DNS warning PTR create failed" },
|
{ kDnsWarningDomainUndeleted, "DNS warning domain undeleted" },
|
{ kDnsErrorDsUnavailable, "DNS error ds unavailable" },
|
{ kDnsErrorDsZoneAlreadyExists, "DNS error ds zone already exists" },
|
{ kDnsErrorNoBootfileIfDsZone, "DNS error no bootfile if ds zone" },
|
{ kDnsInfoAxfrComplete, "DNS info AXFR complete" },
|
{ kDnsErrorAxfr, "DNS error AXFR" },
|
{ kDnsInfoAddedLocalWins, "DNS info added local wins" },
|
{ kDnsStatusContinueNeeded, "DNS status continue needed" },
|
{ kDnsErrorNoTcpip, "DNS error no TCPIP" },
|
{ kDnsErrorNoDnsServers, "DNS error no DNS servers" },
|
{ kDnsErrorDpDoesNotExist, "DNS error dp does not exist" },
|
{ kDnsErrorDpAlreadyExists, "DNS error dp already exists" },
|
{ kDnsErrorDpNotEnlisted, "DNS error dp not enlisted" },
|
{ kDnsErrorDpAlreadyEnlisted, "DNS error dp already enlisted" },
|
{ kWSAQosReceivers, "QOS receivers" },
|
{ kWSAQosSenders, "QOS senders" },
|
{ kWSAQosNoSenders, "QOS no senders" },
|
{ kWSAQosNoReceivers, "QOS no receivers" },
|
{ kWSAQosRequestConfirmed, "QOS request confirmed" },
|
{ kWSAQosAdmissionFailure, "QOS admission failure" },
|
{ kWSAQosPolicyFailure, "QOS policy failure" },
|
{ kWSAQosBadStyle, "QOS bad style" },
|
{ kWSAQosBadObject, "QOS bad object" },
|
{ kWSAQosTrafficCtrlError, "QOS traffic ctrl error" },
|
{ kWSAQosGenericError, "QOS generic error" },
|
{ kWSAQosEservicetype, "QOS eservicetype" },
|
{ kWSAQosEflowspec, "QOS eflowspec" },
|
{ kWSAQosEprovspecbuf, "QOS eprovspecbuf" },
|
{ kWSAQosEfilterstyle, "QOS efilterstyle" },
|
{ kWSAQosEfiltertype, "QOS efiltertype" },
|
{ kWSAQosEfiltercount, "QOS efiltercount" },
|
{ kWSAQosEobjlength, "QOS eobjlength" },
|
{ kWSAQosEflowcount, "QOS eflowcount" },
|
{ kWSAQosEunknownpsobj, "QOS eunknownpsobj" },
|
{ kWSAQosEpolicyobj, "QOS epolicyobj" },
|
{ kWSAQosEflowdesc, "QOS eflowdesc" },
|
{ kWSAQosEpsflowspec, "QOS epsflowspec" },
|
{ kWSAQosEpsfilterspec, "QOS epsfilterspec" },
|
{ kWSAQosEsdmodeobj, "QOS esdmodeobj" },
|
{ kWSAQosEshaperateobj, "QOS eshaperateobj" },
|
{ kWSAQosReservedPetype, "QOS reserved petype" },
|
{ kErrorIpsecQmPolicyExists, "IPSEC qm policy exists" },
|
{ kErrorIpsecQmPolicyNotFound, "IPSEC qm policy not found" },
|
{ kErrorIpsecQmPolicyInUse, "IPSEC qm policy in use" },
|
{ kErrorIpsecMmPolicyExists, "IPSEC mm policy exists" },
|
{ kErrorIpsecMmPolicyNotFound, "IPSEC mm policy not found" },
|
{ kErrorIpsecMmPolicyInUse, "IPSEC mm policy in use" },
|
{ kErrorIpsecMmFilterExists, "IPSEC mm filter exists" },
|
{ kErrorIpsecMmFilterNotFound, "IPSEC mm filter not found" },
|
{ kErrorIpsecTransportFilterExists, "IPSEC transport filter exists" },
|
{ kErrorIpsecTransportFilterNotFound, "IPSEC transport filter not found" },
|
{ kErrorIpsecMmAuthExists, "IPSEC mm auth exists" },
|
{ kErrorIpsecMmAuthNotFound, "IPSEC mm auth not found" },
|
{ kErrorIpsecMmAuthInUse, "IPSEC mm auth in use" },
|
{ kErrorIpsecDefaultMmPolicyNotFound, "IPSEC default mm policy not found" },
|
{ kErrorIpsecDefaultMmAuthNotFound, "IPSEC default mm auth not found" },
|
{ kErrorIpsecDefaultQmPolicyNotFound, "IPSEC default qm policy not found" },
|
{ kErrorIpsecTunnelFilterExists, "IPSEC tunnel filter exists" },
|
{ kErrorIpsecTunnelFilterNotFound, "IPSEC tunnel filter not found" },
|
{ kErrorIpsecMmFilterPendingDeletion, "IPSEC mm filter pending deletion" },
|
{ kErrorIpsecTransportFilterPendingDeletion, "IPSEC transport filter pending deletion" },
|
{ kErrorIpsecTunnelFilterPendingDeletion, "IPSEC tunnel filter pending deletion" },
|
{ kErrorIpsecMmPolicyPendingDeletion, "IPSEC mm policy pending deletion" },
|
{ kErrorIpsecMmAuthPendingDeletion, "IPSEC mm auth pending deletion" },
|
{ kErrorIpsecQmPolicyPendingDeletion, "IPSEC qm policy pending deletion" },
|
{ kErrorIpsecIkeAuthFail, "IPSEC IKE auth fail" },
|
{ kErrorIpsecIkeAttribFail, "IPSEC IKE attrib fail" },
|
{ kErrorIpsecIkeNegotiationPending, "IPSEC IKE negotiation pending" },
|
{ kErrorIpsecIkeGeneralProcessingError, "IPSEC IKE general processing error" },
|
{ kErrorIpsecIkeTimedOut, "IPSEC IKE timed out" },
|
{ kErrorIpsecIkeNoCert, "IPSEC IKE no cert" },
|
{ kErrorIpsecIkeSaDeleted, "IPSEC IKE sa deleted" },
|
{ kErrorIpsecIkeSaReaped, "IPSEC IKE sa reaped" },
|
{ kErrorIpsecIkeMmAcquireDrop, "IPSEC IKE mm acquire drop" },
|
{ kErrorIpsecIkeQmAcquireDrop, "IPSEC IKE qm acquire drop" },
|
{ kErrorIpsecIkeQueueDropMm, "IPSEC IKE queue drop mm" },
|
{ kErrorIpsecIkeQueueDropNoMm, "IPSEC IKE queue drop no mm" },
|
{ kErrorIpsecIkeDropNoResponse, "IPSEC IKE drop no response" },
|
{ kErrorIpsecIkeMmDelayDrop, "IPSEC IKE mm delay drop" },
|
{ kErrorIpsecIkeQmDelayDrop, "IPSEC IKE qm delay drop" },
|
{ kErrorIpsecIkeError, "IPSEC IKE error" },
|
{ kErrorIpsecIkeCrlFailed, "IPSEC IKE crl failed" },
|
{ kErrorIpsecIkeInvalidKeyUsage, "IPSEC IKE invalid key usage" },
|
{ kErrorIpsecIkeInvalidCertType, "IPSEC IKE invalid cert type" },
|
{ kErrorIpsecIkeNoPrivateKey, "IPSEC IKE no private key" },
|
{ kErrorIpsecIkeDhFail, "IPSEC IKE dh fail" },
|
{ kErrorIpsecIkeInvalidHeader, "IPSEC IKE invalid header" },
|
{ kErrorIpsecIkeNoPolicy, "IPSEC IKE no policy" },
|
{ kErrorIpsecIkeInvalidSignature, "IPSEC IKE invalid signature" },
|
{ kErrorIpsecIkeKerberosError, "IPSEC IKE kerberos error" },
|
{ kErrorIpsecIkeNoPublicKey, "IPSEC IKE no public key" },
|
{ kErrorIpsecIkeProcessErr, "IPSEC IKE process err" },
|
{ kErrorIpsecIkeProcessErrSa, "IPSEC IKE process err sa" },
|
{ kErrorIpsecIkeProcessErrProp, "IPSEC IKE process err prop" },
|
{ kErrorIpsecIkeProcessErrTrans, "IPSEC IKE process err trans" },
|
{ kErrorIpsecIkeProcessErrKe, "IPSEC IKE process err ke" },
|
{ kErrorIpsecIkeProcessErrId, "IPSEC IKE process err ID" },
|
{ kErrorIpsecIkeProcessErrCert, "IPSEC IKE process err cert" },
|
{ kErrorIpsecIkeProcessErrCertReq, "IPSEC IKE process err cert req" },
|
{ kErrorIpsecIkeProcessErrHash, "IPSEC IKE process err hash" },
|
{ kErrorIpsecIkeProcessErrSig, "IPSEC IKE process err sig" },
|
{ kErrorIpsecIkeProcessErrNonce, "IPSEC IKE process err nonce" },
|
{ kErrorIpsecIkeProcessErrNotify, "IPSEC IKE process err notify" },
|
{ kErrorIpsecIkeProcessErrDelete, "IPSEC IKE process err delete" },
|
{ kErrorIpsecIkeProcessErrVendor, "IPSEC IKE process err vendor" },
|
{ kErrorIpsecIkeInvalidPayload, "IPSEC IKE invalid payload" },
|
{ kErrorIpsecIkeLoadSoftSa, "IPSEC IKE load soft sa" },
|
{ kErrorIpsecIkeSoftSaTornDown, "IPSEC IKE soft sa torn down" },
|
{ kErrorIpsecIkeInvalidCookie, "IPSEC IKE invalid cookie" },
|
{ kErrorIpsecIkeNoPeerCert, "IPSEC IKE no peer cert" },
|
{ kErrorIpsecIkePeerCrlFailed, "IPSEC IKE peer CRL failed" },
|
{ kErrorIpsecIkePolicyChange, "IPSEC IKE policy change" },
|
{ kErrorIpsecIkeNoMmPolicy, "IPSEC IKE no mm policy" },
|
{ kErrorIpsecIkeNotcbpriv, "IPSEC IKE notcbpriv" },
|
{ kErrorIpsecIkeSecloadfail, "IPSEC IKE secloadfail" },
|
{ kErrorIpsecIkeFailsspinit, "IPSEC IKE failsspinit" },
|
{ kErrorIpsecIkeFailqueryssp, "IPSEC IKE failqueryssp" },
|
{ kErrorIpsecIkeSrvacqfail, "IPSEC IKE srvacqfail" },
|
{ kErrorIpsecIkeSrvquerycred, "IPSEC IKE srvquerycred" },
|
{ kErrorIpsecIkeGetspifail, "IPSEC IKE getspifail" },
|
{ kErrorIpsecIkeInvalidFilter, "IPSEC IKE invalid filter" },
|
{ kErrorIpsecIkeOutOfMemory, "IPSEC IKE out of memory" },
|
{ kErrorIpsecIkeAddUpdateKeyFailed, "IPSEC IKE add update key failed" },
|
{ kErrorIpsecIkeInvalidPolicy, "IPSEC IKE invalid policy" },
|
{ kErrorIpsecIkeUnknownDoi, "IPSEC IKE unknown doi" },
|
{ kErrorIpsecIkeInvalidSituation, "IPSEC IKE invalid situation" },
|
{ kErrorIpsecIkeDhFailure, "IPSEC IKE dh failure" },
|
{ kErrorIpsecIkeInvalidGroup, "IPSEC IKE invalid group" },
|
{ kErrorIpsecIkeEncrypt, "IPSEC IKE encrypt" },
|
{ kErrorIpsecIkeDecrypt, "IPSEC IKE decrypt" },
|
{ kErrorIpsecIkePolicyMatch, "IPSEC IKE policy match" },
|
{ kErrorIpsecIkeUnsupportedId, "IPSEC IKE unsupported ID" },
|
{ kErrorIpsecIkeInvalidHash, "IPSEC IKE invalid hash" },
|
{ kErrorIpsecIkeInvalidHashAlg, "IPSEC IKE invalid hash alg" },
|
{ kErrorIpsecIkeInvalidHashSize, "IPSEC IKE invalid hash size" },
|
{ kErrorIpsecIkeInvalidEncryptAlg, "IPSEC IKE invalid encrypt alg" },
|
{ kErrorIpsecIkeInvalidAuthAlg, "IPSEC IKE invalid auth alg" },
|
{ kErrorIpsecIkeInvalidSig, "IPSEC IKE invalid sig" },
|
{ kErrorIpsecIkeLoadFailed, "IPSEC IKE load failed" },
|
{ kErrorIpsecIkeRpcDelete, "IPSEC IKE rpc delete" },
|
{ kErrorIpsecIkeBenignReinit, "IPSEC IKE benign reinit" },
|
{ kErrorIpsecIkeInvalidResponderLifetimeNotify, "IPSEC IKE invalid responder lifetime notify" },
|
{ kErrorIpsecIkeInvalidCertKeylen, "IPSEC IKE invalid cert keylen" },
|
{ kErrorIpsecIkeMmLimit, "IPSEC IKE mm limit" },
|
{ kErrorIpsecIkeNegotiationDisabled, "IPSEC IKE negotiation disabled" },
|
{ kErrorIpsecIkeNegStatusEnd, "IPSEC IKE neg status end" },
|
{ kErrorSxsSectionNotFound, "Sxs section not found" },
|
{ kErrorSxsCantGenActctx, "Sxs can't gen actctx" },
|
{ kErrorSxsInvalidActctxdataFormat, "Sxs invalid actctxdata format" },
|
{ kErrorSxsAssemblyNotFound, "Sxs assembly not found" },
|
{ kErrorSxsManifestFormatError, "Sxs manifest format error" },
|
{ kErrorSxsManifestParseError, "Sxs manifest parse error" },
|
{ kErrorSxsActivationContextDisabled, "Sxs activation context disabled" },
|
{ kErrorSxsKeyNotFound, "Sxs key not found" },
|
{ kErrorSxsVersionConflict, "Sxs version conflict" },
|
{ kErrorSxsWrongSectionType, "Sxs wrong section type" },
|
{ kErrorSxsThreadQueriesDisabled, "Sxs thread queries disabled" },
|
{ kErrorSxsProcessDefaultAlreadySet, "Sxs process default already set" },
|
{ kErrorSxsUnknownEncodingGroup, "Sxs unknown encoding group" },
|
{ kErrorSxsUnknownEncoding, "Sxs unknown encoding" },
|
{ kErrorSxsInvalidXmlNamespaceUri, "Sxs invalid XML namespace URI" },
|
{ kErrorSxsRootManifestDependencyNotInstalled, "Sxs root manifest dependency not installed" },
|
{ kErrorSxsLeafManifestDependencyNotInstalled, "Sxs leaf manifest dependency not installed" },
|
{ kErrorSxsInvalidAssemblyIdentityAttribute, "Sxs invalid assembly indentity attribute" },
|
{ kErrorSxsManifestMissingRequiredDefaultNamespace, "Sxs manifest missing required default namespace" },
|
{ kErrorSxsManifestInvalidRequiredDefaultNamespace, "Sxs manifest invalid required default namespace" },
|
{ kErrorSxsPrivateManifestCrossPathWithReparsePoint, "Sxs private manifest cross path with reparse point" },
|
{ kErrorSxsDuplicateDllName, "Sxs duplicate dll name" },
|
{ kErrorSxsDuplicateWindowclassName, "Sxs duplicate windowclass name" },
|
{ kErrorSxsDuplicateClsid, "Sxs duplicate clsid" },
|
{ kErrorSxsDuplicateIid, "Sxs duplicate iid" },
|
{ kErrorSxsDuplicateTlbid, "Sxs duplicate tlbid" },
|
{ kErrorSxsDuplicateProgid, "Sxs duplicate progid" },
|
{ kErrorSxsDuplicateAssemblyName, "Sxs duplicate assembly name" },
|
{ kErrorSxsFileHashMismatch, "Sxs file hash mismatch" },
|
{ kErrorSxsPolicyParseError, "Sxs policy parse error" },
|
{ kErrorSxsXmlEMissingquote, "Sxs XML e missingquote" },
|
{ kErrorSxsXmlECommentsyntax, "Sxs XML e commentsyntax" },
|
{ kErrorSxsXmlEBadstartnamechar, "Sxs XML e badstartnamechar" },
|
{ kErrorSxsXmlEBadnamechar, "Sxs XML e badnamechar" },
|
{ kErrorSxsXmlEBadcharinstring, "Sxs XML e badcharinstring" },
|
{ kErrorSxsXmlEXmldeclsyntax, "Sxs XML e xmldeclsyntax" },
|
{ kErrorSxsXmlEBadchardata, "Sxs XML e badchardata" },
|
{ kErrorSxsXmlEMissingwhitespace, "Sxs XML e missingwhitespace" },
|
{ kErrorSxsXmlEExpectingtagend, "Sxs XML e expectingtagend" },
|
{ kErrorSxsXmlEMissingsemicolon, "Sxs XML e missingsemicolon" },
|
{ kErrorSxsXmlEUnbalancedparen, "Sxs XML e unbalancedparen" },
|
{ kErrorSxsXmlEInternalerror, "Sxs XML e internalerror" },
|
{ kErrorSxsXmlEUnexpectedWhitespace, "Sxs XML e unexpected whitespace" },
|
{ kErrorSxsXmlEIncompleteEncoding, "Sxs XML e incomplete encoding" },
|
{ kErrorSxsXmlEMissingParen, "Sxs XML e missing paren" },
|
{ kErrorSxsXmlEExpectingclosequote, "Sxs XML e expectingclosequote" },
|
{ kErrorSxsXmlEMultipleColons, "Sxs XML e multiple colons" },
|
{ kErrorSxsXmlEInvalidDecimal, "Sxs XML e invalid decimal" },
|
{ kErrorSxsXmlEInvalidHexidecimal, "Sxs XML e invalid hexidecimal" },
|
{ kErrorSxsXmlEInvalidUnicode, "Sxs XML e invalid unicode" },
|
{ kErrorSxsXmlEWhitespaceorquestionmark, "Sxs XML e whitespaceorquestionmark" },
|
{ kErrorSxsXmlEUnexpectedendtag, "Sxs XML e unexpectedendtag" },
|
{ kErrorSxsXmlEUnclosedtag, "Sxs XML e unclosedtag" },
|
{ kErrorSxsXmlEDuplicateattribute, "Sxs XML e duplicateattribute" },
|
{ kErrorSxsXmlEMultipleroots, "Sxs XML e multipleroots" },
|
{ kErrorSxsXmlEInvalidatrootlevel, "Sxs XML e invalidatrootlevel" },
|
{ kErrorSxsXmlEBadxmldecl, "Sxs XML e badxmldecl" },
|
{ kErrorSxsXmlEMissingroot, "Sxs XML e missingroot" },
|
{ kErrorSxsXmlEUnexpectedeof, "Sxs XML e unexpectedeof" },
|
{ kErrorSxsXmlEBadperefinsubset, "Sxs XML e badperefinsubset" },
|
{ kErrorSxsXmlEUnclosedstarttag, "Sxs XML e unclosedstarttag" },
|
{ kErrorSxsXmlEUnclosedendtag, "Sxs XML e unclosedendtag" },
|
{ kErrorSxsXmlEUnclosedstring, "Sxs XML e unclosedstring" },
|
{ kErrorSxsXmlEUnclosedcomment, "Sxs XML e unclosedcomment" },
|
{ kErrorSxsXmlEUncloseddecl, "Sxs XML e uncloseddecl" },
|
{ kErrorSxsXmlEUnclosedcdata, "Sxs XML e unclosedcdata" },
|
{ kErrorSxsXmlEReservednamespace, "Sxs XML e reservednamespace" },
|
{ kErrorSxsXmlEInvalidencoding, "Sxs XML e invalidencoding" },
|
{ kErrorSxsXmlEInvalidswitch, "Sxs XML e invalidswitch" },
|
{ kErrorSxsXmlEBadxmlcase, "Sxs XML e badxmlcase" },
|
{ kErrorSxsXmlEInvalidStandalone, "Sxs XML e invalid standalone" },
|
{ kErrorSxsXmlEUnexpectedStandalone, "Sxs XML e unexpected standalone" },
|
{ kErrorSxsXmlEInvalidVersion, "Sxs XML e invalid version" },
|
{ kErrorSxsXmlEMissingequals, "Sxs XML e missingequals" },
|
{ kErrorSxsProtectionRecoveryFailed, "Sxs protection recovery failed" },
|
{ kErrorSxsProtectionPublicKeyTooShort, "Sxs protection public key too short" },
|
{ kErrorSxsProtectionCatalogNotValid, "Sxs protection catalog not valid" },
|
{ kErrorSxsUntranslatableHresult, "Sxs untranslatable hresult" },
|
{ kErrorSxsProtectionCatalogFileMissing, "Sxs protection catalog file missing" },
|
{ kErrorSxsMissingAssemblyIdentityAttribute, "Sxs missing assembly identity attribute" },
|
{ kErrorSxsInvalidAssemblyIdentityAttributeName, "Sxs invalid assembly identity attribute name" },
|
};
|
#endif /* IL2CPP_DISABLE_FULL_MESSAGES */
|
|
|
static int32_t compare_message(const void *first, const void *second)
|
{
|
ErrorDesc *efirst = (ErrorDesc*)first;
|
ErrorDesc *esecond = (ErrorDesc*)second;
|
|
return (int32_t)efirst->code - (int32_t)esecond->code;
|
}
|
|
static const char *find_message(ErrorCode code, ErrorDesc *list, int32_t count)
|
{
|
ErrorDesc key = { code, "" };
|
ErrorDesc *result = (ErrorDesc*)bsearch(&key, list, count, sizeof(ErrorDesc), compare_message);
|
return result ? result->message : NULL;
|
}
|
|
static const char *find_message_linear(ErrorCode code, ErrorDesc *list, int32_t count)
|
{
|
int32_t prev = -1;
|
|
for (int32_t i = 0; i < count; ++i)
|
{
|
if (list[i].code > prev)
|
prev = list[i].code;
|
else
|
{
|
// static int error_shown;
|
// if (!error_shown){
|
// error_shown = 1;
|
// fprintf (stderr, "Mono: Incorrect message sorted in io-layer/messages.c at index %d (msg=%s)\n", i, list [i].txt);
|
// }
|
}
|
|
if (list[i].code == code)
|
{
|
// static int error_shown;
|
// if (!error_shown){
|
// error_shown = 1;
|
// fprintf (stderr, "Mono: Error %d with text %s is improperly sorted in io-layer/messages.c\n", id, list [i].txt);
|
// }
|
return list[i].message;
|
}
|
}
|
return NULL;
|
}
|
|
std::string Messages::FromCode(ErrorCode code)
|
{
|
const char *message = find_message(code, common_messages, N_ELEMENTS(common_messages));
|
if (message != NULL)
|
return message;
|
|
#ifndef IL2CPP_DISABLE_FULL_MESSAGES
|
message = find_message(code, messages, N_ELEMENTS(messages));
|
if (message != NULL)
|
return message;
|
#endif
|
|
// Linear search, in case someone adds an error message and does not add it
|
// to the list in a sorted position, this will be catched during development.
|
|
message = find_message_linear(code, common_messages, N_ELEMENTS(common_messages));
|
if (message != NULL)
|
return message;
|
|
#ifndef IL2CPP_DISABLE_FULL_MESSAGES
|
message = find_message_linear(code, messages, N_ELEMENTS(messages));
|
if (message != NULL)
|
return message;
|
#endif
|
|
return std::string();
|
}
|
}
|
}
|
