diff options
Diffstat (limited to 'toolkit/crashreporter/breakpad-patches')
26 files changed, 36751 insertions, 0 deletions
diff --git a/toolkit/crashreporter/breakpad-patches/00-arm-exidx-rollup.patch b/toolkit/crashreporter/breakpad-patches/00-arm-exidx-rollup.patch new file mode 100644 index 0000000000..33ae81f3df --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/00-arm-exidx-rollup.patch @@ -0,0 +1,1352 @@ +diff --git a/Makefile.am b/Makefile.am +index 9a25d9d4..07206601 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -571,6 +571,8 @@ src_tools_linux_core2md_core2md_LDADD = \ + src/client/linux/libbreakpad_client.a + + src_tools_linux_dump_syms_dump_syms_SOURCES = \ ++ src/common/arm_ex_reader.cc \ ++ src/common/arm_ex_to_module.cc \ + src/common/dwarf_cfi_to_module.cc \ + src/common/dwarf_cu_to_module.cc \ + src/common/dwarf_line_to_module.cc \ +@@ -660,6 +662,8 @@ src_tools_mac_dump_syms_dump_syms_mac_LDADD= \ + $(RUST_DEMANGLE_LIBS) + + src_common_dumper_unittest_SOURCES = \ ++ src/common/arm_ex_reader.cc \ ++ src/common/arm_ex_to_module.cc \ + src/common/byte_cursor_unittest.cc \ + src/common/convert_UTF.cc \ + src/common/dwarf_cfi_to_module.cc \ +@@ -1348,6 +1352,10 @@ EXTRA_DIST = \ + src/client/windows/sender/crash_report_sender.cc \ + src/client/windows/sender/crash_report_sender.h \ + src/client/windows/sender/crash_report_sender.gyp \ ++ src/common/arm_ex_reader.cc \ ++ src/common/arm_ex_reader.h \ ++ src/common/arm_ex_to_module.cc \ ++ src/common/arm_ex_to_module.h \ + src/common/dwarf/dwarf2diehandler.h \ + src/common/dwarf/dwarf2enums.h \ + src/common/dwarf/line_state_machine.h \ +diff --git a/src/common/arm_ex_reader.cc b/src/common/arm_ex_reader.cc +new file mode 100644 +index 00000000..2d1ed983 +--- /dev/null ++++ b/src/common/arm_ex_reader.cc +@@ -0,0 +1,487 @@ ++ ++/* libunwind - a platform-independent unwind library ++ Copyright 2011 Linaro Limited ++ ++This file is part of libunwind. ++ ++Permission is hereby granted, free of charge, to any person obtaining ++a copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to ++permit persons to whom the Software is furnished to do so, subject to ++the following conditions: ++ ++The above copyright notice and this permission notice shall be ++included in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ++LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ++OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ++WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ++ ++// Copyright (c) 2010 Google Inc. ++// All rights reserved. ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++ ++// Derived from libunwind, with extensive modifications. ++ ++ ++#include "common/arm_ex_reader.h" ++ ++#include <assert.h> ++#include <stdio.h> ++ ++// This file, in conjunction with arm_ex_to_module.cc, translates ++// EXIDX unwind information into the same format that Breakpad uses ++// for CFI information. Hence Breakpad's CFI unwinding abilities ++// also become usable for EXIDX. ++// ++// See: "Exception Handling ABI for the ARM Architecture", ARM IHI 0038A ++// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf ++ ++// EXIDX data is presented in two parts: ++// ++// * an index table. This contains two words per routine, ++// the first of which identifies the routine, and the second ++// of which is a reference to the unwind bytecode. If the ++// bytecode is very compact -- 3 bytes or less -- it can be ++// stored directly in the second word. ++// ++// * an area containing the unwind bytecodes. ++ ++// General flow is: ExceptionTableInfo::Start iterates over all ++// of the index table entries (pairs). For each entry, it: ++// ++// * calls ExceptionTableInfo::ExtabEntryExtract to copy the bytecode ++// out into an intermediate buffer. ++ ++// * uses ExceptionTableInfo::ExtabEntryDecode to parse the intermediate ++// buffer. Each bytecode instruction is bundled into a ++// arm_ex_to_module::extab_data structure, and handed to .. ++// ++// * .. ARMExToModule::ImproveStackFrame, which in turn hands it to ++// ARMExToModule::TranslateCmd, and that generates the pseudo-CFI ++// records that Breakpad stores. ++ ++#define ARM_EXIDX_CANT_UNWIND 0x00000001 ++#define ARM_EXIDX_COMPACT 0x80000000 ++#define ARM_EXTBL_OP_FINISH 0xb0 ++#define ARM_EXIDX_TABLE_LIMIT (255*4) ++ ++namespace arm_ex_reader { ++ ++using arm_ex_to_module::ARM_EXIDX_CMD_FINISH; ++using arm_ex_to_module::ARM_EXIDX_CMD_SUB_FROM_VSP; ++using arm_ex_to_module::ARM_EXIDX_CMD_ADD_TO_VSP; ++using arm_ex_to_module::ARM_EXIDX_CMD_REG_POP; ++using arm_ex_to_module::ARM_EXIDX_CMD_REG_TO_SP; ++using arm_ex_to_module::ARM_EXIDX_CMD_VFP_POP; ++using arm_ex_to_module::ARM_EXIDX_CMD_WREG_POP; ++using arm_ex_to_module::ARM_EXIDX_CMD_WCGR_POP; ++using arm_ex_to_module::ARM_EXIDX_CMD_RESERVED; ++using arm_ex_to_module::ARM_EXIDX_CMD_REFUSED; ++using arm_ex_to_module::exidx_entry; ++using arm_ex_to_module::ARM_EXIDX_VFP_SHIFT_16; ++using arm_ex_to_module::ARM_EXIDX_VFP_FSTMD; ++using google_breakpad::MemoryRange; ++ ++ ++static void* Prel31ToAddr(const void* addr) { ++ uint32_t offset32 = *reinterpret_cast<const uint32_t*>(addr); ++ // sign extend offset32[30:0] to 64 bits -- copy bit 30 to positions ++ // 63:31 inclusive. ++ uint64_t offset64 = offset32; ++ if (offset64 & (1ULL << 30)) ++ offset64 |= 0xFFFFFFFF80000000ULL; ++ else ++ offset64 &= 0x000000007FFFFFFFULL; ++ return ((char*)addr) + (uintptr_t)offset64; ++} ++ ++ ++// Extract unwind bytecode for the function denoted by |entry| into |buf|, ++// and return the number of bytes of |buf| written, along with a code ++// indicating the outcome. ++ ++ExceptionTableInfo::ExExtractResult ExceptionTableInfo::ExtabEntryExtract( ++ const struct exidx_entry* entry, ++ uint8_t* buf, size_t buf_size, ++ size_t* buf_used) { ++ MemoryRange mr_out(buf, buf_size); ++ ++ *buf_used = 0; ++ ++# define PUT_BUF_U8(_byte) \ ++ do { if (!mr_out.Covers(*buf_used, 1)) return ExOutBufOverflow; \ ++ buf[(*buf_used)++] = (_byte); } while (0) ++ ++# define GET_EX_U32(_lval, _addr, _sec_mr) \ ++ do { if (!(_sec_mr).Covers(reinterpret_cast<const uint8_t*>(_addr) \ ++ - (_sec_mr).data(), 4)) \ ++ return ExInBufOverflow; \ ++ (_lval) = *(reinterpret_cast<const uint32_t*>(_addr)); } while (0) ++ ++# define GET_EXIDX_U32(_lval, _addr) \ ++ GET_EX_U32(_lval, _addr, mr_exidx_) ++# define GET_EXTAB_U32(_lval, _addr) \ ++ GET_EX_U32(_lval, _addr, mr_extab_) ++ ++ uint32_t data; ++ GET_EXIDX_U32(data, &entry->data); ++ ++ // A function can be marked CANT_UNWIND if (eg) it is known to be ++ // at the bottom of the stack. ++ if (data == ARM_EXIDX_CANT_UNWIND) ++ return ExCantUnwind; ++ ++ uint32_t pers; // personality number ++ uint32_t extra; // number of extra data words required ++ uint32_t extra_allowed; // number of extra data words allowed ++ uint32_t* extbl_data; // the handler entry, if not inlined ++ ++ if (data & ARM_EXIDX_COMPACT) { ++ // The handler table entry has been inlined into the index table entry. ++ // In this case it can only be an ARM-defined compact model, since ++ // bit 31 is 1. Only personalities 0, 1 and 2 are defined for the ++ // ARM compact model, but 1 and 2 are "Long format" and may require ++ // extra data words. Hence the allowable personalities here are: ++ // personality 0, in which case 'extra' has no meaning ++ // personality 1, with zero extra words ++ // personality 2, with zero extra words ++ extbl_data = NULL; ++ pers = (data >> 24) & 0x0F; ++ extra = (data >> 16) & 0xFF; ++ extra_allowed = 0; ++ } ++ else { ++ // The index table entry is a pointer to the handler entry. Note ++ // that Prel31ToAddr will read the given address, but we already ++ // range-checked above. ++ extbl_data = reinterpret_cast<uint32_t*>(Prel31ToAddr(&entry->data)); ++ GET_EXTAB_U32(data, extbl_data); ++ if (!(data & ARM_EXIDX_COMPACT)) { ++ // This denotes a "generic model" handler. That will involve ++ // executing arbitary machine code, which is something we ++ // can't represent here; hence reject it. ++ return ExCantRepresent; ++ } ++ // So we have a compact model representation. Again, 3 possible ++ // personalities, but this time up to 255 allowable extra words. ++ pers = (data >> 24) & 0x0F; ++ extra = (data >> 16) & 0xFF; ++ extra_allowed = 255; ++ extbl_data++; ++ } ++ ++ // Now look at the the handler table entry. The first word is ++ // |data| and subsequent words start at |*extbl_data|. The number ++ // of extra words to use is |extra|, provided that the personality ++ // allows extra words. Even if it does, none may be available -- ++ // extra_allowed is the maximum number of extra words allowed. */ ++ if (pers == 0) { ++ // "Su16" in the documentation -- 3 unwinding insn bytes ++ // |extra| has no meaning here; instead that byte is an unwind-info byte ++ PUT_BUF_U8(data >> 16); ++ PUT_BUF_U8(data >> 8); ++ PUT_BUF_U8(data); ++ } ++ else if ((pers == 1 || pers == 2) && extra <= extra_allowed) { ++ // "Lu16" or "Lu32" respectively -- 2 unwinding insn bytes, ++ // and up to 255 extra words. ++ PUT_BUF_U8(data >> 8); ++ PUT_BUF_U8(data); ++ for (uint32_t j = 0; j < extra; j++) { ++ GET_EXTAB_U32(data, extbl_data); ++ extbl_data++; ++ PUT_BUF_U8(data >> 24); ++ PUT_BUF_U8(data >> 16); ++ PUT_BUF_U8(data >> 8); ++ PUT_BUF_U8(data >> 0); ++ } ++ } ++ else { ++ // The entry is invalid. ++ return ExInvalid; ++ } ++ ++ // Make sure the entry is terminated with "FINISH" ++ if (*buf_used > 0 && buf[(*buf_used) - 1] != ARM_EXTBL_OP_FINISH) ++ PUT_BUF_U8(ARM_EXTBL_OP_FINISH); ++ ++ return ExSuccess; ++ ++# undef GET_EXTAB_U32 ++# undef GET_EXIDX_U32 ++# undef GET_U32 ++# undef PUT_BUF_U8 ++} ++ ++ ++// Take the unwind information extracted by ExtabEntryExtract ++// and parse it into frame-unwind instructions. These are as ++// specified in "Table 4, ARM-defined frame-unwinding instructions" ++// in the specification document detailed in comments at the top ++// of this file. ++// ++// This reads from |buf[0, +data_size)|. It checks for overruns of ++// the input buffer and returns a negative value if that happens, or ++// for any other failure cases. It returns zero in case of success. ++int ExceptionTableInfo::ExtabEntryDecode(const uint8_t* buf, size_t buf_size) { ++ if (buf == NULL || buf_size == 0) ++ return -1; ++ ++ MemoryRange mr_in(buf, buf_size); ++ const uint8_t* buf_initially = buf; ++ ++# define GET_BUF_U8(_lval) \ ++ do { if (!mr_in.Covers(buf - buf_initially, 1)) return -1; \ ++ (_lval) = *(buf++); } while (0) ++ ++ const uint8_t* end = buf + buf_size; ++ ++ while (buf < end) { ++ struct arm_ex_to_module::extab_data edata; ++ memset(&edata, 0, sizeof(edata)); ++ ++ uint8_t op; ++ GET_BUF_U8(op); ++ if ((op & 0xc0) == 0x00) { ++ // vsp = vsp + (xxxxxx << 2) + 4 ++ edata.cmd = ARM_EXIDX_CMD_ADD_TO_VSP; ++ edata.data = (((int)op & 0x3f) << 2) + 4; ++ } else if ((op & 0xc0) == 0x40) { ++ // vsp = vsp - (xxxxxx << 2) - 4 ++ edata.cmd = ARM_EXIDX_CMD_SUB_FROM_VSP; ++ edata.data = (((int)op & 0x3f) << 2) + 4; ++ } else if ((op & 0xf0) == 0x80) { ++ uint8_t op2; ++ GET_BUF_U8(op2); ++ if (op == 0x80 && op2 == 0x00) { ++ // Refuse to unwind ++ edata.cmd = ARM_EXIDX_CMD_REFUSED; ++ } else { ++ // Pop up to 12 integer registers under masks {r15-r12},{r11-r4} ++ edata.cmd = ARM_EXIDX_CMD_REG_POP; ++ edata.data = ((op & 0xf) << 8) | op2; ++ edata.data = edata.data << 4; ++ } ++ } else if ((op & 0xf0) == 0x90) { ++ if (op == 0x9d || op == 0x9f) { ++ // 9d: Reserved as prefix for ARM register to register moves ++ // 9f: Reserved as perfix for Intel Wireless MMX reg to reg moves ++ edata.cmd = ARM_EXIDX_CMD_RESERVED; ++ } else { ++ // Set vsp = r[nnnn] ++ edata.cmd = ARM_EXIDX_CMD_REG_TO_SP; ++ edata.data = op & 0x0f; ++ } ++ } else if ((op & 0xf0) == 0xa0) { ++ // Pop r4 to r[4+nnn], or ++ // Pop r4 to r[4+nnn] and r14 or ++ unsigned end = (op & 0x07); ++ edata.data = (1 << (end + 1)) - 1; ++ edata.data = edata.data << 4; ++ if (op & 0x08) edata.data |= 1 << 14; ++ edata.cmd = ARM_EXIDX_CMD_REG_POP; ++ } else if (op == ARM_EXTBL_OP_FINISH) { ++ // Finish ++ edata.cmd = ARM_EXIDX_CMD_FINISH; ++ buf = end; ++ } else if (op == 0xb1) { ++ uint8_t op2; ++ GET_BUF_U8(op2); ++ if (op2 == 0 || (op2 & 0xf0)) { ++ // Spare ++ edata.cmd = ARM_EXIDX_CMD_RESERVED; ++ } else { ++ // Pop integer registers under mask {r3,r2,r1,r0} ++ edata.cmd = ARM_EXIDX_CMD_REG_POP; ++ edata.data = op2 & 0x0f; ++ } ++ } else if (op == 0xb2) { ++ // vsp = vsp + 0x204 + (uleb128 << 2) ++ uint64_t offset = 0; ++ uint8_t byte, shift = 0; ++ do { ++ GET_BUF_U8(byte); ++ offset |= (byte & 0x7f) << shift; ++ shift += 7; ++ } while ((byte & 0x80) && buf < end); ++ edata.data = offset * 4 + 0x204; ++ edata.cmd = ARM_EXIDX_CMD_ADD_TO_VSP; ++ } else if (op == 0xb3 || op == 0xc8 || op == 0xc9) { ++ // b3: Pop VFP regs D[ssss] to D[ssss+cccc], FSTMFDX-ishly ++ // c8: Pop VFP regs D[16+ssss] to D[16+ssss+cccc], FSTMFDD-ishly ++ // c9: Pop VFP regs D[ssss] to D[ssss+cccc], FSTMFDD-ishly ++ edata.cmd = ARM_EXIDX_CMD_VFP_POP; ++ GET_BUF_U8(edata.data); ++ if (op == 0xc8) edata.data |= ARM_EXIDX_VFP_SHIFT_16; ++ if (op != 0xb3) edata.data |= ARM_EXIDX_VFP_FSTMD; ++ } else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0) { ++ // b8: Pop VFP regs D[8] to D[8+nnn], FSTMFDX-ishly ++ // d0: Pop VFP regs D[8] to D[8+nnn], FSTMFDD-ishly ++ edata.cmd = ARM_EXIDX_CMD_VFP_POP; ++ edata.data = 0x80 | (op & 0x07); ++ if ((op & 0xf8) == 0xd0) edata.data |= ARM_EXIDX_VFP_FSTMD; ++ } else if (op >= 0xc0 && op <= 0xc5) { ++ // Intel Wireless MMX pop wR[10]-wr[10+nnn], nnn != 6,7 ++ edata.cmd = ARM_EXIDX_CMD_WREG_POP; ++ edata.data = 0xa0 | (op & 0x07); ++ } else if (op == 0xc6) { ++ // Intel Wireless MMX pop wR[ssss] to wR[ssss+cccc] ++ edata.cmd = ARM_EXIDX_CMD_WREG_POP; ++ GET_BUF_U8(edata.data); ++ } else if (op == 0xc7) { ++ uint8_t op2; ++ GET_BUF_U8(op2); ++ if (op2 == 0 || (op2 & 0xf0)) { ++ // Spare ++ edata.cmd = ARM_EXIDX_CMD_RESERVED; ++ } else { ++ // Intel Wireless MMX pop wCGR registers under mask {wCGR3,2,1,0} ++ edata.cmd = ARM_EXIDX_CMD_WCGR_POP; ++ edata.data = op2 & 0x0f; ++ } ++ } else { ++ // Spare ++ edata.cmd = ARM_EXIDX_CMD_RESERVED; ++ } ++ ++ int ret = handler_->ImproveStackFrame(&edata); ++ if (ret < 0) ++ return ret; ++ } ++ return 0; ++ ++# undef GET_BUF_U8 ++} ++ ++void ExceptionTableInfo::Start() { ++ const struct exidx_entry* start ++ = reinterpret_cast<const struct exidx_entry*>(mr_exidx_.data()); ++ const struct exidx_entry* end ++ = reinterpret_cast<const struct exidx_entry*>(mr_exidx_.data() ++ + mr_exidx_.length()); ++ ++ // Iterate over each of the EXIDX entries (pairs of 32-bit words). ++ // These occupy the entire .exidx section. ++ for (const struct exidx_entry* entry = start; entry < end; ++entry) { ++ // Figure out the code address range that this table entry is ++ // associated with. ++ uint32_t addr = (reinterpret_cast<char*>(Prel31ToAddr(&entry->addr)) ++ - mapping_addr_ + loading_addr_) & 0x7fffffff; ++ uint32_t next_addr; ++ if (entry < end - 1) { ++ next_addr = (reinterpret_cast<char*>(Prel31ToAddr(&((entry + 1)->addr))) ++ - mapping_addr_ + loading_addr_) & 0x7fffffff; ++ } else { ++ // This is the last EXIDX entry in the sequence, so we don't ++ // have an address for the start of the next function, to limit ++ // this one. Instead use the address of the last byte of the ++ // text section associated with this .exidx section, that we ++ // have been given. So as to avoid junking up the CFI unwind ++ // tables with absurdly large address ranges in the case where ++ // text_last_svma_ is wrong, only use the value if it is nonzero ++ // and within one page of |addr|. Otherwise assume a length of 1. ++ // ++ // In some cases, gcc has been observed to finish the exidx ++ // section with an entry of length 1 marked CANT_UNWIND, ++ // presumably exactly for the purpose of giving a definite ++ // length for the last real entry, without having to look at ++ // text segment boundaries. ++ bool plausible = false; ++ next_addr = addr + 1; ++ if (text_last_svma_ != 0) { ++ uint32_t maybe_next_addr = text_last_svma_ + 1; ++ if (maybe_next_addr > addr && maybe_next_addr - addr <= 4096) { ++ next_addr = maybe_next_addr; ++ plausible = true; ++ } ++ } ++ if (!plausible) { ++ fprintf(stderr, "ExceptionTableInfo: implausible EXIDX last entry size " ++ "%d, using 1 instead.", (int32_t)(text_last_svma_ - addr)); ++ } ++ } ++ ++ // Extract the unwind info into |buf|. This might fail for ++ // various reasons. It involves reading both the .exidx and ++ // .extab sections. All accesses to those sections are ++ // bounds-checked. ++ uint8_t buf[ARM_EXIDX_TABLE_LIMIT]; ++ size_t buf_used = 0; ++ ExExtractResult res = ExtabEntryExtract(entry, buf, sizeof(buf), &buf_used); ++ if (res != ExSuccess) { ++ // Couldn't extract the unwind info, for some reason. Move on. ++ switch (res) { ++ case ExInBufOverflow: ++ fprintf(stderr, "ExtabEntryExtract: .exidx/.extab section overrun"); ++ break; ++ case ExOutBufOverflow: ++ fprintf(stderr, "ExtabEntryExtract: bytecode buffer overflow"); ++ break; ++ case ExCantUnwind: ++ fprintf(stderr, "ExtabEntryExtract: function is marked CANT_UNWIND"); ++ break; ++ case ExCantRepresent: ++ fprintf(stderr, "ExtabEntryExtract: bytecode can't be represented"); ++ break; ++ case ExInvalid: ++ fprintf(stderr, "ExtabEntryExtract: index table entry is invalid"); ++ break; ++ default: ++ fprintf(stderr, "ExtabEntryExtract: unknown error: %d", (int)res); ++ break; ++ } ++ continue; ++ } ++ ++ // Finally, work through the unwind instructions in |buf| and ++ // create CFI entries that Breakpad can use. This can also fail. ++ // First, add a new stack frame entry, into which ExtabEntryDecode ++ // will write the CFI entries. ++ if (!handler_->HasStackFrame(addr, next_addr - addr)) { ++ handler_->AddStackFrame(addr, next_addr - addr); ++ int ret = ExtabEntryDecode(buf, buf_used); ++ if (ret < 0) { ++ handler_->DeleteStackFrame(); ++ fprintf(stderr, "ExtabEntryDecode: failed with error code: %d", ret); ++ continue; ++ } ++ handler_->SubmitStackFrame(); ++ } ++ ++ } /* iterating over .exidx */ ++} ++ ++} // namespace arm_ex_reader +diff --git a/src/common/arm_ex_reader.h b/src/common/arm_ex_reader.h +new file mode 100644 +index 00000000..9b54e8a0 +--- /dev/null ++++ b/src/common/arm_ex_reader.h +@@ -0,0 +1,114 @@ ++/* libunwind - a platform-independent unwind library ++ Copyright 2011 Linaro Limited ++ ++This file is part of libunwind. ++ ++Permission is hereby granted, free of charge, to any person obtaining ++a copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to ++permit persons to whom the Software is furnished to do so, subject to ++the following conditions: ++ ++The above copyright notice and this permission notice shall be ++included in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ++LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ++OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ++WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ++ ++// Copyright (c) 2010 Google Inc. ++// All rights reserved. ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++ ++// Derived from libunwind, with extensive modifications. ++ ++#ifndef COMMON_ARM_EX_READER_H__ ++#define COMMON_ARM_EX_READER_H__ ++ ++#include "common/arm_ex_to_module.h" ++#include "common/memory_range.h" ++ ++namespace arm_ex_reader { ++ ++// This class is a reader for ARM unwind information ++// from .ARM.exidx and .ARM.extab sections. ++class ExceptionTableInfo { ++ public: ++ ExceptionTableInfo(const char* exidx, size_t exidx_size, ++ const char* extab, size_t extab_size, ++ uint32_t text_last_svma, ++ arm_ex_to_module::ARMExToModule* handler, ++ const char* mapping_addr, ++ uint32_t loading_addr) ++ : mr_exidx_(google_breakpad::MemoryRange(exidx, exidx_size)), ++ mr_extab_(google_breakpad::MemoryRange(extab, extab_size)), ++ text_last_svma_(text_last_svma), ++ handler_(handler), mapping_addr_(mapping_addr), ++ loading_addr_(loading_addr) { } ++ ++ ~ExceptionTableInfo() { } ++ ++ // Parses the entries in .ARM.exidx and possibly ++ // in .ARM.extab tables, reports what we find to ++ // arm_ex_to_module::ARMExToModule. ++ void Start(); ++ ++ private: ++ google_breakpad::MemoryRange mr_exidx_; ++ google_breakpad::MemoryRange mr_extab_; ++ uint32_t text_last_svma_; ++ arm_ex_to_module::ARMExToModule* handler_; ++ const char* mapping_addr_; ++ uint32_t loading_addr_; ++ ++ enum ExExtractResult { ++ ExSuccess, // success ++ ExInBufOverflow, // out-of-range while reading .exidx ++ ExOutBufOverflow, // output buffer is too small ++ ExCantUnwind, // this function is marked CANT_UNWIND ++ ExCantRepresent, // entry valid, but we can't represent it ++ ExInvalid // entry is invalid ++ }; ++ ExExtractResult ++ ExtabEntryExtract(const struct arm_ex_to_module::exidx_entry* entry, ++ uint8_t* buf, size_t buf_size, ++ size_t* buf_used); ++ ++ int ExtabEntryDecode(const uint8_t* buf, size_t buf_size); ++}; ++ ++} // namespace arm_ex_reader ++ ++#endif // COMMON_ARM_EX_READER_H__ +diff --git a/src/common/arm_ex_to_module.cc b/src/common/arm_ex_to_module.cc +new file mode 100644 +index 00000000..c326744f +--- /dev/null ++++ b/src/common/arm_ex_to_module.cc +@@ -0,0 +1,209 @@ ++ ++/* libunwind - a platform-independent unwind library ++ Copyright 2011 Linaro Limited ++ ++This file is part of libunwind. ++ ++Permission is hereby granted, free of charge, to any person obtaining ++a copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to ++permit persons to whom the Software is furnished to do so, subject to ++the following conditions: ++ ++The above copyright notice and this permission notice shall be ++included in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ++LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ++OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ++WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ++ ++// Copyright (c) 2010 Google Inc. ++// All rights reserved. ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++ ++// Derived from libunwind, with extensive modifications. ++ ++#include "common/arm_ex_to_module.h" ++ ++#include <stdio.h> ++#include <assert.h> ++ ++// For big-picture comments on how the EXIDX reader works, ++// see arm_ex_reader.cc. ++ ++#define ARM_EXBUF_START(x) (((x) >> 4) & 0x0f) ++#define ARM_EXBUF_COUNT(x) ((x) & 0x0f) ++#define ARM_EXBUF_END(x) (ARM_EXBUF_START(x) + ARM_EXBUF_COUNT(x)) ++ ++using google_breakpad::Module; ++ ++namespace arm_ex_to_module { ++ ++static const char* const regnames[] = { ++ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", ++ "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc", ++ "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", ++ "fps", "cpsr" ++}; ++ ++// Translate command from extab_data to command for Module. ++int ARMExToModule::TranslateCmd(const struct extab_data* edata, ++ Module::StackFrameEntry* entry, string& vsp) { ++ int ret = 0; ++ switch (edata->cmd) { ++ case ARM_EXIDX_CMD_FINISH: ++ /* Copy LR to PC if there isn't currently a rule for PC in force. */ ++ if (entry->initial_rules.find("pc") ++ == entry->initial_rules.end()) { ++ if (entry->initial_rules.find("lr") ++ == entry->initial_rules.end()) { ++ entry->initial_rules["pc"] = "lr"; ++ } else { ++ entry->initial_rules["pc"] = entry->initial_rules["lr"]; ++ } ++ } ++ break; ++ case ARM_EXIDX_CMD_SUB_FROM_VSP: ++ { ++ char c[16]; ++ sprintf(c, " %d -", edata->data); ++ vsp += c; ++ } ++ break; ++ case ARM_EXIDX_CMD_ADD_TO_VSP: ++ { ++ char c[16]; ++ sprintf(c, " %d +", edata->data); ++ vsp += c; ++ } ++ break; ++ case ARM_EXIDX_CMD_REG_POP: ++ for (unsigned int i = 0; i < 16; i++) { ++ if (edata->data & (1 << i)) { ++ entry->initial_rules[regnames[i]] ++ = vsp + " ^"; ++ vsp += " 4 +"; ++ } ++ } ++ /* Set cfa in case the SP got popped. */ ++ if (edata->data & (1 << 13)) { ++ vsp = entry->initial_rules["sp"]; ++ } ++ break; ++ case ARM_EXIDX_CMD_REG_TO_SP: { ++ assert (edata->data < 16); ++ const char* const regname = regnames[edata->data]; ++ if (entry->initial_rules.find(regname) == entry->initial_rules.end()) { ++ entry->initial_rules["sp"] = regname; ++ } else { ++ entry->initial_rules["sp"] = entry->initial_rules[regname]; ++ } ++ vsp = entry->initial_rules["sp"]; ++ break; ++ } ++ case ARM_EXIDX_CMD_VFP_POP: ++ /* Don't recover VFP registers, but be sure to adjust the stack ++ pointer. */ ++ for (unsigned int i = ARM_EXBUF_START(edata->data); ++ i <= ARM_EXBUF_END(edata->data); i++) { ++ vsp += " 8 +"; ++ } ++ if (!(edata->data & ARM_EXIDX_VFP_FSTMD)) { ++ vsp += " 4 +"; ++ } ++ break; ++ case ARM_EXIDX_CMD_WREG_POP: ++ for (unsigned int i = ARM_EXBUF_START(edata->data); ++ i <= ARM_EXBUF_END(edata->data); i++) { ++ vsp += " 8 +"; ++ } ++ break; ++ case ARM_EXIDX_CMD_WCGR_POP: ++ // Pop wCGR registers under mask {wCGR3,2,1,0}, hence "i < 4" ++ for (unsigned int i = 0; i < 4; i++) { ++ if (edata->data & (1 << i)) { ++ vsp += " 4 +"; ++ } ++ } ++ break; ++ case ARM_EXIDX_CMD_REFUSED: ++ case ARM_EXIDX_CMD_RESERVED: ++ ret = -1; ++ break; ++ } ++ return ret; ++} ++ ++bool ARMExToModule::HasStackFrame(uintptr_t addr, size_t size) { ++ // Invariant: the range [addr,covered) is covered by existing stack ++ // frame entries. ++ uintptr_t covered = addr; ++ while (covered < addr + size) { ++ const Module::StackFrameEntry *old_entry = ++ module_->FindStackFrameEntryByAddress(covered); ++ if (!old_entry) { ++ return false; ++ } ++ covered = old_entry->address + old_entry->size; ++ } ++ return true; ++} ++ ++void ARMExToModule::AddStackFrame(uintptr_t addr, size_t size) { ++ stack_frame_entry_ = new Module::StackFrameEntry; ++ stack_frame_entry_->address = addr; ++ stack_frame_entry_->size = size; ++ stack_frame_entry_->initial_rules[".cfa"] = "sp"; ++ vsp_ = "sp"; ++} ++ ++int ARMExToModule::ImproveStackFrame(const struct extab_data* edata) { ++ return TranslateCmd(edata, stack_frame_entry_, vsp_) ; ++} ++ ++void ARMExToModule::DeleteStackFrame() { ++ delete stack_frame_entry_; ++} ++ ++void ARMExToModule::SubmitStackFrame() { ++ // return address always winds up in pc ++ stack_frame_entry_->initial_rules[".ra"] ++ = stack_frame_entry_->initial_rules["pc"]; ++ // the final value of vsp is the new value of sp ++ stack_frame_entry_->initial_rules["sp"] = vsp_; ++ module_->AddStackFrameEntry(stack_frame_entry_); ++} ++ ++} // namespace arm_ex_to_module +diff --git a/src/common/arm_ex_to_module.h b/src/common/arm_ex_to_module.h +new file mode 100644 +index 00000000..f413a16a +--- /dev/null ++++ b/src/common/arm_ex_to_module.h +@@ -0,0 +1,119 @@ ++/* libunwind - a platform-independent unwind library ++ Copyright 2011 Linaro Limited ++ ++This file is part of libunwind. ++ ++Permission is hereby granted, free of charge, to any person obtaining ++a copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to ++permit persons to whom the Software is furnished to do so, subject to ++the following conditions: ++ ++The above copyright notice and this permission notice shall be ++included in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ++LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ++OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ++WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ++ ++// Copyright (c) 2010 Google Inc. ++// All rights reserved. ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++ ++// Derived from libunwind, with extensive modifications. ++ ++#ifndef COMMON_ARM_EX_TO_MODULE__ ++#define COMMON_ARM_EX_TO_MODULE__ ++ ++#include "common/module.h" ++ ++#include <string.h> ++ ++namespace arm_ex_to_module { ++ ++using google_breakpad::Module; ++ ++typedef enum extab_cmd { ++ ARM_EXIDX_CMD_FINISH, ++ ARM_EXIDX_CMD_SUB_FROM_VSP, ++ ARM_EXIDX_CMD_ADD_TO_VSP, ++ ARM_EXIDX_CMD_REG_POP, ++ ARM_EXIDX_CMD_REG_TO_SP, ++ ARM_EXIDX_CMD_VFP_POP, ++ ARM_EXIDX_CMD_WREG_POP, ++ ARM_EXIDX_CMD_WCGR_POP, ++ ARM_EXIDX_CMD_RESERVED, ++ ARM_EXIDX_CMD_REFUSED, ++} extab_cmd_t; ++ ++struct exidx_entry { ++ uint32_t addr; ++ uint32_t data; ++}; ++ ++struct extab_data { ++ extab_cmd_t cmd; ++ uint32_t data; ++}; ++ ++enum extab_cmd_flags { ++ ARM_EXIDX_VFP_SHIFT_16 = 1 << 16, ++ ARM_EXIDX_VFP_FSTMD = 1 << 17, // distinguishes FSTMxxD from FSTMxxX ++}; ++ ++// Receives information from arm_ex_reader::ExceptionTableInfo ++// and adds it to the Module object ++class ARMExToModule { ++ public: ++ ARMExToModule(Module* module) ++ : module_(module) { } ++ ~ARMExToModule() { } ++ bool HasStackFrame(uintptr_t addr, size_t size); ++ void AddStackFrame(uintptr_t addr, size_t size); ++ int ImproveStackFrame(const struct extab_data* edata); ++ void DeleteStackFrame(); ++ void SubmitStackFrame(); ++ private: ++ Module* module_; ++ Module::StackFrameEntry* stack_frame_entry_; ++ string vsp_; ++ int TranslateCmd(const struct extab_data* edata, ++ Module::StackFrameEntry* entry, ++ string& vsp); ++}; ++ ++} // namespace arm_ex_to_module ++ ++#endif // COMMON_ARM_EX_TO_MODULE__ +diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc +index 0eea2b54..e398f7b3 100644 +--- a/src/common/linux/dump_symbols.cc ++++ b/src/common/linux/dump_symbols.cc +@@ -54,6 +54,7 @@ + #include <utility> + #include <vector> + ++#include "common/arm_ex_reader.h" + #include "common/dwarf/bytereader-inl.h" + #include "common/dwarf/dwarf2diehandler.h" + #include "common/dwarf_cfi_to_module.h" +@@ -76,6 +77,11 @@ + #endif + #include "common/using_std_string.h" + ++#ifndef SHT_ARM_EXIDX ++// bionic and older glibc don't define this ++# define SHT_ARM_EXIDX (SHT_LOPROC + 1) ++#endif ++ + // This namespace contains helper functions. + namespace { + +@@ -429,6 +435,52 @@ bool LoadDwarfCFI(const string& dwarf_filename, + return true; + } + ++template<typename ElfClass> ++bool LoadARMexidx(const typename ElfClass::Ehdr* elf_header, ++ const typename ElfClass::Shdr* exidx_section, ++ const typename ElfClass::Shdr* extab_section, ++ uint32_t loading_addr, ++ Module* module) { ++ // To do this properly we need to know: ++ // * the bounds of the .ARM.exidx section in the mapped image ++ // * the bounds of the .ARM.extab section in the mapped image ++ // * the vma of the last byte in the text section associated with the .exidx ++ // The first two are easy. The third is a bit tricky. If we can't ++ // figure out what it is, just pass in zero. ++ const char *exidx_img ++ = GetOffset<ElfClass, char>(elf_header, exidx_section->sh_offset); ++ size_t exidx_size = exidx_section->sh_size; ++ const char *extab_img ++ = GetOffset<ElfClass, char>(elf_header, extab_section->sh_offset); ++ size_t extab_size = extab_section->sh_size; ++ ++ // The sh_link field of the exidx section gives the section number ++ // for the associated text section. ++ uint32_t exidx_text_last_svma = 0; ++ int exidx_text_sno = exidx_section->sh_link; ++ typedef typename ElfClass::Shdr Shdr; ++ // |sections| points to the section header table ++ const Shdr* sections ++ = GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff); ++ const int num_sections = elf_header->e_shnum; ++ if (exidx_text_sno >= 0 && exidx_text_sno < num_sections) { ++ const Shdr* exidx_text_shdr = §ions[exidx_text_sno]; ++ if (exidx_text_shdr->sh_size > 0) { ++ exidx_text_last_svma ++ = exidx_text_shdr->sh_addr + exidx_text_shdr->sh_size - 1; ++ } ++ } ++ ++ arm_ex_to_module::ARMExToModule handler(module); ++ arm_ex_reader::ExceptionTableInfo ++ parser(exidx_img, exidx_size, extab_img, extab_size, exidx_text_last_svma, ++ &handler, ++ reinterpret_cast<const char*>(elf_header), ++ loading_addr); ++ parser.Start(); ++ return true; ++} ++ + bool LoadELF(const string& obj_file, MmapWrapper* map_wrapper, + void** elf_header) { + int obj_fd = open(obj_file.c_str(), O_RDONLY); +@@ -846,6 +898,29 @@ bool LoadSymbols(const string& obj_file, + } + } + ++ // ARM has special unwind tables that can be used. ++ const Shdr* arm_exidx_section = ++ FindElfSectionByName<ElfClass>(".ARM.exidx", SHT_ARM_EXIDX, ++ sections, names, names_end, ++ elf_header->e_shnum); ++ const Shdr* arm_extab_section = ++ FindElfSectionByName<ElfClass>(".ARM.extab", SHT_PROGBITS, ++ sections, names, names_end, ++ elf_header->e_shnum); ++ // Load information from these sections even if there is ++ // .debug_info, because some functions (e.g., hand-written or ++ // script-generated assembly) could have exidx entries but no DWARF. ++ // (For functions with both, the DWARF info that has already been ++ // parsed will take precedence.) ++ if (arm_exidx_section && arm_extab_section && options.symbol_data != NO_CFI) { ++ info->LoadedSection(".ARM.exidx"); ++ info->LoadedSection(".ARM.extab"); ++ bool result = LoadARMexidx<ElfClass>(elf_header, ++ arm_exidx_section, arm_extab_section, ++ loading_addr, module); ++ found_usable_info = found_usable_info || result; ++ } ++ + if (!found_debug_info_section) { + fprintf(stderr, "%s: file contains no debugging information" + " (no \".stab\" or \".debug_info\" sections)\n", +diff --git a/src/common/module.cc b/src/common/module.cc +index aff22127..a3544029 100644 +--- a/src/common/module.cc ++++ b/src/common/module.cc +@@ -64,7 +64,7 @@ Module::~Module() { + it != functions_.end(); ++it) { + delete *it; + } +- for (vector<StackFrameEntry *>::iterator it = stack_frame_entries_.begin(); ++ for (StackFrameEntrySet::iterator it = stack_frame_entries_.begin(); + it != stack_frame_entries_.end(); ++it) { + delete *it; + } +@@ -130,12 +130,18 @@ void Module::AddFunctions(vector<Function *>::iterator begin, + AddFunction(*it); + } + +-void Module::AddStackFrameEntry(StackFrameEntry *stack_frame_entry) { ++void Module::AddStackFrameEntry(StackFrameEntry* stack_frame_entry) { + if (!AddressIsInModule(stack_frame_entry->address)) { + return; + } + +- stack_frame_entries_.push_back(stack_frame_entry); ++ std::pair<StackFrameEntrySet::iterator,bool> ret = ++ stack_frame_entries_.insert(stack_frame_entry); ++ if (!ret.second) { ++ // Free the duplicate that was not inserted because this Module ++ // now owns it. ++ delete stack_frame_entry; ++ } + } + + void Module::AddExtern(Extern *ext) { +@@ -199,8 +205,25 @@ void Module::GetFiles(vector<File *> *vec) { + vec->push_back(it->second); + } + +-void Module::GetStackFrameEntries(vector<StackFrameEntry *> *vec) const { +- *vec = stack_frame_entries_; ++void Module::GetStackFrameEntries(vector<StackFrameEntry*>* vec) const { ++ vec->clear(); ++ vec->insert(vec->begin(), stack_frame_entries_.begin(), ++ stack_frame_entries_.end()); ++} ++ ++Module::StackFrameEntry* Module::FindStackFrameEntryByAddress(Address address) { ++ StackFrameEntry search; ++ search.address = address; ++ StackFrameEntrySet::iterator it = stack_frame_entries_.upper_bound(&search); ++ ++ if (it == stack_frame_entries_.begin()) ++ return NULL; ++ ++ it--; ++ if ((*it)->address <= address && address < (*it)->address + (*it)->size) ++ return *it; ++ ++ return NULL; + } + + void Module::AssignSourceIds() { +@@ -331,7 +354,7 @@ bool Module::Write(std::ostream &stream, SymbolData symbol_data) { + + if (symbol_data != NO_CFI) { + // Write out 'STACK CFI INIT' and 'STACK CFI' records. +- vector<StackFrameEntry *>::const_iterator frame_it; ++ StackFrameEntrySet::const_iterator frame_it; + for (frame_it = stack_frame_entries_.begin(); + frame_it != stack_frame_entries_.end(); ++frame_it) { + StackFrameEntry *entry = *frame_it; +diff --git a/src/common/module.h b/src/common/module.h +index 7309cedd..37758605 100644 +--- a/src/common/module.h ++++ b/src/common/module.h +@@ -185,6 +185,13 @@ class Module { + } + }; + ++ struct StackFrameEntryCompare { ++ bool operator() (const StackFrameEntry* lhs, ++ const StackFrameEntry* rhs) const { ++ return lhs->address < rhs->address; ++ } ++ }; ++ + // Create a new module with the given name, operating system, + // architecture, and ID string. + Module(const string &name, const string &os, const string &architecture, +@@ -273,6 +280,10 @@ class Module { + // a more appropriate interface.) + void GetStackFrameEntries(vector<StackFrameEntry *> *vec) const; + ++ // If this module has a StackFrameEntry whose address range covers ++ // ADDRESS, return it. Otherwise return NULL. ++ StackFrameEntry* FindStackFrameEntryByAddress(Address address); ++ + // Find those files in this module that are actually referred to by + // functions' line number data, and assign them source id numbers. + // Set the source id numbers for all other files --- unused by the +@@ -342,6 +353,9 @@ class Module { + // A set containing Extern structures, sorted by address. + typedef set<Extern *, ExternCompare> ExternSet; + ++ // A set containing StackFrameEntry structures, sorted by address. ++ typedef set<StackFrameEntry*, StackFrameEntryCompare> StackFrameEntrySet; ++ + // The module owns all the files and functions that have been added + // to it; destroying the module frees the Files and Functions these + // point to. +@@ -350,7 +364,7 @@ class Module { + + // The module owns all the call frame info entries that have been + // added to it. +- vector<StackFrameEntry *> stack_frame_entries_; ++ StackFrameEntrySet stack_frame_entries_; + + // The module owns all the externs that have been added to it; + // destroying the module frees the Externs these point to. +diff --git a/src/common/module_unittest.cc b/src/common/module_unittest.cc +index 37fee5dd..b855f186 100644 +--- a/src/common/module_unittest.cc ++++ b/src/common/module_unittest.cc +@@ -344,11 +344,6 @@ TEST(Construct, AddFrames) { + m.Write(s, ALL_SYMBOL_DATA); + string contents = s.str(); + EXPECT_STREQ("MODULE os-name architecture id-string name with spaces\n" +- "STACK CFI INIT ddb5f41285aa7757 1486493370dc5073 \n" +- "STACK CFI INIT 8064f3af5e067e38 de2a5ee55509407" +- " .cfa: I think that I shall never see" +- " cannoli: a tree whose hungry mouth is prest" +- " stromboli: a poem lovely as a tree\n" + "STACK CFI INIT 5e8d0db0a7075c6c 1c7edb12a7aea229" + " .cfa: Whose woods are these\n" + "STACK CFI 36682fad3763ffff" +@@ -356,7 +351,12 @@ TEST(Construct, AddFrames) { + " stromboli: his house is in\n" + "STACK CFI 47ceb0f63c269d7f" + " calzone: the village though" +- " cannoli: he will not see me stopping here\n", ++ " cannoli: he will not see me stopping here\n" ++ "STACK CFI INIT 8064f3af5e067e38 de2a5ee55509407" ++ " .cfa: I think that I shall never see" ++ " cannoli: a tree whose hungry mouth is prest" ++ " stromboli: a poem lovely as a tree\n" ++ "STACK CFI INIT ddb5f41285aa7757 1486493370dc5073 \n", + contents.c_str()); + + // Check that GetStackFrameEntries works. +@@ -364,10 +364,18 @@ TEST(Construct, AddFrames) { + m.GetStackFrameEntries(&entries); + ASSERT_EQ(3U, entries.size()); + // Check first entry. +- EXPECT_EQ(0xddb5f41285aa7757ULL, entries[0]->address); +- EXPECT_EQ(0x1486493370dc5073ULL, entries[0]->size); +- ASSERT_EQ(0U, entries[0]->initial_rules.size()); +- ASSERT_EQ(0U, entries[0]->rule_changes.size()); ++ EXPECT_EQ(0x5e8d0db0a7075c6cULL, entries[0]->address); ++ EXPECT_EQ(0x1c7edb12a7aea229ULL, entries[0]->size); ++ Module::RuleMap entry1_initial; ++ entry1_initial[".cfa"] = "Whose woods are these"; ++ EXPECT_THAT(entries[0]->initial_rules, ContainerEq(entry1_initial)); ++ Module::RuleChangeMap entry1_changes; ++ entry1_changes[0x36682fad3763ffffULL][".cfa"] = "I think I know"; ++ entry1_changes[0x36682fad3763ffffULL]["stromboli"] = "his house is in"; ++ entry1_changes[0x47ceb0f63c269d7fULL]["calzone"] = "the village though"; ++ entry1_changes[0x47ceb0f63c269d7fULL]["cannoli"] = ++ "he will not see me stopping here"; ++ EXPECT_THAT(entries[0]->rule_changes, ContainerEq(entry1_changes)); + // Check second entry. + EXPECT_EQ(0x8064f3af5e067e38ULL, entries[1]->address); + EXPECT_EQ(0x0de2a5ee55509407ULL, entries[1]->size); +@@ -379,18 +387,10 @@ TEST(Construct, AddFrames) { + EXPECT_THAT(entries[1]->initial_rules, ContainerEq(entry2_initial)); + ASSERT_EQ(0U, entries[1]->rule_changes.size()); + // Check third entry. +- EXPECT_EQ(0x5e8d0db0a7075c6cULL, entries[2]->address); +- EXPECT_EQ(0x1c7edb12a7aea229ULL, entries[2]->size); +- Module::RuleMap entry3_initial; +- entry3_initial[".cfa"] = "Whose woods are these"; +- EXPECT_THAT(entries[2]->initial_rules, ContainerEq(entry3_initial)); +- Module::RuleChangeMap entry3_changes; +- entry3_changes[0x36682fad3763ffffULL][".cfa"] = "I think I know"; +- entry3_changes[0x36682fad3763ffffULL]["stromboli"] = "his house is in"; +- entry3_changes[0x47ceb0f63c269d7fULL]["calzone"] = "the village though"; +- entry3_changes[0x47ceb0f63c269d7fULL]["cannoli"] = +- "he will not see me stopping here"; +- EXPECT_THAT(entries[2]->rule_changes, ContainerEq(entry3_changes)); ++ EXPECT_EQ(0xddb5f41285aa7757ULL, entries[2]->address); ++ EXPECT_EQ(0x1486493370dc5073ULL, entries[2]->size); ++ ASSERT_EQ(0U, entries[2]->initial_rules.size()); ++ ASSERT_EQ(0U, entries[2]->rule_changes.size()); + } + + TEST(Construct, UniqueFiles) { +@@ -612,5 +612,63 @@ TEST(Write, OutOfRangeAddresses) { + EXPECT_STREQ("MODULE os-name architecture id-string name with spaces\n" + "STACK CFI INIT 2000 100 \n", + s.str().c_str()); ++} ++ ++TEST(Lookup, StackFrameEntries) { ++ Module m(MODULE_NAME, MODULE_OS, MODULE_ARCH, MODULE_ID); ++ ++ // First STACK CFI entry, with no initial rules or deltas. ++ Module::StackFrameEntry *entry1 = new Module::StackFrameEntry(); ++ entry1->address = 0x2000; ++ entry1->size = 0x900; ++ m.AddStackFrameEntry(entry1); ++ ++ // Second STACK CFI entry, with initial rules but no deltas. ++ Module::StackFrameEntry *entry2 = new Module::StackFrameEntry(); ++ entry2->address = 0x3000; ++ entry2->size = 0x900; ++ entry2->initial_rules[".cfa"] = "I think that I shall never see"; ++ entry2->initial_rules["stromboli"] = "a poem lovely as a tree"; ++ entry2->initial_rules["cannoli"] = "a tree whose hungry mouth is prest"; ++ m.AddStackFrameEntry(entry2); ++ ++ // Third STACK CFI entry, with initial rules and deltas. ++ Module::StackFrameEntry *entry3 = new Module::StackFrameEntry(); ++ entry3->address = 0x1000; ++ entry3->size = 0x900; ++ entry3->initial_rules[".cfa"] = "Whose woods are these"; ++ entry3->rule_changes[0x47ceb0f63c269d7fULL]["calzone"] = ++ "the village though"; ++ entry3->rule_changes[0x47ceb0f63c269d7fULL]["cannoli"] = ++ "he will not see me stopping here"; ++ entry3->rule_changes[0x36682fad3763ffffULL]["stromboli"] = ++ "his house is in"; ++ entry3->rule_changes[0x36682fad3763ffffULL][".cfa"] = ++ "I think I know"; ++ m.AddStackFrameEntry(entry3); + ++ Module::StackFrameEntry* s = m.FindStackFrameEntryByAddress(0x1000); ++ EXPECT_EQ(entry3, s); ++ s = m.FindStackFrameEntryByAddress(0x18FF); ++ EXPECT_EQ(entry3, s); ++ ++ s = m.FindStackFrameEntryByAddress(0x1900); ++ EXPECT_EQ((Module::StackFrameEntry*)NULL, s); ++ s = m.FindStackFrameEntryByAddress(0x1A00); ++ EXPECT_EQ((Module::StackFrameEntry*)NULL, s); ++ ++ s = m.FindStackFrameEntryByAddress(0x2000); ++ EXPECT_EQ(entry1, s); ++ s = m.FindStackFrameEntryByAddress(0x28FF); ++ EXPECT_EQ(entry1, s); ++ ++ s = m.FindStackFrameEntryByAddress(0x3000); ++ EXPECT_EQ(entry2, s); ++ s = m.FindStackFrameEntryByAddress(0x38FF); ++ EXPECT_EQ(entry2, s); ++ ++ s = m.FindStackFrameEntryByAddress(0x3900); ++ EXPECT_EQ((Module::StackFrameEntry*)NULL, s); ++ s = m.FindStackFrameEntryByAddress(0x3A00); ++ EXPECT_EQ((Module::StackFrameEntry*)NULL, s); + } diff --git a/toolkit/crashreporter/breakpad-patches/02-define-print-mach-result.patch b/toolkit/crashreporter/breakpad-patches/02-define-print-mach-result.patch new file mode 100644 index 0000000000..933659120d --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/02-define-print-mach-result.patch @@ -0,0 +1,24 @@ +diff --git a/src/common/mac/MachIPC.h b/src/common/mac/MachIPC.h +--- a/src/common/mac/MachIPC.h ++++ b/src/common/mac/MachIPC.h +@@ -90,18 +90,20 @@ + // + // char messageString[] = "Hello server!\n"; + // message.SetData(messageString, strlen(messageString)+1); + // + // kern_return_t result = sender.SendMessage(message, 1000); // timeout 1000ms + // + + namespace google_breakpad { ++#ifndef PRINT_MACH_RESULT + #define PRINT_MACH_RESULT(result_, message_) \ + printf(message_" %s (%d)\n", mach_error_string(result_), result_ ); ++#endif + + //============================================================================== + // A wrapper class for mach_msg_port_descriptor_t (with same memory layout) + // with convenient constructors and accessors + class MachMsgPortDescriptor : public mach_msg_port_descriptor_t { + public: + // General-purpose constructor + MachMsgPortDescriptor(mach_port_t in_name, diff --git a/toolkit/crashreporter/breakpad-patches/03-strstr-libc-replacement.patch b/toolkit/crashreporter/breakpad-patches/03-strstr-libc-replacement.patch new file mode 100644 index 0000000000..17006a91d9 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/03-strstr-libc-replacement.patch @@ -0,0 +1,54 @@ +diff --git a/src/common/linux/linux_libc_support.cc b/src/common/linux/linux_libc_support.cc +--- a/src/common/linux/linux_libc_support.cc ++++ b/src/common/linux/linux_libc_support.cc +@@ -133,16 +133,27 @@ const char* my_strrchr(const char* hayst + while (*haystack) { + if (*haystack == needle) + ret = haystack; + haystack++; + } + return ret; + } + ++const char* my_strstr(const char* haystack, const char* needle) { ++ while (*haystack != 0) { ++ if((*haystack == *needle) && ++ (my_strncmp(haystack, needle, my_strlen(needle)) == 0)) { ++ return haystack; ++ } ++ haystack++; ++ } ++ return nullptr; ++} ++ + void* my_memchr(const void* src, int needle, size_t src_len) { + const unsigned char* p = (const unsigned char*)src; + const unsigned char* p_end = p + src_len; + for (; p < p_end; ++p) { + if (*p == needle) + return (void*)p; + } + return NULL; +diff --git a/src/common/linux/linux_libc_support.h b/src/common/linux/linux_libc_support.h +--- a/src/common/linux/linux_libc_support.h ++++ b/src/common/linux/linux_libc_support.h +@@ -62,16 +62,18 @@ extern unsigned my_uint_len(uintmax_t i) + // i: the unsigned integer to serialise. + // i_len: the length of the integer in base 10 (see |my_uint_len|). + extern void my_uitos(char* output, uintmax_t i, unsigned i_len); + + extern const char* my_strchr(const char* haystack, char needle); + + extern const char* my_strrchr(const char* haystack, char needle); + ++extern const char *my_strstr(const char *haystack, const char *needle); ++ + // Read a hex value + // result: (output) the resulting value + // s: a string + // Returns a pointer to the first invalid charactor. + extern const char* my_read_hex_ptr(uintptr_t* result, const char* s); + + extern const char* my_read_decimal_ptr(uintptr_t* result, const char* s); + + diff --git a/toolkit/crashreporter/breakpad-patches/04-update-headers.patch b/toolkit/crashreporter/breakpad-patches/04-update-headers.patch new file mode 100644 index 0000000000..4baa27be90 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/04-update-headers.patch @@ -0,0 +1,6039 @@ +diff --git a/src/third_party/curl/COPYING b/src/third_party/curl/COPYING +--- a/src/third_party/curl/COPYING ++++ b/src/third_party/curl/COPYING +@@ -1,11 +1,12 @@ + COPYRIGHT AND PERMISSION NOTICE + +-Copyright (c) 1996 - 2011, Daniel Stenberg, <daniel@haxx.se>. ++Copyright (c) 1996 - 2019, Daniel Stenberg, <daniel@haxx.se>, and many ++contributors, see the THANKS file. + + All rights reserved. + + Permission to use, copy, modify, and distribute this software for any purpose + with or without fee is hereby granted, provided that the above copyright + notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +@@ -14,9 +15,8 @@ FITNESS FOR A PARTICULAR PURPOSE AND NON + NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE + OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the name of a copyright holder shall not + be used in advertising or otherwise to promote the sale, use or other dealings + in this Software without prior written authorization of the copyright holder. +- +diff --git a/src/third_party/curl/curl.h b/src/third_party/curl/curl.h +--- a/src/third_party/curl/curl.h ++++ b/src/third_party/curl/curl.h +@@ -2,234 +2,402 @@ + #define __CURL_CURL_H + /*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. ++ * are also available at https://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * +- * $Id: curl.h,v 1.396 2009-10-16 13:30:31 yangtse Exp $ + ***************************************************************************/ + + /* + * If you have libcurl problems, all docs and details are found here: +- * http://curl.haxx.se/libcurl/ ++ * https://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: +- * http://cool.haxx.se/mailman/listinfo/curl-library/ ++ * https://cool.haxx.se/mailman/listinfo/curl-library/ + */ + +-/* +- * Leading 'curl' path on the 'curlbuild.h' include statement is +- * required to properly allow building outside of the source tree, +- * due to the fact that in this case 'curlbuild.h' is generated in +- * a subdirectory of the build tree while 'curl.h actually remains +- * in a subdirectory of the source tree. +- */ +- +-#include "third_party/curl/curlver.h" /* libcurl version defines */ +-#include "third_party/curl/curlbuild.h" /* libcurl build definitions */ +-#include "third_party/curl/curlrules.h" /* libcurl rules enforcement */ ++#ifdef CURL_NO_OLDIES ++#define CURL_STRICTER ++#endif ++ ++#include "curlver.h" /* libcurl version defines */ ++#include "system.h" /* determine things run-time */ + + /* + * Define WIN32 when build target is Win32 API + */ + + #if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) + #define WIN32 + #endif + + #include <stdio.h> + #include <limits.h> + ++#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) ++/* Needed for __FreeBSD_version symbol definition */ ++#include <osreldate.h> ++#endif ++ + /* The include stuff here below is mainly for time_t! */ + #include <sys/types.h> + #include <time.h> + +-#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) && \ +- !defined(__CYGWIN__) || defined(__MINGW32__) +-#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H)) ++#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) ++#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \ ++ defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H)) + /* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ + #include <winsock2.h> + #include <ws2tcpip.h> + #endif +-#else ++#endif + + /* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish +- libc5-based Linux systems. Only include it on system that are known to ++ libc5-based Linux systems. Only include it on systems that are known to + require it! */ + #if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ + defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \ +- defined(__ANDROID__) ++ defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ ++ defined(__CYGWIN__) || \ ++ (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) + #include <sys/select.h> + #endif + +-#ifndef _WIN32_WCE ++#if !defined(WIN32) && !defined(_WIN32_WCE) + #include <sys/socket.h> + #endif ++ + #if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__) + #include <sys/time.h> + #endif +-#include <sys/types.h> +-#endif + + #ifdef __BEOS__ + #include <support/SupportDefs.h> + #endif + ++/* Compatibility for non-Clang compilers */ ++#ifndef __has_declspec_attribute ++# define __has_declspec_attribute(x) 0 ++#endif ++ + #ifdef __cplusplus + extern "C" { + #endif + ++#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) ++typedef struct Curl_easy CURL; ++typedef struct Curl_share CURLSH; ++#else + typedef void CURL; ++typedef void CURLSH; ++#endif + + /* +- * Decorate exportable functions for Win32 and Symbian OS DLL linking. +- * This avoids using a .def file for building libcurl.dll. ++ * libcurl external API function linkage decorations. + */ +-#if (defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)) && \ +- !defined(CURL_STATICLIB) +-#if defined(BUILDING_LIBCURL) +-#define CURL_EXTERN __declspec(dllexport) +-#else +-#define CURL_EXTERN __declspec(dllimport) +-#endif ++ ++#ifdef CURL_STATICLIB ++# define CURL_EXTERN ++#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__) || \ ++ (__has_declspec_attribute(dllexport) && \ ++ __has_declspec_attribute(dllimport)) ++# if defined(BUILDING_LIBCURL) ++# define CURL_EXTERN __declspec(dllexport) ++# else ++# define CURL_EXTERN __declspec(dllimport) ++# endif ++#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) ++# define CURL_EXTERN CURL_EXTERN_SYMBOL + #else +- +-#ifdef CURL_HIDDEN_SYMBOLS +-/* +- * This definition is used to make external definitions visible in the +- * shared library when symbols are hidden by default. It makes no +- * difference when compiling applications whether this is set or not, +- * only when compiling the library. +- */ +-#define CURL_EXTERN CURL_EXTERN_SYMBOL +-#else +-#define CURL_EXTERN +-#endif ++# define CURL_EXTERN + #endif + + #ifndef curl_socket_typedef + /* socket typedef */ +-#ifdef WIN32 ++#if defined(WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H) + typedef SOCKET curl_socket_t; + #define CURL_SOCKET_BAD INVALID_SOCKET + #else + typedef int curl_socket_t; + #define CURL_SOCKET_BAD -1 + #endif + #define curl_socket_typedef + #endif /* curl_socket_typedef */ + ++/* enum for the different supported SSL backends */ ++typedef enum { ++ CURLSSLBACKEND_NONE = 0, ++ CURLSSLBACKEND_OPENSSL = 1, ++ CURLSSLBACKEND_GNUTLS = 2, ++ CURLSSLBACKEND_NSS = 3, ++ CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ ++ CURLSSLBACKEND_GSKIT = 5, ++ CURLSSLBACKEND_POLARSSL = 6, ++ CURLSSLBACKEND_WOLFSSL = 7, ++ CURLSSLBACKEND_SCHANNEL = 8, ++ CURLSSLBACKEND_SECURETRANSPORT = 9, ++ CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */ ++ CURLSSLBACKEND_MBEDTLS = 11, ++ CURLSSLBACKEND_MESALINK = 12 ++} curl_sslbackend; ++ ++/* aliases for library clones and renames */ ++#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL ++#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL ++ ++/* deprecated names: */ ++#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL ++#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT ++ + struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ +- long contentslength; /* length of contents field */ ++ long contentslength; /* length of contents field, see also ++ CURL_HTTPPOST_LARGE */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ +- struct curl_slist* contentheader; /* list of extra headers for this form */ ++ struct curl_slist *contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ +-#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */ +-#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */ +-#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer +- do not free in formfree */ +-#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer +- do not free in formfree */ +-#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ +-#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ +-#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the +- regular read callback to get the data +- and pass the given pointer as custom +- pointer */ ++ ++/* specified content is a file name */ ++#define CURL_HTTPPOST_FILENAME (1<<0) ++/* specified content is a file name */ ++#define CURL_HTTPPOST_READFILE (1<<1) ++/* name is only stored pointer do not free in formfree */ ++#define CURL_HTTPPOST_PTRNAME (1<<2) ++/* contents is only stored pointer do not free in formfree */ ++#define CURL_HTTPPOST_PTRCONTENTS (1<<3) ++/* upload file from buffer */ ++#define CURL_HTTPPOST_BUFFER (1<<4) ++/* upload file from pointer contents */ ++#define CURL_HTTPPOST_PTRBUFFER (1<<5) ++/* upload file contents by using the regular read callback to get the data and ++ pass the given pointer as custom pointer */ ++#define CURL_HTTPPOST_CALLBACK (1<<6) ++/* use size in 'contentlen', added in 7.46.0 */ ++#define CURL_HTTPPOST_LARGE (1<<7) + + char *showfilename; /* The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ + void *userp; /* custom pointer used for + HTTPPOST_CALLBACK posts */ ++ curl_off_t contentlen; /* alternative length of contents ++ field. Used if CURL_HTTPPOST_LARGE is ++ set. Added in 7.46.0 */ + }; + ++/* This is the CURLOPT_PROGRESSFUNCTION callback proto. It is now considered ++ deprecated but was the only choice up until 7.31.0 */ + typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + ++/* This is the CURLOPT_XFERINFOFUNCTION callback proto. It was introduced in ++ 7.32.0, it avoids floating point and provides more detailed information. */ ++typedef int (*curl_xferinfo_callback)(void *clientp, ++ curl_off_t dltotal, ++ curl_off_t dlnow, ++ curl_off_t ultotal, ++ curl_off_t ulnow); ++ ++#ifndef CURL_MAX_READ_SIZE ++ /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */ ++#define CURL_MAX_READ_SIZE 524288 ++#endif ++ + #ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very bad buffer size for uploads on + Windows, while 16K for some odd reason performed a lot better. + We do the ifndef check to allow this value to easier be changed at build +- time for those who feel adventurous. */ ++ time for those who feel adventurous. The practical minimum is about ++ 400 bytes since libcurl uses a buffer of this size as a scratch area ++ (unrelated to network send operations). */ + #define CURL_MAX_WRITE_SIZE 16384 + #endif + + #ifndef CURL_MAX_HTTP_HEADER + /* The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ + #define CURL_MAX_HTTP_HEADER (100*1024) + #endif + +- + /* This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ + #define CURL_WRITEFUNC_PAUSE 0x10000001 ++ + typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + ++/* This callback will be called when a new resolver request is made */ ++typedef int (*curl_resolver_start_callback)(void *resolver_state, ++ void *reserved, void *userdata); ++ ++/* enumeration of file types */ ++typedef enum { ++ CURLFILETYPE_FILE = 0, ++ CURLFILETYPE_DIRECTORY, ++ CURLFILETYPE_SYMLINK, ++ CURLFILETYPE_DEVICE_BLOCK, ++ CURLFILETYPE_DEVICE_CHAR, ++ CURLFILETYPE_NAMEDPIPE, ++ CURLFILETYPE_SOCKET, ++ CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ ++ ++ CURLFILETYPE_UNKNOWN /* should never occur */ ++} curlfiletype; ++ ++#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) ++#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) ++#define CURLFINFOFLAG_KNOWN_TIME (1<<2) ++#define CURLFINFOFLAG_KNOWN_PERM (1<<3) ++#define CURLFINFOFLAG_KNOWN_UID (1<<4) ++#define CURLFINFOFLAG_KNOWN_GID (1<<5) ++#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) ++#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) ++ ++/* Content of this structure depends on information which is known and is ++ achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man ++ page for callbacks returning this structure -- some fields are mandatory, ++ some others are optional. The FLAG field has special meaning. */ ++struct curl_fileinfo { ++ char *filename; ++ curlfiletype filetype; ++ time_t time; ++ unsigned int perm; ++ int uid; ++ int gid; ++ curl_off_t size; ++ long int hardlinks; ++ ++ struct { ++ /* If some of these fields is not NULL, it is a pointer to b_data. */ ++ char *time; ++ char *perm; ++ char *user; ++ char *group; ++ char *target; /* pointer to the target filename of a symlink */ ++ } strings; ++ ++ unsigned int flags; ++ ++ /* used internally */ ++ char *b_data; ++ size_t b_size; ++ size_t b_used; ++}; ++ ++/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ ++#define CURL_CHUNK_BGN_FUNC_OK 0 ++#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ ++#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ ++ ++/* if splitting of data transfer is enabled, this callback is called before ++ download of an individual chunk started. Note that parameter "remains" works ++ only for FTP wildcard downloading (for now), otherwise is not used */ ++typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, ++ void *ptr, ++ int remains); ++ ++/* return codes for CURLOPT_CHUNK_END_FUNCTION */ ++#define CURL_CHUNK_END_FUNC_OK 0 ++#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ ++ ++/* If splitting of data transfer is enabled this callback is called after ++ download of an individual chunk finished. ++ Note! After this callback was set then it have to be called FOR ALL chunks. ++ Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. ++ This is the reason why we don't need "transfer_info" parameter in this ++ callback and we are not interested in "remains" parameter too. */ ++typedef long (*curl_chunk_end_callback)(void *ptr); ++ ++/* return codes for FNMATCHFUNCTION */ ++#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ ++#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */ ++#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ ++ ++/* callback type for wildcard downloading pattern matching. If the ++ string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ ++typedef int (*curl_fnmatch_callback)(void *ptr, ++ const char *pattern, ++ const char *string); ++ + /* These are the return codes for the seek callbacks */ + #define CURL_SEEKFUNC_OK 0 + #define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ + #define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so + libcurl might try other means instead */ + typedef int (*curl_seek_callback)(void *instream, + curl_off_t offset, + int origin); /* 'whence' */ + + /* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ + #define CURL_READFUNC_ABORT 0x10000000 + /* This is a return code for the read callback that, when returned, will + signal libcurl to pause sending data on the current transfer. */ + #define CURL_READFUNC_PAUSE 0x10000001 + ++/* Return code for when the trailing headers' callback has terminated ++ without any errors*/ ++#define CURL_TRAILERFUNC_OK 0 ++/* Return code for when was an error in the trailing header's list and we ++ want to abort the request */ ++#define CURL_TRAILERFUNC_ABORT 1 ++ + typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +-typedef enum { +- CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ +- CURLSOCKTYPE_LAST /* never use */ ++typedef int (*curl_trailer_callback)(struct curl_slist **list, ++ void *userdata); ++ ++typedef enum { ++ CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ ++ CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ ++ CURLSOCKTYPE_LAST /* never use */ + } curlsocktype; + ++/* The return code from the sockopt_callback can signal information back ++ to libcurl: */ ++#define CURL_SOCKOPT_OK 0 ++#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return ++ CURLE_ABORTED_BY_CALLBACK */ ++#define CURL_SOCKOPT_ALREADY_CONNECTED 2 ++ + typedef int (*curl_sockopt_callback)(void *clientp, + curl_socket_t curlfd, + curlsocktype purpose); + + struct curl_sockaddr { + int family; + int socktype; + int protocol; +@@ -239,53 +407,52 @@ struct curl_sockaddr { + struct sockaddr addr; + }; + + typedef curl_socket_t + (*curl_opensocket_callback)(void *clientp, + curlsocktype purpose, + struct curl_sockaddr *address); + +-#ifndef CURL_NO_OLDIES +- /* not used since 7.10.8, will be removed in a future release */ +-typedef int (*curl_passwd_callback)(void *clientp, +- const char *prompt, +- char *buffer, +- int buflen); +-#endif ++typedef int ++(*curl_closesocket_callback)(void *clientp, curl_socket_t item); + + typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ + } curlioerr; + +-typedef enum { ++typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ + } curliocmd; + + typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + ++#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS + /* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ + typedef void *(*curl_malloc_callback)(size_t size); + typedef void (*curl_free_callback)(void *ptr); + typedef void *(*curl_realloc_callback)(void *ptr, size_t size); + typedef char *(*curl_strdup_callback)(const char *str); + typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + ++#define CURL_DID_MEMORY_FUNC_TYPEDEFS ++#endif ++ + /* the kind of data that is passed to information_callback*/ + typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ +@@ -307,31 +474,37 @@ typedef int (*curl_debug_callback) + codes must remain the same! + */ + + typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ +- CURLE_OBSOLETE4, /* 4 - NOT USED */ ++ CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for ++ 7.17.0, reused in April 2011 for 7.21.5] */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ +- CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */ ++ CURLE_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ +- CURLE_OBSOLETE10, /* 10 - NOT USED */ ++ CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for ++ 7.15.4, reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ +- CURLE_OBSOLETE12, /* 12 - NOT USED */ ++ CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server ++ [was obsoleted in August 2007 for 7.17.0, ++ reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ +- CURLE_OBSOLETE16, /* 16 - NOT USED */ ++ CURLE_HTTP2, /* 16 - A problem in the http2 framing layer. ++ [was obsoleted in August 2007 for 7.17.0, ++ reused in July 2014 for 7.38.0] */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_OBSOLETE24, /* 24 - NOT USED */ +@@ -350,39 +523,39 @@ typedef enum { + CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ +- CURLE_FUNCTION_NOT_FOUND, /* 41 */ ++ CURLE_FUNCTION_NOT_FOUND, /* 41 - NOT USED starting with 7.53.0 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ +- CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ +- CURLE_UNKNOWN_TELNET_OPTION, /* 48 - User specified an unknown option */ +- CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ ++ CURLE_TOO_MANY_REDIRECTS, /* 47 - catch endless re-direct loops */ ++ CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ ++ CURLE_TELNET_OPTION_SYNTAX, /* 49 - Malformed telnet option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ +- CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint +- wasn't verified fine */ ++ CURLE_OBSOLETE51, /* 51 - NOT USED */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_OBSOLETE57, /* 57 - NOT IN USE */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ +- CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ +- CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized transfer encoding */ ++ CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint ++ wasn't verified fine */ ++ CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ +@@ -410,43 +583,72 @@ typedef enum { + connection */ + CURLE_AGAIN, /* 81 - socket is not ready for send/recv, + wait till it's ready and try again (Added + in 7.18.2) */ + CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or + wrong format (Added in 7.19.0) */ + CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in + 7.19.0) */ ++ CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ ++ CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ ++ CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ ++ CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ ++ CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ ++ CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the ++ session will be queued */ ++ CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not ++ match */ ++ CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */ ++ CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer ++ */ ++ CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from ++ inside a callback */ + CURL_LAST /* never use! */ + } CURLcode; + + #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +-/* Backwards compatibility with older names */ ++/* Previously obsolete error code re-used in 7.38.0 */ ++#define CURLE_OBSOLETE16 CURLE_HTTP2 ++ ++/* Previously obsolete error codes re-used in 7.24.0 */ ++#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED ++#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT ++ ++/* compatibility with older names */ ++#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING ++#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY ++ ++/* The following were added in 7.62.0 */ ++#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION ++ ++/* The following were added in 7.21.5, April 2011 */ ++#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + + /* The following were added in 7.17.1 */ + /* These are scheduled to disappear by 2009 */ + #define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION + + /* The following were added in 7.17.0 */ + /* These are scheduled to disappear by 2009 */ +-#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* noone should be using this! */ ++#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ + #define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 + #define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 + #define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 + #define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 + #define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 + #define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 + #define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 + #define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 + #define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 + #define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 + #define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 +-#define CURLE_URL_MALFORMAT_USER CURLE_OBSOLETE4 ++#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN + + #define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED + #define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE + #define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR + #define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL + #define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS + #define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR + #define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED +@@ -462,69 +664,115 @@ typedef enum { + #define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE + #define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME + + /* This was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ + #define CURLE_ALREADY_COMPLETE 99999 + ++/* Provide defines for really old option names */ ++#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */ ++#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */ ++#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA ++ ++/* Since long deprecated options with no code in the lib that does anything ++ with them. */ ++#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40 ++#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72 ++ + #endif /*!CURL_NO_OLDIES*/ + + /* This prototype applies to all conversion callbacks */ + typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); + + typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an + OpenSSL SSL_CTX */ + void *userptr); + + typedef enum { + CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use + CONNECT HTTP/1.1 */ + CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT + HTTP/1.0 */ ++ CURLPROXY_HTTPS = 2, /* added in 7.52.0 */ + CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already + in 7.10 */ + CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ + CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ + CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the + host name rather than the IP address. added + in 7.18.0 */ + } curl_proxytype; /* this enum was added in 7.10 */ + +-#define CURLAUTH_NONE 0 /* nothing */ +-#define CURLAUTH_BASIC (1<<0) /* Basic (default) */ +-#define CURLAUTH_DIGEST (1<<1) /* Digest */ +-#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */ +-#define CURLAUTH_NTLM (1<<3) /* NTLM */ +-#define CURLAUTH_DIGEST_IE (1<<4) /* Digest with IE flavour */ +-#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) /* all fine types set */ +-#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) ++/* ++ * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: ++ * ++ * CURLAUTH_NONE - No HTTP authentication ++ * CURLAUTH_BASIC - HTTP Basic authentication (default) ++ * CURLAUTH_DIGEST - HTTP Digest authentication ++ * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication ++ * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated) ++ * CURLAUTH_NTLM - HTTP NTLM authentication ++ * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour ++ * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper ++ * CURLAUTH_BEARER - HTTP Bearer token authentication ++ * CURLAUTH_ONLY - Use together with a single other type to force no ++ * authentication or just that single type ++ * CURLAUTH_ANY - All fine types set ++ * CURLAUTH_ANYSAFE - All fine types except Basic ++ */ ++ ++#define CURLAUTH_NONE ((unsigned long)0) ++#define CURLAUTH_BASIC (((unsigned long)1)<<0) ++#define CURLAUTH_DIGEST (((unsigned long)1)<<1) ++#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2) ++/* Deprecated since the advent of CURLAUTH_NEGOTIATE */ ++#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE ++/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */ ++#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE ++#define CURLAUTH_NTLM (((unsigned long)1)<<3) ++#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) ++#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) ++#define CURLAUTH_BEARER (((unsigned long)1)<<6) ++#define CURLAUTH_ONLY (((unsigned long)1)<<31) ++#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) ++#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) + + #define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ + #define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ + #define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ + #define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ + #define CURLSSH_AUTH_HOST (1<<2) /* host key files */ + #define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ ++#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ ++#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */ + #define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY + ++#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ ++#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ ++#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ ++ + #define CURL_ERROR_SIZE 256 + ++enum curl_khtype { ++ CURLKHTYPE_UNKNOWN, ++ CURLKHTYPE_RSA1, ++ CURLKHTYPE_RSA, ++ CURLKHTYPE_DSS, ++ CURLKHTYPE_ECDSA, ++ CURLKHTYPE_ED25519 ++}; ++ + struct curl_khkey { + const char *key; /* points to a zero-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; +- enum type { +- CURLKHTYPE_UNKNOWN, +- CURLKHTYPE_RSA1, +- CURLKHTYPE_RSA, +- CURLKHTYPE_DSS +- } keytype; ++ enum curl_khtype keytype; + }; + + /* this is the set of return values expected from the curl_sshkeycallback + callback */ + enum curl_khstat { + CURLKHSTAT_FINE_ADD_TO_FILE, + CURLKHSTAT_FINE, + CURLKHSTAT_REJECT, /* reject the connection, return an error */ +@@ -553,16 +801,37 @@ typedef int + typedef enum { + CURLUSESSL_NONE, /* do not attempt to use SSL */ + CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ + CURLUSESSL_ALL, /* SSL for all communication or fail */ + CURLUSESSL_LAST /* not an option, never use */ + } curl_usessl; + ++/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ ++ ++/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the ++ name of improving interoperability with older servers. Some SSL libraries ++ have introduced work-arounds for this flaw but those work-arounds sometimes ++ make the SSL communication fail. To regain functionality with those broken ++ servers, a user can this way allow the vulnerability back. */ ++#define CURLSSLOPT_ALLOW_BEAST (1<<0) ++ ++/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those ++ SSL backends where such behavior is present. */ ++#define CURLSSLOPT_NO_REVOKE (1<<1) ++ ++/* The default connection attempt delay in milliseconds for happy eyeballs. ++ CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document ++ this value, keep them in sync. */ ++#define CURL_HET_DEFAULT 200L ++ ++/* The default connection upkeep interval in milliseconds. */ ++#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L ++ + #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + + /* Backwards compatibility with older names */ + /* These are scheduled to disappear by 2009 */ + + #define CURLFTPSSL_NONE CURLUSESSL_NONE + #define CURLFTPSSL_TRY CURLUSESSL_TRY +@@ -603,91 +872,124 @@ typedef enum { + typedef enum { + CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ + CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ + CURLFTPMETHOD_NOCWD, /* no CWD at all */ + CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ + CURLFTPMETHOD_LAST /* not an option, never use */ + } curl_ftpmethod; + ++/* bitmask defines for CURLOPT_HEADEROPT */ ++#define CURLHEADER_UNIFIED 0 ++#define CURLHEADER_SEPARATE (1<<0) ++ ++/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */ ++#define CURLALTSVC_IMMEDIATELY (1<<0) ++#define CURLALTSVC_ALTUSED (1<<1) ++#define CURLALTSVC_READONLYFILE (1<<2) ++#define CURLALTSVC_H1 (1<<3) ++#define CURLALTSVC_H2 (1<<4) ++#define CURLALTSVC_H3 (1<<5) ++ + /* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ + #define CURLPROTO_HTTP (1<<0) + #define CURLPROTO_HTTPS (1<<1) + #define CURLPROTO_FTP (1<<2) + #define CURLPROTO_FTPS (1<<3) + #define CURLPROTO_SCP (1<<4) + #define CURLPROTO_SFTP (1<<5) + #define CURLPROTO_TELNET (1<<6) + #define CURLPROTO_LDAP (1<<7) + #define CURLPROTO_LDAPS (1<<8) + #define CURLPROTO_DICT (1<<9) + #define CURLPROTO_FILE (1<<10) + #define CURLPROTO_TFTP (1<<11) ++#define CURLPROTO_IMAP (1<<12) ++#define CURLPROTO_IMAPS (1<<13) ++#define CURLPROTO_POP3 (1<<14) ++#define CURLPROTO_POP3S (1<<15) ++#define CURLPROTO_SMTP (1<<16) ++#define CURLPROTO_SMTPS (1<<17) ++#define CURLPROTO_RTSP (1<<18) ++#define CURLPROTO_RTMP (1<<19) ++#define CURLPROTO_RTMPT (1<<20) ++#define CURLPROTO_RTMPE (1<<21) ++#define CURLPROTO_RTMPTE (1<<22) ++#define CURLPROTO_RTMPS (1<<23) ++#define CURLPROTO_RTMPTS (1<<24) ++#define CURLPROTO_GOPHER (1<<25) ++#define CURLPROTO_SMB (1<<26) ++#define CURLPROTO_SMBS (1<<27) + #define CURLPROTO_ALL (~0) /* enable everything */ + + /* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ + #define CURLOPTTYPE_LONG 0 + #define CURLOPTTYPE_OBJECTPOINT 10000 ++#define CURLOPTTYPE_STRINGPOINT 10000 + #define CURLOPTTYPE_FUNCTIONPOINT 20000 + #define CURLOPTTYPE_OFF_T 30000 + ++/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the ++ string options from the header file */ ++ + /* name is uppercase CURLOPT_<name>, + type is one of the defined CURLOPTTYPE_<type> + number is unique identifier */ + #ifdef CINIT + #undef CINIT + #endif + + #ifdef CURL_ISOCPP +-#define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number ++#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu + #else + /* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ + #define LONG CURLOPTTYPE_LONG + #define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT ++#define STRINGPOINT CURLOPTTYPE_OBJECTPOINT + #define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT + #define OFF_T CURLOPTTYPE_OFF_T + #define CINIT(name,type,number) CURLOPT_/**/name = type + number + #endif + + /* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + + typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ +- CINIT(FILE, OBJECTPOINT, 1), ++ CINIT(WRITEDATA, OBJECTPOINT, 1), + + /* The full URL to get/put */ +- CINIT(URL, OBJECTPOINT, 2), ++ CINIT(URL, STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ +- CINIT(PROXY, OBJECTPOINT, 4), +- +- /* "name:password" to use when fetching. */ +- CINIT(USERPWD, OBJECTPOINT, 5), +- +- /* "name:password" to use with proxy. */ +- CINIT(PROXYUSERPWD, OBJECTPOINT, 6), ++ CINIT(PROXY, STRINGPOINT, 4), ++ ++ /* "user:password;options" to use when fetching. */ ++ CINIT(USERPWD, STRINGPOINT, 5), ++ ++ /* "user:password" to use with proxy. */ ++ CINIT(PROXYUSERPWD, STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ +- CINIT(RANGE, OBJECTPOINT, 7), ++ CINIT(RANGE, STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ +- CINIT(INFILE, OBJECTPOINT, 9), ++ CINIT(READDATA, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE +- * bytes big. If this is not used, error messages go to stderr instead: */ ++ * bytes big. */ + CINIT(ERRORBUFFER, OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ +@@ -706,24 +1008,24 @@ typedef enum { + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST static input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ +- CINIT(REFERER, OBJECTPOINT, 16), ++ CINIT(REFERER, STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ +- CINIT(FTPPORT, OBJECTPOINT, 17), ++ CINIT(FTPPORT, STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ +- CINIT(USERAGENT, OBJECTPOINT, 18), ++ CINIT(USERAGENT, STRINGPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ +@@ -736,43 +1038,44 @@ typedef enum { + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ +- CINIT(COOKIE, OBJECTPOINT, 22), +- +- /* This points to a linked list of headers, struct curl_slist kind */ ++ CINIT(COOKIE, STRINGPOINT, 22), ++ ++ /* This points to a linked list of headers, struct curl_slist kind. This ++ list is also used for RTSP (in spite of its name) */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ +- CINIT(SSLCERT, OBJECTPOINT, 25), ++ CINIT(SSLCERT, STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ +- CINIT(KEYPASSWD, OBJECTPOINT, 26), ++ CINIT(KEYPASSWD, STRINGPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ +- CINIT(WRITEHEADER, OBJECTPOINT, 29), ++ CINIT(HEADERDATA, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ +- CINIT(COOKIEFILE, OBJECTPOINT, 31), ++ CINIT(COOKIEFILE, STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + +@@ -781,87 +1084,88 @@ typedef enum { + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ +- CINIT(CUSTOMREQUEST, OBJECTPOINT, 36), +- +- /* HTTP request, for odd commands like DELETE, TRACE and others */ ++ CINIT(CUSTOMREQUEST, STRINGPOINT, 36), ++ ++ /* FILE handle to use instead of stderr */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + +- /* Pass a pointer to string of the output using full variable-replacement +- as described elsewhere. */ +- CINIT(WRITEINFO, OBJECTPOINT, 40), ++ CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */ + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ +- CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ ++ CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 400 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ +- CINIT(DIRLISTONLY, LONG, 48), /* return bare names when listing directories */ ++ CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ + + CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 55 = OBSOLETE */ + +- /* Function that will be called instead of the internal progress display ++ /* DEPRECATED ++ * Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + +- /* Data passed to the progress callback */ ++ /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION ++ callbacks */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), ++#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA + + /* We want the referrer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ +- CINIT(INTERFACE, OBJECTPOINT, 62), ++ CINIT(INTERFACE, STRINGPOINT, 62), + + /* Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but doesn't match one of these, 'private' will be used. */ +- CINIT(KRBLEVEL, OBJECTPOINT, 63), ++ CINIT(KRBLEVEL, STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ +- CINIT(CAINFO, OBJECTPOINT, 65), ++ CINIT(CAINFO, STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if +@@ -869,42 +1173,39 @@ typedef enum { + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + +- /* What policy to use when closing connections when the cache is filled +- up */ +- CINIT(CLOSEPOLICY, LONG, 72), ++ CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */ + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ +- CINIT(RANDOM_FILE, OBJECTPOINT, 76), ++ CINIT(RANDOM_FILE, STRINGPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ +- CINIT(EGDSOCKET, OBJECTPOINT, 77), +- +- /* Time-out connect operations after this amount of seconds, if connects +- are OK within this time, then fine... This only aborts the connect +- phase. [Only works on unix-style/SIGALRM operating systems] */ ++ CINIT(EGDSOCKET, STRINGPOINT, 77), ++ ++ /* Time-out connect operations after this amount of seconds, if connects are ++ OK within this time, then fine... This only aborts the connect phase. */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. +@@ -913,49 +1214,49 @@ typedef enum { + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ +- CINIT(COOKIEJAR, OBJECTPOINT, 82), ++ CINIT(COOKIEJAR, STRINGPOINT, 82), + + /* Specify which SSL ciphers to use */ +- CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83), ++ CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 84), + + /* Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ +- CINIT(SSLCERTTYPE, OBJECTPOINT, 86), ++ CINIT(SSLCERTTYPE, STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ +- CINIT(SSLKEY, OBJECTPOINT, 87), ++ CINIT(SSLKEY, STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ +- CINIT(SSLKEYTYPE, OBJECTPOINT, 88), ++ CINIT(SSLKEYTYPE, STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ +- CINIT(SSLENGINE, OBJECTPOINT, 89), ++ CINIT(SSLENGINE, STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ +- CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To become OBSOLETE soon */ ++ CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ +@@ -964,50 +1265,52 @@ typedef enum { + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ +- CINIT(CAPATH, OBJECTPOINT, 97), ++ CINIT(CAPATH, STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), +- CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */ ++ CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and ++ CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like +- the response to be compressed. */ +- CINIT(ENCODING, OBJECTPOINT, 102), ++ the response to be compressed. Before 7.21.6, this was known as ++ CURLOPT_ENCODING */ ++ CINIT(ACCEPT_ENCODING, STRINGPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + CINIT(UNRESTRICTED_AUTH, LONG, 105), + +- /* Specifically switch on or off the FTP engine's use of the EPRT command ( it +- also disables the LPRT attempt). By default, those ones will always be ++ /* Specifically switch on or off the FTP engine's use of the EPRT command ( ++ it also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CINIT(FTP_USE_EPRT, LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(HTTPAUTH, LONG, 107), + +@@ -1031,16 +1334,17 @@ typedef enum { + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP option that changes the timeout, in seconds, associated with + getting a response. This is different from transfer timeout time and + essentially places a demand on the FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), ++#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. +@@ -1063,22 +1367,22 @@ typedef enum { + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ +- CINIT(NETRC_FILE, OBJECTPOINT, 118), ++ CINIT(NETRC_FILE, STRINGPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: +- CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise +- CURLFTPSSL_CONTROL - SSL for the control connection or fail +- CURLFTPSSL_ALL - SSL for all communication or fail ++ CURLUSESSL_TRY - try using SSL, proceed anyway otherwise ++ CURLUSESSL_CONTROL - SSL for the control connection or fail ++ CURLUSESSL_ALL - SSL for all communication or fail + */ + CINIT(USE_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, LONG, 121), +@@ -1106,20 +1410,20 @@ typedef enum { + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ +- CINIT(FTP_ACCOUNT, OBJECTPOINT, 134), +- +- /* feed cookies into cookie engine */ +- CINIT(COOKIELIST, OBJECTPOINT, 135), ++ CINIT(FTP_ACCOUNT, STRINGPOINT, 134), ++ ++ /* feed cookie into cookie engine */ ++ CINIT(COOKIELIST, STRINGPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ +@@ -1155,32 +1459,32 @@ typedef enum { + CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), + CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ +- CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147), ++ CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147), + + /* callback function for setting socket options */ + CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), + CINIT(SOCKOPTDATA, OBJECTPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CINIT(SSL_SESSIONID_CACHE, LONG, 150), + + /* allowed SSH authentication methods */ + CINIT(SSH_AUTH_TYPES, LONG, 151), + + /* Used by scp/sftp to do public/private key authentication */ +- CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152), +- CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153), ++ CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152), ++ CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CINIT(FTP_SSL_CCC, LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CINIT(TIMEOUT_MS, LONG, 155), + CINIT(CONNECTTIMEOUT_MS, LONG, 156), + +@@ -1194,17 +1498,17 @@ typedef enum { + CINIT(NEW_FILE_PERMS, LONG, 159), + CINIT(NEW_DIRECTORY_PERMS, LONG, 160), + + /* Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CINIT(POSTREDIR, LONG, 161), + + /* used by scp/sftp to verify the host's public key */ +- CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162), ++ CINIT(SSH_HOST_PUBLIC_KEY_MD5, STRINGPOINT, 162), + + /* Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), + CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), + +@@ -1214,51 +1518,50 @@ typedef enum { + /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */ + CINIT(PROXY_TRANSFER_MODE, LONG, 166), + + /* Callback function for seeking in the input stream */ + CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), + CINIT(SEEKDATA, OBJECTPOINT, 168), + + /* CRL file */ +- CINIT(CRLFILE, OBJECTPOINT, 169), ++ CINIT(CRLFILE, STRINGPOINT, 169), + + /* Issuer certificate */ +- CINIT(ISSUERCERT, OBJECTPOINT, 170), ++ CINIT(ISSUERCERT, STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CINIT(ADDRESS_SCOPE, LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with +- CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only +- working with OpenSSL-powered builds. */ ++ CURLINFO_CERTINFO after the transfer is complete. */ + CINIT(CERTINFO, LONG, 172), + + /* "name" and "pwd" to use when fetching. */ +- CINIT(USERNAME, OBJECTPOINT, 173), +- CINIT(PASSWORD, OBJECTPOINT, 174), ++ CINIT(USERNAME, STRINGPOINT, 173), ++ CINIT(PASSWORD, STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ +- CINIT(PROXYUSERNAME, OBJECTPOINT, 175), +- CINIT(PROXYPASSWORD, OBJECTPOINT, 176), ++ CINIT(PROXYUSERNAME, STRINGPOINT, 175), ++ CINIT(PROXYPASSWORD, STRINGPOINT, 176), + + /* Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ +- CINIT(NOPROXY, OBJECTPOINT, 177), ++ CINIT(NOPROXY, STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ +- CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179), ++ CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179), /* DEPRECATED, do not use! */ + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_NEC, LONG, 180), + + /* set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ +@@ -1266,25 +1569,360 @@ typedef enum { + + /* set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. Defaults + to all protocols except FILE and SCP. */ + CINIT(REDIR_PROTOCOLS, LONG, 182), + + /* set the SSH knownhost file name to use */ +- CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183), ++ CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CINIT(SSH_KEYDATA, OBJECTPOINT, 185), + ++ /* set the SMTP mail originator */ ++ CINIT(MAIL_FROM, STRINGPOINT, 186), ++ ++ /* set the list of SMTP mail receiver(s) */ ++ CINIT(MAIL_RCPT, OBJECTPOINT, 187), ++ ++ /* FTP: send PRET before PASV */ ++ CINIT(FTP_USE_PRET, LONG, 188), ++ ++ /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ ++ CINIT(RTSP_REQUEST, LONG, 189), ++ ++ /* The RTSP session identifier */ ++ CINIT(RTSP_SESSION_ID, STRINGPOINT, 190), ++ ++ /* The RTSP stream URI */ ++ CINIT(RTSP_STREAM_URI, STRINGPOINT, 191), ++ ++ /* The Transport: header to use in RTSP requests */ ++ CINIT(RTSP_TRANSPORT, STRINGPOINT, 192), ++ ++ /* Manually initialize the client RTSP CSeq for this handle */ ++ CINIT(RTSP_CLIENT_CSEQ, LONG, 193), ++ ++ /* Manually initialize the server RTSP CSeq for this handle */ ++ CINIT(RTSP_SERVER_CSEQ, LONG, 194), ++ ++ /* The stream to pass to INTERLEAVEFUNCTION. */ ++ CINIT(INTERLEAVEDATA, OBJECTPOINT, 195), ++ ++ /* Let the application define a custom write method for RTP data */ ++ CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196), ++ ++ /* Turn on wildcard matching */ ++ CINIT(WILDCARDMATCH, LONG, 197), ++ ++ /* Directory matching callback called before downloading of an ++ individual file (chunk) started */ ++ CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198), ++ ++ /* Directory matching callback called after the file (chunk) ++ was downloaded, or skipped */ ++ CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199), ++ ++ /* Change match (fnmatch-like) callback for wildcard matching */ ++ CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200), ++ ++ /* Let the application define custom chunk data pointer */ ++ CINIT(CHUNK_DATA, OBJECTPOINT, 201), ++ ++ /* FNMATCH_FUNCTION user pointer */ ++ CINIT(FNMATCH_DATA, OBJECTPOINT, 202), ++ ++ /* send linked-list of name:port:address sets */ ++ CINIT(RESOLVE, OBJECTPOINT, 203), ++ ++ /* Set a username for authenticated TLS */ ++ CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204), ++ ++ /* Set a password for authenticated TLS */ ++ CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205), ++ ++ /* Set authentication type for authenticated TLS */ ++ CINIT(TLSAUTH_TYPE, STRINGPOINT, 206), ++ ++ /* Set to 1 to enable the "TE:" header in HTTP requests to ask for ++ compressed transfer-encoded responses. Set to 0 to disable the use of TE: ++ in outgoing requests. The current default is 0, but it might change in a ++ future libcurl release. ++ ++ libcurl will ask for the compressed methods it knows of, and if that ++ isn't any, it will not ask for transfer-encoding at all even if this ++ option is set to 1. ++ ++ */ ++ CINIT(TRANSFER_ENCODING, LONG, 207), ++ ++ /* Callback function for closing socket (instead of close(2)). The callback ++ should have type curl_closesocket_callback */ ++ CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208), ++ CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209), ++ ++ /* allow GSSAPI credential delegation */ ++ CINIT(GSSAPI_DELEGATION, LONG, 210), ++ ++ /* Set the name servers to use for DNS resolution */ ++ CINIT(DNS_SERVERS, STRINGPOINT, 211), ++ ++ /* Time-out accept operations (currently for FTP only) after this amount ++ of milliseconds. */ ++ CINIT(ACCEPTTIMEOUT_MS, LONG, 212), ++ ++ /* Set TCP keepalive */ ++ CINIT(TCP_KEEPALIVE, LONG, 213), ++ ++ /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ ++ CINIT(TCP_KEEPIDLE, LONG, 214), ++ CINIT(TCP_KEEPINTVL, LONG, 215), ++ ++ /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ ++ CINIT(SSL_OPTIONS, LONG, 216), ++ ++ /* Set the SMTP auth originator */ ++ CINIT(MAIL_AUTH, STRINGPOINT, 217), ++ ++ /* Enable/disable SASL initial response */ ++ CINIT(SASL_IR, LONG, 218), ++ ++ /* Function that will be called instead of the internal progress display ++ * function. This function should be defined as the curl_xferinfo_callback ++ * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ ++ CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219), ++ ++ /* The XOAUTH2 bearer token */ ++ CINIT(XOAUTH2_BEARER, STRINGPOINT, 220), ++ ++ /* Set the interface string to use as outgoing network ++ * interface for DNS requests. ++ * Only supported by the c-ares DNS backend */ ++ CINIT(DNS_INTERFACE, STRINGPOINT, 221), ++ ++ /* Set the local IPv4 address to use for outgoing DNS requests. ++ * Only supported by the c-ares DNS backend */ ++ CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222), ++ ++ /* Set the local IPv6 address to use for outgoing DNS requests. ++ * Only supported by the c-ares DNS backend */ ++ CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223), ++ ++ /* Set authentication options directly */ ++ CINIT(LOGIN_OPTIONS, STRINGPOINT, 224), ++ ++ /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ ++ CINIT(SSL_ENABLE_NPN, LONG, 225), ++ ++ /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ ++ CINIT(SSL_ENABLE_ALPN, LONG, 226), ++ ++ /* Time to wait for a response to a HTTP request containing an ++ * Expect: 100-continue header before sending the data anyway. */ ++ CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227), ++ ++ /* This points to a linked list of headers used for proxy requests only, ++ struct curl_slist kind */ ++ CINIT(PROXYHEADER, OBJECTPOINT, 228), ++ ++ /* Pass in a bitmask of "header options" */ ++ CINIT(HEADEROPT, LONG, 229), ++ ++ /* The public key in DER form used to validate the peer public key ++ this option is used only if SSL_VERIFYPEER is true */ ++ CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230), ++ ++ /* Path to Unix domain socket */ ++ CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231), ++ ++ /* Set if we should verify the certificate status. */ ++ CINIT(SSL_VERIFYSTATUS, LONG, 232), ++ ++ /* Set if we should enable TLS false start. */ ++ CINIT(SSL_FALSESTART, LONG, 233), ++ ++ /* Do not squash dot-dot sequences */ ++ CINIT(PATH_AS_IS, LONG, 234), ++ ++ /* Proxy Service Name */ ++ CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235), ++ ++ /* Service Name */ ++ CINIT(SERVICE_NAME, STRINGPOINT, 236), ++ ++ /* Wait/don't wait for pipe/mutex to clarify */ ++ CINIT(PIPEWAIT, LONG, 237), ++ ++ /* Set the protocol used when curl is given a URL without a protocol */ ++ CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238), ++ ++ /* Set stream weight, 1 - 256 (default is 16) */ ++ CINIT(STREAM_WEIGHT, LONG, 239), ++ ++ /* Set stream dependency on another CURL handle */ ++ CINIT(STREAM_DEPENDS, OBJECTPOINT, 240), ++ ++ /* Set E-xclusive stream dependency on another CURL handle */ ++ CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241), ++ ++ /* Do not send any tftp option requests to the server */ ++ CINIT(TFTP_NO_OPTIONS, LONG, 242), ++ ++ /* Linked-list of host:port:connect-to-host:connect-to-port, ++ overrides the URL's host:port (only for the network layer) */ ++ CINIT(CONNECT_TO, OBJECTPOINT, 243), ++ ++ /* Set TCP Fast Open */ ++ CINIT(TCP_FASTOPEN, LONG, 244), ++ ++ /* Continue to send data if the server responds early with an ++ * HTTP status code >= 300 */ ++ CINIT(KEEP_SENDING_ON_ERROR, LONG, 245), ++ ++ /* The CApath or CAfile used to validate the proxy certificate ++ this option is used only if PROXY_SSL_VERIFYPEER is true */ ++ CINIT(PROXY_CAINFO, STRINGPOINT, 246), ++ ++ /* The CApath directory used to validate the proxy certificate ++ this option is used only if PROXY_SSL_VERIFYPEER is true */ ++ CINIT(PROXY_CAPATH, STRINGPOINT, 247), ++ ++ /* Set if we should verify the proxy in ssl handshake, ++ set 1 to verify. */ ++ CINIT(PROXY_SSL_VERIFYPEER, LONG, 248), ++ ++ /* Set if we should verify the Common name from the proxy certificate in ssl ++ * handshake, set 1 to check existence, 2 to ensure that it matches ++ * the provided hostname. */ ++ CINIT(PROXY_SSL_VERIFYHOST, LONG, 249), ++ ++ /* What version to specifically try to use for proxy. ++ See CURL_SSLVERSION defines below. */ ++ CINIT(PROXY_SSLVERSION, LONG, 250), ++ ++ /* Set a username for authenticated TLS for proxy */ ++ CINIT(PROXY_TLSAUTH_USERNAME, STRINGPOINT, 251), ++ ++ /* Set a password for authenticated TLS for proxy */ ++ CINIT(PROXY_TLSAUTH_PASSWORD, STRINGPOINT, 252), ++ ++ /* Set authentication type for authenticated TLS for proxy */ ++ CINIT(PROXY_TLSAUTH_TYPE, STRINGPOINT, 253), ++ ++ /* name of the file keeping your private SSL-certificate for proxy */ ++ CINIT(PROXY_SSLCERT, STRINGPOINT, 254), ++ ++ /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for ++ proxy */ ++ CINIT(PROXY_SSLCERTTYPE, STRINGPOINT, 255), ++ ++ /* name of the file keeping your private SSL-key for proxy */ ++ CINIT(PROXY_SSLKEY, STRINGPOINT, 256), ++ ++ /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for ++ proxy */ ++ CINIT(PROXY_SSLKEYTYPE, STRINGPOINT, 257), ++ ++ /* password for the SSL private key for proxy */ ++ CINIT(PROXY_KEYPASSWD, STRINGPOINT, 258), ++ ++ /* Specify which SSL ciphers to use for proxy */ ++ CINIT(PROXY_SSL_CIPHER_LIST, STRINGPOINT, 259), ++ ++ /* CRL file for proxy */ ++ CINIT(PROXY_CRLFILE, STRINGPOINT, 260), ++ ++ /* Enable/disable specific SSL features with a bitmask for proxy, see ++ CURLSSLOPT_* */ ++ CINIT(PROXY_SSL_OPTIONS, LONG, 261), ++ ++ /* Name of pre proxy to use. */ ++ CINIT(PRE_PROXY, STRINGPOINT, 262), ++ ++ /* The public key in DER form used to validate the proxy public key ++ this option is used only if PROXY_SSL_VERIFYPEER is true */ ++ CINIT(PROXY_PINNEDPUBLICKEY, STRINGPOINT, 263), ++ ++ /* Path to an abstract Unix domain socket */ ++ CINIT(ABSTRACT_UNIX_SOCKET, STRINGPOINT, 264), ++ ++ /* Suppress proxy CONNECT response headers from user callbacks */ ++ CINIT(SUPPRESS_CONNECT_HEADERS, LONG, 265), ++ ++ /* The request target, instead of extracted from the URL */ ++ CINIT(REQUEST_TARGET, STRINGPOINT, 266), ++ ++ /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ ++ CINIT(SOCKS5_AUTH, LONG, 267), ++ ++ /* Enable/disable SSH compression */ ++ CINIT(SSH_COMPRESSION, LONG, 268), ++ ++ /* Post MIME data. */ ++ CINIT(MIMEPOST, OBJECTPOINT, 269), ++ ++ /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of ++ seconds since 1 Jan 1970. */ ++ CINIT(TIMEVALUE_LARGE, OFF_T, 270), ++ ++ /* Head start in milliseconds to give happy eyeballs. */ ++ CINIT(HAPPY_EYEBALLS_TIMEOUT_MS, LONG, 271), ++ ++ /* Function that will be called before a resolver request is made */ ++ CINIT(RESOLVER_START_FUNCTION, FUNCTIONPOINT, 272), ++ ++ /* User data to pass to the resolver start callback. */ ++ CINIT(RESOLVER_START_DATA, OBJECTPOINT, 273), ++ ++ /* send HAProxy PROXY protocol header? */ ++ CINIT(HAPROXYPROTOCOL, LONG, 274), ++ ++ /* shuffle addresses before use when DNS returns multiple */ ++ CINIT(DNS_SHUFFLE_ADDRESSES, LONG, 275), ++ ++ /* Specify which TLS 1.3 ciphers suites to use */ ++ CINIT(TLS13_CIPHERS, STRINGPOINT, 276), ++ CINIT(PROXY_TLS13_CIPHERS, STRINGPOINT, 277), ++ ++ /* Disallow specifying username/login in URL. */ ++ CINIT(DISALLOW_USERNAME_IN_URL, LONG, 278), ++ ++ /* DNS-over-HTTPS URL */ ++ CINIT(DOH_URL, STRINGPOINT, 279), ++ ++ /* Preferred buffer size to use for uploads */ ++ CINIT(UPLOAD_BUFFERSIZE, LONG, 280), ++ ++ /* Time in ms between connection upkeep calls for long-lived connections. */ ++ CINIT(UPKEEP_INTERVAL_MS, LONG, 281), ++ ++ /* Specify URL using CURL URL API. */ ++ CINIT(CURLU, OBJECTPOINT, 282), ++ ++ /* add trailing data just after no more data is available */ ++ CINIT(TRAILERFUNCTION, FUNCTIONPOINT, 283), ++ ++ /* pointer to be passed to HTTP_TRAILER_FUNCTION */ ++ CINIT(TRAILERDATA, OBJECTPOINT, 284), ++ ++ /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ ++ CINIT(HTTP09_ALLOWED, LONG, 285), ++ ++ /* alt-svc control bitmask */ ++ CINIT(ALTSVC_CTRL, LONG, 286), ++ ++ /* alt-svc cache file name to possibly read from/write to */ ++ CINIT(ALTSVC, STRINGPOINT, 287), ++ + CURLOPT_LASTENTRY /* the last unused */ + } CURLoption; + + #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + + /* Backwards compatibility with older names */ + /* These are scheduled to disappear by 2011 */ +@@ -1311,81 +1949,260 @@ typedef enum { + #endif + + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ + #define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP + versions that your system allows */ +-#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */ +-#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */ ++#define CURL_IPRESOLVE_V4 1 /* resolve to IPv4 addresses */ ++#define CURL_IPRESOLVE_V6 2 /* resolve to IPv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +-#define CURLOPT_WRITEDATA CURLOPT_FILE +-#define CURLOPT_READDATA CURLOPT_INFILE +-#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER ++#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ + enum { + CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ ++ CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */ ++ CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */ ++ CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1 ++ Upgrade */ + + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ + }; + ++/* Convenience definition simple because the name of the version is HTTP/2 and ++ not 2.0. The 2_0 version of the enum name was set while the version was ++ still planned to be 2.0 and we stick to it for compatibility. */ ++#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0 ++ ++/* ++ * Public API enums for RTSP requests ++ */ ++enum { ++ CURL_RTSPREQ_NONE, /* first in list */ ++ CURL_RTSPREQ_OPTIONS, ++ CURL_RTSPREQ_DESCRIBE, ++ CURL_RTSPREQ_ANNOUNCE, ++ CURL_RTSPREQ_SETUP, ++ CURL_RTSPREQ_PLAY, ++ CURL_RTSPREQ_PAUSE, ++ CURL_RTSPREQ_TEARDOWN, ++ CURL_RTSPREQ_GET_PARAMETER, ++ CURL_RTSPREQ_SET_PARAMETER, ++ CURL_RTSPREQ_RECORD, ++ CURL_RTSPREQ_RECEIVE, ++ CURL_RTSPREQ_LAST /* last in list */ ++}; ++ + /* These enums are for use with the CURLOPT_NETRC option. */ + enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST + }; + + enum { + CURL_SSLVERSION_DEFAULT, +- CURL_SSLVERSION_TLSv1, ++ CURL_SSLVERSION_TLSv1, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, ++ CURL_SSLVERSION_TLSv1_0, ++ CURL_SSLVERSION_TLSv1_1, ++ CURL_SSLVERSION_TLSv1_2, ++ CURL_SSLVERSION_TLSv1_3, + + CURL_SSLVERSION_LAST /* never use, keep last */ + }; + ++enum { ++ CURL_SSLVERSION_MAX_NONE = 0, ++ CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16), ++ CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16), ++ CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16), ++ CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16), ++ CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16), ++ ++ /* never use, keep last */ ++ CURL_SSLVERSION_MAX_LAST = (CURL_SSLVERSION_LAST << 16) ++}; ++ ++enum CURL_TLSAUTH { ++ CURL_TLSAUTH_NONE, ++ CURL_TLSAUTH_SRP, ++ CURL_TLSAUTH_LAST /* never use, keep last */ ++}; ++ + /* symbols to use with CURLOPT_POSTREDIR. +- CURL_REDIR_POST_301 and CURL_REDIR_POST_302 can be bitwise ORed so that +- CURL_REDIR_POST_301 | CURL_REDIR_POST_302 == CURL_REDIR_POST_ALL */ ++ CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 ++ can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 ++ | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */ + + #define CURL_REDIR_GET_ALL 0 + #define CURL_REDIR_POST_301 1 + #define CURL_REDIR_POST_302 2 +-#define CURL_REDIR_POST_ALL (CURL_REDIR_POST_301|CURL_REDIR_POST_302) ++#define CURL_REDIR_POST_303 4 ++#define CURL_REDIR_POST_ALL \ ++ (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) + + typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST + } curl_TimeCond; + ++/* Special size_t value signaling a zero-terminated string. */ ++#define CURL_ZERO_TERMINATED ((size_t) -1) + + /* curl_strequal() and curl_strnequal() are subject for removal in a future +- libcurl, see lib/README.curlx for details */ +-CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2); +-CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n); +- ++ release */ ++CURL_EXTERN int curl_strequal(const char *s1, const char *s2); ++CURL_EXTERN int curl_strnequal(const char *s1, const char *s2, size_t n); ++ ++/* Mime/form handling support. */ ++typedef struct curl_mime_s curl_mime; /* Mime context. */ ++typedef struct curl_mimepart_s curl_mimepart; /* Mime part context. */ ++ ++/* ++ * NAME curl_mime_init() ++ * ++ * DESCRIPTION ++ * ++ * Create a mime context and return its handle. The easy parameter is the ++ * target handle. ++ */ ++CURL_EXTERN curl_mime *curl_mime_init(CURL *easy); ++ ++/* ++ * NAME curl_mime_free() ++ * ++ * DESCRIPTION ++ * ++ * release a mime handle and its substructures. ++ */ ++CURL_EXTERN void curl_mime_free(curl_mime *mime); ++ ++/* ++ * NAME curl_mime_addpart() ++ * ++ * DESCRIPTION ++ * ++ * Append a new empty part to the given mime context and return a handle to ++ * the created part. ++ */ ++CURL_EXTERN curl_mimepart *curl_mime_addpart(curl_mime *mime); ++ ++/* ++ * NAME curl_mime_name() ++ * ++ * DESCRIPTION ++ * ++ * Set mime/form part name. ++ */ ++CURL_EXTERN CURLcode curl_mime_name(curl_mimepart *part, const char *name); ++ ++/* ++ * NAME curl_mime_filename() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part remote file name. ++ */ ++CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part, ++ const char *filename); ++ ++/* ++ * NAME curl_mime_type() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part type. ++ */ ++CURL_EXTERN CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype); ++ ++/* ++ * NAME curl_mime_encoder() ++ * ++ * DESCRIPTION ++ * ++ * Set mime data transfer encoder. ++ */ ++CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part, ++ const char *encoding); ++ ++/* ++ * NAME curl_mime_data() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part data source from memory data, ++ */ ++CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part, ++ const char *data, size_t datasize); ++ ++/* ++ * NAME curl_mime_filedata() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part data source from named file. ++ */ ++CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part, ++ const char *filename); ++ ++/* ++ * NAME curl_mime_data_cb() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part data source from callback function. ++ */ ++CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part, ++ curl_off_t datasize, ++ curl_read_callback readfunc, ++ curl_seek_callback seekfunc, ++ curl_free_callback freefunc, ++ void *arg); ++ ++/* ++ * NAME curl_mime_subparts() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part data source from subparts. ++ */ ++CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, ++ curl_mime *subparts); ++/* ++ * NAME curl_mime_headers() ++ * ++ * DESCRIPTION ++ * ++ * Set mime part headers. ++ */ ++CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part, ++ struct curl_slist *headers, ++ int take_ownership); ++ ++/* Old form API. */ + /* name is uppercase CURLFORM_<name> */ + #ifdef CFINIT + #undef CFINIT + #endif + + #ifdef CURL_ISOCPP + #define CFINIT(name) CURLFORM_ ## name + #else +@@ -1414,16 +2231,17 @@ typedef enum { + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CFINIT(STREAM), ++ CFINIT(CONTENTLEN), /* added in 7.46.0, provide a curl_off_t length */ + + CURLFORM_LASTENTRY /* the last unused */ + } CURLformoption; + + #undef CFINIT /* done */ + + /* structure to be used as parameter for CURLFORM_ARRAY */ + struct curl_forms { +@@ -1477,17 +2295,18 @@ CURL_EXTERN CURLFORMcode curl_formadd(st + /* + * callback function for curl_formget() + * The void *arg pointer will be the one passed as second argument to + * curl_formget(). + * The character buffer passed to it must not be freed. + * Should return the buffer length passed to it as the argument "len" on + * success. + */ +-typedef size_t (*curl_formget_callback)(void *arg, const char *buf, size_t len); ++typedef size_t (*curl_formget_callback)(void *arg, const char *buf, ++ size_t len); + + /* + * NAME curl_formget() + * + * DESCRIPTION + * + * Serialize a curl_httppost struct built with curl_formadd(). + * Accepts a void pointer as second argument which will be passed to +@@ -1616,16 +2435,57 @@ CURL_EXTERN void curl_global_cleanup(voi + + /* linked-list structure for the CURLOPT_QUOTE option (and other) */ + struct curl_slist { + char *data; + struct curl_slist *next; + }; + + /* ++ * NAME curl_global_sslset() ++ * ++ * DESCRIPTION ++ * ++ * When built with multiple SSL backends, curl_global_sslset() allows to ++ * choose one. This function can only be called once, and it must be called ++ * *before* curl_global_init(). ++ * ++ * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The ++ * backend can also be specified via the name parameter (passing -1 as id). ++ * If both id and name are specified, the name will be ignored. If neither id ++ * nor name are specified, the function will fail with ++ * CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the ++ * NULL-terminated list of available backends. ++ * ++ * Upon success, the function returns CURLSSLSET_OK. ++ * ++ * If the specified SSL backend is not available, the function returns ++ * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated ++ * list of available SSL backends. ++ * ++ * The SSL backend can be set only once. If it has already been set, a ++ * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE. ++ */ ++ ++typedef struct { ++ curl_sslbackend id; ++ const char *name; ++} curl_ssl_backend; ++ ++typedef enum { ++ CURLSSLSET_OK = 0, ++ CURLSSLSET_UNKNOWN_BACKEND, ++ CURLSSLSET_TOO_LATE, ++ CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */ ++} CURLsslset; ++ ++CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name, ++ const curl_ssl_backend ***avail); ++ ++/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ + CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *, +@@ -1655,41 +2515,59 @@ CURL_EXTERN time_t curl_getdate(const ch + for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ + struct curl_certinfo { + int num_of_certs; /* number of certificates with information */ + struct curl_slist **certinfo; /* for each index in this array, there's a + linked list with textual information in the + format "name: value" */ + }; + ++/* Information about the SSL library used and the respective internal SSL ++ handle, which can be used to obtain further information regarding the ++ connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */ ++struct curl_tlssessioninfo { ++ curl_sslbackend backend; ++ void *internals; ++}; ++ + #define CURLINFO_STRING 0x100000 + #define CURLINFO_LONG 0x200000 + #define CURLINFO_DOUBLE 0x300000 + #define CURLINFO_SLIST 0x400000 ++#define CURLINFO_PTR 0x400000 /* same as SLIST */ ++#define CURLINFO_SOCKET 0x500000 ++#define CURLINFO_OFF_T 0x600000 + #define CURLINFO_MASK 0x0fffff + #define CURLINFO_TYPEMASK 0xf00000 + + typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7, ++ CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, ++ CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, ++ CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, ++ CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, ++ CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, ++ CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, ++ CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, +@@ -1697,21 +2575,45 @@ typedef enum { + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + CURLINFO_LASTSOCKET = CURLINFO_LONG + 29, + CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, + CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, + CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, + CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, +- CURLINFO_CERTINFO = CURLINFO_SLIST + 34, ++ CURLINFO_CERTINFO = CURLINFO_PTR + 34, + CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, ++ CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, ++ CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, ++ CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, ++ CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, ++ CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, ++ CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, ++ CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, ++ CURLINFO_TLS_SESSION = CURLINFO_PTR + 43, ++ CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44, ++ CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45, ++ CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46, ++ CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47, ++ CURLINFO_PROTOCOL = CURLINFO_LONG + 48, ++ CURLINFO_SCHEME = CURLINFO_STRING + 49, + /* Fill in new entries below here! */ + +- CURLINFO_LASTONE = 35 ++ /* Preferably these would be defined conditionally based on the ++ sizeof curl_off_t being 64-bits */ ++ CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50, ++ CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51, ++ CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52, ++ CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53, ++ CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54, ++ CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55, ++ CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56, ++ ++ CURLINFO_LASTONE = 56 + } CURLINFO; + + /* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ + #define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + + typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ +@@ -1720,21 +2622,22 @@ typedef enum { + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ + } curl_closepolicy; + +-#define CURL_GLOBAL_SSL (1<<0) ++#define CURL_GLOBAL_SSL (1<<0) /* no purpose since since 7.57.0 */ + #define CURL_GLOBAL_WIN32 (1<<1) + #define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) + #define CURL_GLOBAL_NOTHING 0 + #define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL ++#define CURL_GLOBAL_ACK_EINTR (1<<2) + + + /***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + + /* Different data locks for a single share */ + typedef enum { +@@ -1743,16 +2646,17 @@ typedef enum { + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, ++ CURL_LOCK_DATA_PSL, + CURL_LOCK_DATA_LAST + } curl_lock_data; + + /* Different lock access types */ + typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ +@@ -1762,25 +2666,25 @@ typedef enum { + typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); + typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + +-typedef void CURLSH; + + typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ +- CURLSHE_NOMEM, /* out of memory */ +- CURLSHE_LAST /* never use */ ++ CURLSHE_NOMEM, /* 4 out of memory */ ++ CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ ++ CURLSHE_LAST /* never use */ + } CURLSHcode; + + typedef enum { + CURLSHOPT_NONE, /* don't use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ +@@ -1797,25 +2701,26 @@ CURL_EXTERN CURLSHcode curl_share_cleanu + * Structures for querying information about the curl library at runtime. + */ + + typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, ++ CURLVERSION_FIFTH, + CURLVERSION_LAST /* never actually use this */ + } CURLversion; + + /* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +-#define CURLVERSION_NOW CURLVERSION_FOURTH ++#define CURLVERSION_NOW CURLVERSION_FIFTH + + typedef struct { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ +@@ -1833,34 +2738,56 @@ typedef struct { + + /* These field were added in CURLVERSION_FOURTH */ + + /* Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + + const char *libssh_version; /* human readable string */ + ++ /* These fields were added in CURLVERSION_FIFTH */ ++ ++ unsigned int brotli_ver_num; /* Numeric Brotli version ++ (MAJOR << 24) | (MINOR << 12) | PATCH */ ++ const char *brotli_version; /* human readable string. */ ++ + } curl_version_info_data; + +-#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +-#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */ +-#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +-#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +-#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +-#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */ +-#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */ +-#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */ +-#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */ +-#define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */ +-#define CURL_VERSION_IDN (1<<10) /* International Domain Names support */ +-#define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */ +-#define CURL_VERSION_CONV (1<<12) /* character conversions supported */ +-#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */ +- +-/* ++#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ ++#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported ++ (deprecated) */ ++#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ ++#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ ++#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ ++#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported ++ (deprecated) */ ++#define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */ ++#define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */ ++#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */ ++#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */ ++#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are ++ supported */ ++#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */ ++#define CURL_VERSION_CONV (1<<12) /* Character conversions supported */ ++#define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */ ++#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ ++#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper ++ is supported */ ++#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ ++#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */ ++#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */ ++#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */ ++#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used ++ for cookie domain verification */ ++#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */ ++#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */ ++#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */ ++#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */ ++ ++ /* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ + CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); +@@ -1910,16 +2837,17 @@ CURL_EXTERN CURLcode curl_easy_pause(CUR + #ifdef __cplusplus + } + #endif + + /* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ + #include "easy.h" /* nothing in curl is fun without the easy stuff */ + #include "multi.h" ++#include "urlapi.h" + + /* the typechecker doesn't work in C++ (yet) */ + #if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ + ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ + !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) + #include "typecheck-gcc.h" + #else + #if defined(__STDC__) && (__STDC__ >= 1) +diff --git a/src/third_party/curl/curlbuild.h b/src/third_party/curl/curlbuild.h +deleted file mode 100644 +--- a/src/third_party/curl/curlbuild.h ++++ /dev/null +@@ -1,203 +0,0 @@ +-/* include/curl/curlbuild.h. Generated from curlbuild.h.in by configure. */ +-#ifndef __CURL_CURLBUILD_H +-#define __CURL_CURLBUILD_H +-/*************************************************************************** +- * _ _ ____ _ +- * Project ___| | | | _ \| | +- * / __| | | | |_) | | +- * | (__| |_| | _ <| |___ +- * \___|\___/|_| \_\_____| +- * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. +- * +- * This software is licensed as described in the file COPYING, which +- * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. +- * +- * You may opt to use, copy, modify, merge, publish, distribute and/or sell +- * copies of the Software, and permit persons to whom the Software is +- * furnished to do so, under the terms of the COPYING file. +- * +- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +- * KIND, either express or implied. +- * +- * $Id: curlbuild.h.in,v 1.8 2009-04-29 15:15:38 yangtse Exp $ +- ***************************************************************************/ +- +-/* ================================================================ */ +-/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +-/* ================================================================ */ +- +-/* +- * NOTE 1: +- * ------- +- * +- * Nothing in this file is intended to be modified or adjusted by the +- * curl library user nor by the curl library builder. +- * +- * If you think that something actually needs to be changed, adjusted +- * or fixed in this file, then, report it on the libcurl development +- * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ +- * +- * This header file shall only export symbols which are 'curl' or 'CURL' +- * prefixed, otherwise public name space would be polluted. +- * +- * NOTE 2: +- * ------- +- * +- * Right now you might be staring at file include/curl/curlbuild.h.in or +- * at file include/curl/curlbuild.h, this is due to the following reason: +- * +- * On systems capable of running the configure script, the configure process +- * will overwrite the distributed include/curl/curlbuild.h file with one that +- * is suitable and specific to the library being configured and built, which +- * is generated from the include/curl/curlbuild.h.in template file. +- * +- */ +- +-/* ================================================================ */ +-/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +-/* ================================================================ */ +- +-#ifdef CURL_SIZEOF_LONG +-# error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +-#endif +- +-#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +-# error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +-#endif +- +-#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +-# error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +-#endif +- +-#ifdef CURL_TYPEOF_CURL_OFF_T +-# error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +-#endif +- +-#ifdef CURL_FORMAT_CURL_OFF_T +-# error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +-#endif +- +-#ifdef CURL_FORMAT_CURL_OFF_TU +-# error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +-#endif +- +-#ifdef CURL_FORMAT_OFF_T +-# error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +-#endif +- +-#ifdef CURL_SIZEOF_CURL_OFF_T +-# error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +-#endif +- +-#ifdef CURL_SUFFIX_CURL_OFF_T +-# error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +-#endif +- +-#ifdef CURL_SUFFIX_CURL_OFF_TU +-# error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" +- Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +-#endif +- +-/* ================================================================ */ +-/* EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY */ +-/* ================================================================ */ +- +-/* Configure process defines this to 1 when it finds out that system */ +-/* header file ws2tcpip.h must be included by the external interface. */ +-/* #undef CURL_PULL_WS2TCPIP_H */ +-#ifdef CURL_PULL_WS2TCPIP_H +-# ifndef WIN32_LEAN_AND_MEAN +-# define WIN32_LEAN_AND_MEAN +-# endif +-# include <windows.h> +-# include <winsock2.h> +-# include <ws2tcpip.h> +-#endif +- +-/* Configure process defines this to 1 when it finds out that system */ +-/* header file sys/types.h must be included by the external interface. */ +-#define CURL_PULL_SYS_TYPES_H 1 +-#ifdef CURL_PULL_SYS_TYPES_H +-# include <sys/types.h> +-#endif +- +-/* Configure process defines this to 1 when it finds out that system */ +-/* header file stdint.h must be included by the external interface. */ +-/* #undef CURL_PULL_STDINT_H */ +-#ifdef CURL_PULL_STDINT_H +-# include <stdint.h> +-#endif +- +-/* Configure process defines this to 1 when it finds out that system */ +-/* header file inttypes.h must be included by the external interface. */ +-/* #undef CURL_PULL_INTTYPES_H */ +-#ifdef CURL_PULL_INTTYPES_H +-# include <inttypes.h> +-#endif +- +-/* Configure process defines this to 1 when it finds out that system */ +-/* header file sys/socket.h must be included by the external interface. */ +-#define CURL_PULL_SYS_SOCKET_H 1 +-#ifdef CURL_PULL_SYS_SOCKET_H +-# include <sys/socket.h> +-#endif +- +-/* The size of `long', as computed by sizeof. */ +-#if defined(_M_X64) || (defined(__x86_64__) && !defined(__ILP32__)) || \ +- defined(__aarch64__) || (defined(__mips__) && _MIPS_SIM == _ABI64) || \ +- defined(__powerpc64__) || defined(__s390x__) || defined(__LP64__) +-#define CURL_SIZEOF_LONG 8 +-#else +-#define CURL_SIZEOF_LONG 4 +-#endif +- +-/* Integral data type used for curl_socklen_t. */ +-#define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +- +-/* The size of `curl_socklen_t', as computed by sizeof. */ +-#define CURL_SIZEOF_CURL_SOCKLEN_T 4 +- +-/* Data type definition of curl_socklen_t. */ +-typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; +- +-/* Signed integral data type used for curl_off_t. */ +-#if defined(_M_X64) || (defined(__x86_64__) && !defined(__ILP32__)) || \ +- defined(__aarch64__) +-#define CURL_TYPEOF_CURL_OFF_T long +-#else +-#define CURL_TYPEOF_CURL_OFF_T int64_t +-#endif +- +-/* Data type definition of curl_off_t. */ +-typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; +- +-/* curl_off_t formatting string directive without "%" conversion specifier. */ +-#define CURL_FORMAT_CURL_OFF_T "ld" +- +-/* unsigned curl_off_t formatting string without "%" conversion specifier. */ +-#define CURL_FORMAT_CURL_OFF_TU "lu" +- +-/* curl_off_t formatting string directive with "%" conversion specifier. */ +-#define CURL_FORMAT_OFF_T "%ld" +- +-/* The size of `curl_off_t', as computed by sizeof. */ +-#define CURL_SIZEOF_CURL_OFF_T 8 +- +-/* curl_off_t constant suffix. */ +-#define CURL_SUFFIX_CURL_OFF_T L +- +-/* unsigned curl_off_t constant suffix. */ +-#define CURL_SUFFIX_CURL_OFF_TU UL +- +-#endif /* __CURL_CURLBUILD_H */ +diff --git a/src/third_party/curl/curlrules.h b/src/third_party/curl/curlrules.h +deleted file mode 100644 +--- a/src/third_party/curl/curlrules.h ++++ /dev/null +@@ -1,249 +0,0 @@ +-#ifndef __CURL_CURLRULES_H +-#define __CURL_CURLRULES_H +-/*************************************************************************** +- * _ _ ____ _ +- * Project ___| | | | _ \| | +- * / __| | | | |_) | | +- * | (__| |_| | _ <| |___ +- * \___|\___/|_| \_\_____| +- * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. +- * +- * This software is licensed as described in the file COPYING, which +- * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. +- * +- * You may opt to use, copy, modify, merge, publish, distribute and/or sell +- * copies of the Software, and permit persons to whom the Software is +- * furnished to do so, under the terms of the COPYING file. +- * +- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +- * KIND, either express or implied. +- * +- * $Id: curlrules.h,v 1.7 2009-10-27 16:56:20 yangtse Exp $ +- ***************************************************************************/ +- +-/* ================================================================ */ +-/* COMPILE TIME SANITY CHECKS */ +-/* ================================================================ */ +- +-/* +- * NOTE 1: +- * ------- +- * +- * All checks done in this file are intentionally placed in a public +- * header file which is pulled by curl/curl.h when an application is +- * being built using an already built libcurl library. Additionally +- * this file is also included and used when building the library. +- * +- * If compilation fails on this file it is certainly sure that the +- * problem is elsewhere. It could be a problem in the curlbuild.h +- * header file, or simply that you are using different compilation +- * settings than those used to build the library. +- * +- * Nothing in this file is intended to be modified or adjusted by the +- * curl library user nor by the curl library builder. +- * +- * Do not deactivate any check, these are done to make sure that the +- * library is properly built and used. +- * +- * You can find further help on the libcurl development mailing list: +- * http://cool.haxx.se/mailman/listinfo/curl-library/ +- * +- * NOTE 2 +- * ------ +- * +- * Some of the following compile time checks are based on the fact +- * that the dimension of a constant array can not be a negative one. +- * In this way if the compile time verification fails, the compilation +- * will fail issuing an error. The error description wording is compiler +- * dependent but it will be quite similar to one of the following: +- * +- * "negative subscript or subscript is too large" +- * "array must have at least one element" +- * "-1 is an illegal array size" +- * "size of array is negative" +- * +- * If you are building an application which tries to use an already +- * built libcurl library and you are getting this kind of errors on +- * this file, it is a clear indication that there is a mismatch between +- * how the library was built and how you are trying to use it for your +- * application. Your already compiled or binary library provider is the +- * only one who can give you the details you need to properly use it. +- */ +- +-/* +- * Verify that some macros are actually defined. +- */ +- +-#ifndef CURL_SIZEOF_LONG +-# error "CURL_SIZEOF_LONG definition is missing!" +- Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing +-#endif +- +-#ifndef CURL_TYPEOF_CURL_SOCKLEN_T +-# error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!" +- Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing +-#endif +- +-#ifndef CURL_SIZEOF_CURL_SOCKLEN_T +-# error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!" +- Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing +-#endif +- +-#ifndef CURL_TYPEOF_CURL_OFF_T +-# error "CURL_TYPEOF_CURL_OFF_T definition is missing!" +- Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing +-#endif +- +-#ifndef CURL_FORMAT_CURL_OFF_T +-# error "CURL_FORMAT_CURL_OFF_T definition is missing!" +- Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing +-#endif +- +-#ifndef CURL_FORMAT_CURL_OFF_TU +-# error "CURL_FORMAT_CURL_OFF_TU definition is missing!" +- Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing +-#endif +- +-#ifndef CURL_FORMAT_OFF_T +-# error "CURL_FORMAT_OFF_T definition is missing!" +- Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing +-#endif +- +-#ifndef CURL_SIZEOF_CURL_OFF_T +-# error "CURL_SIZEOF_CURL_OFF_T definition is missing!" +- Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing +-#endif +- +-#ifndef CURL_SUFFIX_CURL_OFF_T +-# error "CURL_SUFFIX_CURL_OFF_T definition is missing!" +- Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing +-#endif +- +-#ifndef CURL_SUFFIX_CURL_OFF_TU +-# error "CURL_SUFFIX_CURL_OFF_TU definition is missing!" +- Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing +-#endif +- +-/* +- * Macros private to this header file. +- */ +- +-#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1 +- +-#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1 +- +-/* +- * Verify that the size previously defined and expected for long +- * is the same as the one reported by sizeof() at compile time. +- */ +- +-typedef char +- __curl_rule_01__ +- [CurlchkszEQ(long, CURL_SIZEOF_LONG)]; +- +-/* +- * Verify that the size previously defined and expected for +- * curl_off_t is actually the the same as the one reported +- * by sizeof() at compile time. +- */ +- +-typedef char +- __curl_rule_02__ +- [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)]; +- +-/* +- * Verify at compile time that the size of curl_off_t as reported +- * by sizeof() is greater or equal than the one reported for long +- * for the current compilation. +- */ +- +-typedef char +- __curl_rule_03__ +- [CurlchkszGE(curl_off_t, long)]; +- +-/* +- * Verify that the size previously defined and expected for +- * curl_socklen_t is actually the the same as the one reported +- * by sizeof() at compile time. +- */ +- +-typedef char +- __curl_rule_04__ +- [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)]; +- +-/* +- * Verify at compile time that the size of curl_socklen_t as reported +- * by sizeof() is greater or equal than the one reported for int for +- * the current compilation. +- */ +- +-typedef char +- __curl_rule_05__ +- [CurlchkszGE(curl_socklen_t, int)]; +- +-/* ================================================================ */ +-/* EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS */ +-/* ================================================================ */ +- +-/* +- * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow +- * these to be visible and exported by the external libcurl interface API, +- * while also making them visible to the library internals, simply including +- * setup.h, without actually needing to include curl.h internally. +- * If some day this section would grow big enough, all this should be moved +- * to its own header file. +- */ +- +-/* +- * Figure out if we can use the ## preprocessor operator, which is supported +- * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ +- * or __cplusplus so we need to carefully check for them too. +- */ +- +-#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ +- defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ +- defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ +- defined(__ILEC400__) +- /* This compiler is believed to have an ISO compatible preprocessor */ +-#define CURL_ISOCPP +-#else +- /* This compiler is believed NOT to have an ISO compatible preprocessor */ +-#undef CURL_ISOCPP +-#endif +- +-/* +- * Macros for minimum-width signed and unsigned curl_off_t integer constants. +- */ +- +-#ifdef CURL_ISOCPP +-# define __CURL_OFF_T_C_HELPER2(Val,Suffix) Val ## Suffix +-#else +-# define __CURL_OFF_T_C_HELPER2(Val,Suffix) Val/**/Suffix +-#endif +-#define __CURL_OFF_T_C_HELPER1(Val,Suffix) __CURL_OFF_T_C_HELPER2(Val,Suffix) +-#define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HELPER1(Val,CURL_SUFFIX_CURL_OFF_T) +-#define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HELPER1(Val,CURL_SUFFIX_CURL_OFF_TU) +- +-/* +- * Get rid of macros private to this header file. +- */ +- +-#undef CurlchkszEQ +-#undef CurlchkszGE +- +-/* +- * Get rid of macros not intended to exist beyond this point. +- */ +- +-#undef CURL_PULL_WS2TCPIP_H +-#undef CURL_PULL_SYS_TYPES_H +-#undef CURL_PULL_SYS_SOCKET_H +-#undef CURL_PULL_STDINT_H +-#undef CURL_PULL_INTTYPES_H +- +-#undef CURL_TYPEOF_CURL_SOCKLEN_T +-#undef CURL_TYPEOF_CURL_OFF_T +- +-#endif /* __CURL_CURLRULES_H */ +diff --git a/src/third_party/curl/curlver.h b/src/third_party/curl/curlver.h +--- a/src/third_party/curl/curlver.h ++++ b/src/third_party/curl/curlver.h +@@ -2,69 +2,76 @@ + #define __CURL_CURLVER_H + /*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. ++ * are also available at https://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * +- * $Id: curlver.h,v 1.48 2009-08-12 11:24:52 bagder Exp $ + ***************************************************************************/ + + /* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + + /* This is the global package copyright */ +-#define LIBCURL_COPYRIGHT "1996 - 2009 Daniel Stenberg, <daniel@haxx.se>." ++#define LIBCURL_COPYRIGHT "1996 - 2019 Daniel Stenberg, <daniel@haxx.se>." + + /* This is the version number of the libcurl package from which this header + file origins: */ +-#define LIBCURL_VERSION "7.19.7" ++#define LIBCURL_VERSION "7.64.1-DEV" + + /* The numeric version number is also available "in parts" by using these + defines: */ + #define LIBCURL_VERSION_MAJOR 7 +-#define LIBCURL_VERSION_MINOR 19 +-#define LIBCURL_VERSION_PATCH 7 ++#define LIBCURL_VERSION_MINOR 64 ++#define LIBCURL_VERSION_PATCH 1 + + /* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. ++ ++ Note: This define is the full hex number and _does not_ use the ++ CURL_VERSION_BITS() macro since curl's own configure script greps for it ++ and needs it to contain the full number. + */ +-#define LIBCURL_VERSION_NUM 0x071307 ++#define LIBCURL_VERSION_NUM 0x074001 + + /* + * This is the date and time when the full source package was created. The +- * timestamp is not stored in CVS, as the timestamp is properly set in the ++ * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * +- * The format of the date should follow this template: ++ * The format of the date follows this template: + * +- * "Mon Feb 12 11:35:33 UTC 2007" ++ * "2007-11-23" + */ +-#define LIBCURL_TIMESTAMP "Wed Nov 4 12:34:59 UTC 2009" ++#define LIBCURL_TIMESTAMP "[unreleased]" ++ ++#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|z) ++#define CURL_AT_LEAST_VERSION(x,y,z) \ ++ (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z)) + + #endif /* __CURL_CURLVER_H */ +diff --git a/src/third_party/curl/easy.h b/src/third_party/curl/easy.h +--- a/src/third_party/curl/easy.h ++++ b/src/third_party/curl/easy.h +@@ -2,30 +2,29 @@ + #define __CURL_EASY_H + /*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * +- * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. ++ * are also available at https://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * +- * $Id: easy.h,v 1.14 2008-05-12 21:43:28 bagder Exp $ + ***************************************************************************/ + #ifdef __cplusplus + extern "C" { + #endif + + CURL_EXTERN CURL *curl_easy_init(void); + CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); + CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +@@ -49,22 +48,22 @@ CURL_EXTERN CURLcode curl_easy_getinfo(C + + /* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and +- * options, internal state info and things like persistant connections cannot +- * be transfered. It is useful in multithreaded applications when you can run ++ * options, internal state info and things like persistent connections cannot ++ * be transferred. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +-CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl); ++CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl); + + /* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. +@@ -91,13 +90,23 @@ CURL_EXTERN CURLcode curl_easy_recv(CURL + * DESCRIPTION + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ + CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, + size_t buflen, size_t *n); + ++ ++/* ++ * NAME curl_easy_upkeep() ++ * ++ * DESCRIPTION ++ * ++ * Performs connection upkeep for the given session handle. ++ */ ++CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl); ++ + #ifdef __cplusplus + } + #endif + + #endif +diff --git a/src/third_party/curl/mprintf.h b/src/third_party/curl/mprintf.h +deleted file mode 100644 +--- a/src/third_party/curl/mprintf.h ++++ /dev/null +@@ -1,82 +0,0 @@ +-#ifndef __CURL_MPRINTF_H +-#define __CURL_MPRINTF_H +-/*************************************************************************** +- * _ _ ____ _ +- * Project ___| | | | _ \| | +- * / __| | | | |_) | | +- * | (__| |_| | _ <| |___ +- * \___|\___/|_| \_\_____| +- * +- * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al. +- * +- * This software is licensed as described in the file COPYING, which +- * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. +- * +- * You may opt to use, copy, modify, merge, publish, distribute and/or sell +- * copies of the Software, and permit persons to whom the Software is +- * furnished to do so, under the terms of the COPYING file. +- * +- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +- * KIND, either express or implied. +- * +- * $Id: mprintf.h,v 1.16 2008-05-20 10:21:50 patrickm Exp $ +- ***************************************************************************/ +- +-#include <stdarg.h> +-#include <stdio.h> /* needed for FILE */ +- +-#include "curl.h" +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-CURL_EXTERN int curl_mprintf(const char *format, ...); +-CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +-CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +-CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, +- const char *format, ...); +-CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +-CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +-CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +-CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, +- const char *format, va_list args); +-CURL_EXTERN char *curl_maprintf(const char *format, ...); +-CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); +- +-#ifdef _MPRINTF_REPLACE +-# undef printf +-# undef fprintf +-# undef sprintf +-# undef vsprintf +-# undef snprintf +-# undef vprintf +-# undef vfprintf +-# undef vsnprintf +-# undef aprintf +-# undef vaprintf +-# define printf curl_mprintf +-# define fprintf curl_mfprintf +-#ifdef CURLDEBUG +-/* When built with CURLDEBUG we define away the sprintf() functions since we +- don't want internal code to be using them */ +-# define sprintf sprintf_was_used +-# define vsprintf vsprintf_was_used +-#else +-# define sprintf curl_msprintf +-# define vsprintf curl_mvsprintf +-#endif +-# define snprintf curl_msnprintf +-# define vprintf curl_mvprintf +-# define vfprintf curl_mvfprintf +-# define vsnprintf curl_mvsnprintf +-# define aprintf curl_maprintf +-# define vaprintf curl_mvaprintf +-#endif +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* __CURL_MPRINTF_H */ +diff --git a/src/third_party/curl/multi.h b/src/third_party/curl/multi.h +--- a/src/third_party/curl/multi.h ++++ b/src/third_party/curl/multi.h +@@ -2,30 +2,29 @@ + #define __CURL_MULTI_H + /*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * +- * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. ++ * are also available at https://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * +- * $Id: multi.h,v 1.45 2008-05-20 10:21:50 patrickm Exp $ + ***************************************************************************/ + /* + This is an "external" header file. Don't give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. +@@ -48,36 +47,49 @@ + * but with this warning attached. + */ + #include "curl.h" + + #ifdef __cplusplus + extern "C" { + #endif + ++#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) ++typedef struct Curl_multi CURLM; ++#else + typedef void CURLM; ++#endif + + typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or + curl_multi_socket*() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ + CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ ++ CURLM_ADDED_ALREADY, /* an easy handle already added to a multi handle was ++ attempted to get added - again */ ++ CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a ++ callback */ + CURLM_LAST + } CURLMcode; + + /* just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ + #define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM + ++/* bitmask bits for CURLMOPT_PIPELINING */ ++#define CURLPIPE_NOTHING 0L ++#define CURLPIPE_HTTP1 1L ++#define CURLPIPE_MULTIPLEX 2L ++ + typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ + } CURLMSG; + + struct CURLMsg { +@@ -85,16 +97,29 @@ struct CURLMsg { + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; + }; + typedef struct CURLMsg CURLMsg; + ++/* Based on poll(2) structure and values. ++ * We don't use pollfd and POLL* constants explicitly ++ * to cover platforms without poll(). */ ++#define CURL_WAIT_POLLIN 0x0001 ++#define CURL_WAIT_POLLPRI 0x0002 ++#define CURL_WAIT_POLLOUT 0x0004 ++ ++struct curl_waitfd { ++ curl_socket_t fd; ++ short events; ++ short revents; /* not supported yet */ ++}; ++ + /* + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ + CURL_EXTERN CURLM *curl_multi_init(void); +@@ -129,31 +154,45 @@ CURL_EXTERN CURLMcode curl_multi_remove_ + * Returns: CURLMcode type, general multi error code. + */ + CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + ++/* ++ * Name: curl_multi_wait() ++ * ++ * Desc: Poll on all fds within a CURLM set as well as any ++ * additional fds passed to the function. ++ * ++ * Returns: CURLMcode type, general multi error code. ++ */ ++CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, ++ struct curl_waitfd extra_fds[], ++ unsigned int extra_nfds, ++ int timeout_ms, ++ int *ret); ++ + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might +- * still have occurred problems on invidual transfers even when this +- * returns OK. ++ * still have occurred problems on individual transfers even when ++ * this returns OK. + */ + CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or +@@ -176,17 +215,17 @@ CURL_EXTERN CURLMcode curl_multi_cleanup + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain +- * very basic informations. If more involved information is wanted, ++ * very basic information. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the +@@ -307,16 +346,47 @@ typedef enum { + CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CINIT(TIMERDATA, OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CINIT(MAXCONNECTS, LONG, 6), + ++ /* maximum number of (pipelining) connections to one host */ ++ CINIT(MAX_HOST_CONNECTIONS, LONG, 7), ++ ++ /* maximum number of requests in a pipeline */ ++ CINIT(MAX_PIPELINE_LENGTH, LONG, 8), ++ ++ /* a connection with a content-length longer than this ++ will not be considered for pipelining */ ++ CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9), ++ ++ /* a connection with a chunk length longer than this ++ will not be considered for pipelining */ ++ CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10), ++ ++ /* a list of site names(+port) that are blacklisted from ++ pipelining */ ++ CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11), ++ ++ /* a list of server types that are blacklisted from ++ pipelining */ ++ CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12), ++ ++ /* maximum number of open connections in total */ ++ CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13), ++ ++ /* This is the server push callback function pointer */ ++ CINIT(PUSHFUNCTION, FUNCTIONPOINT, 14), ++ ++ /* This is the argument passed to the server push callback */ ++ CINIT(PUSHDATA, OBJECTPOINT, 15), ++ + CURLMOPT_LASTENTRY /* the last unused */ + } CURLMoption; + + + /* + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. +@@ -334,13 +404,38 @@ CURL_EXTERN CURLMcode curl_multi_setopt( + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ + CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, + curl_socket_t sockfd, void *sockp); + ++ ++/* ++ * Name: curl_push_callback ++ * ++ * Desc: This callback gets called when a new stream is being pushed by the ++ * server. It approves or denies the new stream. ++ * ++ * Returns: CURL_PUSH_OK or CURL_PUSH_DENY. ++ */ ++#define CURL_PUSH_OK 0 ++#define CURL_PUSH_DENY 1 ++ ++struct curl_pushheaders; /* forward declaration only */ ++ ++CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h, ++ size_t num); ++CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h, ++ const char *name); ++ ++typedef int (*curl_push_callback)(CURL *parent, ++ CURL *easy, ++ size_t num_headers, ++ struct curl_pushheaders *headers, ++ void *userp); ++ + #ifdef __cplusplus + } /* end of extern "C" */ + #endif + + #endif +diff --git a/src/third_party/curl/stdcheaders.h b/src/third_party/curl/stdcheaders.h +deleted file mode 100644 +--- a/src/third_party/curl/stdcheaders.h ++++ /dev/null +@@ -1,34 +0,0 @@ +-#ifndef __STDC_HEADERS_H +-#define __STDC_HEADERS_H +-/*************************************************************************** +- * _ _ ____ _ +- * Project ___| | | | _ \| | +- * / __| | | | |_) | | +- * | (__| |_| | _ <| |___ +- * \___|\___/|_| \_\_____| +- * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. +- * +- * This software is licensed as described in the file COPYING, which +- * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. +- * +- * You may opt to use, copy, modify, merge, publish, distribute and/or sell +- * copies of the Software, and permit persons to whom the Software is +- * furnished to do so, under the terms of the COPYING file. +- * +- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +- * KIND, either express or implied. +- * +- * $Id: stdcheaders.h,v 1.9 2009-05-18 12:25:45 yangtse Exp $ +- ***************************************************************************/ +- +-#include <sys/types.h> +- +-size_t fread (void *, size_t, size_t, FILE *); +-size_t fwrite (const void *, size_t, size_t, FILE *); +- +-int strcasecmp(const char *, const char *); +-int strncasecmp(const char *, const char *, size_t); +- +-#endif +diff --git a/src/third_party/curl/system.h b/src/third_party/curl/system.h +new file mode 100644 +--- /dev/null ++++ b/src/third_party/curl/system.h +@@ -0,0 +1,493 @@ ++#ifndef __CURL_SYSTEM_H ++#define __CURL_SYSTEM_H ++/*************************************************************************** ++ * _ _ ____ _ ++ * Project ___| | | | _ \| | ++ * / __| | | | |_) | | ++ * | (__| |_| | _ <| |___ ++ * \___|\___/|_| \_\_____| ++ * ++ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * ++ * This software is licensed as described in the file COPYING, which ++ * you should have received as part of this distribution. The terms ++ * are also available at https://curl.haxx.se/docs/copyright.html. ++ * ++ * You may opt to use, copy, modify, merge, publish, distribute and/or sell ++ * copies of the Software, and permit persons to whom the Software is ++ * furnished to do so, under the terms of the COPYING file. ++ * ++ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY ++ * KIND, either express or implied. ++ * ++ ***************************************************************************/ ++ ++/* ++ * Try to keep one section per platform, compiler and architecture, otherwise, ++ * if an existing section is reused for a different one and later on the ++ * original is adjusted, probably the piggybacking one can be adversely ++ * changed. ++ * ++ * In order to differentiate between platforms/compilers/architectures use ++ * only compiler built in predefined preprocessor symbols. ++ * ++ * curl_off_t ++ * ---------- ++ * ++ * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit ++ * wide signed integral data type. The width of this data type must remain ++ * constant and independent of any possible large file support settings. ++ * ++ * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit ++ * wide signed integral data type if there is no 64-bit type. ++ * ++ * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall ++ * only be violated if off_t is the only 64-bit data type available and the ++ * size of off_t is independent of large file support settings. Keep your ++ * build on the safe side avoiding an off_t gating. If you have a 64-bit ++ * off_t then take for sure that another 64-bit data type exists, dig deeper ++ * and you will find it. ++ * ++ */ ++ ++#if defined(__DJGPP__) || defined(__GO32__) ++# if defined(__DJGPP__) && (__DJGPP__ > 1) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__SALFORDC__) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__BORLANDC__) ++# if (__BORLANDC__ < 0x520) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# else ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T i64 ++# define CURL_SUFFIX_CURL_OFF_TU ui64 ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__TURBOC__) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__WATCOMC__) ++# if defined(__386__) ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T i64 ++# define CURL_SUFFIX_CURL_OFF_TU ui64 ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__POCC__) ++# if (__POCC__ < 280) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# elif defined(_MSC_VER) ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T i64 ++# define CURL_SUFFIX_CURL_OFF_TU ui64 ++# else ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__LCC__) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__SYMBIAN32__) ++# if defined(__EABI__) /* Treat all ARM compilers equally */ ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(__CW32__) ++# pragma longlong on ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(__VC32__) ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int ++ ++#elif defined(__MWERKS__) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(_WIN32_WCE) ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T i64 ++# define CURL_SUFFIX_CURL_OFF_TU ui64 ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__MINGW32__) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_WS2TCPIP_H 1 ++ ++#elif defined(__VMS) ++# if defined(__VAX) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# else ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int ++ ++#elif defined(__OS400__) ++# if defined(__ILEC400__) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++# endif ++ ++#elif defined(__MVS__) ++# if defined(__IBMC__) || defined(__IBMCPP__) ++# if defined(_ILP32) ++# elif defined(_LP64) ++# endif ++# if defined(_LONG_LONG) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(_LP64) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++# endif ++ ++#elif defined(__370__) ++# if defined(__IBMC__) || defined(__IBMCPP__) ++# if defined(_ILP32) ++# elif defined(_LP64) ++# endif ++# if defined(_LONG_LONG) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(_LP64) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++# endif ++ ++#elif defined(TPF) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++#elif defined(__TINYC__) /* also known as tcc */ ++ ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++ ++#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ ++# if !defined(__LP64) && (defined(__ILP32) || \ ++ defined(__i386) || \ ++ defined(__sparcv8) || \ ++ defined(__sparcv8plus)) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(__LP64) || \ ++ defined(__amd64) || defined(__sparcv9) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++ ++#elif defined(__xlc__) /* IBM xlc compiler */ ++# if !defined(_LP64) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++ ++/* ===================================== */ ++/* KEEP MSVC THE PENULTIMATE ENTRY */ ++/* ===================================== */ ++ ++#elif defined(_MSC_VER) ++# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) ++# define CURL_TYPEOF_CURL_OFF_T __int64 ++# define CURL_FORMAT_CURL_OFF_T "I64d" ++# define CURL_FORMAT_CURL_OFF_TU "I64u" ++# define CURL_SUFFIX_CURL_OFF_T i64 ++# define CURL_SUFFIX_CURL_OFF_TU ui64 ++# else ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++ ++/* ===================================== */ ++/* KEEP GENERIC GCC THE LAST ENTRY */ ++/* ===================================== */ ++ ++#elif defined(__GNUC__) && !defined(_SCO_DS) ++# if !defined(__LP64__) && \ ++ (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ ++ defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ ++ defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ ++ defined(__XTENSA__) || \ ++ (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ ++ (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) ++# define CURL_TYPEOF_CURL_OFF_T long long ++# define CURL_FORMAT_CURL_OFF_T "lld" ++# define CURL_FORMAT_CURL_OFF_TU "llu" ++# define CURL_SUFFIX_CURL_OFF_T LL ++# define CURL_SUFFIX_CURL_OFF_TU ULL ++# elif defined(__LP64__) || \ ++ defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ ++ (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ ++ (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# endif ++# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t ++# define CURL_PULL_SYS_TYPES_H 1 ++# define CURL_PULL_SYS_SOCKET_H 1 ++ ++#else ++/* generic "safe guess" on old 32 bit style */ ++# define CURL_TYPEOF_CURL_OFF_T long ++# define CURL_FORMAT_CURL_OFF_T "ld" ++# define CURL_FORMAT_CURL_OFF_TU "lu" ++# define CURL_SUFFIX_CURL_OFF_T L ++# define CURL_SUFFIX_CURL_OFF_TU UL ++# define CURL_TYPEOF_CURL_SOCKLEN_T int ++#endif ++ ++#ifdef _AIX ++/* AIX needs <sys/poll.h> */ ++#define CURL_PULL_SYS_POLL_H ++#endif ++ ++ ++/* CURL_PULL_WS2TCPIP_H is defined above when inclusion of header file */ ++/* ws2tcpip.h is required here to properly make type definitions below. */ ++#ifdef CURL_PULL_WS2TCPIP_H ++# include <winsock2.h> ++# include <windows.h> ++# include <ws2tcpip.h> ++#endif ++ ++/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ ++/* sys/types.h is required here to properly make type definitions below. */ ++#ifdef CURL_PULL_SYS_TYPES_H ++# include <sys/types.h> ++#endif ++ ++/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ ++/* sys/socket.h is required here to properly make type definitions below. */ ++#ifdef CURL_PULL_SYS_SOCKET_H ++# include <sys/socket.h> ++#endif ++ ++/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ ++/* sys/poll.h is required here to properly make type definitions below. */ ++#ifdef CURL_PULL_SYS_POLL_H ++# include <sys/poll.h> ++#endif ++ ++/* Data type definition of curl_socklen_t. */ ++#ifdef CURL_TYPEOF_CURL_SOCKLEN_T ++ typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; ++#endif ++ ++/* Data type definition of curl_off_t. */ ++ ++#ifdef CURL_TYPEOF_CURL_OFF_T ++ typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; ++#endif ++ ++/* ++ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow ++ * these to be visible and exported by the external libcurl interface API, ++ * while also making them visible to the library internals, simply including ++ * curl_setup.h, without actually needing to include curl.h internally. ++ * If some day this section would grow big enough, all this should be moved ++ * to its own header file. ++ */ ++ ++/* ++ * Figure out if we can use the ## preprocessor operator, which is supported ++ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ ++ * or __cplusplus so we need to carefully check for them too. ++ */ ++ ++#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ ++ defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ ++ defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ ++ defined(__ILEC400__) ++ /* This compiler is believed to have an ISO compatible preprocessor */ ++#define CURL_ISOCPP ++#else ++ /* This compiler is believed NOT to have an ISO compatible preprocessor */ ++#undef CURL_ISOCPP ++#endif ++ ++/* ++ * Macros for minimum-width signed and unsigned curl_off_t integer constants. ++ */ ++ ++#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) ++# define __CURL_OFF_T_C_HLPR2(x) x ++# define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x) ++# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ ++ __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) ++# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ ++ __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) ++#else ++# ifdef CURL_ISOCPP ++# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix ++# else ++# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix ++# endif ++# define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix) ++# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) ++# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) ++#endif ++ ++#endif /* __CURL_SYSTEM_H */ +diff --git a/src/third_party/curl/typecheck-gcc.h b/src/third_party/curl/typecheck-gcc.h +--- a/src/third_party/curl/typecheck-gcc.h ++++ b/src/third_party/curl/typecheck-gcc.h +@@ -2,111 +2,151 @@ + #define __CURL_TYPECHECK_GCC_H + /*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * +- * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms +- * are also available at http://curl.haxx.se/docs/copyright.html. ++ * are also available at https://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * +- * $Id: typecheck-gcc.h,v 1.9 2009-01-25 23:26:31 bagder Exp $ + ***************************************************************************/ + + /* wraps curl_easy_setopt() with typechecking */ + + /* To add a new kind of warning, add an +- * if(_curl_is_sometype_option(_curl_opt) && ! _curl_is_sometype(value)) +- * _curl_easy_setopt_err_sometype(); ++ * if(_curl_is_sometype_option(_curl_opt)) ++ * if(!_curl_is_sometype(value)) ++ * _curl_easy_setopt_err_sometype(); + * block and define _curl_is_sometype_option, _curl_is_sometype and + * _curl_easy_setopt_err_sometype below + * ++ * NOTE: We use two nested 'if' statements here instead of the && operator, in ++ * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x ++ * when compiling with -Wlogical-op. ++ * + * To add an option that uses the same type as an existing option, you'll just + * need to extend the appropriate _curl_*_option macro + */ + #define curl_easy_setopt(handle, option, value) \ + __extension__ ({ \ +- __typeof__ (option) _curl_opt = option; \ +- if (__builtin_constant_p(_curl_opt)) { \ +- if (_curl_is_long_option(_curl_opt) && !_curl_is_long(value)) \ +- _curl_easy_setopt_err_long(); \ +- if (_curl_is_off_t_option(_curl_opt) && !_curl_is_off_t(value)) \ +- _curl_easy_setopt_err_curl_off_t(); \ +- if (_curl_is_string_option(_curl_opt) && !_curl_is_string(value)) \ +- _curl_easy_setopt_err_string(); \ +- if (_curl_is_write_cb_option(_curl_opt) && !_curl_is_write_cb(value)) \ +- _curl_easy_setopt_err_write_callback(); \ +- if ((_curl_opt) == CURLOPT_READFUNCTION && !_curl_is_read_cb(value)) \ +- _curl_easy_setopt_err_read_cb(); \ +- if ((_curl_opt) == CURLOPT_IOCTLFUNCTION && !_curl_is_ioctl_cb(value)) \ +- _curl_easy_setopt_err_ioctl_cb(); \ +- if ((_curl_opt) == CURLOPT_SOCKOPTFUNCTION && !_curl_is_sockopt_cb(value))\ +- _curl_easy_setopt_err_sockopt_cb(); \ +- if ((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION && \ +- !_curl_is_opensocket_cb(value)) \ +- _curl_easy_setopt_err_opensocket_cb(); \ +- if ((_curl_opt) == CURLOPT_PROGRESSFUNCTION && \ +- !_curl_is_progress_cb(value)) \ +- _curl_easy_setopt_err_progress_cb(); \ +- if ((_curl_opt) == CURLOPT_DEBUGFUNCTION && !_curl_is_debug_cb(value)) \ +- _curl_easy_setopt_err_debug_cb(); \ +- if ((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION && \ +- !_curl_is_ssl_ctx_cb(value)) \ +- _curl_easy_setopt_err_ssl_ctx_cb(); \ +- if (_curl_is_conv_cb_option(_curl_opt) && !_curl_is_conv_cb(value)) \ +- _curl_easy_setopt_err_conv_cb(); \ +- if ((_curl_opt) == CURLOPT_SEEKFUNCTION && !_curl_is_seek_cb(value)) \ +- _curl_easy_setopt_err_seek_cb(); \ +- if (_curl_is_cb_data_option(_curl_opt) && !_curl_is_cb_data(value)) \ +- _curl_easy_setopt_err_cb_data(); \ +- if ((_curl_opt) == CURLOPT_ERRORBUFFER && !_curl_is_error_buffer(value)) \ +- _curl_easy_setopt_err_error_buffer(); \ +- if ((_curl_opt) == CURLOPT_STDERR && !_curl_is_FILE(value)) \ +- _curl_easy_setopt_err_FILE(); \ +- if (_curl_is_postfields_option(_curl_opt) && !_curl_is_postfields(value)) \ +- _curl_easy_setopt_err_postfields(); \ +- if ((_curl_opt) == CURLOPT_HTTPPOST && \ +- !_curl_is_arr((value), struct curl_httppost)) \ +- _curl_easy_setopt_err_curl_httpost(); \ +- if (_curl_is_slist_option(_curl_opt) && \ +- !_curl_is_arr((value), struct curl_slist)) \ +- _curl_easy_setopt_err_curl_slist(); \ +- if ((_curl_opt) == CURLOPT_SHARE && !_curl_is_ptr((value), CURLSH)) \ +- _curl_easy_setopt_err_CURLSH(); \ ++ __typeof__(option) _curl_opt = option; \ ++ if(__builtin_constant_p(_curl_opt)) { \ ++ if(_curl_is_long_option(_curl_opt)) \ ++ if(!_curl_is_long(value)) \ ++ _curl_easy_setopt_err_long(); \ ++ if(_curl_is_off_t_option(_curl_opt)) \ ++ if(!_curl_is_off_t(value)) \ ++ _curl_easy_setopt_err_curl_off_t(); \ ++ if(_curl_is_string_option(_curl_opt)) \ ++ if(!_curl_is_string(value)) \ ++ _curl_easy_setopt_err_string(); \ ++ if(_curl_is_write_cb_option(_curl_opt)) \ ++ if(!_curl_is_write_cb(value)) \ ++ _curl_easy_setopt_err_write_callback(); \ ++ if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ ++ if(!_curl_is_resolver_start_callback(value)) \ ++ _curl_easy_setopt_err_resolver_start_callback(); \ ++ if((_curl_opt) == CURLOPT_READFUNCTION) \ ++ if(!_curl_is_read_cb(value)) \ ++ _curl_easy_setopt_err_read_cb(); \ ++ if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ ++ if(!_curl_is_ioctl_cb(value)) \ ++ _curl_easy_setopt_err_ioctl_cb(); \ ++ if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ ++ if(!_curl_is_sockopt_cb(value)) \ ++ _curl_easy_setopt_err_sockopt_cb(); \ ++ if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ ++ if(!_curl_is_opensocket_cb(value)) \ ++ _curl_easy_setopt_err_opensocket_cb(); \ ++ if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ ++ if(!_curl_is_progress_cb(value)) \ ++ _curl_easy_setopt_err_progress_cb(); \ ++ if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ ++ if(!_curl_is_debug_cb(value)) \ ++ _curl_easy_setopt_err_debug_cb(); \ ++ if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ ++ if(!_curl_is_ssl_ctx_cb(value)) \ ++ _curl_easy_setopt_err_ssl_ctx_cb(); \ ++ if(_curl_is_conv_cb_option(_curl_opt)) \ ++ if(!_curl_is_conv_cb(value)) \ ++ _curl_easy_setopt_err_conv_cb(); \ ++ if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ ++ if(!_curl_is_seek_cb(value)) \ ++ _curl_easy_setopt_err_seek_cb(); \ ++ if(_curl_is_cb_data_option(_curl_opt)) \ ++ if(!_curl_is_cb_data(value)) \ ++ _curl_easy_setopt_err_cb_data(); \ ++ if((_curl_opt) == CURLOPT_ERRORBUFFER) \ ++ if(!_curl_is_error_buffer(value)) \ ++ _curl_easy_setopt_err_error_buffer(); \ ++ if((_curl_opt) == CURLOPT_STDERR) \ ++ if(!_curl_is_FILE(value)) \ ++ _curl_easy_setopt_err_FILE(); \ ++ if(_curl_is_postfields_option(_curl_opt)) \ ++ if(!_curl_is_postfields(value)) \ ++ _curl_easy_setopt_err_postfields(); \ ++ if((_curl_opt) == CURLOPT_HTTPPOST) \ ++ if(!_curl_is_arr((value), struct curl_httppost)) \ ++ _curl_easy_setopt_err_curl_httpost(); \ ++ if((_curl_opt) == CURLOPT_MIMEPOST) \ ++ if(!_curl_is_ptr((value), curl_mime)) \ ++ _curl_easy_setopt_err_curl_mimepost(); \ ++ if(_curl_is_slist_option(_curl_opt)) \ ++ if(!_curl_is_arr((value), struct curl_slist)) \ ++ _curl_easy_setopt_err_curl_slist(); \ ++ if((_curl_opt) == CURLOPT_SHARE) \ ++ if(!_curl_is_ptr((value), CURLSH)) \ ++ _curl_easy_setopt_err_CURLSH(); \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ + }) + + /* wraps curl_easy_getinfo() with typechecking */ + /* FIXME: don't allow const pointers */ + #define curl_easy_getinfo(handle, info, arg) \ + __extension__ ({ \ +- __typeof__ (info) _curl_info = info; \ +- if (__builtin_constant_p(_curl_info)) { \ +- if (_curl_is_string_info(_curl_info) && !_curl_is_arr((arg), char *)) \ +- _curl_easy_getinfo_err_string(); \ +- if (_curl_is_long_info(_curl_info) && !_curl_is_arr((arg), long)) \ +- _curl_easy_getinfo_err_long(); \ +- if (_curl_is_double_info(_curl_info) && !_curl_is_arr((arg), double)) \ +- _curl_easy_getinfo_err_double(); \ +- if (_curl_is_slist_info(_curl_info) && \ +- !_curl_is_arr((arg), struct curl_slist *)) \ +- _curl_easy_getinfo_err_curl_slist(); \ ++ __typeof__(info) _curl_info = info; \ ++ if(__builtin_constant_p(_curl_info)) { \ ++ if(_curl_is_string_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), char *)) \ ++ _curl_easy_getinfo_err_string(); \ ++ if(_curl_is_long_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), long)) \ ++ _curl_easy_getinfo_err_long(); \ ++ if(_curl_is_double_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), double)) \ ++ _curl_easy_getinfo_err_double(); \ ++ if(_curl_is_slist_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), struct curl_slist *)) \ ++ _curl_easy_getinfo_err_curl_slist(); \ ++ if(_curl_is_tlssessioninfo_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), struct curl_tlssessioninfo *)) \ ++ _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ ++ if(_curl_is_certinfo_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), struct curl_certinfo *)) \ ++ _curl_easy_getinfo_err_curl_certinfo(); \ ++ if(_curl_is_socket_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), curl_socket_t)) \ ++ _curl_easy_getinfo_err_curl_socket(); \ ++ if(_curl_is_off_t_info(_curl_info)) \ ++ if(!_curl_is_arr((arg), curl_off_t)) \ ++ _curl_easy_getinfo_err_curl_off_t(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ + }) + + /* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(), + * for now just make sure that the functions are called with three + * arguments + */ +@@ -114,70 +154,93 @@ + #define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) + + + /* the actual warnings, triggered by calling the _curl_easy_setopt_err* + * functions */ + + /* To define a new warning, use _CURL_WARNING(identifier, "message") */ + #define _CURL_WARNING(id, message) \ +- static void __attribute__((warning(message))) __attribute__((unused)) \ +- __attribute__((noinline)) id(void) { __asm__(""); } ++ static void __attribute__((__warning__(message))) \ ++ __attribute__((__unused__)) __attribute__((__noinline__)) \ ++ id(void) { __asm__(""); } + + _CURL_WARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_string, +- "curl_easy_setopt expects a string (char* or char[]) argument for this option" ++ "curl_easy_setopt expects a " ++ "string ('char *' or char[]) argument for this option" + ) + _CURL_WARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") ++_CURL_WARNING(_curl_easy_setopt_err_resolver_start_callback, ++ "curl_easy_setopt expects a " ++ "curl_resolver_start_callback argument for this option" ++ ) + _CURL_WARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_opensocket_cb, +- "curl_easy_setopt expects a curl_opensocket_callback argument for this option" ++ "curl_easy_setopt expects a " ++ "curl_opensocket_callback argument for this option" + ) + _CURL_WARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_cb_data, +- "curl_easy_setopt expects a private data pointer as argument for this option") ++ "curl_easy_setopt expects a " ++ "private data pointer as argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_error_buffer, +- "curl_easy_setopt expects a char buffer of CURL_ERROR_SIZE as argument for this option") ++ "curl_easy_setopt expects a " ++ "char buffer of CURL_ERROR_SIZE as argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_FILE, +- "curl_easy_setopt expects a FILE* argument for this option") ++ "curl_easy_setopt expects a 'FILE *' argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_postfields, +- "curl_easy_setopt expects a void* or char* argument for this option") ++ "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_curl_httpost, +- "curl_easy_setopt expects a struct curl_httppost* argument for this option") ++ "curl_easy_setopt expects a 'struct curl_httppost *' " ++ "argument for this option") ++_CURL_WARNING(_curl_easy_setopt_err_curl_mimepost, ++ "curl_easy_setopt expects a 'curl_mime *' " ++ "argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_curl_slist, +- "curl_easy_setopt expects a struct curl_slist* argument for this option") ++ "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") + _CURL_WARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + + _CURL_WARNING(_curl_easy_getinfo_err_string, +- "curl_easy_getinfo expects a pointer to char * for this info") ++ "curl_easy_getinfo expects a pointer to 'char *' for this info") + _CURL_WARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") + _CURL_WARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") + _CURL_WARNING(_curl_easy_getinfo_err_curl_slist, +- "curl_easy_getinfo expects a pointer to struct curl_slist * for this info") ++ "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") ++_CURL_WARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, ++ "curl_easy_getinfo expects a pointer to " ++ "'struct curl_tlssessioninfo *' for this info") ++_CURL_WARNING(_curl_easy_getinfo_err_curl_certinfo, ++ "curl_easy_getinfo expects a pointer to " ++ "'struct curl_certinfo *' for this info") ++_CURL_WARNING(_curl_easy_getinfo_err_curl_socket, ++ "curl_easy_getinfo expects a pointer to curl_socket_t for this info") ++_CURL_WARNING(_curl_easy_getinfo_err_curl_off_t, ++ "curl_easy_getinfo expects a pointer to curl_off_t for this info") + + /* groups of curl_easy_setops options that take the same type of argument */ + + /* To add a new option to one of the groups, just add + * (option) == CURLOPT_SOMETHING + * to the or-expression. If the option takes a long or curl_off_t, you don't + * have to do anything + */ +@@ -186,97 +249,145 @@ + #define _curl_is_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + + #define _curl_is_off_t_option(option) \ + ((option) > CURLOPTTYPE_OFF_T) + + /* evaluates to true if option takes a char* argument */ + #define _curl_is_string_option(option) \ +- ((option) == CURLOPT_URL || \ +- (option) == CURLOPT_PROXY || \ +- (option) == CURLOPT_INTERFACE || \ +- (option) == CURLOPT_NETRC_FILE || \ +- (option) == CURLOPT_USERPWD || \ +- (option) == CURLOPT_USERNAME || \ +- (option) == CURLOPT_PASSWORD || \ +- (option) == CURLOPT_PROXYUSERPWD || \ +- (option) == CURLOPT_PROXYUSERNAME || \ +- (option) == CURLOPT_PROXYPASSWORD || \ +- (option) == CURLOPT_NOPROXY || \ +- (option) == CURLOPT_ENCODING || \ +- (option) == CURLOPT_REFERER || \ +- (option) == CURLOPT_USERAGENT || \ ++ ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET || \ ++ (option) == CURLOPT_ACCEPT_ENCODING || \ ++ (option) == CURLOPT_ALTSVC || \ ++ (option) == CURLOPT_CAINFO || \ ++ (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ ++ (option) == CURLOPT_CRLFILE || \ ++ (option) == CURLOPT_CUSTOMREQUEST || \ ++ (option) == CURLOPT_DEFAULT_PROTOCOL || \ ++ (option) == CURLOPT_DNS_INTERFACE || \ ++ (option) == CURLOPT_DNS_LOCAL_IP4 || \ ++ (option) == CURLOPT_DNS_LOCAL_IP6 || \ ++ (option) == CURLOPT_DNS_SERVERS || \ ++ (option) == CURLOPT_DOH_URL || \ ++ (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_FTPPORT || \ +- (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_FTP_ACCOUNT || \ ++ (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ ++ (option) == CURLOPT_INTERFACE || \ ++ (option) == CURLOPT_ISSUERCERT || \ ++ (option) == CURLOPT_KEYPASSWD || \ ++ (option) == CURLOPT_KRBLEVEL || \ ++ (option) == CURLOPT_LOGIN_OPTIONS || \ ++ (option) == CURLOPT_MAIL_AUTH || \ ++ (option) == CURLOPT_MAIL_FROM || \ ++ (option) == CURLOPT_NETRC_FILE || \ ++ (option) == CURLOPT_NOPROXY || \ ++ (option) == CURLOPT_PASSWORD || \ ++ (option) == CURLOPT_PINNEDPUBLICKEY || \ ++ (option) == CURLOPT_PRE_PROXY || \ ++ (option) == CURLOPT_PROXY || \ ++ (option) == CURLOPT_PROXYPASSWORD || \ ++ (option) == CURLOPT_PROXYUSERNAME || \ ++ (option) == CURLOPT_PROXYUSERPWD || \ ++ (option) == CURLOPT_PROXY_CAINFO || \ ++ (option) == CURLOPT_PROXY_CAPATH || \ ++ (option) == CURLOPT_PROXY_CRLFILE || \ ++ (option) == CURLOPT_PROXY_KEYPASSWD || \ ++ (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ ++ (option) == CURLOPT_PROXY_SERVICE_NAME || \ ++ (option) == CURLOPT_PROXY_SSLCERT || \ ++ (option) == CURLOPT_PROXY_SSLCERTTYPE || \ ++ (option) == CURLOPT_PROXY_SSLKEY || \ ++ (option) == CURLOPT_PROXY_SSLKEYTYPE || \ ++ (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ ++ (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ ++ (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ ++ (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ ++ (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ +- (option) == CURLOPT_CUSTOMREQUEST || \ ++ (option) == CURLOPT_REFERER || \ ++ (option) == CURLOPT_RTSP_SESSION_ID || \ ++ (option) == CURLOPT_RTSP_STREAM_URI || \ ++ (option) == CURLOPT_RTSP_TRANSPORT || \ ++ (option) == CURLOPT_SERVICE_NAME || \ ++ (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ ++ (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ ++ (option) == CURLOPT_SSH_KNOWNHOSTS || \ ++ (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ ++ (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ ++ (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ +- (option) == CURLOPT_KEYPASSWD || \ +- (option) == CURLOPT_SSLENGINE || \ +- (option) == CURLOPT_CAINFO || \ +- (option) == CURLOPT_CAPATH || \ +- (option) == CURLOPT_RANDOM_FILE || \ +- (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ +- (option) == CURLOPT_KRBLEVEL || \ +- (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ +- (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ +- (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ +- (option) == CURLOPT_CRLFILE || \ +- (option) == CURLOPT_ISSUERCERT || \ ++ (option) == CURLOPT_TLSAUTH_PASSWORD || \ ++ (option) == CURLOPT_TLSAUTH_TYPE || \ ++ (option) == CURLOPT_TLSAUTH_USERNAME || \ ++ (option) == CURLOPT_UNIX_SOCKET_PATH || \ ++ (option) == CURLOPT_URL || \ ++ (option) == CURLOPT_USERAGENT || \ ++ (option) == CURLOPT_USERNAME || \ ++ (option) == CURLOPT_USERPWD || \ ++ (option) == CURLOPT_XOAUTH2_BEARER || \ + 0) + + /* evaluates to true if option takes a curl_write_callback argument */ + #define _curl_is_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + + /* evaluates to true if option takes a curl_conv_callback argument */ + #define _curl_is_conv_cb_option(option) \ + ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) + + /* evaluates to true if option takes a data argument to pass to a callback */ + #define _curl_is_cb_data_option(option) \ +- ((option) == CURLOPT_WRITEDATA || \ +- (option) == CURLOPT_READDATA || \ ++ ((option) == CURLOPT_CHUNK_DATA || \ ++ (option) == CURLOPT_CLOSESOCKETDATA || \ ++ (option) == CURLOPT_DEBUGDATA || \ ++ (option) == CURLOPT_FNMATCH_DATA || \ ++ (option) == CURLOPT_HEADERDATA || \ ++ (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ +- (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ ++ (option) == CURLOPT_PRIVATE || \ + (option) == CURLOPT_PROGRESSDATA || \ +- (option) == CURLOPT_WRITEHEADER || \ +- (option) == CURLOPT_DEBUGDATA || \ ++ (option) == CURLOPT_READDATA || \ ++ (option) == CURLOPT_SEEKDATA || \ ++ (option) == CURLOPT_SOCKOPTDATA || \ ++ (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ +- (option) == CURLOPT_SEEKDATA || \ +- (option) == CURLOPT_PRIVATE || \ ++ (option) == CURLOPT_WRITEDATA || \ ++ (option) == CURLOPT_RESOLVER_START_DATA || \ ++ (option) == CURLOPT_CURLU || \ + 0) + + /* evaluates to true if option takes a POST data argument (void* or char*) */ + #define _curl_is_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + + /* evaluates to true if option takes a struct curl_slist * argument */ + #define _curl_is_slist_option(option) \ +- ((option) == CURLOPT_HTTPHEADER || \ +- (option) == CURLOPT_HTTP200ALIASES || \ +- (option) == CURLOPT_QUOTE || \ ++ ((option) == CURLOPT_HTTP200ALIASES || \ ++ (option) == CURLOPT_HTTPHEADER || \ ++ (option) == CURLOPT_MAIL_RCPT || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ ++ (option) == CURLOPT_PROXYHEADER || \ ++ (option) == CURLOPT_QUOTE || \ ++ (option) == CURLOPT_RESOLVE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + 0) + + /* groups of curl_easy_getinfo infos that take the same type of argument */ + + /* evaluates to true if info expects a pointer to char * argument */ + #define _curl_is_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG) +@@ -285,34 +396,49 @@ + #define _curl_is_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + + /* evaluates to true if info expects a pointer to double argument */ + #define _curl_is_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + + /* true if info expects a pointer to struct curl_slist * argument */ +-#define _curl_is_slist_info(info) \ +- (CURLINFO_SLIST < (info)) ++#define _curl_is_slist_info(info) \ ++ (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) ++ ++/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ ++#define _curl_is_tlssessioninfo_info(info) \ ++ (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) ++ ++/* true if info expects a pointer to struct curl_certinfo * argument */ ++#define _curl_is_certinfo_info(info) ((info) == CURLINFO_CERTINFO) ++ ++/* true if info expects a pointer to struct curl_socket_t argument */ ++#define _curl_is_socket_info(info) \ ++ (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) ++ ++/* true if info expects a pointer to curl_off_t argument */ ++#define _curl_is_off_t_info(info) \ ++ (CURLINFO_OFF_T < (info)) + + + /* typecheck helpers -- check whether given expression has requested type*/ + + /* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros, + * otherwise define a new macro. Search for __builtin_types_compatible_p + * in the GCC manual. + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is + * the actual expression passed to the curl_easy_setopt macro. This + * means that you can only apply the sizeof and __typeof__ operators, no + * == or whatsoever. + */ + +-/* XXX: should evaluate to true iff expr is a pointer */ ++/* XXX: should evaluate to true if expr is a pointer */ + #define _curl_is_any_ptr(expr) \ +- (sizeof(expr) == sizeof(void*)) ++ (sizeof(expr) == sizeof(void *)) + + /* evaluates to true if expr is NULL */ + /* XXX: must not evaluate expr, so this check is not accurate */ + #define _curl_is_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + + /* evaluates to true if expr is type*, const type* or NULL */ + #define _curl_is_ptr(expr, type) \ +@@ -350,202 +476,225 @@ + + /* evaluates to true if expr is of type curl_off_t */ + #define _curl_is_off_t(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) + + /* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ + /* XXX: also check size of an char[] array? */ + #define _curl_is_error_buffer(expr) \ +- (__builtin_types_compatible_p(__typeof__(expr), char *) || \ ++ (_curl_is_NULL(expr) || \ ++ __builtin_types_compatible_p(__typeof__(expr), char *) || \ + __builtin_types_compatible_p(__typeof__(expr), char[])) + + /* evaluates to true if expr is of type (const) void* or (const) FILE* */ + #if 0 + #define _curl_is_cb_data(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_ptr((expr), FILE)) + #else /* be less strict */ + #define _curl_is_cb_data(expr) \ + _curl_is_any_ptr(expr) + #endif + + /* evaluates to true if expr is of type FILE* */ +-#define _curl_is_FILE(expr) \ +- (__builtin_types_compatible_p(__typeof__(expr), FILE *)) ++#define _curl_is_FILE(expr) \ ++ (_curl_is_NULL(expr) || \ ++ (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + + /* evaluates to true if expr can be passed as POST data (void* or char*) */ + #define _curl_is_postfields(expr) \ + (_curl_is_ptr((expr), void) || \ +- _curl_is_arr((expr), char)) ++ _curl_is_arr((expr), char) || \ ++ _curl_is_arr((expr), unsigned char)) + + /* FIXME: the whole callback checking is messy... + * The idea is to tolerate char vs. void and const vs. not const + * pointers in arguments at least + */ + /* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ + #define _curl_callback_compatible(func, type) \ + (__builtin_types_compatible_p(__typeof__(func), type) || \ +- __builtin_types_compatible_p(__typeof__(func), type*)) ++ __builtin_types_compatible_p(__typeof__(func) *, type)) ++ ++/* evaluates to true if expr is of type curl_resolver_start_callback */ ++#define _curl_is_resolver_start_callback(expr) \ ++ (_curl_is_NULL(expr) || \ ++ _curl_callback_compatible((expr), curl_resolver_start_callback)) + + /* evaluates to true if expr is of type curl_read_callback or "similar" */ + #define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) || \ ++ _curl_callback_compatible((expr), __typeof__(fread) *) || \ ++ _curl_callback_compatible((expr), curl_read_callback) || \ + _curl_callback_compatible((expr), _curl_read_callback1) || \ + _curl_callback_compatible((expr), _curl_read_callback2) || \ + _curl_callback_compatible((expr), _curl_read_callback3) || \ + _curl_callback_compatible((expr), _curl_read_callback4) || \ + _curl_callback_compatible((expr), _curl_read_callback5) || \ + _curl_callback_compatible((expr), _curl_read_callback6)) +-typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*); +-typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*); +-typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*); +-typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*); +-typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*); +-typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*); ++typedef size_t (*_curl_read_callback1)(char *, size_t, size_t, void *); ++typedef size_t (*_curl_read_callback2)(char *, size_t, size_t, const void *); ++typedef size_t (*_curl_read_callback3)(char *, size_t, size_t, FILE *); ++typedef size_t (*_curl_read_callback4)(void *, size_t, size_t, void *); ++typedef size_t (*_curl_read_callback5)(void *, size_t, size_t, const void *); ++typedef size_t (*_curl_read_callback6)(void *, size_t, size_t, FILE *); + + /* evaluates to true if expr is of type curl_write_callback or "similar" */ + #define _curl_is_write_cb(expr) \ + (_curl_is_read_cb(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) || \ ++ _curl_callback_compatible((expr), __typeof__(fwrite) *) || \ ++ _curl_callback_compatible((expr), curl_write_callback) || \ + _curl_callback_compatible((expr), _curl_write_callback1) || \ + _curl_callback_compatible((expr), _curl_write_callback2) || \ + _curl_callback_compatible((expr), _curl_write_callback3) || \ + _curl_callback_compatible((expr), _curl_write_callback4) || \ + _curl_callback_compatible((expr), _curl_write_callback5) || \ + _curl_callback_compatible((expr), _curl_write_callback6)) +-typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*); +-typedef size_t (_curl_write_callback2)(const char *, size_t, size_t, +- const void*); +-typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*); +-typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*); +-typedef size_t (_curl_write_callback5)(const void *, size_t, size_t, +- const void*); +-typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*); ++typedef size_t (*_curl_write_callback1)(const char *, size_t, size_t, void *); ++typedef size_t (*_curl_write_callback2)(const char *, size_t, size_t, ++ const void *); ++typedef size_t (*_curl_write_callback3)(const char *, size_t, size_t, FILE *); ++typedef size_t (*_curl_write_callback4)(const void *, size_t, size_t, void *); ++typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t, ++ const void *); ++typedef size_t (*_curl_write_callback6)(const void *, size_t, size_t, FILE *); + + /* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ + #define _curl_is_ioctl_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) || \ ++ _curl_callback_compatible((expr), curl_ioctl_callback) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback1) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback2) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback3) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback4)) +-typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*); +-typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*); +-typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*); +-typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*); ++typedef curlioerr (*_curl_ioctl_callback1)(CURL *, int, void *); ++typedef curlioerr (*_curl_ioctl_callback2)(CURL *, int, const void *); ++typedef curlioerr (*_curl_ioctl_callback3)(CURL *, curliocmd, void *); ++typedef curlioerr (*_curl_ioctl_callback4)(CURL *, curliocmd, const void *); + + /* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ + #define _curl_is_sockopt_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) || \ ++ _curl_callback_compatible((expr), curl_sockopt_callback) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback1) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback2)) +-typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); +-typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t, ++typedef int (*_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); ++typedef int (*_curl_sockopt_callback2)(const void *, curl_socket_t, + curlsocktype); + +-/* evaluates to true if expr is of type curl_opensocket_callback or "similar" */ ++/* evaluates to true if expr is of type curl_opensocket_callback or ++ "similar" */ + #define _curl_is_opensocket_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\ ++ _curl_callback_compatible((expr), curl_opensocket_callback) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback1) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback2) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback3) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback4)) +-typedef curl_socket_t (_curl_opensocket_callback1) ++typedef curl_socket_t (*_curl_opensocket_callback1) + (void *, curlsocktype, struct curl_sockaddr *); +-typedef curl_socket_t (_curl_opensocket_callback2) ++typedef curl_socket_t (*_curl_opensocket_callback2) + (void *, curlsocktype, const struct curl_sockaddr *); +-typedef curl_socket_t (_curl_opensocket_callback3) ++typedef curl_socket_t (*_curl_opensocket_callback3) + (const void *, curlsocktype, struct curl_sockaddr *); +-typedef curl_socket_t (_curl_opensocket_callback4) ++typedef curl_socket_t (*_curl_opensocket_callback4) + (const void *, curlsocktype, const struct curl_sockaddr *); + + /* evaluates to true if expr is of type curl_progress_callback or "similar" */ + #define _curl_is_progress_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) || \ ++ _curl_callback_compatible((expr), curl_progress_callback) || \ + _curl_callback_compatible((expr), _curl_progress_callback1) || \ + _curl_callback_compatible((expr), _curl_progress_callback2)) +-typedef int (_curl_progress_callback1)(void *, ++typedef int (*_curl_progress_callback1)(void *, + double, double, double, double); +-typedef int (_curl_progress_callback2)(const void *, ++typedef int (*_curl_progress_callback2)(const void *, + double, double, double, double); + + /* evaluates to true if expr is of type curl_debug_callback or "similar" */ + #define _curl_is_debug_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) || \ ++ _curl_callback_compatible((expr), curl_debug_callback) || \ + _curl_callback_compatible((expr), _curl_debug_callback1) || \ + _curl_callback_compatible((expr), _curl_debug_callback2) || \ + _curl_callback_compatible((expr), _curl_debug_callback3) || \ +- _curl_callback_compatible((expr), _curl_debug_callback4)) +-typedef int (_curl_debug_callback1) (CURL *, ++ _curl_callback_compatible((expr), _curl_debug_callback4) || \ ++ _curl_callback_compatible((expr), _curl_debug_callback5) || \ ++ _curl_callback_compatible((expr), _curl_debug_callback6) || \ ++ _curl_callback_compatible((expr), _curl_debug_callback7) || \ ++ _curl_callback_compatible((expr), _curl_debug_callback8)) ++typedef int (*_curl_debug_callback1) (CURL *, + curl_infotype, char *, size_t, void *); +-typedef int (_curl_debug_callback2) (CURL *, ++typedef int (*_curl_debug_callback2) (CURL *, + curl_infotype, char *, size_t, const void *); +-typedef int (_curl_debug_callback3) (CURL *, ++typedef int (*_curl_debug_callback3) (CURL *, + curl_infotype, const char *, size_t, void *); +-typedef int (_curl_debug_callback4) (CURL *, ++typedef int (*_curl_debug_callback4) (CURL *, + curl_infotype, const char *, size_t, const void *); ++typedef int (*_curl_debug_callback5) (CURL *, ++ curl_infotype, unsigned char *, size_t, void *); ++typedef int (*_curl_debug_callback6) (CURL *, ++ curl_infotype, unsigned char *, size_t, const void *); ++typedef int (*_curl_debug_callback7) (CURL *, ++ curl_infotype, const unsigned char *, size_t, void *); ++typedef int (*_curl_debug_callback8) (CURL *, ++ curl_infotype, const unsigned char *, size_t, const void *); + + /* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ + /* this is getting even messier... */ + #define _curl_is_ssl_ctx_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) || \ ++ _curl_callback_compatible((expr), curl_ssl_ctx_callback) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback8)) +-typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *); +-typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *); +-typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *); +-typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *); ++typedef CURLcode (*_curl_ssl_ctx_callback1)(CURL *, void *, void *); ++typedef CURLcode (*_curl_ssl_ctx_callback2)(CURL *, void *, const void *); ++typedef CURLcode (*_curl_ssl_ctx_callback3)(CURL *, const void *, void *); ++typedef CURLcode (*_curl_ssl_ctx_callback4)(CURL *, const void *, ++ const void *); + #ifdef HEADER_SSL_H + /* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX + * this will of course break if we're included before OpenSSL headers... + */ +-typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *); +-typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *); +-typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *); +-typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX, const void *); ++typedef CURLcode (*_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *); ++typedef CURLcode (*_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *); ++typedef CURLcode (*_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *); ++typedef CURLcode (*_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX, ++ const void *); + #else + typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; + typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; + typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; + typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; + #endif + + /* evaluates to true if expr is of type curl_conv_callback or "similar" */ + #define _curl_is_conv_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) || \ ++ _curl_callback_compatible((expr), curl_conv_callback) || \ + _curl_callback_compatible((expr), _curl_conv_callback1) || \ + _curl_callback_compatible((expr), _curl_conv_callback2) || \ + _curl_callback_compatible((expr), _curl_conv_callback3) || \ + _curl_callback_compatible((expr), _curl_conv_callback4)) + typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); + typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); + typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); + typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); + + /* evaluates to true if expr is of type curl_seek_callback or "similar" */ + #define _curl_is_seek_cb(expr) \ + (_curl_is_NULL(expr) || \ +- __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) || \ ++ _curl_callback_compatible((expr), curl_seek_callback) || \ + _curl_callback_compatible((expr), _curl_seek_callback1) || \ + _curl_callback_compatible((expr), _curl_seek_callback2)) + typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); + typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); + + + #endif /* __CURL_TYPECHECK_GCC_H */ +diff --git a/src/third_party/curl/types.h b/src/third_party/curl/types.h +deleted file mode 100644 +--- a/src/third_party/curl/types.h ++++ /dev/null +@@ -1,1 +0,0 @@ +-/* not used */ +diff --git a/src/third_party/curl/urlapi.h b/src/third_party/curl/urlapi.h +new file mode 100644 +--- /dev/null ++++ b/src/third_party/curl/urlapi.h +@@ -0,0 +1,122 @@ ++#ifndef __CURL_URLAPI_H ++#define __CURL_URLAPI_H ++/*************************************************************************** ++ * _ _ ____ _ ++ * Project ___| | | | _ \| | ++ * / __| | | | |_) | | ++ * | (__| |_| | _ <| |___ ++ * \___|\___/|_| \_\_____| ++ * ++ * Copyright (C) 2018 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al. ++ * ++ * This software is licensed as described in the file COPYING, which ++ * you should have received as part of this distribution. The terms ++ * are also available at https://curl.haxx.se/docs/copyright.html. ++ * ++ * You may opt to use, copy, modify, merge, publish, distribute and/or sell ++ * copies of the Software, and permit persons to whom the Software is ++ * furnished to do so, under the terms of the COPYING file. ++ * ++ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY ++ * KIND, either express or implied. ++ * ++ ***************************************************************************/ ++ ++#include "curl.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* the error codes for the URL API */ ++typedef enum { ++ CURLUE_OK, ++ CURLUE_BAD_HANDLE, /* 1 */ ++ CURLUE_BAD_PARTPOINTER, /* 2 */ ++ CURLUE_MALFORMED_INPUT, /* 3 */ ++ CURLUE_BAD_PORT_NUMBER, /* 4 */ ++ CURLUE_UNSUPPORTED_SCHEME, /* 5 */ ++ CURLUE_URLDECODE, /* 6 */ ++ CURLUE_OUT_OF_MEMORY, /* 7 */ ++ CURLUE_USER_NOT_ALLOWED, /* 8 */ ++ CURLUE_UNKNOWN_PART, /* 9 */ ++ CURLUE_NO_SCHEME, /* 10 */ ++ CURLUE_NO_USER, /* 11 */ ++ CURLUE_NO_PASSWORD, /* 12 */ ++ CURLUE_NO_OPTIONS, /* 13 */ ++ CURLUE_NO_HOST, /* 14 */ ++ CURLUE_NO_PORT, /* 15 */ ++ CURLUE_NO_QUERY, /* 16 */ ++ CURLUE_NO_FRAGMENT /* 17 */ ++} CURLUcode; ++ ++typedef enum { ++ CURLUPART_URL, ++ CURLUPART_SCHEME, ++ CURLUPART_USER, ++ CURLUPART_PASSWORD, ++ CURLUPART_OPTIONS, ++ CURLUPART_HOST, ++ CURLUPART_PORT, ++ CURLUPART_PATH, ++ CURLUPART_QUERY, ++ CURLUPART_FRAGMENT ++} CURLUPart; ++ ++#define CURLU_DEFAULT_PORT (1<<0) /* return default port number */ ++#define CURLU_NO_DEFAULT_PORT (1<<1) /* act as if no port number was set, ++ if the port number matches the ++ default for the scheme */ ++#define CURLU_DEFAULT_SCHEME (1<<2) /* return default scheme if ++ missing */ ++#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */ ++#define CURLU_PATH_AS_IS (1<<4) /* leave dot sequences */ ++#define CURLU_DISALLOW_USER (1<<5) /* no user+password allowed */ ++#define CURLU_URLDECODE (1<<6) /* URL decode on get */ ++#define CURLU_URLENCODE (1<<7) /* URL encode on set */ ++#define CURLU_APPENDQUERY (1<<8) /* append a form style part */ ++#define CURLU_GUESS_SCHEME (1<<9) /* legacy curl-style guessing */ ++ ++typedef struct Curl_URL CURLU; ++ ++/* ++ * curl_url() creates a new CURLU handle and returns a pointer to it. ++ * Must be freed with curl_url_cleanup(). ++ */ ++CURL_EXTERN CURLU *curl_url(void); ++ ++/* ++ * curl_url_cleanup() frees the CURLU handle and related resources used for ++ * the URL parsing. It will not free strings previously returned with the URL ++ * API. ++ */ ++CURL_EXTERN void curl_url_cleanup(CURLU *handle); ++ ++/* ++ * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new ++ * handle must also be freed with curl_url_cleanup(). ++ */ ++CURL_EXTERN CURLU *curl_url_dup(CURLU *in); ++ ++/* ++ * curl_url_get() extracts a specific part of the URL from a CURLU ++ * handle. Returns error code. The returned pointer MUST be freed with ++ * curl_free() afterwards. ++ */ ++CURL_EXTERN CURLUcode curl_url_get(CURLU *handle, CURLUPart what, ++ char **part, unsigned int flags); ++ ++/* ++ * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns ++ * error code. The passed in string will be copied. Passing a NULL instead of ++ * a part string, clears that part. ++ */ ++CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what, ++ const char *part, unsigned int flags); ++ ++ ++#ifdef __cplusplus ++} /* end of extern "C" */ ++#endif ++ ++#endif +diff --git a/src/third_party/musl/include/elf.h b/src/third_party/musl/include/elf.h +--- a/src/third_party/musl/include/elf.h ++++ b/src/third_party/musl/include/elf.h +@@ -205,23 +205,123 @@ typedef struct { + #define EM_D10V 85 + #define EM_D30V 86 + #define EM_V850 87 + #define EM_M32R 88 + #define EM_MN10300 89 + #define EM_MN10200 90 + #define EM_PJ 91 + #define EM_OR1K 92 ++#define EM_OPENRISC 92 + #define EM_ARC_A5 93 ++#define EM_ARC_COMPACT 93 + #define EM_XTENSA 94 ++#define EM_VIDEOCORE 95 ++#define EM_TMM_GPP 96 ++#define EM_NS32K 97 ++#define EM_TPC 98 ++#define EM_SNP1K 99 ++#define EM_ST200 100 ++#define EM_IP2K 101 ++#define EM_MAX 102 ++#define EM_CR 103 ++#define EM_F2MC16 104 ++#define EM_MSP430 105 ++#define EM_BLACKFIN 106 ++#define EM_SE_C33 107 ++#define EM_SEP 108 ++#define EM_ARCA 109 ++#define EM_UNICORE 110 ++#define EM_EXCESS 111 ++#define EM_DXP 112 ++#define EM_ALTERA_NIOS2 113 ++#define EM_CRX 114 ++#define EM_XGATE 115 ++#define EM_C166 116 ++#define EM_M16C 117 ++#define EM_DSPIC30F 118 ++#define EM_CE 119 ++#define EM_M32C 120 ++#define EM_TSK3000 131 ++#define EM_RS08 132 ++#define EM_SHARC 133 ++#define EM_ECOG2 134 ++#define EM_SCORE7 135 ++#define EM_DSP24 136 ++#define EM_VIDEOCORE3 137 ++#define EM_LATTICEMICO32 138 ++#define EM_SE_C17 139 ++#define EM_TI_C6000 140 ++#define EM_TI_C2000 141 ++#define EM_TI_C5500 142 ++#define EM_TI_ARP32 143 ++#define EM_TI_PRU 144 ++#define EM_MMDSP_PLUS 160 ++#define EM_CYPRESS_M8C 161 ++#define EM_R32C 162 ++#define EM_TRIMEDIA 163 ++#define EM_QDSP6 164 ++#define EM_8051 165 ++#define EM_STXP7X 166 ++#define EM_NDS32 167 ++#define EM_ECOG1X 168 ++#define EM_MAXQ30 169 ++#define EM_XIMO16 170 ++#define EM_MANIK 171 ++#define EM_CRAYNV2 172 ++#define EM_RX 173 ++#define EM_METAG 174 ++#define EM_MCST_ELBRUS 175 ++#define EM_ECOG16 176 ++#define EM_CR16 177 ++#define EM_ETPU 178 ++#define EM_SLE9X 179 ++#define EM_L10M 180 ++#define EM_K10M 181 + #define EM_AARCH64 183 ++#define EM_AVR32 185 ++#define EM_STM8 186 ++#define EM_TILE64 187 + #define EM_TILEPRO 188 + #define EM_MICROBLAZE 189 ++#define EM_CUDA 190 + #define EM_TILEGX 191 +-#define EM_NUM 192 ++#define EM_CLOUDSHIELD 192 ++#define EM_COREA_1ST 193 ++#define EM_COREA_2ND 194 ++#define EM_ARC_COMPACT2 195 ++#define EM_OPEN8 196 ++#define EM_RL78 197 ++#define EM_VIDEOCORE5 198 ++#define EM_78KOR 199 ++#define EM_56800EX 200 ++#define EM_BA1 201 ++#define EM_BA2 202 ++#define EM_XCORE 203 ++#define EM_MCHP_PIC 204 ++#define EM_KM32 210 ++#define EM_KMX32 211 ++#define EM_EMX16 212 ++#define EM_EMX8 213 ++#define EM_KVARC 214 ++#define EM_CDP 215 ++#define EM_COGE 216 ++#define EM_COOL 217 ++#define EM_NORC 218 ++#define EM_CSR_KALIMBA 219 ++#define EM_Z80 220 ++#define EM_VISIUM 221 ++#define EM_FT32 222 ++#define EM_MOXIE 223 ++#define EM_AMDGPU 224 ++#define EM_RISCV 243 ++#define EM_BPF 247 ++#define EM_CSKY 252 ++#define EM_NUM 253 ++ + #define EM_ALPHA 0x9026 + + #define EV_NONE 0 + #define EV_CURRENT 1 + #define EV_NUM 2 + + typedef struct { + Elf32_Word sh_name; +@@ -311,21 +411,42 @@ typedef struct { + #define SHF_MERGE (1 << 4) + #define SHF_STRINGS (1 << 5) + #define SHF_INFO_LINK (1 << 6) + #define SHF_LINK_ORDER (1 << 7) + #define SHF_OS_NONCONFORMING (1 << 8) + + #define SHF_GROUP (1 << 9) + #define SHF_TLS (1 << 10) ++#define SHF_COMPRESSED (1 << 11) + #define SHF_MASKOS 0x0ff00000 + #define SHF_MASKPROC 0xf0000000 + #define SHF_ORDERED (1 << 30) + #define SHF_EXCLUDE (1U << 31) + ++typedef struct { ++ Elf32_Word ch_type; ++ Elf32_Word ch_size; ++ Elf32_Word ch_addralign; ++} Elf32_Chdr; ++ ++typedef struct { ++ Elf64_Word ch_type; ++ Elf64_Word ch_reserved; ++ Elf64_Xword ch_size; ++ Elf64_Xword ch_addralign; ++} Elf64_Chdr; ++ ++#define ELFCOMPRESS_ZLIB 1 ++#define ELFCOMPRESS_LOOS 0x60000000 ++#define ELFCOMPRESS_HIOS 0x6fffffff ++#define ELFCOMPRESS_LOPROC 0x70000000 ++#define ELFCOMPRESS_HIPROC 0x7fffffff ++ ++ + #define GRP_COMDAT 0x1 + + typedef struct { + Elf32_Word st_name; + Elf32_Addr st_value; + Elf32_Word st_size; + unsigned char st_info; + unsigned char st_other; +@@ -404,18 +525,17 @@ typedef struct { + #define STV_DEFAULT 0 + #define STV_INTERNAL 1 + #define STV_HIDDEN 2 + #define STV_PROTECTED 3 + + + + +-typedef struct +-{ ++typedef struct { + Elf32_Addr r_offset; + Elf32_Word r_info; + } Elf32_Rel; + + typedef struct { + Elf64_Addr r_offset; + Elf64_Xword r_info; + } Elf64_Rel; +@@ -499,16 +619,17 @@ typedef struct { + #define PF_W (1 << 1) + #define PF_R (1 << 2) + #define PF_MASKOS 0x0ff00000 + #define PF_MASKPROC 0xf0000000 + + + + #define NT_PRSTATUS 1 ++#define NT_PRFPREG 2 + #define NT_FPREGSET 2 + #define NT_PRPSINFO 3 + #define NT_PRXREG 4 + #define NT_TASKSTRUCT 4 + #define NT_PLATFORM 5 + #define NT_AUXV 6 + #define NT_GWINDOWS 7 + #define NT_ASRS 8 +@@ -520,35 +641,61 @@ typedef struct { + #define NT_LWPSINFO 17 + #define NT_PRFPXREG 20 + #define NT_SIGINFO 0x53494749 + #define NT_FILE 0x46494c45 + #define NT_PRXFPREG 0x46e62b7f + #define NT_PPC_VMX 0x100 + #define NT_PPC_SPE 0x101 + #define NT_PPC_VSX 0x102 ++#define NT_PPC_TAR 0x103 ++#define NT_PPC_PPR 0x104 ++#define NT_PPC_DSCR 0x105 ++#define NT_PPC_EBB 0x106 ++#define NT_PPC_PMU 0x107 ++#define NT_PPC_TM_CGPR 0x108 ++#define NT_PPC_TM_CFPR 0x109 ++#define NT_PPC_TM_CVMX 0x10a ++#define NT_PPC_TM_CVSX 0x10b ++#define NT_PPC_TM_SPR 0x10c ++#define NT_PPC_TM_CTAR 0x10d ++#define NT_PPC_TM_CPPR 0x10e ++#define NT_PPC_TM_CDSCR 0x10f + #define NT_386_TLS 0x200 + #define NT_386_IOPERM 0x201 + #define NT_X86_XSTATE 0x202 + #define NT_S390_HIGH_GPRS 0x300 + #define NT_S390_TIMER 0x301 + #define NT_S390_TODCMP 0x302 + #define NT_S390_TODPREG 0x303 + #define NT_S390_CTRS 0x304 + #define NT_S390_PREFIX 0x305 + #define NT_S390_LAST_BREAK 0x306 + #define NT_S390_SYSTEM_CALL 0x307 + #define NT_S390_TDB 0x308 ++#define NT_S390_VXRS_LOW 0x309 ++#define NT_S390_VXRS_HIGH 0x30a ++#define NT_S390_GS_CB 0x30b ++#define NT_S390_GS_BC 0x30c ++#define NT_S390_RI_CB 0x30d + #define NT_ARM_VFP 0x400 + #define NT_ARM_TLS 0x401 + #define NT_ARM_HW_BREAK 0x402 + #define NT_ARM_HW_WATCH 0x403 ++#define NT_ARM_SYSTEM_CALL 0x404 ++#define NT_ARM_SVE 0x405 ++#define NT_ARM_PAC_MASK 0x406 + #define NT_METAG_CBUF 0x500 + #define NT_METAG_RPIPE 0x501 + #define NT_METAG_TLS 0x502 ++#define NT_ARC_V2 0x600 ++#define NT_VMCOREDD 0x700 ++#define NT_MIPS_DSP 0x800 ++#define NT_MIPS_FP_MODE 0x801 ++#define NT_MIPS_MSA 0x802 + #define NT_VERSION 1 + + + + + typedef struct { + Elf32_Sword d_tag; + union { +@@ -596,17 +743,18 @@ typedef struct { + #define DT_FINI_ARRAY 26 + #define DT_INIT_ARRAYSZ 27 + #define DT_FINI_ARRAYSZ 28 + #define DT_RUNPATH 29 + #define DT_FLAGS 30 + #define DT_ENCODING 32 + #define DT_PREINIT_ARRAY 32 + #define DT_PREINIT_ARRAYSZ 33 +-#define DT_NUM 34 ++#define DT_SYMTAB_SHNDX 34 ++#define DT_NUM 35 + #define DT_LOOS 0x6000000d + #define DT_HIOS 0x6ffff000 + #define DT_LOPROC 0x70000000 + #define DT_HIPROC 0x7fffffff + #define DT_PROCNUM DT_MIPS_NUM + + #define DT_VALRNGLO 0x6ffffd00 + #define DT_GNU_PRELINKED 0x6ffffdf5 +@@ -696,16 +844,18 @@ typedef struct { + #define DF_1_IGNMULDEF 0x00040000 + #define DF_1_NOKSYMS 0x00080000 + #define DF_1_NOHDR 0x00100000 + #define DF_1_EDITED 0x00200000 + #define DF_1_NORELOC 0x00400000 + #define DF_1_SYMINTPOSE 0x00800000 + #define DF_1_GLOBAUDIT 0x01000000 + #define DF_1_SINGLETON 0x02000000 ++#define DF_1_STUB 0x04000000 ++#define DF_1_PIE 0x08000000 + + #define DTF_1_PARINIT 0x00000001 + #define DTF_1_CONFEXP 0x00000002 + + + #define DF_P1_LAZYLOAD 0x00000001 + #define DF_P1_GROUPPERM 0x00000002 + +@@ -877,17 +1027,26 @@ typedef struct { + + + + #define AT_L1I_CACHESHAPE 34 + #define AT_L1D_CACHESHAPE 35 + #define AT_L2_CACHESHAPE 36 + #define AT_L3_CACHESHAPE 37 + +- ++#define AT_L1I_CACHESIZE 40 ++#define AT_L1I_CACHEGEOMETRY 41 ++#define AT_L1D_CACHESIZE 42 ++#define AT_L1D_CACHEGEOMETRY 43 ++#define AT_L2_CACHESIZE 44 ++#define AT_L2_CACHEGEOMETRY 45 ++#define AT_L3_CACHESIZE 46 ++#define AT_L3_CACHEGEOMETRY 47 ++ ++#define AT_MINSIGSTKSZ 51 + + + typedef struct { + Elf32_Word n_namesz; + Elf32_Word n_descsz; + Elf32_Word n_type; + } Elf32_Nhdr; + +@@ -972,17 +1131,35 @@ typedef struct { + #define R_68K_PLT8 15 + #define R_68K_PLT32O 16 + #define R_68K_PLT16O 17 + #define R_68K_PLT8O 18 + #define R_68K_COPY 19 + #define R_68K_GLOB_DAT 20 + #define R_68K_JMP_SLOT 21 + #define R_68K_RELATIVE 22 +-#define R_68K_NUM 23 ++#define R_68K_TLS_GD32 25 ++#define R_68K_TLS_GD16 26 ++#define R_68K_TLS_GD8 27 ++#define R_68K_TLS_LDM32 28 ++#define R_68K_TLS_LDM16 29 ++#define R_68K_TLS_LDM8 30 ++#define R_68K_TLS_LDO32 31 ++#define R_68K_TLS_LDO16 32 ++#define R_68K_TLS_LDO8 33 ++#define R_68K_TLS_IE32 34 ++#define R_68K_TLS_IE16 35 ++#define R_68K_TLS_IE8 36 ++#define R_68K_TLS_LE32 37 ++#define R_68K_TLS_LE16 38 ++#define R_68K_TLS_LE8 39 ++#define R_68K_TLS_DTPMOD32 40 ++#define R_68K_TLS_DTPREL32 41 ++#define R_68K_TLS_TPREL32 42 ++#define R_68K_NUM 43 + + #define R_386_NONE 0 + #define R_386_32 1 + #define R_386_PC32 2 + #define R_386_GOT32 3 + #define R_386_PLT32 4 + #define R_386_COPY 5 + #define R_386_GLOB_DAT 6 +@@ -1015,17 +1192,18 @@ typedef struct { + #define R_386_TLS_DTPMOD32 35 + #define R_386_TLS_DTPOFF32 36 + #define R_386_TLS_TPOFF32 37 + #define R_386_SIZE32 38 + #define R_386_TLS_GOTDESC 39 + #define R_386_TLS_DESC_CALL 40 + #define R_386_TLS_DESC 41 + #define R_386_IRELATIVE 42 +-#define R_386_NUM 43 ++#define R_386_GOT32X 43 ++#define R_386_NUM 44 + + + + + + #define STT_SPARC_REGISTER 13 + + +@@ -1148,16 +1326,17 @@ typedef struct { + + #define EF_MIPS_NOREORDER 1 + #define EF_MIPS_PIC 2 + #define EF_MIPS_CPIC 4 + #define EF_MIPS_XGOT 8 + #define EF_MIPS_64BIT_WHIRL 16 + #define EF_MIPS_ABI2 32 + #define EF_MIPS_ABI_ON32 64 ++#define EF_MIPS_FP64 512 + #define EF_MIPS_NAN2008 1024 + #define EF_MIPS_ARCH 0xf0000000 + + + + #define EF_MIPS_ARCH_1 0x00000000 + #define EF_MIPS_ARCH_2 0x10000000 + #define EF_MIPS_ARCH_3 0x20000000 +@@ -1392,16 +1571,17 @@ typedef struct { + + #define R_MIPS_NUM 128 + + + + #define PT_MIPS_REGINFO 0x70000000 + #define PT_MIPS_RTPROC 0x70000001 + #define PT_MIPS_OPTIONS 0x70000002 ++#define PT_MIPS_ABIFLAGS 0x70000003 + + + + #define PF_MIPS_LOCAL 0x10000000 + + + + #define DT_MIPS_RLD_VERSION 0x70000001 +@@ -1455,17 +1635,18 @@ typedef struct { + + #define DT_MIPS_COMPACT_SIZE 0x7000002f + #define DT_MIPS_GP_VALUE 0x70000030 + #define DT_MIPS_AUX_DYNAMIC 0x70000031 + + #define DT_MIPS_PLTGOT 0x70000032 + + #define DT_MIPS_RWPLT 0x70000034 +-#define DT_MIPS_NUM 0x35 ++#define DT_MIPS_RLD_MAP_REL 0x70000035 ++#define DT_MIPS_NUM 0x36 + + + + #define RHF_NONE 0 + #define RHF_QUICKSTART (1 << 0) + #define RHF_NOTPOT (1 << 1) + #define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) + #define RHF_NO_MOVE (1 << 3) +@@ -1478,27 +1659,25 @@ typedef struct { + #define RHF_REQUICKSTART (1 << 10) + #define RHF_REQUICKSTARTED (1 << 11) + #define RHF_CORD (1 << 12) + #define RHF_NO_UNRES_UNDEF (1 << 13) + #define RHF_RLD_ORDER_SAFE (1 << 14) + + + +-typedef struct +-{ ++typedef struct { + Elf32_Word l_name; + Elf32_Word l_time_stamp; + Elf32_Word l_checksum; + Elf32_Word l_version; + Elf32_Word l_flags; + } Elf32_Lib; + +-typedef struct +-{ ++typedef struct { + Elf64_Word l_name; + Elf64_Word l_time_stamp; + Elf64_Word l_checksum; + Elf64_Word l_version; + Elf64_Word l_flags; + } Elf64_Lib; + + +@@ -1511,17 +1690,83 @@ typedef struct + #define LL_EXPORTS (1 << 3) + #define LL_DELAY_LOAD (1 << 4) + #define LL_DELTA (1 << 5) + + + + typedef Elf32_Addr Elf32_Conflict; + +- ++typedef struct { ++ Elf32_Half version; ++ unsigned char isa_level; ++ unsigned char isa_rev; ++ unsigned char gpr_size; ++ unsigned char cpr1_size; ++ unsigned char cpr2_size; ++ unsigned char fp_abi; ++ Elf32_Word isa_ext; ++ Elf32_Word ases; ++ Elf32_Word flags1; ++ Elf32_Word flags2; ++} Elf_MIPS_ABIFlags_v0; ++ ++#define MIPS_AFL_REG_NONE 0x00 ++#define MIPS_AFL_REG_32 0x01 ++#define MIPS_AFL_REG_64 0x02 ++#define MIPS_AFL_REG_128 0x03 ++ ++#define MIPS_AFL_ASE_DSP 0x00000001 ++#define MIPS_AFL_ASE_DSPR2 0x00000002 ++#define MIPS_AFL_ASE_EVA 0x00000004 ++#define MIPS_AFL_ASE_MCU 0x00000008 ++#define MIPS_AFL_ASE_MDMX 0x00000010 ++#define MIPS_AFL_ASE_MIPS3D 0x00000020 ++#define MIPS_AFL_ASE_MT 0x00000040 ++#define MIPS_AFL_ASE_SMARTMIPS 0x00000080 ++#define MIPS_AFL_ASE_VIRT 0x00000100 ++#define MIPS_AFL_ASE_MSA 0x00000200 ++#define MIPS_AFL_ASE_MIPS16 0x00000400 ++#define MIPS_AFL_ASE_MICROMIPS 0x00000800 ++#define MIPS_AFL_ASE_XPA 0x00001000 ++#define MIPS_AFL_ASE_MASK 0x00001fff ++ ++#define MIPS_AFL_EXT_XLR 1 ++#define MIPS_AFL_EXT_OCTEON2 2 ++#define MIPS_AFL_EXT_OCTEONP 3 ++#define MIPS_AFL_EXT_LOONGSON_3A 4 ++#define MIPS_AFL_EXT_OCTEON 5 ++#define MIPS_AFL_EXT_5900 6 ++#define MIPS_AFL_EXT_4650 7 ++#define MIPS_AFL_EXT_4010 8 ++#define MIPS_AFL_EXT_4100 9 ++#define MIPS_AFL_EXT_3900 10 ++#define MIPS_AFL_EXT_10000 11 ++#define MIPS_AFL_EXT_SB1 12 ++#define MIPS_AFL_EXT_4111 13 ++#define MIPS_AFL_EXT_4120 14 ++#define MIPS_AFL_EXT_5400 15 ++#define MIPS_AFL_EXT_5500 16 ++#define MIPS_AFL_EXT_LOONGSON_2E 17 ++#define MIPS_AFL_EXT_LOONGSON_2F 18 ++ ++#define MIPS_AFL_FLAGS1_ODDSPREG 1 ++ ++enum ++{ ++ Val_GNU_MIPS_ABI_FP_ANY = 0, ++ Val_GNU_MIPS_ABI_FP_DOUBLE = 1, ++ Val_GNU_MIPS_ABI_FP_SINGLE = 2, ++ Val_GNU_MIPS_ABI_FP_SOFT = 3, ++ Val_GNU_MIPS_ABI_FP_OLD_64 = 4, ++ Val_GNU_MIPS_ABI_FP_XX = 5, ++ Val_GNU_MIPS_ABI_FP_64 = 6, ++ Val_GNU_MIPS_ABI_FP_64A = 7, ++ Val_GNU_MIPS_ABI_FP_MAX = 7 ++}; + + + + + #define EF_PARISC_TRAPNIL 0x00010000 + #define EF_PARISC_EXT 0x00020000 + #define EF_PARISC_LSB 0x00040000 + #define EF_PARISC_WIDE 0x00080000 +@@ -1852,17 +2097,18 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_PPC_GOT_TPREL16 87 + #define R_PPC_GOT_TPREL16_LO 88 + #define R_PPC_GOT_TPREL16_HI 89 + #define R_PPC_GOT_TPREL16_HA 90 + #define R_PPC_GOT_DTPREL16 91 + #define R_PPC_GOT_DTPREL16_LO 92 + #define R_PPC_GOT_DTPREL16_HI 93 + #define R_PPC_GOT_DTPREL16_HA 94 +- ++#define R_PPC_TLSGD 95 ++#define R_PPC_TLSLD 96 + + + #define R_PPC_EMB_NADDR32 101 + #define R_PPC_EMB_NADDR16 102 + #define R_PPC_EMB_NADDR16_LO 103 + #define R_PPC_EMB_NADDR16_HI 104 + #define R_PPC_EMB_NADDR16_HA 105 + #define R_PPC_EMB_SDAI16 106 +@@ -1895,17 +2141,20 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_PPC_REL16_HA 252 + + + + #define R_PPC_TOC16 255 + + + #define DT_PPC_GOT (DT_LOPROC + 0) +-#define DT_PPC_NUM 1 ++#define DT_PPC_OPT (DT_LOPROC + 1) ++#define DT_PPC_NUM 2 ++ ++#define PPC_OPT_TLS 1 + + + #define R_PPC64_NONE R_PPC_NONE + #define R_PPC64_ADDR32 R_PPC_ADDR32 + #define R_PPC64_ADDR24 R_PPC_ADDR24 + #define R_PPC64_ADDR16 R_PPC_ADDR16 + #define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO + #define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI +@@ -2008,33 +2257,49 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_PPC64_TPREL16_HIGHEST 99 + #define R_PPC64_TPREL16_HIGHESTA 100 + #define R_PPC64_DTPREL16_DS 101 + #define R_PPC64_DTPREL16_LO_DS 102 + #define R_PPC64_DTPREL16_HIGHER 103 + #define R_PPC64_DTPREL16_HIGHERA 104 + #define R_PPC64_DTPREL16_HIGHEST 105 + #define R_PPC64_DTPREL16_HIGHESTA 106 ++#define R_PPC64_TLSGD 107 ++#define R_PPC64_TLSLD 108 ++#define R_PPC64_TOCSAVE 109 ++#define R_PPC64_ADDR16_HIGH 110 ++#define R_PPC64_ADDR16_HIGHA 111 ++#define R_PPC64_TPREL16_HIGH 112 ++#define R_PPC64_TPREL16_HIGHA 113 ++#define R_PPC64_DTPREL16_HIGH 114 ++#define R_PPC64_DTPREL16_HIGHA 115 + + + #define R_PPC64_JMP_IREL 247 + #define R_PPC64_IRELATIVE 248 + #define R_PPC64_REL16 249 + #define R_PPC64_REL16_LO 250 + #define R_PPC64_REL16_HI 251 + #define R_PPC64_REL16_HA 252 + ++#define EF_PPC64_ABI 3 + + #define DT_PPC64_GLINK (DT_LOPROC + 0) + #define DT_PPC64_OPD (DT_LOPROC + 1) + #define DT_PPC64_OPDSZ (DT_LOPROC + 2) +-#define DT_PPC64_NUM 3 +- +- +- ++#define DT_PPC64_OPT (DT_LOPROC + 3) ++#define DT_PPC64_NUM 4 ++ ++#define PPC64_OPT_TLS 1 ++#define PPC64_OPT_MULTI_TOC 2 ++#define PPC64_OPT_LOCALENTRY 4 ++ ++#define STO_PPC64_LOCAL_BIT 5 ++#define STO_PPC64_LOCAL_MASK 0xe0 ++#define PPC64_LOCAL_ENTRY_OFFSET(x) (1 << (((x)&0xe0)>>5) & 0xfc) + + + #define EF_ARM_RELEXEC 0x01 + #define EF_ARM_HASENTRY 0x02 + #define EF_ARM_INTERWORK 0x04 + #define EF_ARM_APCS_26 0x08 + #define EF_ARM_APCS_FLOAT 0x10 + #define EF_ARM_PIC 0x20 +@@ -2084,18 +2349,27 @@ typedef Elf32_Addr Elf32_Conflict; + + #define PT_ARM_EXIDX (PT_LOPROC + 1) + + + #define SHT_ARM_EXIDX (SHT_LOPROC + 1) + #define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2) + #define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3) + +- + #define R_AARCH64_NONE 0 ++#define R_AARCH64_P32_ABS32 1 ++#define R_AARCH64_P32_COPY 180 ++#define R_AARCH64_P32_GLOB_DAT 181 ++#define R_AARCH64_P32_JUMP_SLOT 182 ++#define R_AARCH64_P32_RELATIVE 183 ++#define R_AARCH64_P32_TLS_DTPMOD 184 ++#define R_AARCH64_P32_TLS_DTPREL 185 ++#define R_AARCH64_P32_TLS_TPREL 186 ++#define R_AARCH64_P32_TLSDESC 187 ++#define R_AARCH64_P32_IRELATIVE 188 + #define R_AARCH64_ABS64 257 + #define R_AARCH64_ABS32 258 + #define R_AARCH64_ABS16 259 + #define R_AARCH64_PREL64 260 + #define R_AARCH64_PREL32 261 + #define R_AARCH64_PREL16 262 + #define R_AARCH64_MOVW_UABS_G0 263 + #define R_AARCH64_MOVW_UABS_G0_NC 264 +@@ -2203,18 +2477,21 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_AARCH64_TLSLE_LDST128_TPREL_LO12 570 + #define R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC 571 + #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12 572 + #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC 573 + #define R_AARCH64_COPY 1024 + #define R_AARCH64_GLOB_DAT 1025 + #define R_AARCH64_JUMP_SLOT 1026 + #define R_AARCH64_RELATIVE 1027 ++#define R_AARCH64_TLS_DTPMOD 1028 + #define R_AARCH64_TLS_DTPMOD64 1028 ++#define R_AARCH64_TLS_DTPREL 1029 + #define R_AARCH64_TLS_DTPREL64 1029 ++#define R_AARCH64_TLS_TPREL 1030 + #define R_AARCH64_TLS_TPREL64 1030 + #define R_AARCH64_TLSDESC 1031 + + + #define R_ARM_NONE 0 + #define R_ARM_PC24 1 + #define R_ARM_ABS32 2 + #define R_ARM_REL32 3 +@@ -2342,16 +2619,71 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_ARM_RREL32 252 + #define R_ARM_RABS22 253 + #define R_ARM_RPC24 254 + #define R_ARM_RBASE 255 + + #define R_ARM_NUM 256 + + ++#define R_CKCORE_NONE 0 ++#define R_CKCORE_ADDR32 1 ++#define R_CKCORE_PCRELIMM8BY4 2 ++#define R_CKCORE_PCRELIMM11BY2 3 ++#define R_CKCORE_PCREL32 5 ++#define R_CKCORE_PCRELJSR_IMM11BY2 6 ++#define R_CKCORE_RELATIVE 9 ++#define R_CKCORE_COPY 10 ++#define R_CKCORE_GLOB_DAT 11 ++#define R_CKCORE_JUMP_SLOT 12 ++#define R_CKCORE_GOTOFF 13 ++#define R_CKCORE_GOTPC 14 ++#define R_CKCORE_GOT32 15 ++#define R_CKCORE_PLT32 16 ++#define R_CKCORE_ADDRGOT 17 ++#define R_CKCORE_ADDRPLT 18 ++#define R_CKCORE_PCREL_IMM26BY2 19 ++#define R_CKCORE_PCREL_IMM16BY2 20 ++#define R_CKCORE_PCREL_IMM16BY4 21 ++#define R_CKCORE_PCREL_IMM10BY2 22 ++#define R_CKCORE_PCREL_IMM10BY4 23 ++#define R_CKCORE_ADDR_HI16 24 ++#define R_CKCORE_ADDR_LO16 25 ++#define R_CKCORE_GOTPC_HI16 26 ++#define R_CKCORE_GOTPC_LO16 27 ++#define R_CKCORE_GOTOFF_HI16 28 ++#define R_CKCORE_GOTOFF_LO16 29 ++#define R_CKCORE_GOT12 30 ++#define R_CKCORE_GOT_HI16 31 ++#define R_CKCORE_GOT_LO16 32 ++#define R_CKCORE_PLT12 33 ++#define R_CKCORE_PLT_HI16 34 ++#define R_CKCORE_PLT_LO16 35 ++#define R_CKCORE_ADDRGOT_HI16 36 ++#define R_CKCORE_ADDRGOT_LO16 37 ++#define R_CKCORE_ADDRPLT_HI16 38 ++#define R_CKCORE_ADDRPLT_LO16 39 ++#define R_CKCORE_PCREL_JSR_IMM26BY2 40 ++#define R_CKCORE_TOFFSET_LO16 41 ++#define R_CKCORE_DOFFSET_LO16 42 ++#define R_CKCORE_PCREL_IMM18BY2 43 ++#define R_CKCORE_DOFFSET_IMM18 44 ++#define R_CKCORE_DOFFSET_IMM18BY2 45 ++#define R_CKCORE_DOFFSET_IMM18BY4 46 ++#define R_CKCORE_GOT_IMM18BY4 48 ++#define R_CKCORE_PLT_IMM18BY4 49 ++#define R_CKCORE_PCREL_IMM7BY4 50 ++#define R_CKCORE_TLS_LE32 51 ++#define R_CKCORE_TLS_IE32 52 ++#define R_CKCORE_TLS_GD32 53 ++#define R_CKCORE_TLS_LDM32 54 ++#define R_CKCORE_TLS_LDO32 55 ++#define R_CKCORE_TLS_DTPMOD32 56 ++#define R_CKCORE_TLS_DTPOFF32 57 ++#define R_CKCORE_TLS_TPOFF32 58 + + + #define EF_IA_64_MASKOS 0x0000000f + #define EF_IA_64_ABI64 0x00000010 + #define EF_IA_64_ARCH 0xff000000 + + + #define PT_IA_64_ARCHEXT (PT_LOPROC + 0) +@@ -2454,17 +2786,38 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_IA64_DTPREL64I 0xb3 + #define R_IA64_DTPREL32MSB 0xb4 + #define R_IA64_DTPREL32LSB 0xb5 + #define R_IA64_DTPREL64MSB 0xb6 + #define R_IA64_DTPREL64LSB 0xb7 + #define R_IA64_LTOFF_DTPREL22 0xba + + +- ++#define EF_SH_MACH_MASK 0x1f ++#define EF_SH_UNKNOWN 0x0 ++#define EF_SH1 0x1 ++#define EF_SH2 0x2 ++#define EF_SH3 0x3 ++#define EF_SH_DSP 0x4 ++#define EF_SH3_DSP 0x5 ++#define EF_SH4AL_DSP 0x6 ++#define EF_SH3E 0x8 ++#define EF_SH4 0x9 ++#define EF_SH2E 0xb ++#define EF_SH4A 0xc ++#define EF_SH2A 0xd ++#define EF_SH4_NOFPU 0x10 ++#define EF_SH4A_NOFPU 0x11 ++#define EF_SH4_NOMMU_NOFPU 0x12 ++#define EF_SH2A_NOFPU 0x13 ++#define EF_SH3_NOMMU 0x14 ++#define EF_SH2A_SH4_NOFPU 0x15 ++#define EF_SH2A_SH3_NOFPU 0x16 ++#define EF_SH2A_SH4 0x17 ++#define EF_SH2A_SH3E 0x18 + + #define R_SH_NONE 0 + #define R_SH_DIR32 1 + #define R_SH_REL32 2 + #define R_SH_DIR8WPN 3 + #define R_SH_IND12W 4 + #define R_SH_DIR8WPL 5 + #define R_SH_DIR8WPZ 6 +@@ -2660,17 +3013,19 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_X86_64_SIZE64 33 + + #define R_X86_64_GOTPC32_TLSDESC 34 + #define R_X86_64_TLSDESC_CALL 35 + + #define R_X86_64_TLSDESC 36 + #define R_X86_64_IRELATIVE 37 + #define R_X86_64_RELATIVE64 38 +-#define R_X86_64_NUM 39 ++#define R_X86_64_GOTPCRELX 41 ++#define R_X86_64_REX_GOTPCRELX 42 ++#define R_X86_64_NUM 43 + + + + #define R_MN10300_NONE 0 + #define R_MN10300_32 1 + #define R_MN10300_16 2 + #define R_MN10300_8 3 + #define R_MN10300_PCREL32 4 +@@ -2778,16 +3133,65 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_MICROBLAZE_TLSGD 23 + #define R_MICROBLAZE_TLSLD 24 + #define R_MICROBLAZE_TLSDTPMOD32 25 + #define R_MICROBLAZE_TLSDTPREL32 26 + #define R_MICROBLAZE_TLSDTPREL64 27 + #define R_MICROBLAZE_TLSGOTTPREL32 28 + #define R_MICROBLAZE_TLSTPREL32 29 + ++#define DT_NIOS2_GP 0x70000002 ++ ++#define R_NIOS2_NONE 0 ++#define R_NIOS2_S16 1 ++#define R_NIOS2_U16 2 ++#define R_NIOS2_PCREL16 3 ++#define R_NIOS2_CALL26 4 ++#define R_NIOS2_IMM5 5 ++#define R_NIOS2_CACHE_OPX 6 ++#define R_NIOS2_IMM6 7 ++#define R_NIOS2_IMM8 8 ++#define R_NIOS2_HI16 9 ++#define R_NIOS2_LO16 10 ++#define R_NIOS2_HIADJ16 11 ++#define R_NIOS2_BFD_RELOC_32 12 ++#define R_NIOS2_BFD_RELOC_16 13 ++#define R_NIOS2_BFD_RELOC_8 14 ++#define R_NIOS2_GPREL 15 ++#define R_NIOS2_GNU_VTINHERIT 16 ++#define R_NIOS2_GNU_VTENTRY 17 ++#define R_NIOS2_UJMP 18 ++#define R_NIOS2_CJMP 19 ++#define R_NIOS2_CALLR 20 ++#define R_NIOS2_ALIGN 21 ++#define R_NIOS2_GOT16 22 ++#define R_NIOS2_CALL16 23 ++#define R_NIOS2_GOTOFF_LO 24 ++#define R_NIOS2_GOTOFF_HA 25 ++#define R_NIOS2_PCREL_LO 26 ++#define R_NIOS2_PCREL_HA 27 ++#define R_NIOS2_TLS_GD16 28 ++#define R_NIOS2_TLS_LDM16 29 ++#define R_NIOS2_TLS_LDO16 30 ++#define R_NIOS2_TLS_IE16 31 ++#define R_NIOS2_TLS_LE16 32 ++#define R_NIOS2_TLS_DTPMOD 33 ++#define R_NIOS2_TLS_DTPREL 34 ++#define R_NIOS2_TLS_TPREL 35 ++#define R_NIOS2_COPY 36 ++#define R_NIOS2_GLOB_DAT 37 ++#define R_NIOS2_JUMP_SLOT 38 ++#define R_NIOS2_RELATIVE 39 ++#define R_NIOS2_GOTOFF 40 ++#define R_NIOS2_CALL26_NOAT 41 ++#define R_NIOS2_GOT_LO 42 ++#define R_NIOS2_GOT_HA 43 ++#define R_NIOS2_CALL_LO 44 ++#define R_NIOS2_CALL_HA 45 ++ + #define R_OR1K_NONE 0 + #define R_OR1K_32 1 + #define R_OR1K_16 2 + #define R_OR1K_8 3 + #define R_OR1K_LO_16_IN_INSN 4 + #define R_OR1K_HI_16_IN_INSN 5 + #define R_OR1K_INSN_REL_26 6 + #define R_OR1K_GNU_VTENTRY 7 +@@ -2814,14 +3218,17 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_OR1K_TLS_IE_HI16 28 + #define R_OR1K_TLS_IE_LO16 29 + #define R_OR1K_TLS_LE_HI16 30 + #define R_OR1K_TLS_LE_LO16 31 + #define R_OR1K_TLS_TPOFF 32 + #define R_OR1K_TLS_DTPOFF 33 + #define R_OR1K_TLS_DTPMOD 34 + ++#define R_BPF_NONE 0 ++#define R_BPF_MAP_FD 1 ++ + #ifdef __cplusplus + } + #endif + + + #endif + diff --git a/toolkit/crashreporter/breakpad-patches/09-json-upload.patch b/toolkit/crashreporter/breakpad-patches/09-json-upload.patch new file mode 100644 index 0000000000..8ad73bc681 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/09-json-upload.patch @@ -0,0 +1,333 @@ +diff --git a/src/common/linux/http_upload.cc b/src/common/linux/http_upload.cc +index 702526af..0a1019dd 100644 +--- a/src/common/linux/http_upload.cc ++++ b/src/common/linux/http_upload.cc +@@ -55,7 +55,7 @@ static const char kUserAgent[] = "Breakpad/1.0 (Linux)"; + + // static + bool HTTPUpload::SendRequest(const string &url, +- const map<string, string> ¶meters, ++ const string ¶meters, + const map<string, string> &files, + const string &proxy, + const string &proxy_user_pwd, +@@ -66,9 +66,6 @@ bool HTTPUpload::SendRequest(const string &url, + if (response_code != NULL) + *response_code = 0; + +- if (!CheckParameters(parameters)) +- return false; +- + // We may have been linked statically; if curl_easy_init is in the + // current binary, no need to search for a dynamic version. + void* curl_lib = dlopen(NULL, RTLD_NOW); +@@ -133,14 +130,14 @@ bool HTTPUpload::SendRequest(const string &url, + // Add form data. + CURLFORMcode (*curl_formadd)(struct curl_httppost **, struct curl_httppost **, ...); + *(void**) (&curl_formadd) = dlsym(curl_lib, "curl_formadd"); +- map<string, string>::const_iterator iter = parameters.begin(); +- for (; iter != parameters.end(); ++iter) +- (*curl_formadd)(&formpost, &lastptr, +- CURLFORM_COPYNAME, iter->first.c_str(), +- CURLFORM_COPYCONTENTS, iter->second.c_str(), +- CURLFORM_END); ++ (*curl_formadd)(&formpost, &lastptr, CURLFORM_COPYNAME, "extra", ++ CURLFORM_BUFFER, "extra.json", CURLFORM_BUFFERPTR, ++ parameters.c_str(), CURLFORM_BUFFERLENGTH, ++ parameters.length(), CURLFORM_CONTENTTYPE, "application/json", ++ CURLFORM_END); + + // Add form files. ++ map<string, string>::const_iterator iter = files.begin(); + for (iter = files.begin(); iter != files.end(); ++iter) { + (*curl_formadd)(&formpost, &lastptr, + CURLFORM_COPYNAME, iter->first.c_str(), +@@ -210,21 +207,4 @@ bool HTTPUpload::CheckCurlLib(void* curl_lib) { + dlsym(curl_lib, "curl_easy_setopt"); + } + +-// static +-bool HTTPUpload::CheckParameters(const map<string, string> ¶meters) { +- for (map<string, string>::const_iterator pos = parameters.begin(); +- pos != parameters.end(); ++pos) { +- const string &str = pos->first; +- if (str.size() == 0) +- return false; // disallow empty parameter names +- for (unsigned int i = 0; i < str.size(); ++i) { +- int c = str[i]; +- if (c < 32 || c == '"' || c > 127) { +- return false; +- } +- } +- } +- return true; +-} +- + } // namespace google_breakpad +diff --git a/src/common/linux/http_upload.h b/src/common/linux/http_upload.h +index bc1d5d57..95dedebc 100644 +--- a/src/common/linux/http_upload.h ++++ b/src/common/linux/http_upload.h +@@ -29,7 +29,7 @@ + + // HTTPUpload provides a "nice" API to send a multipart HTTP(S) POST + // request using libcurl. It currently supports requests that contain +-// a set of string parameters (key/value pairs), and a file to upload. ++// parameters encoded in a JSON string, and a file to upload. + + #ifndef COMMON_LINUX_HTTP_UPLOAD_H__ + #define COMMON_LINUX_HTTP_UPLOAD_H__ +@@ -49,8 +49,7 @@ class HTTPUpload { + // request to the given URL. + // Each key in |files| is the name of the file part of the request + // (i.e. it corresponds to the name= attribute on an <input type="file">. +- // Parameter names must contain only printable ASCII characters, +- // and may not contain a quote (") character. ++ // Parameters are specified as a JSON-encoded string in |parameters|. + // Only HTTP(S) URLs are currently supported. Returns true on success. + // If the request is successful and response_body is non-NULL, + // the response body will be returned in response_body. +@@ -59,7 +58,7 @@ class HTTPUpload { + // If the send fails, a description of the error will be + // returned in error_description. + static bool SendRequest(const string &url, +- const map<string, string> ¶meters, ++ const string ¶meters, + const map<string, string> &files, + const string &proxy, + const string &proxy_user_pwd, +@@ -69,11 +68,6 @@ class HTTPUpload { + string *error_description); + + private: +- // Checks that the given list of parameters has only printable +- // ASCII characters in the parameter name, and does not contain +- // any quote (") characters. Returns true if so. +- static bool CheckParameters(const map<string, string> ¶meters); +- + // Checks the curl_lib parameter points to a valid curl lib. + static bool CheckCurlLib(void* curl_lib); + +diff --git a/src/common/mac/HTTPMultipartUpload.h b/src/common/mac/HTTPMultipartUpload.h +index 42e8fed3..0cea733e 100644 +--- a/src/common/mac/HTTPMultipartUpload.h ++++ b/src/common/mac/HTTPMultipartUpload.h +@@ -37,7 +37,7 @@ + @interface HTTPMultipartUpload : NSObject { + @protected + NSURL *url_; // The destination URL (STRONG) +- NSDictionary *parameters_; // The key/value pairs for sending data (STRONG) ++ NSMutableString *parameters_; // The JSON payload for sending data (STRONG) + NSMutableDictionary *files_; // Dictionary of name/file-path (STRONG) + NSString *boundary_; // The boundary string (STRONG) + NSHTTPURLResponse *response_; // The response from the send (STRONG) +@@ -47,8 +47,8 @@ + + - (NSURL *)URL; + +-- (void)setParameters:(NSDictionary *)parameters; +-- (NSDictionary *)parameters; ++- (void)setParameters:(NSMutableString *)parameters; ++- (NSMutableString *)parameters; + + - (void)addFileAtPath:(NSString *)path name:(NSString *)name; + - (void)addFileContents:(NSData *)data name:(NSString *)name; +diff --git a/src/common/mac/HTTPMultipartUpload.m b/src/common/mac/HTTPMultipartUpload.m +index a3677f25..d2480493 100644 +--- a/src/common/mac/HTTPMultipartUpload.m ++++ b/src/common/mac/HTTPMultipartUpload.m +@@ -93,7 +93,7 @@ static NSData *SendSynchronousNSURLRequest(NSURLRequest *req, + - (NSString *)multipartBoundary; + // Each of the following methods will append the starting multipart boundary, + // but not the ending one. +-- (NSData *)formDataForKey:(NSString *)key value:(NSString *)value; ++- (NSData *)formDataForJSON:(NSString *)json; + - (NSData *)formDataForFileContents:(NSData *)contents name:(NSString *)name; + - (NSData *)formDataForFile:(NSString *)file name:(NSString *)name; + @end +@@ -110,13 +110,16 @@ static NSData *SendSynchronousNSURLRequest(NSURLRequest *req, + } + + //============================================================================= +-- (NSData *)formDataForKey:(NSString *)key value:(NSString *)value { +- NSString *escaped = PercentEncodeNSString(key); +- NSString *fmt = +- @"--%@\r\nContent-Disposition: form-data; name=\"%@\"\r\n\r\n%@\r\n"; +- NSString *form = [NSString stringWithFormat:fmt, boundary_, escaped, value]; ++- (NSData *)formDataForJSON:(NSString *)json { ++ NSMutableData *data = [NSMutableData data]; ++ NSString *fmt = @"--%@\r\nContent-Disposition: form-data; name=\"extra\"; " ++ "filename=\"extra.json\"\r\nContent-Type: application/json\r\n\r\n"; ++ NSString *form = [NSString stringWithFormat:fmt, boundary_]; ++ ++ [data appendData:[form dataUsingEncoding:NSUTF8StringEncoding]]; ++ [data appendData:[json dataUsingEncoding:NSUTF8StringEncoding]]; + +- return [form dataUsingEncoding:NSUTF8StringEncoding]; ++ return data; + } + + //============================================================================= +@@ -171,15 +174,15 @@ static NSData *SendSynchronousNSURLRequest(NSURLRequest *req, + } + + //============================================================================= +-- (void)setParameters:(NSDictionary *)parameters { ++- (void)setParameters:(NSMutableString *)parameters { + if (parameters != parameters_) { + [parameters_ release]; +- parameters_ = [parameters copy]; ++ parameters_ = [parameters mutableCopy]; + } + } + + //============================================================================= +-- (NSDictionary *)parameters { ++- (NSMutableString *)parameters { + return parameters_; + } + +@@ -210,16 +213,8 @@ static NSData *SendSynchronousNSURLRequest(NSURLRequest *req, + [req setValue:[NSString stringWithFormat:@"multipart/form-data; boundary=%@", + boundary_] forHTTPHeaderField:@"Content-type"]; + +- // Add any parameters to the message +- NSArray *parameterKeys = [parameters_ allKeys]; +- NSString *key; +- +- NSInteger count = [parameterKeys count]; +- for (NSInteger i = 0; i < count; ++i) { +- key = [parameterKeys objectAtIndex:i]; +- [postBody appendData:[self formDataForKey:key +- value:[parameters_ objectForKey:key]]]; +- } ++ // Add JSON parameters to the message ++ [postBody appendData:[self formDataForJSON:parameters_]]; + + // Add any files to the message + NSArray *fileNames = [files_ allKeys]; +diff --git a/src/common/windows/http_upload.cc b/src/common/windows/http_upload.cc +index b0cc9078..5df17e1a 100644 +--- a/src/common/windows/http_upload.cc ++++ b/src/common/windows/http_upload.cc +@@ -141,23 +141,6 @@ namespace { + return rv; + } + +- bool CheckParameters(const map<wstring, wstring> ¶meters) { +- for (map<wstring, wstring>::const_iterator pos = parameters.begin(); +- pos != parameters.end(); ++pos) { +- const wstring &str = pos->first; +- if (str.size() == 0) { +- return false; // disallow empty parameter names +- } +- for (unsigned int i = 0; i < str.size(); ++i) { +- wchar_t c = str[i]; +- if (c < 32 || c == '"' || c > 127) { +- return false; +- } +- } +- } +- return true; +- } +- + // Converts a UTF16 string to UTF8. + string WideToUTF8(const wstring &wide) { + return WideToMBCP(wide, CP_UTF8); +@@ -390,7 +373,7 @@ namespace { + return true; + } + +- bool GenerateRequestBody(const map<wstring, wstring> ¶meters, ++ bool GenerateRequestBody(const string ¶meters, + const map<wstring, wstring> &files, + const wstring &boundary, + string *request_body) { +@@ -401,14 +384,19 @@ namespace { + + request_body->clear(); + +- // Append each of the parameter pairs as a form-data part +- for (map<wstring, wstring>::const_iterator pos = parameters.begin(); +- pos != parameters.end(); ++pos) { +- request_body->append("--" + boundary_str + "\r\n"); +- request_body->append("Content-Disposition: form-data; name=\"" + +- WideToUTF8(pos->first) + "\"\r\n\r\n" + +- WideToUTF8(pos->second) + "\r\n"); ++ // Append the extra data as a single JSON form entry ++ request_body->append("--" + boundary_str + "\r\n"); ++ request_body->append( ++ "Content-Disposition: form-data; " ++ "name=\"extra\"; " ++ "filename=\"extra.json\"\r\n"); ++ request_body->append("Content-Type: application/json\r\n"); ++ request_body->append("\r\n"); ++ ++ if (!parameters.empty()) { ++ request_body->append(parameters); + } ++ request_body->append("\r\n"); + + // Now append each upload file as a binary (octet-stream) part + for (map<wstring, wstring>::const_iterator pos = files.begin(); +@@ -463,16 +451,11 @@ namespace google_breakpad { + + bool HTTPUpload::SendMultipartPostRequest( + const wstring& url, +- const map<wstring, wstring>& parameters, ++ const string& parameters, + const map<wstring, wstring>& files, + int* timeout_ms, + wstring* response_body, + int* response_code) { +- // TODO(bryner): support non-ASCII parameter names +- if (!CheckParameters(parameters)) { +- return false; +- } +- + wstring boundary = GenerateMultipartBoundary(); + wstring content_type_header = GenerateMultipartPostRequestHeader(boundary); + +diff --git a/src/common/windows/http_upload.h b/src/common/windows/http_upload.h +index 57e526e3..1e47f582 100644 +--- a/src/common/windows/http_upload.h ++++ b/src/common/windows/http_upload.h +@@ -29,7 +29,7 @@ + + // HTTPUpload provides a "nice" API to send a multipart HTTP(S) POST + // request using wininet. It currently supports requests that contain +-// a set of string parameters (key/value pairs), and a file to upload. ++// parameters encoded in a JSON string, and a file to upload. + + #ifndef COMMON_WINDOWS_HTTP_UPLOAD_H_ + #define COMMON_WINDOWS_HTTP_UPLOAD_H_ +@@ -45,9 +45,9 @@ + + namespace google_breakpad { + ++using std::map; + using std::string; + using std::wstring; +-using std::map; + + class HTTPUpload { + public: +@@ -81,8 +81,7 @@ class HTTPUpload { + // request to the given URL. + // Each key in |files| is the name of the file part of the request + // (i.e. it corresponds to the name= attribute on an <input type="file">. +- // Parameter names must contain only printable ASCII characters, +- // and may not contain a quote (") character. ++ // Parameters are specified as a JSON-encoded string in |parameters|. + // Only HTTP(S) URLs are currently supported. Returns true on success. + // If the request is successful and response_body is non-NULL, + // the response body will be returned in response_body. +@@ -90,7 +89,7 @@ class HTTPUpload { + // received (or 0 if the request failed before getting an HTTP response). + static bool SendMultipartPostRequest( + const wstring& url, +- const map<wstring, wstring>& parameters, ++ const string& parameters, + const map<wstring, wstring>& files, + int *timeout_ms, + wstring *response_body, diff --git a/toolkit/crashreporter/breakpad-patches/10-macho-cpu-subtype.patch b/toolkit/crashreporter/breakpad-patches/10-macho-cpu-subtype.patch new file mode 100644 index 0000000000..be743f9fe7 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/10-macho-cpu-subtype.patch @@ -0,0 +1,47 @@ +changeset: 571402:0c63dcd7a1c6 +user: Steven Michaud <smichaud@pobox.com> +date: Tue Nov 19 21:42:37 2019 +0000 +summary: Bug 1371390 - Pay attention to macho images' cpusubtype when creating minidumps (revised). r=gsvelto + +diff --git a/src/common/mac/macho_walker.cc b/src/common/mac/macho_walker.cc +--- a/src/common/mac/macho_walker.cc ++++ b/src/common/mac/macho_walker.cc +@@ -151,16 +151,18 @@ bool MachoWalker::FindHeader(cpu_type_t + // header + struct mach_header header; + if (!ReadBytes(&header, sizeof(header), 0)) + return false; + + if (magic == MH_CIGAM || magic == MH_CIGAM_64) + breakpad_swap_mach_header(&header); + ++ header.cpusubtype &= ~CPU_SUBTYPE_MASK; ++ + if (cpu_type != header.cputype || + (cpu_subtype != CPU_SUBTYPE_MULTIPLE && + cpu_subtype != header.cpusubtype)) { + return false; + } + + offset = 0; + return true; +@@ -180,16 +182,18 @@ bool MachoWalker::FindHeader(cpu_type_t + struct fat_arch arch; + for (uint32_t i = 0; i < fat.nfat_arch; ++i) { + if (!ReadBytes(&arch, sizeof(arch), offset)) + return false; + + if (NXHostByteOrder() != NX_BigEndian) + breakpad_swap_fat_arch(&arch, 1); + ++ arch.cpusubtype &= ~CPU_SUBTYPE_MASK; ++ + if (arch.cputype == cpu_type && + (cpu_subtype == CPU_SUBTYPE_MULTIPLE || + arch.cpusubtype == cpu_subtype)) { + offset = arch.offset; + return true; + } + + offset += sizeof(arch); + diff --git a/toolkit/crashreporter/breakpad-patches/12-macho-cpu-subtype-fix.patch b/toolkit/crashreporter/breakpad-patches/12-macho-cpu-subtype-fix.patch new file mode 100644 index 0000000000..6fad2d4d58 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/12-macho-cpu-subtype-fix.patch @@ -0,0 +1,22 @@ +commit 65b01bb302ba1eb7b0240753c22dce39c5ed836b +Author: Nathan Froyd <froydnj@mozilla.com> +Date: Tue Jul 14 16:50:20 2020 -0400 + + mask off cpusubtype bits before determining Mach-O identifiers; r=gsvelto + + If we don't do this, we run into problems when walking over the Mach-O load + commands, where we *do* mask off cpusubtype bits. + +diff --git a/src/common/mac/dump_syms.cc b/src/common/mac/dump_syms.cc +index 4ad0e2b..1c9a067 100644 +--- a/src/common/mac/dump_syms.cc ++++ b/src/common/mac/dump_syms.cc +@@ -286,7 +286,7 @@ string DumpSymbols::Identifier() { + FileID file_id(object_filename_.c_str()); + unsigned char identifier_bytes[16]; + cpu_type_t cpu_type = selected_object_file_->cputype; +- cpu_subtype_t cpu_subtype = selected_object_file_->cpusubtype; ++ cpu_subtype_t cpu_subtype = selected_object_file_->cpusubtype & ~CPU_SUBTYPE_MASK; + if (!file_id.MachoIdentifier(cpu_type, cpu_subtype, identifier_bytes)) { + fprintf(stderr, "Unable to calculate UUID of mach-o binary %s!\n", + object_filename_.c_str()); diff --git a/toolkit/crashreporter/breakpad-patches/13-improve-arm64-stack-walking.patch b/toolkit/crashreporter/breakpad-patches/13-improve-arm64-stack-walking.patch new file mode 100644 index 0000000000..b9c6f82799 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/13-improve-arm64-stack-walking.patch @@ -0,0 +1,79 @@ +diff --git a/src/processor/stackwalker_arm64.cc b/src/processor/stackwalker_arm64.cc +--- a/src/processor/stackwalker_arm64.cc ++++ b/src/processor/stackwalker_arm64.cc +@@ -282,16 +282,27 @@ void StackwalkerARM64::CorrectRegLRByFra + << std::hex << (last_last_fp + 8); + return; + } + last_lr = PtrauthStrip(last_lr); + + last_frame->context.iregs[MD_CONTEXT_ARM64_REG_LR] = last_lr; + } + ++bool StackwalkerARM64::ValidInstructionPointerInFrame(const StackFrameARM64& frame) { ++ const uint64_t ip = frame.context.iregs[MD_CONTEXT_ARM64_REG_PC]; ++ ++ if ((ip < 0x1000) || (ip > 0x000fffffffffffff)) { ++ // The IP points into the first page or above the user space threshold ++ return false; ++ } ++ ++ return true; ++} ++ + StackFrame* StackwalkerARM64::GetCallerFrame(const CallStack* stack, + bool stack_scan_allowed) { + if (!memory_ || !stack) { + BPLOG(ERROR) << "Can't get caller frame without memory or stack"; + return NULL; + } + + const vector<StackFrame*> &frames = *stack->frames(); +@@ -300,21 +311,22 @@ StackFrame* StackwalkerARM64::GetCallerF + + // See if there is DWARF call frame information covering this address. + scoped_ptr<CFIFrameInfo> cfi_frame_info( + frame_symbolizer_->FindCFIFrameInfo(last_frame)); + if (cfi_frame_info.get()) + frame.reset(GetCallerByCFIFrameInfo(frames, cfi_frame_info.get())); + + // If CFI failed, or there wasn't CFI available, fall back to frame pointer. +- if (!frame.get()) ++ if (!frame.get() || !ValidInstructionPointerInFrame(*frame)) + frame.reset(GetCallerByFramePointer(frames)); + + // If everything failed, fall back to stack scanning. +- if (stack_scan_allowed && !frame.get()) ++ if (stack_scan_allowed && ++ (!frame.get() || !ValidInstructionPointerInFrame(*frame))) + frame.reset(GetCallerByStackScan(frames)); + + // If nothing worked, tell the caller. + if (!frame.get()) + return NULL; + + // Should we terminate the stack walk? (end-of-stack or broken invariant) + if (TerminateWalk(frame->context.iregs[MD_CONTEXT_ARM64_REG_PC], +diff --git a/src/processor/stackwalker_arm64.h b/src/processor/stackwalker_arm64.h +--- a/src/processor/stackwalker_arm64.h ++++ b/src/processor/stackwalker_arm64.h +@@ -92,16 +92,19 @@ class StackwalkerARM64 : public Stackwal + + // GetCallerByFramePointer() depends on the previous frame having recovered + // x30($LR) which may not have been done when using CFI. + // This function recovers $LR in the previous frame by using the frame-pointer + // two frames back to read it from the stack. + void CorrectRegLRByFramePointer(const vector<StackFrame*>& frames, + StackFrameARM64* last_frame); + ++ // Return true if the instruction pointer points into the first 4KiB of memory ++ bool ValidInstructionPointerInFrame(const StackFrameARM64& frame); ++ + // Stores the CPU context corresponding to the youngest stack frame, to + // be returned by GetContextFrame. + const MDRawContextARM64* context_; + + // Validity mask for youngest stack frame. This is always + // CONTEXT_VALID_ALL in real use; it is only changeable for the sake of + // unit tests. + uint64_t context_frame_validity_; diff --git a/toolkit/crashreporter/breakpad-patches/14-handle-non-fixed-size-amd64-and-x86-contexts.patch b/toolkit/crashreporter/breakpad-patches/14-handle-non-fixed-size-amd64-and-x86-contexts.patch new file mode 100644 index 0000000000..b9544281c2 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/14-handle-non-fixed-size-amd64-and-x86-contexts.patch @@ -0,0 +1,344 @@ +diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc +index 1f479558..aa63fe47 100644 +--- a/src/processor/minidump.cc ++++ b/src/processor/minidump.cc +@@ -444,140 +444,30 @@ MinidumpContext::MinidumpContext(Minidump* minidump) + + MinidumpContext::~MinidumpContext() { + } + + bool MinidumpContext::Read(uint32_t expected_size) { + valid_ = false; + + // Certain raw context types are currently assumed to have unique sizes. +- if (!IsContextSizeUnique(sizeof(MDRawContextAMD64))) { +- BPLOG(ERROR) << "sizeof(MDRawContextAMD64) cannot match the size of any " +- << "other raw context"; +- return false; +- } + if (!IsContextSizeUnique(sizeof(MDRawContextPPC64))) { + BPLOG(ERROR) << "sizeof(MDRawContextPPC64) cannot match the size of any " + << "other raw context"; + return false; + } + if (!IsContextSizeUnique(sizeof(MDRawContextARM64_Old))) { + BPLOG(ERROR) << "sizeof(MDRawContextARM64_Old) cannot match the size of any " + << "other raw context"; + return false; + } + + FreeContext(); + +- // First, figure out what type of CPU this context structure is for. +- // For some reason, the AMD64 Context doesn't have context_flags +- // at the beginning of the structure, so special case it here. +- if (expected_size == sizeof(MDRawContextAMD64)) { +- BPLOG(INFO) << "MinidumpContext: looks like AMD64 context"; +- +- scoped_ptr<MDRawContextAMD64> context_amd64(new MDRawContextAMD64()); +- if (!minidump_->ReadBytes(context_amd64.get(), +- sizeof(MDRawContextAMD64))) { +- BPLOG(ERROR) << "MinidumpContext could not read amd64 context"; +- return false; +- } +- +- if (minidump_->swap()) +- Swap(&context_amd64->context_flags); +- +- uint32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK; +- if (cpu_type == 0) { +- if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) { +- context_amd64->context_flags |= cpu_type; +- } else { +- BPLOG(ERROR) << "Failed to preserve the current stream position"; +- return false; +- } +- } +- +- if (cpu_type != MD_CONTEXT_AMD64) { +- // TODO: Fall through to switch below. +- // https://bugs.chromium.org/p/google-breakpad/issues/detail?id=550 +- BPLOG(ERROR) << "MinidumpContext not actually amd64 context"; +- return false; +- } +- +- // Do this after reading the entire MDRawContext structure because +- // GetSystemInfo may seek minidump to a new position. +- if (!CheckAgainstSystemInfo(cpu_type)) { +- BPLOG(ERROR) << "MinidumpContext amd64 does not match system info"; +- return false; +- } +- +- // Normalize the 128-bit types in the dump. +- // Since this is AMD64, by definition, the values are little-endian. +- for (unsigned int vr_index = 0; +- vr_index < MD_CONTEXT_AMD64_VR_COUNT; +- ++vr_index) +- Normalize128(&context_amd64->vector_register[vr_index], false); +- +- if (minidump_->swap()) { +- Swap(&context_amd64->p1_home); +- Swap(&context_amd64->p2_home); +- Swap(&context_amd64->p3_home); +- Swap(&context_amd64->p4_home); +- Swap(&context_amd64->p5_home); +- Swap(&context_amd64->p6_home); +- // context_flags is already swapped +- Swap(&context_amd64->mx_csr); +- Swap(&context_amd64->cs); +- Swap(&context_amd64->ds); +- Swap(&context_amd64->es); +- Swap(&context_amd64->fs); +- Swap(&context_amd64->ss); +- Swap(&context_amd64->eflags); +- Swap(&context_amd64->dr0); +- Swap(&context_amd64->dr1); +- Swap(&context_amd64->dr2); +- Swap(&context_amd64->dr3); +- Swap(&context_amd64->dr6); +- Swap(&context_amd64->dr7); +- Swap(&context_amd64->rax); +- Swap(&context_amd64->rcx); +- Swap(&context_amd64->rdx); +- Swap(&context_amd64->rbx); +- Swap(&context_amd64->rsp); +- Swap(&context_amd64->rbp); +- Swap(&context_amd64->rsi); +- Swap(&context_amd64->rdi); +- Swap(&context_amd64->r8); +- Swap(&context_amd64->r9); +- Swap(&context_amd64->r10); +- Swap(&context_amd64->r11); +- Swap(&context_amd64->r12); +- Swap(&context_amd64->r13); +- Swap(&context_amd64->r14); +- Swap(&context_amd64->r15); +- Swap(&context_amd64->rip); +- // FIXME: I'm not sure what actually determines +- // which member of the union {flt_save, sse_registers} +- // is valid. We're not currently using either, +- // but it would be good to have them swapped properly. +- +- for (unsigned int vr_index = 0; +- vr_index < MD_CONTEXT_AMD64_VR_COUNT; +- ++vr_index) +- Swap(&context_amd64->vector_register[vr_index]); +- Swap(&context_amd64->vector_control); +- Swap(&context_amd64->debug_control); +- Swap(&context_amd64->last_branch_to_rip); +- Swap(&context_amd64->last_branch_from_rip); +- Swap(&context_amd64->last_exception_to_rip); +- Swap(&context_amd64->last_exception_from_rip); +- } +- +- SetContextFlags(context_amd64->context_flags); +- +- SetContextAMD64(context_amd64.release()); +- } else if (expected_size == sizeof(MDRawContextPPC64)) { ++ if (expected_size == sizeof(MDRawContextPPC64)) { + // |context_flags| of MDRawContextPPC64 is 64 bits, but other MDRawContext + // in the else case have 32 bits |context_flags|, so special case it here. + uint64_t context_flags; + if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) { + BPLOG(ERROR) << "MinidumpContext could not read context flags"; + return false; + } + if (minidump_->swap()) +@@ -739,56 +629,152 @@ bool MinidumpContext::Read(uint32_t expected_size) { + } + } + + scoped_ptr<MDRawContextARM64> new_context(new MDRawContextARM64()); + ConvertOldARM64Context(*context_arm64.get(), new_context.get()); + SetContextFlags(new_context->context_flags); + SetContextARM64(new_context.release()); + } else { +- uint32_t context_flags; +- if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) { +- BPLOG(ERROR) << "MinidumpContext could not read context flags"; ++ uint32_t cpu_type = 0; ++ if (!minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) { ++ BPLOG(ERROR) << "Failed to preserve the current stream position"; + return false; + } +- if (minidump_->swap()) +- Swap(&context_flags); + +- uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK; +- if (cpu_type == 0) { +- // Unfortunately the flag for MD_CONTEXT_ARM that was taken +- // from a Windows CE SDK header conflicts in practice with +- // the CONTEXT_XSTATE flag. MD_CONTEXT_ARM has been renumbered, +- // but handle dumps with the legacy value gracefully here. +- if (context_flags & MD_CONTEXT_ARM_OLD) { +- context_flags |= MD_CONTEXT_ARM; +- context_flags &= ~MD_CONTEXT_ARM_OLD; +- cpu_type = MD_CONTEXT_ARM; ++ uint32_t context_flags = 0; ++ if ((cpu_type == 0) || cpu_type != MD_CONTEXT_AMD64) { ++ if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) { ++ BPLOG(ERROR) << "MinidumpContext could not read context flags"; ++ return false; + } +- } + +- if (cpu_type == 0) { +- if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) { +- context_flags |= cpu_type; ++ if (minidump_->swap()) ++ Swap(&context_flags); ++ ++ if ((context_flags & MD_CONTEXT_CPU_MASK) == 0) { ++ // Unfortunately the flag for MD_CONTEXT_ARM that was taken ++ // from a Windows CE SDK header conflicts in practice with ++ // the CONTEXT_XSTATE flag. MD_CONTEXT_ARM has been renumbered, ++ // but handle dumps with the legacy value gracefully here. ++ if (context_flags & MD_CONTEXT_ARM_OLD) { ++ context_flags |= MD_CONTEXT_ARM; ++ context_flags &= ~MD_CONTEXT_ARM_OLD; ++ cpu_type = MD_CONTEXT_ARM; ++ } else { ++ context_flags |= cpu_type; ++ } + } else { +- BPLOG(ERROR) << "Failed to preserve the current stream position"; +- return false; ++ cpu_type = context_flags & MD_CONTEXT_CPU_MASK; + } + } + + // Allocate the context structure for the correct CPU and fill it. The + // casts are slightly unorthodox, but it seems better to do that than to + // maintain a separate pointer for each type of CPU context structure + // when only one of them will be used. + switch (cpu_type) { ++ case MD_CONTEXT_AMD64: { ++ if (expected_size != sizeof(MDRawContextAMD64)) { ++ BPLOG(INFO) << "MinidumpContext AMD64 size mismatch, " << ++ expected_size << " != " << sizeof(MDRawContextAMD64); ++ } ++ BPLOG(INFO) << "MinidumpContext: looks like AMD64 context"; ++ ++ scoped_ptr<MDRawContextAMD64> context_amd64(new MDRawContextAMD64()); ++ if (!minidump_->ReadBytes(context_amd64.get(), ++ sizeof(MDRawContextAMD64))) { ++ BPLOG(ERROR) << "MinidumpContext could not read amd64 context"; ++ return false; ++ } ++ ++ if (minidump_->swap()) ++ Swap(&context_amd64->context_flags); ++ ++ // Update context_flags since we haven't done it yet ++ context_flags = context_amd64->context_flags; ++ ++ if (cpu_type != (context_flags & MD_CONTEXT_CPU_MASK)) { ++ BPLOG(ERROR) << "MinidumpContext amd64 does not match system info"; ++ return false; ++ } ++ ++ // Normalize the 128-bit types in the dump. ++ // Since this is AMD64, by definition, the values are little-endian. ++ for (unsigned int vr_index = 0; ++ vr_index < MD_CONTEXT_AMD64_VR_COUNT; ++ ++vr_index) ++ Normalize128(&context_amd64->vector_register[vr_index], false); ++ ++ if (minidump_->swap()) { ++ Swap(&context_amd64->p1_home); ++ Swap(&context_amd64->p2_home); ++ Swap(&context_amd64->p3_home); ++ Swap(&context_amd64->p4_home); ++ Swap(&context_amd64->p5_home); ++ Swap(&context_amd64->p6_home); ++ // context_flags is already swapped ++ Swap(&context_amd64->mx_csr); ++ Swap(&context_amd64->cs); ++ Swap(&context_amd64->ds); ++ Swap(&context_amd64->es); ++ Swap(&context_amd64->fs); ++ Swap(&context_amd64->ss); ++ Swap(&context_amd64->eflags); ++ Swap(&context_amd64->dr0); ++ Swap(&context_amd64->dr1); ++ Swap(&context_amd64->dr2); ++ Swap(&context_amd64->dr3); ++ Swap(&context_amd64->dr6); ++ Swap(&context_amd64->dr7); ++ Swap(&context_amd64->rax); ++ Swap(&context_amd64->rcx); ++ Swap(&context_amd64->rdx); ++ Swap(&context_amd64->rbx); ++ Swap(&context_amd64->rsp); ++ Swap(&context_amd64->rbp); ++ Swap(&context_amd64->rsi); ++ Swap(&context_amd64->rdi); ++ Swap(&context_amd64->r8); ++ Swap(&context_amd64->r9); ++ Swap(&context_amd64->r10); ++ Swap(&context_amd64->r11); ++ Swap(&context_amd64->r12); ++ Swap(&context_amd64->r13); ++ Swap(&context_amd64->r14); ++ Swap(&context_amd64->r15); ++ Swap(&context_amd64->rip); ++ // FIXME: I'm not sure what actually determines ++ // which member of the union {flt_save, sse_registers} ++ // is valid. We're not currently using either, ++ // but it would be good to have them swapped properly. ++ ++ for (unsigned int vr_index = 0; ++ vr_index < MD_CONTEXT_AMD64_VR_COUNT; ++ ++vr_index) ++ Swap(&context_amd64->vector_register[vr_index]); ++ Swap(&context_amd64->vector_control); ++ Swap(&context_amd64->debug_control); ++ Swap(&context_amd64->last_branch_to_rip); ++ Swap(&context_amd64->last_branch_from_rip); ++ Swap(&context_amd64->last_exception_to_rip); ++ Swap(&context_amd64->last_exception_from_rip); ++ } ++ ++ SetContextFlags(context_amd64->context_flags); ++ ++ SetContextAMD64(context_amd64.release()); ++ minidump_->SeekSet( ++ (minidump_->Tell() - sizeof(MDRawContextAMD64)) + expected_size); ++ break; ++ } + case MD_CONTEXT_X86: { + if (expected_size != sizeof(MDRawContextX86)) { +- BPLOG(ERROR) << "MinidumpContext x86 size mismatch, " << ++ BPLOG(INFO) << "MinidumpContext x86 size mismatch, " << + expected_size << " != " << sizeof(MDRawContextX86); +- return false; + } + + scoped_ptr<MDRawContextX86> context_x86(new MDRawContextX86()); + + // Set the context_flags member, which has already been read, and + // read the rest of the structure beginning with the first member + // after context_flags. + context_x86->context_flags = context_flags; +@@ -843,16 +829,18 @@ bool MinidumpContext::Read(uint32_t expected_size) { + Swap(&context_x86->eflags); + Swap(&context_x86->esp); + Swap(&context_x86->ss); + // context_x86->extended_registers[] contains 8-bit quantities and + // does not need to be swapped. + } + + SetContextX86(context_x86.release()); ++ minidump_->SeekSet( ++ (minidump_->Tell() - sizeof(MDRawContextX86)) + expected_size); + + break; + } + + case MD_CONTEXT_PPC: { + if (expected_size != sizeof(MDRawContextPPC)) { + BPLOG(ERROR) << "MinidumpContext ppc size mismatch, " << + expected_size << " != " << sizeof(MDRawContextPPC); +-- +2.26.2 + diff --git a/toolkit/crashreporter/breakpad-patches/15-freebsd-profiler-support.patch b/toolkit/crashreporter/breakpad-patches/15-freebsd-profiler-support.patch new file mode 100644 index 0000000000..812d554865 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/15-freebsd-profiler-support.patch @@ -0,0 +1,107 @@ +changeset: 599606:74707e8ecf38 +user: Greg V <greg@unrelenting.technology> +date: Wed May 06 17:44:19 2020 +0000 +summary: Bug 1634205 - Support Gecko Profiler and Base Profiler on FreeBSD r=mstange + +diff --git a/src/common/dwarf/elf_reader.cc b/src/common/dwarf/elf_reader.cc +--- a/src/common/dwarf/elf_reader.cc ++++ b/src/common/dwarf/elf_reader.cc +@@ -52,17 +52,17 @@ + + // EM_AARCH64 is not defined by elf.h of GRTE v3 on x86. + // TODO(dougkwan): Remove this when v17 is retired. + #if !defined(EM_AARCH64) + #define EM_AARCH64 183 /* ARM AARCH64 */ + #endif + + // Map Linux macros to their Apple equivalents. +-#if __APPLE__ ++#if __APPLE__ || __FreeBSD__ + #ifndef __LITTLE_ENDIAN + #define __LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ + #endif // __LITTLE_ENDIAN + #ifndef __BIG_ENDIAN + #define __BIG_ENDIAN __ORDER_BIG_ENDIAN__ + #endif // __BIG_ENDIAN + #ifndef __BYTE_ORDER + #define __BYTE_ORDER __BYTE_ORDER__ +diff --git a/src/common/linux/elfutils.cc b/src/common/linux/elfutils.cc +--- a/src/common/linux/elfutils.cc ++++ b/src/common/linux/elfutils.cc +@@ -30,16 +30,20 @@ + #include "common/linux/elfutils.h" + + #include <assert.h> + #include <string.h> + + #include "common/linux/linux_libc_support.h" + #include "common/linux/elfutils-inl.h" + ++#if defined(__FreeBSD__) ++# define ElfW(type) Elf_##type ++#endif ++ + namespace google_breakpad { + + namespace { + + template<typename ElfClass> + void FindElfClassSection(const char *elf_base, + const char *section_name, + typename ElfClass::Word section_type, +diff --git a/src/common/memory_allocator.h b/src/common/memory_allocator.h +--- a/src/common/memory_allocator.h ++++ b/src/common/memory_allocator.h +@@ -37,17 +37,17 @@ + + #include <memory> + #include <vector> + + #if defined(MEMORY_SANITIZER) + #include <sanitizer/msan_interface.h> + #endif + +-#ifdef __APPLE__ ++#if defined(__APPLE__) || defined(__FreeBSD__) + #define sys_mmap mmap + #define sys_munmap munmap + #define MAP_ANONYMOUS MAP_ANON + #else + #include "third_party/lss/linux_syscall_support.h" + #endif + + namespace google_breakpad { +diff --git a/src/third_party/lss/linux_syscall_support.h b/src/third_party/lss/linux_syscall_support.h +--- a/src/third_party/lss/linux_syscall_support.h ++++ b/src/third_party/lss/linux_syscall_support.h +@@ -4527,10 +4527,27 @@ struct kernel_statfs { + #pragma pop_macro("pread64") + #pragma pop_macro("pwrite64") + #pragma pop_macro("getdents64") + + #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS) + } + #endif + +-#endif +-#endif ++#elif defined(__FreeBSD__) ++ ++#include <unistd.h> ++#include <sys/stat.h> ++ ++#define sys_readlink readlink ++ ++#define sys_open open ++#define sys_close close ++#define sys_fstat fstat ++#define sys_fstat64 fstat ++#define kernel_stat stat ++#define kernel_stat64 stat ++#define sys_mmap mmap ++#define sys_munmap munmap ++ ++#endif ++ ++#endif + diff --git a/toolkit/crashreporter/breakpad-patches/16-get-last-error.patch b/toolkit/crashreporter/breakpad-patches/16-get-last-error.patch new file mode 100644 index 0000000000..96bebbe503 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/16-get-last-error.patch @@ -0,0 +1,181 @@ +diff --git a/src/google_breakpad/processor/call_stack.h b/src/google_breakpad/processor/call_stack.h +--- a/src/google_breakpad/processor/call_stack.h ++++ b/src/google_breakpad/processor/call_stack.h +@@ -62,26 +62,30 @@ class CallStack { + + // Resets the CallStack to its initial empty state + void Clear(); + + const vector<StackFrame*>* frames() const { return &frames_; } + + // Set the TID associated with this call stack. + void set_tid(uint32_t tid) { tid_ = tid; } ++ void set_last_error(uint32_t last_error) { last_error_ = last_error; } + + uint32_t tid() const { return tid_; } ++ uint32_t last_error() const { return last_error_; } + + private: + // Stackwalker is responsible for building the frames_ vector. + friend class Stackwalker; + + // Storage for pushed frames. + vector<StackFrame*> frames_; + + // The TID associated with this call stack. Default to 0 if it's not + // available. + uint32_t tid_; ++ // The last error the OS set for this thread (win32's GetLastError()) ++ uint32_t last_error_; + }; + + } // namespace google_breakpad + + #endif // GOOGLE_BREAKPAD_PROCSSOR_CALL_STACK_H__ +diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h +--- a/src/google_breakpad/processor/minidump.h ++++ b/src/google_breakpad/processor/minidump.h +@@ -279,16 +279,26 @@ class MinidumpMemoryRegion : public Mini + class MinidumpThread : public MinidumpObject { + public: + virtual ~MinidumpThread(); + + const MDRawThread* thread() const { return valid_ ? &thread_ : NULL; } + // GetMemory may return NULL even if the MinidumpThread is valid, + // if the thread memory cannot be read. + virtual MinidumpMemoryRegion* GetMemory(); ++ // Corresponds to win32's GetLastError function, which records the last ++ // error value set by the OS for this thread. A more useful error message ++ // can be produced by passing this value to FormatMessage: ++ // ++ // https://docs.microsoft.com/windows/win32/debug/retrieving-the-last-error-code ++ // ++ // The value may also be looked up in Microsoft's System Error Codes listing: ++ // ++ // https://docs.microsoft.com/windows/win32/debug/system-error-codes ++ virtual uint32_t GetLastError(); + // GetContext may return NULL even if the MinidumpThread is valid. + virtual MinidumpContext* GetContext(); + + // The thread ID is used to determine if a thread is the exception thread, + // so a special getter is provided to retrieve this data from the + // MDRawThread structure. Returns false if the thread ID cannot be + // determined. + virtual bool GetThreadID(uint32_t *thread_id) const; +diff --git a/src/processor/call_stack.cc b/src/processor/call_stack.cc +--- a/src/processor/call_stack.cc ++++ b/src/processor/call_stack.cc +@@ -44,11 +44,12 @@ CallStack::~CallStack() { + + void CallStack::Clear() { + for (vector<StackFrame *>::const_iterator iterator = frames_.begin(); + iterator != frames_.end(); + ++iterator) { + delete *iterator; + } + tid_ = 0; ++ last_error_ = 0; + } + + } // namespace google_breakpad +diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc +--- a/src/processor/minidump.cc ++++ b/src/processor/minidump.cc +@@ -1567,16 +1567,76 @@ MinidumpMemoryRegion* MinidumpThread::Ge + if (!valid_) { + BPLOG(ERROR) << "Invalid MinidumpThread for GetMemory"; + return NULL; + } + + return memory_; + } + ++uint32_t MinidumpThread::GetLastError() { ++ if (!valid_) { ++ BPLOG(ERROR) << "Cannot retrieve GetLastError() from an invalid thread"; ++ return 0; ++ } ++ ++ if (!thread_.teb) { ++ BPLOG(ERROR) << "Cannot retrieve GetLastError() without a valid TEB pointer"; ++ return 0; ++ } ++ ++ auto memory = minidump_->GetMemoryList(); ++ if (!memory) { ++ BPLOG(ERROR) << "Cannot retrieve GetLastError() without a valid memory list"; ++ return 0; ++ } ++ ++ auto context = GetContext(); ++ if (!context) { ++ BPLOG(ERROR) << "Cannot retrieve GetLastError()'s without a valid context"; ++ return 0; ++ } ++ ++ uint64_t pointer_width = 0; ++ switch (context_->GetContextCPU()) { ++ case MD_CONTEXT_X86: ++ pointer_width = 4; ++ break; ++ case MD_CONTEXT_AMD64: ++ case MD_CONTEXT_ARM64: ++ pointer_width = 8; ++ break; ++ default: ++ BPLOG(ERROR) << "GetLastError() isn't implemented for this CPU type yet"; ++ return 0; ++ } ++ ++ auto region = memory->GetMemoryRegionForAddress(thread_.teb); ++ if (!region) { ++ BPLOG(ERROR) << "GetLastError()'s memory isn't mapped in this minidump"; ++ return 0; ++ } ++ ++ // The TEB is opaque but we know the value we want lives at this offset ++ // from reverse engineering. ++ uint64_t offset = pointer_width * 13; ++ uint32_t error = 0; ++ if (!region->GetMemoryAtAddress(thread_.teb + offset, &error)) { ++ BPLOG(ERROR) << "GetLastError()'s memory isn't mapped in this minidump"; ++ return 0; ++ } ++ ++ if (minidump_->swap()) { ++ Swap(&error); ++ } ++ ++ return error; ++} ++ ++ + + MinidumpContext* MinidumpThread::GetContext() { + if (!valid_) { + BPLOG(ERROR) << "Invalid MinidumpThread for GetContext"; + return NULL; + } + + if (!context_) { +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -301,16 +301,17 @@ ProcessResult MinidumpProcessor::Process + } + } else { + // Threads with missing CPU contexts will hit this, but + // don't abort processing the rest of the dump just for + // one bad thread. + BPLOG(ERROR) << "No stackwalker for " << thread_string; + } + stack->set_tid(thread_id); ++ stack->set_last_error(thread->GetLastError()); + process_state->threads_.push_back(stack.release()); + process_state->thread_memory_regions_.push_back(thread_memory); + } + + if (interrupted) { + BPLOG(INFO) << "Processing interrupted for " << dump->path(); + return PROCESS_SYMBOL_SUPPLIER_INTERRUPTED; + } diff --git a/toolkit/crashreporter/breakpad-patches/17-unloaded-modules.patch b/toolkit/crashreporter/breakpad-patches/17-unloaded-modules.patch new file mode 100644 index 0000000000..c413e4eff4 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/17-unloaded-modules.patch @@ -0,0 +1,251 @@ +changeset: 649910:59994b59eb51 +tag: tip +parent: 649905:058997a8167d +user: Gabriele Svelto <gsvelto@mozilla.com> +date: Wed Mar 31 16:25:34 2021 +0200 +summary: Bug 1702043 - Print out the list of unloaded modules when processing a minidump + +diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h +--- a/src/google_breakpad/processor/minidump.h ++++ b/src/google_breakpad/processor/minidump.h +@@ -792,16 +792,19 @@ class MinidumpUnloadedModule : public Mi + string debug_file() const override; + string debug_identifier() const override; + string version() const override; + CodeModule* Copy() const override; + bool is_unloaded() const override { return true; } + uint64_t shrink_down_delta() const override; + void SetShrinkDownDelta(uint64_t shrink_down_delta) override; + ++ // Print a human-readable representation of the object to stdout. ++ void Print(); ++ + protected: + explicit MinidumpUnloadedModule(Minidump* minidump); + + private: + // These objects are managed by MinidumpUnloadedModuleList + friend class MinidumpUnloadedModuleList; + + // This works like MinidumpStream::Read, but is driven by +@@ -850,16 +853,19 @@ class MinidumpUnloadedModuleList : publi + const MinidumpUnloadedModule* GetMainModule() const override; + const MinidumpUnloadedModule* + GetModuleAtSequence(unsigned int sequence) const override; + const MinidumpUnloadedModule* + GetModuleAtIndex(unsigned int index) const override; + const CodeModules* Copy() const override; + vector<linked_ptr<const CodeModule>> GetShrunkRangeModules() const override; + ++ // Print a human-readable representation of the object to stdout. ++ void Print(); ++ + protected: + explicit MinidumpUnloadedModuleList(Minidump* minidump_); + + private: + friend class Minidump; + + typedef vector<MinidumpUnloadedModule> MinidumpUnloadedModules; + +diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc +--- a/src/processor/minidump.cc ++++ b/src/processor/minidump.cc +@@ -3727,16 +3727,46 @@ MinidumpUnloadedModule::MinidumpUnloaded + name_(NULL) { + + } + + MinidumpUnloadedModule::~MinidumpUnloadedModule() { + delete name_; + } + ++void MinidumpUnloadedModule::Print() { ++ if (!valid_) { ++ BPLOG(ERROR) << "MinidumpUnloadedModule cannot print invalid data"; ++ return; ++ } ++ ++ printf("MDRawUnloadedModule\n"); ++ printf(" base_of_image = 0x%" PRIx64 "\n", ++ unloaded_module_.base_of_image); ++ printf(" size_of_image = 0x%x\n", ++ unloaded_module_.size_of_image); ++ printf(" checksum = 0x%x\n", ++ unloaded_module_.checksum); ++ printf(" time_date_stamp = 0x%x %s\n", ++ unloaded_module_.time_date_stamp, ++ TimeTToUTCString(unloaded_module_.time_date_stamp).c_str()); ++ printf(" module_name_rva = 0x%x\n", ++ unloaded_module_.module_name_rva); ++ ++ printf(" (code_file) = \"%s\"\n", code_file().c_str()); ++ printf(" (code_identifier) = \"%s\"\n", ++ code_identifier().c_str()); ++ ++ printf(" (debug_file) = \"%s\"\n", debug_file().c_str()); ++ printf(" (debug_identifier) = \"%s\"\n", ++ debug_identifier().c_str()); ++ printf(" (version) = \"%s\"\n", version().c_str()); ++ printf("\n"); ++} ++ + string MinidumpUnloadedModule::code_file() const { + if (!valid_) { + BPLOG(ERROR) << "Invalid MinidumpUnloadedModule for code_file"; + return ""; + } + + return *name_; + } +@@ -3911,16 +3941,34 @@ MinidumpUnloadedModuleList::MinidumpUnlo + range_map_->SetMergeStrategy(MergeRangeStrategy::kTruncateLower); + } + + MinidumpUnloadedModuleList::~MinidumpUnloadedModuleList() { + delete range_map_; + delete unloaded_modules_; + } + ++void MinidumpUnloadedModuleList::Print() { ++ if (!valid_) { ++ BPLOG(ERROR) << "MinidumpUnloadedModuleList cannot print invalid data"; ++ return; ++ } ++ ++ printf("MinidumpUnloadedModuleList\n"); ++ printf(" module_count = %d\n", module_count_); ++ printf("\n"); ++ ++ for (unsigned int module_index = 0; ++ module_index < module_count_; ++ ++module_index) { ++ printf("module[%d]\n", module_index); ++ ++ (*unloaded_modules_)[module_index].Print(); ++ } ++} + + bool MinidumpUnloadedModuleList::Read(uint32_t expected_size) { + range_map_->Clear(); + delete unloaded_modules_; + unloaded_modules_ = NULL; + module_count_ = 0; + + valid_ = false; +diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc +--- a/src/processor/minidump_dump.cc ++++ b/src/processor/minidump_dump.cc +@@ -40,16 +40,17 @@ + #include "google_breakpad/processor/minidump.h" + #include "processor/logging.h" + + namespace { + + using google_breakpad::Minidump; + using google_breakpad::MinidumpThreadList; + using google_breakpad::MinidumpModuleList; ++using google_breakpad::MinidumpUnloadedModuleList; + using google_breakpad::MinidumpMemoryInfoList; + using google_breakpad::MinidumpMemoryList; + using google_breakpad::MinidumpException; + using google_breakpad::MinidumpAssertion; + using google_breakpad::MinidumpSystemInfo; + using google_breakpad::MinidumpMiscInfo; + using google_breakpad::MinidumpBreakpadInfo; + using google_breakpad::MinidumpCrashpadInfo; +@@ -127,16 +128,25 @@ static bool PrintMinidumpDump(const Opti + MinidumpModuleList *module_list = minidump.GetModuleList(); + if (!module_list) { + ++errors; + BPLOG(ERROR) << "minidump.GetModuleList() failed"; + } else { + module_list->Print(); + } + ++ MinidumpUnloadedModuleList::set_max_modules(UINT32_MAX); ++ MinidumpUnloadedModuleList *unloaded_module_list = minidump.GetUnloadedModuleList(); ++ if (!unloaded_module_list) { ++ ++errors; ++ BPLOG(ERROR) << "minidump.GetUnloadedModuleList() failed"; ++ } else { ++ unloaded_module_list->Print(); ++ } ++ + MinidumpMemoryList *memory_list = minidump.GetMemoryList(); + if (!memory_list) { + ++errors; + BPLOG(ERROR) << "minidump.GetMemoryList() failed"; + } else { + memory_list->Print(); + } + +diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc +--- a/src/processor/stackwalk_common.cc ++++ b/src/processor/stackwalk_common.cc +@@ -777,16 +777,46 @@ static void PrintModulesMachineReadable( + StripSeparator(module->debug_identifier()).c_str(), + kOutputSeparator, base_address, + kOutputSeparator, base_address + module->size() - 1, + kOutputSeparator, + main_module != NULL && base_address == main_address ? 1 : 0); + } + } + ++// PrintUnloadedModulesMachineReadable outputs a list of loaded modules, ++// one per line, in the following machine-readable pipe-delimited ++// text format: ++// UnloadedModule|{Module Filename}|{Base Address}|{Max Address}|{Main} ++static void PrintUnloadedModulesMachineReadable(const CodeModules* modules) { ++ if (!modules) ++ return; ++ ++ uint64_t main_address = 0; ++ const CodeModule* main_module = modules->GetMainModule(); ++ if (main_module) { ++ main_address = main_module->base_address(); ++ } ++ ++ unsigned int module_count = modules->module_count(); ++ for (unsigned int module_sequence = 0; ++ module_sequence < module_count; ++ ++module_sequence) { ++ const CodeModule* module = modules->GetModuleAtSequence(module_sequence); ++ uint64_t base_address = module->base_address(); ++ printf("UnloadedModule%c%s%c0x%08" PRIx64 "%c0x%08" PRIx64 "%c%d\n", ++ kOutputSeparator, ++ StripSeparator(PathnameStripper::File(module->code_file())).c_str(), ++ kOutputSeparator, base_address, ++ kOutputSeparator, base_address + module->size() - 1, ++ kOutputSeparator, ++ main_module != NULL && base_address == main_address ? 1 : 0); ++ } ++} ++ + } // namespace + + void PrintProcessState(const ProcessState& process_state, + bool output_stack_contents, + SourceLineResolverInterface* resolver) { + // Print OS and CPU information. + string cpu = process_state.system_info()->cpu; + string cpu_info = process_state.system_info()->cpu_info; +@@ -921,16 +951,17 @@ void PrintProcessStateMachineReadable(co + + if (requesting_thread != -1) { + printf("%d\n", requesting_thread); + } else { + printf("\n"); + } + + PrintModulesMachineReadable(process_state.modules()); ++ PrintUnloadedModulesMachineReadable(process_state.unloaded_modules()); + + // blank line to indicate start of threads + printf("\n"); + + // If the thread that requested the dump is known, print it first. + if (requesting_thread != -1) { + PrintStackMachineReadable(requesting_thread, + process_state.threads()->at(requesting_thread)); + diff --git a/toolkit/crashreporter/breakpad-patches/18-fastfail-codes.patch b/toolkit/crashreporter/breakpad-patches/18-fastfail-codes.patch new file mode 100644 index 0000000000..543f320c46 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/18-fastfail-codes.patch @@ -0,0 +1,359 @@ +changeset: 651272:ff2582aceafe +parent: 651260:b740f950e497 +user: Gabriele Svelto <gsvelto@mozilla.com> +date: Thu Apr 08 12:01:43 2021 +0200 +summary: fastfail + +diff --git a/src/google_breakpad/common/minidump_exception_win32.h b/src/google_breakpad/common/minidump_exception_win32.h +--- a/src/google_breakpad/common/minidump_exception_win32.h ++++ b/src/google_breakpad/common/minidump_exception_win32.h +@@ -2261,9 +2261,84 @@ typedef enum { + // These constants are defined in the MSDN documentation of + // the EXCEPTION_RECORD structure. + typedef enum { + MD_IN_PAGE_ERROR_WIN_READ = 0, + MD_IN_PAGE_ERROR_WIN_WRITE = 1, + MD_IN_PAGE_ERROR_WIN_EXEC = 8 + } MDInPageErrorTypeWin; + ++/* For (MDException).exception_information[0], when (MDException).exception_code ++ * is MD_EXCEPTION_CODE_WIN_STACK_BUFFER_OVERRUN. This describes the underlying ++ * reason for the crash. These values come from winnt.h. ++ * ++ * The content of this enum was created from winnt.h in the 10 SDK ++ * (version 10.0.19041.0) with ++ * ++ * egrep '#define FAST_FAIL_[A-Z_0-9]+\s+[0-9]' winnt.h ++ * | tr -d '\r' ++ * | sed -r 's@#define FAST_FAIL_([A-Z_0-9]+)\s+([0-9]+).*@\2 \1@' ++ * | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ MD_FAST_FAIL_WIN_\2 = \1,@' */ ++typedef enum { ++ MD_FAST_FAIL_WIN_LEGACY_GS_VIOLATION = 0, ++ MD_FAST_FAIL_WIN_VTGUARD_CHECK_FAILURE = 1, ++ MD_FAST_FAIL_WIN_STACK_COOKIE_CHECK_FAILURE = 2, ++ MD_FAST_FAIL_WIN_CORRUPT_LIST_ENTRY = 3, ++ MD_FAST_FAIL_WIN_INCORRECT_STACK = 4, ++ MD_FAST_FAIL_WIN_INVALID_ARG = 5, ++ MD_FAST_FAIL_WIN_GS_COOKIE_INIT = 6, ++ MD_FAST_FAIL_WIN_FATAL_APP_EXIT = 7, ++ MD_FAST_FAIL_WIN_RANGE_CHECK_FAILURE = 8, ++ MD_FAST_FAIL_WIN_UNSAFE_REGISTRY_ACCESS = 9, ++ MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_FAILURE = 10, ++ MD_FAST_FAIL_WIN_GUARD_WRITE_CHECK_FAILURE = 11, ++ MD_FAST_FAIL_WIN_INVALID_FIBER_SWITCH = 12, ++ MD_FAST_FAIL_WIN_INVALID_SET_OF_CONTEXT = 13, ++ MD_FAST_FAIL_WIN_INVALID_REFERENCE_COUNT = 14, ++ MD_FAST_FAIL_WIN_INVALID_JUMP_BUFFER = 18, ++ MD_FAST_FAIL_WIN_MRDATA_MODIFIED = 19, ++ MD_FAST_FAIL_WIN_CERTIFICATION_FAILURE = 20, ++ MD_FAST_FAIL_WIN_INVALID_EXCEPTION_CHAIN = 21, ++ MD_FAST_FAIL_WIN_CRYPTO_LIBRARY = 22, ++ MD_FAST_FAIL_WIN_INVALID_CALL_IN_DLL_CALLOUT = 23, ++ MD_FAST_FAIL_WIN_INVALID_IMAGE_BASE = 24, ++ MD_FAST_FAIL_WIN_DLOAD_PROTECTION_FAILURE = 25, ++ MD_FAST_FAIL_WIN_UNSAFE_EXTENSION_CALL = 26, ++ MD_FAST_FAIL_WIN_DEPRECATED_SERVICE_INVOKED = 27, ++ MD_FAST_FAIL_WIN_INVALID_BUFFER_ACCESS = 28, ++ MD_FAST_FAIL_WIN_INVALID_BALANCED_TREE = 29, ++ MD_FAST_FAIL_WIN_INVALID_NEXT_THREAD = 30, ++ MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_SUPPRESSED = 31, ++ MD_FAST_FAIL_WIN_APCS_DISABLED = 32, ++ MD_FAST_FAIL_WIN_INVALID_IDLE_STATE = 33, ++ MD_FAST_FAIL_WIN_MRDATA_PROTECTION_FAILURE = 34, ++ MD_FAST_FAIL_WIN_UNEXPECTED_HEAP_EXCEPTION = 35, ++ MD_FAST_FAIL_WIN_INVALID_LOCK_STATE = 36, ++ MD_FAST_FAIL_WIN_GUARD_JUMPTABLE = 37, ++ MD_FAST_FAIL_WIN_INVALID_LONGJUMP_TARGET = 38, ++ MD_FAST_FAIL_WIN_INVALID_DISPATCH_CONTEXT = 39, ++ MD_FAST_FAIL_WIN_INVALID_THREAD = 40, ++ MD_FAST_FAIL_WIN_INVALID_SYSCALL_NUMBER = 41, ++ MD_FAST_FAIL_WIN_INVALID_FILE_OPERATION = 42, ++ MD_FAST_FAIL_WIN_LPAC_ACCESS_DENIED = 43, ++ MD_FAST_FAIL_WIN_GUARD_SS_FAILURE = 44, ++ MD_FAST_FAIL_WIN_LOADER_CONTINUITY_FAILURE = 45, ++ MD_FAST_FAIL_WIN_GUARD_EXPORT_SUPPRESSION_FAILURE = 46, ++ MD_FAST_FAIL_WIN_INVALID_CONTROL_STACK = 47, ++ MD_FAST_FAIL_WIN_SET_CONTEXT_DENIED = 48, ++ MD_FAST_FAIL_WIN_INVALID_IAT = 49, ++ MD_FAST_FAIL_WIN_HEAP_METADATA_CORRUPTION = 50, ++ MD_FAST_FAIL_WIN_PAYLOAD_RESTRICTION_VIOLATION = 51, ++ MD_FAST_FAIL_WIN_LOW_LABEL_ACCESS_DENIED = 52, ++ MD_FAST_FAIL_WIN_ENCLAVE_CALL_FAILURE = 53, ++ MD_FAST_FAIL_WIN_UNHANDLED_LSS_EXCEPTON = 54, ++ MD_FAST_FAIL_WIN_ADMINLESS_ACCESS_DENIED = 55, ++ MD_FAST_FAIL_WIN_UNEXPECTED_CALL = 56, ++ MD_FAST_FAIL_WIN_CONTROL_INVALID_RETURN_ADDRESS = 57, ++ MD_FAST_FAIL_WIN_UNEXPECTED_HOST_BEHAVIOR = 58, ++ MD_FAST_FAIL_WIN_FLAGS_CORRUPTION = 59, ++ MD_FAST_FAIL_WIN_VEH_CORRUPTION = 60, ++ MD_FAST_FAIL_WIN_ETW_CORRUPTION = 61, ++ MD_FAST_FAIL_WIN_RIO_ABORT = 62, ++ MD_FAST_FAIL_WIN_INVALID_PFN = 63, ++} MDFastFailWin; ++ + #endif /* GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_WIN32_H__ */ +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1288,16 +1288,24 @@ string MinidumpProcessor::GetCrashReason + case MD_EXCEPTION_CODE_WIN_BAD_FUNCTION_TABLE: + reason = "EXCEPTION_BAD_FUNCTION_TABLE"; + break; + case MD_EXCEPTION_CODE_WIN_POSSIBLE_DEADLOCK: + reason = "EXCEPTION_POSSIBLE_DEADLOCK"; + break; + case MD_EXCEPTION_CODE_WIN_STACK_BUFFER_OVERRUN: + reason = "EXCEPTION_STACK_BUFFER_OVERRUN"; ++ if (raw_exception->exception_record.number_parameters > 0) { ++ uint32_t fast_fail_code = ++ static_cast<uint32_t> ++ (raw_exception->exception_record.exception_information[0]); ++ reason.append(" / "); ++ reason.append(FastFailToString(fast_fail_code)); ++ } ++ + break; + case MD_EXCEPTION_CODE_WIN_HEAP_CORRUPTION: + reason = "EXCEPTION_HEAP_CORRUPTION"; + break; + case MD_EXCEPTION_OUT_OF_MEMORY: + reason = "Out of Memory"; + break; + case MD_EXCEPTION_CODE_WIN_UNHANDLED_CPP_EXCEPTION: +diff --git a/src/processor/symbolic_constants_win.cc b/src/processor/symbolic_constants_win.cc +--- a/src/processor/symbolic_constants_win.cc ++++ b/src/processor/symbolic_constants_win.cc +@@ -6409,9 +6409,214 @@ string NTStatusToString(uint32_t ntstatu + snprintf(reason_string, sizeof(reason_string), "0x%08x", ntstatus); + reason = reason_string; + break; + } + } + return reason; + } + ++string FastFailToString(uint32_t fast_fail_code) { ++ string code_string; ++ // The content of this switch was created from winnt.h in the 10 SDK ++ // (version 10.0.19041.0) with ++ // ++ // egrep '#define FAST_FAIL_[A-Z_0-9]+\s+[0-9]' winnt.h ++ // | tr -d '\r' ++ // | sed -r 's@#define FAST_FAIL_([A-Z_0-9]+)\s+([0-9]+).*@\2 \1@' ++ // | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ case MD_FAST_FAIL_WIN_\2:\n code_string = "FAST_FAIL_\2";\n break;@' ++ // ++ // and then the default case added. ++ switch (fast_fail_code) { ++ case MD_FAST_FAIL_WIN_LEGACY_GS_VIOLATION: ++ code_string = "FAST_FAIL_LEGACY_GS_VIOLATION"; ++ break; ++ case MD_FAST_FAIL_WIN_VTGUARD_CHECK_FAILURE: ++ code_string = "FAST_FAIL_VTGUARD_CHECK_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_STACK_COOKIE_CHECK_FAILURE: ++ code_string = "FAST_FAIL_STACK_COOKIE_CHECK_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_CORRUPT_LIST_ENTRY: ++ code_string = "FAST_FAIL_CORRUPT_LIST_ENTRY"; ++ break; ++ case MD_FAST_FAIL_WIN_INCORRECT_STACK: ++ code_string = "FAST_FAIL_INCORRECT_STACK"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_ARG: ++ code_string = "FAST_FAIL_INVALID_ARG"; ++ break; ++ case MD_FAST_FAIL_WIN_GS_COOKIE_INIT: ++ code_string = "FAST_FAIL_GS_COOKIE_INIT"; ++ break; ++ case MD_FAST_FAIL_WIN_FATAL_APP_EXIT: ++ code_string = "FAST_FAIL_FATAL_APP_EXIT"; ++ break; ++ case MD_FAST_FAIL_WIN_RANGE_CHECK_FAILURE: ++ code_string = "FAST_FAIL_RANGE_CHECK_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_UNSAFE_REGISTRY_ACCESS: ++ code_string = "FAST_FAIL_UNSAFE_REGISTRY_ACCESS"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_FAILURE: ++ code_string = "FAST_FAIL_GUARD_ICALL_CHECK_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_WRITE_CHECK_FAILURE: ++ code_string = "FAST_FAIL_GUARD_WRITE_CHECK_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_FIBER_SWITCH: ++ code_string = "FAST_FAIL_INVALID_FIBER_SWITCH"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_SET_OF_CONTEXT: ++ code_string = "FAST_FAIL_INVALID_SET_OF_CONTEXT"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_REFERENCE_COUNT: ++ code_string = "FAST_FAIL_INVALID_REFERENCE_COUNT"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_JUMP_BUFFER: ++ code_string = "FAST_FAIL_INVALID_JUMP_BUFFER"; ++ break; ++ case MD_FAST_FAIL_WIN_MRDATA_MODIFIED: ++ code_string = "FAST_FAIL_MRDATA_MODIFIED"; ++ break; ++ case MD_FAST_FAIL_WIN_CERTIFICATION_FAILURE: ++ code_string = "FAST_FAIL_CERTIFICATION_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_EXCEPTION_CHAIN: ++ code_string = "FAST_FAIL_INVALID_EXCEPTION_CHAIN"; ++ break; ++ case MD_FAST_FAIL_WIN_CRYPTO_LIBRARY: ++ code_string = "FAST_FAIL_CRYPTO_LIBRARY"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_CALL_IN_DLL_CALLOUT: ++ code_string = "FAST_FAIL_INVALID_CALL_IN_DLL_CALLOUT"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_IMAGE_BASE: ++ code_string = "FAST_FAIL_INVALID_IMAGE_BASE"; ++ break; ++ case MD_FAST_FAIL_WIN_DLOAD_PROTECTION_FAILURE: ++ code_string = "FAST_FAIL_DLOAD_PROTECTION_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_UNSAFE_EXTENSION_CALL: ++ code_string = "FAST_FAIL_UNSAFE_EXTENSION_CALL"; ++ break; ++ case MD_FAST_FAIL_WIN_DEPRECATED_SERVICE_INVOKED: ++ code_string = "FAST_FAIL_DEPRECATED_SERVICE_INVOKED"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_BUFFER_ACCESS: ++ code_string = "FAST_FAIL_INVALID_BUFFER_ACCESS"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_BALANCED_TREE: ++ code_string = "FAST_FAIL_INVALID_BALANCED_TREE"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_NEXT_THREAD: ++ code_string = "FAST_FAIL_INVALID_NEXT_THREAD"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_SUPPRESSED: ++ code_string = "FAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSED"; ++ break; ++ case MD_FAST_FAIL_WIN_APCS_DISABLED: ++ code_string = "FAST_FAIL_APCS_DISABLED"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_IDLE_STATE: ++ code_string = "FAST_FAIL_INVALID_IDLE_STATE"; ++ break; ++ case MD_FAST_FAIL_WIN_MRDATA_PROTECTION_FAILURE: ++ code_string = "FAST_FAIL_MRDATA_PROTECTION_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_UNEXPECTED_HEAP_EXCEPTION: ++ code_string = "FAST_FAIL_UNEXPECTED_HEAP_EXCEPTION"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_LOCK_STATE: ++ code_string = "FAST_FAIL_INVALID_LOCK_STATE"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_JUMPTABLE: ++ code_string = "FAST_FAIL_GUARD_JUMPTABLE"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_LONGJUMP_TARGET: ++ code_string = "FAST_FAIL_INVALID_LONGJUMP_TARGET"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_DISPATCH_CONTEXT: ++ code_string = "FAST_FAIL_INVALID_DISPATCH_CONTEXT"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_THREAD: ++ code_string = "FAST_FAIL_INVALID_THREAD"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_SYSCALL_NUMBER: ++ code_string = "FAST_FAIL_INVALID_SYSCALL_NUMBER"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_FILE_OPERATION: ++ code_string = "FAST_FAIL_INVALID_FILE_OPERATION"; ++ break; ++ case MD_FAST_FAIL_WIN_LPAC_ACCESS_DENIED: ++ code_string = "FAST_FAIL_LPAC_ACCESS_DENIED"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_SS_FAILURE: ++ code_string = "FAST_FAIL_GUARD_SS_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_LOADER_CONTINUITY_FAILURE: ++ code_string = "FAST_FAIL_LOADER_CONTINUITY_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_GUARD_EXPORT_SUPPRESSION_FAILURE: ++ code_string = "FAST_FAIL_GUARD_EXPORT_SUPPRESSION_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_CONTROL_STACK: ++ code_string = "FAST_FAIL_INVALID_CONTROL_STACK"; ++ break; ++ case MD_FAST_FAIL_WIN_SET_CONTEXT_DENIED: ++ code_string = "FAST_FAIL_SET_CONTEXT_DENIED"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_IAT: ++ code_string = "FAST_FAIL_INVALID_IAT"; ++ break; ++ case MD_FAST_FAIL_WIN_HEAP_METADATA_CORRUPTION: ++ code_string = "FAST_FAIL_HEAP_METADATA_CORRUPTION"; ++ break; ++ case MD_FAST_FAIL_WIN_PAYLOAD_RESTRICTION_VIOLATION: ++ code_string = "FAST_FAIL_PAYLOAD_RESTRICTION_VIOLATION"; ++ break; ++ case MD_FAST_FAIL_WIN_LOW_LABEL_ACCESS_DENIED: ++ code_string = "FAST_FAIL_LOW_LABEL_ACCESS_DENIED"; ++ break; ++ case MD_FAST_FAIL_WIN_ENCLAVE_CALL_FAILURE: ++ code_string = "FAST_FAIL_ENCLAVE_CALL_FAILURE"; ++ break; ++ case MD_FAST_FAIL_WIN_UNHANDLED_LSS_EXCEPTON: ++ code_string = "FAST_FAIL_UNHANDLED_LSS_EXCEPTON"; ++ break; ++ case MD_FAST_FAIL_WIN_ADMINLESS_ACCESS_DENIED: ++ code_string = "FAST_FAIL_ADMINLESS_ACCESS_DENIED"; ++ break; ++ case MD_FAST_FAIL_WIN_UNEXPECTED_CALL: ++ code_string = "FAST_FAIL_UNEXPECTED_CALL"; ++ break; ++ case MD_FAST_FAIL_WIN_CONTROL_INVALID_RETURN_ADDRESS: ++ code_string = "FAST_FAIL_CONTROL_INVALID_RETURN_ADDRESS"; ++ break; ++ case MD_FAST_FAIL_WIN_UNEXPECTED_HOST_BEHAVIOR: ++ code_string = "FAST_FAIL_UNEXPECTED_HOST_BEHAVIOR"; ++ break; ++ case MD_FAST_FAIL_WIN_FLAGS_CORRUPTION: ++ code_string = "FAST_FAIL_FLAGS_CORRUPTION"; ++ break; ++ case MD_FAST_FAIL_WIN_VEH_CORRUPTION: ++ code_string = "FAST_FAIL_VEH_CORRUPTION"; ++ break; ++ case MD_FAST_FAIL_WIN_ETW_CORRUPTION: ++ code_string = "FAST_FAIL_ETW_CORRUPTION"; ++ break; ++ case MD_FAST_FAIL_WIN_RIO_ABORT: ++ code_string = "FAST_FAIL_RIO_ABORT"; ++ break; ++ case MD_FAST_FAIL_WIN_INVALID_PFN: ++ code_string = "FAST_FAIL_INVALID_PFN"; ++ break; ++ default: { ++ char buffer[11]; ++ snprintf(buffer, sizeof(buffer), "%u", fast_fail_code); ++ code_string = buffer; ++ break; ++ } ++ } ++ return code_string; ++} ++ + } // namespace google_breakpad +diff --git a/src/processor/symbolic_constants_win.h b/src/processor/symbolic_constants_win.h +--- a/src/processor/symbolic_constants_win.h ++++ b/src/processor/symbolic_constants_win.h +@@ -41,11 +41,14 @@ + #include "common/using_std_string.h" + #include "google_breakpad/common/breakpad_types.h" + + namespace google_breakpad { + + /* Converts a NTSTATUS code to a reason string. */ + string NTStatusToString(uint32_t ntstatus); + ++/* Converts a FAST_FAIL code to a reason string. */ ++string FastFailToString(uint32_t fast_fail_code); ++ + } // namespace google_breakpad + + #endif // GOOGLE_BREAKPAD_PROCESSOR_SYMBOLIC_CONSTANTS_WIN_H_ + diff --git a/toolkit/crashreporter/breakpad-patches/19-updated-ntstatus.patch b/toolkit/crashreporter/breakpad-patches/19-updated-ntstatus.patch new file mode 100644 index 0000000000..13c6597435 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/19-updated-ntstatus.patch @@ -0,0 +1,3500 @@ +changeset: 651287:a6a1b6cc572e +tag: tip +parent: 651282:232ec0fbbaaa +user: Gabriele Svelto <gsvelto@mozilla.com> +date: Thu Apr 08 11:13:10 2021 +0200 +summary: Updated ntstatus.h definitions in Breakpad + +diff --git a/src/google_breakpad/common/minidump_exception_win32.h b/src/google_breakpad/common/minidump_exception_win32.h +--- a/src/google_breakpad/common/minidump_exception_win32.h ++++ b/src/google_breakpad/common/minidump_exception_win32.h +@@ -39,22 +39,18 @@ + #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_WIN32_H__ + #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_WIN32_H__ + + #include <stddef.h> + + #include "google_breakpad/common/breakpad_types.h" + + +-/* For (MDException).exception_code. These values come from WinBase.h +- * and WinNT.h (names beginning with EXCEPTION_ are in WinBase.h, +- * they are STATUS_ in WinNT.h). */ ++/* For (MDException).exception_code. These values come from WinBase.h */ + typedef enum { +- MD_EXCEPTION_CODE_WIN_CONTROL_C = 0x40010005, +- /* DBG_CONTROL_C */ + MD_EXCEPTION_CODE_WIN_GUARD_PAGE_VIOLATION = 0x80000001, + /* EXCEPTION_GUARD_PAGE */ + MD_EXCEPTION_CODE_WIN_DATATYPE_MISALIGNMENT = 0x80000002, + /* EXCEPTION_DATATYPE_MISALIGNMENT */ + MD_EXCEPTION_CODE_WIN_BREAKPOINT = 0x80000003, + /* EXCEPTION_BREAKPOINT */ + MD_EXCEPTION_CODE_WIN_SINGLE_STEP = 0x80000004, + /* EXCEPTION_SINGLE_STEP */ +@@ -93,51 +89,291 @@ typedef enum { + MD_EXCEPTION_CODE_WIN_PRIVILEGED_INSTRUCTION = 0xc0000096, + /* EXCEPTION_PRIV_INSTRUCTION */ + MD_EXCEPTION_CODE_WIN_STACK_OVERFLOW = 0xc00000fd, + /* EXCEPTION_STACK_OVERFLOW */ + MD_EXCEPTION_CODE_WIN_BAD_FUNCTION_TABLE = 0xc00000ff, + /* EXCEPTION_BAD_FUNCTION_TABLE */ + MD_EXCEPTION_CODE_WIN_POSSIBLE_DEADLOCK = 0xc0000194, + /* EXCEPTION_POSSIBLE_DEADLOCK */ +- MD_EXCEPTION_CODE_WIN_STACK_BUFFER_OVERRUN = 0xc0000409, +- /* STATUS_STACK_BUFFER_OVERRUN */ +- MD_EXCEPTION_CODE_WIN_HEAP_CORRUPTION = 0xc0000374, +- /* STATUS_HEAP_CORRUPTION */ + MD_EXCEPTION_OUT_OF_MEMORY = 0xe0000008, + /* Exception thrown by Chromium allocators to indicate OOM. + See base/process/memory.h in Chromium for rationale. */ + MD_EXCEPTION_CODE_WIN_UNHANDLED_CPP_EXCEPTION = 0xe06d7363, + /* Per http://support.microsoft.com/kb/185294, + generated by Visual C++ compiler */ + MD_EXCEPTION_CODE_WIN_SIMULATED = 0x0517a7ed + /* Fake exception code used by Crashpad's + CrashpadClient::DumpWithoutCrash. */ + } MDExceptionCodeWin; + + + /* For (MDException).exception_information[2], when (MDException).exception_code + * is MD_EXCEPTION_CODE_WIN_IN_PAGE_ERROR. This describes the underlying reason + * for the error. These values come from ntstatus.h. + * +- * The content of this enum was created from ntstatus.h in the 8.1 SDK with ++ * The content of this enum was created from ntstatus.h in the 10 SDK ++ * (version 10.0.19041.0) with + * +- * egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0xC[0-9A-F]+L\)' ntstatus.h ++ * egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0x[048C][0-9A-F]+L\)' ntstatus.h + * | tr -d '\r' +- * | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0xC[0-9A-F]+)L\).*@\2 \1@' ++ * | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0x[048C][0-9A-F]+)L\).*@\2 \1@' + * | sort +- * | sed -r 's@(0xC[0-9A-F]+) ([A-Z_0-9]+)@ MD_NTSTATUS_WIN_\2 = \1,@' ++ * | sed -r 's@(0x[048C][0-9A-F]+) ([A-Z_0-9]+)@ MD_NTSTATUS_WIN_\2 = \1,@' + * + * With easy copy to clipboard with + * | xclip -selection c # on linux + * | clip # on windows +- * | pbcopy # on mac +- * +- * and then the last comma manually removed. */ ++ * | pbcopy # on mac */ + typedef enum { ++ MD_NTSTATUS_WIN_STATUS_SUCCESS = 0x00000000, ++ MD_NTSTATUS_WIN_STATUS_WAIT_0 = 0x00000000, ++ MD_NTSTATUS_WIN_STATUS_WAIT_1 = 0x00000001, ++ MD_NTSTATUS_WIN_STATUS_WAIT_2 = 0x00000002, ++ MD_NTSTATUS_WIN_STATUS_WAIT_3 = 0x00000003, ++ MD_NTSTATUS_WIN_STATUS_WAIT_63 = 0x0000003F, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED = 0x00000080, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_0 = 0x00000080, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_63 = 0x000000BF, ++ MD_NTSTATUS_WIN_STATUS_USER_APC = 0x000000C0, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_COMPLETE = 0x000000FF, ++ MD_NTSTATUS_WIN_STATUS_KERNEL_APC = 0x00000100, ++ MD_NTSTATUS_WIN_STATUS_ALERTED = 0x00000101, ++ MD_NTSTATUS_WIN_STATUS_TIMEOUT = 0x00000102, ++ MD_NTSTATUS_WIN_STATUS_PENDING = 0x00000103, ++ MD_NTSTATUS_WIN_STATUS_REPARSE = 0x00000104, ++ MD_NTSTATUS_WIN_STATUS_MORE_ENTRIES = 0x00000105, ++ MD_NTSTATUS_WIN_STATUS_NOT_ALL_ASSIGNED = 0x00000106, ++ MD_NTSTATUS_WIN_STATUS_SOME_NOT_MAPPED = 0x00000107, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_BREAK_IN_PROGRESS = 0x00000108, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_MOUNTED = 0x00000109, ++ MD_NTSTATUS_WIN_STATUS_RXACT_COMMITTED = 0x0000010A, ++ MD_NTSTATUS_WIN_STATUS_NOTIFY_CLEANUP = 0x0000010B, ++ MD_NTSTATUS_WIN_STATUS_NOTIFY_ENUM_DIR = 0x0000010C, ++ MD_NTSTATUS_WIN_STATUS_NO_QUOTAS_FOR_ACCOUNT = 0x0000010D, ++ MD_NTSTATUS_WIN_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED = 0x0000010E, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_TRANSITION = 0x00000110, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_DEMAND_ZERO = 0x00000111, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_COPY_ON_WRITE = 0x00000112, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_GUARD_PAGE = 0x00000113, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_PAGING_FILE = 0x00000114, ++ MD_NTSTATUS_WIN_STATUS_CACHE_PAGE_LOCKED = 0x00000115, ++ MD_NTSTATUS_WIN_STATUS_CRASH_DUMP = 0x00000116, ++ MD_NTSTATUS_WIN_STATUS_BUFFER_ALL_ZEROS = 0x00000117, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_OBJECT = 0x00000118, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_REQUIREMENTS_CHANGED = 0x00000119, ++ MD_NTSTATUS_WIN_STATUS_TRANSLATION_COMPLETE = 0x00000120, ++ MD_NTSTATUS_WIN_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY = 0x00000121, ++ MD_NTSTATUS_WIN_STATUS_NOTHING_TO_TERMINATE = 0x00000122, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_NOT_IN_JOB = 0x00000123, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_IN_JOB = 0x00000124, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_HIBERNATE_READY = 0x00000125, ++ MD_NTSTATUS_WIN_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY = 0x00000126, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED = 0x00000127, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPT_STILL_CONNECTED = 0x00000128, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_CLONED = 0x00000129, ++ MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_ONLY_READERS = 0x0000012A, ++ MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_WRITERS = 0x0000012B, ++ MD_NTSTATUS_WIN_STATUS_VALID_IMAGE_HASH = 0x0000012C, ++ MD_NTSTATUS_WIN_STATUS_VALID_CATALOG_HASH = 0x0000012D, ++ MD_NTSTATUS_WIN_STATUS_VALID_STRONG_CODE_HASH = 0x0000012E, ++ MD_NTSTATUS_WIN_STATUS_GHOSTED = 0x0000012F, ++ MD_NTSTATUS_WIN_STATUS_DATA_OVERWRITTEN = 0x00000130, ++ MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_READ_ONLY = 0x00000202, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_EMPTY = 0x00000210, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_FULL = 0x00000211, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_ABOVE_QUOTA = 0x00000212, ++ MD_NTSTATUS_WIN_STATUS_RING_NEWLY_EMPTY = 0x00000213, ++ MD_NTSTATUS_WIN_STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT = 0x00000214, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE = 0x00000215, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_HANDLE_CLOSED = 0x00000216, ++ MD_NTSTATUS_WIN_STATUS_WAIT_FOR_OPLOCK = 0x00000367, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_GLOBAL = 0x00000368, ++ MD_NTSTATUS_WIN_DBG_EXCEPTION_HANDLED = 0x00010001, ++ MD_NTSTATUS_WIN_DBG_CONTINUE = 0x00010002, ++ MD_NTSTATUS_WIN_STATUS_FLT_IO_COMPLETE = 0x001C0001, ++ MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_CONTINUE = 0x00293000, ++ MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_COMPLETE = 0x00293001, ++ MD_NTSTATUS_WIN_STATUS_HV_PENDING_PAGE_REQUESTS = 0x00350059, ++ MD_NTSTATUS_WIN_STATUS_SPACES_REPAIRED = 0x00E70000, ++ MD_NTSTATUS_WIN_STATUS_SPACES_PAUSE = 0x00E70001, ++ MD_NTSTATUS_WIN_STATUS_SPACES_COMPLETE = 0x00E70002, ++ MD_NTSTATUS_WIN_STATUS_SPACES_REDIRECT = 0x00E70003, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_EXISTS = 0x40000000, ++ MD_NTSTATUS_WIN_STATUS_THREAD_WAS_SUSPENDED = 0x40000001, ++ MD_NTSTATUS_WIN_STATUS_WORKING_SET_LIMIT_RANGE = 0x40000002, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_NOT_AT_BASE = 0x40000003, ++ MD_NTSTATUS_WIN_STATUS_RXACT_STATE_CREATED = 0x40000004, ++ MD_NTSTATUS_WIN_STATUS_SEGMENT_NOTIFICATION = 0x40000005, ++ MD_NTSTATUS_WIN_STATUS_LOCAL_USER_SESSION_KEY = 0x40000006, ++ MD_NTSTATUS_WIN_STATUS_BAD_CURRENT_DIRECTORY = 0x40000007, ++ MD_NTSTATUS_WIN_STATUS_SERIAL_MORE_WRITES = 0x40000008, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_RECOVERED = 0x40000009, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_RECOVERY_FROM_BACKUP = 0x4000000A, ++ MD_NTSTATUS_WIN_STATUS_FT_WRITE_RECOVERY = 0x4000000B, ++ MD_NTSTATUS_WIN_STATUS_SERIAL_COUNTER_TIMEOUT = 0x4000000C, ++ MD_NTSTATUS_WIN_STATUS_NULL_LM_PASSWORD = 0x4000000D, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH = 0x4000000E, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL = 0x4000000F, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_EXPEDITED = 0x40000010, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL_EXPEDITED = 0x40000011, ++ MD_NTSTATUS_WIN_STATUS_EVENT_DONE = 0x40000012, ++ MD_NTSTATUS_WIN_STATUS_EVENT_PENDING = 0x40000013, ++ MD_NTSTATUS_WIN_STATUS_CHECKING_FILE_SYSTEM = 0x40000014, ++ MD_NTSTATUS_WIN_STATUS_FATAL_APP_EXIT = 0x40000015, ++ MD_NTSTATUS_WIN_STATUS_PREDEFINED_HANDLE = 0x40000016, ++ MD_NTSTATUS_WIN_STATUS_WAS_UNLOCKED = 0x40000017, ++ MD_NTSTATUS_WIN_STATUS_SERVICE_NOTIFICATION = 0x40000018, ++ MD_NTSTATUS_WIN_STATUS_WAS_LOCKED = 0x40000019, ++ MD_NTSTATUS_WIN_STATUS_LOG_HARD_ERROR = 0x4000001A, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_WIN32 = 0x4000001B, ++ MD_NTSTATUS_WIN_STATUS_WX86_UNSIMULATE = 0x4000001C, ++ MD_NTSTATUS_WIN_STATUS_WX86_CONTINUE = 0x4000001D, ++ MD_NTSTATUS_WIN_STATUS_WX86_SINGLE_STEP = 0x4000001E, ++ MD_NTSTATUS_WIN_STATUS_WX86_BREAKPOINT = 0x4000001F, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CONTINUE = 0x40000020, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_LASTCHANCE = 0x40000021, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CHAIN = 0x40000022, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE = 0x40000023, ++ MD_NTSTATUS_WIN_STATUS_NO_YIELD_PERFORMED = 0x40000024, ++ MD_NTSTATUS_WIN_STATUS_TIMER_RESUME_IGNORED = 0x40000025, ++ MD_NTSTATUS_WIN_STATUS_ARBITRATION_UNHANDLED = 0x40000026, ++ MD_NTSTATUS_WIN_STATUS_CARDBUS_NOT_SUPPORTED = 0x40000027, ++ MD_NTSTATUS_WIN_STATUS_WX86_CREATEWX86TIB = 0x40000028, ++ MD_NTSTATUS_WIN_STATUS_MP_PROCESSOR_MISMATCH = 0x40000029, ++ MD_NTSTATUS_WIN_STATUS_HIBERNATED = 0x4000002A, ++ MD_NTSTATUS_WIN_STATUS_RESUME_HIBERNATION = 0x4000002B, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_UPDATED = 0x4000002C, ++ MD_NTSTATUS_WIN_STATUS_DRIVERS_LEAKING_LOCKED_PAGES = 0x4000002D, ++ MD_NTSTATUS_WIN_STATUS_MESSAGE_RETRIEVED = 0x4000002E, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_TRANSITION = 0x4000002F, ++ MD_NTSTATUS_WIN_STATUS_ALPC_CHECK_COMPLETION_LIST = 0x40000030, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION = 0x40000031, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_AUDIT_BY_POLICY = 0x40000032, ++ MD_NTSTATUS_WIN_STATUS_ABANDON_HIBERFILE = 0x40000033, ++ MD_NTSTATUS_WIN_STATUS_BIZRULES_NOT_ENABLED = 0x40000034, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_FROM_COPY = 0x40000035, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_AT_DIFFERENT_BASE = 0x40000036, ++ MD_NTSTATUS_WIN_STATUS_PATCH_DEFERRED = 0x40000037, ++ MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM = 0x40000294, ++ MD_NTSTATUS_WIN_STATUS_DS_SHUTTING_DOWN = 0x40000370, ++ MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_REDIRECTED = 0x40000807, ++ MD_NTSTATUS_WIN_STATUS_SERVICES_FAILED_AUTOSTART = 0x4000A144, ++ MD_NTSTATUS_WIN_DBG_REPLY_LATER = 0x40010001, ++ MD_NTSTATUS_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE = 0x40010002, ++ MD_NTSTATUS_WIN_DBG_TERMINATE_THREAD = 0x40010003, ++ MD_NTSTATUS_WIN_DBG_TERMINATE_PROCESS = 0x40010004, ++ MD_NTSTATUS_WIN_DBG_CONTROL_C = 0x40010005, ++ MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_C = 0x40010006, ++ MD_NTSTATUS_WIN_DBG_RIPEXCEPTION = 0x40010007, ++ MD_NTSTATUS_WIN_DBG_CONTROL_BREAK = 0x40010008, ++ MD_NTSTATUS_WIN_DBG_COMMAND_EXCEPTION = 0x40010009, ++ MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_WIDE_C = 0x4001000A, ++ MD_NTSTATUS_WIN_RPC_NT_UUID_LOCAL_ONLY = 0x40020056, ++ MD_NTSTATUS_WIN_RPC_NT_SEND_INCOMPLETE = 0x400200AF, ++ MD_NTSTATUS_WIN_STATUS_CTX_CDM_CONNECT = 0x400A0004, ++ MD_NTSTATUS_WIN_STATUS_CTX_CDM_DISCONNECT = 0x400A0005, ++ MD_NTSTATUS_WIN_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT = 0x4015000D, ++ MD_NTSTATUS_WIN_STATUS_HEURISTIC_DAMAGE_POSSIBLE = 0x40190001, ++ MD_NTSTATUS_WIN_STATUS_RECOVERY_NOT_NEEDED = 0x40190034, ++ MD_NTSTATUS_WIN_STATUS_RM_ALREADY_STARTED = 0x40190035, ++ MD_NTSTATUS_WIN_STATUS_LOG_NO_RESTART = 0x401A000C, ++ MD_NTSTATUS_WIN_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST = 0x401B00EC, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED = 0x401E000A, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION = 0x401E0201, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_PINNED = 0x401E0307, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_PREFERRED_MODE = 0x401E031E, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DATASET_IS_EMPTY = 0x401E034B, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET = 0x401E034C, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED = 0x401E0351, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS = 0x401E042F, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_START_DEFERRED = 0x401E0437, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY = 0x401E0439, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_START_DEFERRED = 0x401E043A, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS = 0x401E043C, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INDICATION_REQUIRED = 0x40230001, ++ MD_NTSTATUS_WIN_STATUS_PCP_UNSUPPORTED_PSS_SALT = 0x40292023, ++ MD_NTSTATUS_WIN_STATUS_GUARD_PAGE_VIOLATION = 0x80000001, ++ MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT = 0x80000002, ++ MD_NTSTATUS_WIN_STATUS_BREAKPOINT = 0x80000003, ++ MD_NTSTATUS_WIN_STATUS_SINGLE_STEP = 0x80000004, ++ MD_NTSTATUS_WIN_STATUS_BUFFER_OVERFLOW = 0x80000005, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_FILES = 0x80000006, ++ MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM_DEBUGGER = 0x80000007, ++ MD_NTSTATUS_WIN_STATUS_HANDLES_CLOSED = 0x8000000A, ++ MD_NTSTATUS_WIN_STATUS_NO_INHERITANCE = 0x8000000B, ++ MD_NTSTATUS_WIN_STATUS_GUID_SUBSTITUTION_MADE = 0x8000000C, ++ MD_NTSTATUS_WIN_STATUS_PARTIAL_COPY = 0x8000000D, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_PAPER_EMPTY = 0x8000000E, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_POWERED_OFF = 0x8000000F, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_OFF_LINE = 0x80000010, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_BUSY = 0x80000011, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_EAS = 0x80000012, ++ MD_NTSTATUS_WIN_STATUS_INVALID_EA_NAME = 0x80000013, ++ MD_NTSTATUS_WIN_STATUS_EA_LIST_INCONSISTENT = 0x80000014, ++ MD_NTSTATUS_WIN_STATUS_INVALID_EA_FLAG = 0x80000015, ++ MD_NTSTATUS_WIN_STATUS_VERIFY_REQUIRED = 0x80000016, ++ MD_NTSTATUS_WIN_STATUS_EXTRANEOUS_INFORMATION = 0x80000017, ++ MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_NECESSARY = 0x80000018, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_ENTRIES = 0x8000001A, ++ MD_NTSTATUS_WIN_STATUS_FILEMARK_DETECTED = 0x8000001B, ++ MD_NTSTATUS_WIN_STATUS_MEDIA_CHANGED = 0x8000001C, ++ MD_NTSTATUS_WIN_STATUS_BUS_RESET = 0x8000001D, ++ MD_NTSTATUS_WIN_STATUS_END_OF_MEDIA = 0x8000001E, ++ MD_NTSTATUS_WIN_STATUS_BEGINNING_OF_MEDIA = 0x8000001F, ++ MD_NTSTATUS_WIN_STATUS_MEDIA_CHECK = 0x80000020, ++ MD_NTSTATUS_WIN_STATUS_SETMARK_DETECTED = 0x80000021, ++ MD_NTSTATUS_WIN_STATUS_NO_DATA_DETECTED = 0x80000022, ++ MD_NTSTATUS_WIN_STATUS_REDIRECTOR_HAS_OPEN_HANDLES = 0x80000023, ++ MD_NTSTATUS_WIN_STATUS_SERVER_HAS_OPEN_HANDLES = 0x80000024, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_DISCONNECTED = 0x80000025, ++ MD_NTSTATUS_WIN_STATUS_LONGJUMP = 0x80000026, ++ MD_NTSTATUS_WIN_STATUS_CLEANER_CARTRIDGE_INSTALLED = 0x80000027, ++ MD_NTSTATUS_WIN_STATUS_PLUGPLAY_QUERY_VETOED = 0x80000028, ++ MD_NTSTATUS_WIN_STATUS_UNWIND_CONSOLIDATE = 0x80000029, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_HIVE_RECOVERED = 0x8000002A, ++ MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INSECURE = 0x8000002B, ++ MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INCOMPATIBLE = 0x8000002C, ++ MD_NTSTATUS_WIN_STATUS_STOPPED_ON_SYMLINK = 0x8000002D, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK = 0x8000002E, ++ MD_NTSTATUS_WIN_STATUS_NO_ACE_CONDITION = 0x8000002F, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_SUPPORT_IN_PROGRESS = 0x80000030, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_CYCLE_REQUIRED = 0x80000031, ++ MD_NTSTATUS_WIN_STATUS_NO_WORK_DONE = 0x80000032, ++ MD_NTSTATUS_WIN_STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT = 0x80000033, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_REQUIRES_CLEANING = 0x80000288, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_DOOR_OPEN = 0x80000289, ++ MD_NTSTATUS_WIN_STATUS_DATA_LOST_REPAIR = 0x80000803, ++ MD_NTSTATUS_WIN_STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED = 0x8000A127, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH = 0x8000CF00, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE = 0x8000CF04, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS = 0x8000CF05, ++ MD_NTSTATUS_WIN_DBG_EXCEPTION_NOT_HANDLED = 0x80010001, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_UP = 0x80130001, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_DOWN = 0x80130002, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE = 0x80130003, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE = 0x80130004, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_MEMBER = 0x80130005, ++ MD_NTSTATUS_WIN_STATUS_COULD_NOT_RESIZE_LOG = 0x80190009, ++ MD_NTSTATUS_WIN_STATUS_NO_TXF_METADATA = 0x80190029, ++ MD_NTSTATUS_WIN_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN = 0x80190031, ++ MD_NTSTATUS_WIN_STATUS_TXF_METADATA_ALREADY_PRESENT = 0x80190041, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET = 0x80190042, ++ MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED = 0x801B00EB, ++ MD_NTSTATUS_WIN_STATUS_FLT_BUFFER_TOO_SMALL = 0x801C0001, ++ MD_NTSTATUS_WIN_STATUS_FVE_PARTIAL_METADATA = 0x80210001, ++ MD_NTSTATUS_WIN_STATUS_FVE_TRANSIENT_STATE = 0x80210002, ++ MD_NTSTATUS_WIN_STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED = 0x80370001, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_REGENERATION = 0x80380001, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION = 0x80380002, ++ MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED = 0x80390001, ++ MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED = 0x80390003, ++ MD_NTSTATUS_WIN_STATUS_QUERY_STORAGE_ERROR = 0x803A0001, ++ MD_NTSTATUS_WIN_STATUS_GDI_HANDLE_LEAK = 0x803F0001, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_ENABLED = 0x80430006, + MD_NTSTATUS_WIN_STATUS_UNSUCCESSFUL = 0xC0000001, + MD_NTSTATUS_WIN_STATUS_NOT_IMPLEMENTED = 0xC0000002, + MD_NTSTATUS_WIN_STATUS_INVALID_INFO_CLASS = 0xC0000003, + MD_NTSTATUS_WIN_STATUS_INFO_LENGTH_MISMATCH = 0xC0000004, + MD_NTSTATUS_WIN_STATUS_ACCESS_VIOLATION = 0xC0000005, + MD_NTSTATUS_WIN_STATUS_IN_PAGE_ERROR = 0xC0000006, + MD_NTSTATUS_WIN_STATUS_PAGEFILE_QUOTA = 0xC0000007, + MD_NTSTATUS_WIN_STATUS_INVALID_HANDLE = 0xC0000008, +@@ -181,16 +417,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_INVALID_PORT_ATTRIBUTES = 0xC000002E, + MD_NTSTATUS_WIN_STATUS_PORT_MESSAGE_TOO_LONG = 0xC000002F, + MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_MIX = 0xC0000030, + MD_NTSTATUS_WIN_STATUS_INVALID_QUOTA_LOWER = 0xC0000031, + MD_NTSTATUS_WIN_STATUS_DISK_CORRUPT_ERROR = 0xC0000032, + MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_INVALID = 0xC0000033, + MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_NOT_FOUND = 0xC0000034, + MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_COLLISION = 0xC0000035, ++ MD_NTSTATUS_WIN_STATUS_PORT_DO_NOT_DISTURB = 0xC0000036, + MD_NTSTATUS_WIN_STATUS_PORT_DISCONNECTED = 0xC0000037, + MD_NTSTATUS_WIN_STATUS_DEVICE_ALREADY_ATTACHED = 0xC0000038, + MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_INVALID = 0xC0000039, + MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_NOT_FOUND = 0xC000003A, + MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_SYNTAX_BAD = 0xC000003B, + MD_NTSTATUS_WIN_STATUS_DATA_OVERRUN = 0xC000003C, + MD_NTSTATUS_WIN_STATUS_DATA_LATE_ERROR = 0xC000003D, + MD_NTSTATUS_WIN_STATUS_DATA_ERROR = 0xC000003E, +@@ -549,16 +786,24 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT = 0xC00001A3, + MD_NTSTATUS_WIN_STATUS_NOTIFICATION_GUID_ALREADY_DEFINED = 0xC00001A4, + MD_NTSTATUS_WIN_STATUS_INVALID_EXCEPTION_HANDLER = 0xC00001A5, + MD_NTSTATUS_WIN_STATUS_DUPLICATE_PRIVILEGES = 0xC00001A6, + MD_NTSTATUS_WIN_STATUS_NOT_ALLOWED_ON_SYSTEM_FILE = 0xC00001A7, + MD_NTSTATUS_WIN_STATUS_REPAIR_NEEDED = 0xC00001A8, + MD_NTSTATUS_WIN_STATUS_QUOTA_NOT_ENABLED = 0xC00001A9, + MD_NTSTATUS_WIN_STATUS_NO_APPLICATION_PACKAGE = 0xC00001AA, ++ MD_NTSTATUS_WIN_STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS = 0xC00001AB, ++ MD_NTSTATUS_WIN_STATUS_NOT_SAME_OBJECT = 0xC00001AC, ++ MD_NTSTATUS_WIN_STATUS_FATAL_MEMORY_EXHAUSTION = 0xC00001AD, ++ MD_NTSTATUS_WIN_STATUS_ERROR_PROCESS_NOT_IN_JOB = 0xC00001AE, ++ MD_NTSTATUS_WIN_STATUS_CPU_SET_INVALID = 0xC00001AF, ++ MD_NTSTATUS_WIN_STATUS_IO_DEVICE_INVALID_DATA = 0xC00001B0, ++ MD_NTSTATUS_WIN_STATUS_IO_UNALIGNED_WRITE = 0xC00001B1, ++ MD_NTSTATUS_WIN_STATUS_CONTROL_STACK_VIOLATION = 0xC00001B2, + MD_NTSTATUS_WIN_STATUS_NETWORK_OPEN_RESTRICTION = 0xC0000201, + MD_NTSTATUS_WIN_STATUS_NO_USER_SESSION_KEY = 0xC0000202, + MD_NTSTATUS_WIN_STATUS_USER_SESSION_DELETED = 0xC0000203, + MD_NTSTATUS_WIN_STATUS_RESOURCE_LANG_NOT_FOUND = 0xC0000204, + MD_NTSTATUS_WIN_STATUS_INSUFF_SERVER_RESOURCES = 0xC0000205, + MD_NTSTATUS_WIN_STATUS_INVALID_BUFFER_SIZE = 0xC0000206, + MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_COMPONENT = 0xC0000207, + MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_WILDCARD = 0xC0000208, +@@ -664,16 +909,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_NO_MORE_MATCHES = 0xC0000273, + MD_NTSTATUS_WIN_STATUS_NOT_A_REPARSE_POINT = 0xC0000275, + MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_INVALID = 0xC0000276, + MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_MISMATCH = 0xC0000277, + MD_NTSTATUS_WIN_STATUS_IO_REPARSE_DATA_INVALID = 0xC0000278, + MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_NOT_HANDLED = 0xC0000279, + MD_NTSTATUS_WIN_STATUS_PWD_TOO_LONG = 0xC000027A, + MD_NTSTATUS_WIN_STATUS_STOWED_EXCEPTION = 0xC000027B, ++ MD_NTSTATUS_WIN_STATUS_CONTEXT_STOWED_EXCEPTION = 0xC000027C, + MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_NOT_RESOLVED = 0xC0000280, + MD_NTSTATUS_WIN_STATUS_DIRECTORY_IS_A_REPARSE_POINT = 0xC0000281, + MD_NTSTATUS_WIN_STATUS_RANGE_LIST_CONFLICT = 0xC0000282, + MD_NTSTATUS_WIN_STATUS_SOURCE_ELEMENT_EMPTY = 0xC0000283, + MD_NTSTATUS_WIN_STATUS_DESTINATION_ELEMENT_FULL = 0xC0000284, + MD_NTSTATUS_WIN_STATUS_ILLEGAL_ELEMENT_ADDRESS = 0xC0000285, + MD_NTSTATUS_WIN_STATUS_MAGAZINE_NOT_PRESENT = 0xC0000286, + MD_NTSTATUS_WIN_STATUS_REINITIALIZATION_NEEDED = 0xC0000287, +@@ -796,16 +1042,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_COPY_PROTECTION_FAILURE = 0xC0000305, + MD_NTSTATUS_WIN_STATUS_CSS_AUTHENTICATION_FAILURE = 0xC0000306, + MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_PRESENT = 0xC0000307, + MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_ESTABLISHED = 0xC0000308, + MD_NTSTATUS_WIN_STATUS_CSS_SCRAMBLED_SECTOR = 0xC0000309, + MD_NTSTATUS_WIN_STATUS_CSS_REGION_MISMATCH = 0xC000030A, + MD_NTSTATUS_WIN_STATUS_CSS_RESETS_EXHAUSTED = 0xC000030B, + MD_NTSTATUS_WIN_STATUS_PASSWORD_CHANGE_REQUIRED = 0xC000030C, ++ MD_NTSTATUS_WIN_STATUS_LOST_MODE_LOGON_RESTRICTION = 0xC000030D, + MD_NTSTATUS_WIN_STATUS_PKINIT_FAILURE = 0xC0000320, + MD_NTSTATUS_WIN_STATUS_SMARTCARD_SUBSYSTEM_FAILURE = 0xC0000321, + MD_NTSTATUS_WIN_STATUS_NO_KERB_KEY = 0xC0000322, + MD_NTSTATUS_WIN_STATUS_HOST_DOWN = 0xC0000350, + MD_NTSTATUS_WIN_STATUS_UNSUPPORTED_PREAUTH = 0xC0000351, + MD_NTSTATUS_WIN_STATUS_EFS_ALG_BLOB_TOO_BIG = 0xC0000352, + MD_NTSTATUS_WIN_STATUS_PORT_NOT_SET = 0xC0000353, + MD_NTSTATUS_WIN_STATUS_DEBUGGER_INACTIVE = 0xC0000354, +@@ -928,16 +1175,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_FILE_NOT_AVAILABLE = 0xC0000467, + MD_NTSTATUS_WIN_STATUS_DEVICE_INSUFFICIENT_RESOURCES = 0xC0000468, + MD_NTSTATUS_WIN_STATUS_PACKAGE_UPDATING = 0xC0000469, + MD_NTSTATUS_WIN_STATUS_NOT_READ_FROM_COPY = 0xC000046A, + MD_NTSTATUS_WIN_STATUS_FT_WRITE_FAILURE = 0xC000046B, + MD_NTSTATUS_WIN_STATUS_FT_DI_SCAN_REQUIRED = 0xC000046C, + MD_NTSTATUS_WIN_STATUS_OBJECT_NOT_EXTERNALLY_BACKED = 0xC000046D, + MD_NTSTATUS_WIN_STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN = 0xC000046E, ++ MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_BENEFICIAL = 0xC000046F, + MD_NTSTATUS_WIN_STATUS_DATA_CHECKSUM_ERROR = 0xC0000470, + MD_NTSTATUS_WIN_STATUS_INTERMIXED_KERNEL_EA_OPERATION = 0xC0000471, + MD_NTSTATUS_WIN_STATUS_TRIM_READ_ZERO_NOT_SUPPORTED = 0xC0000472, + MD_NTSTATUS_WIN_STATUS_TOO_MANY_SEGMENT_DESCRIPTORS = 0xC0000473, + MD_NTSTATUS_WIN_STATUS_INVALID_OFFSET_ALIGNMENT = 0xC0000474, + MD_NTSTATUS_WIN_STATUS_INVALID_FIELD_IN_PARAMETER_LIST = 0xC0000475, + MD_NTSTATUS_WIN_STATUS_OPERATION_IN_PROGRESS = 0xC0000476, + MD_NTSTATUS_WIN_STATUS_INVALID_INITIATOR_TARGET_PATH = 0xC0000477, +@@ -948,26 +1196,101 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_SUPPORTED = 0xC000047C, + MD_NTSTATUS_WIN_STATUS_IO_OPERATION_TIMEOUT = 0xC000047D, + MD_NTSTATUS_WIN_STATUS_SYSTEM_NEEDS_REMEDIATION = 0xC000047E, + MD_NTSTATUS_WIN_STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN = 0xC000047F, + MD_NTSTATUS_WIN_STATUS_SHARE_UNAVAILABLE = 0xC0000480, + MD_NTSTATUS_WIN_STATUS_APISET_NOT_HOSTED = 0xC0000481, + MD_NTSTATUS_WIN_STATUS_APISET_NOT_PRESENT = 0xC0000482, + MD_NTSTATUS_WIN_STATUS_DEVICE_HARDWARE_ERROR = 0xC0000483, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_SLOT_INVALID = 0xC0000484, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_IMAGE_INVALID = 0xC0000485, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_TOPOLOGY_ID_MISMATCH = 0xC0000486, ++ MD_NTSTATUS_WIN_STATUS_WIM_NOT_BOOTABLE = 0xC0000487, ++ MD_NTSTATUS_WIN_STATUS_BLOCKED_BY_PARENTAL_CONTROLS = 0xC0000488, ++ MD_NTSTATUS_WIN_STATUS_NEEDS_REGISTRATION = 0xC0000489, ++ MD_NTSTATUS_WIN_STATUS_QUOTA_ACTIVITY = 0xC000048A, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_INVOKE_INLINE = 0xC000048B, ++ MD_NTSTATUS_WIN_STATUS_BLOCK_TOO_MANY_REFERENCES = 0xC000048C, ++ MD_NTSTATUS_WIN_STATUS_MARKED_TO_DISALLOW_WRITES = 0xC000048D, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED_EDP = 0xC000048E, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_FAILURE = 0xC000048F, ++ MD_NTSTATUS_WIN_STATUS_PNP_NO_COMPAT_DRIVERS = 0xC0000490, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND = 0xC0000491, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND = 0xC0000492, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE = 0xC0000493, ++ MD_NTSTATUS_WIN_STATUS_PNP_FUNCTION_DRIVER_REQUIRED = 0xC0000494, ++ MD_NTSTATUS_WIN_STATUS_PNP_DEVICE_CONFIGURATION_PENDING = 0xC0000495, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL = 0xC0000496, ++ MD_NTSTATUS_WIN_STATUS_PACKAGE_NOT_AVAILABLE = 0xC0000497, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_IN_MAINTENANCE = 0xC0000499, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_DAX = 0xC000049A, ++ MD_NTSTATUS_WIN_STATUS_FREE_SPACE_TOO_FRAGMENTED = 0xC000049B, ++ MD_NTSTATUS_WIN_STATUS_DAX_MAPPING_EXISTS = 0xC000049C, ++ MD_NTSTATUS_WIN_STATUS_CHILD_PROCESS_BLOCKED = 0xC000049D, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_LOST_DATA_PERSISTENCE = 0xC000049E, ++ MD_NTSTATUS_WIN_STATUS_VRF_CFG_AND_IO_ENABLED = 0xC000049F, ++ MD_NTSTATUS_WIN_STATUS_PARTITION_TERMINATING = 0xC00004A0, ++ MD_NTSTATUS_WIN_STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED = 0xC00004A1, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_VIOLATION = 0xC00004A2, ++ MD_NTSTATUS_WIN_STATUS_FILE_PROTECTED_UNDER_DPL = 0xC00004A3, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_CLUSTER_ALIGNED = 0xC00004A4, ++ MD_NTSTATUS_WIN_STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND = 0xC00004A5, ++ MD_NTSTATUS_WIN_STATUS_APPX_FILE_NOT_ENCRYPTED = 0xC00004A6, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED = 0xC00004A7, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET = 0xC00004A8, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE = 0xC00004A9, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER = 0xC00004AA, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_FAILURE = 0xC00004AB, ++ MD_NTSTATUS_WIN_STATUS_PATCH_CONFLICT = 0xC00004AC, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ID_INVALID = 0xC00004AD, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_DOES_NOT_EXIST = 0xC00004AE, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ALREADY_EXISTS = 0xC00004AF, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_NOT_EMPTY = 0xC00004B0, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_DAX_VOLUME = 0xC00004B1, ++ MD_NTSTATUS_WIN_STATUS_NOT_DAX_MAPPABLE = 0xC00004B2, ++ MD_NTSTATUS_WIN_STATUS_CASE_DIFFERING_NAMES_IN_DIR = 0xC00004B3, ++ MD_NTSTATUS_WIN_STATUS_FILE_NOT_SUPPORTED = 0xC00004B4, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_WITH_BTT = 0xC00004B5, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTION_DISABLED = 0xC00004B6, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTING_METADATA_DISALLOWED = 0xC00004B7, ++ MD_NTSTATUS_WIN_STATUS_CANT_CLEAR_ENCRYPTION_FLAG = 0xC00004B8, ++ MD_NTSTATUS_WIN_STATUS_UNSATISFIED_DEPENDENCIES = 0xC00004B9, ++ MD_NTSTATUS_WIN_STATUS_CASE_SENSITIVE_PATH = 0xC00004BA, ++ MD_NTSTATUS_WIN_STATUS_HAS_SYSTEM_CRITICAL_FILES = 0xC00004BD, + MD_NTSTATUS_WIN_STATUS_INVALID_TASK_NAME = 0xC0000500, + MD_NTSTATUS_WIN_STATUS_INVALID_TASK_INDEX = 0xC0000501, + MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_TASK = 0xC0000502, + MD_NTSTATUS_WIN_STATUS_CALLBACK_BYPASS = 0xC0000503, + MD_NTSTATUS_WIN_STATUS_UNDEFINED_SCOPE = 0xC0000504, + MD_NTSTATUS_WIN_STATUS_INVALID_CAP = 0xC0000505, + MD_NTSTATUS_WIN_STATUS_NOT_GUI_PROCESS = 0xC0000506, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_HUNG = 0xC0000507, ++ MD_NTSTATUS_WIN_STATUS_CONTAINER_ASSIGNED = 0xC0000508, ++ MD_NTSTATUS_WIN_STATUS_JOB_NO_CONTAINER = 0xC0000509, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_UNRESPONSIVE = 0xC000050A, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_ENCOUNTERED = 0xC000050B, ++ MD_NTSTATUS_WIN_STATUS_ATTRIBUTE_NOT_PRESENT = 0xC000050C, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_TIERED_VOLUME = 0xC000050D, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_HAS_STREAM_ID = 0xC000050E, ++ MD_NTSTATUS_WIN_STATUS_JOB_NOT_EMPTY = 0xC000050F, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_INITIALIZED = 0xC0000510, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_NOT_TERMINATED = 0xC0000511, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_IS_TERMINATING = 0xC0000512, ++ MD_NTSTATUS_WIN_STATUS_SMB1_NOT_AVAILABLE = 0xC0000513, ++ MD_NTSTATUS_WIN_STATUS_SMR_GARBAGE_COLLECTION_REQUIRED = 0xC0000514, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPTED = 0xC0000515, ++ MD_NTSTATUS_WIN_STATUS_THREAD_NOT_RUNNING = 0xC0000516, + MD_NTSTATUS_WIN_STATUS_FAIL_FAST_EXCEPTION = 0xC0000602, + MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_REVOKED = 0xC0000603, + MD_NTSTATUS_WIN_STATUS_DYNAMIC_CODE_BLOCKED = 0xC0000604, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_EXPIRED = 0xC0000605, ++ MD_NTSTATUS_WIN_STATUS_STRICT_CFG_VIOLATION = 0xC0000606, ++ MD_NTSTATUS_WIN_STATUS_SET_CONTEXT_DENIED = 0xC000060A, ++ MD_NTSTATUS_WIN_STATUS_CROSS_PARTITION_VIOLATION = 0xC000060B, + MD_NTSTATUS_WIN_STATUS_PORT_CLOSED = 0xC0000700, + MD_NTSTATUS_WIN_STATUS_MESSAGE_LOST = 0xC0000701, + MD_NTSTATUS_WIN_STATUS_INVALID_MESSAGE = 0xC0000702, + MD_NTSTATUS_WIN_STATUS_REQUEST_CANCELED = 0xC0000703, + MD_NTSTATUS_WIN_STATUS_RECURSIVE_DISPATCH = 0xC0000704, + MD_NTSTATUS_WIN_STATUS_LPC_RECEIVE_BUFFER_EXPECTED = 0xC0000705, + MD_NTSTATUS_WIN_STATUS_LPC_INVALID_CONNECTION_USAGE = 0xC0000706, + MD_NTSTATUS_WIN_STATUS_LPC_REQUESTS_NOT_ALLOWED = 0xC0000707, +@@ -992,16 +1315,21 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_PORT_ALREADY_HAS_COMPLETION_LIST = 0xC000071A, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_PRIORITY = 0xC000071B, + MD_NTSTATUS_WIN_STATUS_INVALID_THREAD = 0xC000071C, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_TRANSACTION = 0xC000071D, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LDR_LOCK = 0xC000071E, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LANG = 0xC000071F, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_PRI_BACK = 0xC0000720, + MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY = 0xC0000721, ++ MD_NTSTATUS_WIN_STATUS_LPC_HANDLE_COUNT_EXCEEDED = 0xC0000722, ++ MD_NTSTATUS_WIN_STATUS_EXECUTABLE_MEMORY_WRITE = 0xC0000723, ++ MD_NTSTATUS_WIN_STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE = 0xC0000724, ++ MD_NTSTATUS_WIN_STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE = 0xC0000725, ++ MD_NTSTATUS_WIN_STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE = 0xC0000726, + MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_DISABLED = 0xC0000800, + MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS = 0xC0000801, + MD_NTSTATUS_WIN_STATUS_DISK_QUOTA_EXCEEDED = 0xC0000802, + MD_NTSTATUS_WIN_STATUS_CONTENT_BLOCKED = 0xC0000804, + MD_NTSTATUS_WIN_STATUS_BAD_CLUSTERS = 0xC0000805, + MD_NTSTATUS_WIN_STATUS_VOLUME_DIRTY = 0xC0000806, + MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_UNSUCCESSFUL = 0xC0000808, + MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_OVERFULL = 0xC0000809, +@@ -1028,16 +1356,19 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_FILE_HANDLE_REVOKED = 0xC0000910, + MD_NTSTATUS_WIN_STATUS_WOW_ASSERTION = 0xC0009898, + MD_NTSTATUS_WIN_STATUS_INVALID_SIGNATURE = 0xC000A000, + MD_NTSTATUS_WIN_STATUS_HMAC_NOT_SUPPORTED = 0xC000A001, + MD_NTSTATUS_WIN_STATUS_AUTH_TAG_MISMATCH = 0xC000A002, + MD_NTSTATUS_WIN_STATUS_INVALID_STATE_TRANSITION = 0xC000A003, + MD_NTSTATUS_WIN_STATUS_INVALID_KERNEL_INFO_VERSION = 0xC000A004, + MD_NTSTATUS_WIN_STATUS_INVALID_PEP_INFO_VERSION = 0xC000A005, ++ MD_NTSTATUS_WIN_STATUS_HANDLE_REVOKED = 0xC000A006, ++ MD_NTSTATUS_WIN_STATUS_EOF_ON_GHOSTED_RANGE = 0xC000A007, ++ MD_NTSTATUS_WIN_STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN = 0xC000A008, + MD_NTSTATUS_WIN_STATUS_IPSEC_QUEUE_OVERFLOW = 0xC000A010, + MD_NTSTATUS_WIN_STATUS_ND_QUEUE_OVERFLOW = 0xC000A011, + MD_NTSTATUS_WIN_STATUS_HOPLIMIT_EXCEEDED = 0xC000A012, + MD_NTSTATUS_WIN_STATUS_PROTOCOL_NOT_SUPPORTED = 0xC000A013, + MD_NTSTATUS_WIN_STATUS_FASTPATH_REJECTED = 0xC000A014, + MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED = 0xC000A080, + MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR = 0xC000A081, + MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR = 0xC000A082, +@@ -1059,25 +1390,72 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_CANNOT_SWITCH_RUNLEVEL = 0xC000A141, + MD_NTSTATUS_WIN_STATUS_INVALID_RUNLEVEL_SETTING = 0xC000A142, + MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_TIMEOUT = 0xC000A143, + MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT = 0xC000A145, + MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_IN_PROGRESS = 0xC000A146, + MD_NTSTATUS_WIN_STATUS_NOT_APPCONTAINER = 0xC000A200, + MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_IN_APPCONTAINER = 0xC000A201, + MD_NTSTATUS_WIN_STATUS_INVALID_PACKAGE_SID_LENGTH = 0xC000A202, ++ MD_NTSTATUS_WIN_STATUS_LPAC_ACCESS_DENIED = 0xC000A203, ++ MD_NTSTATUS_WIN_STATUS_ADMINLESS_ACCESS_DENIED = 0xC000A204, + MD_NTSTATUS_WIN_STATUS_APP_DATA_NOT_FOUND = 0xC000A281, + MD_NTSTATUS_WIN_STATUS_APP_DATA_EXPIRED = 0xC000A282, + MD_NTSTATUS_WIN_STATUS_APP_DATA_CORRUPT = 0xC000A283, + MD_NTSTATUS_WIN_STATUS_APP_DATA_LIMIT_EXCEEDED = 0xC000A284, + MD_NTSTATUS_WIN_STATUS_APP_DATA_REBOOT_REQUIRED = 0xC000A285, + MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED = 0xC000A2A1, + MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED = 0xC000A2A2, + MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED = 0xC000A2A3, + MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED = 0xC000A2A4, ++ MD_NTSTATUS_WIN_STATUS_WOF_WIM_HEADER_CORRUPT = 0xC000A2A5, ++ MD_NTSTATUS_WIN_STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT = 0xC000A2A6, ++ MD_NTSTATUS_WIN_STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT = 0xC000A2A7, ++ MD_NTSTATUS_WIN_STATUS_CIMFS_IMAGE_CORRUPT = 0xC000C001, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE = 0xC000CE01, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT = 0xC000CE02, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY = 0xC000CE03, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN = 0xC000CE04, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION = 0xC000CE05, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT = 0xC000CF00, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING = 0xC000CF01, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_CORRUPT = 0xC000CF02, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_TOO_LARGE = 0xC000CF03, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED = 0xC000CF06, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_FILE = 0xC000CF07, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_IN_SYNC = 0xC000CF08, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ALREADY_CONNECTED = 0xC000CF09, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_SUPPORTED = 0xC000CF0A, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INVALID_REQUEST = 0xC000CF0B, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_READ_ONLY_VOLUME = 0xC000CF0C, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY = 0xC000CF0D, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_VALIDATION_FAILED = 0xC000CF0E, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_AUTHENTICATION_FAILED = 0xC000CF0F, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES = 0xC000CF10, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE = 0xC000CF11, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_UNSUCCESSFUL = 0xC000CF12, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT = 0xC000CF13, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_IN_USE = 0xC000CF14, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PINNED = 0xC000CF15, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_ABORTED = 0xC000CF16, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_CORRUPT = 0xC000CF17, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ACCESS_DENIED = 0xC000CF18, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS = 0xC000CF19, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT = 0xC000CF1A, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_CANCELED = 0xC000CF1B, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_TERMINATED = 0xC000CF1D, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_SYNC_ROOT = 0xC000CF1E, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_TIMEOUT = 0xC000CF1F, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED = 0xC000CF20, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IN_PROGRESS = 0xC000F500, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED = 0xC000F501, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED = 0xC000F502, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IO_NOT_COORDINATED = 0xC000F503, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_UNEXPECTED_ERROR = 0xC000F504, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_INVALID_PARAMETER = 0xC000F505, + MD_NTSTATUS_WIN_DBG_NO_STATE_CHANGE = 0xC0010001, + MD_NTSTATUS_WIN_DBG_APP_NOT_IDLE = 0xC0010002, + MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_BINDING = 0xC0020001, + MD_NTSTATUS_WIN_RPC_NT_WRONG_KIND_OF_BINDING = 0xC0020002, + MD_NTSTATUS_WIN_RPC_NT_INVALID_BINDING = 0xC0020003, + MD_NTSTATUS_WIN_RPC_NT_PROTSEQ_NOT_SUPPORTED = 0xC0020004, + MD_NTSTATUS_WIN_RPC_NT_INVALID_RPC_PROTSEQ = 0xC0020005, + MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_UUID = 0xC0020006, +@@ -1263,16 +1641,21 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL = 0xC0130019, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS = 0xC0130020, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR = 0xC0130021, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_REDIRECTED = 0xC0130022, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NOT_REDIRECTED = 0xC0130023, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING = 0xC0130024, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS = 0xC0130025, + MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL = 0xC0130026, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NO_SNAPSHOTS = 0xC0130027, ++ MD_NTSTATUS_WIN_STATUS_CSV_IO_PAUSE_TIMEOUT = 0xC0130028, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_INVALID_HANDLE = 0xC0130029, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR = 0xC0130030, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED = 0xC0130031, + MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OPCODE = 0xC0140001, + MD_NTSTATUS_WIN_STATUS_ACPI_STACK_OVERFLOW = 0xC0140002, + MD_NTSTATUS_WIN_STATUS_ACPI_ASSERT_FAILED = 0xC0140003, + MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_INDEX = 0xC0140004, + MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGUMENT = 0xC0140005, + MD_NTSTATUS_WIN_STATUS_ACPI_FATAL = 0xC0140006, + MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_SUPERNAME = 0xC0140007, + MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGTYPE = 0xC0140008, +@@ -1504,16 +1887,21 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_OCCLUDED = 0xC01E0006, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_DENIED = 0xC01E0007, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANNOTCOLORCONVERT = 0xC01E0008, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_DRIVER_MISMATCH = 0xC01E0009, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED = 0xC01E000B, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_UNOCCLUDED = 0xC01E000C, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE = 0xC01E000D, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED = 0xC01E000E, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_INVALID_WINDOW = 0xC01E000F, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND = 0xC01E0010, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VAIL_STATE_CHANGED = 0xC01E0011, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN = 0xC01E0012, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED = 0xC01E0013, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDEO_MEMORY = 0xC01E0100, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_LOCK_MEMORY = 0xC01E0101, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_BUSY = 0xC01E0102, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_TOO_MANY_REFERENCES = 0xC01E0103, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_LATER = 0xC01E0104, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_NOW = 0xC01E0105, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_INVALID = 0xC01E0106, + MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE = 0xC01E0107, +@@ -1725,16 +2113,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_FVE_EDRIVE_DRY_RUN_FAILED = 0xC0210038, + MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_DISABLED = 0xC0210039, + MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_CONFIG_CHANGE = 0xC021003A, + MD_NTSTATUS_WIN_STATUS_FVE_DEVICE_LOCKEDOUT = 0xC021003B, + MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT = 0xC021003C, + MD_NTSTATUS_WIN_STATUS_FVE_NOT_DE_VOLUME = 0xC021003D, + MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_DISABLED = 0xC021003E, + MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED = 0xC021003F, ++ MD_NTSTATUS_WIN_STATUS_FVE_OSV_KSR_NOT_ALLOWED = 0xC0210040, + MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOT_FOUND = 0xC0220001, + MD_NTSTATUS_WIN_STATUS_FWP_CONDITION_NOT_FOUND = 0xC0220002, + MD_NTSTATUS_WIN_STATUS_FWP_FILTER_NOT_FOUND = 0xC0220003, + MD_NTSTATUS_WIN_STATUS_FWP_LAYER_NOT_FOUND = 0xC0220004, + MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_NOT_FOUND = 0xC0220005, + MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND = 0xC0220006, + MD_NTSTATUS_WIN_STATUS_FWP_SUBLAYER_NOT_FOUND = 0xC0220007, + MD_NTSTATUS_WIN_STATUS_FWP_NOT_FOUND = 0xC0220008, +@@ -1832,25 +2221,32 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_ADDRESS = 0xC0230022, + MD_NTSTATUS_WIN_STATUS_NDIS_PAUSED = 0xC023002A, + MD_NTSTATUS_WIN_STATUS_NDIS_INTERFACE_NOT_FOUND = 0xC023002B, + MD_NTSTATUS_WIN_STATUS_NDIS_UNSUPPORTED_REVISION = 0xC023002C, + MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT = 0xC023002D, + MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT_STATE = 0xC023002E, + MD_NTSTATUS_WIN_STATUS_NDIS_LOW_POWER_STATE = 0xC023002F, + MD_NTSTATUS_WIN_STATUS_NDIS_REINIT_REQUIRED = 0xC0230030, ++ MD_NTSTATUS_WIN_STATUS_NDIS_NO_QUEUES = 0xC0230031, + MD_NTSTATUS_WIN_STATUS_NDIS_NOT_SUPPORTED = 0xC02300BB, + MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_POLICY = 0xC023100F, + MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED = 0xC0231012, + MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_PATH_REJECTED = 0xC0231013, + MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED = 0xC0232000, + MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_MEDIA_IN_USE = 0xC0232001, + MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_POWER_STATE_INVALID = 0xC0232002, + MD_NTSTATUS_WIN_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL = 0xC0232003, + MD_NTSTATUS_WIN_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL = 0xC0232004, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE = 0xC0232005, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE = 0xC0232006, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED = 0xC0232007, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED = 0xC0232008, ++ MD_NTSTATUS_WIN_STATUS_QUIC_HANDSHAKE_FAILURE = 0xC0240000, ++ MD_NTSTATUS_WIN_STATUS_QUIC_VER_NEG_FAILURE = 0xC0240001, + MD_NTSTATUS_WIN_STATUS_TPM_ERROR_MASK = 0xC0290000, + MD_NTSTATUS_WIN_STATUS_TPM_AUTHFAIL = 0xC0290001, + MD_NTSTATUS_WIN_STATUS_TPM_BADINDEX = 0xC0290002, + MD_NTSTATUS_WIN_STATUS_TPM_BAD_PARAMETER = 0xC0290003, + MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAILURE = 0xC0290004, + MD_NTSTATUS_WIN_STATUS_TPM_CLEAR_DISABLED = 0xC0290005, + MD_NTSTATUS_WIN_STATUS_TPM_DEACTIVATED = 0xC0290006, + MD_NTSTATUS_WIN_STATUS_TPM_DISABLED = 0xC0290007, +@@ -1940,16 +2336,84 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_TPM_TOOMANYCONTEXTS = 0xC029005B, + MD_NTSTATUS_WIN_STATUS_TPM_MA_TICKET_SIGNATURE = 0xC029005C, + MD_NTSTATUS_WIN_STATUS_TPM_MA_DESTINATION = 0xC029005D, + MD_NTSTATUS_WIN_STATUS_TPM_MA_SOURCE = 0xC029005E, + MD_NTSTATUS_WIN_STATUS_TPM_MA_AUTHORITY = 0xC029005F, + MD_NTSTATUS_WIN_STATUS_TPM_PERMANENTEK = 0xC0290061, + MD_NTSTATUS_WIN_STATUS_TPM_BAD_SIGNATURE = 0xC0290062, + MD_NTSTATUS_WIN_STATUS_TPM_NOCONTEXTSPACE = 0xC0290063, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ASYMMETRIC = 0xC0290081, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ATTRIBUTES = 0xC0290082, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HASH = 0xC0290083, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_VALUE = 0xC0290084, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HIERARCHY = 0xC0290085, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY_SIZE = 0xC0290087, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_MGF = 0xC0290088, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_MODE = 0xC0290089, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TYPE = 0xC029008A, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HANDLE = 0xC029008B, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KDF = 0xC029008C, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_RANGE = 0xC029008D, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_FAIL = 0xC029008E, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NONCE = 0xC029008F, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PP = 0xC0290090, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SCHEME = 0xC0290092, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIZE = 0xC0290095, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SYMMETRIC = 0xC0290096, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TAG = 0xC0290097, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SELECTOR = 0xC0290098, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INSUFFICIENT = 0xC029009A, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIGNATURE = 0xC029009B, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY = 0xC029009C, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_FAIL = 0xC029009D, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INTEGRITY = 0xC029009F, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TICKET = 0xC02900A0, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_RESERVED_BITS = 0xC02900A1, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_AUTH = 0xC02900A2, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXPIRED = 0xC02900A3, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_CC = 0xC02900A4, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BINDING = 0xC02900A5, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_CURVE = 0xC02900A6, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_POINT = 0xC02900A7, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INITIALIZE = 0xC0290100, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_FAILURE = 0xC0290101, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SEQUENCE = 0xC0290103, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PRIVATE = 0xC029010B, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HMAC = 0xC0290119, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_DISABLED = 0xC0290120, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXCLUSIVE = 0xC0290121, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_CURVE = 0xC0290123, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_TYPE = 0xC0290124, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_MISSING = 0xC0290125, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY = 0xC0290126, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR = 0xC0290127, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR_CHANGED = 0xC0290128, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_UPGRADE = 0xC029012D, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TOO_MANY_CONTEXTS = 0xC029012E, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_UNAVAILABLE = 0xC029012F, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_REBOOT = 0xC0290130, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_UNBALANCED = 0xC0290131, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_SIZE = 0xC0290142, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_CODE = 0xC0290143, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTHSIZE = 0xC0290144, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_CONTEXT = 0xC0290145, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_RANGE = 0xC0290146, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SIZE = 0xC0290147, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_LOCKED = 0xC0290148, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_AUTHORIZATION = 0xC0290149, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_UNINITIALIZED = 0xC029014A, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SPACE = 0xC029014B, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_DEFINED = 0xC029014C, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_CONTEXT = 0xC0290150, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_CPHASH = 0xC0290151, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PARENT = 0xC0290152, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NEEDS_TEST = 0xC0290153, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NO_RESULT = 0xC0290154, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SENSITIVE = 0xC0290155, + MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_BLOCKED = 0xC0290400, + MD_NTSTATUS_WIN_STATUS_TPM_INVALID_HANDLE = 0xC0290401, + MD_NTSTATUS_WIN_STATUS_TPM_DUPLICATE_VHANDLE = 0xC0290402, + MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_BLOCKED = 0xC0290403, + MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED = 0xC0290404, + MD_NTSTATUS_WIN_STATUS_TPM_RETRY = 0xC0290800, + MD_NTSTATUS_WIN_STATUS_TPM_NEEDS_SELFTEST = 0xC0290801, + MD_NTSTATUS_WIN_STATUS_TPM_DOING_SELFTEST = 0xC0290802, +@@ -1969,16 +2433,42 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_TOO_SMALL = 0xC0292006, + MD_NTSTATUS_WIN_STATUS_PCP_INTERNAL_ERROR = 0xC0292007, + MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_FAILED = 0xC0292008, + MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_IGNORED = 0xC0292009, + MD_NTSTATUS_WIN_STATUS_PCP_POLICY_NOT_FOUND = 0xC029200A, + MD_NTSTATUS_WIN_STATUS_PCP_PROFILE_NOT_FOUND = 0xC029200B, + MD_NTSTATUS_WIN_STATUS_PCP_VALIDATION_FAILED = 0xC029200C, + MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_FOUND = 0xC029200D, ++ MD_NTSTATUS_WIN_STATUS_PCP_WRONG_PARENT = 0xC029200E, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_LOADED = 0xC029200F, ++ MD_NTSTATUS_WIN_STATUS_PCP_NO_KEY_CERTIFICATION = 0xC0292010, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_FINALIZED = 0xC0292011, ++ MD_NTSTATUS_WIN_STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET = 0xC0292012, ++ MD_NTSTATUS_WIN_STATUS_PCP_NOT_PCR_BOUND = 0xC0292013, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_ALREADY_FINALIZED = 0xC0292014, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED = 0xC0292015, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_INVALID = 0xC0292016, ++ MD_NTSTATUS_WIN_STATUS_PCP_SOFT_KEY_ERROR = 0xC0292017, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AUTHENTICATED = 0xC0292018, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AIK = 0xC0292019, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_SIGNING_KEY = 0xC029201A, ++ MD_NTSTATUS_WIN_STATUS_PCP_LOCKED_OUT = 0xC029201B, ++ MD_NTSTATUS_WIN_STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED = 0xC029201C, ++ MD_NTSTATUS_WIN_STATUS_PCP_TPM_VERSION_NOT_SUPPORTED = 0xC029201D, ++ MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_LENGTH_MISMATCH = 0xC029201E, ++ MD_NTSTATUS_WIN_STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED = 0xC029201F, ++ MD_NTSTATUS_WIN_STATUS_PCP_TICKET_MISSING = 0xC0292020, ++ MD_NTSTATUS_WIN_STATUS_PCP_RAW_POLICY_NOT_SUPPORTED = 0xC0292021, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_HANDLE_INVALIDATED = 0xC0292022, ++ MD_NTSTATUS_WIN_STATUS_RTPM_NO_RESULT = 0xC0293002, ++ MD_NTSTATUS_WIN_STATUS_RTPM_PCR_READ_INCOMPLETE = 0xC0293003, ++ MD_NTSTATUS_WIN_STATUS_RTPM_INVALID_CONTEXT = 0xC0293004, ++ MD_NTSTATUS_WIN_STATUS_RTPM_UNSUPPORTED_CMD = 0xC0293005, ++ MD_NTSTATUS_WIN_STATUS_TPM_ZERO_EXHAUST_ENABLED = 0xC0294000, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_CODE = 0xC0350002, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_INPUT = 0xC0350003, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_ALIGNMENT = 0xC0350004, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARAMETER = 0xC0350005, + MD_NTSTATUS_WIN_STATUS_HV_ACCESS_DENIED = 0xC0350006, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_STATE = 0xC0350007, + MD_NTSTATUS_WIN_STATUS_HV_OPERATION_DENIED = 0xC0350008, + MD_NTSTATUS_WIN_STATUS_HV_UNKNOWN_PROPERTY = 0xC0350009, +@@ -1986,28 +2476,46 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_MEMORY = 0xC035000B, + MD_NTSTATUS_WIN_STATUS_HV_PARTITION_TOO_DEEP = 0xC035000C, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_ID = 0xC035000D, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_INDEX = 0xC035000E, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_PORT_ID = 0xC0350011, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_CONNECTION_ID = 0xC0350012, + MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFERS = 0xC0350013, + MD_NTSTATUS_WIN_STATUS_HV_NOT_ACKNOWLEDGED = 0xC0350014, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_STATE = 0xC0350015, + MD_NTSTATUS_WIN_STATUS_HV_ACKNOWLEDGED = 0xC0350016, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_SAVE_RESTORE_STATE = 0xC0350017, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_SYNIC_STATE = 0xC0350018, + MD_NTSTATUS_WIN_STATUS_HV_OBJECT_IN_USE = 0xC0350019, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO = 0xC035001A, + MD_NTSTATUS_WIN_STATUS_HV_NO_DATA = 0xC035001B, + MD_NTSTATUS_WIN_STATUS_HV_INACTIVE = 0xC035001C, + MD_NTSTATUS_WIN_STATUS_HV_NO_RESOURCES = 0xC035001D, + MD_NTSTATUS_WIN_STATUS_HV_FEATURE_UNAVAILABLE = 0xC035001E, + MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFER = 0xC0350033, + MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS = 0xC0350038, ++ MD_NTSTATUS_WIN_STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR = 0xC035003C, ++ MD_NTSTATUS_WIN_STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR = 0xC035003D, ++ MD_NTSTATUS_WIN_STATUS_HV_PROCESSOR_STARTUP_TIMEOUT = 0xC035003E, ++ MD_NTSTATUS_WIN_STATUS_HV_SMX_ENABLED = 0xC035003F, + MD_NTSTATUS_WIN_STATUS_HV_INVALID_LP_INDEX = 0xC0350041, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_REGISTER_VALUE = 0xC0350050, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_VTL_STATE = 0xC0350051, ++ MD_NTSTATUS_WIN_STATUS_HV_NX_NOT_DETECTED = 0xC0350055, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_ID = 0xC0350057, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_STATE = 0xC0350058, ++ MD_NTSTATUS_WIN_STATUS_HV_PAGE_REQUEST_INVALID = 0xC0350060, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_ID = 0xC035006F, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_STATE = 0xC0350070, ++ MD_NTSTATUS_WIN_STATUS_HV_OPERATION_FAILED = 0xC0350071, ++ MD_NTSTATUS_WIN_STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE = 0xC0350072, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_ROOT_MEMORY = 0xC0350073, ++ MD_NTSTATUS_WIN_STATUS_HV_EVENT_BUFFER_ALREADY_FREED = 0xC0350074, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY = 0xC0350075, + MD_NTSTATUS_WIN_STATUS_HV_NOT_PRESENT = 0xC0351000, + MD_NTSTATUS_WIN_STATUS_IPSEC_BAD_SPI = 0xC0360001, + MD_NTSTATUS_WIN_STATUS_IPSEC_SA_LIFETIME_EXPIRED = 0xC0360002, + MD_NTSTATUS_WIN_STATUS_IPSEC_WRONG_SA = 0xC0360003, + MD_NTSTATUS_WIN_STATUS_IPSEC_REPLAY_CHECK_FAILED = 0xC0360004, + MD_NTSTATUS_WIN_STATUS_IPSEC_INVALID_PACKET = 0xC0360005, + MD_NTSTATUS_WIN_STATUS_IPSEC_INTEGRITY_CHECK_FAILED = 0xC0360006, + MD_NTSTATUS_WIN_STATUS_IPSEC_CLEAR_TEXT_DROP = 0xC0360007, +@@ -2056,16 +2564,17 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_VID_INVALID_CHILD_GPA_PAGE_SET = 0xC0370022, + MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED = 0xC0370023, + MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL = 0xC0370024, + MD_NTSTATUS_WIN_STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE = 0xC0370025, + MD_NTSTATUS_WIN_STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT = 0xC0370026, + MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_CORRUPT = 0xC0370027, + MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM = 0xC0370028, + MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_INCOMPATIBLE = 0xC0370029, ++ MD_NTSTATUS_WIN_STATUS_VID_VTL_ACCESS_DENIED = 0xC037002A, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DATABASE_FULL = 0xC0380001, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED = 0xC0380002, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC = 0xC0380003, + MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED = 0xC0380004, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME = 0xC0380005, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DUPLICATE = 0xC0380006, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DYNAMIC = 0xC0380007, + MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_ID_INVALID = 0xC0380008, +@@ -2186,25 +2695,32 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ALREADY_OWNED = 0xC03A001E, + MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE = 0xC03A001F, + MD_NTSTATUS_WIN_STATUS_CTLOG_TRACKING_NOT_INITIALIZED = 0xC03A0020, + MD_NTSTATUS_WIN_STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE = 0xC03A0021, + MD_NTSTATUS_WIN_STATUS_CTLOG_VHD_CHANGED_OFFLINE = 0xC03A0022, + MD_NTSTATUS_WIN_STATUS_CTLOG_INVALID_TRACKING_STATE = 0xC03A0023, + MD_NTSTATUS_WIN_STATUS_CTLOG_INCONSISTENT_TRACKING_FILE = 0xC03A0024, + MD_NTSTATUS_WIN_STATUS_VHD_METADATA_FULL = 0xC03A0028, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_CHANGE_TRACKING_ID = 0xC03A0029, ++ MD_NTSTATUS_WIN_STATUS_VHD_CHANGE_TRACKING_DISABLED = 0xC03A002A, ++ MD_NTSTATUS_WIN_STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION = 0xC03A0030, ++ MD_NTSTATUS_WIN_STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA = 0xC03A0031, ++ MD_NTSTATUS_WIN_STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE = 0xC03A0032, ++ MD_NTSTATUS_WIN_STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE = 0xC03A0033, + MD_NTSTATUS_WIN_STATUS_RKF_KEY_NOT_FOUND = 0xC0400001, + MD_NTSTATUS_WIN_STATUS_RKF_DUPLICATE_KEY = 0xC0400002, + MD_NTSTATUS_WIN_STATUS_RKF_BLOB_FULL = 0xC0400003, + MD_NTSTATUS_WIN_STATUS_RKF_STORE_FULL = 0xC0400004, + MD_NTSTATUS_WIN_STATUS_RKF_FILE_BLOCKED = 0xC0400005, + MD_NTSTATUS_WIN_STATUS_RKF_ACTIVE_KEY = 0xC0400006, + MD_NTSTATUS_WIN_STATUS_RDBSS_RESTART_OPERATION = 0xC0410001, + MD_NTSTATUS_WIN_STATUS_RDBSS_CONTINUE_OPERATION = 0xC0410002, + MD_NTSTATUS_WIN_STATUS_RDBSS_POST_OPERATION = 0xC0410003, ++ MD_NTSTATUS_WIN_STATUS_RDBSS_RETRY_LOOKUP = 0xC0410004, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_HANDLE = 0xC0420001, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_READ_NOT_PERMITTED = 0xC0420002, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_WRITE_NOT_PERMITTED = 0xC0420003, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_PDU = 0xC0420004, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION = 0xC0420005, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED = 0xC0420006, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_OFFSET = 0xC0420007, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION = 0xC0420008, +@@ -2219,40 +2735,113 @@ typedef enum { + MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_RESOURCES = 0xC0420011, + MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNKNOWN_ERROR = 0xC0421000, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_ROLLBACK_DETECTED = 0xC0430001, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_VIOLATION = 0xC0430002, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_INVALID_POLICY = 0xC0430003, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND = 0xC0430004, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_SIGNED = 0xC0430005, + MD_NTSTATUS_WIN_STATUS_SECUREBOOT_FILE_REPLACED = 0xC0430007, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED = 0xC0430008, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UNKNOWN = 0xC0430009, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION = 0xC043000A, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH = 0xC043000B, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED = 0xC043000C, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH = 0xC043000D, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING = 0xC043000E, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_BASE_POLICY = 0xC043000F, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY = 0xC0430010, + MD_NTSTATUS_WIN_STATUS_AUDIO_ENGINE_NODE_NOT_FOUND = 0xC0440001, + MD_NTSTATUS_WIN_STATUS_HDAUDIO_EMPTY_CONNECTION_LIST = 0xC0440002, + MD_NTSTATUS_WIN_STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED = 0xC0440003, + MD_NTSTATUS_WIN_STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED = 0xC0440004, + MD_NTSTATUS_WIN_STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY = 0xC0440005, ++ MD_NTSTATUS_WIN_STATUS_VSM_NOT_INITIALIZED = 0xC0450000, ++ MD_NTSTATUS_WIN_STATUS_VSM_DMA_PROTECTION_NOT_IN_USE = 0xC0450001, + MD_NTSTATUS_WIN_STATUS_VOLSNAP_BOOTFILE_NOT_VALID = 0xC0500003, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_ACTIVATION_TIMEOUT = 0xC0500004, + MD_NTSTATUS_WIN_STATUS_IO_PREEMPTED = 0xC0510001, + MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_STORED = 0xC05C0000, + MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_NOT_AVAILABLE = 0xC05CFF00, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE = 0xC05CFF01, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED = 0xC05CFF02, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED = 0xC05CFF03, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED = 0xC05CFF04, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED = 0xC05CFF05, + MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED = 0xC05CFF06, + MD_NTSTATUS_WIN_STATUS_SVHDX_RESERVATION_CONFLICT = 0xC05CFF07, + MD_NTSTATUS_WIN_STATUS_SVHDX_WRONG_FILE_TYPE = 0xC05CFF08, + MD_NTSTATUS_WIN_STATUS_SVHDX_VERSION_MISMATCH = 0xC05CFF09, + MD_NTSTATUS_WIN_STATUS_VHD_SHARED = 0xC05CFF0A, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_NO_INITIATOR = 0xC05CFF0B, ++ MD_NTSTATUS_WIN_STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND = 0xC05CFF0C, ++ MD_NTSTATUS_WIN_STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP = 0xC05D0000, ++ MD_NTSTATUS_WIN_STATUS_SMB_BAD_CLUSTER_DIALECT = 0xC05D0001, ++ MD_NTSTATUS_WIN_STATUS_SMB_GUEST_LOGON_BLOCKED = 0xC05D0002, ++ MD_NTSTATUS_WIN_STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID = 0xC0E70001, + MD_NTSTATUS_WIN_STATUS_SPACES_RESILIENCY_TYPE_INVALID = 0xC0E70003, + MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID = 0xC0E70004, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_REDUNDANCY_INVALID = 0xC0E70006, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID = 0xC0E70007, + MD_NTSTATUS_WIN_STATUS_SPACES_INTERLEAVE_LENGTH_INVALID = 0xC0E70009, + MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID = 0xC0E7000A, +- MD_NTSTATUS_WIN_STATUS_SPACES_NOT_ENOUGH_DRIVES = 0xC0E7000B ++ MD_NTSTATUS_WIN_STATUS_SPACES_NOT_ENOUGH_DRIVES = 0xC0E7000B, ++ MD_NTSTATUS_WIN_STATUS_SPACES_EXTENDED_ERROR = 0xC0E7000C, ++ MD_NTSTATUS_WIN_STATUS_SPACES_PROVISIONING_TYPE_INVALID = 0xC0E7000D, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ALLOCATION_SIZE_INVALID = 0xC0E7000E, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENCLOSURE_AWARE_INVALID = 0xC0E7000F, ++ MD_NTSTATUS_WIN_STATUS_SPACES_WRITE_CACHE_SIZE_INVALID = 0xC0E70010, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_GROUPS_INVALID = 0xC0E70011, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID = 0xC0E70012, ++ MD_NTSTATUS_WIN_STATUS_SPACES_UPDATE_COLUMN_STATE = 0xC0E70013, ++ MD_NTSTATUS_WIN_STATUS_SPACES_MAP_REQUIRED = 0xC0E70014, ++ MD_NTSTATUS_WIN_STATUS_SPACES_UNSUPPORTED_VERSION = 0xC0E70015, ++ MD_NTSTATUS_WIN_STATUS_SPACES_CORRUPT_METADATA = 0xC0E70016, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRT_FULL = 0xC0E70017, ++ MD_NTSTATUS_WIN_STATUS_SPACES_INCONSISTENCY = 0xC0E70018, ++ MD_NTSTATUS_WIN_STATUS_SPACES_LOG_NOT_READY = 0xC0E70019, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NO_REDUNDANCY = 0xC0E7001A, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_NOT_READY = 0xC0E7001B, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SPLIT = 0xC0E7001C, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_LOST_DATA = 0xC0E7001D, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INCOMPLETE = 0xC0E7001E, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INVALID = 0xC0E7001F, ++ MD_NTSTATUS_WIN_STATUS_SPACES_MARK_DIRTY = 0xC0E70020, ++ MD_NTSTATUS_WIN_STATUS_SECCORE_INVALID_COMMAND = 0xC0E80000, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED = 0xC0E90001, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION = 0xC0E90002, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_INVALID_POLICY = 0xC0E90003, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED = 0xC0E90004, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES = 0xC0E90005, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED = 0xC0E90006, ++ MD_NTSTATUS_WIN_STATUS_NO_APPLICABLE_APP_LICENSES_FOUND = 0xC0EA0001, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_FOUND = 0xC0EA0002, ++ MD_NTSTATUS_WIN_STATUS_CLIP_DEVICE_LICENSE_MISSING = 0xC0EA0003, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_INVALID_SIGNATURE = 0xC0EA0004, ++ MD_NTSTATUS_WIN_STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID = 0xC0EA0005, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_EXPIRED = 0xC0EA0006, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE = 0xC0EA0007, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_SIGNED = 0xC0EA0008, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE = 0xC0EA0009, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH = 0xC0EA000A, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED = 0xC0EB0001, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_INVALID = 0xC0EB0002, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED = 0xC0EB0003, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED = 0xC0EB0004, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND = 0xC0EB0005, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_ACTIVE = 0xC0EB0006, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_SIGNED = 0xC0EB0007, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_CONDITION_NOT_SATISFIED = 0xC0EC0000, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_HANDLE_INVALIDATED = 0xC0EC0001, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_GENERATION = 0xC0EC0002, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION = 0xC0EC0003, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_STATE = 0xC0EC0004, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_NO_DONOR = 0xC0EC0005, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_HOST_ID_MISMATCH = 0xC0EC0006, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_UNKNOWN_USER = 0xC0EC0007, + } MDNTStatusCodeWin; + + // These constants are defined in the MSDN documentation of + // the EXCEPTION_RECORD structure. + typedef enum { + MD_ACCESS_VIOLATION_WIN_READ = 0, + MD_ACCESS_VIOLATION_WIN_WRITE = 1, + MD_ACCESS_VIOLATION_WIN_EXEC = 8 +diff --git a/src/processor/exploitability_win.cc b/src/processor/exploitability_win.cc +--- a/src/processor/exploitability_win.cc ++++ b/src/processor/exploitability_win.cc +@@ -147,18 +147,18 @@ ExploitabilityRating ExploitabilityWin:: + break; + + // These represent bugs in exception handlers. + case MD_EXCEPTION_CODE_WIN_INVALID_DISPOSITION: + case MD_EXCEPTION_CODE_WIN_NONCONTINUABLE_EXCEPTION: + exploitability_weight += kSmallBump; + break; + +- case MD_EXCEPTION_CODE_WIN_HEAP_CORRUPTION: +- case MD_EXCEPTION_CODE_WIN_STACK_BUFFER_OVERRUN: ++ case MD_NTSTATUS_WIN_STATUS_HEAP_CORRUPTION: ++ case MD_NTSTATUS_WIN_STATUS_STACK_BUFFER_OVERRUN: + exploitability_weight += kHugeBump; + break; + + case MD_EXCEPTION_CODE_WIN_GUARD_PAGE_VIOLATION: + exploitability_weight += kLargeBump; + break; + + case MD_EXCEPTION_CODE_WIN_ACCESS_VIOLATION: +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1138,19 +1138,16 @@ string MinidumpProcessor::GetCrashReason + break; + } + break; + } + + case MD_OS_WIN32_NT: + case MD_OS_WIN32_WINDOWS: { + switch (exception_code) { +- case MD_EXCEPTION_CODE_WIN_CONTROL_C: +- reason = "DBG_CONTROL_C"; +- break; + case MD_EXCEPTION_CODE_WIN_GUARD_PAGE_VIOLATION: + reason = "EXCEPTION_GUARD_PAGE"; + break; + case MD_EXCEPTION_CODE_WIN_DATATYPE_MISALIGNMENT: + reason = "EXCEPTION_DATATYPE_MISALIGNMENT"; + break; + case MD_EXCEPTION_CODE_WIN_BREAKPOINT: + reason = "EXCEPTION_BREAKPOINT"; +@@ -1245,17 +1242,17 @@ string MinidumpProcessor::GetCrashReason + break; + case MD_EXCEPTION_CODE_WIN_NONCONTINUABLE_EXCEPTION: + reason = "EXCEPTION_NONCONTINUABLE_EXCEPTION"; + break; + case MD_EXCEPTION_CODE_WIN_INVALID_DISPOSITION: + reason = "EXCEPTION_INVALID_DISPOSITION"; + break; + case MD_EXCEPTION_CODE_WIN_ARRAY_BOUNDS_EXCEEDED: +- reason = "EXCEPTION_BOUNDS_EXCEEDED"; ++ reason = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED"; + break; + case MD_EXCEPTION_CODE_WIN_FLOAT_DENORMAL_OPERAND: + reason = "EXCEPTION_FLT_DENORMAL_OPERAND"; + break; + case MD_EXCEPTION_CODE_WIN_FLOAT_DIVIDE_BY_ZERO: + reason = "EXCEPTION_FLT_DIVIDE_BY_ZERO"; + break; + case MD_EXCEPTION_CODE_WIN_FLOAT_INEXACT_RESULT: +@@ -1286,41 +1283,41 @@ string MinidumpProcessor::GetCrashReason + reason = "EXCEPTION_STACK_OVERFLOW"; + break; + case MD_EXCEPTION_CODE_WIN_BAD_FUNCTION_TABLE: + reason = "EXCEPTION_BAD_FUNCTION_TABLE"; + break; + case MD_EXCEPTION_CODE_WIN_POSSIBLE_DEADLOCK: + reason = "EXCEPTION_POSSIBLE_DEADLOCK"; + break; +- case MD_EXCEPTION_CODE_WIN_STACK_BUFFER_OVERRUN: +- reason = "EXCEPTION_STACK_BUFFER_OVERRUN"; ++ case MD_NTSTATUS_WIN_STATUS_STACK_BUFFER_OVERRUN: ++ reason = "STATUS_STACK_BUFFER_OVERRUN"; + if (raw_exception->exception_record.number_parameters > 0) { + uint32_t fast_fail_code = + static_cast<uint32_t> + (raw_exception->exception_record.exception_information[0]); + reason.append(" / "); + reason.append(FastFailToString(fast_fail_code)); + } + + break; +- case MD_EXCEPTION_CODE_WIN_HEAP_CORRUPTION: +- reason = "EXCEPTION_HEAP_CORRUPTION"; +- break; + case MD_EXCEPTION_OUT_OF_MEMORY: + reason = "Out of Memory"; + break; + case MD_EXCEPTION_CODE_WIN_UNHANDLED_CPP_EXCEPTION: + reason = "Unhandled C++ Exception"; + break; + case MD_EXCEPTION_CODE_WIN_SIMULATED: + reason = "Simulated Exception"; + break; + default: +- BPLOG(INFO) << "Unknown exception reason " << reason; ++ reason = NTStatusToString(exception_code); ++ if (reason.substr(0, 2) == "0x") { ++ BPLOG(INFO) << "Unknown exception reason " << reason; ++ } + break; + } + break; + } + + case MD_OS_ANDROID: + case MD_OS_LINUX: { + switch (exception_code) { +diff --git a/src/processor/symbolic_constants_win.cc b/src/processor/symbolic_constants_win.cc +--- a/src/processor/symbolic_constants_win.cc ++++ b/src/processor/symbolic_constants_win.cc +@@ -39,31 +39,761 @@ + #include "google_breakpad/common/breakpad_types.h" + #include "google_breakpad/common/minidump_exception_win32.h" + #include "processor/symbolic_constants_win.h" + + namespace google_breakpad { + + string NTStatusToString(uint32_t ntstatus) { + string reason; +- // The content of this switch was created from ntstatus.h in the 8.1 SDK with ++ // The content of this switch was created from ntstatus.h in the 10 SDK ++ // (version 10.0.19041.0) with + // +- // egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0xC[0-9A-F]+L\)' ntstatus.h ++ // egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0x[048C][0-9A-F]+L\)' ntstatus.h + // | tr -d '\r' +- // | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0xC[0-9A-F]+)L\).*@\2 \1@' ++ // | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0x[048C][0-9A-F]+)L\).*@\2 \1@' + // | sort +- // | sed -r 's@(0xC[0-9A-F]+) ([A-Z_0-9]+)@ case MD_NTSTATUS_WIN_\2:\n reason = "\2";\n break;@' ++ // | sed -r 's@(0x[048C][0-9A-F]+) ([A-Z_0-9]+)@ case MD_NTSTATUS_WIN_\2:\n reason = "\2";\n break;@' + // + // With easy copy to clipboard with + // | xclip -selection c # on linux + // | clip # on windows + // | pbcopy # on mac + // + // and then the default case added. + switch (ntstatus) { ++ case MD_NTSTATUS_WIN_STATUS_SUCCESS: ++ reason = "STATUS_SUCCESS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAIT_1: ++ reason = "STATUS_WAIT_1"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAIT_2: ++ reason = "STATUS_WAIT_2"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAIT_3: ++ reason = "STATUS_WAIT_3"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAIT_63: ++ reason = "STATUS_WAIT_63"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ABANDONED: ++ reason = "STATUS_ABANDONED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_63: ++ reason = "STATUS_ABANDONED_WAIT_63"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_USER_APC: ++ reason = "STATUS_USER_APC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALREADY_COMPLETE: ++ reason = "STATUS_ALREADY_COMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_KERNEL_APC: ++ reason = "STATUS_KERNEL_APC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALERTED: ++ reason = "STATUS_ALERTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TIMEOUT: ++ reason = "STATUS_TIMEOUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PENDING: ++ reason = "STATUS_PENDING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REPARSE: ++ reason = "STATUS_REPARSE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MORE_ENTRIES: ++ reason = "STATUS_MORE_ENTRIES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_ALL_ASSIGNED: ++ reason = "STATUS_NOT_ALL_ASSIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SOME_NOT_MAPPED: ++ reason = "STATUS_SOME_NOT_MAPPED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_OPLOCK_BREAK_IN_PROGRESS: ++ reason = "STATUS_OPLOCK_BREAK_IN_PROGRESS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VOLUME_MOUNTED: ++ reason = "STATUS_VOLUME_MOUNTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RXACT_COMMITTED: ++ reason = "STATUS_RXACT_COMMITTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOTIFY_CLEANUP: ++ reason = "STATUS_NOTIFY_CLEANUP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOTIFY_ENUM_DIR: ++ reason = "STATUS_NOTIFY_ENUM_DIR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_QUOTAS_FOR_ACCOUNT: ++ reason = "STATUS_NO_QUOTAS_FOR_ACCOUNT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED: ++ reason = "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_TRANSITION: ++ reason = "STATUS_PAGE_FAULT_TRANSITION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_DEMAND_ZERO: ++ reason = "STATUS_PAGE_FAULT_DEMAND_ZERO"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_COPY_ON_WRITE: ++ reason = "STATUS_PAGE_FAULT_COPY_ON_WRITE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_GUARD_PAGE: ++ reason = "STATUS_PAGE_FAULT_GUARD_PAGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_PAGING_FILE: ++ reason = "STATUS_PAGE_FAULT_PAGING_FILE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CACHE_PAGE_LOCKED: ++ reason = "STATUS_CACHE_PAGE_LOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CRASH_DUMP: ++ reason = "STATUS_CRASH_DUMP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BUFFER_ALL_ZEROS: ++ reason = "STATUS_BUFFER_ALL_ZEROS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REPARSE_OBJECT: ++ reason = "STATUS_REPARSE_OBJECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RESOURCE_REQUIREMENTS_CHANGED: ++ reason = "STATUS_RESOURCE_REQUIREMENTS_CHANGED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TRANSLATION_COMPLETE: ++ reason = "STATUS_TRANSLATION_COMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY: ++ reason = "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOTHING_TO_TERMINATE: ++ reason = "STATUS_NOTHING_TO_TERMINATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PROCESS_NOT_IN_JOB: ++ reason = "STATUS_PROCESS_NOT_IN_JOB"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PROCESS_IN_JOB: ++ reason = "STATUS_PROCESS_IN_JOB"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VOLSNAP_HIBERNATE_READY: ++ reason = "STATUS_VOLSNAP_HIBERNATE_READY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY: ++ reason = "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED: ++ reason = "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_INTERRUPT_STILL_CONNECTED: ++ reason = "STATUS_INTERRUPT_STILL_CONNECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PROCESS_CLONED: ++ reason = "STATUS_PROCESS_CLONED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_ONLY_READERS: ++ reason = "STATUS_FILE_LOCKED_WITH_ONLY_READERS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_WRITERS: ++ reason = "STATUS_FILE_LOCKED_WITH_WRITERS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VALID_IMAGE_HASH: ++ reason = "STATUS_VALID_IMAGE_HASH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VALID_CATALOG_HASH: ++ reason = "STATUS_VALID_CATALOG_HASH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VALID_STRONG_CODE_HASH: ++ reason = "STATUS_VALID_STRONG_CODE_HASH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GHOSTED: ++ reason = "STATUS_GHOSTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DATA_OVERWRITTEN: ++ reason = "STATUS_DATA_OVERWRITTEN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_READ_ONLY: ++ reason = "STATUS_RESOURCEMANAGER_READ_ONLY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_EMPTY: ++ reason = "STATUS_RING_PREVIOUSLY_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_FULL: ++ reason = "STATUS_RING_PREVIOUSLY_FULL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_ABOVE_QUOTA: ++ reason = "STATUS_RING_PREVIOUSLY_ABOVE_QUOTA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RING_NEWLY_EMPTY: ++ reason = "STATUS_RING_NEWLY_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT: ++ reason = "STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE: ++ reason = "STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_OPLOCK_HANDLE_CLOSED: ++ reason = "STATUS_OPLOCK_HANDLE_CLOSED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAIT_FOR_OPLOCK: ++ reason = "STATUS_WAIT_FOR_OPLOCK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REPARSE_GLOBAL: ++ reason = "STATUS_REPARSE_GLOBAL"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_EXCEPTION_HANDLED: ++ reason = "DBG_EXCEPTION_HANDLED"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_CONTINUE: ++ reason = "DBG_CONTINUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FLT_IO_COMPLETE: ++ reason = "STATUS_FLT_IO_COMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_CONTINUE: ++ reason = "STATUS_RTPM_CONTEXT_CONTINUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_COMPLETE: ++ reason = "STATUS_RTPM_CONTEXT_COMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_PENDING_PAGE_REQUESTS: ++ reason = "STATUS_HV_PENDING_PAGE_REQUESTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_REPAIRED: ++ reason = "STATUS_SPACES_REPAIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_PAUSE: ++ reason = "STATUS_SPACES_PAUSE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_COMPLETE: ++ reason = "STATUS_SPACES_COMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_REDIRECT: ++ reason = "STATUS_SPACES_REDIRECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_EXISTS: ++ reason = "STATUS_OBJECT_NAME_EXISTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_THREAD_WAS_SUSPENDED: ++ reason = "STATUS_THREAD_WAS_SUSPENDED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WORKING_SET_LIMIT_RANGE: ++ reason = "STATUS_WORKING_SET_LIMIT_RANGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IMAGE_NOT_AT_BASE: ++ reason = "STATUS_IMAGE_NOT_AT_BASE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RXACT_STATE_CREATED: ++ reason = "STATUS_RXACT_STATE_CREATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SEGMENT_NOTIFICATION: ++ reason = "STATUS_SEGMENT_NOTIFICATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_LOCAL_USER_SESSION_KEY: ++ reason = "STATUS_LOCAL_USER_SESSION_KEY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BAD_CURRENT_DIRECTORY: ++ reason = "STATUS_BAD_CURRENT_DIRECTORY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SERIAL_MORE_WRITES: ++ reason = "STATUS_SERIAL_MORE_WRITES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REGISTRY_RECOVERED: ++ reason = "STATUS_REGISTRY_RECOVERED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FT_READ_RECOVERY_FROM_BACKUP: ++ reason = "STATUS_FT_READ_RECOVERY_FROM_BACKUP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FT_WRITE_RECOVERY: ++ reason = "STATUS_FT_WRITE_RECOVERY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SERIAL_COUNTER_TIMEOUT: ++ reason = "STATUS_SERIAL_COUNTER_TIMEOUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NULL_LM_PASSWORD: ++ reason = "STATUS_NULL_LM_PASSWORD"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH: ++ reason = "STATUS_IMAGE_MACHINE_TYPE_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL: ++ reason = "STATUS_RECEIVE_PARTIAL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RECEIVE_EXPEDITED: ++ reason = "STATUS_RECEIVE_EXPEDITED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL_EXPEDITED: ++ reason = "STATUS_RECEIVE_PARTIAL_EXPEDITED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EVENT_DONE: ++ reason = "STATUS_EVENT_DONE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EVENT_PENDING: ++ reason = "STATUS_EVENT_PENDING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CHECKING_FILE_SYSTEM: ++ reason = "STATUS_CHECKING_FILE_SYSTEM"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FATAL_APP_EXIT: ++ reason = "STATUS_FATAL_APP_EXIT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PREDEFINED_HANDLE: ++ reason = "STATUS_PREDEFINED_HANDLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAS_UNLOCKED: ++ reason = "STATUS_WAS_UNLOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SERVICE_NOTIFICATION: ++ reason = "STATUS_SERVICE_NOTIFICATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAS_LOCKED: ++ reason = "STATUS_WAS_LOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_LOG_HARD_ERROR: ++ reason = "STATUS_LOG_HARD_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALREADY_WIN32: ++ reason = "STATUS_ALREADY_WIN32"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_UNSIMULATE: ++ reason = "STATUS_WX86_UNSIMULATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_CONTINUE: ++ reason = "STATUS_WX86_CONTINUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_SINGLE_STEP: ++ reason = "STATUS_WX86_SINGLE_STEP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_BREAKPOINT: ++ reason = "STATUS_WX86_BREAKPOINT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CONTINUE: ++ reason = "STATUS_WX86_EXCEPTION_CONTINUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_LASTCHANCE: ++ reason = "STATUS_WX86_EXCEPTION_LASTCHANCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CHAIN: ++ reason = "STATUS_WX86_EXCEPTION_CHAIN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE: ++ reason = "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_YIELD_PERFORMED: ++ reason = "STATUS_NO_YIELD_PERFORMED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TIMER_RESUME_IGNORED: ++ reason = "STATUS_TIMER_RESUME_IGNORED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ARBITRATION_UNHANDLED: ++ reason = "STATUS_ARBITRATION_UNHANDLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CARDBUS_NOT_SUPPORTED: ++ reason = "STATUS_CARDBUS_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WX86_CREATEWX86TIB: ++ reason = "STATUS_WX86_CREATEWX86TIB"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MP_PROCESSOR_MISMATCH: ++ reason = "STATUS_MP_PROCESSOR_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HIBERNATED: ++ reason = "STATUS_HIBERNATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RESUME_HIBERNATION: ++ reason = "STATUS_RESUME_HIBERNATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FIRMWARE_UPDATED: ++ reason = "STATUS_FIRMWARE_UPDATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DRIVERS_LEAKING_LOCKED_PAGES: ++ reason = "STATUS_DRIVERS_LEAKING_LOCKED_PAGES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MESSAGE_RETRIEVED: ++ reason = "STATUS_MESSAGE_RETRIEVED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_TRANSITION: ++ reason = "STATUS_SYSTEM_POWERSTATE_TRANSITION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALPC_CHECK_COMPLETION_LIST: ++ reason = "STATUS_ALPC_CHECK_COMPLETION_LIST"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION: ++ reason = "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ACCESS_AUDIT_BY_POLICY: ++ reason = "STATUS_ACCESS_AUDIT_BY_POLICY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ABANDON_HIBERFILE: ++ reason = "STATUS_ABANDON_HIBERFILE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BIZRULES_NOT_ENABLED: ++ reason = "STATUS_BIZRULES_NOT_ENABLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FT_READ_FROM_COPY: ++ reason = "STATUS_FT_READ_FROM_COPY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IMAGE_AT_DIFFERENT_BASE: ++ reason = "STATUS_IMAGE_AT_DIFFERENT_BASE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PATCH_DEFERRED: ++ reason = "STATUS_PATCH_DEFERRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM: ++ reason = "STATUS_WAKE_SYSTEM"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DS_SHUTTING_DOWN: ++ reason = "STATUS_DS_SHUTTING_DOWN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_REDIRECTED: ++ reason = "STATUS_DISK_REPAIR_REDIRECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SERVICES_FAILED_AUTOSTART: ++ reason = "STATUS_SERVICES_FAILED_AUTOSTART"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_REPLY_LATER: ++ reason = "DBG_REPLY_LATER"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE: ++ reason = "DBG_UNABLE_TO_PROVIDE_HANDLE"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_TERMINATE_THREAD: ++ reason = "DBG_TERMINATE_THREAD"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_TERMINATE_PROCESS: ++ reason = "DBG_TERMINATE_PROCESS"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_CONTROL_C: ++ reason = "DBG_CONTROL_C"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_C: ++ reason = "DBG_PRINTEXCEPTION_C"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_RIPEXCEPTION: ++ reason = "DBG_RIPEXCEPTION"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_CONTROL_BREAK: ++ reason = "DBG_CONTROL_BREAK"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_COMMAND_EXCEPTION: ++ reason = "DBG_COMMAND_EXCEPTION"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_WIDE_C: ++ reason = "DBG_PRINTEXCEPTION_WIDE_C"; ++ break; ++ case MD_NTSTATUS_WIN_RPC_NT_UUID_LOCAL_ONLY: ++ reason = "RPC_NT_UUID_LOCAL_ONLY"; ++ break; ++ case MD_NTSTATUS_WIN_RPC_NT_SEND_INCOMPLETE: ++ reason = "RPC_NT_SEND_INCOMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CTX_CDM_CONNECT: ++ reason = "STATUS_CTX_CDM_CONNECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CTX_CDM_DISCONNECT: ++ reason = "STATUS_CTX_CDM_DISCONNECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT: ++ reason = "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HEURISTIC_DAMAGE_POSSIBLE: ++ reason = "STATUS_HEURISTIC_DAMAGE_POSSIBLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RECOVERY_NOT_NEEDED: ++ reason = "STATUS_RECOVERY_NOT_NEEDED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RM_ALREADY_STARTED: ++ reason = "STATUS_RM_ALREADY_STARTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_LOG_NO_RESTART: ++ reason = "STATUS_LOG_NO_RESTART"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST: ++ reason = "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED: ++ reason = "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION: ++ reason = "STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_PINNED: ++ reason = "STATUS_GRAPHICS_MODE_NOT_PINNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_PREFERRED_MODE: ++ reason = "STATUS_GRAPHICS_NO_PREFERRED_MODE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DATASET_IS_EMPTY: ++ reason = "STATUS_GRAPHICS_DATASET_IS_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET: ++ reason = "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED: ++ reason = "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS: ++ reason = "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_START_DEFERRED: ++ reason = "STATUS_GRAPHICS_LEADLINK_START_DEFERRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY: ++ reason = "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_START_DEFERRED: ++ reason = "STATUS_GRAPHICS_START_DEFERRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS: ++ reason = "STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_INDICATION_REQUIRED: ++ reason = "STATUS_NDIS_INDICATION_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_UNSUPPORTED_PSS_SALT: ++ reason = "STATUS_PCP_UNSUPPORTED_PSS_SALT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GUARD_PAGE_VIOLATION: ++ reason = "STATUS_GUARD_PAGE_VIOLATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT: ++ reason = "STATUS_DATATYPE_MISALIGNMENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BREAKPOINT: ++ reason = "STATUS_BREAKPOINT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SINGLE_STEP: ++ reason = "STATUS_SINGLE_STEP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BUFFER_OVERFLOW: ++ reason = "STATUS_BUFFER_OVERFLOW"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_MORE_FILES: ++ reason = "STATUS_NO_MORE_FILES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM_DEBUGGER: ++ reason = "STATUS_WAKE_SYSTEM_DEBUGGER"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HANDLES_CLOSED: ++ reason = "STATUS_HANDLES_CLOSED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_INHERITANCE: ++ reason = "STATUS_NO_INHERITANCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GUID_SUBSTITUTION_MADE: ++ reason = "STATUS_GUID_SUBSTITUTION_MADE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PARTIAL_COPY: ++ reason = "STATUS_PARTIAL_COPY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_PAPER_EMPTY: ++ reason = "STATUS_DEVICE_PAPER_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_POWERED_OFF: ++ reason = "STATUS_DEVICE_POWERED_OFF"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_OFF_LINE: ++ reason = "STATUS_DEVICE_OFF_LINE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_BUSY: ++ reason = "STATUS_DEVICE_BUSY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_MORE_EAS: ++ reason = "STATUS_NO_MORE_EAS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_INVALID_EA_NAME: ++ reason = "STATUS_INVALID_EA_NAME"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EA_LIST_INCONSISTENT: ++ reason = "STATUS_EA_LIST_INCONSISTENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_INVALID_EA_FLAG: ++ reason = "STATUS_INVALID_EA_FLAG"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VERIFY_REQUIRED: ++ reason = "STATUS_VERIFY_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EXTRANEOUS_INFORMATION: ++ reason = "STATUS_EXTRANEOUS_INFORMATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_NECESSARY: ++ reason = "STATUS_RXACT_COMMIT_NECESSARY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_MORE_ENTRIES: ++ reason = "STATUS_NO_MORE_ENTRIES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILEMARK_DETECTED: ++ reason = "STATUS_FILEMARK_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MEDIA_CHANGED: ++ reason = "STATUS_MEDIA_CHANGED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BUS_RESET: ++ reason = "STATUS_BUS_RESET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_END_OF_MEDIA: ++ reason = "STATUS_END_OF_MEDIA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BEGINNING_OF_MEDIA: ++ reason = "STATUS_BEGINNING_OF_MEDIA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MEDIA_CHECK: ++ reason = "STATUS_MEDIA_CHECK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SETMARK_DETECTED: ++ reason = "STATUS_SETMARK_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_DATA_DETECTED: ++ reason = "STATUS_NO_DATA_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REDIRECTOR_HAS_OPEN_HANDLES: ++ reason = "STATUS_REDIRECTOR_HAS_OPEN_HANDLES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SERVER_HAS_OPEN_HANDLES: ++ reason = "STATUS_SERVER_HAS_OPEN_HANDLES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALREADY_DISCONNECTED: ++ reason = "STATUS_ALREADY_DISCONNECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_LONGJUMP: ++ reason = "STATUS_LONGJUMP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLEANER_CARTRIDGE_INSTALLED: ++ reason = "STATUS_CLEANER_CARTRIDGE_INSTALLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLUGPLAY_QUERY_VETOED: ++ reason = "STATUS_PLUGPLAY_QUERY_VETOED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_UNWIND_CONSOLIDATE: ++ reason = "STATUS_UNWIND_CONSOLIDATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REGISTRY_HIVE_RECOVERED: ++ reason = "STATUS_REGISTRY_HIVE_RECOVERED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INSECURE: ++ reason = "STATUS_DLL_MIGHT_BE_INSECURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INCOMPATIBLE: ++ reason = "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STOPPED_ON_SYMLINK: ++ reason = "STATUS_STOPPED_ON_SYMLINK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK: ++ reason = "STATUS_CANNOT_GRANT_REQUESTED_OPLOCK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_ACE_CONDITION: ++ reason = "STATUS_NO_ACE_CONDITION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_SUPPORT_IN_PROGRESS: ++ reason = "STATUS_DEVICE_SUPPORT_IN_PROGRESS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_CYCLE_REQUIRED: ++ reason = "STATUS_DEVICE_POWER_CYCLE_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_WORK_DONE: ++ reason = "STATUS_NO_WORK_DONE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT: ++ reason = "STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_REQUIRES_CLEANING: ++ reason = "STATUS_DEVICE_REQUIRES_CLEANING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_DOOR_OPEN: ++ reason = "STATUS_DEVICE_DOOR_OPEN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DATA_LOST_REPAIR: ++ reason = "STATUS_DATA_LOST_REPAIR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED: ++ reason = "STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH: ++ reason = "STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE: ++ reason = "STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS: ++ reason = "STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS"; ++ break; ++ case MD_NTSTATUS_WIN_DBG_EXCEPTION_NOT_HANDLED: ++ reason = "DBG_EXCEPTION_NOT_HANDLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_UP: ++ reason = "STATUS_CLUSTER_NODE_ALREADY_UP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_DOWN: ++ reason = "STATUS_CLUSTER_NODE_ALREADY_DOWN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE: ++ reason = "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE: ++ reason = "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_MEMBER: ++ reason = "STATUS_CLUSTER_NODE_ALREADY_MEMBER"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_COULD_NOT_RESIZE_LOG: ++ reason = "STATUS_COULD_NOT_RESIZE_LOG"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_TXF_METADATA: ++ reason = "STATUS_NO_TXF_METADATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN: ++ reason = "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TXF_METADATA_ALREADY_PRESENT: ++ reason = "STATUS_TXF_METADATA_ALREADY_PRESENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET: ++ reason = "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED: ++ reason = "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FLT_BUFFER_TOO_SMALL: ++ reason = "STATUS_FLT_BUFFER_TOO_SMALL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FVE_PARTIAL_METADATA: ++ reason = "STATUS_FVE_PARTIAL_METADATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FVE_TRANSIENT_STATE: ++ reason = "STATUS_FVE_TRANSIENT_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED: ++ reason = "STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_REGENERATION: ++ reason = "STATUS_VOLMGR_INCOMPLETE_REGENERATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION: ++ reason = "STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED: ++ reason = "STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED: ++ reason = "STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_QUERY_STORAGE_ERROR: ++ reason = "STATUS_QUERY_STORAGE_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GDI_HANDLE_LEAK: ++ reason = "STATUS_GDI_HANDLE_LEAK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_ENABLED: ++ reason = "STATUS_SECUREBOOT_NOT_ENABLED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_UNSUCCESSFUL: + reason = "STATUS_UNSUCCESSFUL"; + break; + case MD_NTSTATUS_WIN_STATUS_NOT_IMPLEMENTED: + reason = "STATUS_NOT_IMPLEMENTED"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_INFO_CLASS: + reason = "STATUS_INVALID_INFO_CLASS"; +@@ -213,16 +943,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_OBJECT_NAME_INVALID"; + break; + case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_NOT_FOUND: + reason = "STATUS_OBJECT_NAME_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_COLLISION: + reason = "STATUS_OBJECT_NAME_COLLISION"; + break; ++ case MD_NTSTATUS_WIN_STATUS_PORT_DO_NOT_DISTURB: ++ reason = "STATUS_PORT_DO_NOT_DISTURB"; ++ break; + case MD_NTSTATUS_WIN_STATUS_PORT_DISCONNECTED: + reason = "STATUS_PORT_DISCONNECTED"; + break; + case MD_NTSTATUS_WIN_STATUS_DEVICE_ALREADY_ATTACHED: + reason = "STATUS_DEVICE_ALREADY_ATTACHED"; + break; + case MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_INVALID: + reason = "STATUS_OBJECT_PATH_INVALID"; +@@ -1317,16 +2050,40 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_REPAIR_NEEDED"; + break; + case MD_NTSTATUS_WIN_STATUS_QUOTA_NOT_ENABLED: + reason = "STATUS_QUOTA_NOT_ENABLED"; + break; + case MD_NTSTATUS_WIN_STATUS_NO_APPLICATION_PACKAGE: + reason = "STATUS_NO_APPLICATION_PACKAGE"; + break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS: ++ reason = "STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_SAME_OBJECT: ++ reason = "STATUS_NOT_SAME_OBJECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FATAL_MEMORY_EXHAUSTION: ++ reason = "STATUS_FATAL_MEMORY_EXHAUSTION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ERROR_PROCESS_NOT_IN_JOB: ++ reason = "STATUS_ERROR_PROCESS_NOT_IN_JOB"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CPU_SET_INVALID: ++ reason = "STATUS_CPU_SET_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IO_DEVICE_INVALID_DATA: ++ reason = "STATUS_IO_DEVICE_INVALID_DATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_IO_UNALIGNED_WRITE: ++ reason = "STATUS_IO_UNALIGNED_WRITE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CONTROL_STACK_VIOLATION: ++ reason = "STATUS_CONTROL_STACK_VIOLATION"; ++ break; + case MD_NTSTATUS_WIN_STATUS_NETWORK_OPEN_RESTRICTION: + reason = "STATUS_NETWORK_OPEN_RESTRICTION"; + break; + case MD_NTSTATUS_WIN_STATUS_NO_USER_SESSION_KEY: + reason = "STATUS_NO_USER_SESSION_KEY"; + break; + case MD_NTSTATUS_WIN_STATUS_USER_SESSION_DELETED: + reason = "STATUS_USER_SESSION_DELETED"; +@@ -1662,16 +2419,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_IO_REPARSE_TAG_NOT_HANDLED"; + break; + case MD_NTSTATUS_WIN_STATUS_PWD_TOO_LONG: + reason = "STATUS_PWD_TOO_LONG"; + break; + case MD_NTSTATUS_WIN_STATUS_STOWED_EXCEPTION: + reason = "STATUS_STOWED_EXCEPTION"; + break; ++ case MD_NTSTATUS_WIN_STATUS_CONTEXT_STOWED_EXCEPTION: ++ reason = "STATUS_CONTEXT_STOWED_EXCEPTION"; ++ break; + case MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_NOT_RESOLVED: + reason = "STATUS_REPARSE_POINT_NOT_RESOLVED"; + break; + case MD_NTSTATUS_WIN_STATUS_DIRECTORY_IS_A_REPARSE_POINT: + reason = "STATUS_DIRECTORY_IS_A_REPARSE_POINT"; + break; + case MD_NTSTATUS_WIN_STATUS_RANGE_LIST_CONFLICT: + reason = "STATUS_RANGE_LIST_CONFLICT"; +@@ -2058,16 +2818,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_CSS_REGION_MISMATCH"; + break; + case MD_NTSTATUS_WIN_STATUS_CSS_RESETS_EXHAUSTED: + reason = "STATUS_CSS_RESETS_EXHAUSTED"; + break; + case MD_NTSTATUS_WIN_STATUS_PASSWORD_CHANGE_REQUIRED: + reason = "STATUS_PASSWORD_CHANGE_REQUIRED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_LOST_MODE_LOGON_RESTRICTION: ++ reason = "STATUS_LOST_MODE_LOGON_RESTRICTION"; ++ break; + case MD_NTSTATUS_WIN_STATUS_PKINIT_FAILURE: + reason = "STATUS_PKINIT_FAILURE"; + break; + case MD_NTSTATUS_WIN_STATUS_SMARTCARD_SUBSYSTEM_FAILURE: + reason = "STATUS_SMARTCARD_SUBSYSTEM_FAILURE"; + break; + case MD_NTSTATUS_WIN_STATUS_NO_KERB_KEY: + reason = "STATUS_NO_KERB_KEY"; +@@ -2454,16 +3217,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_FT_DI_SCAN_REQUIRED"; + break; + case MD_NTSTATUS_WIN_STATUS_OBJECT_NOT_EXTERNALLY_BACKED: + reason = "STATUS_OBJECT_NOT_EXTERNALLY_BACKED"; + break; + case MD_NTSTATUS_WIN_STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN: + reason = "STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN"; + break; ++ case MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_BENEFICIAL: ++ reason = "STATUS_COMPRESSION_NOT_BENEFICIAL"; ++ break; + case MD_NTSTATUS_WIN_STATUS_DATA_CHECKSUM_ERROR: + reason = "STATUS_DATA_CHECKSUM_ERROR"; + break; + case MD_NTSTATUS_WIN_STATUS_INTERMIXED_KERNEL_EA_OPERATION: + reason = "STATUS_INTERMIXED_KERNEL_EA_OPERATION"; + break; + case MD_NTSTATUS_WIN_STATUS_TRIM_READ_ZERO_NOT_SUPPORTED: + reason = "STATUS_TRIM_READ_ZERO_NOT_SUPPORTED"; +@@ -2514,16 +3280,181 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_APISET_NOT_HOSTED"; + break; + case MD_NTSTATUS_WIN_STATUS_APISET_NOT_PRESENT: + reason = "STATUS_APISET_NOT_PRESENT"; + break; + case MD_NTSTATUS_WIN_STATUS_DEVICE_HARDWARE_ERROR: + reason = "STATUS_DEVICE_HARDWARE_ERROR"; + break; ++ case MD_NTSTATUS_WIN_STATUS_FIRMWARE_SLOT_INVALID: ++ reason = "STATUS_FIRMWARE_SLOT_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FIRMWARE_IMAGE_INVALID: ++ reason = "STATUS_FIRMWARE_IMAGE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_TOPOLOGY_ID_MISMATCH: ++ reason = "STATUS_STORAGE_TOPOLOGY_ID_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WIM_NOT_BOOTABLE: ++ reason = "STATUS_WIM_NOT_BOOTABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BLOCKED_BY_PARENTAL_CONTROLS: ++ reason = "STATUS_BLOCKED_BY_PARENTAL_CONTROLS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NEEDS_REGISTRATION: ++ reason = "STATUS_NEEDS_REGISTRATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_QUOTA_ACTIVITY: ++ reason = "STATUS_QUOTA_ACTIVITY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CALLBACK_INVOKE_INLINE: ++ reason = "STATUS_CALLBACK_INVOKE_INLINE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_BLOCK_TOO_MANY_REFERENCES: ++ reason = "STATUS_BLOCK_TOO_MANY_REFERENCES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_MARKED_TO_DISALLOW_WRITES: ++ reason = "STATUS_MARKED_TO_DISALLOW_WRITES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED_EDP: ++ reason = "STATUS_NETWORK_ACCESS_DENIED_EDP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCLAVE_FAILURE: ++ reason = "STATUS_ENCLAVE_FAILURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_NO_COMPAT_DRIVERS: ++ reason = "STATUS_PNP_NO_COMPAT_DRIVERS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND: ++ reason = "STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND: ++ reason = "STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE: ++ reason = "STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_FUNCTION_DRIVER_REQUIRED: ++ reason = "STATUS_PNP_FUNCTION_DRIVER_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PNP_DEVICE_CONFIGURATION_PENDING: ++ reason = "STATUS_PNP_DEVICE_CONFIGURATION_PENDING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL: ++ reason = "STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PACKAGE_NOT_AVAILABLE: ++ reason = "STATUS_PACKAGE_NOT_AVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_IN_MAINTENANCE: ++ reason = "STATUS_DEVICE_IN_MAINTENANCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_DAX: ++ reason = "STATUS_NOT_SUPPORTED_ON_DAX"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FREE_SPACE_TOO_FRAGMENTED: ++ reason = "STATUS_FREE_SPACE_TOO_FRAGMENTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DAX_MAPPING_EXISTS: ++ reason = "STATUS_DAX_MAPPING_EXISTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CHILD_PROCESS_BLOCKED: ++ reason = "STATUS_CHILD_PROCESS_BLOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_LOST_DATA_PERSISTENCE: ++ reason = "STATUS_STORAGE_LOST_DATA_PERSISTENCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VRF_CFG_AND_IO_ENABLED: ++ reason = "STATUS_VRF_CFG_AND_IO_ENABLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PARTITION_TERMINATING: ++ reason = "STATUS_PARTITION_TERMINATING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED: ++ reason = "STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCLAVE_VIOLATION: ++ reason = "STATUS_ENCLAVE_VIOLATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_PROTECTED_UNDER_DPL: ++ reason = "STATUS_FILE_PROTECTED_UNDER_DPL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_CLUSTER_ALIGNED: ++ reason = "STATUS_VOLUME_NOT_CLUSTER_ALIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND: ++ reason = "STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPX_FILE_NOT_ENCRYPTED: ++ reason = "STATUS_APPX_FILE_NOT_ENCRYPTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED: ++ reason = "STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET: ++ reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE: ++ reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER: ++ reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FT_READ_FAILURE: ++ reason = "STATUS_FT_READ_FAILURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PATCH_CONFLICT: ++ reason = "STATUS_PATCH_CONFLICT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ID_INVALID: ++ reason = "STATUS_STORAGE_RESERVE_ID_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_DOES_NOT_EXIST: ++ reason = "STATUS_STORAGE_RESERVE_DOES_NOT_EXIST"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ALREADY_EXISTS: ++ reason = "STATUS_STORAGE_RESERVE_ALREADY_EXISTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_NOT_EMPTY: ++ reason = "STATUS_STORAGE_RESERVE_NOT_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_A_DAX_VOLUME: ++ reason = "STATUS_NOT_A_DAX_VOLUME"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_DAX_MAPPABLE: ++ reason = "STATUS_NOT_DAX_MAPPABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CASE_DIFFERING_NAMES_IN_DIR: ++ reason = "STATUS_CASE_DIFFERING_NAMES_IN_DIR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_NOT_SUPPORTED: ++ reason = "STATUS_FILE_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_WITH_BTT: ++ reason = "STATUS_NOT_SUPPORTED_WITH_BTT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCRYPTION_DISABLED: ++ reason = "STATUS_ENCRYPTION_DISABLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCRYPTING_METADATA_DISALLOWED: ++ reason = "STATUS_ENCRYPTING_METADATA_DISALLOWED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CANT_CLEAR_ENCRYPTION_FLAG: ++ reason = "STATUS_CANT_CLEAR_ENCRYPTION_FLAG"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_UNSATISFIED_DEPENDENCIES: ++ reason = "STATUS_UNSATISFIED_DEPENDENCIES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CASE_SENSITIVE_PATH: ++ reason = "STATUS_CASE_SENSITIVE_PATH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HAS_SYSTEM_CRITICAL_FILES: ++ reason = "STATUS_HAS_SYSTEM_CRITICAL_FILES"; ++ break; + case MD_NTSTATUS_WIN_STATUS_INVALID_TASK_NAME: + reason = "STATUS_INVALID_TASK_NAME"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_TASK_INDEX: + reason = "STATUS_INVALID_TASK_INDEX"; + break; + case MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_TASK: + reason = "STATUS_THREAD_ALREADY_IN_TASK"; +@@ -2535,25 +3466,85 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_UNDEFINED_SCOPE"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_CAP: + reason = "STATUS_INVALID_CAP"; + break; + case MD_NTSTATUS_WIN_STATUS_NOT_GUI_PROCESS: + reason = "STATUS_NOT_GUI_PROCESS"; + break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_HUNG: ++ reason = "STATUS_DEVICE_HUNG"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CONTAINER_ASSIGNED: ++ reason = "STATUS_CONTAINER_ASSIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_JOB_NO_CONTAINER: ++ reason = "STATUS_JOB_NO_CONTAINER"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_DEVICE_UNRESPONSIVE: ++ reason = "STATUS_DEVICE_UNRESPONSIVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_ENCOUNTERED: ++ reason = "STATUS_REPARSE_POINT_ENCOUNTERED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ATTRIBUTE_NOT_PRESENT: ++ reason = "STATUS_ATTRIBUTE_NOT_PRESENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_A_TIERED_VOLUME: ++ reason = "STATUS_NOT_A_TIERED_VOLUME"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALREADY_HAS_STREAM_ID: ++ reason = "STATUS_ALREADY_HAS_STREAM_ID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_JOB_NOT_EMPTY: ++ reason = "STATUS_JOB_NOT_EMPTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ALREADY_INITIALIZED: ++ reason = "STATUS_ALREADY_INITIALIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCLAVE_NOT_TERMINATED: ++ reason = "STATUS_ENCLAVE_NOT_TERMINATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ENCLAVE_IS_TERMINATING: ++ reason = "STATUS_ENCLAVE_IS_TERMINATING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SMB1_NOT_AVAILABLE: ++ reason = "STATUS_SMB1_NOT_AVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SMR_GARBAGE_COLLECTION_REQUIRED: ++ reason = "STATUS_SMR_GARBAGE_COLLECTION_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_INTERRUPTED: ++ reason = "STATUS_INTERRUPTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_THREAD_NOT_RUNNING: ++ reason = "STATUS_THREAD_NOT_RUNNING"; ++ break; + case MD_NTSTATUS_WIN_STATUS_FAIL_FAST_EXCEPTION: + reason = "STATUS_FAIL_FAST_EXCEPTION"; + break; + case MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_REVOKED: + reason = "STATUS_IMAGE_CERT_REVOKED"; + break; + case MD_NTSTATUS_WIN_STATUS_DYNAMIC_CODE_BLOCKED: + reason = "STATUS_DYNAMIC_CODE_BLOCKED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_EXPIRED: ++ reason = "STATUS_IMAGE_CERT_EXPIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_STRICT_CFG_VIOLATION: ++ reason = "STATUS_STRICT_CFG_VIOLATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SET_CONTEXT_DENIED: ++ reason = "STATUS_SET_CONTEXT_DENIED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CROSS_PARTITION_VIOLATION: ++ reason = "STATUS_CROSS_PARTITION_VIOLATION"; ++ break; + case MD_NTSTATUS_WIN_STATUS_PORT_CLOSED: + reason = "STATUS_PORT_CLOSED"; + break; + case MD_NTSTATUS_WIN_STATUS_MESSAGE_LOST: + reason = "STATUS_MESSAGE_LOST"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_MESSAGE: + reason = "STATUS_INVALID_MESSAGE"; +@@ -2646,16 +3637,31 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_CALLBACK_RETURNED_LANG"; + break; + case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_PRI_BACK: + reason = "STATUS_CALLBACK_RETURNED_PRI_BACK"; + break; + case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY: + reason = "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY"; + break; ++ case MD_NTSTATUS_WIN_STATUS_LPC_HANDLE_COUNT_EXCEEDED: ++ reason = "STATUS_LPC_HANDLE_COUNT_EXCEEDED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EXECUTABLE_MEMORY_WRITE: ++ reason = "STATUS_EXECUTABLE_MEMORY_WRITE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE: ++ reason = "STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE: ++ reason = "STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE: ++ reason = "STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_DISABLED: + reason = "STATUS_DISK_REPAIR_DISABLED"; + break; + case MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS: + reason = "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS"; + break; + case MD_NTSTATUS_WIN_STATUS_DISK_QUOTA_EXCEEDED: + reason = "STATUS_DISK_QUOTA_EXCEEDED"; +@@ -2754,16 +3760,25 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_INVALID_STATE_TRANSITION"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_KERNEL_INFO_VERSION: + reason = "STATUS_INVALID_KERNEL_INFO_VERSION"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_PEP_INFO_VERSION: + reason = "STATUS_INVALID_PEP_INFO_VERSION"; + break; ++ case MD_NTSTATUS_WIN_STATUS_HANDLE_REVOKED: ++ reason = "STATUS_HANDLE_REVOKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_EOF_ON_GHOSTED_RANGE: ++ reason = "STATUS_EOF_ON_GHOSTED_RANGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN: ++ reason = "STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN"; ++ break; + case MD_NTSTATUS_WIN_STATUS_IPSEC_QUEUE_OVERFLOW: + reason = "STATUS_IPSEC_QUEUE_OVERFLOW"; + break; + case MD_NTSTATUS_WIN_STATUS_ND_QUEUE_OVERFLOW: + reason = "STATUS_ND_QUEUE_OVERFLOW"; + break; + case MD_NTSTATUS_WIN_STATUS_HOPLIMIT_EXCEEDED: + reason = "STATUS_HOPLIMIT_EXCEEDED"; +@@ -2847,16 +3862,22 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_NOT_APPCONTAINER"; + break; + case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_IN_APPCONTAINER: + reason = "STATUS_NOT_SUPPORTED_IN_APPCONTAINER"; + break; + case MD_NTSTATUS_WIN_STATUS_INVALID_PACKAGE_SID_LENGTH: + reason = "STATUS_INVALID_PACKAGE_SID_LENGTH"; + break; ++ case MD_NTSTATUS_WIN_STATUS_LPAC_ACCESS_DENIED: ++ reason = "STATUS_LPAC_ACCESS_DENIED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_ADMINLESS_ACCESS_DENIED: ++ reason = "STATUS_ADMINLESS_ACCESS_DENIED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_APP_DATA_NOT_FOUND: + reason = "STATUS_APP_DATA_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_APP_DATA_EXPIRED: + reason = "STATUS_APP_DATA_EXPIRED"; + break; + case MD_NTSTATUS_WIN_STATUS_APP_DATA_CORRUPT: + reason = "STATUS_APP_DATA_CORRUPT"; +@@ -2874,16 +3895,151 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED"; + break; + case MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED: + reason = "STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED"; + break; + case MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED: + reason = "STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_WOF_WIM_HEADER_CORRUPT: ++ reason = "STATUS_WOF_WIM_HEADER_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT: ++ reason = "STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT: ++ reason = "STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CIMFS_IMAGE_CORRUPT: ++ reason = "STATUS_CIMFS_IMAGE_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE: ++ reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT: ++ reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY: ++ reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN: ++ reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION: ++ reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT: ++ reason = "STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING: ++ reason = "STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_CORRUPT: ++ reason = "STATUS_CLOUD_FILE_METADATA_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_TOO_LARGE: ++ reason = "STATUS_CLOUD_FILE_METADATA_TOO_LARGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED: ++ reason = "STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_FILE: ++ reason = "STATUS_NOT_A_CLOUD_FILE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_IN_SYNC: ++ reason = "STATUS_CLOUD_FILE_NOT_IN_SYNC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ALREADY_CONNECTED: ++ reason = "STATUS_CLOUD_FILE_ALREADY_CONNECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_SUPPORTED: ++ reason = "STATUS_CLOUD_FILE_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INVALID_REQUEST: ++ reason = "STATUS_CLOUD_FILE_INVALID_REQUEST"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_READ_ONLY_VOLUME: ++ reason = "STATUS_CLOUD_FILE_READ_ONLY_VOLUME"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY: ++ reason = "STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_VALIDATION_FAILED: ++ reason = "STATUS_CLOUD_FILE_VALIDATION_FAILED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_AUTHENTICATION_FAILED: ++ reason = "STATUS_CLOUD_FILE_AUTHENTICATION_FAILED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES: ++ reason = "STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE: ++ reason = "STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_UNSUCCESSFUL: ++ reason = "STATUS_CLOUD_FILE_UNSUCCESSFUL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT: ++ reason = "STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_IN_USE: ++ reason = "STATUS_CLOUD_FILE_IN_USE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PINNED: ++ reason = "STATUS_CLOUD_FILE_PINNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_ABORTED: ++ reason = "STATUS_CLOUD_FILE_REQUEST_ABORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_CORRUPT: ++ reason = "STATUS_CLOUD_FILE_PROPERTY_CORRUPT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ACCESS_DENIED: ++ reason = "STATUS_CLOUD_FILE_ACCESS_DENIED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS: ++ reason = "STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT: ++ reason = "STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_CANCELED: ++ reason = "STATUS_CLOUD_FILE_REQUEST_CANCELED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_TERMINATED: ++ reason = "STATUS_CLOUD_FILE_PROVIDER_TERMINATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_SYNC_ROOT: ++ reason = "STATUS_NOT_A_CLOUD_SYNC_ROOT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_TIMEOUT: ++ reason = "STATUS_CLOUD_FILE_REQUEST_TIMEOUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED: ++ reason = "STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IN_PROGRESS: ++ reason = "STATUS_FILE_SNAP_IN_PROGRESS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED: ++ reason = "STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED: ++ reason = "STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IO_NOT_COORDINATED: ++ reason = "STATUS_FILE_SNAP_IO_NOT_COORDINATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_UNEXPECTED_ERROR: ++ reason = "STATUS_FILE_SNAP_UNEXPECTED_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_INVALID_PARAMETER: ++ reason = "STATUS_FILE_SNAP_INVALID_PARAMETER"; ++ break; + case MD_NTSTATUS_WIN_DBG_NO_STATE_CHANGE: + reason = "DBG_NO_STATE_CHANGE"; + break; + case MD_NTSTATUS_WIN_DBG_APP_NOT_IDLE: + reason = "DBG_APP_NOT_IDLE"; + break; + case MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_BINDING: + reason = "RPC_NT_INVALID_STRING_BINDING"; +@@ -3459,16 +4615,31 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_CLUSTER_CSV_VOLUME_DRAINING"; + break; + case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS: + reason = "STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS"; + break; + case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL: + reason = "STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL"; + break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NO_SNAPSHOTS: ++ reason = "STATUS_CLUSTER_CSV_NO_SNAPSHOTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CSV_IO_PAUSE_TIMEOUT: ++ reason = "STATUS_CSV_IO_PAUSE_TIMEOUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_INVALID_HANDLE: ++ reason = "STATUS_CLUSTER_CSV_INVALID_HANDLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR: ++ reason = "STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED: ++ reason = "STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OPCODE: + reason = "STATUS_ACPI_INVALID_OPCODE"; + break; + case MD_NTSTATUS_WIN_STATUS_ACPI_STACK_OVERFLOW: + reason = "STATUS_ACPI_STACK_OVERFLOW"; + break; + case MD_NTSTATUS_WIN_STATUS_ACPI_ASSERT_FAILED: + reason = "STATUS_ACPI_ASSERT_FAILED"; +@@ -4182,16 +5353,31 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_GRAPHICS_PRESENT_UNOCCLUDED"; + break; + case MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE: + reason = "STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE"; + break; + case MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED: + reason = "STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_INVALID_WINDOW: ++ reason = "STATUS_GRAPHICS_PRESENT_INVALID_WINDOW"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND: ++ reason = "STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VAIL_STATE_CHANGED: ++ reason = "STATUS_GRAPHICS_VAIL_STATE_CHANGED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN: ++ reason = "STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED: ++ reason = "STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDEO_MEMORY: + reason = "STATUS_GRAPHICS_NO_VIDEO_MEMORY"; + break; + case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_LOCK_MEMORY: + reason = "STATUS_GRAPHICS_CANT_LOCK_MEMORY"; + break; + case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_BUSY: + reason = "STATUS_GRAPHICS_ALLOCATION_BUSY"; +@@ -4845,16 +6031,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_FVE_NOT_DE_VOLUME"; + break; + case MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_DISABLED: + reason = "STATUS_FVE_PROTECTION_DISABLED"; + break; + case MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED: + reason = "STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_FVE_OSV_KSR_NOT_ALLOWED: ++ reason = "STATUS_FVE_OSV_KSR_NOT_ALLOWED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOT_FOUND: + reason = "STATUS_FWP_CALLOUT_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_FWP_CONDITION_NOT_FOUND: + reason = "STATUS_FWP_CONDITION_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_FWP_FILTER_NOT_FOUND: + reason = "STATUS_FWP_FILTER_NOT_FOUND"; +@@ -5166,16 +6355,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_NDIS_INVALID_PORT_STATE"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_LOW_POWER_STATE: + reason = "STATUS_NDIS_LOW_POWER_STATE"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_REINIT_REQUIRED: + reason = "STATUS_NDIS_REINIT_REQUIRED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_NO_QUEUES: ++ reason = "STATUS_NDIS_NO_QUEUES"; ++ break; + case MD_NTSTATUS_WIN_STATUS_NDIS_NOT_SUPPORTED: + reason = "STATUS_NDIS_NOT_SUPPORTED"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_POLICY: + reason = "STATUS_NDIS_OFFLOAD_POLICY"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED: + reason = "STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED"; +@@ -5193,16 +6385,34 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_NDIS_DOT11_POWER_STATE_INVALID"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL: + reason = "STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL"; + break; + case MD_NTSTATUS_WIN_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL: + reason = "STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL"; + break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE: ++ reason = "STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE: ++ reason = "STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED: ++ reason = "STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED: ++ reason = "STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_QUIC_HANDSHAKE_FAILURE: ++ reason = "STATUS_QUIC_HANDSHAKE_FAILURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_QUIC_VER_NEG_FAILURE: ++ reason = "STATUS_QUIC_VER_NEG_FAILURE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_TPM_ERROR_MASK: + reason = "STATUS_TPM_ERROR_MASK"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_AUTHFAIL: + reason = "STATUS_TPM_AUTHFAIL"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_BADINDEX: + reason = "STATUS_TPM_BADINDEX"; +@@ -5490,16 +6700,220 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_TPM_PERMANENTEK"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_BAD_SIGNATURE: + reason = "STATUS_TPM_BAD_SIGNATURE"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_NOCONTEXTSPACE: + reason = "STATUS_TPM_NOCONTEXTSPACE"; + break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ASYMMETRIC: ++ reason = "STATUS_TPM_20_E_ASYMMETRIC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ATTRIBUTES: ++ reason = "STATUS_TPM_20_E_ATTRIBUTES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HASH: ++ reason = "STATUS_TPM_20_E_HASH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_VALUE: ++ reason = "STATUS_TPM_20_E_VALUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HIERARCHY: ++ reason = "STATUS_TPM_20_E_HIERARCHY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY_SIZE: ++ reason = "STATUS_TPM_20_E_KEY_SIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_MGF: ++ reason = "STATUS_TPM_20_E_MGF"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_MODE: ++ reason = "STATUS_TPM_20_E_MODE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TYPE: ++ reason = "STATUS_TPM_20_E_TYPE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HANDLE: ++ reason = "STATUS_TPM_20_E_HANDLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KDF: ++ reason = "STATUS_TPM_20_E_KDF"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_RANGE: ++ reason = "STATUS_TPM_20_E_RANGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_FAIL: ++ reason = "STATUS_TPM_20_E_AUTH_FAIL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NONCE: ++ reason = "STATUS_TPM_20_E_NONCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PP: ++ reason = "STATUS_TPM_20_E_PP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SCHEME: ++ reason = "STATUS_TPM_20_E_SCHEME"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIZE: ++ reason = "STATUS_TPM_20_E_SIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SYMMETRIC: ++ reason = "STATUS_TPM_20_E_SYMMETRIC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TAG: ++ reason = "STATUS_TPM_20_E_TAG"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SELECTOR: ++ reason = "STATUS_TPM_20_E_SELECTOR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INSUFFICIENT: ++ reason = "STATUS_TPM_20_E_INSUFFICIENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIGNATURE: ++ reason = "STATUS_TPM_20_E_SIGNATURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY: ++ reason = "STATUS_TPM_20_E_KEY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_FAIL: ++ reason = "STATUS_TPM_20_E_POLICY_FAIL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INTEGRITY: ++ reason = "STATUS_TPM_20_E_INTEGRITY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TICKET: ++ reason = "STATUS_TPM_20_E_TICKET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_RESERVED_BITS: ++ reason = "STATUS_TPM_20_E_RESERVED_BITS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_AUTH: ++ reason = "STATUS_TPM_20_E_BAD_AUTH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXPIRED: ++ reason = "STATUS_TPM_20_E_EXPIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_CC: ++ reason = "STATUS_TPM_20_E_POLICY_CC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BINDING: ++ reason = "STATUS_TPM_20_E_BINDING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_CURVE: ++ reason = "STATUS_TPM_20_E_CURVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_POINT: ++ reason = "STATUS_TPM_20_E_ECC_POINT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INITIALIZE: ++ reason = "STATUS_TPM_20_E_INITIALIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_FAILURE: ++ reason = "STATUS_TPM_20_E_FAILURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SEQUENCE: ++ reason = "STATUS_TPM_20_E_SEQUENCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PRIVATE: ++ reason = "STATUS_TPM_20_E_PRIVATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HMAC: ++ reason = "STATUS_TPM_20_E_HMAC"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_DISABLED: ++ reason = "STATUS_TPM_20_E_DISABLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXCLUSIVE: ++ reason = "STATUS_TPM_20_E_EXCLUSIVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_CURVE: ++ reason = "STATUS_TPM_20_E_ECC_CURVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_TYPE: ++ reason = "STATUS_TPM_20_E_AUTH_TYPE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_MISSING: ++ reason = "STATUS_TPM_20_E_AUTH_MISSING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY: ++ reason = "STATUS_TPM_20_E_POLICY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR: ++ reason = "STATUS_TPM_20_E_PCR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR_CHANGED: ++ reason = "STATUS_TPM_20_E_PCR_CHANGED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_UPGRADE: ++ reason = "STATUS_TPM_20_E_UPGRADE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TOO_MANY_CONTEXTS: ++ reason = "STATUS_TPM_20_E_TOO_MANY_CONTEXTS"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_UNAVAILABLE: ++ reason = "STATUS_TPM_20_E_AUTH_UNAVAILABLE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_REBOOT: ++ reason = "STATUS_TPM_20_E_REBOOT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_UNBALANCED: ++ reason = "STATUS_TPM_20_E_UNBALANCED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_SIZE: ++ reason = "STATUS_TPM_20_E_COMMAND_SIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_CODE: ++ reason = "STATUS_TPM_20_E_COMMAND_CODE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTHSIZE: ++ reason = "STATUS_TPM_20_E_AUTHSIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_CONTEXT: ++ reason = "STATUS_TPM_20_E_AUTH_CONTEXT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_RANGE: ++ reason = "STATUS_TPM_20_E_NV_RANGE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SIZE: ++ reason = "STATUS_TPM_20_E_NV_SIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_LOCKED: ++ reason = "STATUS_TPM_20_E_NV_LOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_AUTHORIZATION: ++ reason = "STATUS_TPM_20_E_NV_AUTHORIZATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_UNINITIALIZED: ++ reason = "STATUS_TPM_20_E_NV_UNINITIALIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SPACE: ++ reason = "STATUS_TPM_20_E_NV_SPACE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_DEFINED: ++ reason = "STATUS_TPM_20_E_NV_DEFINED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_CONTEXT: ++ reason = "STATUS_TPM_20_E_BAD_CONTEXT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_CPHASH: ++ reason = "STATUS_TPM_20_E_CPHASH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PARENT: ++ reason = "STATUS_TPM_20_E_PARENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NEEDS_TEST: ++ reason = "STATUS_TPM_20_E_NEEDS_TEST"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NO_RESULT: ++ reason = "STATUS_TPM_20_E_NO_RESULT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SENSITIVE: ++ reason = "STATUS_TPM_20_E_SENSITIVE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_BLOCKED: + reason = "STATUS_TPM_COMMAND_BLOCKED"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_HANDLE: + reason = "STATUS_TPM_INVALID_HANDLE"; + break; + case MD_NTSTATUS_WIN_STATUS_TPM_DUPLICATE_VHANDLE: + reason = "STATUS_TPM_DUPLICATE_VHANDLE"; +@@ -5577,16 +6991,94 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_PCP_PROFILE_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_PCP_VALIDATION_FAILED: + reason = "STATUS_PCP_VALIDATION_FAILED"; + break; + case MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_FOUND: + reason = "STATUS_PCP_DEVICE_NOT_FOUND"; + break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_WRONG_PARENT: ++ reason = "STATUS_PCP_WRONG_PARENT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_LOADED: ++ reason = "STATUS_PCP_KEY_NOT_LOADED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_NO_KEY_CERTIFICATION: ++ reason = "STATUS_PCP_NO_KEY_CERTIFICATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_FINALIZED: ++ reason = "STATUS_PCP_KEY_NOT_FINALIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET: ++ reason = "STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_NOT_PCR_BOUND: ++ reason = "STATUS_PCP_NOT_PCR_BOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_ALREADY_FINALIZED: ++ reason = "STATUS_PCP_KEY_ALREADY_FINALIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED: ++ reason = "STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_INVALID: ++ reason = "STATUS_PCP_KEY_USAGE_POLICY_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_SOFT_KEY_ERROR: ++ reason = "STATUS_PCP_SOFT_KEY_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AUTHENTICATED: ++ reason = "STATUS_PCP_KEY_NOT_AUTHENTICATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AIK: ++ reason = "STATUS_PCP_KEY_NOT_AIK"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_SIGNING_KEY: ++ reason = "STATUS_PCP_KEY_NOT_SIGNING_KEY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_LOCKED_OUT: ++ reason = "STATUS_PCP_LOCKED_OUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED: ++ reason = "STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_TPM_VERSION_NOT_SUPPORTED: ++ reason = "STATUS_PCP_TPM_VERSION_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_LENGTH_MISMATCH: ++ reason = "STATUS_PCP_BUFFER_LENGTH_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED: ++ reason = "STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_TICKET_MISSING: ++ reason = "STATUS_PCP_TICKET_MISSING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_RAW_POLICY_NOT_SUPPORTED: ++ reason = "STATUS_PCP_RAW_POLICY_NOT_SUPPORTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PCP_KEY_HANDLE_INVALIDATED: ++ reason = "STATUS_PCP_KEY_HANDLE_INVALIDATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_NO_RESULT: ++ reason = "STATUS_RTPM_NO_RESULT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_PCR_READ_INCOMPLETE: ++ reason = "STATUS_RTPM_PCR_READ_INCOMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_INVALID_CONTEXT: ++ reason = "STATUS_RTPM_INVALID_CONTEXT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_RTPM_UNSUPPORTED_CMD: ++ reason = "STATUS_RTPM_UNSUPPORTED_CMD"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_TPM_ZERO_EXHAUST_ENABLED: ++ reason = "STATUS_TPM_ZERO_EXHAUST_ENABLED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_CODE: + reason = "STATUS_HV_INVALID_HYPERCALL_CODE"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_INPUT: + reason = "STATUS_HV_INVALID_HYPERCALL_INPUT"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_ALIGNMENT: + reason = "STATUS_HV_INVALID_ALIGNMENT"; +@@ -5628,16 +7120,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_HV_INVALID_CONNECTION_ID"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFERS: + reason = "STATUS_HV_INSUFFICIENT_BUFFERS"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_NOT_ACKNOWLEDGED: + reason = "STATUS_HV_NOT_ACKNOWLEDGED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_STATE: ++ reason = "STATUS_HV_INVALID_VP_STATE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_HV_ACKNOWLEDGED: + reason = "STATUS_HV_ACKNOWLEDGED"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_SAVE_RESTORE_STATE: + reason = "STATUS_HV_INVALID_SAVE_RESTORE_STATE"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_SYNIC_STATE: + reason = "STATUS_HV_INVALID_SYNIC_STATE"; +@@ -5661,19 +7156,70 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_HV_FEATURE_UNAVAILABLE"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFER: + reason = "STATUS_HV_INSUFFICIENT_BUFFER"; + break; + case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS: + reason = "STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS"; + break; ++ case MD_NTSTATUS_WIN_STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR: ++ reason = "STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR: ++ reason = "STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_PROCESSOR_STARTUP_TIMEOUT: ++ reason = "STATUS_HV_PROCESSOR_STARTUP_TIMEOUT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_SMX_ENABLED: ++ reason = "STATUS_HV_SMX_ENABLED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_HV_INVALID_LP_INDEX: + reason = "STATUS_HV_INVALID_LP_INDEX"; + break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_REGISTER_VALUE: ++ reason = "STATUS_HV_INVALID_REGISTER_VALUE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_VTL_STATE: ++ reason = "STATUS_HV_INVALID_VTL_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_NX_NOT_DETECTED: ++ reason = "STATUS_HV_NX_NOT_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_ID: ++ reason = "STATUS_HV_INVALID_DEVICE_ID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_STATE: ++ reason = "STATUS_HV_INVALID_DEVICE_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_PAGE_REQUEST_INVALID: ++ reason = "STATUS_HV_PAGE_REQUEST_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_ID: ++ reason = "STATUS_HV_INVALID_CPU_GROUP_ID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_STATE: ++ reason = "STATUS_HV_INVALID_CPU_GROUP_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_OPERATION_FAILED: ++ reason = "STATUS_HV_OPERATION_FAILED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE: ++ reason = "STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_ROOT_MEMORY: ++ reason = "STATUS_HV_INSUFFICIENT_ROOT_MEMORY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_EVENT_BUFFER_ALREADY_FREED: ++ reason = "STATUS_HV_EVENT_BUFFER_ALREADY_FREED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY: ++ reason = "STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY"; ++ break; + case MD_NTSTATUS_WIN_STATUS_HV_NOT_PRESENT: + reason = "STATUS_HV_NOT_PRESENT"; + break; + case MD_NTSTATUS_WIN_STATUS_IPSEC_BAD_SPI: + reason = "STATUS_IPSEC_BAD_SPI"; + break; + case MD_NTSTATUS_WIN_STATUS_IPSEC_SA_LIFETIME_EXPIRED: + reason = "STATUS_IPSEC_SA_LIFETIME_EXPIRED"; +@@ -5838,16 +7384,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_VID_SAVED_STATE_CORRUPT"; + break; + case MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM: + reason = "STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM"; + break; + case MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_INCOMPATIBLE: + reason = "STATUS_VID_SAVED_STATE_INCOMPATIBLE"; + break; ++ case MD_NTSTATUS_WIN_STATUS_VID_VTL_ACCESS_DENIED: ++ reason = "STATUS_VID_VTL_ACCESS_DENIED"; ++ break; + case MD_NTSTATUS_WIN_STATUS_VOLMGR_DATABASE_FULL: + reason = "STATUS_VOLMGR_DATABASE_FULL"; + break; + case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED: + reason = "STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED"; + break; + case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC: + reason = "STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC"; +@@ -6228,16 +7777,34 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_CTLOG_INVALID_TRACKING_STATE"; + break; + case MD_NTSTATUS_WIN_STATUS_CTLOG_INCONSISTENT_TRACKING_FILE: + reason = "STATUS_CTLOG_INCONSISTENT_TRACKING_FILE"; + break; + case MD_NTSTATUS_WIN_STATUS_VHD_METADATA_FULL: + reason = "STATUS_VHD_METADATA_FULL"; + break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_CHANGE_TRACKING_ID: ++ reason = "STATUS_VHD_INVALID_CHANGE_TRACKING_ID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_CHANGE_TRACKING_DISABLED: ++ reason = "STATUS_VHD_CHANGE_TRACKING_DISABLED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION: ++ reason = "STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA: ++ reason = "STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE: ++ reason = "STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE: ++ reason = "STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_RKF_KEY_NOT_FOUND: + reason = "STATUS_RKF_KEY_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_RKF_DUPLICATE_KEY: + reason = "STATUS_RKF_DUPLICATE_KEY"; + break; + case MD_NTSTATUS_WIN_STATUS_RKF_BLOB_FULL: + reason = "STATUS_RKF_BLOB_FULL"; +@@ -6255,16 +7822,19 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_RDBSS_RESTART_OPERATION"; + break; + case MD_NTSTATUS_WIN_STATUS_RDBSS_CONTINUE_OPERATION: + reason = "STATUS_RDBSS_CONTINUE_OPERATION"; + break; + case MD_NTSTATUS_WIN_STATUS_RDBSS_POST_OPERATION: + reason = "STATUS_RDBSS_POST_OPERATION"; + break; ++ case MD_NTSTATUS_WIN_STATUS_RDBSS_RETRY_LOOKUP: ++ reason = "STATUS_RDBSS_RETRY_LOOKUP"; ++ break; + case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_HANDLE: + reason = "STATUS_BTH_ATT_INVALID_HANDLE"; + break; + case MD_NTSTATUS_WIN_STATUS_BTH_ATT_READ_NOT_PERMITTED: + reason = "STATUS_BTH_ATT_READ_NOT_PERMITTED"; + break; + case MD_NTSTATUS_WIN_STATUS_BTH_ATT_WRITE_NOT_PERMITTED: + reason = "STATUS_BTH_ATT_WRITE_NOT_PERMITTED"; +@@ -6327,34 +7897,70 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_SIGNED: + reason = "STATUS_SECUREBOOT_POLICY_NOT_SIGNED"; + break; + case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_FILE_REPLACED: + reason = "STATUS_SECUREBOOT_FILE_REPLACED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED: ++ reason = "STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UNKNOWN: ++ reason = "STATUS_SECUREBOOT_POLICY_UNKNOWN"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION: ++ reason = "STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH: ++ reason = "STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED: ++ reason = "STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH: ++ reason = "STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING: ++ reason = "STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_BASE_POLICY: ++ reason = "STATUS_SECUREBOOT_NOT_BASE_POLICY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY: ++ reason = "STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY"; ++ break; + case MD_NTSTATUS_WIN_STATUS_AUDIO_ENGINE_NODE_NOT_FOUND: + reason = "STATUS_AUDIO_ENGINE_NODE_NOT_FOUND"; + break; + case MD_NTSTATUS_WIN_STATUS_HDAUDIO_EMPTY_CONNECTION_LIST: + reason = "STATUS_HDAUDIO_EMPTY_CONNECTION_LIST"; + break; + case MD_NTSTATUS_WIN_STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED: + reason = "STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED"; + break; + case MD_NTSTATUS_WIN_STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED: + reason = "STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED"; + break; + case MD_NTSTATUS_WIN_STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY: + reason = "STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY"; + break; ++ case MD_NTSTATUS_WIN_STATUS_VSM_NOT_INITIALIZED: ++ reason = "STATUS_VSM_NOT_INITIALIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VSM_DMA_PROTECTION_NOT_IN_USE: ++ reason = "STATUS_VSM_DMA_PROTECTION_NOT_IN_USE"; ++ break; + case MD_NTSTATUS_WIN_STATUS_VOLSNAP_BOOTFILE_NOT_VALID: + reason = "STATUS_VOLSNAP_BOOTFILE_NOT_VALID"; + break; ++ case MD_NTSTATUS_WIN_STATUS_VOLSNAP_ACTIVATION_TIMEOUT: ++ reason = "STATUS_VOLSNAP_ACTIVATION_TIMEOUT"; ++ break; + case MD_NTSTATUS_WIN_STATUS_IO_PREEMPTED: + reason = "STATUS_IO_PREEMPTED"; + break; + case MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_STORED: + reason = "STATUS_SVHDX_ERROR_STORED"; + break; + case MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_NOT_AVAILABLE: + reason = "STATUS_SVHDX_ERROR_NOT_AVAILABLE"; +@@ -6384,31 +7990,214 @@ string NTStatusToString(uint32_t ntstatu + reason = "STATUS_SVHDX_WRONG_FILE_TYPE"; + break; + case MD_NTSTATUS_WIN_STATUS_SVHDX_VERSION_MISMATCH: + reason = "STATUS_SVHDX_VERSION_MISMATCH"; + break; + case MD_NTSTATUS_WIN_STATUS_VHD_SHARED: + reason = "STATUS_VHD_SHARED"; + break; ++ case MD_NTSTATUS_WIN_STATUS_SVHDX_NO_INITIATOR: ++ reason = "STATUS_SVHDX_NO_INITIATOR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND: ++ reason = "STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP: ++ reason = "STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SMB_BAD_CLUSTER_DIALECT: ++ reason = "STATUS_SMB_BAD_CLUSTER_DIALECT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SMB_GUEST_LOGON_BLOCKED: ++ reason = "STATUS_SMB_GUEST_LOGON_BLOCKED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID: ++ reason = "STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID"; ++ break; + case MD_NTSTATUS_WIN_STATUS_SPACES_RESILIENCY_TYPE_INVALID: + reason = "STATUS_SPACES_RESILIENCY_TYPE_INVALID"; + break; + case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID: + reason = "STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID"; + break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_REDUNDANCY_INVALID: ++ reason = "STATUS_SPACES_DRIVE_REDUNDANCY_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID: ++ reason = "STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID"; ++ break; + case MD_NTSTATUS_WIN_STATUS_SPACES_INTERLEAVE_LENGTH_INVALID: + reason = "STATUS_SPACES_INTERLEAVE_LENGTH_INVALID"; + break; + case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID: + reason = "STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID"; + break; + case MD_NTSTATUS_WIN_STATUS_SPACES_NOT_ENOUGH_DRIVES: + reason = "STATUS_SPACES_NOT_ENOUGH_DRIVES"; + break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_EXTENDED_ERROR: ++ reason = "STATUS_SPACES_EXTENDED_ERROR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_PROVISIONING_TYPE_INVALID: ++ reason = "STATUS_SPACES_PROVISIONING_TYPE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_ALLOCATION_SIZE_INVALID: ++ reason = "STATUS_SPACES_ALLOCATION_SIZE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_ENCLOSURE_AWARE_INVALID: ++ reason = "STATUS_SPACES_ENCLOSURE_AWARE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_WRITE_CACHE_SIZE_INVALID: ++ reason = "STATUS_SPACES_WRITE_CACHE_SIZE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_GROUPS_INVALID: ++ reason = "STATUS_SPACES_NUMBER_OF_GROUPS_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID: ++ reason = "STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_UPDATE_COLUMN_STATE: ++ reason = "STATUS_SPACES_UPDATE_COLUMN_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_MAP_REQUIRED: ++ reason = "STATUS_SPACES_MAP_REQUIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_UNSUPPORTED_VERSION: ++ reason = "STATUS_SPACES_UNSUPPORTED_VERSION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_CORRUPT_METADATA: ++ reason = "STATUS_SPACES_CORRUPT_METADATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRT_FULL: ++ reason = "STATUS_SPACES_DRT_FULL"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_INCONSISTENCY: ++ reason = "STATUS_SPACES_INCONSISTENCY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_LOG_NOT_READY: ++ reason = "STATUS_SPACES_LOG_NOT_READY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_NO_REDUNDANCY: ++ reason = "STATUS_SPACES_NO_REDUNDANCY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_NOT_READY: ++ reason = "STATUS_SPACES_DRIVE_NOT_READY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SPLIT: ++ reason = "STATUS_SPACES_DRIVE_SPLIT"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_LOST_DATA: ++ reason = "STATUS_SPACES_DRIVE_LOST_DATA"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INCOMPLETE: ++ reason = "STATUS_SPACES_ENTRY_INCOMPLETE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INVALID: ++ reason = "STATUS_SPACES_ENTRY_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SPACES_MARK_DIRTY: ++ reason = "STATUS_SPACES_MARK_DIRTY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SECCORE_INVALID_COMMAND: ++ reason = "STATUS_SECCORE_INVALID_COMMAND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED: ++ reason = "STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION: ++ reason = "STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_INVALID_POLICY: ++ reason = "STATUS_SYSTEM_INTEGRITY_INVALID_POLICY"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED: ++ reason = "STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES: ++ reason = "STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED: ++ reason = "STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_NO_APPLICABLE_APP_LICENSES_FOUND: ++ reason = "STATUS_NO_APPLICABLE_APP_LICENSES_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_FOUND: ++ reason = "STATUS_CLIP_LICENSE_NOT_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_DEVICE_LICENSE_MISSING: ++ reason = "STATUS_CLIP_DEVICE_LICENSE_MISSING"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_INVALID_SIGNATURE: ++ reason = "STATUS_CLIP_LICENSE_INVALID_SIGNATURE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID: ++ reason = "STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_EXPIRED: ++ reason = "STATUS_CLIP_LICENSE_EXPIRED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE: ++ reason = "STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_SIGNED: ++ reason = "STATUS_CLIP_LICENSE_NOT_SIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE: ++ reason = "STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH: ++ reason = "STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED: ++ reason = "STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_INVALID: ++ reason = "STATUS_PLATFORM_MANIFEST_INVALID"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED: ++ reason = "STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED: ++ reason = "STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND: ++ reason = "STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_ACTIVE: ++ reason = "STATUS_PLATFORM_MANIFEST_NOT_ACTIVE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_SIGNED: ++ reason = "STATUS_PLATFORM_MANIFEST_NOT_SIGNED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_CONDITION_NOT_SATISFIED: ++ reason = "STATUS_APPEXEC_CONDITION_NOT_SATISFIED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_HANDLE_INVALIDATED: ++ reason = "STATUS_APPEXEC_HANDLE_INVALIDATED"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_GENERATION: ++ reason = "STATUS_APPEXEC_INVALID_HOST_GENERATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION: ++ reason = "STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_STATE: ++ reason = "STATUS_APPEXEC_INVALID_HOST_STATE"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_NO_DONOR: ++ reason = "STATUS_APPEXEC_NO_DONOR"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_HOST_ID_MISMATCH: ++ reason = "STATUS_APPEXEC_HOST_ID_MISMATCH"; ++ break; ++ case MD_NTSTATUS_WIN_STATUS_APPEXEC_UNKNOWN_USER: ++ reason = "STATUS_APPEXEC_UNKNOWN_USER"; ++ break; + default: { + char reason_string[11]; + snprintf(reason_string, sizeof(reason_string), "0x%08x", ntstatus); + reason = reason_string; + break; + } + } + return reason; + diff --git a/toolkit/crashreporter/breakpad-patches/20-mac-crash-info.patch b/toolkit/crashreporter/breakpad-patches/20-mac-crash-info.patch new file mode 100644 index 0000000000..be971133a1 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/20-mac-crash-info.patch @@ -0,0 +1,516 @@ +# HG changeset patch +# User Steven Michaud <smichaud@pobox.com> +# Date 1619800781 18000 +# Fri Apr 30 11:39:41 2021 -0500 +# Node ID 9f89eb3d68316e8c3a469d1c058ad40c1807d7bc +# Parent 0db412525773fff333e8d338551021e083c25619 +Bug 1577886 - Add support to for macOS __crash_info data to Breakpad. r=gsvelto +Differential Revision: https://phabricator.services.mozilla.com/D112871 + +diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h +--- a/src/google_breakpad/common/minidump_format.h ++++ b/src/google_breakpad/common/minidump_format.h +@@ -351,6 +351,10 @@ typedef enum { + /* Crashpad extension types. 0x4350 = "CP" + * See Crashpad's minidump/minidump_extensions.h. */ + MD_CRASHPAD_INFO_STREAM = 0x43500001, /* MDRawCrashpadInfo */ ++ ++ /* Data from the __DATA,__crash_info section of every module which contains ++ * one that has useful data. Only available on macOS. 0x4D7A = "Mz". */ ++ MOZ_MACOS_CRASH_INFO_STREAM = 0x4d7a0001, + } MDStreamType; /* MINIDUMP_STREAM_TYPE */ + + +@@ -1094,6 +1098,52 @@ typedef struct { + MDLocationDescriptor module_list; /* MDRawModuleCrashpadInfoList */ + } MDRawCrashpadInfo; + ++/* macOS __DATA,__crash_info data */ ++ ++typedef struct { ++ uint64_t stream_type; /* MOZ_MACOS_CRASH_INFO_STREAM */ ++ uint64_t version; ++ uint64_t thread; ++ uint64_t dialog_mode; ++ uint64_t abort_cause; /* Only valid when 'version' > 4 */ ++ /* If/when Apple adds more fields to crashreporter_annotations_t, add ++ * numerical fields here and change (MDRawMacCrashInfo).record_start_size ++ * accordingly. Make them all uint64_t, to keep this structure the same size ++ * on all platforms. 'data' should always be the last field. Add new string ++ * fields to the end of 'data'. */ ++ /* 'data' currently contains five null-terminated uint8_t arrays, each ++ * possibly empty (containing only a single terminal null), stored one after ++ * the other: ++ * module_path; ++ * message; ++ * signature_string; ++ * backtrace; ++ * message2; */ ++ uint8_t data[0]; ++} MDRawMacCrashInfoRecord; ++ ++/* This is the maximum supported size for each string in ++ * (MDRawMacCrashInfoRecord).data. If we encounter a string in the ++ * __crash_info section which seems larger than this, that's a sign of data ++ * corruption. */ ++#define MACCRASHINFO_STRING_MAXSIZE 8192 ++ ++/* In principle there should only be one or two non-empty __DATA,__crash_info ++ * sections per process. But the __crash_info section is almost entirely ++ * undocumented, so just in case we set a large maximum. */ ++#define MAC_CRASH_INFOS_MAX 20 ++ ++typedef struct { ++ uint32_t stream_type; /* MOZ_MACOS_CRASH_INFO_STREAM */ ++ uint32_t record_count; ++ /* The size of the "fixed-size" part of MDRawMacCrashInfoRecord, before the ++ * 'data' field. This will always be 'sizeof(MDRawMacCrashInfoRecord)'. But ++ * that value may change if more numerical fields are added to ++ * MDRawMacCrashInfoRecord in the future. */ ++ uint32_t record_start_size; ++ MDLocationDescriptor records[MAC_CRASH_INFOS_MAX]; ++} MDRawMacCrashInfo; ++ + #if defined(_MSC_VER) + #pragma warning(pop) + #endif /* _MSC_VER */ +diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h +--- a/src/google_breakpad/processor/minidump.h ++++ b/src/google_breakpad/processor/minidump.h +@@ -1151,6 +1151,57 @@ class MinidumpCrashpadInfo : public Mini + std::map<std::string, std::string> simple_annotations_; + }; + ++// MinidumpMacCrashInfo wraps MDRawMacCrashInfo. It's an optional stream ++// in a minidump that records information from the __DATA,__crash_info ++// section of every module in the crashing process that contains one, and ++// which isn't empty of useful information. Only present on macOS. ++ ++// Friendly wrapper for the information in MDRawMacCrashInfoRecord. ++typedef struct crash_info_record { ++ string module_path; ++ unsigned long version; ++ string message; ++ string signature_string; ++ string backtrace; ++ string message2; ++ unsigned long long thread; ++ unsigned int dialog_mode; ++ long long abort_cause; // Only valid when 'version' > 4 ++ crash_info_record() ++ : version(0), thread(0), dialog_mode(0), abort_cause(0) ++ {} ++} crash_info_record_t; ++ ++class MinidumpMacCrashInfo : public MinidumpStream { ++ public: ++ // A human-readable representation of the data from the __DATA,__crash_info ++ // sections in all of the crashing process's modules that have one, if ++ // it's not empty of useful data. Suitable for use by "minidump_stackwalk". ++ string description() const { return description_; } ++ // A "machine-readable" copy of the same information, suitable for use by ++ // "minidump_stalkwalk -m". ++ vector<crash_info_record_t> const records() { ++ return records_; ++ } ++ ++ // Print a human-readable representation of the object to stdout. ++ void Print(); ++ ++ private: ++ friend class Minidump; ++ ++ static const uint32_t kStreamType = MOZ_MACOS_CRASH_INFO_STREAM; ++ ++ explicit MinidumpMacCrashInfo(Minidump* minidump_); ++ ++ bool ReadCrashInfoRecord(MDLocationDescriptor location, ++ uint32_t record_start_size); ++ bool Read(uint32_t expected_size); ++ ++ string description_; ++ vector<crash_info_record_t> records_; ++}; ++ + + // Minidump is the user's interface to a minidump file. It wraps MDRawHeader + // and provides access to the minidump's top-level stream directory. +@@ -1214,6 +1265,7 @@ class Minidump { + virtual MinidumpBreakpadInfo* GetBreakpadInfo(); + virtual MinidumpMemoryInfoList* GetMemoryInfoList(); + MinidumpCrashpadInfo* GetCrashpadInfo(); ++ MinidumpMacCrashInfo* GetMacCrashInfo(); + + // The next method also calls GetStream, but is exclusive for Linux dumps. + virtual MinidumpLinuxMapsList *GetLinuxMapsList(); +diff --git a/src/google_breakpad/processor/process_state.h b/src/google_breakpad/processor/process_state.h +--- a/src/google_breakpad/processor/process_state.h ++++ b/src/google_breakpad/processor/process_state.h +@@ -112,6 +112,14 @@ class ProcessState { + return &thread_memory_regions_; + } + const SystemInfo* system_info() const { return &system_info_; } ++ string mac_crash_info() const { return mac_crash_info_; } ++ size_t mac_crash_info_records_count() const { ++ return mac_crash_info_records_.size(); ++ } ++ const crash_info_record_t* mac_crash_info_records() const { ++ return reinterpret_cast<const crash_info_record_t*>( ++ &mac_crash_info_records_[0]); ++ } + const CodeModules* modules() const { return modules_; } + const CodeModules* unloaded_modules() const { return unloaded_modules_; } + const vector<linked_ptr<const CodeModule> >* shrunk_range_modules() const { +@@ -179,6 +187,10 @@ class ProcessState { + // OS and CPU information. + SystemInfo system_info_; + ++ // Information from __DATA,__crash_info sections. Only present on macOS. ++ string mac_crash_info_; ++ vector<crash_info_record_t> mac_crash_info_records_; ++ + // The modules that were loaded into the process represented by the + // ProcessState. + const CodeModules *modules_; +diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc +--- a/src/processor/minidump.cc ++++ b/src/processor/minidump.cc +@@ -5116,6 +5116,230 @@ void MinidumpCrashpadInfo::Print() { + printf("\n"); + } + ++// ++// MinidumpMacCrashInfo ++// ++ ++MinidumpMacCrashInfo::MinidumpMacCrashInfo(Minidump* minidump) ++ : MinidumpStream(minidump), ++ description_(), ++ records_() { ++} ++ ++bool MinidumpMacCrashInfo::ReadCrashInfoRecord(MDLocationDescriptor location, ++ uint32_t record_start_size) { ++ if (!minidump_->SeekSet(location.rva)) { ++ BPLOG(ERROR) << "ReadCrashInfoRecord could not seek to record"; ++ return false; ++ } ++ ++ // We may be reading a minidump 1) created by (newer) code that defines more ++ // fields than we do in the fixed-size part of MDRawMacCrashInfoRecord ++ // (before 'data'), or 2) created by (older) code that defines fewer fields. ++ // In the first case we read in the newer fields but ignore them. In the ++ // second case we read in only the older fields, and leave the newer fields ++ // (in 'raw_record_start') set to zero. ++ uint32_t raw_record_size = sizeof(MDRawMacCrashInfoRecord); ++ if (record_start_size > raw_record_size) { ++ raw_record_size = record_start_size; ++ } ++ scoped_ptr< vector<uint8_t> > raw_record( ++ new vector<uint8_t>(raw_record_size)); ++ if (!minidump_->ReadBytes(&(*raw_record)[0], record_start_size)) { ++ BPLOG(ERROR) << "ReadCrashInfoRecord could not read " << ++ record_start_size << " bytes of record"; ++ return false; ++ } ++ MDRawMacCrashInfoRecord* raw_record_start = ++ (MDRawMacCrashInfoRecord*) &(*raw_record)[0]; ++ ++ if (minidump_->swap()) { ++ Swap(&raw_record_start->stream_type); ++ Swap(&raw_record_start->version); ++ Swap(&raw_record_start->thread); ++ Swap(&raw_record_start->dialog_mode); ++ Swap(&raw_record_start->abort_cause); ++ } ++ ++ if (raw_record_start->stream_type != MOZ_MACOS_CRASH_INFO_STREAM) { ++ BPLOG(ERROR) << "ReadCrashInfoRecord stream type mismatch, " << ++ raw_record_start->stream_type << " != " << ++ MOZ_MACOS_CRASH_INFO_STREAM; ++ return false; ++ } ++ ++ uint32_t string_data_size = location.data_size - record_start_size; ++ scoped_ptr< vector<uint8_t> > data(new vector<uint8_t>(string_data_size)); ++ if (!minidump_->ReadBytes(&(*data)[0], string_data_size)) { ++ BPLOG(ERROR) << "ReadCrashInfoRecord could not read " << ++ string_data_size << " bytes of record data"; ++ return false; ++ } ++ ++ crash_info_record_t record; ++ ++ record.version = (unsigned long) raw_record_start->version; ++ record.thread = (unsigned long long) raw_record_start->thread; ++ record.dialog_mode = (unsigned int) raw_record_start->dialog_mode; ++ record.abort_cause = (long long) raw_record_start->abort_cause; ++ ++ // Once again, we may be reading a minidump created by newer code that ++ // stores more strings than we expect in (MDRawMacCrashInfoRecord).data, ++ // or one created by older code that contains fewer strings than we ++ // expect. In the first case we ignore the "extra" strings. To deal with ++ // the second case we bail when 'offset >= string_data_size'. ++ const char* string_data = (const char*) &(*data)[0]; ++ size_t offset = 0; ++ for (int i = 1; i <= 5; ++i) { ++ switch (i) { ++ case 1: ++ record.module_path.append(string_data); ++ break; ++ case 2: ++ record.message.append(string_data); ++ break; ++ case 3: ++ record.signature_string.append(string_data); ++ break; ++ case 4: ++ record.backtrace.append(string_data); ++ break; ++ case 5: ++ record.message2.append(string_data); ++ break; ++ } ++ size_t char_array_size = strlen(string_data) + 1; ++ offset += char_array_size; ++ if (offset >= string_data_size) { ++ break; ++ } ++ string_data += char_array_size; ++ } ++ ++ records_.push_back(record); ++ ++ description_.append(" Module \""); ++ description_.append(record.module_path); ++ description_.append("\":\n"); ++ ++ int num_fields = 6; ++ if (record.version > 4) { ++ num_fields = 7; ++ } ++ for (int i = 1; i <= num_fields; ++i) { ++ switch (i) { ++ case 1: ++ if (!record.message.empty()) { ++ description_.append(" message: \""); ++ description_.append(record.message); ++ description_.append("\"\n"); ++ } ++ break; ++ case 2: ++ if (!record.signature_string.empty()) { ++ description_.append(" signature_string: \""); ++ description_.append(record.signature_string); ++ description_.append("\"\n"); ++ } ++ break; ++ case 3: ++ if (!record.backtrace.empty()) { ++ description_.append(" backtrace: \""); ++ description_.append(record.backtrace); ++ description_.append("\"\n"); ++ } ++ break; ++ case 4: ++ if (!record.message2.empty()) { ++ description_.append(" message2: \""); ++ description_.append(record.message2); ++ description_.append("\"\n"); ++ } ++ break; ++ case 5: ++ if (record.thread) { ++ char thread[128]; ++ snprintf(thread, sizeof(thread), " thread: 0x%llx\n", ++ record.thread); ++ description_.append(thread); ++ } ++ break; ++ case 6: ++ if (record.dialog_mode) { ++ char dialog_mode[128]; ++ snprintf(dialog_mode, sizeof(dialog_mode), " dialog_mode: 0x%x\n", ++ record.dialog_mode); ++ description_.append(dialog_mode); ++ } ++ break; ++ case 7: ++ if (record.abort_cause) { ++ char abort_cause[128]; ++ snprintf(abort_cause, sizeof(abort_cause), " abort_cause: %lld\n", ++ record.abort_cause); ++ description_.append(abort_cause); ++ } ++ break; ++ default: ++ break; ++ } ++ } ++ ++ return true; ++} ++ ++bool MinidumpMacCrashInfo::Read(uint32_t expected_size) { ++ description_.clear(); ++ records_.clear(); ++ valid_ = false; ++ ++ MDRawMacCrashInfo crash_info; ++ if (expected_size != sizeof(crash_info)) { ++ BPLOG(ERROR) << "MinidumpMacCrashInfo size mismatch, " << ++ expected_size << " != " << sizeof(crash_info); ++ return false; ++ } ++ if (!minidump_->ReadBytes(&crash_info, sizeof(crash_info))) { ++ BPLOG(ERROR) << "MinidumpMacCrashInfo could not read " << ++ sizeof(crash_info) << " bytes"; ++ return false; ++ } ++ if (minidump_->swap()) { ++ Swap(&crash_info.stream_type); ++ Swap(&crash_info.record_count); ++ Swap(&crash_info.record_start_size); ++ for (uint32_t i = 0; i < crash_info.record_count; ++i) { ++ Swap(&crash_info.records[i].data_size); ++ Swap(&crash_info.records[i].rva); ++ } ++ } ++ if (crash_info.stream_type != MOZ_MACOS_CRASH_INFO_STREAM) { ++ BPLOG(ERROR) << "MinidumpMacCrashInfo stream type mismatch, " << ++ crash_info.stream_type << " != " << ++ MOZ_MACOS_CRASH_INFO_STREAM; ++ return false; ++ } ++ ++ for (uint32_t i = 0; i < crash_info.record_count; ++i) { ++ if (!ReadCrashInfoRecord(crash_info.records[i], ++ crash_info.record_start_size)) { ++ return false; ++ } ++ } ++ ++ valid_ = true; ++ return true; ++} ++ ++void MinidumpMacCrashInfo::Print() { ++ if (!valid_) { ++ BPLOG(ERROR) << "MinidumpMacCrashInfo cannot print invalid data"; ++ return; ++ } ++ ++ printf("MinidumpMacCrashInfo:\n\n"); ++ printf("%s", description_.c_str()); ++} + + // + // Minidump +@@ -5378,7 +5602,8 @@ bool Minidump::Read() { + case MD_SYSTEM_INFO_STREAM: + case MD_MISC_INFO_STREAM: + case MD_BREAKPAD_INFO_STREAM: +- case MD_CRASHPAD_INFO_STREAM: { ++ case MD_CRASHPAD_INFO_STREAM: ++ case MOZ_MACOS_CRASH_INFO_STREAM: { + if (stream_map_->find(stream_type) != stream_map_->end()) { + // Another stream with this type was already found. A minidump + // file should contain at most one of each of these stream types. +@@ -5499,6 +5724,11 @@ MinidumpCrashpadInfo* Minidump::GetCrash + return GetStream(&crashpad_info); + } + ++MinidumpMacCrashInfo* Minidump::GetMacCrashInfo() { ++ MinidumpMacCrashInfo* mac_crash_info; ++ return GetStream(&mac_crash_info); ++} ++ + static const char* get_stream_name(uint32_t stream_type) { + switch (stream_type) { + case MD_UNUSED_STREAM: +@@ -5571,6 +5801,8 @@ static const char* get_stream_name(uint3 + return "MD_LINUX_DSO_DEBUG"; + case MD_CRASHPAD_INFO_STREAM: + return "MD_CRASHPAD_INFO_STREAM"; ++ case MOZ_MACOS_CRASH_INFO_STREAM: ++ return "MOZ_MACOS_CRASH_INFO_STREAM"; + default: + return "unknown"; + } +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -137,6 +137,12 @@ ProcessResult MinidumpProcessor::Process + } + } + ++ MinidumpMacCrashInfo *crash_info = dump->GetMacCrashInfo(); ++ if (crash_info) { ++ process_state->mac_crash_info_ = crash_info->description(); ++ process_state->mac_crash_info_records_ = crash_info->records(); ++ } ++ + // This will just return an empty string if it doesn't exist. + process_state->assertion_ = GetAssertion(dump); + +diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc +--- a/src/processor/stackwalk_common.cc ++++ b/src/processor/stackwalk_common.cc +@@ -872,6 +872,12 @@ void PrintProcessState(const ProcessStat + printf("Process uptime: not available\n"); + } + ++ if (!process_state.mac_crash_info().empty()) { ++ printf("\n"); ++ printf("Application-specific information:\n"); ++ printf("%s", process_state.mac_crash_info().c_str()); ++ } ++ + // If the thread that requested the dump is known, print it first. + int requesting_thread = process_state.requesting_thread(); + if (requesting_thread != -1) { +@@ -955,6 +961,44 @@ void PrintProcessStateMachineReadable(co + printf("\n"); + } + ++ const crash_info_record_t* crash_info_records = ++ process_state.mac_crash_info_records(); ++ size_t num_records = ++ process_state.mac_crash_info_records_count(); ++ for (size_t i = 0; i < num_records; ++i) { ++ char thread_str[32]; ++ if (crash_info_records[i].thread) { ++ snprintf(thread_str, sizeof(thread_str), "0x%llx", ++ crash_info_records[i].thread); ++ } else { ++ strncpy(thread_str, "0", sizeof(thread_str)); ++ } ++ char dialog_mode_str[32]; ++ if (crash_info_records[i].dialog_mode) { ++ snprintf(dialog_mode_str, sizeof(dialog_mode_str), "0x%x", ++ crash_info_records[i].dialog_mode); ++ } else { ++ strncpy(dialog_mode_str, "0", sizeof(dialog_mode_str)); ++ } ++ char abort_cause_str[32]; ++ if (crash_info_records[i].abort_cause) { ++ snprintf(abort_cause_str, sizeof(abort_cause_str), "%lld", ++ crash_info_records[i].abort_cause); ++ } else { ++ strncpy(abort_cause_str, "0", sizeof(abort_cause_str)); ++ } ++ printf("MacCrashInfo%c%s%c%lu%c%s%c%s%c%s%c%s%c%s%c%s%c%s\n", ++ kOutputSeparator, crash_info_records[i].module_path.c_str(), ++ kOutputSeparator, crash_info_records[i].version, ++ kOutputSeparator, crash_info_records[i].message.c_str(), ++ kOutputSeparator, crash_info_records[i].signature_string.c_str(), ++ kOutputSeparator, crash_info_records[i].backtrace.c_str(), ++ kOutputSeparator, crash_info_records[i].message2.c_str(), ++ kOutputSeparator, thread_str, ++ kOutputSeparator, dialog_mode_str, ++ kOutputSeparator, abort_cause_str); ++ } ++ + PrintModulesMachineReadable(process_state.modules()); + PrintUnloadedModulesMachineReadable(process_state.unloaded_modules()); + diff --git a/toolkit/crashreporter/breakpad-patches/21-thread-names.patch b/toolkit/crashreporter/breakpad-patches/21-thread-names.patch new file mode 100644 index 0000000000..ea4dd67cd1 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/21-thread-names.patch @@ -0,0 +1,661 @@ +diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h +--- a/src/google_breakpad/common/minidump_format.h ++++ b/src/google_breakpad/common/minidump_format.h +@@ -227,17 +227,18 @@ typedef struct { + + /* + * DbgHelp.h + */ + + + /* An MDRVA is an offset into the minidump file. The beginning of the + * MDRawHeader is at offset 0. */ +-typedef uint32_t MDRVA; /* RVA */ ++typedef uint32_t MDRVA; /* RVA */ ++typedef uint64_t MDRVA64; /* RVA64 */ + + typedef struct { + uint32_t data_size; + MDRVA rva; + } MDLocationDescriptor; /* MINIDUMP_LOCATION_DESCRIPTOR */ + + + typedef struct { +@@ -327,16 +328,18 @@ typedef enum { + MD_MISC_INFO_STREAM = 15, /* MDRawMiscInfo */ + MD_MEMORY_INFO_LIST_STREAM = 16, /* MDRawMemoryInfoList */ + MD_THREAD_INFO_LIST_STREAM = 17, + MD_HANDLE_OPERATION_LIST_STREAM = 18, + MD_TOKEN_STREAM = 19, + MD_JAVASCRIPT_DATA_STREAM = 20, + MD_SYSTEM_MEMORY_INFO_STREAM = 21, + MD_PROCESS_VM_COUNTERS_STREAM = 22, ++ MD_IPT_TRACE_STREAM = 23, ++ MD_THREAD_NAMES_STREAM = 24, + MD_LAST_RESERVED_STREAM = 0x0000ffff, + + /* Breakpad extension types. 0x4767 = "Gg" */ + MD_BREAKPAD_INFO_STREAM = 0x47670001, /* MDRawBreakpadInfo */ + MD_ASSERTION_INFO_STREAM = 0x47670002, /* MDRawAssertionInfo */ + /* These are additional minidump stream values which are specific to + * the linux breakpad implementation. */ + MD_LINUX_CPU_INFO = 0x47670003, /* /proc/cpuinfo */ +@@ -1117,16 +1120,26 @@ typedef struct { + * module_path; + * message; + * signature_string; + * backtrace; + * message2; */ + uint8_t data[0]; + } MDRawMacCrashInfoRecord; + ++typedef struct __attribute__((packed,aligned(4))) { ++ uint32_t thread_id; ++ MDRVA64 rva_of_thread_name; ++} MDRawThreadName; ++ ++typedef struct { ++ uint32_t number_of_thread_names; ++ MDRawThreadName thread_names[0]; ++} MDRawThreadNamesList; ++ + /* This is the maximum supported size for each string in + * (MDRawMacCrashInfoRecord).data. If we encounter a string in the + * __crash_info section which seems larger than this, that's a sign of data + * corruption. */ + #define MACCRASHINFO_STRING_MAXSIZE 8192 + + /* In principle there should only be one or two non-empty __DATA,__crash_info + * sections per process. But the __crash_info section is almost entirely +diff --git a/src/google_breakpad/processor/call_stack.h b/src/google_breakpad/processor/call_stack.h +--- a/src/google_breakpad/processor/call_stack.h ++++ b/src/google_breakpad/processor/call_stack.h +@@ -41,21 +41,23 @@ + // beginning with the innermost callee frame. + // + // Author: Mark Mentovai + + #ifndef GOOGLE_BREAKPAD_PROCESSOR_CALL_STACK_H__ + #define GOOGLE_BREAKPAD_PROCESSOR_CALL_STACK_H__ + + #include <cstdint> ++#include <string> + #include <vector> + + namespace google_breakpad { + + using std::vector; ++using std::string; + + struct StackFrame; + template<typename T> class linked_ptr; + + class CallStack { + public: + CallStack() { Clear(); } + ~CallStack(); +@@ -63,29 +65,33 @@ class CallStack { + // Resets the CallStack to its initial empty state + void Clear(); + + const vector<StackFrame*>* frames() const { return &frames_; } + + // Set the TID associated with this call stack. + void set_tid(uint32_t tid) { tid_ = tid; } + void set_last_error(uint32_t last_error) { last_error_ = last_error; } ++ void set_name(const string& name) { name_ = name; } + + uint32_t tid() const { return tid_; } + uint32_t last_error() const { return last_error_; } ++ const string name() const { return name_; } + + private: + // Stackwalker is responsible for building the frames_ vector. + friend class Stackwalker; + + // Storage for pushed frames. + vector<StackFrame*> frames_; + + // The TID associated with this call stack. Default to 0 if it's not + // available. + uint32_t tid_; + // The last error the OS set for this thread (win32's GetLastError()) + uint32_t last_error_; ++ // The name of this thread, empty if it's not available ++ string name_; + }; + + } // namespace google_breakpad + + #endif // GOOGLE_BREAKPAD_PROCSSOR_CALL_STACK_H__ +diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h +--- a/src/google_breakpad/processor/minidump.h ++++ b/src/google_breakpad/processor/minidump.h +@@ -1197,16 +1197,96 @@ class MinidumpMacCrashInfo : public Mini + bool ReadCrashInfoRecord(MDLocationDescriptor location, + uint32_t record_start_size); + bool Read(uint32_t expected_size); + + string description_; + vector<crash_info_record_t> records_; + }; + ++// MinidumpThreadName wraps MDRawThreadName ++class MinidumpThreadName : public MinidumpObject { ++ public: ++ ~MinidumpThreadName() override; ++ ++ const MDRawThreadName* thread_name() const { ++ if (valid_) { ++ return &thread_name_; ++ } ++ ++ return NULL; ++ } ++ ++ uint32_t thread_id() const { ++ if (valid_) { ++ return thread_name_.thread_id; ++ } ++ ++ return 0; ++ } ++ ++ string name() const; ++ ++ // Print a human-readable representation of the object to stdout. ++ void Print(); ++ ++ protected: ++ explicit MinidumpThreadName(Minidump* minidump); ++ ++ private: ++ // These objects are managed by MinidumpThreadNameList ++ friend class MinidumpThreadNamesList; ++ ++ // This works like MinidumpStream::Read, but is driven by ++ // MinidumpThreadNameList. ++ bool Read(uint32_t expected_size); ++ ++ // Reads the thread name. This is done separately from Read to ++ // allow contiguous reading of thread names by MinidumpThreadNameList. ++ bool ReadAuxiliaryData(); ++ ++ bool valid_; ++ MDRawThreadName thread_name_; ++ const string* name_; ++}; ++ ++ ++// MinidumpThreadNamesList contains all the names for threads in a process ++// in the form of MinidumpThreadNames. ++class MinidumpThreadNamesList : public MinidumpStream { ++ public: ++ ~MinidumpThreadNamesList() override; ++ ++ unsigned int name_count() const { ++ return valid_ ? name_count_ : 0; ++ } ++ ++ const string GetNameForThreadId(uint32_t thread_id) const; ++ ++ // Print a human-readable representation of the object to stdout. ++ void Print(); ++ ++ protected: ++ explicit MinidumpThreadNamesList(Minidump* minidump_); ++ ++ private: ++ friend class Minidump; ++ ++ typedef vector<MinidumpThreadName> MinidumpThreadNames; ++ ++ static const uint32_t kStreamType = MD_THREAD_NAMES_STREAM; ++ ++ bool Read(uint32_t expected_size_) override; ++ ++ MinidumpThreadNames* thread_names_; ++ uint32_t name_count_; ++ bool valid_; ++ ++ DISALLOW_COPY_AND_ASSIGN(MinidumpThreadNamesList); ++}; + + // Minidump is the user's interface to a minidump file. It wraps MDRawHeader + // and provides access to the minidump's top-level stream directory. + class Minidump { + public: + // path is the pathname of a file containing the minidump. + explicit Minidump(const string& path, + bool hexdump=false, +@@ -1261,16 +1343,17 @@ class Minidump { + virtual MinidumpAssertion* GetAssertion(); + virtual MinidumpSystemInfo* GetSystemInfo(); + virtual MinidumpUnloadedModuleList* GetUnloadedModuleList(); + virtual MinidumpMiscInfo* GetMiscInfo(); + virtual MinidumpBreakpadInfo* GetBreakpadInfo(); + virtual MinidumpMemoryInfoList* GetMemoryInfoList(); + MinidumpCrashpadInfo* GetCrashpadInfo(); + MinidumpMacCrashInfo* GetMacCrashInfo(); ++ MinidumpThreadNamesList* GetThreadNamesList(); + + // The next method also calls GetStream, but is exclusive for Linux dumps. + virtual MinidumpLinuxMapsList *GetLinuxMapsList(); + + // The next set of methods are provided for users who wish to access + // data in minidump files directly, while leveraging the rest of + // this class and related classes to handle the basic minidump + // structure and known stream types. +diff --git a/src/processor/call_stack.cc b/src/processor/call_stack.cc +--- a/src/processor/call_stack.cc ++++ b/src/processor/call_stack.cc +@@ -45,11 +45,12 @@ CallStack::~CallStack() { + void CallStack::Clear() { + for (vector<StackFrame *>::const_iterator iterator = frames_.begin(); + iterator != frames_.end(); + ++iterator) { + delete *iterator; + } + tid_ = 0; + last_error_ = 0; ++ name_ = ""; + } + + } // namespace google_breakpad +diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc +--- a/src/processor/minidump.cc ++++ b/src/processor/minidump.cc +@@ -5724,16 +5724,226 @@ MinidumpCrashpadInfo* Minidump::GetCrash + return GetStream(&crashpad_info); + } + + MinidumpMacCrashInfo* Minidump::GetMacCrashInfo() { + MinidumpMacCrashInfo* mac_crash_info; + return GetStream(&mac_crash_info); + } + ++MinidumpThreadNamesList* Minidump::GetThreadNamesList() { ++ MinidumpThreadNamesList* thread_names_list; ++ return GetStream(&thread_names_list); ++} ++ ++// ++// MinidumpThreadName ++// ++ ++ ++MinidumpThreadName::MinidumpThreadName(Minidump* minidump) ++ : MinidumpObject(minidump), ++ valid_(false), ++ thread_name_(), ++ name_(NULL) { ++ ++} ++ ++MinidumpThreadName::~MinidumpThreadName() { ++ ; ++} ++ ++void MinidumpThreadName::Print() { ++ if (!valid_) { ++ BPLOG(ERROR) << "MinidumpThreadName cannot print invalid data"; ++ return; ++ } ++ ++ printf("MDRawThreadName\n"); ++ printf(" thread_id = 0x%x\n", ++ thread_name_.thread_id); ++ printf(" rva_of_thread_name = 0x%" PRIx64 "\n", ++ thread_name_.rva_of_thread_name); ++ ++ printf(" (name) = \"%s\"\n", name().c_str()); ++ printf("\n"); ++} ++ ++string MinidumpThreadName::name() const { ++ if (!valid_) { ++ BPLOG(ERROR) << "Invalid MinidumpThreadName for name"; ++ return ""; ++ } ++ ++ return *name_; ++} ++ ++bool MinidumpThreadName::Read(uint32_t expected_size) { ++ ++ delete name_; ++ ++ if (expected_size < sizeof(thread_name_)) { ++ BPLOG(ERROR) << "MinidumpThreadName expected size is less than size " ++ << "of struct " << expected_size << " < " ++ << sizeof(thread_name_); ++ return false; ++ } ++ ++ if (!minidump_->ReadBytes(&thread_name_, sizeof(thread_name_))) { ++ BPLOG(ERROR) << "MinidumpThreadName cannot read name"; ++ return false; ++ } ++ ++ if (expected_size > sizeof(thread_name_)) { ++ uint32_t thread_name_bytes_remaining = expected_size - sizeof(thread_name_); ++ off_t pos = minidump_->Tell(); ++ if (!minidump_->SeekSet(pos + thread_name_bytes_remaining)) { ++ BPLOG(ERROR) << "MinidumpThreadName unable to seek to end of name"; ++ return false; ++ } ++ } ++ ++ if (minidump_->swap()) { ++ Swap(&thread_name_.thread_id); ++ uint64_t rva_of_thread_name; ++ memcpy(&rva_of_thread_name, &thread_name_.rva_of_thread_name, sizeof(uint64_t)); ++ Swap(&rva_of_thread_name); ++ memcpy(&thread_name_.rva_of_thread_name, &rva_of_thread_name, sizeof(uint64_t)); ++ } ++ ++ return true; ++} ++ ++bool MinidumpThreadName::ReadAuxiliaryData() { ++ // Each thread must have a name string. ++ name_ = minidump_->ReadString(thread_name_.rva_of_thread_name); ++ if (!name_) { ++ BPLOG(ERROR) << "MinidumpThreadName could not read name"; ++ valid_ = false; ++ return false; ++ } ++ ++ // At this point, we have enough info for the name to be valid. ++ valid_ = true; ++ return true; ++} ++ ++// ++// MinidumpThreadNamesList ++// ++ ++ ++MinidumpThreadNamesList::MinidumpThreadNamesList(Minidump* minidump) ++ : MinidumpStream(minidump), ++ thread_names_(NULL), ++ name_count_(0), ++ valid_(false) { ++ ; ++} ++ ++MinidumpThreadNamesList::~MinidumpThreadNamesList() { ++ delete thread_names_; ++} ++ ++const string MinidumpThreadNamesList::GetNameForThreadId(uint32_t thread_id) const { ++ if (valid_) { ++ for (unsigned int name_index = 0; ++ name_index < name_count_; ++ ++name_index) { ++ const MinidumpThreadName& thread_name = (*thread_names_)[name_index]; ++ if (thread_name.thread_id() == thread_id) { ++ return thread_name.name(); ++ } ++ } ++ } ++ ++ return ""; ++} ++ ++void MinidumpThreadNamesList::Print() { ++ if (!valid_) { ++ BPLOG(ERROR) << "MinidumpThreadNamesList cannot print invalid data"; ++ return; ++ } ++ ++ printf("MinidumpThreadNamesList\n"); ++ printf(" name_count = %d\n", name_count_); ++ printf("\n"); ++ ++ for (unsigned int name_index = 0; ++ name_index < name_count_; ++ ++name_index) { ++ printf("thread_name[%d]\n", name_index); ++ ++ (*thread_names_)[name_index].Print(); ++ } ++} ++ ++bool MinidumpThreadNamesList::Read(uint32_t expected_size) { ++ delete thread_names_; ++ thread_names_ = NULL; ++ name_count_ = 0; ++ ++ valid_ = false; ++ ++ uint32_t number_of_thread_names; ++ if (!minidump_->ReadBytes(&number_of_thread_names, sizeof(number_of_thread_names))) { ++ BPLOG(ERROR) << "MinidumpThreadNamesList could not read the number of thread names"; ++ return false; ++ } ++ ++ if (minidump_->swap()) { ++ Swap(&number_of_thread_names); ++ } ++ ++ if (expected_size != ++ sizeof(number_of_thread_names) + (sizeof(MDRawThreadName) * number_of_thread_names)) { ++ BPLOG(ERROR) << "MinidumpThreadNamesList expected_size mismatch " << ++ expected_size << " != " << sizeof(number_of_thread_names) << " + (" << ++ sizeof(MDRawThreadName) << " * " << number_of_thread_names << ")"; ++ return false; ++ } ++ ++ if (number_of_thread_names != 0) { ++ scoped_ptr<MinidumpThreadNames> thread_names( ++ new MinidumpThreadNames(number_of_thread_names, ++ MinidumpThreadName(minidump_))); ++ ++ for (unsigned int name_index = 0; ++ name_index < number_of_thread_names; ++ ++name_index) { ++ MinidumpThreadName* thread_name = &(*thread_names)[name_index]; ++ ++ if (!thread_name->Read(sizeof(MDRawThreadName))) { ++ BPLOG(ERROR) << "MinidumpThreadNamesList could not read name " << ++ name_index << "/" << number_of_thread_names; ++ return false; ++ } ++ } ++ ++ for (unsigned int name_index = 0; ++ name_index < number_of_thread_names; ++ ++name_index) { ++ MinidumpThreadName* thread_name = &(*thread_names)[name_index]; ++ ++ if (!thread_name->ReadAuxiliaryData()) { ++ BPLOG(ERROR) << "MinidumpThreadNamesList could not read required " ++ "auxiliary data for thread name " << ++ name_index << "/" << number_of_thread_names; ++ return false; ++ } ++ } ++ thread_names_ = thread_names.release(); ++ } ++ ++ name_count_ = number_of_thread_names; ++ valid_ = true; ++ return true; ++} ++ + static const char* get_stream_name(uint32_t stream_type) { + switch (stream_type) { + case MD_UNUSED_STREAM: + return "MD_UNUSED_STREAM"; + case MD_RESERVED_STREAM_0: + return "MD_RESERVED_STREAM_0"; + case MD_RESERVED_STREAM_1: + return "MD_RESERVED_STREAM_1"; +@@ -5772,16 +5982,20 @@ static const char* get_stream_name(uint3 + case MD_TOKEN_STREAM: + return "MD_TOKEN_STREAM"; + case MD_JAVASCRIPT_DATA_STREAM: + return "MD_JAVASCRIPT_DATA_STREAM"; + case MD_SYSTEM_MEMORY_INFO_STREAM: + return "MD_SYSTEM_MEMORY_INFO_STREAM"; + case MD_PROCESS_VM_COUNTERS_STREAM: + return "MD_PROCESS_VM_COUNTERS_STREAM"; ++ case MD_IPT_TRACE_STREAM: ++ return "MD_IPT_TRACE_STREAM"; ++ case MD_THREAD_NAMES_STREAM: ++ return "MD_THREAD_NAMES_STREAM"; + case MD_LAST_RESERVED_STREAM: + return "MD_LAST_RESERVED_STREAM"; + case MD_BREAKPAD_INFO_STREAM: + return "MD_BREAKPAD_INFO_STREAM"; + case MD_ASSERTION_INFO_STREAM: + return "MD_ASSERTION_INFO_STREAM"; + case MD_LINUX_CPU_INFO: + return "MD_LINUX_CPU_INFO"; +diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc +--- a/src/processor/minidump_dump.cc ++++ b/src/processor/minidump_dump.cc +@@ -49,16 +49,17 @@ using google_breakpad::MinidumpUnloadedM + using google_breakpad::MinidumpMemoryInfoList; + using google_breakpad::MinidumpMemoryList; + using google_breakpad::MinidumpException; + using google_breakpad::MinidumpAssertion; + using google_breakpad::MinidumpSystemInfo; + using google_breakpad::MinidumpMiscInfo; + using google_breakpad::MinidumpBreakpadInfo; + using google_breakpad::MinidumpCrashpadInfo; ++using google_breakpad::MinidumpThreadNamesList; + + struct Options { + Options() + : minidumpPath(), hexdump(false), hexdump_width(16) {} + + string minidumpPath; + bool hexdump; + unsigned int hexdump_width; +@@ -197,16 +198,21 @@ static bool PrintMinidumpDump(const Opti + } + + MinidumpCrashpadInfo *crashpad_info = minidump.GetCrashpadInfo(); + if (crashpad_info) { + // Crashpad info is optional, so don't treat absence as an error. + crashpad_info->Print(); + } + ++ MinidumpThreadNamesList *thread_names_list = minidump.GetThreadNamesList(); ++ if (thread_names_list) { ++ thread_names_list->Print(); ++ } ++ + DumpRawStream(&minidump, + MD_LINUX_CMD_LINE, + "MD_LINUX_CMD_LINE", + &errors); + DumpRawStream(&minidump, + MD_LINUX_ENVIRON, + "MD_LINUX_ENVIRON", + &errors); +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -173,16 +173,22 @@ ProcessResult MinidumpProcessor::Process + } + + MinidumpMemoryList *memory_list = dump->GetMemoryList(); + if (memory_list) { + BPLOG(INFO) << "Found " << memory_list->region_count() + << " memory regions."; + } + ++ MinidumpThreadNamesList* thread_names_list = dump->GetThreadNamesList(); ++ if (thread_names_list) { ++ BPLOG(INFO) << "Found " << thread_names_list->name_count() ++ << " thread names."; ++ } ++ + MinidumpThreadList *threads = dump->GetThreadList(); + if (!threads) { + BPLOG(ERROR) << "Minidump " << dump->path() << " has no thread list"; + return PROCESS_ERROR_NO_THREAD_LIST; + } + + BPLOG(INFO) << "Minidump " << dump->path() << " has " << + (has_cpu_info ? "" : "no ") << "CPU info, " << +@@ -308,16 +314,19 @@ ProcessResult MinidumpProcessor::Process + } else { + // Threads with missing CPU contexts will hit this, but + // don't abort processing the rest of the dump just for + // one bad thread. + BPLOG(ERROR) << "No stackwalker for " << thread_string; + } + stack->set_tid(thread_id); + stack->set_last_error(thread->GetLastError()); ++ if (thread_names_list) { ++ stack->set_name(thread_names_list->GetNameForThreadId(thread_id)); ++ } + process_state->threads_.push_back(stack.release()); + process_state->thread_memory_regions_.push_back(thread_memory); + } + + if (interrupted) { + BPLOG(INFO) << "Processing interrupted for " << dump->path(); + return PROCESS_SYMBOL_SUPPLIER_INTERRUPTED; + } +diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc +--- a/src/processor/stackwalk_common.cc ++++ b/src/processor/stackwalk_common.cc +@@ -876,35 +876,45 @@ void PrintProcessState(const ProcessStat + printf("\n"); + printf("Application-specific information:\n"); + printf("%s", process_state.mac_crash_info().c_str()); + } + + // If the thread that requested the dump is known, print it first. + int requesting_thread = process_state.requesting_thread(); + if (requesting_thread != -1) { +- printf("\n"); +- printf("Thread %d (%s)\n", +- requesting_thread, +- process_state.crashed() ? "crashed" : +- "requested dump, did not crash"); +- PrintStack(process_state.threads()->at(requesting_thread), cpu, ++ const CallStack* requesting_thread_callstack = ++ process_state.threads()->at(requesting_thread); ++ printf("\n" ++ "Thread %d (%s)", ++ requesting_thread, ++ process_state.crashed() ? "crashed" : ++ "requested dump, did not crash"); ++ if (!requesting_thread_callstack->name().empty()) { ++ printf(" - %s", requesting_thread_callstack->name().c_str()); ++ } ++ PrintStack(requesting_thread_callstack, cpu, + output_stack_contents, + process_state.thread_memory_regions()->at(requesting_thread), + process_state.modules(), resolver); + } + + // Print all of the threads in the dump. + int thread_count = process_state.threads()->size(); + for (int thread_index = 0; thread_index < thread_count; ++thread_index) { + if (thread_index != requesting_thread) { + // Don't print the crash thread again, it was already printed. ++ const CallStack* callstack = process_state.threads()->at(thread_index); ++ printf("\n" ++ "Thread %d", thread_index); ++ if (!callstack->name().empty()) { ++ printf(" - %s", callstack->name().c_str()); ++ } + printf("\n"); +- printf("Thread %d\n", thread_index); +- PrintStack(process_state.threads()->at(thread_index), cpu, ++ PrintStack(callstack, cpu, + output_stack_contents, + process_state.thread_memory_regions()->at(thread_index), + process_state.modules(), resolver); + } + } + + PrintModules(process_state.modules(), + process_state.modules_without_symbols(), diff --git a/toolkit/crashreporter/breakpad-patches/22-winerror-codes.patch b/toolkit/crashreporter/breakpad-patches/22-winerror-codes.patch new file mode 100644 index 0000000000..f0845366dc --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/22-winerror-codes.patch @@ -0,0 +1,22069 @@ +diff --git a/src/google_breakpad/common/minidump_exception_win32.h b/src/google_breakpad/common/minidump_exception_win32.h +--- a/src/google_breakpad/common/minidump_exception_win32.h ++++ b/src/google_breakpad/common/minidump_exception_win32.h +@@ -2925,9 +2925,2651 @@ typedef enum { + MD_FAST_FAIL_WIN_UNEXPECTED_HOST_BEHAVIOR = 58, + MD_FAST_FAIL_WIN_FLAGS_CORRUPTION = 59, + MD_FAST_FAIL_WIN_VEH_CORRUPTION = 60, + MD_FAST_FAIL_WIN_ETW_CORRUPTION = 61, + MD_FAST_FAIL_WIN_RIO_ABORT = 62, + MD_FAST_FAIL_WIN_INVALID_PFN = 63, + } MDFastFailWin; + ++/* For various (MDException).exception_information entries. This describes the ++* underlying reason for the crash. These values come from winerror.h. ++ * ++ * The content of this enum was created from winnt.h in the 10 SDK ++ * (version 10.0.19041.0) with ++ * ++ * egrep -o '#define ERROR_[A-Z_0-9]+\s+[0-9]+L' winerror.h ++ * | tr -d '\r' ++ * | sed -r 's@#define ERROR_([A-Z_0-9]+)\s+([0-9]+)L@\2 \1@' ++ * | sort -n ++ * | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ MD_ERROR_WIN_\2 = \1,@' */ ++typedef enum { ++ MD_ERROR_WIN_SUCCESS = 0, ++ MD_ERROR_WIN_INVALID_FUNCTION = 1, ++ MD_ERROR_WIN_FILE_NOT_FOUND = 2, ++ MD_ERROR_WIN_PATH_NOT_FOUND = 3, ++ MD_ERROR_WIN_TOO_MANY_OPEN_FILES = 4, ++ MD_ERROR_WIN_ACCESS_DENIED = 5, ++ MD_ERROR_WIN_INVALID_HANDLE = 6, ++ MD_ERROR_WIN_ARENA_TRASHED = 7, ++ MD_ERROR_WIN_NOT_ENOUGH_MEMORY = 8, ++ MD_ERROR_WIN_INVALID_BLOCK = 9, ++ MD_ERROR_WIN_BAD_ENVIRONMENT = 10, ++ MD_ERROR_WIN_BAD_FORMAT = 11, ++ MD_ERROR_WIN_INVALID_ACCESS = 12, ++ MD_ERROR_WIN_INVALID_DATA = 13, ++ MD_ERROR_WIN_OUTOFMEMORY = 14, ++ MD_ERROR_WIN_INVALID_DRIVE = 15, ++ MD_ERROR_WIN_CURRENT_DIRECTORY = 16, ++ MD_ERROR_WIN_NOT_SAME_DEVICE = 17, ++ MD_ERROR_WIN_NO_MORE_FILES = 18, ++ MD_ERROR_WIN_WRITE_PROTECT = 19, ++ MD_ERROR_WIN_BAD_UNIT = 20, ++ MD_ERROR_WIN_NOT_READY = 21, ++ MD_ERROR_WIN_BAD_COMMAND = 22, ++ MD_ERROR_WIN_CRC = 23, ++ MD_ERROR_WIN_BAD_LENGTH = 24, ++ MD_ERROR_WIN_SEEK = 25, ++ MD_ERROR_WIN_NOT_DOS_DISK = 26, ++ MD_ERROR_WIN_SECTOR_NOT_FOUND = 27, ++ MD_ERROR_WIN_OUT_OF_PAPER = 28, ++ MD_ERROR_WIN_WRITE_FAULT = 29, ++ MD_ERROR_WIN_READ_FAULT = 30, ++ MD_ERROR_WIN_GEN_FAILURE = 31, ++ MD_ERROR_WIN_SHARING_VIOLATION = 32, ++ MD_ERROR_WIN_LOCK_VIOLATION = 33, ++ MD_ERROR_WIN_WRONG_DISK = 34, ++ MD_ERROR_WIN_SHARING_BUFFER_EXCEEDED = 36, ++ MD_ERROR_WIN_HANDLE_EOF = 38, ++ MD_ERROR_WIN_HANDLE_DISK_FULL = 39, ++ MD_ERROR_WIN_NOT_SUPPORTED = 50, ++ MD_ERROR_WIN_REM_NOT_LIST = 51, ++ MD_ERROR_WIN_DUP_NAME = 52, ++ MD_ERROR_WIN_BAD_NETPATH = 53, ++ MD_ERROR_WIN_NETWORK_BUSY = 54, ++ MD_ERROR_WIN_DEV_NOT_EXIST = 55, ++ MD_ERROR_WIN_TOO_MANY_CMDS = 56, ++ MD_ERROR_WIN_ADAP_HDW_ERR = 57, ++ MD_ERROR_WIN_BAD_NET_RESP = 58, ++ MD_ERROR_WIN_UNEXP_NET_ERR = 59, ++ MD_ERROR_WIN_BAD_REM_ADAP = 60, ++ MD_ERROR_WIN_PRINTQ_FULL = 61, ++ MD_ERROR_WIN_NO_SPOOL_SPACE = 62, ++ MD_ERROR_WIN_PRINT_CANCELLED = 63, ++ MD_ERROR_WIN_NETNAME_DELETED = 64, ++ MD_ERROR_WIN_NETWORK_ACCESS_DENIED = 65, ++ MD_ERROR_WIN_BAD_DEV_TYPE = 66, ++ MD_ERROR_WIN_BAD_NET_NAME = 67, ++ MD_ERROR_WIN_TOO_MANY_NAMES = 68, ++ MD_ERROR_WIN_TOO_MANY_SESS = 69, ++ MD_ERROR_WIN_SHARING_PAUSED = 70, ++ MD_ERROR_WIN_REQ_NOT_ACCEP = 71, ++ MD_ERROR_WIN_REDIR_PAUSED = 72, ++ MD_ERROR_WIN_FILE_EXISTS = 80, ++ MD_ERROR_WIN_CANNOT_MAKE = 82, ++ MD_ERROR_WIN_FAIL_I24 = 83, ++ MD_ERROR_WIN_OUT_OF_STRUCTURES = 84, ++ MD_ERROR_WIN_ALREADY_ASSIGNED = 85, ++ MD_ERROR_WIN_INVALID_PASSWORD = 86, ++ MD_ERROR_WIN_INVALID_PARAMETER = 87, ++ MD_ERROR_WIN_NET_WRITE_FAULT = 88, ++ MD_ERROR_WIN_NO_PROC_SLOTS = 89, ++ MD_ERROR_WIN_TOO_MANY_SEMAPHORES = 100, ++ MD_ERROR_WIN_EXCL_SEM_ALREADY_OWNED = 101, ++ MD_ERROR_WIN_SEM_IS_SET = 102, ++ MD_ERROR_WIN_TOO_MANY_SEM_REQUESTS = 103, ++ MD_ERROR_WIN_INVALID_AT_INTERRUPT_TIME = 104, ++ MD_ERROR_WIN_SEM_OWNER_DIED = 105, ++ MD_ERROR_WIN_SEM_USER_LIMIT = 106, ++ MD_ERROR_WIN_DISK_CHANGE = 107, ++ MD_ERROR_WIN_DRIVE_LOCKED = 108, ++ MD_ERROR_WIN_BROKEN_PIPE = 109, ++ MD_ERROR_WIN_OPEN_FAILED = 110, ++ MD_ERROR_WIN_BUFFER_OVERFLOW = 111, ++ MD_ERROR_WIN_DISK_FULL = 112, ++ MD_ERROR_WIN_NO_MORE_SEARCH_HANDLES = 113, ++ MD_ERROR_WIN_INVALID_TARGET_HANDLE = 114, ++ MD_ERROR_WIN_INVALID_CATEGORY = 117, ++ MD_ERROR_WIN_INVALID_VERIFY_SWITCH = 118, ++ MD_ERROR_WIN_BAD_DRIVER_LEVEL = 119, ++ MD_ERROR_WIN_CALL_NOT_IMPLEMENTED = 120, ++ MD_ERROR_WIN_SEM_TIMEOUT = 121, ++ MD_ERROR_WIN_INSUFFICIENT_BUFFER = 122, ++ MD_ERROR_WIN_INVALID_NAME = 123, ++ MD_ERROR_WIN_INVALID_LEVEL = 124, ++ MD_ERROR_WIN_NO_VOLUME_LABEL = 125, ++ MD_ERROR_WIN_MOD_NOT_FOUND = 126, ++ MD_ERROR_WIN_PROC_NOT_FOUND = 127, ++ MD_ERROR_WIN_WAIT_NO_CHILDREN = 128, ++ MD_ERROR_WIN_CHILD_NOT_COMPLETE = 129, ++ MD_ERROR_WIN_DIRECT_ACCESS_HANDLE = 130, ++ MD_ERROR_WIN_NEGATIVE_SEEK = 131, ++ MD_ERROR_WIN_SEEK_ON_DEVICE = 132, ++ MD_ERROR_WIN_IS_JOIN_TARGET = 133, ++ MD_ERROR_WIN_IS_JOINED = 134, ++ MD_ERROR_WIN_IS_SUBSTED = 135, ++ MD_ERROR_WIN_NOT_JOINED = 136, ++ MD_ERROR_WIN_NOT_SUBSTED = 137, ++ MD_ERROR_WIN_JOIN_TO_JOIN = 138, ++ MD_ERROR_WIN_SUBST_TO_SUBST = 139, ++ MD_ERROR_WIN_JOIN_TO_SUBST = 140, ++ MD_ERROR_WIN_SUBST_TO_JOIN = 141, ++ MD_ERROR_WIN_BUSY_DRIVE = 142, ++ MD_ERROR_WIN_SAME_DRIVE = 143, ++ MD_ERROR_WIN_DIR_NOT_ROOT = 144, ++ MD_ERROR_WIN_DIR_NOT_EMPTY = 145, ++ MD_ERROR_WIN_IS_SUBST_PATH = 146, ++ MD_ERROR_WIN_IS_JOIN_PATH = 147, ++ MD_ERROR_WIN_PATH_BUSY = 148, ++ MD_ERROR_WIN_IS_SUBST_TARGET = 149, ++ MD_ERROR_WIN_SYSTEM_TRACE = 150, ++ MD_ERROR_WIN_INVALID_EVENT_COUNT = 151, ++ MD_ERROR_WIN_TOO_MANY_MUXWAITERS = 152, ++ MD_ERROR_WIN_INVALID_LIST_FORMAT = 153, ++ MD_ERROR_WIN_LABEL_TOO_LONG = 154, ++ MD_ERROR_WIN_TOO_MANY_TCBS = 155, ++ MD_ERROR_WIN_SIGNAL_REFUSED = 156, ++ MD_ERROR_WIN_DISCARDED = 157, ++ MD_ERROR_WIN_NOT_LOCKED = 158, ++ MD_ERROR_WIN_BAD_THREADID_ADDR = 159, ++ MD_ERROR_WIN_BAD_ARGUMENTS = 160, ++ MD_ERROR_WIN_BAD_PATHNAME = 161, ++ MD_ERROR_WIN_SIGNAL_PENDING = 162, ++ MD_ERROR_WIN_MAX_THRDS_REACHED = 164, ++ MD_ERROR_WIN_LOCK_FAILED = 167, ++ MD_ERROR_WIN_BUSY = 170, ++ MD_ERROR_WIN_DEVICE_SUPPORT_IN_PROGRESS = 171, ++ MD_ERROR_WIN_CANCEL_VIOLATION = 173, ++ MD_ERROR_WIN_ATOMIC_LOCKS_NOT_SUPPORTED = 174, ++ MD_ERROR_WIN_INVALID_SEGMENT_NUMBER = 180, ++ MD_ERROR_WIN_INVALID_ORDINAL = 182, ++ MD_ERROR_WIN_ALREADY_EXISTS = 183, ++ MD_ERROR_WIN_INVALID_FLAG_NUMBER = 186, ++ MD_ERROR_WIN_SEM_NOT_FOUND = 187, ++ MD_ERROR_WIN_INVALID_STARTING_CODESEG = 188, ++ MD_ERROR_WIN_INVALID_STACKSEG = 189, ++ MD_ERROR_WIN_INVALID_MODULETYPE = 190, ++ MD_ERROR_WIN_INVALID_EXE_SIGNATURE = 191, ++ MD_ERROR_WIN_EXE_MARKED_INVALID = 192, ++ MD_ERROR_WIN_BAD_EXE_FORMAT = 193, ++ MD_ERROR_WIN_INVALID_MINALLOCSIZE = 195, ++ MD_ERROR_WIN_DYNLINK_FROM_INVALID_RING = 196, ++ MD_ERROR_WIN_IOPL_NOT_ENABLED = 197, ++ MD_ERROR_WIN_INVALID_SEGDPL = 198, ++ MD_ERROR_WIN_RING2SEG_MUST_BE_MOVABLE = 200, ++ MD_ERROR_WIN_RELOC_CHAIN_XEEDS_SEGLIM = 201, ++ MD_ERROR_WIN_INFLOOP_IN_RELOC_CHAIN = 202, ++ MD_ERROR_WIN_ENVVAR_NOT_FOUND = 203, ++ MD_ERROR_WIN_NO_SIGNAL_SENT = 205, ++ MD_ERROR_WIN_FILENAME_EXCED_RANGE = 206, ++ MD_ERROR_WIN_RING2_STACK_IN_USE = 207, ++ MD_ERROR_WIN_META_EXPANSION_TOO_LONG = 208, ++ MD_ERROR_WIN_INVALID_SIGNAL_NUMBER = 209, ++ MD_ERROR_WIN_THREAD_1_INACTIVE = 210, ++ MD_ERROR_WIN_LOCKED = 212, ++ MD_ERROR_WIN_TOO_MANY_MODULES = 214, ++ MD_ERROR_WIN_NESTING_NOT_ALLOWED = 215, ++ MD_ERROR_WIN_EXE_MACHINE_TYPE_MISMATCH = 216, ++ MD_ERROR_WIN_EXE_CANNOT_MODIFY_SIGNED_BINARY = 217, ++ MD_ERROR_WIN_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY = 218, ++ MD_ERROR_WIN_FILE_CHECKED_OUT = 220, ++ MD_ERROR_WIN_CHECKOUT_REQUIRED = 221, ++ MD_ERROR_WIN_BAD_FILE_TYPE = 222, ++ MD_ERROR_WIN_FILE_TOO_LARGE = 223, ++ MD_ERROR_WIN_FORMS_AUTH_REQUIRED = 224, ++ MD_ERROR_WIN_VIRUS_INFECTED = 225, ++ MD_ERROR_WIN_VIRUS_DELETED = 226, ++ MD_ERROR_WIN_PIPE_LOCAL = 229, ++ MD_ERROR_WIN_BAD_PIPE = 230, ++ MD_ERROR_WIN_PIPE_BUSY = 231, ++ MD_ERROR_WIN_NO_DATA = 232, ++ MD_ERROR_WIN_PIPE_NOT_CONNECTED = 233, ++ MD_ERROR_WIN_MORE_DATA = 234, ++ MD_ERROR_WIN_NO_WORK_DONE = 235, ++ MD_ERROR_WIN_VC_DISCONNECTED = 240, ++ MD_ERROR_WIN_INVALID_EA_NAME = 254, ++ MD_ERROR_WIN_EA_LIST_INCONSISTENT = 255, ++ MD_ERROR_WIN_NO_MORE_ITEMS = 259, ++ MD_ERROR_WIN_CANNOT_COPY = 266, ++ MD_ERROR_WIN_DIRECTORY = 267, ++ MD_ERROR_WIN_EAS_DIDNT_FIT = 275, ++ MD_ERROR_WIN_EA_FILE_CORRUPT = 276, ++ MD_ERROR_WIN_EA_TABLE_FULL = 277, ++ MD_ERROR_WIN_INVALID_EA_HANDLE = 278, ++ MD_ERROR_WIN_EAS_NOT_SUPPORTED = 282, ++ MD_ERROR_WIN_NOT_OWNER = 288, ++ MD_ERROR_WIN_TOO_MANY_POSTS = 298, ++ MD_ERROR_WIN_PARTIAL_COPY = 299, ++ MD_ERROR_WIN_OPLOCK_NOT_GRANTED = 300, ++ MD_ERROR_WIN_INVALID_OPLOCK_PROTOCOL = 301, ++ MD_ERROR_WIN_DISK_TOO_FRAGMENTED = 302, ++ MD_ERROR_WIN_DELETE_PENDING = 303, ++ MD_ERROR_WIN_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING = 304, ++ MD_ERROR_WIN_SHORT_NAMES_NOT_ENABLED_ON_VOLUME = 305, ++ MD_ERROR_WIN_SECURITY_STREAM_IS_INCONSISTENT = 306, ++ MD_ERROR_WIN_INVALID_LOCK_RANGE = 307, ++ MD_ERROR_WIN_IMAGE_SUBSYSTEM_NOT_PRESENT = 308, ++ MD_ERROR_WIN_NOTIFICATION_GUID_ALREADY_DEFINED = 309, ++ MD_ERROR_WIN_INVALID_EXCEPTION_HANDLER = 310, ++ MD_ERROR_WIN_DUPLICATE_PRIVILEGES = 311, ++ MD_ERROR_WIN_NO_RANGES_PROCESSED = 312, ++ MD_ERROR_WIN_NOT_ALLOWED_ON_SYSTEM_FILE = 313, ++ MD_ERROR_WIN_DISK_RESOURCES_EXHAUSTED = 314, ++ MD_ERROR_WIN_INVALID_TOKEN = 315, ++ MD_ERROR_WIN_DEVICE_FEATURE_NOT_SUPPORTED = 316, ++ MD_ERROR_WIN_MR_MID_NOT_FOUND = 317, ++ MD_ERROR_WIN_SCOPE_NOT_FOUND = 318, ++ MD_ERROR_WIN_UNDEFINED_SCOPE = 319, ++ MD_ERROR_WIN_INVALID_CAP = 320, ++ MD_ERROR_WIN_DEVICE_UNREACHABLE = 321, ++ MD_ERROR_WIN_DEVICE_NO_RESOURCES = 322, ++ MD_ERROR_WIN_DATA_CHECKSUM_ERROR = 323, ++ MD_ERROR_WIN_INTERMIXED_KERNEL_EA_OPERATION = 324, ++ MD_ERROR_WIN_FILE_LEVEL_TRIM_NOT_SUPPORTED = 326, ++ MD_ERROR_WIN_OFFSET_ALIGNMENT_VIOLATION = 327, ++ MD_ERROR_WIN_INVALID_FIELD_IN_PARAMETER_LIST = 328, ++ MD_ERROR_WIN_OPERATION_IN_PROGRESS = 329, ++ MD_ERROR_WIN_BAD_DEVICE_PATH = 330, ++ MD_ERROR_WIN_TOO_MANY_DESCRIPTORS = 331, ++ MD_ERROR_WIN_SCRUB_DATA_DISABLED = 332, ++ MD_ERROR_WIN_NOT_REDUNDANT_STORAGE = 333, ++ MD_ERROR_WIN_RESIDENT_FILE_NOT_SUPPORTED = 334, ++ MD_ERROR_WIN_COMPRESSED_FILE_NOT_SUPPORTED = 335, ++ MD_ERROR_WIN_DIRECTORY_NOT_SUPPORTED = 336, ++ MD_ERROR_WIN_NOT_READ_FROM_COPY = 337, ++ MD_ERROR_WIN_FT_WRITE_FAILURE = 338, ++ MD_ERROR_WIN_FT_DI_SCAN_REQUIRED = 339, ++ MD_ERROR_WIN_INVALID_KERNEL_INFO_VERSION = 340, ++ MD_ERROR_WIN_INVALID_PEP_INFO_VERSION = 341, ++ MD_ERROR_WIN_OBJECT_NOT_EXTERNALLY_BACKED = 342, ++ MD_ERROR_WIN_EXTERNAL_BACKING_PROVIDER_UNKNOWN = 343, ++ MD_ERROR_WIN_COMPRESSION_NOT_BENEFICIAL = 344, ++ MD_ERROR_WIN_STORAGE_TOPOLOGY_ID_MISMATCH = 345, ++ MD_ERROR_WIN_BLOCKED_BY_PARENTAL_CONTROLS = 346, ++ MD_ERROR_WIN_BLOCK_TOO_MANY_REFERENCES = 347, ++ MD_ERROR_WIN_MARKED_TO_DISALLOW_WRITES = 348, ++ MD_ERROR_WIN_ENCLAVE_FAILURE = 349, ++ MD_ERROR_WIN_FAIL_NOACTION_REBOOT = 350, ++ MD_ERROR_WIN_FAIL_SHUTDOWN = 351, ++ MD_ERROR_WIN_FAIL_RESTART = 352, ++ MD_ERROR_WIN_MAX_SESSIONS_REACHED = 353, ++ MD_ERROR_WIN_NETWORK_ACCESS_DENIED_EDP = 354, ++ MD_ERROR_WIN_DEVICE_HINT_NAME_BUFFER_TOO_SMALL = 355, ++ MD_ERROR_WIN_EDP_POLICY_DENIES_OPERATION = 356, ++ MD_ERROR_WIN_EDP_DPL_POLICY_CANT_BE_SATISFIED = 357, ++ MD_ERROR_WIN_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT = 358, ++ MD_ERROR_WIN_DEVICE_IN_MAINTENANCE = 359, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_DAX = 360, ++ MD_ERROR_WIN_DAX_MAPPING_EXISTS = 361, ++ MD_ERROR_WIN_CLOUD_FILE_PROVIDER_NOT_RUNNING = 362, ++ MD_ERROR_WIN_CLOUD_FILE_METADATA_CORRUPT = 363, ++ MD_ERROR_WIN_CLOUD_FILE_METADATA_TOO_LARGE = 364, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE = 365, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH = 366, ++ MD_ERROR_WIN_CHILD_PROCESS_BLOCKED = 367, ++ MD_ERROR_WIN_STORAGE_LOST_DATA_PERSISTENCE = 368, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE = 369, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT = 370, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_BUSY = 371, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN = 372, ++ MD_ERROR_WIN_GDI_HANDLE_LEAK = 373, ++ MD_ERROR_WIN_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS = 374, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED = 375, ++ MD_ERROR_WIN_NOT_A_CLOUD_FILE = 376, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_IN_SYNC = 377, ++ MD_ERROR_WIN_CLOUD_FILE_ALREADY_CONNECTED = 378, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_SUPPORTED = 379, ++ MD_ERROR_WIN_CLOUD_FILE_INVALID_REQUEST = 380, ++ MD_ERROR_WIN_CLOUD_FILE_READ_ONLY_VOLUME = 381, ++ MD_ERROR_WIN_CLOUD_FILE_CONNECTED_PROVIDER_ONLY = 382, ++ MD_ERROR_WIN_CLOUD_FILE_VALIDATION_FAILED = 383, ++ MD_ERROR_WIN_SMB1_NOT_AVAILABLE = 384, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION = 385, ++ MD_ERROR_WIN_CLOUD_FILE_AUTHENTICATION_FAILED = 386, ++ MD_ERROR_WIN_CLOUD_FILE_INSUFFICIENT_RESOURCES = 387, ++ MD_ERROR_WIN_CLOUD_FILE_NETWORK_UNAVAILABLE = 388, ++ MD_ERROR_WIN_CLOUD_FILE_UNSUCCESSFUL = 389, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_UNDER_SYNC_ROOT = 390, ++ MD_ERROR_WIN_CLOUD_FILE_IN_USE = 391, ++ MD_ERROR_WIN_CLOUD_FILE_PINNED = 392, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_ABORTED = 393, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_CORRUPT = 394, ++ MD_ERROR_WIN_CLOUD_FILE_ACCESS_DENIED = 395, ++ MD_ERROR_WIN_CLOUD_FILE_INCOMPATIBLE_HARDLINKS = 396, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_LOCK_CONFLICT = 397, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_CANCELED = 398, ++ MD_ERROR_WIN_EXTERNAL_SYSKEY_NOT_SUPPORTED = 399, ++ MD_ERROR_WIN_THREAD_MODE_ALREADY_BACKGROUND = 400, ++ MD_ERROR_WIN_THREAD_MODE_NOT_BACKGROUND = 401, ++ MD_ERROR_WIN_PROCESS_MODE_ALREADY_BACKGROUND = 402, ++ MD_ERROR_WIN_PROCESS_MODE_NOT_BACKGROUND = 403, ++ MD_ERROR_WIN_CLOUD_FILE_PROVIDER_TERMINATED = 404, ++ MD_ERROR_WIN_NOT_A_CLOUD_SYNC_ROOT = 405, ++ MD_ERROR_WIN_FILE_PROTECTED_UNDER_DPL = 406, ++ MD_ERROR_WIN_VOLUME_NOT_CLUSTER_ALIGNED = 407, ++ MD_ERROR_WIN_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND = 408, ++ MD_ERROR_WIN_APPX_FILE_NOT_ENCRYPTED = 409, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED = 410, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET = 411, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE = 412, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER = 413, ++ MD_ERROR_WIN_LINUX_SUBSYSTEM_NOT_PRESENT = 414, ++ MD_ERROR_WIN_FT_READ_FAILURE = 415, ++ MD_ERROR_WIN_STORAGE_RESERVE_ID_INVALID = 416, ++ MD_ERROR_WIN_STORAGE_RESERVE_DOES_NOT_EXIST = 417, ++ MD_ERROR_WIN_STORAGE_RESERVE_ALREADY_EXISTS = 418, ++ MD_ERROR_WIN_STORAGE_RESERVE_NOT_EMPTY = 419, ++ MD_ERROR_WIN_NOT_A_DAX_VOLUME = 420, ++ MD_ERROR_WIN_NOT_DAX_MAPPABLE = 421, ++ MD_ERROR_WIN_TIME_SENSITIVE_THREAD = 422, ++ MD_ERROR_WIN_DPL_NOT_SUPPORTED_FOR_USER = 423, ++ MD_ERROR_WIN_CASE_DIFFERING_NAMES_IN_DIR = 424, ++ MD_ERROR_WIN_FILE_NOT_SUPPORTED = 425, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_TIMEOUT = 426, ++ MD_ERROR_WIN_NO_TASK_QUEUE = 427, ++ MD_ERROR_WIN_SRC_SRV_DLL_LOAD_FAILED = 428, ++ MD_ERROR_WIN_NOT_SUPPORTED_WITH_BTT = 429, ++ MD_ERROR_WIN_ENCRYPTION_DISABLED = 430, ++ MD_ERROR_WIN_ENCRYPTING_METADATA_DISALLOWED = 431, ++ MD_ERROR_WIN_CANT_CLEAR_ENCRYPTION_FLAG = 432, ++ MD_ERROR_WIN_NO_SUCH_DEVICE = 433, ++ MD_ERROR_WIN_CLOUD_FILE_DEHYDRATION_DISALLOWED = 434, ++ MD_ERROR_WIN_FILE_SNAP_IN_PROGRESS = 435, ++ MD_ERROR_WIN_FILE_SNAP_USER_SECTION_NOT_SUPPORTED = 436, ++ MD_ERROR_WIN_FILE_SNAP_MODIFY_NOT_SUPPORTED = 437, ++ MD_ERROR_WIN_FILE_SNAP_IO_NOT_COORDINATED = 438, ++ MD_ERROR_WIN_FILE_SNAP_UNEXPECTED_ERROR = 439, ++ MD_ERROR_WIN_FILE_SNAP_INVALID_PARAMETER = 440, ++ MD_ERROR_WIN_UNSATISFIED_DEPENDENCIES = 441, ++ MD_ERROR_WIN_CASE_SENSITIVE_PATH = 442, ++ MD_ERROR_WIN_UNEXPECTED_NTCACHEMANAGER_ERROR = 443, ++ MD_ERROR_WIN_LINUX_SUBSYSTEM_UPDATE_REQUIRED = 444, ++ MD_ERROR_WIN_DLP_POLICY_WARNS_AGAINST_OPERATION = 445, ++ MD_ERROR_WIN_DLP_POLICY_DENIES_OPERATION = 446, ++ MD_ERROR_WIN_DLP_POLICY_SILENTLY_FAIL = 449, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_DEVUNLOCKED = 450, ++ MD_ERROR_WIN_CAPAUTHZ_CHANGE_TYPE = 451, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_PROVISIONED = 452, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_AUTHORIZED = 453, ++ MD_ERROR_WIN_CAPAUTHZ_NO_POLICY = 454, ++ MD_ERROR_WIN_CAPAUTHZ_DB_CORRUPTED = 455, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_INVALID_CATALOG = 456, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_NO_AUTH_ENTITY = 457, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_PARSE_ERROR = 458, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_DEV_MODE_REQUIRED = 459, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCH = 460, ++ MD_ERROR_WIN_CIMFS_IMAGE_CORRUPT = 470, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_DEVICE_TIMEOUT = 480, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUT = 481, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUT = 482, ++ MD_ERROR_WIN_DEVICE_HARDWARE_ERROR = 483, ++ MD_ERROR_WIN_INVALID_ADDRESS = 487, ++ MD_ERROR_WIN_HAS_SYSTEM_CRITICAL_FILES = 488, ++ MD_ERROR_WIN_USER_PROFILE_LOAD = 500, ++ MD_ERROR_WIN_ARITHMETIC_OVERFLOW = 534, ++ MD_ERROR_WIN_PIPE_CONNECTED = 535, ++ MD_ERROR_WIN_PIPE_LISTENING = 536, ++ MD_ERROR_WIN_VERIFIER_STOP = 537, ++ MD_ERROR_WIN_ABIOS_ERROR = 538, ++ MD_ERROR_WIN_WX86_WARNING = 539, ++ MD_ERROR_WIN_WX86_ERROR = 540, ++ MD_ERROR_WIN_TIMER_NOT_CANCELED = 541, ++ MD_ERROR_WIN_UNWIND = 542, ++ MD_ERROR_WIN_BAD_STACK = 543, ++ MD_ERROR_WIN_INVALID_UNWIND_TARGET = 544, ++ MD_ERROR_WIN_INVALID_PORT_ATTRIBUTES = 545, ++ MD_ERROR_WIN_PORT_MESSAGE_TOO_LONG = 546, ++ MD_ERROR_WIN_INVALID_QUOTA_LOWER = 547, ++ MD_ERROR_WIN_DEVICE_ALREADY_ATTACHED = 548, ++ MD_ERROR_WIN_INSTRUCTION_MISALIGNMENT = 549, ++ MD_ERROR_WIN_PROFILING_NOT_STARTED = 550, ++ MD_ERROR_WIN_PROFILING_NOT_STOPPED = 551, ++ MD_ERROR_WIN_COULD_NOT_INTERPRET = 552, ++ MD_ERROR_WIN_PROFILING_AT_LIMIT = 553, ++ MD_ERROR_WIN_CANT_WAIT = 554, ++ MD_ERROR_WIN_CANT_TERMINATE_SELF = 555, ++ MD_ERROR_WIN_UNEXPECTED_MM_CREATE_ERR = 556, ++ MD_ERROR_WIN_UNEXPECTED_MM_MAP_ERROR = 557, ++ MD_ERROR_WIN_UNEXPECTED_MM_EXTEND_ERR = 558, ++ MD_ERROR_WIN_BAD_FUNCTION_TABLE = 559, ++ MD_ERROR_WIN_NO_GUID_TRANSLATION = 560, ++ MD_ERROR_WIN_INVALID_LDT_SIZE = 561, ++ MD_ERROR_WIN_INVALID_LDT_OFFSET = 563, ++ MD_ERROR_WIN_INVALID_LDT_DESCRIPTOR = 564, ++ MD_ERROR_WIN_TOO_MANY_THREADS = 565, ++ MD_ERROR_WIN_THREAD_NOT_IN_PROCESS = 566, ++ MD_ERROR_WIN_PAGEFILE_QUOTA_EXCEEDED = 567, ++ MD_ERROR_WIN_LOGON_SERVER_CONFLICT = 568, ++ MD_ERROR_WIN_SYNCHRONIZATION_REQUIRED = 569, ++ MD_ERROR_WIN_NET_OPEN_FAILED = 570, ++ MD_ERROR_WIN_IO_PRIVILEGE_FAILED = 571, ++ MD_ERROR_WIN_CONTROL_C_EXIT = 572, ++ MD_ERROR_WIN_MISSING_SYSTEMFILE = 573, ++ MD_ERROR_WIN_UNHANDLED_EXCEPTION = 574, ++ MD_ERROR_WIN_APP_INIT_FAILURE = 575, ++ MD_ERROR_WIN_PAGEFILE_CREATE_FAILED = 576, ++ MD_ERROR_WIN_INVALID_IMAGE_HASH = 577, ++ MD_ERROR_WIN_NO_PAGEFILE = 578, ++ MD_ERROR_WIN_ILLEGAL_FLOAT_CONTEXT = 579, ++ MD_ERROR_WIN_NO_EVENT_PAIR = 580, ++ MD_ERROR_WIN_DOMAIN_CTRLR_CONFIG_ERROR = 581, ++ MD_ERROR_WIN_ILLEGAL_CHARACTER = 582, ++ MD_ERROR_WIN_UNDEFINED_CHARACTER = 583, ++ MD_ERROR_WIN_FLOPPY_VOLUME = 584, ++ MD_ERROR_WIN_BIOS_FAILED_TO_CONNECT_INTERRUPT = 585, ++ MD_ERROR_WIN_BACKUP_CONTROLLER = 586, ++ MD_ERROR_WIN_MUTANT_LIMIT_EXCEEDED = 587, ++ MD_ERROR_WIN_FS_DRIVER_REQUIRED = 588, ++ MD_ERROR_WIN_CANNOT_LOAD_REGISTRY_FILE = 589, ++ MD_ERROR_WIN_DEBUG_ATTACH_FAILED = 590, ++ MD_ERROR_WIN_SYSTEM_PROCESS_TERMINATED = 591, ++ MD_ERROR_WIN_DATA_NOT_ACCEPTED = 592, ++ MD_ERROR_WIN_VDM_HARD_ERROR = 593, ++ MD_ERROR_WIN_DRIVER_CANCEL_TIMEOUT = 594, ++ MD_ERROR_WIN_REPLY_MESSAGE_MISMATCH = 595, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA = 596, ++ MD_ERROR_WIN_CLIENT_SERVER_PARAMETERS_INVALID = 597, ++ MD_ERROR_WIN_NOT_TINY_STREAM = 598, ++ MD_ERROR_WIN_STACK_OVERFLOW_READ = 599, ++ MD_ERROR_WIN_CONVERT_TO_LARGE = 600, ++ MD_ERROR_WIN_FOUND_OUT_OF_SCOPE = 601, ++ MD_ERROR_WIN_ALLOCATE_BUCKET = 602, ++ MD_ERROR_WIN_MARSHALL_OVERFLOW = 603, ++ MD_ERROR_WIN_INVALID_VARIANT = 604, ++ MD_ERROR_WIN_BAD_COMPRESSION_BUFFER = 605, ++ MD_ERROR_WIN_AUDIT_FAILED = 606, ++ MD_ERROR_WIN_TIMER_RESOLUTION_NOT_SET = 607, ++ MD_ERROR_WIN_INSUFFICIENT_LOGON_INFO = 608, ++ MD_ERROR_WIN_BAD_DLL_ENTRYPOINT = 609, ++ MD_ERROR_WIN_BAD_SERVICE_ENTRYPOINT = 610, ++ MD_ERROR_WIN_IP_ADDRESS_CONFLICT1 = 611, ++ MD_ERROR_WIN_IP_ADDRESS_CONFLICT2 = 612, ++ MD_ERROR_WIN_REGISTRY_QUOTA_LIMIT = 613, ++ MD_ERROR_WIN_NO_CALLBACK_ACTIVE = 614, ++ MD_ERROR_WIN_PWD_TOO_SHORT = 615, ++ MD_ERROR_WIN_PWD_TOO_RECENT = 616, ++ MD_ERROR_WIN_PWD_HISTORY_CONFLICT = 617, ++ MD_ERROR_WIN_UNSUPPORTED_COMPRESSION = 618, ++ MD_ERROR_WIN_INVALID_HW_PROFILE = 619, ++ MD_ERROR_WIN_INVALID_PLUGPLAY_DEVICE_PATH = 620, ++ MD_ERROR_WIN_QUOTA_LIST_INCONSISTENT = 621, ++ MD_ERROR_WIN_EVALUATION_EXPIRATION = 622, ++ MD_ERROR_WIN_ILLEGAL_DLL_RELOCATION = 623, ++ MD_ERROR_WIN_DLL_INIT_FAILED_LOGOFF = 624, ++ MD_ERROR_WIN_VALIDATE_CONTINUE = 625, ++ MD_ERROR_WIN_NO_MORE_MATCHES = 626, ++ MD_ERROR_WIN_RANGE_LIST_CONFLICT = 627, ++ MD_ERROR_WIN_SERVER_SID_MISMATCH = 628, ++ MD_ERROR_WIN_CANT_ENABLE_DENY_ONLY = 629, ++ MD_ERROR_WIN_FLOAT_MULTIPLE_FAULTS = 630, ++ MD_ERROR_WIN_FLOAT_MULTIPLE_TRAPS = 631, ++ MD_ERROR_WIN_NOINTERFACE = 632, ++ MD_ERROR_WIN_DRIVER_FAILED_SLEEP = 633, ++ MD_ERROR_WIN_CORRUPT_SYSTEM_FILE = 634, ++ MD_ERROR_WIN_COMMITMENT_MINIMUM = 635, ++ MD_ERROR_WIN_PNP_RESTART_ENUMERATION = 636, ++ MD_ERROR_WIN_SYSTEM_IMAGE_BAD_SIGNATURE = 637, ++ MD_ERROR_WIN_PNP_REBOOT_REQUIRED = 638, ++ MD_ERROR_WIN_INSUFFICIENT_POWER = 639, ++ MD_ERROR_WIN_MULTIPLE_FAULT_VIOLATION = 640, ++ MD_ERROR_WIN_SYSTEM_SHUTDOWN = 641, ++ MD_ERROR_WIN_PORT_NOT_SET = 642, ++ MD_ERROR_WIN_DS_VERSION_CHECK_FAILURE = 643, ++ MD_ERROR_WIN_RANGE_NOT_FOUND = 644, ++ MD_ERROR_WIN_NOT_SAFE_MODE_DRIVER = 646, ++ MD_ERROR_WIN_FAILED_DRIVER_ENTRY = 647, ++ MD_ERROR_WIN_DEVICE_ENUMERATION_ERROR = 648, ++ MD_ERROR_WIN_MOUNT_POINT_NOT_RESOLVED = 649, ++ MD_ERROR_WIN_INVALID_DEVICE_OBJECT_PARAMETER = 650, ++ MD_ERROR_WIN_MCA_OCCURED = 651, ++ MD_ERROR_WIN_DRIVER_DATABASE_ERROR = 652, ++ MD_ERROR_WIN_SYSTEM_HIVE_TOO_LARGE = 653, ++ MD_ERROR_WIN_DRIVER_FAILED_PRIOR_UNLOAD = 654, ++ MD_ERROR_WIN_VOLSNAP_PREPARE_HIBERNATE = 655, ++ MD_ERROR_WIN_HIBERNATION_FAILURE = 656, ++ MD_ERROR_WIN_PWD_TOO_LONG = 657, ++ MD_ERROR_WIN_FILE_SYSTEM_LIMITATION = 665, ++ MD_ERROR_WIN_ASSERTION_FAILURE = 668, ++ MD_ERROR_WIN_ACPI_ERROR = 669, ++ MD_ERROR_WIN_WOW_ASSERTION = 670, ++ MD_ERROR_WIN_PNP_BAD_MPS_TABLE = 671, ++ MD_ERROR_WIN_PNP_TRANSLATION_FAILED = 672, ++ MD_ERROR_WIN_PNP_IRQ_TRANSLATION_FAILED = 673, ++ MD_ERROR_WIN_PNP_INVALID_ID = 674, ++ MD_ERROR_WIN_WAKE_SYSTEM_DEBUGGER = 675, ++ MD_ERROR_WIN_HANDLES_CLOSED = 676, ++ MD_ERROR_WIN_EXTRANEOUS_INFORMATION = 677, ++ MD_ERROR_WIN_RXACT_COMMIT_NECESSARY = 678, ++ MD_ERROR_WIN_MEDIA_CHECK = 679, ++ MD_ERROR_WIN_GUID_SUBSTITUTION_MADE = 680, ++ MD_ERROR_WIN_STOPPED_ON_SYMLINK = 681, ++ MD_ERROR_WIN_LONGJUMP = 682, ++ MD_ERROR_WIN_PLUGPLAY_QUERY_VETOED = 683, ++ MD_ERROR_WIN_UNWIND_CONSOLIDATE = 684, ++ MD_ERROR_WIN_REGISTRY_HIVE_RECOVERED = 685, ++ MD_ERROR_WIN_DLL_MIGHT_BE_INSECURE = 686, ++ MD_ERROR_WIN_DLL_MIGHT_BE_INCOMPATIBLE = 687, ++ MD_ERROR_WIN_DBG_EXCEPTION_NOT_HANDLED = 688, ++ MD_ERROR_WIN_DBG_REPLY_LATER = 689, ++ MD_ERROR_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE = 690, ++ MD_ERROR_WIN_DBG_TERMINATE_THREAD = 691, ++ MD_ERROR_WIN_DBG_TERMINATE_PROCESS = 692, ++ MD_ERROR_WIN_DBG_CONTROL_C = 693, ++ MD_ERROR_WIN_DBG_PRINTEXCEPTION_C = 694, ++ MD_ERROR_WIN_DBG_RIPEXCEPTION = 695, ++ MD_ERROR_WIN_DBG_CONTROL_BREAK = 696, ++ MD_ERROR_WIN_DBG_COMMAND_EXCEPTION = 697, ++ MD_ERROR_WIN_OBJECT_NAME_EXISTS = 698, ++ MD_ERROR_WIN_THREAD_WAS_SUSPENDED = 699, ++ MD_ERROR_WIN_IMAGE_NOT_AT_BASE = 700, ++ MD_ERROR_WIN_RXACT_STATE_CREATED = 701, ++ MD_ERROR_WIN_SEGMENT_NOTIFICATION = 702, ++ MD_ERROR_WIN_BAD_CURRENT_DIRECTORY = 703, ++ MD_ERROR_WIN_FT_READ_RECOVERY_FROM_BACKUP = 704, ++ MD_ERROR_WIN_FT_WRITE_RECOVERY = 705, ++ MD_ERROR_WIN_IMAGE_MACHINE_TYPE_MISMATCH = 706, ++ MD_ERROR_WIN_RECEIVE_PARTIAL = 707, ++ MD_ERROR_WIN_RECEIVE_EXPEDITED = 708, ++ MD_ERROR_WIN_RECEIVE_PARTIAL_EXPEDITED = 709, ++ MD_ERROR_WIN_EVENT_DONE = 710, ++ MD_ERROR_WIN_EVENT_PENDING = 711, ++ MD_ERROR_WIN_CHECKING_FILE_SYSTEM = 712, ++ MD_ERROR_WIN_FATAL_APP_EXIT = 713, ++ MD_ERROR_WIN_PREDEFINED_HANDLE = 714, ++ MD_ERROR_WIN_WAS_UNLOCKED = 715, ++ MD_ERROR_WIN_SERVICE_NOTIFICATION = 716, ++ MD_ERROR_WIN_WAS_LOCKED = 717, ++ MD_ERROR_WIN_LOG_HARD_ERROR = 718, ++ MD_ERROR_WIN_ALREADY_WIN32 = 719, ++ MD_ERROR_WIN_IMAGE_MACHINE_TYPE_MISMATCH_EXE = 720, ++ MD_ERROR_WIN_NO_YIELD_PERFORMED = 721, ++ MD_ERROR_WIN_TIMER_RESUME_IGNORED = 722, ++ MD_ERROR_WIN_ARBITRATION_UNHANDLED = 723, ++ MD_ERROR_WIN_CARDBUS_NOT_SUPPORTED = 724, ++ MD_ERROR_WIN_MP_PROCESSOR_MISMATCH = 725, ++ MD_ERROR_WIN_HIBERNATED = 726, ++ MD_ERROR_WIN_RESUME_HIBERNATION = 727, ++ MD_ERROR_WIN_FIRMWARE_UPDATED = 728, ++ MD_ERROR_WIN_DRIVERS_LEAKING_LOCKED_PAGES = 729, ++ MD_ERROR_WIN_WAKE_SYSTEM = 730, ++ MD_ERROR_WIN_WAIT_1 = 731, ++ MD_ERROR_WIN_WAIT_2 = 732, ++ MD_ERROR_WIN_WAIT_3 = 733, ++ MD_ERROR_WIN_WAIT_63 = 734, ++ MD_ERROR_WIN_ABANDONED_WAIT_0 = 735, ++ MD_ERROR_WIN_ABANDONED_WAIT_63 = 736, ++ MD_ERROR_WIN_USER_APC = 737, ++ MD_ERROR_WIN_KERNEL_APC = 738, ++ MD_ERROR_WIN_ALERTED = 739, ++ MD_ERROR_WIN_ELEVATION_REQUIRED = 740, ++ MD_ERROR_WIN_REPARSE = 741, ++ MD_ERROR_WIN_OPLOCK_BREAK_IN_PROGRESS = 742, ++ MD_ERROR_WIN_VOLUME_MOUNTED = 743, ++ MD_ERROR_WIN_RXACT_COMMITTED = 744, ++ MD_ERROR_WIN_NOTIFY_CLEANUP = 745, ++ MD_ERROR_WIN_PRIMARY_TRANSPORT_CONNECT_FAILED = 746, ++ MD_ERROR_WIN_PAGE_FAULT_TRANSITION = 747, ++ MD_ERROR_WIN_PAGE_FAULT_DEMAND_ZERO = 748, ++ MD_ERROR_WIN_PAGE_FAULT_COPY_ON_WRITE = 749, ++ MD_ERROR_WIN_PAGE_FAULT_GUARD_PAGE = 750, ++ MD_ERROR_WIN_PAGE_FAULT_PAGING_FILE = 751, ++ MD_ERROR_WIN_CACHE_PAGE_LOCKED = 752, ++ MD_ERROR_WIN_CRASH_DUMP = 753, ++ MD_ERROR_WIN_BUFFER_ALL_ZEROS = 754, ++ MD_ERROR_WIN_REPARSE_OBJECT = 755, ++ MD_ERROR_WIN_RESOURCE_REQUIREMENTS_CHANGED = 756, ++ MD_ERROR_WIN_TRANSLATION_COMPLETE = 757, ++ MD_ERROR_WIN_NOTHING_TO_TERMINATE = 758, ++ MD_ERROR_WIN_PROCESS_NOT_IN_JOB = 759, ++ MD_ERROR_WIN_PROCESS_IN_JOB = 760, ++ MD_ERROR_WIN_VOLSNAP_HIBERNATE_READY = 761, ++ MD_ERROR_WIN_FSFILTER_OP_COMPLETED_SUCCESSFULLY = 762, ++ MD_ERROR_WIN_INTERRUPT_VECTOR_ALREADY_CONNECTED = 763, ++ MD_ERROR_WIN_INTERRUPT_STILL_CONNECTED = 764, ++ MD_ERROR_WIN_WAIT_FOR_OPLOCK = 765, ++ MD_ERROR_WIN_DBG_EXCEPTION_HANDLED = 766, ++ MD_ERROR_WIN_DBG_CONTINUE = 767, ++ MD_ERROR_WIN_CALLBACK_POP_STACK = 768, ++ MD_ERROR_WIN_COMPRESSION_DISABLED = 769, ++ MD_ERROR_WIN_CANTFETCHBACKWARDS = 770, ++ MD_ERROR_WIN_CANTSCROLLBACKWARDS = 771, ++ MD_ERROR_WIN_ROWSNOTRELEASED = 772, ++ MD_ERROR_WIN_BAD_ACCESSOR_FLAGS = 773, ++ MD_ERROR_WIN_ERRORS_ENCOUNTERED = 774, ++ MD_ERROR_WIN_NOT_CAPABLE = 775, ++ MD_ERROR_WIN_REQUEST_OUT_OF_SEQUENCE = 776, ++ MD_ERROR_WIN_VERSION_PARSE_ERROR = 777, ++ MD_ERROR_WIN_BADSTARTPOSITION = 778, ++ MD_ERROR_WIN_MEMORY_HARDWARE = 779, ++ MD_ERROR_WIN_DISK_REPAIR_DISABLED = 780, ++ MD_ERROR_WIN_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE = 781, ++ MD_ERROR_WIN_SYSTEM_POWERSTATE_TRANSITION = 782, ++ MD_ERROR_WIN_SYSTEM_POWERSTATE_COMPLEX_TRANSITION = 783, ++ MD_ERROR_WIN_MCA_EXCEPTION = 784, ++ MD_ERROR_WIN_ACCESS_AUDIT_BY_POLICY = 785, ++ MD_ERROR_WIN_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY = 786, ++ MD_ERROR_WIN_ABANDON_HIBERFILE = 787, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED = 788, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR = 789, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR = 790, ++ MD_ERROR_WIN_BAD_MCFG_TABLE = 791, ++ MD_ERROR_WIN_DISK_REPAIR_REDIRECTED = 792, ++ MD_ERROR_WIN_DISK_REPAIR_UNSUCCESSFUL = 793, ++ MD_ERROR_WIN_CORRUPT_LOG_OVERFULL = 794, ++ MD_ERROR_WIN_CORRUPT_LOG_CORRUPTED = 795, ++ MD_ERROR_WIN_CORRUPT_LOG_UNAVAILABLE = 796, ++ MD_ERROR_WIN_CORRUPT_LOG_DELETED_FULL = 797, ++ MD_ERROR_WIN_CORRUPT_LOG_CLEARED = 798, ++ MD_ERROR_WIN_ORPHAN_NAME_EXHAUSTED = 799, ++ MD_ERROR_WIN_OPLOCK_SWITCHED_TO_NEW_HANDLE = 800, ++ MD_ERROR_WIN_CANNOT_GRANT_REQUESTED_OPLOCK = 801, ++ MD_ERROR_WIN_CANNOT_BREAK_OPLOCK = 802, ++ MD_ERROR_WIN_OPLOCK_HANDLE_CLOSED = 803, ++ MD_ERROR_WIN_NO_ACE_CONDITION = 804, ++ MD_ERROR_WIN_INVALID_ACE_CONDITION = 805, ++ MD_ERROR_WIN_FILE_HANDLE_REVOKED = 806, ++ MD_ERROR_WIN_IMAGE_AT_DIFFERENT_BASE = 807, ++ MD_ERROR_WIN_ENCRYPTED_IO_NOT_POSSIBLE = 808, ++ MD_ERROR_WIN_FILE_METADATA_OPTIMIZATION_IN_PROGRESS = 809, ++ MD_ERROR_WIN_QUOTA_ACTIVITY = 810, ++ MD_ERROR_WIN_HANDLE_REVOKED = 811, ++ MD_ERROR_WIN_CALLBACK_INVOKE_INLINE = 812, ++ MD_ERROR_WIN_CPU_SET_INVALID = 813, ++ MD_ERROR_WIN_ENCLAVE_NOT_TERMINATED = 814, ++ MD_ERROR_WIN_ENCLAVE_VIOLATION = 815, ++ MD_ERROR_WIN_EA_ACCESS_DENIED = 994, ++ MD_ERROR_WIN_OPERATION_ABORTED = 995, ++ MD_ERROR_WIN_IO_INCOMPLETE = 996, ++ MD_ERROR_WIN_IO_PENDING = 997, ++ MD_ERROR_WIN_NOACCESS = 998, ++ MD_ERROR_WIN_SWAPERROR = 999, ++ MD_ERROR_WIN_STACK_OVERFLOW = 1001, ++ MD_ERROR_WIN_INVALID_MESSAGE = 1002, ++ MD_ERROR_WIN_CAN_NOT_COMPLETE = 1003, ++ MD_ERROR_WIN_INVALID_FLAGS = 1004, ++ MD_ERROR_WIN_UNRECOGNIZED_VOLUME = 1005, ++ MD_ERROR_WIN_FILE_INVALID = 1006, ++ MD_ERROR_WIN_FULLSCREEN_MODE = 1007, ++ MD_ERROR_WIN_NO_TOKEN = 1008, ++ MD_ERROR_WIN_BADDB = 1009, ++ MD_ERROR_WIN_BADKEY = 1010, ++ MD_ERROR_WIN_CANTOPEN = 1011, ++ MD_ERROR_WIN_CANTREAD = 1012, ++ MD_ERROR_WIN_CANTWRITE = 1013, ++ MD_ERROR_WIN_REGISTRY_RECOVERED = 1014, ++ MD_ERROR_WIN_REGISTRY_CORRUPT = 1015, ++ MD_ERROR_WIN_REGISTRY_IO_FAILED = 1016, ++ MD_ERROR_WIN_NOT_REGISTRY_FILE = 1017, ++ MD_ERROR_WIN_KEY_DELETED = 1018, ++ MD_ERROR_WIN_NO_LOG_SPACE = 1019, ++ MD_ERROR_WIN_KEY_HAS_CHILDREN = 1020, ++ MD_ERROR_WIN_CHILD_MUST_BE_VOLATILE = 1021, ++ MD_ERROR_WIN_NOTIFY_ENUM_DIR = 1022, ++ MD_ERROR_WIN_DEPENDENT_SERVICES_RUNNING = 1051, ++ MD_ERROR_WIN_INVALID_SERVICE_CONTROL = 1052, ++ MD_ERROR_WIN_SERVICE_REQUEST_TIMEOUT = 1053, ++ MD_ERROR_WIN_SERVICE_NO_THREAD = 1054, ++ MD_ERROR_WIN_SERVICE_DATABASE_LOCKED = 1055, ++ MD_ERROR_WIN_SERVICE_ALREADY_RUNNING = 1056, ++ MD_ERROR_WIN_INVALID_SERVICE_ACCOUNT = 1057, ++ MD_ERROR_WIN_SERVICE_DISABLED = 1058, ++ MD_ERROR_WIN_CIRCULAR_DEPENDENCY = 1059, ++ MD_ERROR_WIN_SERVICE_DOES_NOT_EXIST = 1060, ++ MD_ERROR_WIN_SERVICE_CANNOT_ACCEPT_CTRL = 1061, ++ MD_ERROR_WIN_SERVICE_NOT_ACTIVE = 1062, ++ MD_ERROR_WIN_FAILED_SERVICE_CONTROLLER_CONNECT = 1063, ++ MD_ERROR_WIN_EXCEPTION_IN_SERVICE = 1064, ++ MD_ERROR_WIN_DATABASE_DOES_NOT_EXIST = 1065, ++ MD_ERROR_WIN_SERVICE_SPECIFIC_ERROR = 1066, ++ MD_ERROR_WIN_PROCESS_ABORTED = 1067, ++ MD_ERROR_WIN_SERVICE_DEPENDENCY_FAIL = 1068, ++ MD_ERROR_WIN_SERVICE_LOGON_FAILED = 1069, ++ MD_ERROR_WIN_SERVICE_START_HANG = 1070, ++ MD_ERROR_WIN_INVALID_SERVICE_LOCK = 1071, ++ MD_ERROR_WIN_SERVICE_MARKED_FOR_DELETE = 1072, ++ MD_ERROR_WIN_SERVICE_EXISTS = 1073, ++ MD_ERROR_WIN_ALREADY_RUNNING_LKG = 1074, ++ MD_ERROR_WIN_SERVICE_DEPENDENCY_DELETED = 1075, ++ MD_ERROR_WIN_BOOT_ALREADY_ACCEPTED = 1076, ++ MD_ERROR_WIN_SERVICE_NEVER_STARTED = 1077, ++ MD_ERROR_WIN_DUPLICATE_SERVICE_NAME = 1078, ++ MD_ERROR_WIN_DIFFERENT_SERVICE_ACCOUNT = 1079, ++ MD_ERROR_WIN_CANNOT_DETECT_DRIVER_FAILURE = 1080, ++ MD_ERROR_WIN_CANNOT_DETECT_PROCESS_ABORT = 1081, ++ MD_ERROR_WIN_NO_RECOVERY_PROGRAM = 1082, ++ MD_ERROR_WIN_SERVICE_NOT_IN_EXE = 1083, ++ MD_ERROR_WIN_NOT_SAFEBOOT_SERVICE = 1084, ++ MD_ERROR_WIN_END_OF_MEDIA = 1100, ++ MD_ERROR_WIN_FILEMARK_DETECTED = 1101, ++ MD_ERROR_WIN_BEGINNING_OF_MEDIA = 1102, ++ MD_ERROR_WIN_SETMARK_DETECTED = 1103, ++ MD_ERROR_WIN_NO_DATA_DETECTED = 1104, ++ MD_ERROR_WIN_PARTITION_FAILURE = 1105, ++ MD_ERROR_WIN_INVALID_BLOCK_LENGTH = 1106, ++ MD_ERROR_WIN_DEVICE_NOT_PARTITIONED = 1107, ++ MD_ERROR_WIN_UNABLE_TO_LOCK_MEDIA = 1108, ++ MD_ERROR_WIN_UNABLE_TO_UNLOAD_MEDIA = 1109, ++ MD_ERROR_WIN_MEDIA_CHANGED = 1110, ++ MD_ERROR_WIN_BUS_RESET = 1111, ++ MD_ERROR_WIN_NO_MEDIA_IN_DRIVE = 1112, ++ MD_ERROR_WIN_NO_UNICODE_TRANSLATION = 1113, ++ MD_ERROR_WIN_DLL_INIT_FAILED = 1114, ++ MD_ERROR_WIN_SHUTDOWN_IN_PROGRESS = 1115, ++ MD_ERROR_WIN_NO_SHUTDOWN_IN_PROGRESS = 1116, ++ MD_ERROR_WIN_IO_DEVICE = 1117, ++ MD_ERROR_WIN_SERIAL_NO_DEVICE = 1118, ++ MD_ERROR_WIN_IRQ_BUSY = 1119, ++ MD_ERROR_WIN_MORE_WRITES = 1120, ++ MD_ERROR_WIN_COUNTER_TIMEOUT = 1121, ++ MD_ERROR_WIN_FLOPPY_ID_MARK_NOT_FOUND = 1122, ++ MD_ERROR_WIN_FLOPPY_WRONG_CYLINDER = 1123, ++ MD_ERROR_WIN_FLOPPY_UNKNOWN_ERROR = 1124, ++ MD_ERROR_WIN_FLOPPY_BAD_REGISTERS = 1125, ++ MD_ERROR_WIN_DISK_RECALIBRATE_FAILED = 1126, ++ MD_ERROR_WIN_DISK_OPERATION_FAILED = 1127, ++ MD_ERROR_WIN_DISK_RESET_FAILED = 1128, ++ MD_ERROR_WIN_EOM_OVERFLOW = 1129, ++ MD_ERROR_WIN_NOT_ENOUGH_SERVER_MEMORY = 1130, ++ MD_ERROR_WIN_POSSIBLE_DEADLOCK = 1131, ++ MD_ERROR_WIN_MAPPED_ALIGNMENT = 1132, ++ MD_ERROR_WIN_SET_POWER_STATE_VETOED = 1140, ++ MD_ERROR_WIN_SET_POWER_STATE_FAILED = 1141, ++ MD_ERROR_WIN_TOO_MANY_LINKS = 1142, ++ MD_ERROR_WIN_OLD_WIN_VERSION = 1150, ++ MD_ERROR_WIN_APP_WRONG_OS = 1151, ++ MD_ERROR_WIN_SINGLE_INSTANCE_APP = 1152, ++ MD_ERROR_WIN_RMODE_APP = 1153, ++ MD_ERROR_WIN_INVALID_DLL = 1154, ++ MD_ERROR_WIN_NO_ASSOCIATION = 1155, ++ MD_ERROR_WIN_DDE_FAIL = 1156, ++ MD_ERROR_WIN_DLL_NOT_FOUND = 1157, ++ MD_ERROR_WIN_NO_MORE_USER_HANDLES = 1158, ++ MD_ERROR_WIN_MESSAGE_SYNC_ONLY = 1159, ++ MD_ERROR_WIN_SOURCE_ELEMENT_EMPTY = 1160, ++ MD_ERROR_WIN_DESTINATION_ELEMENT_FULL = 1161, ++ MD_ERROR_WIN_ILLEGAL_ELEMENT_ADDRESS = 1162, ++ MD_ERROR_WIN_MAGAZINE_NOT_PRESENT = 1163, ++ MD_ERROR_WIN_DEVICE_REINITIALIZATION_NEEDED = 1164, ++ MD_ERROR_WIN_DEVICE_REQUIRES_CLEANING = 1165, ++ MD_ERROR_WIN_DEVICE_DOOR_OPEN = 1166, ++ MD_ERROR_WIN_DEVICE_NOT_CONNECTED = 1167, ++ MD_ERROR_WIN_NOT_FOUND = 1168, ++ MD_ERROR_WIN_NO_MATCH = 1169, ++ MD_ERROR_WIN_SET_NOT_FOUND = 1170, ++ MD_ERROR_WIN_POINT_NOT_FOUND = 1171, ++ MD_ERROR_WIN_NO_TRACKING_SERVICE = 1172, ++ MD_ERROR_WIN_NO_VOLUME_ID = 1173, ++ MD_ERROR_WIN_UNABLE_TO_REMOVE_REPLACED = 1175, ++ MD_ERROR_WIN_UNABLE_TO_MOVE_REPLACEMENT = 1176, ++ MD_ERROR_WIN_UNABLE_TO_MOVE_REPLACEMENT_2 = 1177, ++ MD_ERROR_WIN_JOURNAL_DELETE_IN_PROGRESS = 1178, ++ MD_ERROR_WIN_JOURNAL_NOT_ACTIVE = 1179, ++ MD_ERROR_WIN_POTENTIAL_FILE_FOUND = 1180, ++ MD_ERROR_WIN_JOURNAL_ENTRY_DELETED = 1181, ++ MD_ERROR_WIN_VRF_CFG_AND_IO_ENABLED = 1183, ++ MD_ERROR_WIN_PARTITION_TERMINATING = 1184, ++ MD_ERROR_WIN_SHUTDOWN_IS_SCHEDULED = 1190, ++ MD_ERROR_WIN_SHUTDOWN_USERS_LOGGED_ON = 1191, ++ MD_ERROR_WIN_BAD_DEVICE = 1200, ++ MD_ERROR_WIN_CONNECTION_UNAVAIL = 1201, ++ MD_ERROR_WIN_DEVICE_ALREADY_REMEMBERED = 1202, ++ MD_ERROR_WIN_NO_NET_OR_BAD_PATH = 1203, ++ MD_ERROR_WIN_BAD_PROVIDER = 1204, ++ MD_ERROR_WIN_CANNOT_OPEN_PROFILE = 1205, ++ MD_ERROR_WIN_BAD_PROFILE = 1206, ++ MD_ERROR_WIN_NOT_CONTAINER = 1207, ++ MD_ERROR_WIN_EXTENDED_ERROR = 1208, ++ MD_ERROR_WIN_INVALID_GROUPNAME = 1209, ++ MD_ERROR_WIN_INVALID_COMPUTERNAME = 1210, ++ MD_ERROR_WIN_INVALID_EVENTNAME = 1211, ++ MD_ERROR_WIN_INVALID_DOMAINNAME = 1212, ++ MD_ERROR_WIN_INVALID_SERVICENAME = 1213, ++ MD_ERROR_WIN_INVALID_NETNAME = 1214, ++ MD_ERROR_WIN_INVALID_SHARENAME = 1215, ++ MD_ERROR_WIN_INVALID_PASSWORDNAME = 1216, ++ MD_ERROR_WIN_INVALID_MESSAGENAME = 1217, ++ MD_ERROR_WIN_INVALID_MESSAGEDEST = 1218, ++ MD_ERROR_WIN_SESSION_CREDENTIAL_CONFLICT = 1219, ++ MD_ERROR_WIN_REMOTE_SESSION_LIMIT_EXCEEDED = 1220, ++ MD_ERROR_WIN_DUP_DOMAINNAME = 1221, ++ MD_ERROR_WIN_NO_NETWORK = 1222, ++ MD_ERROR_WIN_CANCELLED = 1223, ++ MD_ERROR_WIN_USER_MAPPED_FILE = 1224, ++ MD_ERROR_WIN_CONNECTION_REFUSED = 1225, ++ MD_ERROR_WIN_GRACEFUL_DISCONNECT = 1226, ++ MD_ERROR_WIN_ADDRESS_ALREADY_ASSOCIATED = 1227, ++ MD_ERROR_WIN_ADDRESS_NOT_ASSOCIATED = 1228, ++ MD_ERROR_WIN_CONNECTION_INVALID = 1229, ++ MD_ERROR_WIN_CONNECTION_ACTIVE = 1230, ++ MD_ERROR_WIN_NETWORK_UNREACHABLE = 1231, ++ MD_ERROR_WIN_HOST_UNREACHABLE = 1232, ++ MD_ERROR_WIN_PROTOCOL_UNREACHABLE = 1233, ++ MD_ERROR_WIN_PORT_UNREACHABLE = 1234, ++ MD_ERROR_WIN_REQUEST_ABORTED = 1235, ++ MD_ERROR_WIN_CONNECTION_ABORTED = 1236, ++ MD_ERROR_WIN_RETRY = 1237, ++ MD_ERROR_WIN_CONNECTION_COUNT_LIMIT = 1238, ++ MD_ERROR_WIN_LOGIN_TIME_RESTRICTION = 1239, ++ MD_ERROR_WIN_LOGIN_WKSTA_RESTRICTION = 1240, ++ MD_ERROR_WIN_INCORRECT_ADDRESS = 1241, ++ MD_ERROR_WIN_ALREADY_REGISTERED = 1242, ++ MD_ERROR_WIN_SERVICE_NOT_FOUND = 1243, ++ MD_ERROR_WIN_NOT_AUTHENTICATED = 1244, ++ MD_ERROR_WIN_NOT_LOGGED_ON = 1245, ++ MD_ERROR_WIN_CONTINUE = 1246, ++ MD_ERROR_WIN_ALREADY_INITIALIZED = 1247, ++ MD_ERROR_WIN_NO_MORE_DEVICES = 1248, ++ MD_ERROR_WIN_NO_SUCH_SITE = 1249, ++ MD_ERROR_WIN_DOMAIN_CONTROLLER_EXISTS = 1250, ++ MD_ERROR_WIN_ONLY_IF_CONNECTED = 1251, ++ MD_ERROR_WIN_OVERRIDE_NOCHANGES = 1252, ++ MD_ERROR_WIN_BAD_USER_PROFILE = 1253, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_SBS = 1254, ++ MD_ERROR_WIN_SERVER_SHUTDOWN_IN_PROGRESS = 1255, ++ MD_ERROR_WIN_HOST_DOWN = 1256, ++ MD_ERROR_WIN_NON_ACCOUNT_SID = 1257, ++ MD_ERROR_WIN_NON_DOMAIN_SID = 1258, ++ MD_ERROR_WIN_APPHELP_BLOCK = 1259, ++ MD_ERROR_WIN_ACCESS_DISABLED_BY_POLICY = 1260, ++ MD_ERROR_WIN_REG_NAT_CONSUMPTION = 1261, ++ MD_ERROR_WIN_CSCSHARE_OFFLINE = 1262, ++ MD_ERROR_WIN_PKINIT_FAILURE = 1263, ++ MD_ERROR_WIN_SMARTCARD_SUBSYSTEM_FAILURE = 1264, ++ MD_ERROR_WIN_DOWNGRADE_DETECTED = 1265, ++ MD_ERROR_WIN_MACHINE_LOCKED = 1271, ++ MD_ERROR_WIN_SMB_GUEST_LOGON_BLOCKED = 1272, ++ MD_ERROR_WIN_CALLBACK_SUPPLIED_INVALID_DATA = 1273, ++ MD_ERROR_WIN_SYNC_FOREGROUND_REFRESH_REQUIRED = 1274, ++ MD_ERROR_WIN_DRIVER_BLOCKED = 1275, ++ MD_ERROR_WIN_INVALID_IMPORT_OF_NON_DLL = 1276, ++ MD_ERROR_WIN_ACCESS_DISABLED_WEBBLADE = 1277, ++ MD_ERROR_WIN_ACCESS_DISABLED_WEBBLADE_TAMPER = 1278, ++ MD_ERROR_WIN_RECOVERY_FAILURE = 1279, ++ MD_ERROR_WIN_ALREADY_FIBER = 1280, ++ MD_ERROR_WIN_ALREADY_THREAD = 1281, ++ MD_ERROR_WIN_STACK_BUFFER_OVERRUN = 1282, ++ MD_ERROR_WIN_PARAMETER_QUOTA_EXCEEDED = 1283, ++ MD_ERROR_WIN_DEBUGGER_INACTIVE = 1284, ++ MD_ERROR_WIN_DELAY_LOAD_FAILED = 1285, ++ MD_ERROR_WIN_VDM_DISALLOWED = 1286, ++ MD_ERROR_WIN_UNIDENTIFIED_ERROR = 1287, ++ MD_ERROR_WIN_INVALID_CRUNTIME_PARAMETER = 1288, ++ MD_ERROR_WIN_BEYOND_VDL = 1289, ++ MD_ERROR_WIN_INCOMPATIBLE_SERVICE_SID_TYPE = 1290, ++ MD_ERROR_WIN_DRIVER_PROCESS_TERMINATED = 1291, ++ MD_ERROR_WIN_IMPLEMENTATION_LIMIT = 1292, ++ MD_ERROR_WIN_PROCESS_IS_PROTECTED = 1293, ++ MD_ERROR_WIN_SERVICE_NOTIFY_CLIENT_LAGGING = 1294, ++ MD_ERROR_WIN_DISK_QUOTA_EXCEEDED = 1295, ++ MD_ERROR_WIN_CONTENT_BLOCKED = 1296, ++ MD_ERROR_WIN_INCOMPATIBLE_SERVICE_PRIVILEGE = 1297, ++ MD_ERROR_WIN_APP_HANG = 1298, ++ MD_ERROR_WIN_INVALID_LABEL = 1299, ++ MD_ERROR_WIN_NOT_ALL_ASSIGNED = 1300, ++ MD_ERROR_WIN_SOME_NOT_MAPPED = 1301, ++ MD_ERROR_WIN_NO_QUOTAS_FOR_ACCOUNT = 1302, ++ MD_ERROR_WIN_LOCAL_USER_SESSION_KEY = 1303, ++ MD_ERROR_WIN_NULL_LM_PASSWORD = 1304, ++ MD_ERROR_WIN_UNKNOWN_REVISION = 1305, ++ MD_ERROR_WIN_REVISION_MISMATCH = 1306, ++ MD_ERROR_WIN_INVALID_OWNER = 1307, ++ MD_ERROR_WIN_INVALID_PRIMARY_GROUP = 1308, ++ MD_ERROR_WIN_NO_IMPERSONATION_TOKEN = 1309, ++ MD_ERROR_WIN_CANT_DISABLE_MANDATORY = 1310, ++ MD_ERROR_WIN_NO_LOGON_SERVERS = 1311, ++ MD_ERROR_WIN_NO_SUCH_LOGON_SESSION = 1312, ++ MD_ERROR_WIN_NO_SUCH_PRIVILEGE = 1313, ++ MD_ERROR_WIN_PRIVILEGE_NOT_HELD = 1314, ++ MD_ERROR_WIN_INVALID_ACCOUNT_NAME = 1315, ++ MD_ERROR_WIN_USER_EXISTS = 1316, ++ MD_ERROR_WIN_NO_SUCH_USER = 1317, ++ MD_ERROR_WIN_GROUP_EXISTS = 1318, ++ MD_ERROR_WIN_NO_SUCH_GROUP = 1319, ++ MD_ERROR_WIN_MEMBER_IN_GROUP = 1320, ++ MD_ERROR_WIN_MEMBER_NOT_IN_GROUP = 1321, ++ MD_ERROR_WIN_LAST_ADMIN = 1322, ++ MD_ERROR_WIN_WRONG_PASSWORD = 1323, ++ MD_ERROR_WIN_ILL_FORMED_PASSWORD = 1324, ++ MD_ERROR_WIN_PASSWORD_RESTRICTION = 1325, ++ MD_ERROR_WIN_LOGON_FAILURE = 1326, ++ MD_ERROR_WIN_ACCOUNT_RESTRICTION = 1327, ++ MD_ERROR_WIN_INVALID_LOGON_HOURS = 1328, ++ MD_ERROR_WIN_INVALID_WORKSTATION = 1329, ++ MD_ERROR_WIN_PASSWORD_EXPIRED = 1330, ++ MD_ERROR_WIN_ACCOUNT_DISABLED = 1331, ++ MD_ERROR_WIN_NONE_MAPPED = 1332, ++ MD_ERROR_WIN_TOO_MANY_LUIDS_REQUESTED = 1333, ++ MD_ERROR_WIN_LUIDS_EXHAUSTED = 1334, ++ MD_ERROR_WIN_INVALID_SUB_AUTHORITY = 1335, ++ MD_ERROR_WIN_INVALID_ACL = 1336, ++ MD_ERROR_WIN_INVALID_SID = 1337, ++ MD_ERROR_WIN_INVALID_SECURITY_DESCR = 1338, ++ MD_ERROR_WIN_BAD_INHERITANCE_ACL = 1340, ++ MD_ERROR_WIN_SERVER_DISABLED = 1341, ++ MD_ERROR_WIN_SERVER_NOT_DISABLED = 1342, ++ MD_ERROR_WIN_INVALID_ID_AUTHORITY = 1343, ++ MD_ERROR_WIN_ALLOTTED_SPACE_EXCEEDED = 1344, ++ MD_ERROR_WIN_INVALID_GROUP_ATTRIBUTES = 1345, ++ MD_ERROR_WIN_BAD_IMPERSONATION_LEVEL = 1346, ++ MD_ERROR_WIN_CANT_OPEN_ANONYMOUS = 1347, ++ MD_ERROR_WIN_BAD_VALIDATION_CLASS = 1348, ++ MD_ERROR_WIN_BAD_TOKEN_TYPE = 1349, ++ MD_ERROR_WIN_NO_SECURITY_ON_OBJECT = 1350, ++ MD_ERROR_WIN_CANT_ACCESS_DOMAIN_INFO = 1351, ++ MD_ERROR_WIN_INVALID_SERVER_STATE = 1352, ++ MD_ERROR_WIN_INVALID_DOMAIN_STATE = 1353, ++ MD_ERROR_WIN_INVALID_DOMAIN_ROLE = 1354, ++ MD_ERROR_WIN_NO_SUCH_DOMAIN = 1355, ++ MD_ERROR_WIN_DOMAIN_EXISTS = 1356, ++ MD_ERROR_WIN_DOMAIN_LIMIT_EXCEEDED = 1357, ++ MD_ERROR_WIN_INTERNAL_DB_CORRUPTION = 1358, ++ MD_ERROR_WIN_INTERNAL_ERROR = 1359, ++ MD_ERROR_WIN_GENERIC_NOT_MAPPED = 1360, ++ MD_ERROR_WIN_BAD_DESCRIPTOR_FORMAT = 1361, ++ MD_ERROR_WIN_NOT_LOGON_PROCESS = 1362, ++ MD_ERROR_WIN_LOGON_SESSION_EXISTS = 1363, ++ MD_ERROR_WIN_NO_SUCH_PACKAGE = 1364, ++ MD_ERROR_WIN_BAD_LOGON_SESSION_STATE = 1365, ++ MD_ERROR_WIN_LOGON_SESSION_COLLISION = 1366, ++ MD_ERROR_WIN_INVALID_LOGON_TYPE = 1367, ++ MD_ERROR_WIN_CANNOT_IMPERSONATE = 1368, ++ MD_ERROR_WIN_RXACT_INVALID_STATE = 1369, ++ MD_ERROR_WIN_RXACT_COMMIT_FAILURE = 1370, ++ MD_ERROR_WIN_SPECIAL_ACCOUNT = 1371, ++ MD_ERROR_WIN_SPECIAL_GROUP = 1372, ++ MD_ERROR_WIN_SPECIAL_USER = 1373, ++ MD_ERROR_WIN_MEMBERS_PRIMARY_GROUP = 1374, ++ MD_ERROR_WIN_TOKEN_ALREADY_IN_USE = 1375, ++ MD_ERROR_WIN_NO_SUCH_ALIAS = 1376, ++ MD_ERROR_WIN_MEMBER_NOT_IN_ALIAS = 1377, ++ MD_ERROR_WIN_MEMBER_IN_ALIAS = 1378, ++ MD_ERROR_WIN_ALIAS_EXISTS = 1379, ++ MD_ERROR_WIN_LOGON_NOT_GRANTED = 1380, ++ MD_ERROR_WIN_TOO_MANY_SECRETS = 1381, ++ MD_ERROR_WIN_SECRET_TOO_LONG = 1382, ++ MD_ERROR_WIN_INTERNAL_DB_ERROR = 1383, ++ MD_ERROR_WIN_TOO_MANY_CONTEXT_IDS = 1384, ++ MD_ERROR_WIN_LOGON_TYPE_NOT_GRANTED = 1385, ++ MD_ERROR_WIN_NT_CROSS_ENCRYPTION_REQUIRED = 1386, ++ MD_ERROR_WIN_NO_SUCH_MEMBER = 1387, ++ MD_ERROR_WIN_INVALID_MEMBER = 1388, ++ MD_ERROR_WIN_TOO_MANY_SIDS = 1389, ++ MD_ERROR_WIN_LM_CROSS_ENCRYPTION_REQUIRED = 1390, ++ MD_ERROR_WIN_NO_INHERITANCE = 1391, ++ MD_ERROR_WIN_FILE_CORRUPT = 1392, ++ MD_ERROR_WIN_DISK_CORRUPT = 1393, ++ MD_ERROR_WIN_NO_USER_SESSION_KEY = 1394, ++ MD_ERROR_WIN_LICENSE_QUOTA_EXCEEDED = 1395, ++ MD_ERROR_WIN_WRONG_TARGET_NAME = 1396, ++ MD_ERROR_WIN_MUTUAL_AUTH_FAILED = 1397, ++ MD_ERROR_WIN_TIME_SKEW = 1398, ++ MD_ERROR_WIN_CURRENT_DOMAIN_NOT_ALLOWED = 1399, ++ MD_ERROR_WIN_INVALID_WINDOW_HANDLE = 1400, ++ MD_ERROR_WIN_INVALID_MENU_HANDLE = 1401, ++ MD_ERROR_WIN_INVALID_CURSOR_HANDLE = 1402, ++ MD_ERROR_WIN_INVALID_ACCEL_HANDLE = 1403, ++ MD_ERROR_WIN_INVALID_HOOK_HANDLE = 1404, ++ MD_ERROR_WIN_INVALID_DWP_HANDLE = 1405, ++ MD_ERROR_WIN_TLW_WITH_WSCHILD = 1406, ++ MD_ERROR_WIN_CANNOT_FIND_WND_CLASS = 1407, ++ MD_ERROR_WIN_WINDOW_OF_OTHER_THREAD = 1408, ++ MD_ERROR_WIN_HOTKEY_ALREADY_REGISTERED = 1409, ++ MD_ERROR_WIN_CLASS_ALREADY_EXISTS = 1410, ++ MD_ERROR_WIN_CLASS_DOES_NOT_EXIST = 1411, ++ MD_ERROR_WIN_CLASS_HAS_WINDOWS = 1412, ++ MD_ERROR_WIN_INVALID_INDEX = 1413, ++ MD_ERROR_WIN_INVALID_ICON_HANDLE = 1414, ++ MD_ERROR_WIN_PRIVATE_DIALOG_INDEX = 1415, ++ MD_ERROR_WIN_LISTBOX_ID_NOT_FOUND = 1416, ++ MD_ERROR_WIN_NO_WILDCARD_CHARACTERS = 1417, ++ MD_ERROR_WIN_CLIPBOARD_NOT_OPEN = 1418, ++ MD_ERROR_WIN_HOTKEY_NOT_REGISTERED = 1419, ++ MD_ERROR_WIN_WINDOW_NOT_DIALOG = 1420, ++ MD_ERROR_WIN_CONTROL_ID_NOT_FOUND = 1421, ++ MD_ERROR_WIN_INVALID_COMBOBOX_MESSAGE = 1422, ++ MD_ERROR_WIN_WINDOW_NOT_COMBOBOX = 1423, ++ MD_ERROR_WIN_INVALID_EDIT_HEIGHT = 1424, ++ MD_ERROR_WIN_DC_NOT_FOUND = 1425, ++ MD_ERROR_WIN_INVALID_HOOK_FILTER = 1426, ++ MD_ERROR_WIN_INVALID_FILTER_PROC = 1427, ++ MD_ERROR_WIN_HOOK_NEEDS_HMOD = 1428, ++ MD_ERROR_WIN_GLOBAL_ONLY_HOOK = 1429, ++ MD_ERROR_WIN_JOURNAL_HOOK_SET = 1430, ++ MD_ERROR_WIN_HOOK_NOT_INSTALLED = 1431, ++ MD_ERROR_WIN_INVALID_LB_MESSAGE = 1432, ++ MD_ERROR_WIN_SETCOUNT_ON_BAD_LB = 1433, ++ MD_ERROR_WIN_LB_WITHOUT_TABSTOPS = 1434, ++ MD_ERROR_WIN_DESTROY_OBJECT_OF_OTHER_THREAD = 1435, ++ MD_ERROR_WIN_CHILD_WINDOW_MENU = 1436, ++ MD_ERROR_WIN_NO_SYSTEM_MENU = 1437, ++ MD_ERROR_WIN_INVALID_MSGBOX_STYLE = 1438, ++ MD_ERROR_WIN_INVALID_SPI_VALUE = 1439, ++ MD_ERROR_WIN_SCREEN_ALREADY_LOCKED = 1440, ++ MD_ERROR_WIN_HWNDS_HAVE_DIFF_PARENT = 1441, ++ MD_ERROR_WIN_NOT_CHILD_WINDOW = 1442, ++ MD_ERROR_WIN_INVALID_GW_COMMAND = 1443, ++ MD_ERROR_WIN_INVALID_THREAD_ID = 1444, ++ MD_ERROR_WIN_NON_MDICHILD_WINDOW = 1445, ++ MD_ERROR_WIN_POPUP_ALREADY_ACTIVE = 1446, ++ MD_ERROR_WIN_NO_SCROLLBARS = 1447, ++ MD_ERROR_WIN_INVALID_SCROLLBAR_RANGE = 1448, ++ MD_ERROR_WIN_INVALID_SHOWWIN_COMMAND = 1449, ++ MD_ERROR_WIN_NO_SYSTEM_RESOURCES = 1450, ++ MD_ERROR_WIN_NONPAGED_SYSTEM_RESOURCES = 1451, ++ MD_ERROR_WIN_PAGED_SYSTEM_RESOURCES = 1452, ++ MD_ERROR_WIN_WORKING_SET_QUOTA = 1453, ++ MD_ERROR_WIN_PAGEFILE_QUOTA = 1454, ++ MD_ERROR_WIN_COMMITMENT_LIMIT = 1455, ++ MD_ERROR_WIN_MENU_ITEM_NOT_FOUND = 1456, ++ MD_ERROR_WIN_INVALID_KEYBOARD_HANDLE = 1457, ++ MD_ERROR_WIN_HOOK_TYPE_NOT_ALLOWED = 1458, ++ MD_ERROR_WIN_REQUIRES_INTERACTIVE_WINDOWSTATION = 1459, ++ MD_ERROR_WIN_TIMEOUT = 1460, ++ MD_ERROR_WIN_INVALID_MONITOR_HANDLE = 1461, ++ MD_ERROR_WIN_INCORRECT_SIZE = 1462, ++ MD_ERROR_WIN_SYMLINK_CLASS_DISABLED = 1463, ++ MD_ERROR_WIN_SYMLINK_NOT_SUPPORTED = 1464, ++ MD_ERROR_WIN_XML_PARSE_ERROR = 1465, ++ MD_ERROR_WIN_XMLDSIG_ERROR = 1466, ++ MD_ERROR_WIN_RESTART_APPLICATION = 1467, ++ MD_ERROR_WIN_WRONG_COMPARTMENT = 1468, ++ MD_ERROR_WIN_AUTHIP_FAILURE = 1469, ++ MD_ERROR_WIN_NO_NVRAM_RESOURCES = 1470, ++ MD_ERROR_WIN_NOT_GUI_PROCESS = 1471, ++ MD_ERROR_WIN_EVENTLOG_FILE_CORRUPT = 1500, ++ MD_ERROR_WIN_EVENTLOG_CANT_START = 1501, ++ MD_ERROR_WIN_LOG_FILE_FULL = 1502, ++ MD_ERROR_WIN_EVENTLOG_FILE_CHANGED = 1503, ++ MD_ERROR_WIN_CONTAINER_ASSIGNED = 1504, ++ MD_ERROR_WIN_JOB_NO_CONTAINER = 1505, ++ MD_ERROR_WIN_INVALID_TASK_NAME = 1550, ++ MD_ERROR_WIN_INVALID_TASK_INDEX = 1551, ++ MD_ERROR_WIN_THREAD_ALREADY_IN_TASK = 1552, ++ MD_ERROR_WIN_INSTALL_SERVICE_FAILURE = 1601, ++ MD_ERROR_WIN_INSTALL_USEREXIT = 1602, ++ MD_ERROR_WIN_INSTALL_FAILURE = 1603, ++ MD_ERROR_WIN_INSTALL_SUSPEND = 1604, ++ MD_ERROR_WIN_UNKNOWN_PRODUCT = 1605, ++ MD_ERROR_WIN_UNKNOWN_FEATURE = 1606, ++ MD_ERROR_WIN_UNKNOWN_COMPONENT = 1607, ++ MD_ERROR_WIN_UNKNOWN_PROPERTY = 1608, ++ MD_ERROR_WIN_INVALID_HANDLE_STATE = 1609, ++ MD_ERROR_WIN_BAD_CONFIGURATION = 1610, ++ MD_ERROR_WIN_INDEX_ABSENT = 1611, ++ MD_ERROR_WIN_INSTALL_SOURCE_ABSENT = 1612, ++ MD_ERROR_WIN_INSTALL_PACKAGE_VERSION = 1613, ++ MD_ERROR_WIN_PRODUCT_UNINSTALLED = 1614, ++ MD_ERROR_WIN_BAD_QUERY_SYNTAX = 1615, ++ MD_ERROR_WIN_INVALID_FIELD = 1616, ++ MD_ERROR_WIN_DEVICE_REMOVED = 1617, ++ MD_ERROR_WIN_INSTALL_ALREADY_RUNNING = 1618, ++ MD_ERROR_WIN_INSTALL_PACKAGE_OPEN_FAILED = 1619, ++ MD_ERROR_WIN_INSTALL_PACKAGE_INVALID = 1620, ++ MD_ERROR_WIN_INSTALL_UI_FAILURE = 1621, ++ MD_ERROR_WIN_INSTALL_LOG_FAILURE = 1622, ++ MD_ERROR_WIN_INSTALL_LANGUAGE_UNSUPPORTED = 1623, ++ MD_ERROR_WIN_INSTALL_TRANSFORM_FAILURE = 1624, ++ MD_ERROR_WIN_INSTALL_PACKAGE_REJECTED = 1625, ++ MD_ERROR_WIN_FUNCTION_NOT_CALLED = 1626, ++ MD_ERROR_WIN_FUNCTION_FAILED = 1627, ++ MD_ERROR_WIN_INVALID_TABLE = 1628, ++ MD_ERROR_WIN_DATATYPE_MISMATCH = 1629, ++ MD_ERROR_WIN_UNSUPPORTED_TYPE = 1630, ++ MD_ERROR_WIN_CREATE_FAILED = 1631, ++ MD_ERROR_WIN_INSTALL_TEMP_UNWRITABLE = 1632, ++ MD_ERROR_WIN_INSTALL_PLATFORM_UNSUPPORTED = 1633, ++ MD_ERROR_WIN_INSTALL_NOTUSED = 1634, ++ MD_ERROR_WIN_PATCH_PACKAGE_OPEN_FAILED = 1635, ++ MD_ERROR_WIN_PATCH_PACKAGE_INVALID = 1636, ++ MD_ERROR_WIN_PATCH_PACKAGE_UNSUPPORTED = 1637, ++ MD_ERROR_WIN_PRODUCT_VERSION = 1638, ++ MD_ERROR_WIN_INVALID_COMMAND_LINE = 1639, ++ MD_ERROR_WIN_INSTALL_REMOTE_DISALLOWED = 1640, ++ MD_ERROR_WIN_SUCCESS_REBOOT_INITIATED = 1641, ++ MD_ERROR_WIN_PATCH_TARGET_NOT_FOUND = 1642, ++ MD_ERROR_WIN_PATCH_PACKAGE_REJECTED = 1643, ++ MD_ERROR_WIN_INSTALL_TRANSFORM_REJECTED = 1644, ++ MD_ERROR_WIN_INSTALL_REMOTE_PROHIBITED = 1645, ++ MD_ERROR_WIN_PATCH_REMOVAL_UNSUPPORTED = 1646, ++ MD_ERROR_WIN_UNKNOWN_PATCH = 1647, ++ MD_ERROR_WIN_PATCH_NO_SEQUENCE = 1648, ++ MD_ERROR_WIN_PATCH_REMOVAL_DISALLOWED = 1649, ++ MD_ERROR_WIN_INVALID_PATCH_XML = 1650, ++ MD_ERROR_WIN_PATCH_MANAGED_ADVERTISED_PRODUCT = 1651, ++ MD_ERROR_WIN_INSTALL_SERVICE_SAFEBOOT = 1652, ++ MD_ERROR_WIN_FAIL_FAST_EXCEPTION = 1653, ++ MD_ERROR_WIN_INSTALL_REJECTED = 1654, ++ MD_ERROR_WIN_DYNAMIC_CODE_BLOCKED = 1655, ++ MD_ERROR_WIN_NOT_SAME_OBJECT = 1656, ++ MD_ERROR_WIN_STRICT_CFG_VIOLATION = 1657, ++ MD_ERROR_WIN_SET_CONTEXT_DENIED = 1660, ++ MD_ERROR_WIN_CROSS_PARTITION_VIOLATION = 1661, ++ MD_ERROR_WIN_RETURN_ADDRESS_HIJACK_ATTEMPT = 1662, ++ MD_ERROR_WIN_INVALID_USER_BUFFER = 1784, ++ MD_ERROR_WIN_UNRECOGNIZED_MEDIA = 1785, ++ MD_ERROR_WIN_NO_TRUST_LSA_SECRET = 1786, ++ MD_ERROR_WIN_NO_TRUST_SAM_ACCOUNT = 1787, ++ MD_ERROR_WIN_TRUSTED_DOMAIN_FAILURE = 1788, ++ MD_ERROR_WIN_TRUSTED_RELATIONSHIP_FAILURE = 1789, ++ MD_ERROR_WIN_TRUST_FAILURE = 1790, ++ MD_ERROR_WIN_NETLOGON_NOT_STARTED = 1792, ++ MD_ERROR_WIN_ACCOUNT_EXPIRED = 1793, ++ MD_ERROR_WIN_REDIRECTOR_HAS_OPEN_HANDLES = 1794, ++ MD_ERROR_WIN_PRINTER_DRIVER_ALREADY_INSTALLED = 1795, ++ MD_ERROR_WIN_UNKNOWN_PORT = 1796, ++ MD_ERROR_WIN_UNKNOWN_PRINTER_DRIVER = 1797, ++ MD_ERROR_WIN_UNKNOWN_PRINTPROCESSOR = 1798, ++ MD_ERROR_WIN_INVALID_SEPARATOR_FILE = 1799, ++ MD_ERROR_WIN_INVALID_PRIORITY = 1800, ++ MD_ERROR_WIN_INVALID_PRINTER_NAME = 1801, ++ MD_ERROR_WIN_PRINTER_ALREADY_EXISTS = 1802, ++ MD_ERROR_WIN_INVALID_PRINTER_COMMAND = 1803, ++ MD_ERROR_WIN_INVALID_DATATYPE = 1804, ++ MD_ERROR_WIN_INVALID_ENVIRONMENT = 1805, ++ MD_ERROR_WIN_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT = 1807, ++ MD_ERROR_WIN_NOLOGON_WORKSTATION_TRUST_ACCOUNT = 1808, ++ MD_ERROR_WIN_NOLOGON_SERVER_TRUST_ACCOUNT = 1809, ++ MD_ERROR_WIN_DOMAIN_TRUST_INCONSISTENT = 1810, ++ MD_ERROR_WIN_SERVER_HAS_OPEN_HANDLES = 1811, ++ MD_ERROR_WIN_RESOURCE_DATA_NOT_FOUND = 1812, ++ MD_ERROR_WIN_RESOURCE_TYPE_NOT_FOUND = 1813, ++ MD_ERROR_WIN_RESOURCE_NAME_NOT_FOUND = 1814, ++ MD_ERROR_WIN_RESOURCE_LANG_NOT_FOUND = 1815, ++ MD_ERROR_WIN_NOT_ENOUGH_QUOTA = 1816, ++ MD_ERROR_WIN_INVALID_TIME = 1901, ++ MD_ERROR_WIN_INVALID_FORM_NAME = 1902, ++ MD_ERROR_WIN_INVALID_FORM_SIZE = 1903, ++ MD_ERROR_WIN_ALREADY_WAITING = 1904, ++ MD_ERROR_WIN_PRINTER_DELETED = 1905, ++ MD_ERROR_WIN_INVALID_PRINTER_STATE = 1906, ++ MD_ERROR_WIN_PASSWORD_MUST_CHANGE = 1907, ++ MD_ERROR_WIN_DOMAIN_CONTROLLER_NOT_FOUND = 1908, ++ MD_ERROR_WIN_ACCOUNT_LOCKED_OUT = 1909, ++ MD_ERROR_WIN_NO_SITENAME = 1919, ++ MD_ERROR_WIN_CANT_ACCESS_FILE = 1920, ++ MD_ERROR_WIN_CANT_RESOLVE_FILENAME = 1921, ++ MD_ERROR_WIN_KM_DRIVER_BLOCKED = 1930, ++ MD_ERROR_WIN_CONTEXT_EXPIRED = 1931, ++ MD_ERROR_WIN_PER_USER_TRUST_QUOTA_EXCEEDED = 1932, ++ MD_ERROR_WIN_ALL_USER_TRUST_QUOTA_EXCEEDED = 1933, ++ MD_ERROR_WIN_USER_DELETE_TRUST_QUOTA_EXCEEDED = 1934, ++ MD_ERROR_WIN_AUTHENTICATION_FIREWALL_FAILED = 1935, ++ MD_ERROR_WIN_REMOTE_PRINT_CONNECTIONS_BLOCKED = 1936, ++ MD_ERROR_WIN_NTLM_BLOCKED = 1937, ++ MD_ERROR_WIN_PASSWORD_CHANGE_REQUIRED = 1938, ++ MD_ERROR_WIN_LOST_MODE_LOGON_RESTRICTION = 1939, ++ MD_ERROR_WIN_INVALID_PIXEL_FORMAT = 2000, ++ MD_ERROR_WIN_BAD_DRIVER = 2001, ++ MD_ERROR_WIN_INVALID_WINDOW_STYLE = 2002, ++ MD_ERROR_WIN_METAFILE_NOT_SUPPORTED = 2003, ++ MD_ERROR_WIN_TRANSFORM_NOT_SUPPORTED = 2004, ++ MD_ERROR_WIN_CLIPPING_NOT_SUPPORTED = 2005, ++ MD_ERROR_WIN_INVALID_CMM = 2010, ++ MD_ERROR_WIN_INVALID_PROFILE = 2011, ++ MD_ERROR_WIN_TAG_NOT_FOUND = 2012, ++ MD_ERROR_WIN_TAG_NOT_PRESENT = 2013, ++ MD_ERROR_WIN_DUPLICATE_TAG = 2014, ++ MD_ERROR_WIN_PROFILE_NOT_ASSOCIATED_WITH_DEVICE = 2015, ++ MD_ERROR_WIN_PROFILE_NOT_FOUND = 2016, ++ MD_ERROR_WIN_INVALID_COLORSPACE = 2017, ++ MD_ERROR_WIN_ICM_NOT_ENABLED = 2018, ++ MD_ERROR_WIN_DELETING_ICM_XFORM = 2019, ++ MD_ERROR_WIN_INVALID_TRANSFORM = 2020, ++ MD_ERROR_WIN_COLORSPACE_MISMATCH = 2021, ++ MD_ERROR_WIN_INVALID_COLORINDEX = 2022, ++ MD_ERROR_WIN_PROFILE_DOES_NOT_MATCH_DEVICE = 2023, ++ MD_ERROR_WIN_CONNECTED_OTHER_PASSWORD = 2108, ++ MD_ERROR_WIN_CONNECTED_OTHER_PASSWORD_DEFAULT = 2109, ++ MD_ERROR_WIN_BAD_USERNAME = 2202, ++ MD_ERROR_WIN_NOT_CONNECTED = 2250, ++ MD_ERROR_WIN_OPEN_FILES = 2401, ++ MD_ERROR_WIN_ACTIVE_CONNECTIONS = 2402, ++ MD_ERROR_WIN_DEVICE_IN_USE = 2404, ++ MD_ERROR_WIN_UNKNOWN_PRINT_MONITOR = 3000, ++ MD_ERROR_WIN_PRINTER_DRIVER_IN_USE = 3001, ++ MD_ERROR_WIN_SPOOL_FILE_NOT_FOUND = 3002, ++ MD_ERROR_WIN_SPL_NO_STARTDOC = 3003, ++ MD_ERROR_WIN_SPL_NO_ADDJOB = 3004, ++ MD_ERROR_WIN_PRINT_PROCESSOR_ALREADY_INSTALLED = 3005, ++ MD_ERROR_WIN_PRINT_MONITOR_ALREADY_INSTALLED = 3006, ++ MD_ERROR_WIN_INVALID_PRINT_MONITOR = 3007, ++ MD_ERROR_WIN_PRINT_MONITOR_IN_USE = 3008, ++ MD_ERROR_WIN_PRINTER_HAS_JOBS_QUEUED = 3009, ++ MD_ERROR_WIN_SUCCESS_REBOOT_REQUIRED = 3010, ++ MD_ERROR_WIN_SUCCESS_RESTART_REQUIRED = 3011, ++ MD_ERROR_WIN_PRINTER_NOT_FOUND = 3012, ++ MD_ERROR_WIN_PRINTER_DRIVER_WARNED = 3013, ++ MD_ERROR_WIN_PRINTER_DRIVER_BLOCKED = 3014, ++ MD_ERROR_WIN_PRINTER_DRIVER_PACKAGE_IN_USE = 3015, ++ MD_ERROR_WIN_CORE_DRIVER_PACKAGE_NOT_FOUND = 3016, ++ MD_ERROR_WIN_FAIL_REBOOT_REQUIRED = 3017, ++ MD_ERROR_WIN_FAIL_REBOOT_INITIATED = 3018, ++ MD_ERROR_WIN_PRINTER_DRIVER_DOWNLOAD_NEEDED = 3019, ++ MD_ERROR_WIN_PRINT_JOB_RESTART_REQUIRED = 3020, ++ MD_ERROR_WIN_INVALID_PRINTER_DRIVER_MANIFEST = 3021, ++ MD_ERROR_WIN_PRINTER_NOT_SHAREABLE = 3022, ++ MD_ERROR_WIN_REQUEST_PAUSED = 3050, ++ MD_ERROR_WIN_APPEXEC_CONDITION_NOT_SATISFIED = 3060, ++ MD_ERROR_WIN_APPEXEC_HANDLE_INVALIDATED = 3061, ++ MD_ERROR_WIN_APPEXEC_INVALID_HOST_GENERATION = 3062, ++ MD_ERROR_WIN_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION = 3063, ++ MD_ERROR_WIN_APPEXEC_INVALID_HOST_STATE = 3064, ++ MD_ERROR_WIN_APPEXEC_NO_DONOR = 3065, ++ MD_ERROR_WIN_APPEXEC_HOST_ID_MISMATCH = 3066, ++ MD_ERROR_WIN_APPEXEC_UNKNOWN_USER = 3067, ++ MD_ERROR_WIN_IO_REISSUE_AS_CACHED = 3950, ++ MD_ERROR_WIN_WINS_INTERNAL = 4000, ++ MD_ERROR_WIN_CAN_NOT_DEL_LOCAL_WINS = 4001, ++ MD_ERROR_WIN_STATIC_INIT = 4002, ++ MD_ERROR_WIN_INC_BACKUP = 4003, ++ MD_ERROR_WIN_FULL_BACKUP = 4004, ++ MD_ERROR_WIN_REC_NON_EXISTENT = 4005, ++ MD_ERROR_WIN_RPL_NOT_ALLOWED = 4006, ++ MD_ERROR_WIN_DHCP_ADDRESS_CONFLICT = 4100, ++ MD_ERROR_WIN_WMI_GUID_NOT_FOUND = 4200, ++ MD_ERROR_WIN_WMI_INSTANCE_NOT_FOUND = 4201, ++ MD_ERROR_WIN_WMI_ITEMID_NOT_FOUND = 4202, ++ MD_ERROR_WIN_WMI_TRY_AGAIN = 4203, ++ MD_ERROR_WIN_WMI_DP_NOT_FOUND = 4204, ++ MD_ERROR_WIN_WMI_UNRESOLVED_INSTANCE_REF = 4205, ++ MD_ERROR_WIN_WMI_ALREADY_ENABLED = 4206, ++ MD_ERROR_WIN_WMI_GUID_DISCONNECTED = 4207, ++ MD_ERROR_WIN_WMI_SERVER_UNAVAILABLE = 4208, ++ MD_ERROR_WIN_WMI_DP_FAILED = 4209, ++ MD_ERROR_WIN_WMI_INVALID_MOF = 4210, ++ MD_ERROR_WIN_WMI_INVALID_REGINFO = 4211, ++ MD_ERROR_WIN_WMI_ALREADY_DISABLED = 4212, ++ MD_ERROR_WIN_WMI_READ_ONLY = 4213, ++ MD_ERROR_WIN_WMI_SET_FAILURE = 4214, ++ MD_ERROR_WIN_NOT_APPCONTAINER = 4250, ++ MD_ERROR_WIN_APPCONTAINER_REQUIRED = 4251, ++ MD_ERROR_WIN_NOT_SUPPORTED_IN_APPCONTAINER = 4252, ++ MD_ERROR_WIN_INVALID_PACKAGE_SID_LENGTH = 4253, ++ MD_ERROR_WIN_INVALID_MEDIA = 4300, ++ MD_ERROR_WIN_INVALID_LIBRARY = 4301, ++ MD_ERROR_WIN_INVALID_MEDIA_POOL = 4302, ++ MD_ERROR_WIN_DRIVE_MEDIA_MISMATCH = 4303, ++ MD_ERROR_WIN_MEDIA_OFFLINE = 4304, ++ MD_ERROR_WIN_LIBRARY_OFFLINE = 4305, ++ MD_ERROR_WIN_EMPTY = 4306, ++ MD_ERROR_WIN_NOT_EMPTY = 4307, ++ MD_ERROR_WIN_MEDIA_UNAVAILABLE = 4308, ++ MD_ERROR_WIN_RESOURCE_DISABLED = 4309, ++ MD_ERROR_WIN_INVALID_CLEANER = 4310, ++ MD_ERROR_WIN_UNABLE_TO_CLEAN = 4311, ++ MD_ERROR_WIN_OBJECT_NOT_FOUND = 4312, ++ MD_ERROR_WIN_DATABASE_FAILURE = 4313, ++ MD_ERROR_WIN_DATABASE_FULL = 4314, ++ MD_ERROR_WIN_MEDIA_INCOMPATIBLE = 4315, ++ MD_ERROR_WIN_RESOURCE_NOT_PRESENT = 4316, ++ MD_ERROR_WIN_INVALID_OPERATION = 4317, ++ MD_ERROR_WIN_MEDIA_NOT_AVAILABLE = 4318, ++ MD_ERROR_WIN_DEVICE_NOT_AVAILABLE = 4319, ++ MD_ERROR_WIN_REQUEST_REFUSED = 4320, ++ MD_ERROR_WIN_INVALID_DRIVE_OBJECT = 4321, ++ MD_ERROR_WIN_LIBRARY_FULL = 4322, ++ MD_ERROR_WIN_MEDIUM_NOT_ACCESSIBLE = 4323, ++ MD_ERROR_WIN_UNABLE_TO_LOAD_MEDIUM = 4324, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_DRIVE = 4325, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_SLOT = 4326, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_TRANSPORT = 4327, ++ MD_ERROR_WIN_TRANSPORT_FULL = 4328, ++ MD_ERROR_WIN_CONTROLLING_IEPORT = 4329, ++ MD_ERROR_WIN_UNABLE_TO_EJECT_MOUNTED_MEDIA = 4330, ++ MD_ERROR_WIN_CLEANER_SLOT_SET = 4331, ++ MD_ERROR_WIN_CLEANER_SLOT_NOT_SET = 4332, ++ MD_ERROR_WIN_CLEANER_CARTRIDGE_SPENT = 4333, ++ MD_ERROR_WIN_UNEXPECTED_OMID = 4334, ++ MD_ERROR_WIN_CANT_DELETE_LAST_ITEM = 4335, ++ MD_ERROR_WIN_MESSAGE_EXCEEDS_MAX_SIZE = 4336, ++ MD_ERROR_WIN_VOLUME_CONTAINS_SYS_FILES = 4337, ++ MD_ERROR_WIN_INDIGENOUS_TYPE = 4338, ++ MD_ERROR_WIN_NO_SUPPORTING_DRIVES = 4339, ++ MD_ERROR_WIN_CLEANER_CARTRIDGE_INSTALLED = 4340, ++ MD_ERROR_WIN_IEPORT_FULL = 4341, ++ MD_ERROR_WIN_FILE_OFFLINE = 4350, ++ MD_ERROR_WIN_REMOTE_STORAGE_NOT_ACTIVE = 4351, ++ MD_ERROR_WIN_REMOTE_STORAGE_MEDIA_ERROR = 4352, ++ MD_ERROR_WIN_NOT_A_REPARSE_POINT = 4390, ++ MD_ERROR_WIN_REPARSE_ATTRIBUTE_CONFLICT = 4391, ++ MD_ERROR_WIN_INVALID_REPARSE_DATA = 4392, ++ MD_ERROR_WIN_REPARSE_TAG_INVALID = 4393, ++ MD_ERROR_WIN_REPARSE_TAG_MISMATCH = 4394, ++ MD_ERROR_WIN_REPARSE_POINT_ENCOUNTERED = 4395, ++ MD_ERROR_WIN_APP_DATA_NOT_FOUND = 4400, ++ MD_ERROR_WIN_APP_DATA_EXPIRED = 4401, ++ MD_ERROR_WIN_APP_DATA_CORRUPT = 4402, ++ MD_ERROR_WIN_APP_DATA_LIMIT_EXCEEDED = 4403, ++ MD_ERROR_WIN_APP_DATA_REBOOT_REQUIRED = 4404, ++ MD_ERROR_WIN_SECUREBOOT_ROLLBACK_DETECTED = 4420, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_VIOLATION = 4421, ++ MD_ERROR_WIN_SECUREBOOT_INVALID_POLICY = 4422, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND = 4423, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_NOT_SIGNED = 4424, ++ MD_ERROR_WIN_SECUREBOOT_NOT_ENABLED = 4425, ++ MD_ERROR_WIN_SECUREBOOT_FILE_REPLACED = 4426, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_NOT_AUTHORIZED = 4427, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_UNKNOWN = 4428, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION = 4429, ++ MD_ERROR_WIN_SECUREBOOT_PLATFORM_ID_MISMATCH = 4430, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_ROLLBACK_DETECTED = 4431, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_UPGRADE_MISMATCH = 4432, ++ MD_ERROR_WIN_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING = 4433, ++ MD_ERROR_WIN_SECUREBOOT_NOT_BASE_POLICY = 4434, ++ MD_ERROR_WIN_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY = 4435, ++ MD_ERROR_WIN_OFFLOAD_READ_FLT_NOT_SUPPORTED = 4440, ++ MD_ERROR_WIN_OFFLOAD_WRITE_FLT_NOT_SUPPORTED = 4441, ++ MD_ERROR_WIN_OFFLOAD_READ_FILE_NOT_SUPPORTED = 4442, ++ MD_ERROR_WIN_OFFLOAD_WRITE_FILE_NOT_SUPPORTED = 4443, ++ MD_ERROR_WIN_ALREADY_HAS_STREAM_ID = 4444, ++ MD_ERROR_WIN_SMR_GARBAGE_COLLECTION_REQUIRED = 4445, ++ MD_ERROR_WIN_WOF_WIM_HEADER_CORRUPT = 4446, ++ MD_ERROR_WIN_WOF_WIM_RESOURCE_TABLE_CORRUPT = 4447, ++ MD_ERROR_WIN_WOF_FILE_RESOURCE_TABLE_CORRUPT = 4448, ++ MD_ERROR_WIN_VOLUME_NOT_SIS_ENABLED = 4500, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_ROLLBACK_DETECTED = 4550, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_POLICY_VIOLATION = 4551, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_INVALID_POLICY = 4552, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED = 4553, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_TOO_MANY_POLICIES = 4554, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED = 4555, ++ MD_ERROR_WIN_VSM_NOT_INITIALIZED = 4560, ++ MD_ERROR_WIN_VSM_DMA_PROTECTION_NOT_IN_USE = 4561, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_AUTHORIZED = 4570, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_INVALID = 4571, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED = 4572, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED = 4573, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND = 4574, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_ACTIVE = 4575, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_SIGNED = 4576, ++ MD_ERROR_WIN_DEPENDENT_RESOURCE_EXISTS = 5001, ++ MD_ERROR_WIN_DEPENDENCY_NOT_FOUND = 5002, ++ MD_ERROR_WIN_DEPENDENCY_ALREADY_EXISTS = 5003, ++ MD_ERROR_WIN_RESOURCE_NOT_ONLINE = 5004, ++ MD_ERROR_WIN_HOST_NODE_NOT_AVAILABLE = 5005, ++ MD_ERROR_WIN_RESOURCE_NOT_AVAILABLE = 5006, ++ MD_ERROR_WIN_RESOURCE_NOT_FOUND = 5007, ++ MD_ERROR_WIN_SHUTDOWN_CLUSTER = 5008, ++ MD_ERROR_WIN_CANT_EVICT_ACTIVE_NODE = 5009, ++ MD_ERROR_WIN_OBJECT_ALREADY_EXISTS = 5010, ++ MD_ERROR_WIN_OBJECT_IN_LIST = 5011, ++ MD_ERROR_WIN_GROUP_NOT_AVAILABLE = 5012, ++ MD_ERROR_WIN_GROUP_NOT_FOUND = 5013, ++ MD_ERROR_WIN_GROUP_NOT_ONLINE = 5014, ++ MD_ERROR_WIN_HOST_NODE_NOT_RESOURCE_OWNER = 5015, ++ MD_ERROR_WIN_HOST_NODE_NOT_GROUP_OWNER = 5016, ++ MD_ERROR_WIN_RESMON_CREATE_FAILED = 5017, ++ MD_ERROR_WIN_RESMON_ONLINE_FAILED = 5018, ++ MD_ERROR_WIN_RESOURCE_ONLINE = 5019, ++ MD_ERROR_WIN_QUORUM_RESOURCE = 5020, ++ MD_ERROR_WIN_NOT_QUORUM_CAPABLE = 5021, ++ MD_ERROR_WIN_CLUSTER_SHUTTING_DOWN = 5022, ++ MD_ERROR_WIN_INVALID_STATE = 5023, ++ MD_ERROR_WIN_RESOURCE_PROPERTIES_STORED = 5024, ++ MD_ERROR_WIN_NOT_QUORUM_CLASS = 5025, ++ MD_ERROR_WIN_CORE_RESOURCE = 5026, ++ MD_ERROR_WIN_QUORUM_RESOURCE_ONLINE_FAILED = 5027, ++ MD_ERROR_WIN_QUORUMLOG_OPEN_FAILED = 5028, ++ MD_ERROR_WIN_CLUSTERLOG_CORRUPT = 5029, ++ MD_ERROR_WIN_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE = 5030, ++ MD_ERROR_WIN_CLUSTERLOG_EXCEEDS_MAXSIZE = 5031, ++ MD_ERROR_WIN_CLUSTERLOG_CHKPOINT_NOT_FOUND = 5032, ++ MD_ERROR_WIN_CLUSTERLOG_NOT_ENOUGH_SPACE = 5033, ++ MD_ERROR_WIN_QUORUM_OWNER_ALIVE = 5034, ++ MD_ERROR_WIN_NETWORK_NOT_AVAILABLE = 5035, ++ MD_ERROR_WIN_NODE_NOT_AVAILABLE = 5036, ++ MD_ERROR_WIN_ALL_NODES_NOT_AVAILABLE = 5037, ++ MD_ERROR_WIN_RESOURCE_FAILED = 5038, ++ MD_ERROR_WIN_CLUSTER_INVALID_NODE = 5039, ++ MD_ERROR_WIN_CLUSTER_NODE_EXISTS = 5040, ++ MD_ERROR_WIN_CLUSTER_JOIN_IN_PROGRESS = 5041, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_FOUND = 5042, ++ MD_ERROR_WIN_CLUSTER_LOCAL_NODE_NOT_FOUND = 5043, ++ MD_ERROR_WIN_CLUSTER_NETWORK_EXISTS = 5044, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_FOUND = 5045, ++ MD_ERROR_WIN_CLUSTER_NETINTERFACE_EXISTS = 5046, ++ MD_ERROR_WIN_CLUSTER_NETINTERFACE_NOT_FOUND = 5047, ++ MD_ERROR_WIN_CLUSTER_INVALID_REQUEST = 5048, ++ MD_ERROR_WIN_CLUSTER_INVALID_NETWORK_PROVIDER = 5049, ++ MD_ERROR_WIN_CLUSTER_NODE_DOWN = 5050, ++ MD_ERROR_WIN_CLUSTER_NODE_UNREACHABLE = 5051, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_MEMBER = 5052, ++ MD_ERROR_WIN_CLUSTER_JOIN_NOT_IN_PROGRESS = 5053, ++ MD_ERROR_WIN_CLUSTER_INVALID_NETWORK = 5054, ++ MD_ERROR_WIN_CLUSTER_NODE_UP = 5056, ++ MD_ERROR_WIN_CLUSTER_IPADDR_IN_USE = 5057, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_PAUSED = 5058, ++ MD_ERROR_WIN_CLUSTER_NO_SECURITY_CONTEXT = 5059, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_INTERNAL = 5060, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_UP = 5061, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_DOWN = 5062, ++ MD_ERROR_WIN_CLUSTER_NETWORK_ALREADY_ONLINE = 5063, ++ MD_ERROR_WIN_CLUSTER_NETWORK_ALREADY_OFFLINE = 5064, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_MEMBER = 5065, ++ MD_ERROR_WIN_CLUSTER_LAST_INTERNAL_NETWORK = 5066, ++ MD_ERROR_WIN_CLUSTER_NETWORK_HAS_DEPENDENTS = 5067, ++ MD_ERROR_WIN_INVALID_OPERATION_ON_QUORUM = 5068, ++ MD_ERROR_WIN_DEPENDENCY_NOT_ALLOWED = 5069, ++ MD_ERROR_WIN_CLUSTER_NODE_PAUSED = 5070, ++ MD_ERROR_WIN_NODE_CANT_HOST_RESOURCE = 5071, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_READY = 5072, ++ MD_ERROR_WIN_CLUSTER_NODE_SHUTTING_DOWN = 5073, ++ MD_ERROR_WIN_CLUSTER_JOIN_ABORTED = 5074, ++ MD_ERROR_WIN_CLUSTER_INCOMPATIBLE_VERSIONS = 5075, ++ MD_ERROR_WIN_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED = 5076, ++ MD_ERROR_WIN_CLUSTER_SYSTEM_CONFIG_CHANGED = 5077, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_TYPE_NOT_FOUND = 5078, ++ MD_ERROR_WIN_CLUSTER_RESTYPE_NOT_SUPPORTED = 5079, ++ MD_ERROR_WIN_CLUSTER_RESNAME_NOT_FOUND = 5080, ++ MD_ERROR_WIN_CLUSTER_NO_RPC_PACKAGES_REGISTERED = 5081, ++ MD_ERROR_WIN_CLUSTER_OWNER_NOT_IN_PREFLIST = 5082, ++ MD_ERROR_WIN_CLUSTER_DATABASE_SEQMISMATCH = 5083, ++ MD_ERROR_WIN_RESMON_INVALID_STATE = 5084, ++ MD_ERROR_WIN_CLUSTER_GUM_NOT_LOCKER = 5085, ++ MD_ERROR_WIN_QUORUM_DISK_NOT_FOUND = 5086, ++ MD_ERROR_WIN_DATABASE_BACKUP_CORRUPT = 5087, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT = 5088, ++ MD_ERROR_WIN_RESOURCE_PROPERTY_UNCHANGEABLE = 5089, ++ MD_ERROR_WIN_NO_ADMIN_ACCESS_POINT = 5090, ++ MD_ERROR_WIN_CLUSTER_MEMBERSHIP_INVALID_STATE = 5890, ++ MD_ERROR_WIN_CLUSTER_QUORUMLOG_NOT_FOUND = 5891, ++ MD_ERROR_WIN_CLUSTER_MEMBERSHIP_HALT = 5892, ++ MD_ERROR_WIN_CLUSTER_INSTANCE_ID_MISMATCH = 5893, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_FOUND_FOR_IP = 5894, ++ MD_ERROR_WIN_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH = 5895, ++ MD_ERROR_WIN_CLUSTER_EVICT_WITHOUT_CLEANUP = 5896, ++ MD_ERROR_WIN_CLUSTER_PARAMETER_MISMATCH = 5897, ++ MD_ERROR_WIN_NODE_CANNOT_BE_CLUSTERED = 5898, ++ MD_ERROR_WIN_CLUSTER_WRONG_OS_VERSION = 5899, ++ MD_ERROR_WIN_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME = 5900, ++ MD_ERROR_WIN_CLUSCFG_ALREADY_COMMITTED = 5901, ++ MD_ERROR_WIN_CLUSCFG_ROLLBACK_FAILED = 5902, ++ MD_ERROR_WIN_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT = 5903, ++ MD_ERROR_WIN_CLUSTER_OLD_VERSION = 5904, ++ MD_ERROR_WIN_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME = 5905, ++ MD_ERROR_WIN_CLUSTER_NO_NET_ADAPTERS = 5906, ++ MD_ERROR_WIN_CLUSTER_POISONED = 5907, ++ MD_ERROR_WIN_CLUSTER_GROUP_MOVING = 5908, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_TYPE_BUSY = 5909, ++ MD_ERROR_WIN_RESOURCE_CALL_TIMED_OUT = 5910, ++ MD_ERROR_WIN_INVALID_CLUSTER_IPV6_ADDRESS = 5911, ++ MD_ERROR_WIN_CLUSTER_INTERNAL_INVALID_FUNCTION = 5912, ++ MD_ERROR_WIN_CLUSTER_PARAMETER_OUT_OF_BOUNDS = 5913, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_SEND = 5914, ++ MD_ERROR_WIN_CLUSTER_REGISTRY_INVALID_FUNCTION = 5915, ++ MD_ERROR_WIN_CLUSTER_INVALID_STRING_TERMINATION = 5916, ++ MD_ERROR_WIN_CLUSTER_INVALID_STRING_FORMAT = 5917, ++ MD_ERROR_WIN_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS = 5918, ++ MD_ERROR_WIN_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS = 5919, ++ MD_ERROR_WIN_CLUSTER_NULL_DATA = 5920, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_READ = 5921, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_WRITE = 5922, ++ MD_ERROR_WIN_CLUSTER_CANT_DESERIALIZE_DATA = 5923, ++ MD_ERROR_WIN_DEPENDENT_RESOURCE_PROPERTY_CONFLICT = 5924, ++ MD_ERROR_WIN_CLUSTER_NO_QUORUM = 5925, ++ MD_ERROR_WIN_CLUSTER_INVALID_IPV6_NETWORK = 5926, ++ MD_ERROR_WIN_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK = 5927, ++ MD_ERROR_WIN_QUORUM_NOT_ALLOWED_IN_THIS_GROUP = 5928, ++ MD_ERROR_WIN_DEPENDENCY_TREE_TOO_COMPLEX = 5929, ++ MD_ERROR_WIN_EXCEPTION_IN_RESOURCE_CALL = 5930, ++ MD_ERROR_WIN_CLUSTER_RHS_FAILED_INITIALIZATION = 5931, ++ MD_ERROR_WIN_CLUSTER_NOT_INSTALLED = 5932, ++ MD_ERROR_WIN_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODE = 5933, ++ MD_ERROR_WIN_CLUSTER_MAX_NODES_IN_CLUSTER = 5934, ++ MD_ERROR_WIN_CLUSTER_TOO_MANY_NODES = 5935, ++ MD_ERROR_WIN_CLUSTER_OBJECT_ALREADY_USED = 5936, ++ MD_ERROR_WIN_NONCORE_GROUPS_FOUND = 5937, ++ MD_ERROR_WIN_FILE_SHARE_RESOURCE_CONFLICT = 5938, ++ MD_ERROR_WIN_CLUSTER_EVICT_INVALID_REQUEST = 5939, ++ MD_ERROR_WIN_CLUSTER_SINGLETON_RESOURCE = 5940, ++ MD_ERROR_WIN_CLUSTER_GROUP_SINGLETON_RESOURCE = 5941, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_PROVIDER_FAILED = 5942, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_CONFIGURATION_ERROR = 5943, ++ MD_ERROR_WIN_CLUSTER_GROUP_BUSY = 5944, ++ MD_ERROR_WIN_CLUSTER_NOT_SHARED_VOLUME = 5945, ++ MD_ERROR_WIN_CLUSTER_INVALID_SECURITY_DESCRIPTOR = 5946, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUMES_IN_USE = 5947, ++ MD_ERROR_WIN_CLUSTER_USE_SHARED_VOLUMES_API = 5948, ++ MD_ERROR_WIN_CLUSTER_BACKUP_IN_PROGRESS = 5949, ++ MD_ERROR_WIN_NON_CSV_PATH = 5950, ++ MD_ERROR_WIN_CSV_VOLUME_NOT_LOCAL = 5951, ++ MD_ERROR_WIN_CLUSTER_WATCHDOG_TERMINATING = 5952, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODES = 5953, ++ MD_ERROR_WIN_CLUSTER_INVALID_NODE_WEIGHT = 5954, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_CALL = 5955, ++ MD_ERROR_WIN_RESMON_SYSTEM_RESOURCES_LACKING = 5956, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATION = 5957, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCE = 5958, ++ MD_ERROR_WIN_CLUSTER_GROUP_QUEUED = 5959, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_LOCKED_STATUS = 5960, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWED = 5961, ++ MD_ERROR_WIN_CLUSTER_NODE_DRAIN_IN_PROGRESS = 5962, ++ MD_ERROR_WIN_CLUSTER_DISK_NOT_CONNECTED = 5963, ++ MD_ERROR_WIN_DISK_NOT_CSV_CAPABLE = 5964, ++ MD_ERROR_WIN_RESOURCE_NOT_IN_AVAILABLE_STORAGE = 5965, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_REDIRECTED = 5966, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_NOT_REDIRECTED = 5967, ++ MD_ERROR_WIN_CLUSTER_CANNOT_RETURN_PROPERTIES = 5968, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMES = 5969, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODE = 5970, ++ MD_ERROR_WIN_CLUSTER_AFFINITY_CONFLICT = 5971, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINE = 5972, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_INCOMPATIBLE_VERSIONS = 5973, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_FIX_QUORUM_NOT_SUPPORTED = 5974, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_RESTART_REQUIRED = 5975, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_IN_PROGRESS = 5976, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_INCOMPLETE = 5977, ++ MD_ERROR_WIN_CLUSTER_NODE_IN_GRACE_PERIOD = 5978, ++ MD_ERROR_WIN_CLUSTER_CSV_IO_PAUSE_TIMEOUT = 5979, ++ MD_ERROR_WIN_NODE_NOT_ACTIVE_CLUSTER_MEMBER = 5980, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_NOT_MONITORED = 5981, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_DOES_NOT_SUPPORT_UNMONITORED = 5982, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_REPLICATED = 5983, ++ MD_ERROR_WIN_CLUSTER_NODE_ISOLATED = 5984, ++ MD_ERROR_WIN_CLUSTER_NODE_QUARANTINED = 5985, ++ MD_ERROR_WIN_CLUSTER_DATABASE_UPDATE_CONDITION_FAILED = 5986, ++ MD_ERROR_WIN_CLUSTER_SPACE_DEGRADED = 5987, ++ MD_ERROR_WIN_CLUSTER_TOKEN_DELEGATION_NOT_SUPPORTED = 5988, ++ MD_ERROR_WIN_CLUSTER_CSV_INVALID_HANDLE = 5989, ++ MD_ERROR_WIN_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR = 5990, ++ MD_ERROR_WIN_GROUPSET_NOT_AVAILABLE = 5991, ++ MD_ERROR_WIN_GROUPSET_NOT_FOUND = 5992, ++ MD_ERROR_WIN_GROUPSET_CANT_PROVIDE = 5993, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_PARENT_NOT_FOUND = 5994, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_INVALID_HIERARCHY = 5995, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_FAILED_S2D_VALIDATION = 5996, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_S2D_CONNECTIVITY_LOSS = 5997, ++ MD_ERROR_WIN_CLUSTER_INVALID_INFRASTRUCTURE_FILESERVER_NAME = 5998, ++ MD_ERROR_WIN_CLUSTERSET_MANAGEMENT_CLUSTER_UNREACHABLE = 5999, ++ MD_ERROR_WIN_ENCRYPTION_FAILED = 6000, ++ MD_ERROR_WIN_DECRYPTION_FAILED = 6001, ++ MD_ERROR_WIN_FILE_ENCRYPTED = 6002, ++ MD_ERROR_WIN_NO_RECOVERY_POLICY = 6003, ++ MD_ERROR_WIN_NO_EFS = 6004, ++ MD_ERROR_WIN_WRONG_EFS = 6005, ++ MD_ERROR_WIN_NO_USER_KEYS = 6006, ++ MD_ERROR_WIN_FILE_NOT_ENCRYPTED = 6007, ++ MD_ERROR_WIN_NOT_EXPORT_FORMAT = 6008, ++ MD_ERROR_WIN_FILE_READ_ONLY = 6009, ++ MD_ERROR_WIN_DIR_EFS_DISALLOWED = 6010, ++ MD_ERROR_WIN_EFS_SERVER_NOT_TRUSTED = 6011, ++ MD_ERROR_WIN_BAD_RECOVERY_POLICY = 6012, ++ MD_ERROR_WIN_EFS_ALG_BLOB_TOO_BIG = 6013, ++ MD_ERROR_WIN_VOLUME_NOT_SUPPORT_EFS = 6014, ++ MD_ERROR_WIN_EFS_DISABLED = 6015, ++ MD_ERROR_WIN_EFS_VERSION_NOT_SUPPORT = 6016, ++ MD_ERROR_WIN_CS_ENCRYPTION_INVALID_SERVER_RESPONSE = 6017, ++ MD_ERROR_WIN_CS_ENCRYPTION_UNSUPPORTED_SERVER = 6018, ++ MD_ERROR_WIN_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE = 6019, ++ MD_ERROR_WIN_CS_ENCRYPTION_NEW_ENCRYPTED_FILE = 6020, ++ MD_ERROR_WIN_CS_ENCRYPTION_FILE_NOT_CSE = 6021, ++ MD_ERROR_WIN_ENCRYPTION_POLICY_DENIES_OPERATION = 6022, ++ MD_ERROR_WIN_WIP_ENCRYPTION_FAILED = 6023, ++ MD_ERROR_WIN_NO_BROWSER_SERVERS_FOUND = 6118, ++ MD_ERROR_WIN_CLUSTER_OBJECT_IS_CLUSTER_SET_VM = 6250, ++ MD_ERROR_WIN_LOG_SECTOR_INVALID = 6600, ++ MD_ERROR_WIN_LOG_SECTOR_PARITY_INVALID = 6601, ++ MD_ERROR_WIN_LOG_SECTOR_REMAPPED = 6602, ++ MD_ERROR_WIN_LOG_BLOCK_INCOMPLETE = 6603, ++ MD_ERROR_WIN_LOG_INVALID_RANGE = 6604, ++ MD_ERROR_WIN_LOG_BLOCKS_EXHAUSTED = 6605, ++ MD_ERROR_WIN_LOG_READ_CONTEXT_INVALID = 6606, ++ MD_ERROR_WIN_LOG_RESTART_INVALID = 6607, ++ MD_ERROR_WIN_LOG_BLOCK_VERSION = 6608, ++ MD_ERROR_WIN_LOG_BLOCK_INVALID = 6609, ++ MD_ERROR_WIN_LOG_READ_MODE_INVALID = 6610, ++ MD_ERROR_WIN_LOG_NO_RESTART = 6611, ++ MD_ERROR_WIN_LOG_METADATA_CORRUPT = 6612, ++ MD_ERROR_WIN_LOG_METADATA_INVALID = 6613, ++ MD_ERROR_WIN_LOG_METADATA_INCONSISTENT = 6614, ++ MD_ERROR_WIN_LOG_RESERVATION_INVALID = 6615, ++ MD_ERROR_WIN_LOG_CANT_DELETE = 6616, ++ MD_ERROR_WIN_LOG_CONTAINER_LIMIT_EXCEEDED = 6617, ++ MD_ERROR_WIN_LOG_START_OF_LOG = 6618, ++ MD_ERROR_WIN_LOG_POLICY_ALREADY_INSTALLED = 6619, ++ MD_ERROR_WIN_LOG_POLICY_NOT_INSTALLED = 6620, ++ MD_ERROR_WIN_LOG_POLICY_INVALID = 6621, ++ MD_ERROR_WIN_LOG_POLICY_CONFLICT = 6622, ++ MD_ERROR_WIN_LOG_PINNED_ARCHIVE_TAIL = 6623, ++ MD_ERROR_WIN_LOG_RECORD_NONEXISTENT = 6624, ++ MD_ERROR_WIN_LOG_RECORDS_RESERVED_INVALID = 6625, ++ MD_ERROR_WIN_LOG_SPACE_RESERVED_INVALID = 6626, ++ MD_ERROR_WIN_LOG_TAIL_INVALID = 6627, ++ MD_ERROR_WIN_LOG_FULL = 6628, ++ MD_ERROR_WIN_COULD_NOT_RESIZE_LOG = 6629, ++ MD_ERROR_WIN_LOG_MULTIPLEXED = 6630, ++ MD_ERROR_WIN_LOG_DEDICATED = 6631, ++ MD_ERROR_WIN_LOG_ARCHIVE_NOT_IN_PROGRESS = 6632, ++ MD_ERROR_WIN_LOG_ARCHIVE_IN_PROGRESS = 6633, ++ MD_ERROR_WIN_LOG_EPHEMERAL = 6634, ++ MD_ERROR_WIN_LOG_NOT_ENOUGH_CONTAINERS = 6635, ++ MD_ERROR_WIN_LOG_CLIENT_ALREADY_REGISTERED = 6636, ++ MD_ERROR_WIN_LOG_CLIENT_NOT_REGISTERED = 6637, ++ MD_ERROR_WIN_LOG_FULL_HANDLER_IN_PROGRESS = 6638, ++ MD_ERROR_WIN_LOG_CONTAINER_READ_FAILED = 6639, ++ MD_ERROR_WIN_LOG_CONTAINER_WRITE_FAILED = 6640, ++ MD_ERROR_WIN_LOG_CONTAINER_OPEN_FAILED = 6641, ++ MD_ERROR_WIN_LOG_CONTAINER_STATE_INVALID = 6642, ++ MD_ERROR_WIN_LOG_STATE_INVALID = 6643, ++ MD_ERROR_WIN_LOG_PINNED = 6644, ++ MD_ERROR_WIN_LOG_METADATA_FLUSH_FAILED = 6645, ++ MD_ERROR_WIN_LOG_INCONSISTENT_SECURITY = 6646, ++ MD_ERROR_WIN_LOG_APPENDED_FLUSH_FAILED = 6647, ++ MD_ERROR_WIN_LOG_PINNED_RESERVATION = 6648, ++ MD_ERROR_WIN_INVALID_TRANSACTION = 6700, ++ MD_ERROR_WIN_TRANSACTION_NOT_ACTIVE = 6701, ++ MD_ERROR_WIN_TRANSACTION_REQUEST_NOT_VALID = 6702, ++ MD_ERROR_WIN_TRANSACTION_NOT_REQUESTED = 6703, ++ MD_ERROR_WIN_TRANSACTION_ALREADY_ABORTED = 6704, ++ MD_ERROR_WIN_TRANSACTION_ALREADY_COMMITTED = 6705, ++ MD_ERROR_WIN_TM_INITIALIZATION_FAILED = 6706, ++ MD_ERROR_WIN_RESOURCEMANAGER_READ_ONLY = 6707, ++ MD_ERROR_WIN_TRANSACTION_NOT_JOINED = 6708, ++ MD_ERROR_WIN_TRANSACTION_SUPERIOR_EXISTS = 6709, ++ MD_ERROR_WIN_CRM_PROTOCOL_ALREADY_EXISTS = 6710, ++ MD_ERROR_WIN_TRANSACTION_PROPAGATION_FAILED = 6711, ++ MD_ERROR_WIN_CRM_PROTOCOL_NOT_FOUND = 6712, ++ MD_ERROR_WIN_TRANSACTION_INVALID_MARSHALL_BUFFER = 6713, ++ MD_ERROR_WIN_CURRENT_TRANSACTION_NOT_VALID = 6714, ++ MD_ERROR_WIN_TRANSACTION_NOT_FOUND = 6715, ++ MD_ERROR_WIN_RESOURCEMANAGER_NOT_FOUND = 6716, ++ MD_ERROR_WIN_ENLISTMENT_NOT_FOUND = 6717, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_NOT_FOUND = 6718, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_NOT_ONLINE = 6719, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION = 6720, ++ MD_ERROR_WIN_TRANSACTION_NOT_ROOT = 6721, ++ MD_ERROR_WIN_TRANSACTION_OBJECT_EXPIRED = 6722, ++ MD_ERROR_WIN_TRANSACTION_RESPONSE_NOT_ENLISTED = 6723, ++ MD_ERROR_WIN_TRANSACTION_RECORD_TOO_LONG = 6724, ++ MD_ERROR_WIN_IMPLICIT_TRANSACTION_NOT_SUPPORTED = 6725, ++ MD_ERROR_WIN_TRANSACTION_INTEGRITY_VIOLATED = 6726, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_IDENTITY_MISMATCH = 6727, ++ MD_ERROR_WIN_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT = 6728, ++ MD_ERROR_WIN_TRANSACTION_MUST_WRITETHROUGH = 6729, ++ MD_ERROR_WIN_TRANSACTION_NO_SUPERIOR = 6730, ++ MD_ERROR_WIN_HEURISTIC_DAMAGE_POSSIBLE = 6731, ++ MD_ERROR_WIN_TRANSACTIONAL_CONFLICT = 6800, ++ MD_ERROR_WIN_RM_NOT_ACTIVE = 6801, ++ MD_ERROR_WIN_RM_METADATA_CORRUPT = 6802, ++ MD_ERROR_WIN_DIRECTORY_NOT_RM = 6803, ++ MD_ERROR_WIN_TRANSACTIONS_UNSUPPORTED_REMOTE = 6805, ++ MD_ERROR_WIN_LOG_RESIZE_INVALID_SIZE = 6806, ++ MD_ERROR_WIN_OBJECT_NO_LONGER_EXISTS = 6807, ++ MD_ERROR_WIN_STREAM_MINIVERSION_NOT_FOUND = 6808, ++ MD_ERROR_WIN_STREAM_MINIVERSION_NOT_VALID = 6809, ++ MD_ERROR_WIN_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION = 6810, ++ MD_ERROR_WIN_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT = 6811, ++ MD_ERROR_WIN_CANT_CREATE_MORE_STREAM_MINIVERSIONS = 6812, ++ MD_ERROR_WIN_REMOTE_FILE_VERSION_MISMATCH = 6814, ++ MD_ERROR_WIN_HANDLE_NO_LONGER_VALID = 6815, ++ MD_ERROR_WIN_NO_TXF_METADATA = 6816, ++ MD_ERROR_WIN_LOG_CORRUPTION_DETECTED = 6817, ++ MD_ERROR_WIN_CANT_RECOVER_WITH_HANDLE_OPEN = 6818, ++ MD_ERROR_WIN_RM_DISCONNECTED = 6819, ++ MD_ERROR_WIN_ENLISTMENT_NOT_SUPERIOR = 6820, ++ MD_ERROR_WIN_RECOVERY_NOT_NEEDED = 6821, ++ MD_ERROR_WIN_RM_ALREADY_STARTED = 6822, ++ MD_ERROR_WIN_FILE_IDENTITY_NOT_PERSISTENT = 6823, ++ MD_ERROR_WIN_CANT_BREAK_TRANSACTIONAL_DEPENDENCY = 6824, ++ MD_ERROR_WIN_CANT_CROSS_RM_BOUNDARY = 6825, ++ MD_ERROR_WIN_TXF_DIR_NOT_EMPTY = 6826, ++ MD_ERROR_WIN_INDOUBT_TRANSACTIONS_EXIST = 6827, ++ MD_ERROR_WIN_TM_VOLATILE = 6828, ++ MD_ERROR_WIN_ROLLBACK_TIMER_EXPIRED = 6829, ++ MD_ERROR_WIN_TXF_ATTRIBUTE_CORRUPT = 6830, ++ MD_ERROR_WIN_EFS_NOT_ALLOWED_IN_TRANSACTION = 6831, ++ MD_ERROR_WIN_TRANSACTIONAL_OPEN_NOT_ALLOWED = 6832, ++ MD_ERROR_WIN_LOG_GROWTH_FAILED = 6833, ++ MD_ERROR_WIN_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE = 6834, ++ MD_ERROR_WIN_TXF_METADATA_ALREADY_PRESENT = 6835, ++ MD_ERROR_WIN_TRANSACTION_SCOPE_CALLBACKS_NOT_SET = 6836, ++ MD_ERROR_WIN_TRANSACTION_REQUIRED_PROMOTION = 6837, ++ MD_ERROR_WIN_CANNOT_EXECUTE_FILE_IN_TRANSACTION = 6838, ++ MD_ERROR_WIN_TRANSACTIONS_NOT_FROZEN = 6839, ++ MD_ERROR_WIN_TRANSACTION_FREEZE_IN_PROGRESS = 6840, ++ MD_ERROR_WIN_NOT_SNAPSHOT_VOLUME = 6841, ++ MD_ERROR_WIN_NO_SAVEPOINT_WITH_OPEN_FILES = 6842, ++ MD_ERROR_WIN_DATA_LOST_REPAIR = 6843, ++ MD_ERROR_WIN_SPARSE_NOT_ALLOWED_IN_TRANSACTION = 6844, ++ MD_ERROR_WIN_TM_IDENTITY_MISMATCH = 6845, ++ MD_ERROR_WIN_FLOATED_SECTION = 6846, ++ MD_ERROR_WIN_CANNOT_ACCEPT_TRANSACTED_WORK = 6847, ++ MD_ERROR_WIN_CANNOT_ABORT_TRANSACTIONS = 6848, ++ MD_ERROR_WIN_BAD_CLUSTERS = 6849, ++ MD_ERROR_WIN_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION = 6850, ++ MD_ERROR_WIN_VOLUME_DIRTY = 6851, ++ MD_ERROR_WIN_NO_LINK_TRACKING_IN_TRANSACTION = 6852, ++ MD_ERROR_WIN_OPERATION_NOT_SUPPORTED_IN_TRANSACTION = 6853, ++ MD_ERROR_WIN_EXPIRED_HANDLE = 6854, ++ MD_ERROR_WIN_TRANSACTION_NOT_ENLISTED = 6855, ++ MD_ERROR_WIN_CTX_WINSTATION_NAME_INVALID = 7001, ++ MD_ERROR_WIN_CTX_INVALID_PD = 7002, ++ MD_ERROR_WIN_CTX_PD_NOT_FOUND = 7003, ++ MD_ERROR_WIN_CTX_WD_NOT_FOUND = 7004, ++ MD_ERROR_WIN_CTX_CANNOT_MAKE_EVENTLOG_ENTRY = 7005, ++ MD_ERROR_WIN_CTX_SERVICE_NAME_COLLISION = 7006, ++ MD_ERROR_WIN_CTX_CLOSE_PENDING = 7007, ++ MD_ERROR_WIN_CTX_NO_OUTBUF = 7008, ++ MD_ERROR_WIN_CTX_MODEM_INF_NOT_FOUND = 7009, ++ MD_ERROR_WIN_CTX_INVALID_MODEMNAME = 7010, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_ERROR = 7011, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_TIMEOUT = 7012, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_NO_CARRIER = 7013, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_NO_DIALTONE = 7014, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_BUSY = 7015, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_VOICE = 7016, ++ MD_ERROR_WIN_CTX_TD_ERROR = 7017, ++ MD_ERROR_WIN_CTX_WINSTATION_NOT_FOUND = 7022, ++ MD_ERROR_WIN_CTX_WINSTATION_ALREADY_EXISTS = 7023, ++ MD_ERROR_WIN_CTX_WINSTATION_BUSY = 7024, ++ MD_ERROR_WIN_CTX_BAD_VIDEO_MODE = 7025, ++ MD_ERROR_WIN_CTX_GRAPHICS_INVALID = 7035, ++ MD_ERROR_WIN_CTX_LOGON_DISABLED = 7037, ++ MD_ERROR_WIN_CTX_NOT_CONSOLE = 7038, ++ MD_ERROR_WIN_CTX_CLIENT_QUERY_TIMEOUT = 7040, ++ MD_ERROR_WIN_CTX_CONSOLE_DISCONNECT = 7041, ++ MD_ERROR_WIN_CTX_CONSOLE_CONNECT = 7042, ++ MD_ERROR_WIN_CTX_SHADOW_DENIED = 7044, ++ MD_ERROR_WIN_CTX_WINSTATION_ACCESS_DENIED = 7045, ++ MD_ERROR_WIN_CTX_INVALID_WD = 7049, ++ MD_ERROR_WIN_CTX_SHADOW_INVALID = 7050, ++ MD_ERROR_WIN_CTX_SHADOW_DISABLED = 7051, ++ MD_ERROR_WIN_CTX_CLIENT_LICENSE_IN_USE = 7052, ++ MD_ERROR_WIN_CTX_CLIENT_LICENSE_NOT_SET = 7053, ++ MD_ERROR_WIN_CTX_LICENSE_NOT_AVAILABLE = 7054, ++ MD_ERROR_WIN_CTX_LICENSE_CLIENT_INVALID = 7055, ++ MD_ERROR_WIN_CTX_LICENSE_EXPIRED = 7056, ++ MD_ERROR_WIN_CTX_SHADOW_NOT_RUNNING = 7057, ++ MD_ERROR_WIN_CTX_SHADOW_ENDED_BY_MODE_CHANGE = 7058, ++ MD_ERROR_WIN_ACTIVATION_COUNT_EXCEEDED = 7059, ++ MD_ERROR_WIN_CTX_WINSTATIONS_DISABLED = 7060, ++ MD_ERROR_WIN_CTX_ENCRYPTION_LEVEL_REQUIRED = 7061, ++ MD_ERROR_WIN_CTX_SESSION_IN_USE = 7062, ++ MD_ERROR_WIN_CTX_NO_FORCE_LOGOFF = 7063, ++ MD_ERROR_WIN_CTX_ACCOUNT_RESTRICTION = 7064, ++ MD_ERROR_WIN_RDP_PROTOCOL_ERROR = 7065, ++ MD_ERROR_WIN_CTX_CDM_CONNECT = 7066, ++ MD_ERROR_WIN_CTX_CDM_DISCONNECT = 7067, ++ MD_ERROR_WIN_CTX_SECURITY_LAYER_ERROR = 7068, ++ MD_ERROR_WIN_TS_INCOMPATIBLE_SESSIONS = 7069, ++ MD_ERROR_WIN_TS_VIDEO_SUBSYSTEM_ERROR = 7070, ++ MD_ERROR_WIN_DS_NOT_INSTALLED = 8200, ++ MD_ERROR_WIN_DS_MEMBERSHIP_EVALUATED_LOCALLY = 8201, ++ MD_ERROR_WIN_DS_NO_ATTRIBUTE_OR_VALUE = 8202, ++ MD_ERROR_WIN_DS_INVALID_ATTRIBUTE_SYNTAX = 8203, ++ MD_ERROR_WIN_DS_ATTRIBUTE_TYPE_UNDEFINED = 8204, ++ MD_ERROR_WIN_DS_ATTRIBUTE_OR_VALUE_EXISTS = 8205, ++ MD_ERROR_WIN_DS_BUSY = 8206, ++ MD_ERROR_WIN_DS_UNAVAILABLE = 8207, ++ MD_ERROR_WIN_DS_NO_RIDS_ALLOCATED = 8208, ++ MD_ERROR_WIN_DS_NO_MORE_RIDS = 8209, ++ MD_ERROR_WIN_DS_INCORRECT_ROLE_OWNER = 8210, ++ MD_ERROR_WIN_DS_RIDMGR_INIT_ERROR = 8211, ++ MD_ERROR_WIN_DS_OBJ_CLASS_VIOLATION = 8212, ++ MD_ERROR_WIN_DS_CANT_ON_NON_LEAF = 8213, ++ MD_ERROR_WIN_DS_CANT_ON_RDN = 8214, ++ MD_ERROR_WIN_DS_CANT_MOD_OBJ_CLASS = 8215, ++ MD_ERROR_WIN_DS_CROSS_DOM_MOVE_ERROR = 8216, ++ MD_ERROR_WIN_DS_GC_NOT_AVAILABLE = 8217, ++ MD_ERROR_WIN_SHARED_POLICY = 8218, ++ MD_ERROR_WIN_POLICY_OBJECT_NOT_FOUND = 8219, ++ MD_ERROR_WIN_POLICY_ONLY_IN_DS = 8220, ++ MD_ERROR_WIN_PROMOTION_ACTIVE = 8221, ++ MD_ERROR_WIN_NO_PROMOTION_ACTIVE = 8222, ++ MD_ERROR_WIN_DS_OPERATIONS_ERROR = 8224, ++ MD_ERROR_WIN_DS_PROTOCOL_ERROR = 8225, ++ MD_ERROR_WIN_DS_TIMELIMIT_EXCEEDED = 8226, ++ MD_ERROR_WIN_DS_SIZELIMIT_EXCEEDED = 8227, ++ MD_ERROR_WIN_DS_ADMIN_LIMIT_EXCEEDED = 8228, ++ MD_ERROR_WIN_DS_COMPARE_FALSE = 8229, ++ MD_ERROR_WIN_DS_COMPARE_TRUE = 8230, ++ MD_ERROR_WIN_DS_AUTH_METHOD_NOT_SUPPORTED = 8231, ++ MD_ERROR_WIN_DS_STRONG_AUTH_REQUIRED = 8232, ++ MD_ERROR_WIN_DS_INAPPROPRIATE_AUTH = 8233, ++ MD_ERROR_WIN_DS_AUTH_UNKNOWN = 8234, ++ MD_ERROR_WIN_DS_REFERRAL = 8235, ++ MD_ERROR_WIN_DS_UNAVAILABLE_CRIT_EXTENSION = 8236, ++ MD_ERROR_WIN_DS_CONFIDENTIALITY_REQUIRED = 8237, ++ MD_ERROR_WIN_DS_INAPPROPRIATE_MATCHING = 8238, ++ MD_ERROR_WIN_DS_CONSTRAINT_VIOLATION = 8239, ++ MD_ERROR_WIN_DS_NO_SUCH_OBJECT = 8240, ++ MD_ERROR_WIN_DS_ALIAS_PROBLEM = 8241, ++ MD_ERROR_WIN_DS_INVALID_DN_SYNTAX = 8242, ++ MD_ERROR_WIN_DS_IS_LEAF = 8243, ++ MD_ERROR_WIN_DS_ALIAS_DEREF_PROBLEM = 8244, ++ MD_ERROR_WIN_DS_UNWILLING_TO_PERFORM = 8245, ++ MD_ERROR_WIN_DS_LOOP_DETECT = 8246, ++ MD_ERROR_WIN_DS_NAMING_VIOLATION = 8247, ++ MD_ERROR_WIN_DS_OBJECT_RESULTS_TOO_LARGE = 8248, ++ MD_ERROR_WIN_DS_AFFECTS_MULTIPLE_DSAS = 8249, ++ MD_ERROR_WIN_DS_SERVER_DOWN = 8250, ++ MD_ERROR_WIN_DS_LOCAL_ERROR = 8251, ++ MD_ERROR_WIN_DS_ENCODING_ERROR = 8252, ++ MD_ERROR_WIN_DS_DECODING_ERROR = 8253, ++ MD_ERROR_WIN_DS_FILTER_UNKNOWN = 8254, ++ MD_ERROR_WIN_DS_PARAM_ERROR = 8255, ++ MD_ERROR_WIN_DS_NOT_SUPPORTED = 8256, ++ MD_ERROR_WIN_DS_NO_RESULTS_RETURNED = 8257, ++ MD_ERROR_WIN_DS_CONTROL_NOT_FOUND = 8258, ++ MD_ERROR_WIN_DS_CLIENT_LOOP = 8259, ++ MD_ERROR_WIN_DS_REFERRAL_LIMIT_EXCEEDED = 8260, ++ MD_ERROR_WIN_DS_SORT_CONTROL_MISSING = 8261, ++ MD_ERROR_WIN_DS_OFFSET_RANGE_ERROR = 8262, ++ MD_ERROR_WIN_DS_RIDMGR_DISABLED = 8263, ++ MD_ERROR_WIN_DS_ROOT_MUST_BE_NC = 8301, ++ MD_ERROR_WIN_DS_ADD_REPLICA_INHIBITED = 8302, ++ MD_ERROR_WIN_DS_ATT_NOT_DEF_IN_SCHEMA = 8303, ++ MD_ERROR_WIN_DS_MAX_OBJ_SIZE_EXCEEDED = 8304, ++ MD_ERROR_WIN_DS_OBJ_STRING_NAME_EXISTS = 8305, ++ MD_ERROR_WIN_DS_NO_RDN_DEFINED_IN_SCHEMA = 8306, ++ MD_ERROR_WIN_DS_RDN_DOESNT_MATCH_SCHEMA = 8307, ++ MD_ERROR_WIN_DS_NO_REQUESTED_ATTS_FOUND = 8308, ++ MD_ERROR_WIN_DS_USER_BUFFER_TO_SMALL = 8309, ++ MD_ERROR_WIN_DS_ATT_IS_NOT_ON_OBJ = 8310, ++ MD_ERROR_WIN_DS_ILLEGAL_MOD_OPERATION = 8311, ++ MD_ERROR_WIN_DS_OBJ_TOO_LARGE = 8312, ++ MD_ERROR_WIN_DS_BAD_INSTANCE_TYPE = 8313, ++ MD_ERROR_WIN_DS_MASTERDSA_REQUIRED = 8314, ++ MD_ERROR_WIN_DS_OBJECT_CLASS_REQUIRED = 8315, ++ MD_ERROR_WIN_DS_MISSING_REQUIRED_ATT = 8316, ++ MD_ERROR_WIN_DS_ATT_NOT_DEF_FOR_CLASS = 8317, ++ MD_ERROR_WIN_DS_ATT_ALREADY_EXISTS = 8318, ++ MD_ERROR_WIN_DS_CANT_ADD_ATT_VALUES = 8320, ++ MD_ERROR_WIN_DS_SINGLE_VALUE_CONSTRAINT = 8321, ++ MD_ERROR_WIN_DS_RANGE_CONSTRAINT = 8322, ++ MD_ERROR_WIN_DS_ATT_VAL_ALREADY_EXISTS = 8323, ++ MD_ERROR_WIN_DS_CANT_REM_MISSING_ATT = 8324, ++ MD_ERROR_WIN_DS_CANT_REM_MISSING_ATT_VAL = 8325, ++ MD_ERROR_WIN_DS_ROOT_CANT_BE_SUBREF = 8326, ++ MD_ERROR_WIN_DS_NO_CHAINING = 8327, ++ MD_ERROR_WIN_DS_NO_CHAINED_EVAL = 8328, ++ MD_ERROR_WIN_DS_NO_PARENT_OBJECT = 8329, ++ MD_ERROR_WIN_DS_PARENT_IS_AN_ALIAS = 8330, ++ MD_ERROR_WIN_DS_CANT_MIX_MASTER_AND_REPS = 8331, ++ MD_ERROR_WIN_DS_CHILDREN_EXIST = 8332, ++ MD_ERROR_WIN_DS_OBJ_NOT_FOUND = 8333, ++ MD_ERROR_WIN_DS_ALIASED_OBJ_MISSING = 8334, ++ MD_ERROR_WIN_DS_BAD_NAME_SYNTAX = 8335, ++ MD_ERROR_WIN_DS_ALIAS_POINTS_TO_ALIAS = 8336, ++ MD_ERROR_WIN_DS_CANT_DEREF_ALIAS = 8337, ++ MD_ERROR_WIN_DS_OUT_OF_SCOPE = 8338, ++ MD_ERROR_WIN_DS_OBJECT_BEING_REMOVED = 8339, ++ MD_ERROR_WIN_DS_CANT_DELETE_DSA_OBJ = 8340, ++ MD_ERROR_WIN_DS_GENERIC_ERROR = 8341, ++ MD_ERROR_WIN_DS_DSA_MUST_BE_INT_MASTER = 8342, ++ MD_ERROR_WIN_DS_CLASS_NOT_DSA = 8343, ++ MD_ERROR_WIN_DS_INSUFF_ACCESS_RIGHTS = 8344, ++ MD_ERROR_WIN_DS_ILLEGAL_SUPERIOR = 8345, ++ MD_ERROR_WIN_DS_ATTRIBUTE_OWNED_BY_SAM = 8346, ++ MD_ERROR_WIN_DS_NAME_TOO_MANY_PARTS = 8347, ++ MD_ERROR_WIN_DS_NAME_TOO_LONG = 8348, ++ MD_ERROR_WIN_DS_NAME_VALUE_TOO_LONG = 8349, ++ MD_ERROR_WIN_DS_NAME_UNPARSEABLE = 8350, ++ MD_ERROR_WIN_DS_NAME_TYPE_UNKNOWN = 8351, ++ MD_ERROR_WIN_DS_NOT_AN_OBJECT = 8352, ++ MD_ERROR_WIN_DS_SEC_DESC_TOO_SHORT = 8353, ++ MD_ERROR_WIN_DS_SEC_DESC_INVALID = 8354, ++ MD_ERROR_WIN_DS_NO_DELETED_NAME = 8355, ++ MD_ERROR_WIN_DS_SUBREF_MUST_HAVE_PARENT = 8356, ++ MD_ERROR_WIN_DS_NCNAME_MUST_BE_NC = 8357, ++ MD_ERROR_WIN_DS_CANT_ADD_SYSTEM_ONLY = 8358, ++ MD_ERROR_WIN_DS_CLASS_MUST_BE_CONCRETE = 8359, ++ MD_ERROR_WIN_DS_INVALID_DMD = 8360, ++ MD_ERROR_WIN_DS_OBJ_GUID_EXISTS = 8361, ++ MD_ERROR_WIN_DS_NOT_ON_BACKLINK = 8362, ++ MD_ERROR_WIN_DS_NO_CROSSREF_FOR_NC = 8363, ++ MD_ERROR_WIN_DS_SHUTTING_DOWN = 8364, ++ MD_ERROR_WIN_DS_UNKNOWN_OPERATION = 8365, ++ MD_ERROR_WIN_DS_INVALID_ROLE_OWNER = 8366, ++ MD_ERROR_WIN_DS_COULDNT_CONTACT_FSMO = 8367, ++ MD_ERROR_WIN_DS_CROSS_NC_DN_RENAME = 8368, ++ MD_ERROR_WIN_DS_CANT_MOD_SYSTEM_ONLY = 8369, ++ MD_ERROR_WIN_DS_REPLICATOR_ONLY = 8370, ++ MD_ERROR_WIN_DS_OBJ_CLASS_NOT_DEFINED = 8371, ++ MD_ERROR_WIN_DS_OBJ_CLASS_NOT_SUBCLASS = 8372, ++ MD_ERROR_WIN_DS_NAME_REFERENCE_INVALID = 8373, ++ MD_ERROR_WIN_DS_CROSS_REF_EXISTS = 8374, ++ MD_ERROR_WIN_DS_CANT_DEL_MASTER_CROSSREF = 8375, ++ MD_ERROR_WIN_DS_SUBTREE_NOTIFY_NOT_NC_HEAD = 8376, ++ MD_ERROR_WIN_DS_NOTIFY_FILTER_TOO_COMPLEX = 8377, ++ MD_ERROR_WIN_DS_DUP_RDN = 8378, ++ MD_ERROR_WIN_DS_DUP_OID = 8379, ++ MD_ERROR_WIN_DS_DUP_MAPI_ID = 8380, ++ MD_ERROR_WIN_DS_DUP_SCHEMA_ID_GUID = 8381, ++ MD_ERROR_WIN_DS_DUP_LDAP_DISPLAY_NAME = 8382, ++ MD_ERROR_WIN_DS_SEMANTIC_ATT_TEST = 8383, ++ MD_ERROR_WIN_DS_SYNTAX_MISMATCH = 8384, ++ MD_ERROR_WIN_DS_EXISTS_IN_MUST_HAVE = 8385, ++ MD_ERROR_WIN_DS_EXISTS_IN_MAY_HAVE = 8386, ++ MD_ERROR_WIN_DS_NONEXISTENT_MAY_HAVE = 8387, ++ MD_ERROR_WIN_DS_NONEXISTENT_MUST_HAVE = 8388, ++ MD_ERROR_WIN_DS_AUX_CLS_TEST_FAIL = 8389, ++ MD_ERROR_WIN_DS_NONEXISTENT_POSS_SUP = 8390, ++ MD_ERROR_WIN_DS_SUB_CLS_TEST_FAIL = 8391, ++ MD_ERROR_WIN_DS_BAD_RDN_ATT_ID_SYNTAX = 8392, ++ MD_ERROR_WIN_DS_EXISTS_IN_AUX_CLS = 8393, ++ MD_ERROR_WIN_DS_EXISTS_IN_SUB_CLS = 8394, ++ MD_ERROR_WIN_DS_EXISTS_IN_POSS_SUP = 8395, ++ MD_ERROR_WIN_DS_RECALCSCHEMA_FAILED = 8396, ++ MD_ERROR_WIN_DS_TREE_DELETE_NOT_FINISHED = 8397, ++ MD_ERROR_WIN_DS_CANT_DELETE = 8398, ++ MD_ERROR_WIN_DS_ATT_SCHEMA_REQ_ID = 8399, ++ MD_ERROR_WIN_DS_BAD_ATT_SCHEMA_SYNTAX = 8400, ++ MD_ERROR_WIN_DS_CANT_CACHE_ATT = 8401, ++ MD_ERROR_WIN_DS_CANT_CACHE_CLASS = 8402, ++ MD_ERROR_WIN_DS_CANT_REMOVE_ATT_CACHE = 8403, ++ MD_ERROR_WIN_DS_CANT_REMOVE_CLASS_CACHE = 8404, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_DN = 8405, ++ MD_ERROR_WIN_DS_MISSING_SUPREF = 8406, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_INSTANCE = 8407, ++ MD_ERROR_WIN_DS_CODE_INCONSISTENCY = 8408, ++ MD_ERROR_WIN_DS_DATABASE_ERROR = 8409, ++ MD_ERROR_WIN_DS_GOVERNSID_MISSING = 8410, ++ MD_ERROR_WIN_DS_MISSING_EXPECTED_ATT = 8411, ++ MD_ERROR_WIN_DS_NCNAME_MISSING_CR_REF = 8412, ++ MD_ERROR_WIN_DS_SECURITY_CHECKING_ERROR = 8413, ++ MD_ERROR_WIN_DS_SCHEMA_NOT_LOADED = 8414, ++ MD_ERROR_WIN_DS_SCHEMA_ALLOC_FAILED = 8415, ++ MD_ERROR_WIN_DS_ATT_SCHEMA_REQ_SYNTAX = 8416, ++ MD_ERROR_WIN_DS_GCVERIFY_ERROR = 8417, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_MISMATCH = 8418, ++ MD_ERROR_WIN_DS_CANT_FIND_DSA_OBJ = 8419, ++ MD_ERROR_WIN_DS_CANT_FIND_EXPECTED_NC = 8420, ++ MD_ERROR_WIN_DS_CANT_FIND_NC_IN_CACHE = 8421, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_CHILD = 8422, ++ MD_ERROR_WIN_DS_SECURITY_ILLEGAL_MODIFY = 8423, ++ MD_ERROR_WIN_DS_CANT_REPLACE_HIDDEN_REC = 8424, ++ MD_ERROR_WIN_DS_BAD_HIERARCHY_FILE = 8425, ++ MD_ERROR_WIN_DS_BUILD_HIERARCHY_TABLE_FAILED = 8426, ++ MD_ERROR_WIN_DS_CONFIG_PARAM_MISSING = 8427, ++ MD_ERROR_WIN_DS_COUNTING_AB_INDICES_FAILED = 8428, ++ MD_ERROR_WIN_DS_HIERARCHY_TABLE_MALLOC_FAILED = 8429, ++ MD_ERROR_WIN_DS_INTERNAL_FAILURE = 8430, ++ MD_ERROR_WIN_DS_UNKNOWN_ERROR = 8431, ++ MD_ERROR_WIN_DS_ROOT_REQUIRES_CLASS_TOP = 8432, ++ MD_ERROR_WIN_DS_REFUSING_FSMO_ROLES = 8433, ++ MD_ERROR_WIN_DS_MISSING_FSMO_SETTINGS = 8434, ++ MD_ERROR_WIN_DS_UNABLE_TO_SURRENDER_ROLES = 8435, ++ MD_ERROR_WIN_DS_DRA_GENERIC = 8436, ++ MD_ERROR_WIN_DS_DRA_INVALID_PARAMETER = 8437, ++ MD_ERROR_WIN_DS_DRA_BUSY = 8438, ++ MD_ERROR_WIN_DS_DRA_BAD_DN = 8439, ++ MD_ERROR_WIN_DS_DRA_BAD_NC = 8440, ++ MD_ERROR_WIN_DS_DRA_DN_EXISTS = 8441, ++ MD_ERROR_WIN_DS_DRA_INTERNAL_ERROR = 8442, ++ MD_ERROR_WIN_DS_DRA_INCONSISTENT_DIT = 8443, ++ MD_ERROR_WIN_DS_DRA_CONNECTION_FAILED = 8444, ++ MD_ERROR_WIN_DS_DRA_BAD_INSTANCE_TYPE = 8445, ++ MD_ERROR_WIN_DS_DRA_OUT_OF_MEM = 8446, ++ MD_ERROR_WIN_DS_DRA_MAIL_PROBLEM = 8447, ++ MD_ERROR_WIN_DS_DRA_REF_ALREADY_EXISTS = 8448, ++ MD_ERROR_WIN_DS_DRA_REF_NOT_FOUND = 8449, ++ MD_ERROR_WIN_DS_DRA_OBJ_IS_REP_SOURCE = 8450, ++ MD_ERROR_WIN_DS_DRA_DB_ERROR = 8451, ++ MD_ERROR_WIN_DS_DRA_NO_REPLICA = 8452, ++ MD_ERROR_WIN_DS_DRA_ACCESS_DENIED = 8453, ++ MD_ERROR_WIN_DS_DRA_NOT_SUPPORTED = 8454, ++ MD_ERROR_WIN_DS_DRA_RPC_CANCELLED = 8455, ++ MD_ERROR_WIN_DS_DRA_SOURCE_DISABLED = 8456, ++ MD_ERROR_WIN_DS_DRA_SINK_DISABLED = 8457, ++ MD_ERROR_WIN_DS_DRA_NAME_COLLISION = 8458, ++ MD_ERROR_WIN_DS_DRA_SOURCE_REINSTALLED = 8459, ++ MD_ERROR_WIN_DS_DRA_MISSING_PARENT = 8460, ++ MD_ERROR_WIN_DS_DRA_PREEMPTED = 8461, ++ MD_ERROR_WIN_DS_DRA_ABANDON_SYNC = 8462, ++ MD_ERROR_WIN_DS_DRA_SHUTDOWN = 8463, ++ MD_ERROR_WIN_DS_DRA_INCOMPATIBLE_PARTIAL_SET = 8464, ++ MD_ERROR_WIN_DS_DRA_SOURCE_IS_PARTIAL_REPLICA = 8465, ++ MD_ERROR_WIN_DS_DRA_EXTN_CONNECTION_FAILED = 8466, ++ MD_ERROR_WIN_DS_INSTALL_SCHEMA_MISMATCH = 8467, ++ MD_ERROR_WIN_DS_DUP_LINK_ID = 8468, ++ MD_ERROR_WIN_DS_NAME_ERROR_RESOLVING = 8469, ++ MD_ERROR_WIN_DS_NAME_ERROR_NOT_FOUND = 8470, ++ MD_ERROR_WIN_DS_NAME_ERROR_NOT_UNIQUE = 8471, ++ MD_ERROR_WIN_DS_NAME_ERROR_NO_MAPPING = 8472, ++ MD_ERROR_WIN_DS_NAME_ERROR_DOMAIN_ONLY = 8473, ++ MD_ERROR_WIN_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING = 8474, ++ MD_ERROR_WIN_DS_CONSTRUCTED_ATT_MOD = 8475, ++ MD_ERROR_WIN_DS_WRONG_OM_OBJ_CLASS = 8476, ++ MD_ERROR_WIN_DS_DRA_REPL_PENDING = 8477, ++ MD_ERROR_WIN_DS_DS_REQUIRED = 8478, ++ MD_ERROR_WIN_DS_INVALID_LDAP_DISPLAY_NAME = 8479, ++ MD_ERROR_WIN_DS_NON_BASE_SEARCH = 8480, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_ATTS = 8481, ++ MD_ERROR_WIN_DS_BACKLINK_WITHOUT_LINK = 8482, ++ MD_ERROR_WIN_DS_EPOCH_MISMATCH = 8483, ++ MD_ERROR_WIN_DS_SRC_NAME_MISMATCH = 8484, ++ MD_ERROR_WIN_DS_SRC_AND_DST_NC_IDENTICAL = 8485, ++ MD_ERROR_WIN_DS_DST_NC_MISMATCH = 8486, ++ MD_ERROR_WIN_DS_NOT_AUTHORITIVE_FOR_DST_NC = 8487, ++ MD_ERROR_WIN_DS_SRC_GUID_MISMATCH = 8488, ++ MD_ERROR_WIN_DS_CANT_MOVE_DELETED_OBJECT = 8489, ++ MD_ERROR_WIN_DS_PDC_OPERATION_IN_PROGRESS = 8490, ++ MD_ERROR_WIN_DS_CROSS_DOMAIN_CLEANUP_REQD = 8491, ++ MD_ERROR_WIN_DS_ILLEGAL_XDOM_MOVE_OPERATION = 8492, ++ MD_ERROR_WIN_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS = 8493, ++ MD_ERROR_WIN_DS_NC_MUST_HAVE_NC_PARENT = 8494, ++ MD_ERROR_WIN_DS_CR_IMPOSSIBLE_TO_VALIDATE = 8495, ++ MD_ERROR_WIN_DS_DST_DOMAIN_NOT_NATIVE = 8496, ++ MD_ERROR_WIN_DS_MISSING_INFRASTRUCTURE_CONTAINER = 8497, ++ MD_ERROR_WIN_DS_CANT_MOVE_ACCOUNT_GROUP = 8498, ++ MD_ERROR_WIN_DS_CANT_MOVE_RESOURCE_GROUP = 8499, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG = 8500, ++ MD_ERROR_WIN_DS_NO_TREE_DELETE_ABOVE_NC = 8501, ++ MD_ERROR_WIN_DS_COULDNT_LOCK_TREE_FOR_DELETE = 8502, ++ MD_ERROR_WIN_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE = 8503, ++ MD_ERROR_WIN_DS_SAM_INIT_FAILURE = 8504, ++ MD_ERROR_WIN_DS_SENSITIVE_GROUP_VIOLATION = 8505, ++ MD_ERROR_WIN_DS_CANT_MOD_PRIMARYGROUPID = 8506, ++ MD_ERROR_WIN_DS_ILLEGAL_BASE_SCHEMA_MOD = 8507, ++ MD_ERROR_WIN_DS_NONSAFE_SCHEMA_CHANGE = 8508, ++ MD_ERROR_WIN_DS_SCHEMA_UPDATE_DISALLOWED = 8509, ++ MD_ERROR_WIN_DS_CANT_CREATE_UNDER_SCHEMA = 8510, ++ MD_ERROR_WIN_DS_INSTALL_NO_SRC_SCH_VERSION = 8511, ++ MD_ERROR_WIN_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE = 8512, ++ MD_ERROR_WIN_DS_INVALID_GROUP_TYPE = 8513, ++ MD_ERROR_WIN_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN = 8514, ++ MD_ERROR_WIN_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN = 8515, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER = 8516, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER = 8517, ++ MD_ERROR_WIN_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER = 8518, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER = 8519, ++ MD_ERROR_WIN_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER = 8520, ++ MD_ERROR_WIN_DS_HAVE_PRIMARY_MEMBERS = 8521, ++ MD_ERROR_WIN_DS_STRING_SD_CONVERSION_FAILED = 8522, ++ MD_ERROR_WIN_DS_NAMING_MASTER_GC = 8523, ++ MD_ERROR_WIN_DS_DNS_LOOKUP_FAILURE = 8524, ++ MD_ERROR_WIN_DS_COULDNT_UPDATE_SPNS = 8525, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_SD = 8526, ++ MD_ERROR_WIN_DS_KEY_NOT_UNIQUE = 8527, ++ MD_ERROR_WIN_DS_WRONG_LINKED_ATT_SYNTAX = 8528, ++ MD_ERROR_WIN_DS_SAM_NEED_BOOTKEY_PASSWORD = 8529, ++ MD_ERROR_WIN_DS_SAM_NEED_BOOTKEY_FLOPPY = 8530, ++ MD_ERROR_WIN_DS_CANT_START = 8531, ++ MD_ERROR_WIN_DS_INIT_FAILURE = 8532, ++ MD_ERROR_WIN_DS_NO_PKT_PRIVACY_ON_CONNECTION = 8533, ++ MD_ERROR_WIN_DS_SOURCE_DOMAIN_IN_FOREST = 8534, ++ MD_ERROR_WIN_DS_DESTINATION_DOMAIN_NOT_IN_FOREST = 8535, ++ MD_ERROR_WIN_DS_DESTINATION_AUDITING_NOT_ENABLED = 8536, ++ MD_ERROR_WIN_DS_CANT_FIND_DC_FOR_SRC_DOMAIN = 8537, ++ MD_ERROR_WIN_DS_SRC_OBJ_NOT_GROUP_OR_USER = 8538, ++ MD_ERROR_WIN_DS_SRC_SID_EXISTS_IN_FOREST = 8539, ++ MD_ERROR_WIN_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH = 8540, ++ MD_ERROR_WIN_SAM_INIT_FAILURE = 8541, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_INFO_SHIP = 8542, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_CONFLICT = 8543, ++ MD_ERROR_WIN_DS_DRA_EARLIER_SCHEMA_CONFLICT = 8544, ++ MD_ERROR_WIN_DS_DRA_OBJ_NC_MISMATCH = 8545, ++ MD_ERROR_WIN_DS_NC_STILL_HAS_DSAS = 8546, ++ MD_ERROR_WIN_DS_GC_REQUIRED = 8547, ++ MD_ERROR_WIN_DS_LOCAL_MEMBER_OF_LOCAL_ONLY = 8548, ++ MD_ERROR_WIN_DS_NO_FPO_IN_UNIVERSAL_GROUPS = 8549, ++ MD_ERROR_WIN_DS_CANT_ADD_TO_GC = 8550, ++ MD_ERROR_WIN_DS_NO_CHECKPOINT_WITH_PDC = 8551, ++ MD_ERROR_WIN_DS_SOURCE_AUDITING_NOT_ENABLED = 8552, ++ MD_ERROR_WIN_DS_CANT_CREATE_IN_NONDOMAIN_NC = 8553, ++ MD_ERROR_WIN_DS_INVALID_NAME_FOR_SPN = 8554, ++ MD_ERROR_WIN_DS_FILTER_USES_CONTRUCTED_ATTRS = 8555, ++ MD_ERROR_WIN_DS_UNICODEPWD_NOT_IN_QUOTES = 8556, ++ MD_ERROR_WIN_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED = 8557, ++ MD_ERROR_WIN_DS_MUST_BE_RUN_ON_DST_DC = 8558, ++ MD_ERROR_WIN_DS_SRC_DC_MUST_BE_SP4_OR_GREATER = 8559, ++ MD_ERROR_WIN_DS_CANT_TREE_DELETE_CRITICAL_OBJ = 8560, ++ MD_ERROR_WIN_DS_INIT_FAILURE_CONSOLE = 8561, ++ MD_ERROR_WIN_DS_SAM_INIT_FAILURE_CONSOLE = 8562, ++ MD_ERROR_WIN_DS_FOREST_VERSION_TOO_HIGH = 8563, ++ MD_ERROR_WIN_DS_DOMAIN_VERSION_TOO_HIGH = 8564, ++ MD_ERROR_WIN_DS_FOREST_VERSION_TOO_LOW = 8565, ++ MD_ERROR_WIN_DS_DOMAIN_VERSION_TOO_LOW = 8566, ++ MD_ERROR_WIN_DS_INCOMPATIBLE_VERSION = 8567, ++ MD_ERROR_WIN_DS_LOW_DSA_VERSION = 8568, ++ MD_ERROR_WIN_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN = 8569, ++ MD_ERROR_WIN_DS_NOT_SUPPORTED_SORT_ORDER = 8570, ++ MD_ERROR_WIN_DS_NAME_NOT_UNIQUE = 8571, ++ MD_ERROR_WIN_DS_MACHINE_ACCOUNT_CREATED_PRENT4 = 8572, ++ MD_ERROR_WIN_DS_OUT_OF_VERSION_STORE = 8573, ++ MD_ERROR_WIN_DS_INCOMPATIBLE_CONTROLS_USED = 8574, ++ MD_ERROR_WIN_DS_NO_REF_DOMAIN = 8575, ++ MD_ERROR_WIN_DS_RESERVED_LINK_ID = 8576, ++ MD_ERROR_WIN_DS_LINK_ID_NOT_AVAILABLE = 8577, ++ MD_ERROR_WIN_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER = 8578, ++ MD_ERROR_WIN_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE = 8579, ++ MD_ERROR_WIN_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC = 8580, ++ MD_ERROR_WIN_DS_MODIFYDN_DISALLOWED_BY_FLAG = 8581, ++ MD_ERROR_WIN_DS_MODIFYDN_WRONG_GRANDPARENT = 8582, ++ MD_ERROR_WIN_DS_NAME_ERROR_TRUST_REFERRAL = 8583, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_STANDARD_SERVER = 8584, ++ MD_ERROR_WIN_DS_CANT_ACCESS_REMOTE_PART_OF_AD = 8585, ++ MD_ERROR_WIN_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2 = 8586, ++ MD_ERROR_WIN_DS_THREAD_LIMIT_EXCEEDED = 8587, ++ MD_ERROR_WIN_DS_NOT_CLOSEST = 8588, ++ MD_ERROR_WIN_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF = 8589, ++ MD_ERROR_WIN_DS_SINGLE_USER_MODE_FAILED = 8590, ++ MD_ERROR_WIN_DS_NTDSCRIPT_SYNTAX_ERROR = 8591, ++ MD_ERROR_WIN_DS_NTDSCRIPT_PROCESS_ERROR = 8592, ++ MD_ERROR_WIN_DS_DIFFERENT_REPL_EPOCHS = 8593, ++ MD_ERROR_WIN_DS_DRS_EXTENSIONS_CHANGED = 8594, ++ MD_ERROR_WIN_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR = 8595, ++ MD_ERROR_WIN_DS_NO_MSDS_INTID = 8596, ++ MD_ERROR_WIN_DS_DUP_MSDS_INTID = 8597, ++ MD_ERROR_WIN_DS_EXISTS_IN_RDNATTID = 8598, ++ MD_ERROR_WIN_DS_AUTHORIZATION_FAILED = 8599, ++ MD_ERROR_WIN_DS_INVALID_SCRIPT = 8600, ++ MD_ERROR_WIN_DS_REMOTE_CROSSREF_OP_FAILED = 8601, ++ MD_ERROR_WIN_DS_CROSS_REF_BUSY = 8602, ++ MD_ERROR_WIN_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN = 8603, ++ MD_ERROR_WIN_DS_CANT_DEMOTE_WITH_WRITEABLE_NC = 8604, ++ MD_ERROR_WIN_DS_DUPLICATE_ID_FOUND = 8605, ++ MD_ERROR_WIN_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT = 8606, ++ MD_ERROR_WIN_DS_GROUP_CONVERSION_ERROR = 8607, ++ MD_ERROR_WIN_DS_CANT_MOVE_APP_BASIC_GROUP = 8608, ++ MD_ERROR_WIN_DS_CANT_MOVE_APP_QUERY_GROUP = 8609, ++ MD_ERROR_WIN_DS_ROLE_NOT_VERIFIED = 8610, ++ MD_ERROR_WIN_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL = 8611, ++ MD_ERROR_WIN_DS_DOMAIN_RENAME_IN_PROGRESS = 8612, ++ MD_ERROR_WIN_DS_EXISTING_AD_CHILD_NC = 8613, ++ MD_ERROR_WIN_DS_REPL_LIFETIME_EXCEEDED = 8614, ++ MD_ERROR_WIN_DS_DISALLOWED_IN_SYSTEM_CONTAINER = 8615, ++ MD_ERROR_WIN_DS_LDAP_SEND_QUEUE_FULL = 8616, ++ MD_ERROR_WIN_DS_DRA_OUT_SCHEDULE_WINDOW = 8617, ++ MD_ERROR_WIN_DS_POLICY_NOT_KNOWN = 8618, ++ MD_ERROR_WIN_NO_SITE_SETTINGS_OBJECT = 8619, ++ MD_ERROR_WIN_NO_SECRETS = 8620, ++ MD_ERROR_WIN_NO_WRITABLE_DC_FOUND = 8621, ++ MD_ERROR_WIN_DS_NO_SERVER_OBJECT = 8622, ++ MD_ERROR_WIN_DS_NO_NTDSA_OBJECT = 8623, ++ MD_ERROR_WIN_DS_NON_ASQ_SEARCH = 8624, ++ MD_ERROR_WIN_DS_AUDIT_FAILURE = 8625, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG_SUBTREE = 8626, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG_TUPLE = 8627, ++ MD_ERROR_WIN_DS_HIERARCHY_TABLE_TOO_DEEP = 8628, ++ MD_ERROR_WIN_DS_DRA_CORRUPT_UTD_VECTOR = 8629, ++ MD_ERROR_WIN_DS_DRA_SECRETS_DENIED = 8630, ++ MD_ERROR_WIN_DS_RESERVED_MAPI_ID = 8631, ++ MD_ERROR_WIN_DS_MAPI_ID_NOT_AVAILABLE = 8632, ++ MD_ERROR_WIN_DS_DRA_MISSING_KRBTGT_SECRET = 8633, ++ MD_ERROR_WIN_DS_DOMAIN_NAME_EXISTS_IN_FOREST = 8634, ++ MD_ERROR_WIN_DS_FLAT_NAME_EXISTS_IN_FOREST = 8635, ++ MD_ERROR_WIN_INVALID_USER_PRINCIPAL_NAME = 8636, ++ MD_ERROR_WIN_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS = 8637, ++ MD_ERROR_WIN_DS_OID_NOT_FOUND = 8638, ++ MD_ERROR_WIN_DS_DRA_RECYCLED_TARGET = 8639, ++ MD_ERROR_WIN_DS_DISALLOWED_NC_REDIRECT = 8640, ++ MD_ERROR_WIN_DS_HIGH_ADLDS_FFL = 8641, ++ MD_ERROR_WIN_DS_HIGH_DSA_VERSION = 8642, ++ MD_ERROR_WIN_DS_LOW_ADLDS_FFL = 8643, ++ MD_ERROR_WIN_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATION = 8644, ++ MD_ERROR_WIN_DS_UNDELETE_SAM_VALIDATION_FAILED = 8645, ++ MD_ERROR_WIN_INCORRECT_ACCOUNT_TYPE = 8646, ++ MD_ERROR_WIN_DS_SPN_VALUE_NOT_UNIQUE_IN_FOREST = 8647, ++ MD_ERROR_WIN_DS_UPN_VALUE_NOT_UNIQUE_IN_FOREST = 8648, ++ MD_ERROR_WIN_DS_MISSING_FOREST_TRUST = 8649, ++ MD_ERROR_WIN_DS_VALUE_KEY_NOT_UNIQUE = 8650, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_EXISTS = 13000, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_NOT_FOUND = 13001, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_IN_USE = 13002, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_EXISTS = 13003, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_NOT_FOUND = 13004, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_IN_USE = 13005, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_EXISTS = 13006, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_NOT_FOUND = 13007, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_EXISTS = 13008, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_NOT_FOUND = 13009, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_EXISTS = 13010, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_NOT_FOUND = 13011, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_IN_USE = 13012, ++ MD_ERROR_WIN_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND = 13013, ++ MD_ERROR_WIN_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND = 13014, ++ MD_ERROR_WIN_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND = 13015, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_EXISTS = 13016, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_NOT_FOUND = 13017, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_PENDING_DELETION = 13018, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_PENDING_DELETION = 13019, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_PENDING_DELETION = 13020, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_PENDING_DELETION = 13021, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_PENDING_DELETION = 13022, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_PENDING_DELETION = 13023, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_BEGIN = 13800, ++ MD_ERROR_WIN_IPSEC_IKE_AUTH_FAIL = 13801, ++ MD_ERROR_WIN_IPSEC_IKE_ATTRIB_FAIL = 13802, ++ MD_ERROR_WIN_IPSEC_IKE_NEGOTIATION_PENDING = 13803, ++ MD_ERROR_WIN_IPSEC_IKE_GENERAL_PROCESSING_ERROR = 13804, ++ MD_ERROR_WIN_IPSEC_IKE_TIMED_OUT = 13805, ++ MD_ERROR_WIN_IPSEC_IKE_NO_CERT = 13806, ++ MD_ERROR_WIN_IPSEC_IKE_SA_DELETED = 13807, ++ MD_ERROR_WIN_IPSEC_IKE_SA_REAPED = 13808, ++ MD_ERROR_WIN_IPSEC_IKE_MM_ACQUIRE_DROP = 13809, ++ MD_ERROR_WIN_IPSEC_IKE_QM_ACQUIRE_DROP = 13810, ++ MD_ERROR_WIN_IPSEC_IKE_QUEUE_DROP_MM = 13811, ++ MD_ERROR_WIN_IPSEC_IKE_QUEUE_DROP_NO_MM = 13812, ++ MD_ERROR_WIN_IPSEC_IKE_DROP_NO_RESPONSE = 13813, ++ MD_ERROR_WIN_IPSEC_IKE_MM_DELAY_DROP = 13814, ++ MD_ERROR_WIN_IPSEC_IKE_QM_DELAY_DROP = 13815, ++ MD_ERROR_WIN_IPSEC_IKE_ERROR = 13816, ++ MD_ERROR_WIN_IPSEC_IKE_CRL_FAILED = 13817, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_KEY_USAGE = 13818, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_CERT_TYPE = 13819, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PRIVATE_KEY = 13820, ++ MD_ERROR_WIN_IPSEC_IKE_SIMULTANEOUS_REKEY = 13821, ++ MD_ERROR_WIN_IPSEC_IKE_DH_FAIL = 13822, ++ MD_ERROR_WIN_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZED = 13823, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HEADER = 13824, ++ MD_ERROR_WIN_IPSEC_IKE_NO_POLICY = 13825, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SIGNATURE = 13826, ++ MD_ERROR_WIN_IPSEC_IKE_KERBEROS_ERROR = 13827, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PUBLIC_KEY = 13828, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR = 13829, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_SA = 13830, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_PROP = 13831, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_TRANS = 13832, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_KE = 13833, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_ID = 13834, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_CERT = 13835, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_CERT_REQ = 13836, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_HASH = 13837, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_SIG = 13838, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NONCE = 13839, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NOTIFY = 13840, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_DELETE = 13841, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_VENDOR = 13842, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_PAYLOAD = 13843, ++ MD_ERROR_WIN_IPSEC_IKE_LOAD_SOFT_SA = 13844, ++ MD_ERROR_WIN_IPSEC_IKE_SOFT_SA_TORN_DOWN = 13845, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_COOKIE = 13846, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PEER_CERT = 13847, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_CRL_FAILED = 13848, ++ MD_ERROR_WIN_IPSEC_IKE_POLICY_CHANGE = 13849, ++ MD_ERROR_WIN_IPSEC_IKE_NO_MM_POLICY = 13850, ++ MD_ERROR_WIN_IPSEC_IKE_NOTCBPRIV = 13851, ++ MD_ERROR_WIN_IPSEC_IKE_SECLOADFAIL = 13852, ++ MD_ERROR_WIN_IPSEC_IKE_FAILSSPINIT = 13853, ++ MD_ERROR_WIN_IPSEC_IKE_FAILQUERYSSP = 13854, ++ MD_ERROR_WIN_IPSEC_IKE_SRVACQFAIL = 13855, ++ MD_ERROR_WIN_IPSEC_IKE_SRVQUERYCRED = 13856, ++ MD_ERROR_WIN_IPSEC_IKE_GETSPIFAIL = 13857, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_FILTER = 13858, ++ MD_ERROR_WIN_IPSEC_IKE_OUT_OF_MEMORY = 13859, ++ MD_ERROR_WIN_IPSEC_IKE_ADD_UPDATE_KEY_FAILED = 13860, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_POLICY = 13861, ++ MD_ERROR_WIN_IPSEC_IKE_UNKNOWN_DOI = 13862, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SITUATION = 13863, ++ MD_ERROR_WIN_IPSEC_IKE_DH_FAILURE = 13864, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_GROUP = 13865, ++ MD_ERROR_WIN_IPSEC_IKE_ENCRYPT = 13866, ++ MD_ERROR_WIN_IPSEC_IKE_DECRYPT = 13867, ++ MD_ERROR_WIN_IPSEC_IKE_POLICY_MATCH = 13868, ++ MD_ERROR_WIN_IPSEC_IKE_UNSUPPORTED_ID = 13869, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH = 13870, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH_ALG = 13871, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH_SIZE = 13872, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_ENCRYPT_ALG = 13873, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_AUTH_ALG = 13874, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SIG = 13875, ++ MD_ERROR_WIN_IPSEC_IKE_LOAD_FAILED = 13876, ++ MD_ERROR_WIN_IPSEC_IKE_RPC_DELETE = 13877, ++ MD_ERROR_WIN_IPSEC_IKE_BENIGN_REINIT = 13878, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY = 13879, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_MAJOR_VERSION = 13880, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_CERT_KEYLEN = 13881, ++ MD_ERROR_WIN_IPSEC_IKE_MM_LIMIT = 13882, ++ MD_ERROR_WIN_IPSEC_IKE_NEGOTIATION_DISABLED = 13883, ++ MD_ERROR_WIN_IPSEC_IKE_QM_LIMIT = 13884, ++ MD_ERROR_WIN_IPSEC_IKE_MM_EXPIRED = 13885, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_MM_ASSUMED_INVALID = 13886, ++ MD_ERROR_WIN_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH = 13887, ++ MD_ERROR_WIN_IPSEC_IKE_UNEXPECTED_MESSAGE_ID = 13888, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_AUTH_PAYLOAD = 13889, ++ MD_ERROR_WIN_IPSEC_IKE_DOS_COOKIE_SENT = 13890, ++ MD_ERROR_WIN_IPSEC_IKE_SHUTTING_DOWN = 13891, ++ MD_ERROR_WIN_IPSEC_IKE_CGA_AUTH_FAILED = 13892, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NATOA = 13893, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_MM_FOR_QM = 13894, ++ MD_ERROR_WIN_IPSEC_IKE_QM_EXPIRED = 13895, ++ MD_ERROR_WIN_IPSEC_IKE_TOO_MANY_FILTERS = 13896, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_END = 13897, ++ MD_ERROR_WIN_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL = 13898, ++ MD_ERROR_WIN_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE = 13899, ++ MD_ERROR_WIN_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING = 13900, ++ MD_ERROR_WIN_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING = 13901, ++ MD_ERROR_WIN_IPSEC_IKE_COEXISTENCE_SUPPRESS = 13902, ++ MD_ERROR_WIN_IPSEC_IKE_RATELIMIT_DROP = 13903, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE = 13904, ++ MD_ERROR_WIN_IPSEC_IKE_AUTHORIZATION_FAILURE = 13905, ++ MD_ERROR_WIN_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE = 13906, ++ MD_ERROR_WIN_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY = 13907, ++ MD_ERROR_WIN_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE = 13908, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_EXTENDED_END = 13909, ++ MD_ERROR_WIN_IPSEC_BAD_SPI = 13910, ++ MD_ERROR_WIN_IPSEC_SA_LIFETIME_EXPIRED = 13911, ++ MD_ERROR_WIN_IPSEC_WRONG_SA = 13912, ++ MD_ERROR_WIN_IPSEC_REPLAY_CHECK_FAILED = 13913, ++ MD_ERROR_WIN_IPSEC_INVALID_PACKET = 13914, ++ MD_ERROR_WIN_IPSEC_INTEGRITY_CHECK_FAILED = 13915, ++ MD_ERROR_WIN_IPSEC_CLEAR_TEXT_DROP = 13916, ++ MD_ERROR_WIN_IPSEC_AUTH_FIREWALL_DROP = 13917, ++ MD_ERROR_WIN_IPSEC_THROTTLE_DROP = 13918, ++ MD_ERROR_WIN_IPSEC_DOSP_BLOCK = 13925, ++ MD_ERROR_WIN_IPSEC_DOSP_RECEIVED_MULTICAST = 13926, ++ MD_ERROR_WIN_IPSEC_DOSP_INVALID_PACKET = 13927, ++ MD_ERROR_WIN_IPSEC_DOSP_STATE_LOOKUP_FAILED = 13928, ++ MD_ERROR_WIN_IPSEC_DOSP_MAX_ENTRIES = 13929, ++ MD_ERROR_WIN_IPSEC_DOSP_KEYMOD_NOT_ALLOWED = 13930, ++ MD_ERROR_WIN_IPSEC_DOSP_NOT_INSTALLED = 13931, ++ MD_ERROR_WIN_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES = 13932, ++ MD_ERROR_WIN_SXS_SECTION_NOT_FOUND = 14000, ++ MD_ERROR_WIN_SXS_CANT_GEN_ACTCTX = 14001, ++ MD_ERROR_WIN_SXS_INVALID_ACTCTXDATA_FORMAT = 14002, ++ MD_ERROR_WIN_SXS_ASSEMBLY_NOT_FOUND = 14003, ++ MD_ERROR_WIN_SXS_MANIFEST_FORMAT_ERROR = 14004, ++ MD_ERROR_WIN_SXS_MANIFEST_PARSE_ERROR = 14005, ++ MD_ERROR_WIN_SXS_ACTIVATION_CONTEXT_DISABLED = 14006, ++ MD_ERROR_WIN_SXS_KEY_NOT_FOUND = 14007, ++ MD_ERROR_WIN_SXS_VERSION_CONFLICT = 14008, ++ MD_ERROR_WIN_SXS_WRONG_SECTION_TYPE = 14009, ++ MD_ERROR_WIN_SXS_THREAD_QUERIES_DISABLED = 14010, ++ MD_ERROR_WIN_SXS_PROCESS_DEFAULT_ALREADY_SET = 14011, ++ MD_ERROR_WIN_SXS_UNKNOWN_ENCODING_GROUP = 14012, ++ MD_ERROR_WIN_SXS_UNKNOWN_ENCODING = 14013, ++ MD_ERROR_WIN_SXS_INVALID_XML_NAMESPACE_URI = 14014, ++ MD_ERROR_WIN_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED = 14015, ++ MD_ERROR_WIN_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED = 14016, ++ MD_ERROR_WIN_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE = 14017, ++ MD_ERROR_WIN_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE = 14018, ++ MD_ERROR_WIN_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE = 14019, ++ MD_ERROR_WIN_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT = 14020, ++ MD_ERROR_WIN_SXS_DUPLICATE_DLL_NAME = 14021, ++ MD_ERROR_WIN_SXS_DUPLICATE_WINDOWCLASS_NAME = 14022, ++ MD_ERROR_WIN_SXS_DUPLICATE_CLSID = 14023, ++ MD_ERROR_WIN_SXS_DUPLICATE_IID = 14024, ++ MD_ERROR_WIN_SXS_DUPLICATE_TLBID = 14025, ++ MD_ERROR_WIN_SXS_DUPLICATE_PROGID = 14026, ++ MD_ERROR_WIN_SXS_DUPLICATE_ASSEMBLY_NAME = 14027, ++ MD_ERROR_WIN_SXS_FILE_HASH_MISMATCH = 14028, ++ MD_ERROR_WIN_SXS_POLICY_PARSE_ERROR = 14029, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGQUOTE = 14030, ++ MD_ERROR_WIN_SXS_XML_E_COMMENTSYNTAX = 14031, ++ MD_ERROR_WIN_SXS_XML_E_BADSTARTNAMECHAR = 14032, ++ MD_ERROR_WIN_SXS_XML_E_BADNAMECHAR = 14033, ++ MD_ERROR_WIN_SXS_XML_E_BADCHARINSTRING = 14034, ++ MD_ERROR_WIN_SXS_XML_E_XMLDECLSYNTAX = 14035, ++ MD_ERROR_WIN_SXS_XML_E_BADCHARDATA = 14036, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGWHITESPACE = 14037, ++ MD_ERROR_WIN_SXS_XML_E_EXPECTINGTAGEND = 14038, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGSEMICOLON = 14039, ++ MD_ERROR_WIN_SXS_XML_E_UNBALANCEDPAREN = 14040, ++ MD_ERROR_WIN_SXS_XML_E_INTERNALERROR = 14041, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTED_WHITESPACE = 14042, ++ MD_ERROR_WIN_SXS_XML_E_INCOMPLETE_ENCODING = 14043, ++ MD_ERROR_WIN_SXS_XML_E_MISSING_PAREN = 14044, ++ MD_ERROR_WIN_SXS_XML_E_EXPECTINGCLOSEQUOTE = 14045, ++ MD_ERROR_WIN_SXS_XML_E_MULTIPLE_COLONS = 14046, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_DECIMAL = 14047, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_HEXIDECIMAL = 14048, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_UNICODE = 14049, ++ MD_ERROR_WIN_SXS_XML_E_WHITESPACEORQUESTIONMARK = 14050, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTEDENDTAG = 14051, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDTAG = 14052, ++ MD_ERROR_WIN_SXS_XML_E_DUPLICATEATTRIBUTE = 14053, ++ MD_ERROR_WIN_SXS_XML_E_MULTIPLEROOTS = 14054, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDATROOTLEVEL = 14055, ++ MD_ERROR_WIN_SXS_XML_E_BADXMLDECL = 14056, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGROOT = 14057, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTEDEOF = 14058, ++ MD_ERROR_WIN_SXS_XML_E_BADPEREFINSUBSET = 14059, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDSTARTTAG = 14060, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDENDTAG = 14061, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDSTRING = 14062, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDCOMMENT = 14063, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDDECL = 14064, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDCDATA = 14065, ++ MD_ERROR_WIN_SXS_XML_E_RESERVEDNAMESPACE = 14066, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDENCODING = 14067, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDSWITCH = 14068, ++ MD_ERROR_WIN_SXS_XML_E_BADXMLCASE = 14069, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_STANDALONE = 14070, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTED_STANDALONE = 14071, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_VERSION = 14072, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGEQUALS = 14073, ++ MD_ERROR_WIN_SXS_PROTECTION_RECOVERY_FAILED = 14074, ++ MD_ERROR_WIN_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT = 14075, ++ MD_ERROR_WIN_SXS_PROTECTION_CATALOG_NOT_VALID = 14076, ++ MD_ERROR_WIN_SXS_UNTRANSLATABLE_HRESULT = 14077, ++ MD_ERROR_WIN_SXS_PROTECTION_CATALOG_FILE_MISSING = 14078, ++ MD_ERROR_WIN_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE = 14079, ++ MD_ERROR_WIN_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME = 14080, ++ MD_ERROR_WIN_SXS_ASSEMBLY_MISSING = 14081, ++ MD_ERROR_WIN_SXS_CORRUPT_ACTIVATION_STACK = 14082, ++ MD_ERROR_WIN_SXS_CORRUPTION = 14083, ++ MD_ERROR_WIN_SXS_EARLY_DEACTIVATION = 14084, ++ MD_ERROR_WIN_SXS_INVALID_DEACTIVATION = 14085, ++ MD_ERROR_WIN_SXS_MULTIPLE_DEACTIVATION = 14086, ++ MD_ERROR_WIN_SXS_PROCESS_TERMINATION_REQUESTED = 14087, ++ MD_ERROR_WIN_SXS_RELEASE_ACTIVATION_CONTEXT = 14088, ++ MD_ERROR_WIN_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY = 14089, ++ MD_ERROR_WIN_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE = 14090, ++ MD_ERROR_WIN_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME = 14091, ++ MD_ERROR_WIN_SXS_IDENTITY_DUPLICATE_ATTRIBUTE = 14092, ++ MD_ERROR_WIN_SXS_IDENTITY_PARSE_ERROR = 14093, ++ MD_ERROR_WIN_MALFORMED_SUBSTITUTION_STRING = 14094, ++ MD_ERROR_WIN_SXS_INCORRECT_PUBLIC_KEY_TOKEN = 14095, ++ MD_ERROR_WIN_UNMAPPED_SUBSTITUTION_STRING = 14096, ++ MD_ERROR_WIN_SXS_ASSEMBLY_NOT_LOCKED = 14097, ++ MD_ERROR_WIN_SXS_COMPONENT_STORE_CORRUPT = 14098, ++ MD_ERROR_WIN_ADVANCED_INSTALLER_FAILED = 14099, ++ MD_ERROR_WIN_XML_ENCODING_MISMATCH = 14100, ++ MD_ERROR_WIN_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT = 14101, ++ MD_ERROR_WIN_SXS_IDENTITIES_DIFFERENT = 14102, ++ MD_ERROR_WIN_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT = 14103, ++ MD_ERROR_WIN_SXS_FILE_NOT_PART_OF_ASSEMBLY = 14104, ++ MD_ERROR_WIN_SXS_MANIFEST_TOO_BIG = 14105, ++ MD_ERROR_WIN_SXS_SETTING_NOT_REGISTERED = 14106, ++ MD_ERROR_WIN_SXS_TRANSACTION_CLOSURE_INCOMPLETE = 14107, ++ MD_ERROR_WIN_SMI_PRIMITIVE_INSTALLER_FAILED = 14108, ++ MD_ERROR_WIN_GENERIC_COMMAND_FAILED = 14109, ++ MD_ERROR_WIN_SXS_FILE_HASH_MISSING = 14110, ++ MD_ERROR_WIN_SXS_DUPLICATE_ACTIVATABLE_CLASS = 14111, ++ MD_ERROR_WIN_EVT_INVALID_CHANNEL_PATH = 15000, ++ MD_ERROR_WIN_EVT_INVALID_QUERY = 15001, ++ MD_ERROR_WIN_EVT_PUBLISHER_METADATA_NOT_FOUND = 15002, ++ MD_ERROR_WIN_EVT_EVENT_TEMPLATE_NOT_FOUND = 15003, ++ MD_ERROR_WIN_EVT_INVALID_PUBLISHER_NAME = 15004, ++ MD_ERROR_WIN_EVT_INVALID_EVENT_DATA = 15005, ++ MD_ERROR_WIN_EVT_CHANNEL_NOT_FOUND = 15007, ++ MD_ERROR_WIN_EVT_MALFORMED_XML_TEXT = 15008, ++ MD_ERROR_WIN_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL = 15009, ++ MD_ERROR_WIN_EVT_CONFIGURATION_ERROR = 15010, ++ MD_ERROR_WIN_EVT_QUERY_RESULT_STALE = 15011, ++ MD_ERROR_WIN_EVT_QUERY_RESULT_INVALID_POSITION = 15012, ++ MD_ERROR_WIN_EVT_NON_VALIDATING_MSXML = 15013, ++ MD_ERROR_WIN_EVT_FILTER_ALREADYSCOPED = 15014, ++ MD_ERROR_WIN_EVT_FILTER_NOTELTSET = 15015, ++ MD_ERROR_WIN_EVT_FILTER_INVARG = 15016, ++ MD_ERROR_WIN_EVT_FILTER_INVTEST = 15017, ++ MD_ERROR_WIN_EVT_FILTER_INVTYPE = 15018, ++ MD_ERROR_WIN_EVT_FILTER_PARSEERR = 15019, ++ MD_ERROR_WIN_EVT_FILTER_UNSUPPORTEDOP = 15020, ++ MD_ERROR_WIN_EVT_FILTER_UNEXPECTEDTOKEN = 15021, ++ MD_ERROR_WIN_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL = 15022, ++ MD_ERROR_WIN_EVT_INVALID_CHANNEL_PROPERTY_VALUE = 15023, ++ MD_ERROR_WIN_EVT_INVALID_PUBLISHER_PROPERTY_VALUE = 15024, ++ MD_ERROR_WIN_EVT_CHANNEL_CANNOT_ACTIVATE = 15025, ++ MD_ERROR_WIN_EVT_FILTER_TOO_COMPLEX = 15026, ++ MD_ERROR_WIN_EVT_MESSAGE_NOT_FOUND = 15027, ++ MD_ERROR_WIN_EVT_MESSAGE_ID_NOT_FOUND = 15028, ++ MD_ERROR_WIN_EVT_UNRESOLVED_VALUE_INSERT = 15029, ++ MD_ERROR_WIN_EVT_UNRESOLVED_PARAMETER_INSERT = 15030, ++ MD_ERROR_WIN_EVT_MAX_INSERTS_REACHED = 15031, ++ MD_ERROR_WIN_EVT_EVENT_DEFINITION_NOT_FOUND = 15032, ++ MD_ERROR_WIN_EVT_MESSAGE_LOCALE_NOT_FOUND = 15033, ++ MD_ERROR_WIN_EVT_VERSION_TOO_OLD = 15034, ++ MD_ERROR_WIN_EVT_VERSION_TOO_NEW = 15035, ++ MD_ERROR_WIN_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY = 15036, ++ MD_ERROR_WIN_EVT_PUBLISHER_DISABLED = 15037, ++ MD_ERROR_WIN_EVT_FILTER_OUT_OF_RANGE = 15038, ++ MD_ERROR_WIN_EC_SUBSCRIPTION_CANNOT_ACTIVATE = 15080, ++ MD_ERROR_WIN_EC_LOG_DISABLED = 15081, ++ MD_ERROR_WIN_EC_CIRCULAR_FORWARDING = 15082, ++ MD_ERROR_WIN_EC_CREDSTORE_FULL = 15083, ++ MD_ERROR_WIN_EC_CRED_NOT_FOUND = 15084, ++ MD_ERROR_WIN_EC_NO_ACTIVE_CHANNEL = 15085, ++ MD_ERROR_WIN_MUI_FILE_NOT_FOUND = 15100, ++ MD_ERROR_WIN_MUI_INVALID_FILE = 15101, ++ MD_ERROR_WIN_MUI_INVALID_RC_CONFIG = 15102, ++ MD_ERROR_WIN_MUI_INVALID_LOCALE_NAME = 15103, ++ MD_ERROR_WIN_MUI_INVALID_ULTIMATEFALLBACK_NAME = 15104, ++ MD_ERROR_WIN_MUI_FILE_NOT_LOADED = 15105, ++ MD_ERROR_WIN_RESOURCE_ENUM_USER_STOP = 15106, ++ MD_ERROR_WIN_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED = 15107, ++ MD_ERROR_WIN_MUI_INTLSETTINGS_INVALID_LOCALE_NAME = 15108, ++ MD_ERROR_WIN_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE = 15110, ++ MD_ERROR_WIN_MRM_INVALID_PRICONFIG = 15111, ++ MD_ERROR_WIN_MRM_INVALID_FILE_TYPE = 15112, ++ MD_ERROR_WIN_MRM_UNKNOWN_QUALIFIER = 15113, ++ MD_ERROR_WIN_MRM_INVALID_QUALIFIER_VALUE = 15114, ++ MD_ERROR_WIN_MRM_NO_CANDIDATE = 15115, ++ MD_ERROR_WIN_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE = 15116, ++ MD_ERROR_WIN_MRM_RESOURCE_TYPE_MISMATCH = 15117, ++ MD_ERROR_WIN_MRM_DUPLICATE_MAP_NAME = 15118, ++ MD_ERROR_WIN_MRM_DUPLICATE_ENTRY = 15119, ++ MD_ERROR_WIN_MRM_INVALID_RESOURCE_IDENTIFIER = 15120, ++ MD_ERROR_WIN_MRM_FILEPATH_TOO_LONG = 15121, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_DIRECTORY_TYPE = 15122, ++ MD_ERROR_WIN_MRM_INVALID_PRI_FILE = 15126, ++ MD_ERROR_WIN_MRM_NAMED_RESOURCE_NOT_FOUND = 15127, ++ MD_ERROR_WIN_MRM_MAP_NOT_FOUND = 15135, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_PROFILE_TYPE = 15136, ++ MD_ERROR_WIN_MRM_INVALID_QUALIFIER_OPERATOR = 15137, ++ MD_ERROR_WIN_MRM_INDETERMINATE_QUALIFIER_VALUE = 15138, ++ MD_ERROR_WIN_MRM_AUTOMERGE_ENABLED = 15139, ++ MD_ERROR_WIN_MRM_TOO_MANY_RESOURCES = 15140, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGE = 15141, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILE = 15142, ++ MD_ERROR_WIN_MRM_NO_CURRENT_VIEW_ON_THREAD = 15143, ++ MD_ERROR_WIN_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXIST = 15144, ++ MD_ERROR_WIN_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENT = 15145, ++ MD_ERROR_WIN_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCE = 15146, ++ MD_ERROR_WIN_MRM_GENERATION_COUNT_MISMATCH = 15147, ++ MD_ERROR_WIN_PRI_MERGE_VERSION_MISMATCH = 15148, ++ MD_ERROR_WIN_PRI_MERGE_MISSING_SCHEMA = 15149, ++ MD_ERROR_WIN_PRI_MERGE_LOAD_FILE_FAILED = 15150, ++ MD_ERROR_WIN_PRI_MERGE_ADD_FILE_FAILED = 15151, ++ MD_ERROR_WIN_PRI_MERGE_WRITE_FILE_FAILED = 15152, ++ MD_ERROR_WIN_PRI_MERGE_MULTIPLE_PACKAGE_FAMILIES_NOT_ALLOWED = 15153, ++ MD_ERROR_WIN_PRI_MERGE_MULTIPLE_MAIN_PACKAGES_NOT_ALLOWED = 15154, ++ MD_ERROR_WIN_PRI_MERGE_BUNDLE_PACKAGES_NOT_ALLOWED = 15155, ++ MD_ERROR_WIN_PRI_MERGE_MAIN_PACKAGE_REQUIRED = 15156, ++ MD_ERROR_WIN_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED = 15157, ++ MD_ERROR_WIN_PRI_MERGE_INVALID_FILE_NAME = 15158, ++ MD_ERROR_WIN_MRM_PACKAGE_NOT_FOUND = 15159, ++ MD_ERROR_WIN_MRM_MISSING_DEFAULT_LANGUAGE = 15160, ++ MD_ERROR_WIN_MCA_INVALID_CAPABILITIES_STRING = 15200, ++ MD_ERROR_WIN_MCA_INVALID_VCP_VERSION = 15201, ++ MD_ERROR_WIN_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION = 15202, ++ MD_ERROR_WIN_MCA_MCCS_VERSION_MISMATCH = 15203, ++ MD_ERROR_WIN_MCA_UNSUPPORTED_MCCS_VERSION = 15204, ++ MD_ERROR_WIN_MCA_INTERNAL_ERROR = 15205, ++ MD_ERROR_WIN_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED = 15206, ++ MD_ERROR_WIN_MCA_UNSUPPORTED_COLOR_TEMPERATURE = 15207, ++ MD_ERROR_WIN_AMBIGUOUS_SYSTEM_DEVICE = 15250, ++ MD_ERROR_WIN_SYSTEM_DEVICE_NOT_FOUND = 15299, ++ MD_ERROR_WIN_HASH_NOT_SUPPORTED = 15300, ++ MD_ERROR_WIN_HASH_NOT_PRESENT = 15301, ++ MD_ERROR_WIN_SECONDARY_IC_PROVIDER_NOT_REGISTERED = 15321, ++ MD_ERROR_WIN_GPIO_CLIENT_INFORMATION_INVALID = 15322, ++ MD_ERROR_WIN_GPIO_VERSION_NOT_SUPPORTED = 15323, ++ MD_ERROR_WIN_GPIO_INVALID_REGISTRATION_PACKET = 15324, ++ MD_ERROR_WIN_GPIO_OPERATION_DENIED = 15325, ++ MD_ERROR_WIN_GPIO_INCOMPATIBLE_CONNECT_MODE = 15326, ++ MD_ERROR_WIN_GPIO_INTERRUPT_ALREADY_UNMASKED = 15327, ++ MD_ERROR_WIN_CANNOT_SWITCH_RUNLEVEL = 15400, ++ MD_ERROR_WIN_INVALID_RUNLEVEL_SETTING = 15401, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_TIMEOUT = 15402, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_AGENT_TIMEOUT = 15403, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_IN_PROGRESS = 15404, ++ MD_ERROR_WIN_SERVICES_FAILED_AUTOSTART = 15405, ++ MD_ERROR_WIN_COM_TASK_STOP_PENDING = 15501, ++ MD_ERROR_WIN_INSTALL_OPEN_PACKAGE_FAILED = 15600, ++ MD_ERROR_WIN_INSTALL_PACKAGE_NOT_FOUND = 15601, ++ MD_ERROR_WIN_INSTALL_INVALID_PACKAGE = 15602, ++ MD_ERROR_WIN_INSTALL_RESOLVE_DEPENDENCY_FAILED = 15603, ++ MD_ERROR_WIN_INSTALL_OUT_OF_DISK_SPACE = 15604, ++ MD_ERROR_WIN_INSTALL_NETWORK_FAILURE = 15605, ++ MD_ERROR_WIN_INSTALL_REGISTRATION_FAILURE = 15606, ++ MD_ERROR_WIN_INSTALL_DEREGISTRATION_FAILURE = 15607, ++ MD_ERROR_WIN_INSTALL_CANCEL = 15608, ++ MD_ERROR_WIN_INSTALL_FAILED = 15609, ++ MD_ERROR_WIN_REMOVE_FAILED = 15610, ++ MD_ERROR_WIN_PACKAGE_ALREADY_EXISTS = 15611, ++ MD_ERROR_WIN_NEEDS_REMEDIATION = 15612, ++ MD_ERROR_WIN_INSTALL_PREREQUISITE_FAILED = 15613, ++ MD_ERROR_WIN_PACKAGE_REPOSITORY_CORRUPTED = 15614, ++ MD_ERROR_WIN_INSTALL_POLICY_FAILURE = 15615, ++ MD_ERROR_WIN_PACKAGE_UPDATING = 15616, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_POLICY = 15617, ++ MD_ERROR_WIN_PACKAGES_IN_USE = 15618, ++ MD_ERROR_WIN_RECOVERY_FILE_CORRUPT = 15619, ++ MD_ERROR_WIN_INVALID_STAGED_SIGNATURE = 15620, ++ MD_ERROR_WIN_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED = 15621, ++ MD_ERROR_WIN_INSTALL_PACKAGE_DOWNGRADE = 15622, ++ MD_ERROR_WIN_SYSTEM_NEEDS_REMEDIATION = 15623, ++ MD_ERROR_WIN_APPX_INTEGRITY_FAILURE_CLR_NGEN = 15624, ++ MD_ERROR_WIN_RESILIENCY_FILE_CORRUPT = 15625, ++ MD_ERROR_WIN_INSTALL_FIREWALL_SERVICE_NOT_RUNNING = 15626, ++ MD_ERROR_WIN_PACKAGE_MOVE_FAILED = 15627, ++ MD_ERROR_WIN_INSTALL_VOLUME_NOT_EMPTY = 15628, ++ MD_ERROR_WIN_INSTALL_VOLUME_OFFLINE = 15629, ++ MD_ERROR_WIN_INSTALL_VOLUME_CORRUPT = 15630, ++ MD_ERROR_WIN_NEEDS_REGISTRATION = 15631, ++ MD_ERROR_WIN_INSTALL_WRONG_PROCESSOR_ARCHITECTURE = 15632, ++ MD_ERROR_WIN_DEV_SIDELOAD_LIMIT_EXCEEDED = 15633, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE = 15634, ++ MD_ERROR_WIN_PACKAGE_NOT_SUPPORTED_ON_FILESYSTEM = 15635, ++ MD_ERROR_WIN_PACKAGE_MOVE_BLOCKED_BY_STREAMING = 15636, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_APPLICATIONID_NOT_UNIQUE = 15637, ++ MD_ERROR_WIN_PACKAGE_STAGING_ONHOLD = 15638, ++ MD_ERROR_WIN_INSTALL_INVALID_RELATED_SET_UPDATE = 15639, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY = 15640, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_USER_LOG_OFF = 15641, ++ MD_ERROR_WIN_PROVISION_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_PROVISIONED = 15642, ++ MD_ERROR_WIN_PACKAGES_REPUTATION_CHECK_FAILED = 15643, ++ MD_ERROR_WIN_PACKAGES_REPUTATION_CHECK_TIMEDOUT = 15644, ++ MD_ERROR_WIN_DEPLOYMENT_OPTION_NOT_SUPPORTED = 15645, ++ MD_ERROR_WIN_APPINSTALLER_ACTIVATION_BLOCKED = 15646, ++ MD_ERROR_WIN_REGISTRATION_FROM_REMOTE_DRIVE_NOT_SUPPORTED = 15647, ++ MD_ERROR_WIN_APPX_RAW_DATA_WRITE_FAILED = 15648, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_PACKAGE = 15649, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_MACHINE = 15650, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_PROFILE_POLICY = 15651, ++ MD_ERROR_WIN_DEPLOYMENT_FAILED_CONFLICTING_MUTABLE_PACKAGE_DIRECTORY = 15652, ++ MD_ERROR_WIN_SINGLETON_RESOURCE_INSTALLED_IN_ACTIVE_USER = 15653, ++ MD_ERROR_WIN_DIFFERENT_VERSION_OF_PACKAGED_SERVICE_INSTALLED = 15654, ++ MD_ERROR_WIN_SERVICE_EXISTS_AS_NON_PACKAGED_SERVICE = 15655, ++ MD_ERROR_WIN_PACKAGED_SERVICE_REQUIRES_ADMIN_PRIVILEGES = 15656, ++ MD_ERROR_WIN_REDIRECTION_TO_DEFAULT_ACCOUNT_NOT_ALLOWED = 15657, ++ MD_ERROR_WIN_PACKAGE_LACKS_CAPABILITY_TO_DEPLOY_ON_HOST = 15658, ++ MD_ERROR_WIN_UNSIGNED_PACKAGE_INVALID_CONTENT = 15659, ++ MD_ERROR_WIN_UNSIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE = 15660, ++ MD_ERROR_WIN_SIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE = 15661, ++ MD_ERROR_WIN_PACKAGE_EXTERNAL_LOCATION_NOT_ALLOWED = 15662, ++ MD_ERROR_WIN_INSTALL_FULLTRUST_HOSTRUNTIME_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY = 15663, ++ MD_ERROR_WIN_STATE_LOAD_STORE_FAILED = 15800, ++ MD_ERROR_WIN_STATE_GET_VERSION_FAILED = 15801, ++ MD_ERROR_WIN_STATE_SET_VERSION_FAILED = 15802, ++ MD_ERROR_WIN_STATE_STRUCTURED_RESET_FAILED = 15803, ++ MD_ERROR_WIN_STATE_OPEN_CONTAINER_FAILED = 15804, ++ MD_ERROR_WIN_STATE_CREATE_CONTAINER_FAILED = 15805, ++ MD_ERROR_WIN_STATE_DELETE_CONTAINER_FAILED = 15806, ++ MD_ERROR_WIN_STATE_READ_SETTING_FAILED = 15807, ++ MD_ERROR_WIN_STATE_WRITE_SETTING_FAILED = 15808, ++ MD_ERROR_WIN_STATE_DELETE_SETTING_FAILED = 15809, ++ MD_ERROR_WIN_STATE_QUERY_SETTING_FAILED = 15810, ++ MD_ERROR_WIN_STATE_READ_COMPOSITE_SETTING_FAILED = 15811, ++ MD_ERROR_WIN_STATE_WRITE_COMPOSITE_SETTING_FAILED = 15812, ++ MD_ERROR_WIN_STATE_ENUMERATE_CONTAINER_FAILED = 15813, ++ MD_ERROR_WIN_STATE_ENUMERATE_SETTINGS_FAILED = 15814, ++ MD_ERROR_WIN_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED = 15815, ++ MD_ERROR_WIN_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED = 15816, ++ MD_ERROR_WIN_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED = 15817, ++ MD_ERROR_WIN_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED = 15818, ++ MD_ERROR_WIN_API_UNAVAILABLE = 15841, ++} MDErrorWin; ++ + #endif /* GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_WIN32_H__ */ +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1241,17 +1241,23 @@ string MinidumpProcessor::GetCrashReason + *address = + raw_exception->exception_record.exception_information[1]; + } + if (raw_exception->exception_record.number_parameters >= 3) { + uint32_t ntstatus = + static_cast<uint32_t> + (raw_exception->exception_record.exception_information[2]); + reason.append(" / "); +- reason.append(NTStatusToString(ntstatus)); ++ const char* ntstatus_str = NTStatusToString(ntstatus); ++ if (ntstatus_str) { ++ reason.append(ntstatus_str); ++ } else { ++ snprintf(reason_string, sizeof(reason_string), "%#010x", ntstatus); ++ reason.append(reason_string); ++ } + } + break; + case MD_EXCEPTION_CODE_WIN_INVALID_HANDLE: + reason = "EXCEPTION_INVALID_HANDLE"; + break; + case MD_EXCEPTION_CODE_WIN_ILLEGAL_INSTRUCTION: + reason = "EXCEPTION_ILLEGAL_INSTRUCTION"; + break; +@@ -1304,34 +1310,47 @@ string MinidumpProcessor::GetCrashReason + reason = "EXCEPTION_POSSIBLE_DEADLOCK"; + break; + case MD_NTSTATUS_WIN_STATUS_STACK_BUFFER_OVERRUN: + reason = "STATUS_STACK_BUFFER_OVERRUN"; + if (raw_exception->exception_record.number_parameters > 0) { + uint32_t fast_fail_code = + static_cast<uint32_t> + (raw_exception->exception_record.exception_information[0]); ++ char fast_fail_buff[13] = {}; ++ const char* fast_fail_string = FastFailToString(fast_fail_code); ++ if (!fast_fail_string) { ++ snprintf(fast_fail_buff, sizeof(fast_fail_buff), "%#010x", ++ fast_fail_code); ++ fast_fail_string = fast_fail_buff; ++ } ++ + reason.append(" / "); +- reason.append(FastFailToString(fast_fail_code)); ++ reason.append(fast_fail_string); + } + + break; + case MD_EXCEPTION_OUT_OF_MEMORY: + reason = "Out of Memory"; + break; + case MD_EXCEPTION_CODE_WIN_UNHANDLED_CPP_EXCEPTION: + reason = "Unhandled C++ Exception"; + break; + case MD_EXCEPTION_CODE_WIN_SIMULATED: + reason = "Simulated Exception"; + break; + default: +- reason = NTStatusToString(exception_code); +- if (reason.substr(0, 2) == "0x") { +- BPLOG(INFO) << "Unknown exception reason " << reason; ++ fprintf(stderr, "exception_code = %u\n", exception_code); ++ const char* exception_str = NTStatusToString(exception_code); ++ fprintf(stderr, "exception_str = %s\n", exception_str); ++ if (exception_str == nullptr) { ++ exception_str = WinErrorToString(exception_code); ++ } ++ if (exception_str != nullptr) { ++ reason = exception_str; + } + break; + } + break; + } + + case MD_OS_ANDROID: + case MD_OS_LINUX: { +diff --git a/src/processor/symbolic_constants_win.cc b/src/processor/symbolic_constants_win.cc +--- a/src/processor/symbolic_constants_win.cc ++++ b/src/processor/symbolic_constants_win.cc +@@ -28,8384 +28,10931 @@ + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + // ntstatus_reason_win.h: Windows NTSTATUS code to string. + // + // Provides a means to convert NTSTATUS codes to strings. + // + // Author: Ben Wagner + ++#include <algorithm> + #include <string> + + #include "common/stdio_wrapper.h" + #include "google_breakpad/common/breakpad_types.h" + #include "google_breakpad/common/minidump_exception_win32.h" + #include "processor/symbolic_constants_win.h" + + namespace google_breakpad { + +-string NTStatusToString(uint32_t ntstatus) { +- string reason; +- // The content of this switch was created from ntstatus.h in the 10 SDK +- // (version 10.0.19041.0) with +- // +- // egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0x[048C][0-9A-F]+L\)' ntstatus.h +- // | tr -d '\r' +- // | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0x[048C][0-9A-F]+)L\).*@\2 \1@' +- // | sort +- // | sed -r 's@(0x[048C][0-9A-F]+) ([A-Z_0-9]+)@ case MD_NTSTATUS_WIN_\2:\n reason = "\2";\n break;@' +- // +- // With easy copy to clipboard with +- // | xclip -selection c # on linux +- // | clip # on windows +- // | pbcopy # on mac +- // +- // and then the default case added. +- switch (ntstatus) { +- case MD_NTSTATUS_WIN_STATUS_SUCCESS: +- reason = "STATUS_SUCCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAIT_1: +- reason = "STATUS_WAIT_1"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAIT_2: +- reason = "STATUS_WAIT_2"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAIT_3: +- reason = "STATUS_WAIT_3"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAIT_63: +- reason = "STATUS_WAIT_63"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABANDONED: +- reason = "STATUS_ABANDONED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_63: +- reason = "STATUS_ABANDONED_WAIT_63"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER_APC: +- reason = "STATUS_USER_APC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_COMPLETE: +- reason = "STATUS_ALREADY_COMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KERNEL_APC: +- reason = "STATUS_KERNEL_APC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALERTED: +- reason = "STATUS_ALERTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TIMEOUT: +- reason = "STATUS_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PENDING: +- reason = "STATUS_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE: +- reason = "STATUS_REPARSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MORE_ENTRIES: +- reason = "STATUS_MORE_ENTRIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_ALL_ASSIGNED: +- reason = "STATUS_NOT_ALL_ASSIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SOME_NOT_MAPPED: +- reason = "STATUS_SOME_NOT_MAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPLOCK_BREAK_IN_PROGRESS: +- reason = "STATUS_OPLOCK_BREAK_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLUME_MOUNTED: +- reason = "STATUS_VOLUME_MOUNTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RXACT_COMMITTED: +- reason = "STATUS_RXACT_COMMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOTIFY_CLEANUP: +- reason = "STATUS_NOTIFY_CLEANUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOTIFY_ENUM_DIR: +- reason = "STATUS_NOTIFY_ENUM_DIR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_QUOTAS_FOR_ACCOUNT: +- reason = "STATUS_NO_QUOTAS_FOR_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED: +- reason = "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_TRANSITION: +- reason = "STATUS_PAGE_FAULT_TRANSITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_DEMAND_ZERO: +- reason = "STATUS_PAGE_FAULT_DEMAND_ZERO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_COPY_ON_WRITE: +- reason = "STATUS_PAGE_FAULT_COPY_ON_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_GUARD_PAGE: +- reason = "STATUS_PAGE_FAULT_GUARD_PAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_PAGING_FILE: +- reason = "STATUS_PAGE_FAULT_PAGING_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CACHE_PAGE_LOCKED: +- reason = "STATUS_CACHE_PAGE_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRASH_DUMP: +- reason = "STATUS_CRASH_DUMP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BUFFER_ALL_ZEROS: +- reason = "STATUS_BUFFER_ALL_ZEROS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE_OBJECT: +- reason = "STATUS_REPARSE_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_REQUIREMENTS_CHANGED: +- reason = "STATUS_RESOURCE_REQUIREMENTS_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSLATION_COMPLETE: +- reason = "STATUS_TRANSLATION_COMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY: +- reason = "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOTHING_TO_TERMINATE: +- reason = "STATUS_NOTHING_TO_TERMINATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCESS_NOT_IN_JOB: +- reason = "STATUS_PROCESS_NOT_IN_JOB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCESS_IN_JOB: +- reason = "STATUS_PROCESS_IN_JOB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLSNAP_HIBERNATE_READY: +- reason = "STATUS_VOLSNAP_HIBERNATE_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY: +- reason = "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED: +- reason = "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERRUPT_STILL_CONNECTED: +- reason = "STATUS_INTERRUPT_STILL_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCESS_CLONED: +- reason = "STATUS_PROCESS_CLONED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_ONLY_READERS: +- reason = "STATUS_FILE_LOCKED_WITH_ONLY_READERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_WRITERS: +- reason = "STATUS_FILE_LOCKED_WITH_WRITERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VALID_IMAGE_HASH: +- reason = "STATUS_VALID_IMAGE_HASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VALID_CATALOG_HASH: +- reason = "STATUS_VALID_CATALOG_HASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VALID_STRONG_CODE_HASH: +- reason = "STATUS_VALID_STRONG_CODE_HASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GHOSTED: +- reason = "STATUS_GHOSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_OVERWRITTEN: +- reason = "STATUS_DATA_OVERWRITTEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_READ_ONLY: +- reason = "STATUS_RESOURCEMANAGER_READ_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_EMPTY: +- reason = "STATUS_RING_PREVIOUSLY_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_FULL: +- reason = "STATUS_RING_PREVIOUSLY_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_ABOVE_QUOTA: +- reason = "STATUS_RING_PREVIOUSLY_ABOVE_QUOTA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RING_NEWLY_EMPTY: +- reason = "STATUS_RING_NEWLY_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT: +- reason = "STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE: +- reason = "STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPLOCK_HANDLE_CLOSED: +- reason = "STATUS_OPLOCK_HANDLE_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAIT_FOR_OPLOCK: +- reason = "STATUS_WAIT_FOR_OPLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE_GLOBAL: +- reason = "STATUS_REPARSE_GLOBAL"; +- break; +- case MD_NTSTATUS_WIN_DBG_EXCEPTION_HANDLED: +- reason = "DBG_EXCEPTION_HANDLED"; +- break; +- case MD_NTSTATUS_WIN_DBG_CONTINUE: +- reason = "DBG_CONTINUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_IO_COMPLETE: +- reason = "STATUS_FLT_IO_COMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_CONTINUE: +- reason = "STATUS_RTPM_CONTEXT_CONTINUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_COMPLETE: +- reason = "STATUS_RTPM_CONTEXT_COMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_PENDING_PAGE_REQUESTS: +- reason = "STATUS_HV_PENDING_PAGE_REQUESTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_REPAIRED: +- reason = "STATUS_SPACES_REPAIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_PAUSE: +- reason = "STATUS_SPACES_PAUSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_COMPLETE: +- reason = "STATUS_SPACES_COMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_REDIRECT: +- reason = "STATUS_SPACES_REDIRECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_EXISTS: +- reason = "STATUS_OBJECT_NAME_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_WAS_SUSPENDED: +- reason = "STATUS_THREAD_WAS_SUSPENDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WORKING_SET_LIMIT_RANGE: +- reason = "STATUS_WORKING_SET_LIMIT_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_NOT_AT_BASE: +- reason = "STATUS_IMAGE_NOT_AT_BASE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RXACT_STATE_CREATED: +- reason = "STATUS_RXACT_STATE_CREATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SEGMENT_NOTIFICATION: +- reason = "STATUS_SEGMENT_NOTIFICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOCAL_USER_SESSION_KEY: +- reason = "STATUS_LOCAL_USER_SESSION_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_CURRENT_DIRECTORY: +- reason = "STATUS_BAD_CURRENT_DIRECTORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERIAL_MORE_WRITES: +- reason = "STATUS_SERIAL_MORE_WRITES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REGISTRY_RECOVERED: +- reason = "STATUS_REGISTRY_RECOVERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_READ_RECOVERY_FROM_BACKUP: +- reason = "STATUS_FT_READ_RECOVERY_FROM_BACKUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_WRITE_RECOVERY: +- reason = "STATUS_FT_WRITE_RECOVERY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERIAL_COUNTER_TIMEOUT: +- reason = "STATUS_SERIAL_COUNTER_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NULL_LM_PASSWORD: +- reason = "STATUS_NULL_LM_PASSWORD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH: +- reason = "STATUS_IMAGE_MACHINE_TYPE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL: +- reason = "STATUS_RECEIVE_PARTIAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECEIVE_EXPEDITED: +- reason = "STATUS_RECEIVE_EXPEDITED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL_EXPEDITED: +- reason = "STATUS_RECEIVE_PARTIAL_EXPEDITED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVENT_DONE: +- reason = "STATUS_EVENT_DONE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVENT_PENDING: +- reason = "STATUS_EVENT_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CHECKING_FILE_SYSTEM: +- reason = "STATUS_CHECKING_FILE_SYSTEM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FATAL_APP_EXIT: +- reason = "STATUS_FATAL_APP_EXIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PREDEFINED_HANDLE: +- reason = "STATUS_PREDEFINED_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAS_UNLOCKED: +- reason = "STATUS_WAS_UNLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVICE_NOTIFICATION: +- reason = "STATUS_SERVICE_NOTIFICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAS_LOCKED: +- reason = "STATUS_WAS_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_HARD_ERROR: +- reason = "STATUS_LOG_HARD_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_WIN32: +- reason = "STATUS_ALREADY_WIN32"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_UNSIMULATE: +- reason = "STATUS_WX86_UNSIMULATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_CONTINUE: +- reason = "STATUS_WX86_CONTINUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_SINGLE_STEP: +- reason = "STATUS_WX86_SINGLE_STEP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_BREAKPOINT: +- reason = "STATUS_WX86_BREAKPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CONTINUE: +- reason = "STATUS_WX86_EXCEPTION_CONTINUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_LASTCHANCE: +- reason = "STATUS_WX86_EXCEPTION_LASTCHANCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CHAIN: +- reason = "STATUS_WX86_EXCEPTION_CHAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE: +- reason = "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_YIELD_PERFORMED: +- reason = "STATUS_NO_YIELD_PERFORMED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TIMER_RESUME_IGNORED: +- reason = "STATUS_TIMER_RESUME_IGNORED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ARBITRATION_UNHANDLED: +- reason = "STATUS_ARBITRATION_UNHANDLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CARDBUS_NOT_SUPPORTED: +- reason = "STATUS_CARDBUS_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_CREATEWX86TIB: +- reason = "STATUS_WX86_CREATEWX86TIB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MP_PROCESSOR_MISMATCH: +- reason = "STATUS_MP_PROCESSOR_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HIBERNATED: +- reason = "STATUS_HIBERNATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESUME_HIBERNATION: +- reason = "STATUS_RESUME_HIBERNATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FIRMWARE_UPDATED: +- reason = "STATUS_FIRMWARE_UPDATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVERS_LEAKING_LOCKED_PAGES: +- reason = "STATUS_DRIVERS_LEAKING_LOCKED_PAGES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MESSAGE_RETRIEVED: +- reason = "STATUS_MESSAGE_RETRIEVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_TRANSITION: +- reason = "STATUS_SYSTEM_POWERSTATE_TRANSITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALPC_CHECK_COMPLETION_LIST: +- reason = "STATUS_ALPC_CHECK_COMPLETION_LIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION: +- reason = "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_AUDIT_BY_POLICY: +- reason = "STATUS_ACCESS_AUDIT_BY_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABANDON_HIBERFILE: +- reason = "STATUS_ABANDON_HIBERFILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BIZRULES_NOT_ENABLED: +- reason = "STATUS_BIZRULES_NOT_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_READ_FROM_COPY: +- reason = "STATUS_FT_READ_FROM_COPY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_AT_DIFFERENT_BASE: +- reason = "STATUS_IMAGE_AT_DIFFERENT_BASE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PATCH_DEFERRED: +- reason = "STATUS_PATCH_DEFERRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM: +- reason = "STATUS_WAKE_SYSTEM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_SHUTTING_DOWN: +- reason = "STATUS_DS_SHUTTING_DOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_REDIRECTED: +- reason = "STATUS_DISK_REPAIR_REDIRECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVICES_FAILED_AUTOSTART: +- reason = "STATUS_SERVICES_FAILED_AUTOSTART"; +- break; +- case MD_NTSTATUS_WIN_DBG_REPLY_LATER: +- reason = "DBG_REPLY_LATER"; +- break; +- case MD_NTSTATUS_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE: +- reason = "DBG_UNABLE_TO_PROVIDE_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_DBG_TERMINATE_THREAD: +- reason = "DBG_TERMINATE_THREAD"; +- break; +- case MD_NTSTATUS_WIN_DBG_TERMINATE_PROCESS: +- reason = "DBG_TERMINATE_PROCESS"; +- break; +- case MD_NTSTATUS_WIN_DBG_CONTROL_C: +- reason = "DBG_CONTROL_C"; +- break; +- case MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_C: +- reason = "DBG_PRINTEXCEPTION_C"; +- break; +- case MD_NTSTATUS_WIN_DBG_RIPEXCEPTION: +- reason = "DBG_RIPEXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_DBG_CONTROL_BREAK: +- reason = "DBG_CONTROL_BREAK"; +- break; +- case MD_NTSTATUS_WIN_DBG_COMMAND_EXCEPTION: +- reason = "DBG_COMMAND_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_WIDE_C: +- reason = "DBG_PRINTEXCEPTION_WIDE_C"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UUID_LOCAL_ONLY: +- reason = "RPC_NT_UUID_LOCAL_ONLY"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SEND_INCOMPLETE: +- reason = "RPC_NT_SEND_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CDM_CONNECT: +- reason = "STATUS_CTX_CDM_CONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CDM_DISCONNECT: +- reason = "STATUS_CTX_CDM_DISCONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT: +- reason = "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HEURISTIC_DAMAGE_POSSIBLE: +- reason = "STATUS_HEURISTIC_DAMAGE_POSSIBLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECOVERY_NOT_NEEDED: +- reason = "STATUS_RECOVERY_NOT_NEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RM_ALREADY_STARTED: +- reason = "STATUS_RM_ALREADY_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_NO_RESTART: +- reason = "STATUS_LOG_NO_RESTART"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST: +- reason = "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED: +- reason = "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION: +- reason = "STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_PINNED: +- reason = "STATUS_GRAPHICS_MODE_NOT_PINNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_PREFERRED_MODE: +- reason = "STATUS_GRAPHICS_NO_PREFERRED_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DATASET_IS_EMPTY: +- reason = "STATUS_GRAPHICS_DATASET_IS_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET: +- reason = "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED: +- reason = "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS: +- reason = "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_START_DEFERRED: +- reason = "STATUS_GRAPHICS_LEADLINK_START_DEFERRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY: +- reason = "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_START_DEFERRED: +- reason = "STATUS_GRAPHICS_START_DEFERRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS: +- reason = "STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INDICATION_REQUIRED: +- reason = "STATUS_NDIS_INDICATION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_UNSUPPORTED_PSS_SALT: +- reason = "STATUS_PCP_UNSUPPORTED_PSS_SALT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GUARD_PAGE_VIOLATION: +- reason = "STATUS_GUARD_PAGE_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT: +- reason = "STATUS_DATATYPE_MISALIGNMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BREAKPOINT: +- reason = "STATUS_BREAKPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SINGLE_STEP: +- reason = "STATUS_SINGLE_STEP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BUFFER_OVERFLOW: +- reason = "STATUS_BUFFER_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MORE_FILES: +- reason = "STATUS_NO_MORE_FILES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM_DEBUGGER: +- reason = "STATUS_WAKE_SYSTEM_DEBUGGER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HANDLES_CLOSED: +- reason = "STATUS_HANDLES_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_INHERITANCE: +- reason = "STATUS_NO_INHERITANCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GUID_SUBSTITUTION_MADE: +- reason = "STATUS_GUID_SUBSTITUTION_MADE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PARTIAL_COPY: +- reason = "STATUS_PARTIAL_COPY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_PAPER_EMPTY: +- reason = "STATUS_DEVICE_PAPER_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_POWERED_OFF: +- reason = "STATUS_DEVICE_POWERED_OFF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_OFF_LINE: +- reason = "STATUS_DEVICE_OFF_LINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_BUSY: +- reason = "STATUS_DEVICE_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MORE_EAS: +- reason = "STATUS_NO_MORE_EAS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_EA_NAME: +- reason = "STATUS_INVALID_EA_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EA_LIST_INCONSISTENT: +- reason = "STATUS_EA_LIST_INCONSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_EA_FLAG: +- reason = "STATUS_INVALID_EA_FLAG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VERIFY_REQUIRED: +- reason = "STATUS_VERIFY_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EXTRANEOUS_INFORMATION: +- reason = "STATUS_EXTRANEOUS_INFORMATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_NECESSARY: +- reason = "STATUS_RXACT_COMMIT_NECESSARY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MORE_ENTRIES: +- reason = "STATUS_NO_MORE_ENTRIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILEMARK_DETECTED: +- reason = "STATUS_FILEMARK_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEDIA_CHANGED: +- reason = "STATUS_MEDIA_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BUS_RESET: +- reason = "STATUS_BUS_RESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_END_OF_MEDIA: +- reason = "STATUS_END_OF_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BEGINNING_OF_MEDIA: +- reason = "STATUS_BEGINNING_OF_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEDIA_CHECK: +- reason = "STATUS_MEDIA_CHECK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SETMARK_DETECTED: +- reason = "STATUS_SETMARK_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_DATA_DETECTED: +- reason = "STATUS_NO_DATA_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REDIRECTOR_HAS_OPEN_HANDLES: +- reason = "STATUS_REDIRECTOR_HAS_OPEN_HANDLES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_HAS_OPEN_HANDLES: +- reason = "STATUS_SERVER_HAS_OPEN_HANDLES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_DISCONNECTED: +- reason = "STATUS_ALREADY_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LONGJUMP: +- reason = "STATUS_LONGJUMP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLEANER_CARTRIDGE_INSTALLED: +- reason = "STATUS_CLEANER_CARTRIDGE_INSTALLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLUGPLAY_QUERY_VETOED: +- reason = "STATUS_PLUGPLAY_QUERY_VETOED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNWIND_CONSOLIDATE: +- reason = "STATUS_UNWIND_CONSOLIDATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REGISTRY_HIVE_RECOVERED: +- reason = "STATUS_REGISTRY_HIVE_RECOVERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INSECURE: +- reason = "STATUS_DLL_MIGHT_BE_INSECURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INCOMPATIBLE: +- reason = "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STOPPED_ON_SYMLINK: +- reason = "STATUS_STOPPED_ON_SYMLINK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK: +- reason = "STATUS_CANNOT_GRANT_REQUESTED_OPLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_ACE_CONDITION: +- reason = "STATUS_NO_ACE_CONDITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_SUPPORT_IN_PROGRESS: +- reason = "STATUS_DEVICE_SUPPORT_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_CYCLE_REQUIRED: +- reason = "STATUS_DEVICE_POWER_CYCLE_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_WORK_DONE: +- reason = "STATUS_NO_WORK_DONE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT: +- reason = "STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_REQUIRES_CLEANING: +- reason = "STATUS_DEVICE_REQUIRES_CLEANING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_DOOR_OPEN: +- reason = "STATUS_DEVICE_DOOR_OPEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_LOST_REPAIR: +- reason = "STATUS_DATA_LOST_REPAIR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED: +- reason = "STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH: +- reason = "STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE: +- reason = "STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS: +- reason = "STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS"; +- break; +- case MD_NTSTATUS_WIN_DBG_EXCEPTION_NOT_HANDLED: +- reason = "DBG_EXCEPTION_NOT_HANDLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_UP: +- reason = "STATUS_CLUSTER_NODE_ALREADY_UP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_DOWN: +- reason = "STATUS_CLUSTER_NODE_ALREADY_DOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE: +- reason = "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE: +- reason = "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_MEMBER: +- reason = "STATUS_CLUSTER_NODE_ALREADY_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COULD_NOT_RESIZE_LOG: +- reason = "STATUS_COULD_NOT_RESIZE_LOG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TXF_METADATA: +- reason = "STATUS_NO_TXF_METADATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN: +- reason = "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TXF_METADATA_ALREADY_PRESENT: +- reason = "STATUS_TXF_METADATA_ALREADY_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET: +- reason = "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED: +- reason = "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_BUFFER_TOO_SMALL: +- reason = "STATUS_FLT_BUFFER_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_PARTIAL_METADATA: +- reason = "STATUS_FVE_PARTIAL_METADATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TRANSIENT_STATE: +- reason = "STATUS_FVE_TRANSIENT_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED: +- reason = "STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_REGENERATION: +- reason = "STATUS_VOLMGR_INCOMPLETE_REGENERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION: +- reason = "STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED: +- reason = "STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED: +- reason = "STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUERY_STORAGE_ERROR: +- reason = "STATUS_QUERY_STORAGE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GDI_HANDLE_LEAK: +- reason = "STATUS_GDI_HANDLE_LEAK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_ENABLED: +- reason = "STATUS_SECUREBOOT_NOT_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNSUCCESSFUL: +- reason = "STATUS_UNSUCCESSFUL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_IMPLEMENTED: +- reason = "STATUS_NOT_IMPLEMENTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_INFO_CLASS: +- reason = "STATUS_INVALID_INFO_CLASS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INFO_LENGTH_MISMATCH: +- reason = "STATUS_INFO_LENGTH_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_VIOLATION: +- reason = "STATUS_ACCESS_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IN_PAGE_ERROR: +- reason = "STATUS_IN_PAGE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGEFILE_QUOTA: +- reason = "STATUS_PAGEFILE_QUOTA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_HANDLE: +- reason = "STATUS_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_INITIAL_STACK: +- reason = "STATUS_BAD_INITIAL_STACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_INITIAL_PC: +- reason = "STATUS_BAD_INITIAL_PC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_CID: +- reason = "STATUS_INVALID_CID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TIMER_NOT_CANCELED: +- reason = "STATUS_TIMER_NOT_CANCELED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER: +- reason = "STATUS_INVALID_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_DEVICE: +- reason = "STATUS_NO_SUCH_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_FILE: +- reason = "STATUS_NO_SUCH_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_REQUEST: +- reason = "STATUS_INVALID_DEVICE_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_END_OF_FILE: +- reason = "STATUS_END_OF_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_VOLUME: +- reason = "STATUS_WRONG_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MEDIA_IN_DEVICE: +- reason = "STATUS_NO_MEDIA_IN_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNRECOGNIZED_MEDIA: +- reason = "STATUS_UNRECOGNIZED_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NONEXISTENT_SECTOR: +- reason = "STATUS_NONEXISTENT_SECTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MORE_PROCESSING_REQUIRED: +- reason = "STATUS_MORE_PROCESSING_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MEMORY: +- reason = "STATUS_NO_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONFLICTING_ADDRESSES: +- reason = "STATUS_CONFLICTING_ADDRESSES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_MAPPED_VIEW: +- reason = "STATUS_NOT_MAPPED_VIEW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNABLE_TO_FREE_VM: +- reason = "STATUS_UNABLE_TO_FREE_VM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNABLE_TO_DELETE_SECTION: +- reason = "STATUS_UNABLE_TO_DELETE_SECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SYSTEM_SERVICE: +- reason = "STATUS_INVALID_SYSTEM_SERVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_INSTRUCTION: +- reason = "STATUS_ILLEGAL_INSTRUCTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LOCK_SEQUENCE: +- reason = "STATUS_INVALID_LOCK_SEQUENCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_VIEW_SIZE: +- reason = "STATUS_INVALID_VIEW_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_FILE_FOR_SECTION: +- reason = "STATUS_INVALID_FILE_FOR_SECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_COMMITTED: +- reason = "STATUS_ALREADY_COMMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DENIED: +- reason = "STATUS_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BUFFER_TOO_SMALL: +- reason = "STATUS_BUFFER_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_TYPE_MISMATCH: +- reason = "STATUS_OBJECT_TYPE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NONCONTINUABLE_EXCEPTION: +- reason = "STATUS_NONCONTINUABLE_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DISPOSITION: +- reason = "STATUS_INVALID_DISPOSITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNWIND: +- reason = "STATUS_UNWIND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_STACK: +- reason = "STATUS_BAD_STACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_UNWIND_TARGET: +- reason = "STATUS_INVALID_UNWIND_TARGET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_LOCKED: +- reason = "STATUS_NOT_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PARITY_ERROR: +- reason = "STATUS_PARITY_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNABLE_TO_DECOMMIT_VM: +- reason = "STATUS_UNABLE_TO_DECOMMIT_VM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_COMMITTED: +- reason = "STATUS_NOT_COMMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PORT_ATTRIBUTES: +- reason = "STATUS_INVALID_PORT_ATTRIBUTES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_MESSAGE_TOO_LONG: +- reason = "STATUS_PORT_MESSAGE_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_MIX: +- reason = "STATUS_INVALID_PARAMETER_MIX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_QUOTA_LOWER: +- reason = "STATUS_INVALID_QUOTA_LOWER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_CORRUPT_ERROR: +- reason = "STATUS_DISK_CORRUPT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_INVALID: +- reason = "STATUS_OBJECT_NAME_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_NOT_FOUND: +- reason = "STATUS_OBJECT_NAME_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_COLLISION: +- reason = "STATUS_OBJECT_NAME_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_DO_NOT_DISTURB: +- reason = "STATUS_PORT_DO_NOT_DISTURB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_DISCONNECTED: +- reason = "STATUS_PORT_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_ALREADY_ATTACHED: +- reason = "STATUS_DEVICE_ALREADY_ATTACHED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_INVALID: +- reason = "STATUS_OBJECT_PATH_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_NOT_FOUND: +- reason = "STATUS_OBJECT_PATH_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_SYNTAX_BAD: +- reason = "STATUS_OBJECT_PATH_SYNTAX_BAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_OVERRUN: +- reason = "STATUS_DATA_OVERRUN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_LATE_ERROR: +- reason = "STATUS_DATA_LATE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_ERROR: +- reason = "STATUS_DATA_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRC_ERROR: +- reason = "STATUS_CRC_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECTION_TOO_BIG: +- reason = "STATUS_SECTION_TOO_BIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_CONNECTION_REFUSED: +- reason = "STATUS_PORT_CONNECTION_REFUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PORT_HANDLE: +- reason = "STATUS_INVALID_PORT_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHARING_VIOLATION: +- reason = "STATUS_SHARING_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUOTA_EXCEEDED: +- reason = "STATUS_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PAGE_PROTECTION: +- reason = "STATUS_INVALID_PAGE_PROTECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUTANT_NOT_OWNED: +- reason = "STATUS_MUTANT_NOT_OWNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SEMAPHORE_LIMIT_EXCEEDED: +- reason = "STATUS_SEMAPHORE_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_ALREADY_SET: +- reason = "STATUS_PORT_ALREADY_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECTION_NOT_IMAGE: +- reason = "STATUS_SECTION_NOT_IMAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SUSPEND_COUNT_EXCEEDED: +- reason = "STATUS_SUSPEND_COUNT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_IS_TERMINATING: +- reason = "STATUS_THREAD_IS_TERMINATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_WORKING_SET_LIMIT: +- reason = "STATUS_BAD_WORKING_SET_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_FILE_MAP: +- reason = "STATUS_INCOMPATIBLE_FILE_MAP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECTION_PROTECTION: +- reason = "STATUS_SECTION_PROTECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EAS_NOT_SUPPORTED: +- reason = "STATUS_EAS_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EA_TOO_LARGE: +- reason = "STATUS_EA_TOO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NONEXISTENT_EA_ENTRY: +- reason = "STATUS_NONEXISTENT_EA_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_EAS_ON_FILE: +- reason = "STATUS_NO_EAS_ON_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EA_CORRUPT_ERROR: +- reason = "STATUS_EA_CORRUPT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_LOCK_CONFLICT: +- reason = "STATUS_FILE_LOCK_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOCK_NOT_GRANTED: +- reason = "STATUS_LOCK_NOT_GRANTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DELETE_PENDING: +- reason = "STATUS_DELETE_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTL_FILE_NOT_SUPPORTED: +- reason = "STATUS_CTL_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNKNOWN_REVISION: +- reason = "STATUS_UNKNOWN_REVISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REVISION_MISMATCH: +- reason = "STATUS_REVISION_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_OWNER: +- reason = "STATUS_INVALID_OWNER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PRIMARY_GROUP: +- reason = "STATUS_INVALID_PRIMARY_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_IMPERSONATION_TOKEN: +- reason = "STATUS_NO_IMPERSONATION_TOKEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_DISABLE_MANDATORY: +- reason = "STATUS_CANT_DISABLE_MANDATORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_LOGON_SERVERS: +- reason = "STATUS_NO_LOGON_SERVERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_LOGON_SESSION: +- reason = "STATUS_NO_SUCH_LOGON_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_PRIVILEGE: +- reason = "STATUS_NO_SUCH_PRIVILEGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRIVILEGE_NOT_HELD: +- reason = "STATUS_PRIVILEGE_NOT_HELD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ACCOUNT_NAME: +- reason = "STATUS_INVALID_ACCOUNT_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER_EXISTS: +- reason = "STATUS_USER_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_USER: +- reason = "STATUS_NO_SUCH_USER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GROUP_EXISTS: +- reason = "STATUS_GROUP_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_GROUP: +- reason = "STATUS_NO_SUCH_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMBER_IN_GROUP: +- reason = "STATUS_MEMBER_IN_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMBER_NOT_IN_GROUP: +- reason = "STATUS_MEMBER_NOT_IN_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LAST_ADMIN: +- reason = "STATUS_LAST_ADMIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_PASSWORD: +- reason = "STATUS_WRONG_PASSWORD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILL_FORMED_PASSWORD: +- reason = "STATUS_ILL_FORMED_PASSWORD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PASSWORD_RESTRICTION: +- reason = "STATUS_PASSWORD_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_FAILURE: +- reason = "STATUS_LOGON_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCOUNT_RESTRICTION: +- reason = "STATUS_ACCOUNT_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LOGON_HOURS: +- reason = "STATUS_INVALID_LOGON_HOURS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_WORKSTATION: +- reason = "STATUS_INVALID_WORKSTATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PASSWORD_EXPIRED: +- reason = "STATUS_PASSWORD_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCOUNT_DISABLED: +- reason = "STATUS_ACCOUNT_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NONE_MAPPED: +- reason = "STATUS_NONE_MAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_LUIDS_REQUESTED: +- reason = "STATUS_TOO_MANY_LUIDS_REQUESTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LUIDS_EXHAUSTED: +- reason = "STATUS_LUIDS_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SUB_AUTHORITY: +- reason = "STATUS_INVALID_SUB_AUTHORITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ACL: +- reason = "STATUS_INVALID_ACL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SID: +- reason = "STATUS_INVALID_SID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SECURITY_DESCR: +- reason = "STATUS_INVALID_SECURITY_DESCR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCEDURE_NOT_FOUND: +- reason = "STATUS_PROCEDURE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_FORMAT: +- reason = "STATUS_INVALID_IMAGE_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TOKEN: +- reason = "STATUS_NO_TOKEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_INHERITANCE_ACL: +- reason = "STATUS_BAD_INHERITANCE_ACL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RANGE_NOT_LOCKED: +- reason = "STATUS_RANGE_NOT_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_FULL: +- reason = "STATUS_DISK_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_DISABLED: +- reason = "STATUS_SERVER_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_NOT_DISABLED: +- reason = "STATUS_SERVER_NOT_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_GUIDS_REQUESTED: +- reason = "STATUS_TOO_MANY_GUIDS_REQUESTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GUIDS_EXHAUSTED: +- reason = "STATUS_GUIDS_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ID_AUTHORITY: +- reason = "STATUS_INVALID_ID_AUTHORITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AGENTS_EXHAUSTED: +- reason = "STATUS_AGENTS_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_VOLUME_LABEL: +- reason = "STATUS_INVALID_VOLUME_LABEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECTION_NOT_EXTENDED: +- reason = "STATUS_SECTION_NOT_EXTENDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_MAPPED_DATA: +- reason = "STATUS_NOT_MAPPED_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_DATA_NOT_FOUND: +- reason = "STATUS_RESOURCE_DATA_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_TYPE_NOT_FOUND: +- reason = "STATUS_RESOURCE_TYPE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_NAME_NOT_FOUND: +- reason = "STATUS_RESOURCE_NAME_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ARRAY_BOUNDS_EXCEEDED: +- reason = "STATUS_ARRAY_BOUNDS_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_DENORMAL_OPERAND: +- reason = "STATUS_FLOAT_DENORMAL_OPERAND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_DIVIDE_BY_ZERO: +- reason = "STATUS_FLOAT_DIVIDE_BY_ZERO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_INEXACT_RESULT: +- reason = "STATUS_FLOAT_INEXACT_RESULT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_INVALID_OPERATION: +- reason = "STATUS_FLOAT_INVALID_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_OVERFLOW: +- reason = "STATUS_FLOAT_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_STACK_CHECK: +- reason = "STATUS_FLOAT_STACK_CHECK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_UNDERFLOW: +- reason = "STATUS_FLOAT_UNDERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTEGER_DIVIDE_BY_ZERO: +- reason = "STATUS_INTEGER_DIVIDE_BY_ZERO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTEGER_OVERFLOW: +- reason = "STATUS_INTEGER_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRIVILEGED_INSTRUCTION: +- reason = "STATUS_PRIVILEGED_INSTRUCTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_PAGING_FILES: +- reason = "STATUS_TOO_MANY_PAGING_FILES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_INVALID: +- reason = "STATUS_FILE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALLOTTED_SPACE_EXCEEDED: +- reason = "STATUS_ALLOTTED_SPACE_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_RESOURCES: +- reason = "STATUS_INSUFFICIENT_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DFS_EXIT_PATH_FOUND: +- reason = "STATUS_DFS_EXIT_PATH_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_DATA_ERROR: +- reason = "STATUS_DEVICE_DATA_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_CONNECTED: +- reason = "STATUS_DEVICE_NOT_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_FAILURE: +- reason = "STATUS_DEVICE_POWER_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FREE_VM_NOT_AT_BASE: +- reason = "STATUS_FREE_VM_NOT_AT_BASE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMORY_NOT_ALLOCATED: +- reason = "STATUS_MEMORY_NOT_ALLOCATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WORKING_SET_QUOTA: +- reason = "STATUS_WORKING_SET_QUOTA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEDIA_WRITE_PROTECTED: +- reason = "STATUS_MEDIA_WRITE_PROTECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_READY: +- reason = "STATUS_DEVICE_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_GROUP_ATTRIBUTES: +- reason = "STATUS_INVALID_GROUP_ATTRIBUTES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_IMPERSONATION_LEVEL: +- reason = "STATUS_BAD_IMPERSONATION_LEVEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_OPEN_ANONYMOUS: +- reason = "STATUS_CANT_OPEN_ANONYMOUS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_VALIDATION_CLASS: +- reason = "STATUS_BAD_VALIDATION_CLASS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_TOKEN_TYPE: +- reason = "STATUS_BAD_TOKEN_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_MASTER_BOOT_RECORD: +- reason = "STATUS_BAD_MASTER_BOOT_RECORD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSTRUCTION_MISALIGNMENT: +- reason = "STATUS_INSTRUCTION_MISALIGNMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSTANCE_NOT_AVAILABLE: +- reason = "STATUS_INSTANCE_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_NOT_AVAILABLE: +- reason = "STATUS_PIPE_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PIPE_STATE: +- reason = "STATUS_INVALID_PIPE_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_BUSY: +- reason = "STATUS_PIPE_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_FUNCTION: +- reason = "STATUS_ILLEGAL_FUNCTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_DISCONNECTED: +- reason = "STATUS_PIPE_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_CLOSING: +- reason = "STATUS_PIPE_CLOSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_CONNECTED: +- reason = "STATUS_PIPE_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_LISTENING: +- reason = "STATUS_PIPE_LISTENING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_READ_MODE: +- reason = "STATUS_INVALID_READ_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_TIMEOUT: +- reason = "STATUS_IO_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_FORCED_CLOSED: +- reason = "STATUS_FILE_FORCED_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROFILING_NOT_STARTED: +- reason = "STATUS_PROFILING_NOT_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROFILING_NOT_STOPPED: +- reason = "STATUS_PROFILING_NOT_STOPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COULD_NOT_INTERPRET: +- reason = "STATUS_COULD_NOT_INTERPRET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_IS_A_DIRECTORY: +- reason = "STATUS_FILE_IS_A_DIRECTORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED: +- reason = "STATUS_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_NOT_LISTENING: +- reason = "STATUS_REMOTE_NOT_LISTENING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DUPLICATE_NAME: +- reason = "STATUS_DUPLICATE_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_NETWORK_PATH: +- reason = "STATUS_BAD_NETWORK_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_BUSY: +- reason = "STATUS_NETWORK_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_DOES_NOT_EXIST: +- reason = "STATUS_DEVICE_DOES_NOT_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_COMMANDS: +- reason = "STATUS_TOO_MANY_COMMANDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADAPTER_HARDWARE_ERROR: +- reason = "STATUS_ADAPTER_HARDWARE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_NETWORK_RESPONSE: +- reason = "STATUS_INVALID_NETWORK_RESPONSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNEXPECTED_NETWORK_ERROR: +- reason = "STATUS_UNEXPECTED_NETWORK_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_REMOTE_ADAPTER: +- reason = "STATUS_BAD_REMOTE_ADAPTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRINT_QUEUE_FULL: +- reason = "STATUS_PRINT_QUEUE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SPOOL_SPACE: +- reason = "STATUS_NO_SPOOL_SPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRINT_CANCELLED: +- reason = "STATUS_PRINT_CANCELLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_NAME_DELETED: +- reason = "STATUS_NETWORK_NAME_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED: +- reason = "STATUS_NETWORK_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_DEVICE_TYPE: +- reason = "STATUS_BAD_DEVICE_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_NETWORK_NAME: +- reason = "STATUS_BAD_NETWORK_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_NAMES: +- reason = "STATUS_TOO_MANY_NAMES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_SESSIONS: +- reason = "STATUS_TOO_MANY_SESSIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHARING_PAUSED: +- reason = "STATUS_SHARING_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REQUEST_NOT_ACCEPTED: +- reason = "STATUS_REQUEST_NOT_ACCEPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REDIRECTOR_PAUSED: +- reason = "STATUS_REDIRECTOR_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NET_WRITE_FAULT: +- reason = "STATUS_NET_WRITE_FAULT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROFILING_AT_LIMIT: +- reason = "STATUS_PROFILING_AT_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SAME_DEVICE: +- reason = "STATUS_NOT_SAME_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_RENAMED: +- reason = "STATUS_FILE_RENAMED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTUAL_CIRCUIT_CLOSED: +- reason = "STATUS_VIRTUAL_CIRCUIT_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SECURITY_ON_OBJECT: +- reason = "STATUS_NO_SECURITY_ON_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_WAIT: +- reason = "STATUS_CANT_WAIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_EMPTY: +- reason = "STATUS_PIPE_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_ACCESS_DOMAIN_INFO: +- reason = "STATUS_CANT_ACCESS_DOMAIN_INFO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_TERMINATE_SELF: +- reason = "STATUS_CANT_TERMINATE_SELF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SERVER_STATE: +- reason = "STATUS_INVALID_SERVER_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DOMAIN_STATE: +- reason = "STATUS_INVALID_DOMAIN_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DOMAIN_ROLE: +- reason = "STATUS_INVALID_DOMAIN_ROLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_DOMAIN: +- reason = "STATUS_NO_SUCH_DOMAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOMAIN_EXISTS: +- reason = "STATUS_DOMAIN_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOMAIN_LIMIT_EXCEEDED: +- reason = "STATUS_DOMAIN_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPLOCK_NOT_GRANTED: +- reason = "STATUS_OPLOCK_NOT_GRANTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_OPLOCK_PROTOCOL: +- reason = "STATUS_INVALID_OPLOCK_PROTOCOL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERNAL_DB_CORRUPTION: +- reason = "STATUS_INTERNAL_DB_CORRUPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERNAL_ERROR: +- reason = "STATUS_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GENERIC_NOT_MAPPED: +- reason = "STATUS_GENERIC_NOT_MAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_DESCRIPTOR_FORMAT: +- reason = "STATUS_BAD_DESCRIPTOR_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_USER_BUFFER: +- reason = "STATUS_INVALID_USER_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNEXPECTED_IO_ERROR: +- reason = "STATUS_UNEXPECTED_IO_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_CREATE_ERR: +- reason = "STATUS_UNEXPECTED_MM_CREATE_ERR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_MAP_ERROR: +- reason = "STATUS_UNEXPECTED_MM_MAP_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_EXTEND_ERR: +- reason = "STATUS_UNEXPECTED_MM_EXTEND_ERR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_LOGON_PROCESS: +- reason = "STATUS_NOT_LOGON_PROCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_SESSION_EXISTS: +- reason = "STATUS_LOGON_SESSION_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_1: +- reason = "STATUS_INVALID_PARAMETER_1"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_2: +- reason = "STATUS_INVALID_PARAMETER_2"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_3: +- reason = "STATUS_INVALID_PARAMETER_3"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_4: +- reason = "STATUS_INVALID_PARAMETER_4"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_5: +- reason = "STATUS_INVALID_PARAMETER_5"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_6: +- reason = "STATUS_INVALID_PARAMETER_6"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_7: +- reason = "STATUS_INVALID_PARAMETER_7"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_8: +- reason = "STATUS_INVALID_PARAMETER_8"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_9: +- reason = "STATUS_INVALID_PARAMETER_9"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_10: +- reason = "STATUS_INVALID_PARAMETER_10"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_11: +- reason = "STATUS_INVALID_PARAMETER_11"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_12: +- reason = "STATUS_INVALID_PARAMETER_12"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REDIRECTOR_NOT_STARTED: +- reason = "STATUS_REDIRECTOR_NOT_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REDIRECTOR_STARTED: +- reason = "STATUS_REDIRECTOR_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STACK_OVERFLOW: +- reason = "STATUS_STACK_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_PACKAGE: +- reason = "STATUS_NO_SUCH_PACKAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_FUNCTION_TABLE: +- reason = "STATUS_BAD_FUNCTION_TABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VARIABLE_NOT_FOUND: +- reason = "STATUS_VARIABLE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_EMPTY: +- reason = "STATUS_DIRECTORY_NOT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_CORRUPT_ERROR: +- reason = "STATUS_FILE_CORRUPT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_DIRECTORY: +- reason = "STATUS_NOT_A_DIRECTORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_LOGON_SESSION_STATE: +- reason = "STATUS_BAD_LOGON_SESSION_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_SESSION_COLLISION: +- reason = "STATUS_LOGON_SESSION_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NAME_TOO_LONG: +- reason = "STATUS_NAME_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILES_OPEN: +- reason = "STATUS_FILES_OPEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_IN_USE: +- reason = "STATUS_CONNECTION_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MESSAGE_NOT_FOUND: +- reason = "STATUS_MESSAGE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCESS_IS_TERMINATING: +- reason = "STATUS_PROCESS_IS_TERMINATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LOGON_TYPE: +- reason = "STATUS_INVALID_LOGON_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_GUID_TRANSLATION: +- reason = "STATUS_NO_GUID_TRANSLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_IMPERSONATE: +- reason = "STATUS_CANNOT_IMPERSONATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_ALREADY_LOADED: +- reason = "STATUS_IMAGE_ALREADY_LOADED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_NOT_PRESENT: +- reason = "STATUS_ABIOS_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_LID_NOT_EXIST: +- reason = "STATUS_ABIOS_LID_NOT_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_LID_ALREADY_OWNED: +- reason = "STATUS_ABIOS_LID_ALREADY_OWNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_NOT_LID_OWNER: +- reason = "STATUS_ABIOS_NOT_LID_OWNER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_COMMAND: +- reason = "STATUS_ABIOS_INVALID_COMMAND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_LID: +- reason = "STATUS_ABIOS_INVALID_LID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE: +- reason = "STATUS_ABIOS_SELECTOR_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_SELECTOR: +- reason = "STATUS_ABIOS_INVALID_SELECTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_LDT: +- reason = "STATUS_NO_LDT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LDT_SIZE: +- reason = "STATUS_INVALID_LDT_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LDT_OFFSET: +- reason = "STATUS_INVALID_LDT_OFFSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LDT_DESCRIPTOR: +- reason = "STATUS_INVALID_LDT_DESCRIPTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_NE_FORMAT: +- reason = "STATUS_INVALID_IMAGE_NE_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RXACT_INVALID_STATE: +- reason = "STATUS_RXACT_INVALID_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_FAILURE: +- reason = "STATUS_RXACT_COMMIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MAPPED_FILE_SIZE_ZERO: +- reason = "STATUS_MAPPED_FILE_SIZE_ZERO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_OPENED_FILES: +- reason = "STATUS_TOO_MANY_OPENED_FILES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANCELLED: +- reason = "STATUS_CANCELLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_DELETE: +- reason = "STATUS_CANNOT_DELETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_COMPUTER_NAME: +- reason = "STATUS_INVALID_COMPUTER_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_DELETED: +- reason = "STATUS_FILE_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPECIAL_ACCOUNT: +- reason = "STATUS_SPECIAL_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPECIAL_GROUP: +- reason = "STATUS_SPECIAL_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPECIAL_USER: +- reason = "STATUS_SPECIAL_USER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMBERS_PRIMARY_GROUP: +- reason = "STATUS_MEMBERS_PRIMARY_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_CLOSED: +- reason = "STATUS_FILE_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_THREADS: +- reason = "STATUS_TOO_MANY_THREADS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_NOT_IN_PROCESS: +- reason = "STATUS_THREAD_NOT_IN_PROCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOKEN_ALREADY_IN_USE: +- reason = "STATUS_TOKEN_ALREADY_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGEFILE_QUOTA_EXCEEDED: +- reason = "STATUS_PAGEFILE_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMMITMENT_LIMIT: +- reason = "STATUS_COMMITMENT_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_LE_FORMAT: +- reason = "STATUS_INVALID_IMAGE_LE_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_NOT_MZ: +- reason = "STATUS_INVALID_IMAGE_NOT_MZ"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_PROTECT: +- reason = "STATUS_INVALID_IMAGE_PROTECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_16: +- reason = "STATUS_INVALID_IMAGE_WIN_16"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_SERVER_CONFLICT: +- reason = "STATUS_LOGON_SERVER_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TIME_DIFFERENCE_AT_DC: +- reason = "STATUS_TIME_DIFFERENCE_AT_DC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYNCHRONIZATION_REQUIRED: +- reason = "STATUS_SYNCHRONIZATION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DLL_NOT_FOUND: +- reason = "STATUS_DLL_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPEN_FAILED: +- reason = "STATUS_OPEN_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_PRIVILEGE_FAILED: +- reason = "STATUS_IO_PRIVILEGE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ORDINAL_NOT_FOUND: +- reason = "STATUS_ORDINAL_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENTRYPOINT_NOT_FOUND: +- reason = "STATUS_ENTRYPOINT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTROL_C_EXIT: +- reason = "STATUS_CONTROL_C_EXIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOCAL_DISCONNECT: +- reason = "STATUS_LOCAL_DISCONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_DISCONNECT: +- reason = "STATUS_REMOTE_DISCONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_RESOURCES: +- reason = "STATUS_REMOTE_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LINK_FAILED: +- reason = "STATUS_LINK_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LINK_TIMEOUT: +- reason = "STATUS_LINK_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_CONNECTION: +- reason = "STATUS_INVALID_CONNECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS: +- reason = "STATUS_INVALID_ADDRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DLL_INIT_FAILED: +- reason = "STATUS_DLL_INIT_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MISSING_SYSTEMFILE: +- reason = "STATUS_MISSING_SYSTEMFILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNHANDLED_EXCEPTION: +- reason = "STATUS_UNHANDLED_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_INIT_FAILURE: +- reason = "STATUS_APP_INIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PAGEFILE_CREATE_FAILED: +- reason = "STATUS_PAGEFILE_CREATE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_PAGEFILE: +- reason = "STATUS_NO_PAGEFILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LEVEL: +- reason = "STATUS_INVALID_LEVEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_PASSWORD_CORE: +- reason = "STATUS_WRONG_PASSWORD_CORE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_FLOAT_CONTEXT: +- reason = "STATUS_ILLEGAL_FLOAT_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PIPE_BROKEN: +- reason = "STATUS_PIPE_BROKEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REGISTRY_CORRUPT: +- reason = "STATUS_REGISTRY_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REGISTRY_IO_FAILED: +- reason = "STATUS_REGISTRY_IO_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_EVENT_PAIR: +- reason = "STATUS_NO_EVENT_PAIR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNRECOGNIZED_VOLUME: +- reason = "STATUS_UNRECOGNIZED_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERIAL_NO_DEVICE_INITED: +- reason = "STATUS_SERIAL_NO_DEVICE_INITED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_ALIAS: +- reason = "STATUS_NO_SUCH_ALIAS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMBER_NOT_IN_ALIAS: +- reason = "STATUS_MEMBER_NOT_IN_ALIAS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MEMBER_IN_ALIAS: +- reason = "STATUS_MEMBER_IN_ALIAS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALIAS_EXISTS: +- reason = "STATUS_ALIAS_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_NOT_GRANTED: +- reason = "STATUS_LOGON_NOT_GRANTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_SECRETS: +- reason = "STATUS_TOO_MANY_SECRETS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECRET_TOO_LONG: +- reason = "STATUS_SECRET_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERNAL_DB_ERROR: +- reason = "STATUS_INTERNAL_DB_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FULLSCREEN_MODE: +- reason = "STATUS_FULLSCREEN_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_CONTEXT_IDS: +- reason = "STATUS_TOO_MANY_CONTEXT_IDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGON_TYPE_NOT_GRANTED: +- reason = "STATUS_LOGON_TYPE_NOT_GRANTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_REGISTRY_FILE: +- reason = "STATUS_NOT_REGISTRY_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NT_CROSS_ENCRYPTION_REQUIRED: +- reason = "STATUS_NT_CROSS_ENCRYPTION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOMAIN_CTRLR_CONFIG_ERROR: +- reason = "STATUS_DOMAIN_CTRLR_CONFIG_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_MISSING_MEMBER: +- reason = "STATUS_FT_MISSING_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILL_FORMED_SERVICE_ENTRY: +- reason = "STATUS_ILL_FORMED_SERVICE_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_CHARACTER: +- reason = "STATUS_ILLEGAL_CHARACTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNMAPPABLE_CHARACTER: +- reason = "STATUS_UNMAPPABLE_CHARACTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNDEFINED_CHARACTER: +- reason = "STATUS_UNDEFINED_CHARACTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOPPY_VOLUME: +- reason = "STATUS_FLOPPY_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOPPY_ID_MARK_NOT_FOUND: +- reason = "STATUS_FLOPPY_ID_MARK_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOPPY_WRONG_CYLINDER: +- reason = "STATUS_FLOPPY_WRONG_CYLINDER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOPPY_UNKNOWN_ERROR: +- reason = "STATUS_FLOPPY_UNKNOWN_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOPPY_BAD_REGISTERS: +- reason = "STATUS_FLOPPY_BAD_REGISTERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_RECALIBRATE_FAILED: +- reason = "STATUS_DISK_RECALIBRATE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_OPERATION_FAILED: +- reason = "STATUS_DISK_OPERATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_RESET_FAILED: +- reason = "STATUS_DISK_RESET_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHARED_IRQ_BUSY: +- reason = "STATUS_SHARED_IRQ_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_ORPHANING: +- reason = "STATUS_FT_ORPHANING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT: +- reason = "STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PARTITION_FAILURE: +- reason = "STATUS_PARTITION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_BLOCK_LENGTH: +- reason = "STATUS_INVALID_BLOCK_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_PARTITIONED: +- reason = "STATUS_DEVICE_NOT_PARTITIONED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNABLE_TO_LOCK_MEDIA: +- reason = "STATUS_UNABLE_TO_LOCK_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNABLE_TO_UNLOAD_MEDIA: +- reason = "STATUS_UNABLE_TO_UNLOAD_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EOM_OVERFLOW: +- reason = "STATUS_EOM_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MEDIA: +- reason = "STATUS_NO_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SUCH_MEMBER: +- reason = "STATUS_NO_SUCH_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_MEMBER: +- reason = "STATUS_INVALID_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KEY_DELETED: +- reason = "STATUS_KEY_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_LOG_SPACE: +- reason = "STATUS_NO_LOG_SPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_SIDS: +- reason = "STATUS_TOO_MANY_SIDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LM_CROSS_ENCRYPTION_REQUIRED: +- reason = "STATUS_LM_CROSS_ENCRYPTION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KEY_HAS_CHILDREN: +- reason = "STATUS_KEY_HAS_CHILDREN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CHILD_MUST_BE_VOLATILE: +- reason = "STATUS_CHILD_MUST_BE_VOLATILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_CONFIGURATION_ERROR: +- reason = "STATUS_DEVICE_CONFIGURATION_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_INTERNAL_ERROR: +- reason = "STATUS_DRIVER_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_STATE: +- reason = "STATUS_INVALID_DEVICE_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_DEVICE_ERROR: +- reason = "STATUS_IO_DEVICE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_PROTOCOL_ERROR: +- reason = "STATUS_DEVICE_PROTOCOL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BACKUP_CONTROLLER: +- reason = "STATUS_BACKUP_CONTROLLER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_FILE_FULL: +- reason = "STATUS_LOG_FILE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_LATE: +- reason = "STATUS_TOO_LATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TRUST_LSA_SECRET: +- reason = "STATUS_NO_TRUST_LSA_SECRET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TRUST_SAM_ACCOUNT: +- reason = "STATUS_NO_TRUST_SAM_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRUSTED_DOMAIN_FAILURE: +- reason = "STATUS_TRUSTED_DOMAIN_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRUSTED_RELATIONSHIP_FAILURE: +- reason = "STATUS_TRUSTED_RELATIONSHIP_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVENTLOG_FILE_CORRUPT: +- reason = "STATUS_EVENTLOG_FILE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVENTLOG_CANT_START: +- reason = "STATUS_EVENTLOG_CANT_START"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRUST_FAILURE: +- reason = "STATUS_TRUST_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUTANT_LIMIT_EXCEEDED: +- reason = "STATUS_MUTANT_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETLOGON_NOT_STARTED: +- reason = "STATUS_NETLOGON_NOT_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCOUNT_EXPIRED: +- reason = "STATUS_ACCOUNT_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_POSSIBLE_DEADLOCK: +- reason = "STATUS_POSSIBLE_DEADLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_CREDENTIAL_CONFLICT: +- reason = "STATUS_NETWORK_CREDENTIAL_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_SESSION_LIMIT: +- reason = "STATUS_REMOTE_SESSION_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVENTLOG_FILE_CHANGED: +- reason = "STATUS_EVENTLOG_FILE_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: +- reason = "STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT: +- reason = "STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT: +- reason = "STATUS_NOLOGON_SERVER_TRUST_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOMAIN_TRUST_INCONSISTENT: +- reason = "STATUS_DOMAIN_TRUST_INCONSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FS_DRIVER_REQUIRED: +- reason = "STATUS_FS_DRIVER_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_ALREADY_LOADED_AS_DLL: +- reason = "STATUS_IMAGE_ALREADY_LOADED_AS_DLL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING: +- reason = "STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME: +- reason = "STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECURITY_STREAM_IS_INCONSISTENT: +- reason = "STATUS_SECURITY_STREAM_IS_INCONSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LOCK_RANGE: +- reason = "STATUS_INVALID_LOCK_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ACE_CONDITION: +- reason = "STATUS_INVALID_ACE_CONDITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT: +- reason = "STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOTIFICATION_GUID_ALREADY_DEFINED: +- reason = "STATUS_NOTIFICATION_GUID_ALREADY_DEFINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_EXCEPTION_HANDLER: +- reason = "STATUS_INVALID_EXCEPTION_HANDLER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DUPLICATE_PRIVILEGES: +- reason = "STATUS_DUPLICATE_PRIVILEGES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_ALLOWED_ON_SYSTEM_FILE: +- reason = "STATUS_NOT_ALLOWED_ON_SYSTEM_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPAIR_NEEDED: +- reason = "STATUS_REPAIR_NEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUOTA_NOT_ENABLED: +- reason = "STATUS_QUOTA_NOT_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_APPLICATION_PACKAGE: +- reason = "STATUS_NO_APPLICATION_PACKAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS: +- reason = "STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SAME_OBJECT: +- reason = "STATUS_NOT_SAME_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FATAL_MEMORY_EXHAUSTION: +- reason = "STATUS_FATAL_MEMORY_EXHAUSTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ERROR_PROCESS_NOT_IN_JOB: +- reason = "STATUS_ERROR_PROCESS_NOT_IN_JOB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CPU_SET_INVALID: +- reason = "STATUS_CPU_SET_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_DEVICE_INVALID_DATA: +- reason = "STATUS_IO_DEVICE_INVALID_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_UNALIGNED_WRITE: +- reason = "STATUS_IO_UNALIGNED_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTROL_STACK_VIOLATION: +- reason = "STATUS_CONTROL_STACK_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_OPEN_RESTRICTION: +- reason = "STATUS_NETWORK_OPEN_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_USER_SESSION_KEY: +- reason = "STATUS_NO_USER_SESSION_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER_SESSION_DELETED: +- reason = "STATUS_USER_SESSION_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_LANG_NOT_FOUND: +- reason = "STATUS_RESOURCE_LANG_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFF_SERVER_RESOURCES: +- reason = "STATUS_INSUFF_SERVER_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_BUFFER_SIZE: +- reason = "STATUS_INVALID_BUFFER_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_COMPONENT: +- reason = "STATUS_INVALID_ADDRESS_COMPONENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_WILDCARD: +- reason = "STATUS_INVALID_ADDRESS_WILDCARD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_ADDRESSES: +- reason = "STATUS_TOO_MANY_ADDRESSES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADDRESS_ALREADY_EXISTS: +- reason = "STATUS_ADDRESS_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADDRESS_CLOSED: +- reason = "STATUS_ADDRESS_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_DISCONNECTED: +- reason = "STATUS_CONNECTION_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_RESET: +- reason = "STATUS_CONNECTION_RESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_NODES: +- reason = "STATUS_TOO_MANY_NODES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_ABORTED: +- reason = "STATUS_TRANSACTION_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_TIMED_OUT: +- reason = "STATUS_TRANSACTION_TIMED_OUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_RELEASE: +- reason = "STATUS_TRANSACTION_NO_RELEASE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_MATCH: +- reason = "STATUS_TRANSACTION_NO_MATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_RESPONDED: +- reason = "STATUS_TRANSACTION_RESPONDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_ID: +- reason = "STATUS_TRANSACTION_INVALID_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_TYPE: +- reason = "STATUS_TRANSACTION_INVALID_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SERVER_SESSION: +- reason = "STATUS_NOT_SERVER_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_CLIENT_SESSION: +- reason = "STATUS_NOT_CLIENT_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_LOAD_REGISTRY_FILE: +- reason = "STATUS_CANNOT_LOAD_REGISTRY_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEBUG_ATTACH_FAILED: +- reason = "STATUS_DEBUG_ATTACH_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_PROCESS_TERMINATED: +- reason = "STATUS_SYSTEM_PROCESS_TERMINATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_NOT_ACCEPTED: +- reason = "STATUS_DATA_NOT_ACCEPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_BROWSER_SERVERS_FOUND: +- reason = "STATUS_NO_BROWSER_SERVERS_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VDM_HARD_ERROR: +- reason = "STATUS_VDM_HARD_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_CANCEL_TIMEOUT: +- reason = "STATUS_DRIVER_CANCEL_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPLY_MESSAGE_MISMATCH: +- reason = "STATUS_REPLY_MESSAGE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MAPPED_ALIGNMENT: +- reason = "STATUS_MAPPED_ALIGNMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_CHECKSUM_MISMATCH: +- reason = "STATUS_IMAGE_CHECKSUM_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA: +- reason = "STATUS_LOST_WRITEBEHIND_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIENT_SERVER_PARAMETERS_INVALID: +- reason = "STATUS_CLIENT_SERVER_PARAMETERS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PASSWORD_MUST_CHANGE: +- reason = "STATUS_PASSWORD_MUST_CHANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_FOUND: +- reason = "STATUS_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_TINY_STREAM: +- reason = "STATUS_NOT_TINY_STREAM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECOVERY_FAILURE: +- reason = "STATUS_RECOVERY_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STACK_OVERFLOW_READ: +- reason = "STATUS_STACK_OVERFLOW_READ"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FAIL_CHECK: +- reason = "STATUS_FAIL_CHECK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DUPLICATE_OBJECTID: +- reason = "STATUS_DUPLICATE_OBJECTID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECTID_EXISTS: +- reason = "STATUS_OBJECTID_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONVERT_TO_LARGE: +- reason = "STATUS_CONVERT_TO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RETRY: +- reason = "STATUS_RETRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FOUND_OUT_OF_SCOPE: +- reason = "STATUS_FOUND_OUT_OF_SCOPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALLOCATE_BUCKET: +- reason = "STATUS_ALLOCATE_BUCKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROPSET_NOT_FOUND: +- reason = "STATUS_PROPSET_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MARSHALL_OVERFLOW: +- reason = "STATUS_MARSHALL_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_VARIANT: +- reason = "STATUS_INVALID_VARIANT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOMAIN_CONTROLLER_NOT_FOUND: +- reason = "STATUS_DOMAIN_CONTROLLER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCOUNT_LOCKED_OUT: +- reason = "STATUS_ACCOUNT_LOCKED_OUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HANDLE_NOT_CLOSABLE: +- reason = "STATUS_HANDLE_NOT_CLOSABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_REFUSED: +- reason = "STATUS_CONNECTION_REFUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRACEFUL_DISCONNECT: +- reason = "STATUS_GRACEFUL_DISCONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADDRESS_ALREADY_ASSOCIATED: +- reason = "STATUS_ADDRESS_ALREADY_ASSOCIATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADDRESS_NOT_ASSOCIATED: +- reason = "STATUS_ADDRESS_NOT_ASSOCIATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_INVALID: +- reason = "STATUS_CONNECTION_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_ACTIVE: +- reason = "STATUS_CONNECTION_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_UNREACHABLE: +- reason = "STATUS_NETWORK_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HOST_UNREACHABLE: +- reason = "STATUS_HOST_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROTOCOL_UNREACHABLE: +- reason = "STATUS_PROTOCOL_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_UNREACHABLE: +- reason = "STATUS_PORT_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REQUEST_ABORTED: +- reason = "STATUS_REQUEST_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_ABORTED: +- reason = "STATUS_CONNECTION_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_COMPRESSION_BUFFER: +- reason = "STATUS_BAD_COMPRESSION_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER_MAPPED_FILE: +- reason = "STATUS_USER_MAPPED_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUDIT_FAILED: +- reason = "STATUS_AUDIT_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TIMER_RESOLUTION_NOT_SET: +- reason = "STATUS_TIMER_RESOLUTION_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONNECTION_COUNT_LIMIT: +- reason = "STATUS_CONNECTION_COUNT_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGIN_TIME_RESTRICTION: +- reason = "STATUS_LOGIN_TIME_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOGIN_WKSTA_RESTRICTION: +- reason = "STATUS_LOGIN_WKSTA_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_MP_UP_MISMATCH: +- reason = "STATUS_IMAGE_MP_UP_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_LOGON_INFO: +- reason = "STATUS_INSUFFICIENT_LOGON_INFO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_DLL_ENTRYPOINT: +- reason = "STATUS_BAD_DLL_ENTRYPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_SERVICE_ENTRYPOINT: +- reason = "STATUS_BAD_SERVICE_ENTRYPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPC_REPLY_LOST: +- reason = "STATUS_LPC_REPLY_LOST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IP_ADDRESS_CONFLICT1: +- reason = "STATUS_IP_ADDRESS_CONFLICT1"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IP_ADDRESS_CONFLICT2: +- reason = "STATUS_IP_ADDRESS_CONFLICT2"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REGISTRY_QUOTA_LIMIT: +- reason = "STATUS_REGISTRY_QUOTA_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PATH_NOT_COVERED: +- reason = "STATUS_PATH_NOT_COVERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_CALLBACK_ACTIVE: +- reason = "STATUS_NO_CALLBACK_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LICENSE_QUOTA_EXCEEDED: +- reason = "STATUS_LICENSE_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PWD_TOO_SHORT: +- reason = "STATUS_PWD_TOO_SHORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PWD_TOO_RECENT: +- reason = "STATUS_PWD_TOO_RECENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PWD_HISTORY_CONFLICT: +- reason = "STATUS_PWD_HISTORY_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLUGPLAY_NO_DEVICE: +- reason = "STATUS_PLUGPLAY_NO_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNSUPPORTED_COMPRESSION: +- reason = "STATUS_UNSUPPORTED_COMPRESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_HW_PROFILE: +- reason = "STATUS_INVALID_HW_PROFILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PLUGPLAY_DEVICE_PATH: +- reason = "STATUS_INVALID_PLUGPLAY_DEVICE_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_ORDINAL_NOT_FOUND: +- reason = "STATUS_DRIVER_ORDINAL_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND: +- reason = "STATUS_DRIVER_ENTRYPOINT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_NOT_OWNED: +- reason = "STATUS_RESOURCE_NOT_OWNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_LINKS: +- reason = "STATUS_TOO_MANY_LINKS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUOTA_LIST_INCONSISTENT: +- reason = "STATUS_QUOTA_LIST_INCONSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_IS_OFFLINE: +- reason = "STATUS_FILE_IS_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EVALUATION_EXPIRATION: +- reason = "STATUS_EVALUATION_EXPIRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_DLL_RELOCATION: +- reason = "STATUS_ILLEGAL_DLL_RELOCATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LICENSE_VIOLATION: +- reason = "STATUS_LICENSE_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DLL_INIT_FAILED_LOGOFF: +- reason = "STATUS_DLL_INIT_FAILED_LOGOFF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_UNABLE_TO_LOAD: +- reason = "STATUS_DRIVER_UNABLE_TO_LOAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DFS_UNAVAILABLE: +- reason = "STATUS_DFS_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLUME_DISMOUNTED: +- reason = "STATUS_VOLUME_DISMOUNTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_INTERNAL_ERROR: +- reason = "STATUS_WX86_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WX86_FLOAT_STACK_CHECK: +- reason = "STATUS_WX86_FLOAT_STACK_CHECK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VALIDATE_CONTINUE: +- reason = "STATUS_VALIDATE_CONTINUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MATCH: +- reason = "STATUS_NO_MATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_MORE_MATCHES: +- reason = "STATUS_NO_MORE_MATCHES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_REPARSE_POINT: +- reason = "STATUS_NOT_A_REPARSE_POINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_INVALID: +- reason = "STATUS_IO_REPARSE_TAG_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_MISMATCH: +- reason = "STATUS_IO_REPARSE_TAG_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_REPARSE_DATA_INVALID: +- reason = "STATUS_IO_REPARSE_DATA_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_NOT_HANDLED: +- reason = "STATUS_IO_REPARSE_TAG_NOT_HANDLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PWD_TOO_LONG: +- reason = "STATUS_PWD_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STOWED_EXCEPTION: +- reason = "STATUS_STOWED_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTEXT_STOWED_EXCEPTION: +- reason = "STATUS_CONTEXT_STOWED_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_NOT_RESOLVED: +- reason = "STATUS_REPARSE_POINT_NOT_RESOLVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DIRECTORY_IS_A_REPARSE_POINT: +- reason = "STATUS_DIRECTORY_IS_A_REPARSE_POINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RANGE_LIST_CONFLICT: +- reason = "STATUS_RANGE_LIST_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SOURCE_ELEMENT_EMPTY: +- reason = "STATUS_SOURCE_ELEMENT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DESTINATION_ELEMENT_FULL: +- reason = "STATUS_DESTINATION_ELEMENT_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ILLEGAL_ELEMENT_ADDRESS: +- reason = "STATUS_ILLEGAL_ELEMENT_ADDRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MAGAZINE_NOT_PRESENT: +- reason = "STATUS_MAGAZINE_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REINITIALIZATION_NEEDED: +- reason = "STATUS_REINITIALIZATION_NEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCRYPTION_FAILED: +- reason = "STATUS_ENCRYPTION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DECRYPTION_FAILED: +- reason = "STATUS_DECRYPTION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RANGE_NOT_FOUND: +- reason = "STATUS_RANGE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_RECOVERY_POLICY: +- reason = "STATUS_NO_RECOVERY_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_EFS: +- reason = "STATUS_NO_EFS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_EFS: +- reason = "STATUS_WRONG_EFS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_USER_KEYS: +- reason = "STATUS_NO_USER_KEYS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_NOT_ENCRYPTED: +- reason = "STATUS_FILE_NOT_ENCRYPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_EXPORT_FORMAT: +- reason = "STATUS_NOT_EXPORT_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_ENCRYPTED: +- reason = "STATUS_FILE_ENCRYPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_GUID_NOT_FOUND: +- reason = "STATUS_WMI_GUID_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_INSTANCE_NOT_FOUND: +- reason = "STATUS_WMI_INSTANCE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_ITEMID_NOT_FOUND: +- reason = "STATUS_WMI_ITEMID_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_TRY_AGAIN: +- reason = "STATUS_WMI_TRY_AGAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHARED_POLICY: +- reason = "STATUS_SHARED_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_POLICY_OBJECT_NOT_FOUND: +- reason = "STATUS_POLICY_OBJECT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_POLICY_ONLY_IN_DS: +- reason = "STATUS_POLICY_ONLY_IN_DS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_UPGRADED: +- reason = "STATUS_VOLUME_NOT_UPGRADED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_STORAGE_NOT_ACTIVE: +- reason = "STATUS_REMOTE_STORAGE_NOT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_STORAGE_MEDIA_ERROR: +- reason = "STATUS_REMOTE_STORAGE_MEDIA_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TRACKING_SERVICE: +- reason = "STATUS_NO_TRACKING_SERVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_SID_MISMATCH: +- reason = "STATUS_SERVER_SID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_ATTRIBUTE_OR_VALUE: +- reason = "STATUS_DS_NO_ATTRIBUTE_OR_VALUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_INVALID_ATTRIBUTE_SYNTAX: +- reason = "STATUS_DS_INVALID_ATTRIBUTE_SYNTAX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED: +- reason = "STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS: +- reason = "STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_BUSY: +- reason = "STATUS_DS_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_UNAVAILABLE: +- reason = "STATUS_DS_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_RIDS_ALLOCATED: +- reason = "STATUS_DS_NO_RIDS_ALLOCATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_MORE_RIDS: +- reason = "STATUS_DS_NO_MORE_RIDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_INCORRECT_ROLE_OWNER: +- reason = "STATUS_DS_INCORRECT_ROLE_OWNER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_RIDMGR_INIT_ERROR: +- reason = "STATUS_DS_RIDMGR_INIT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_OBJ_CLASS_VIOLATION: +- reason = "STATUS_DS_OBJ_CLASS_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CANT_ON_NON_LEAF: +- reason = "STATUS_DS_CANT_ON_NON_LEAF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CANT_ON_RDN: +- reason = "STATUS_DS_CANT_ON_RDN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CANT_MOD_OBJ_CLASS: +- reason = "STATUS_DS_CANT_MOD_OBJ_CLASS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CROSS_DOM_MOVE_FAILED: +- reason = "STATUS_DS_CROSS_DOM_MOVE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GC_NOT_AVAILABLE: +- reason = "STATUS_DS_GC_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DIRECTORY_SERVICE_REQUIRED: +- reason = "STATUS_DIRECTORY_SERVICE_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE_ATTRIBUTE_CONFLICT: +- reason = "STATUS_REPARSE_ATTRIBUTE_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_ENABLE_DENY_ONLY: +- reason = "STATUS_CANT_ENABLE_DENY_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_MULTIPLE_FAULTS: +- reason = "STATUS_FLOAT_MULTIPLE_FAULTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOAT_MULTIPLE_TRAPS: +- reason = "STATUS_FLOAT_MULTIPLE_TRAPS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_REMOVED: +- reason = "STATUS_DEVICE_REMOVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_JOURNAL_DELETE_IN_PROGRESS: +- reason = "STATUS_JOURNAL_DELETE_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_JOURNAL_NOT_ACTIVE: +- reason = "STATUS_JOURNAL_NOT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOINTERFACE: +- reason = "STATUS_NOINTERFACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_RIDMGR_DISABLED: +- reason = "STATUS_DS_RIDMGR_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_ADMIN_LIMIT_EXCEEDED: +- reason = "STATUS_DS_ADMIN_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_FAILED_SLEEP: +- reason = "STATUS_DRIVER_FAILED_SLEEP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUTUAL_AUTHENTICATION_FAILED: +- reason = "STATUS_MUTUAL_AUTHENTICATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_SYSTEM_FILE: +- reason = "STATUS_CORRUPT_SYSTEM_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT_ERROR: +- reason = "STATUS_DATATYPE_MISALIGNMENT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_READ_ONLY: +- reason = "STATUS_WMI_READ_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_SET_FAILURE: +- reason = "STATUS_WMI_SET_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMMITMENT_MINIMUM: +- reason = "STATUS_COMMITMENT_MINIMUM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REG_NAT_CONSUMPTION: +- reason = "STATUS_REG_NAT_CONSUMPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSPORT_FULL: +- reason = "STATUS_TRANSPORT_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_SAM_INIT_FAILURE: +- reason = "STATUS_DS_SAM_INIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ONLY_IF_CONNECTED: +- reason = "STATUS_ONLY_IF_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_SENSITIVE_GROUP_VIOLATION: +- reason = "STATUS_DS_SENSITIVE_GROUP_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_RESTART_ENUMERATION: +- reason = "STATUS_PNP_RESTART_ENUMERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_JOURNAL_ENTRY_DELETED: +- reason = "STATUS_JOURNAL_ENTRY_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CANT_MOD_PRIMARYGROUPID: +- reason = "STATUS_DS_CANT_MOD_PRIMARYGROUPID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_IMAGE_BAD_SIGNATURE: +- reason = "STATUS_SYSTEM_IMAGE_BAD_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_REBOOT_REQUIRED: +- reason = "STATUS_PNP_REBOOT_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_POWER_STATE_INVALID: +- reason = "STATUS_POWER_STATE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_INVALID_GROUP_TYPE: +- reason = "STATUS_DS_INVALID_GROUP_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: +- reason = "STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: +- reason = "STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: +- reason = "STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: +- reason = "STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: +- reason = "STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: +- reason = "STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: +- reason = "STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_HAVE_PRIMARY_MEMBERS: +- reason = "STATUS_DS_HAVE_PRIMARY_MEMBERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_NOT_SUPPORTED: +- reason = "STATUS_WMI_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_POWER: +- reason = "STATUS_INSUFFICIENT_POWER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SAM_NEED_BOOTKEY_PASSWORD: +- reason = "STATUS_SAM_NEED_BOOTKEY_PASSWORD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SAM_NEED_BOOTKEY_FLOPPY: +- reason = "STATUS_SAM_NEED_BOOTKEY_FLOPPY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_CANT_START: +- reason = "STATUS_DS_CANT_START"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_INIT_FAILURE: +- reason = "STATUS_DS_INIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SAM_INIT_FAILURE: +- reason = "STATUS_SAM_INIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GC_REQUIRED: +- reason = "STATUS_DS_GC_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: +- reason = "STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS: +- reason = "STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: +- reason = "STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MULTIPLE_FAULT_VIOLATION: +- reason = "STATUS_MULTIPLE_FAULT_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CURRENT_DOMAIN_NOT_ALLOWED: +- reason = "STATUS_CURRENT_DOMAIN_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_MAKE: +- reason = "STATUS_CANNOT_MAKE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_SHUTDOWN: +- reason = "STATUS_SYSTEM_SHUTDOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_INIT_FAILURE_CONSOLE: +- reason = "STATUS_DS_INIT_FAILURE_CONSOLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_SAM_INIT_FAILURE_CONSOLE: +- reason = "STATUS_DS_SAM_INIT_FAILURE_CONSOLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNFINISHED_CONTEXT_DELETED: +- reason = "STATUS_UNFINISHED_CONTEXT_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_TGT_REPLY: +- reason = "STATUS_NO_TGT_REPLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECTID_NOT_FOUND: +- reason = "STATUS_OBJECTID_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_IP_ADDRESSES: +- reason = "STATUS_NO_IP_ADDRESSES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_CREDENTIAL_HANDLE: +- reason = "STATUS_WRONG_CREDENTIAL_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRYPTO_SYSTEM_INVALID: +- reason = "STATUS_CRYPTO_SYSTEM_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MAX_REFERRALS_EXCEEDED: +- reason = "STATUS_MAX_REFERRALS_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUST_BE_KDC: +- reason = "STATUS_MUST_BE_KDC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STRONG_CRYPTO_NOT_SUPPORTED: +- reason = "STATUS_STRONG_CRYPTO_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_PRINCIPALS: +- reason = "STATUS_TOO_MANY_PRINCIPALS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_PA_DATA: +- reason = "STATUS_NO_PA_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PKINIT_NAME_MISMATCH: +- reason = "STATUS_PKINIT_NAME_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_LOGON_REQUIRED: +- reason = "STATUS_SMARTCARD_LOGON_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KDC_INVALID_REQUEST: +- reason = "STATUS_KDC_INVALID_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KDC_UNABLE_TO_REFER: +- reason = "STATUS_KDC_UNABLE_TO_REFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KDC_UNKNOWN_ETYPE: +- reason = "STATUS_KDC_UNKNOWN_ETYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHUTDOWN_IN_PROGRESS: +- reason = "STATUS_SHUTDOWN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_SHUTDOWN_IN_PROGRESS: +- reason = "STATUS_SERVER_SHUTDOWN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_SBS: +- reason = "STATUS_NOT_SUPPORTED_ON_SBS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_GUID_DISCONNECTED: +- reason = "STATUS_WMI_GUID_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_ALREADY_DISABLED: +- reason = "STATUS_WMI_ALREADY_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WMI_ALREADY_ENABLED: +- reason = "STATUS_WMI_ALREADY_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MFT_TOO_FRAGMENTED: +- reason = "STATUS_MFT_TOO_FRAGMENTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COPY_PROTECTION_FAILURE: +- reason = "STATUS_COPY_PROTECTION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_AUTHENTICATION_FAILURE: +- reason = "STATUS_CSS_AUTHENTICATION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_PRESENT: +- reason = "STATUS_CSS_KEY_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_ESTABLISHED: +- reason = "STATUS_CSS_KEY_NOT_ESTABLISHED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_SCRAMBLED_SECTOR: +- reason = "STATUS_CSS_SCRAMBLED_SECTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_REGION_MISMATCH: +- reason = "STATUS_CSS_REGION_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSS_RESETS_EXHAUSTED: +- reason = "STATUS_CSS_RESETS_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PASSWORD_CHANGE_REQUIRED: +- reason = "STATUS_PASSWORD_CHANGE_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOST_MODE_LOGON_RESTRICTION: +- reason = "STATUS_LOST_MODE_LOGON_RESTRICTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PKINIT_FAILURE: +- reason = "STATUS_PKINIT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_SUBSYSTEM_FAILURE: +- reason = "STATUS_SMARTCARD_SUBSYSTEM_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_KERB_KEY: +- reason = "STATUS_NO_KERB_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HOST_DOWN: +- reason = "STATUS_HOST_DOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNSUPPORTED_PREAUTH: +- reason = "STATUS_UNSUPPORTED_PREAUTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EFS_ALG_BLOB_TOO_BIG: +- reason = "STATUS_EFS_ALG_BLOB_TOO_BIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_NOT_SET: +- reason = "STATUS_PORT_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEBUGGER_INACTIVE: +- reason = "STATUS_DEBUGGER_INACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_VERSION_CHECK_FAILURE: +- reason = "STATUS_DS_VERSION_CHECK_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUDITING_DISABLED: +- reason = "STATUS_AUDITING_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PRENT4_MACHINE_ACCOUNT: +- reason = "STATUS_PRENT4_MACHINE_ACCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: +- reason = "STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_32: +- reason = "STATUS_INVALID_IMAGE_WIN_32"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_64: +- reason = "STATUS_INVALID_IMAGE_WIN_64"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_BINDINGS: +- reason = "STATUS_BAD_BINDINGS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_SESSION_EXPIRED: +- reason = "STATUS_NETWORK_SESSION_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPHELP_BLOCK: +- reason = "STATUS_APPHELP_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALL_SIDS_FILTERED: +- reason = "STATUS_ALL_SIDS_FILTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SAFE_MODE_DRIVER: +- reason = "STATUS_NOT_SAFE_MODE_DRIVER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT: +- reason = "STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_PATH: +- reason = "STATUS_ACCESS_DISABLED_BY_POLICY_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER: +- reason = "STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_OTHER: +- reason = "STATUS_ACCESS_DISABLED_BY_POLICY_OTHER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FAILED_DRIVER_ENTRY: +- reason = "STATUS_FAILED_DRIVER_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_ENUMERATION_ERROR: +- reason = "STATUS_DEVICE_ENUMERATION_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MOUNT_POINT_NOT_RESOLVED: +- reason = "STATUS_MOUNT_POINT_NOT_RESOLVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_OBJECT_PARAMETER: +- reason = "STATUS_INVALID_DEVICE_OBJECT_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MCA_OCCURED: +- reason = "STATUS_MCA_OCCURED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_BLOCKED_CRITICAL: +- reason = "STATUS_DRIVER_BLOCKED_CRITICAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_BLOCKED: +- reason = "STATUS_DRIVER_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_DATABASE_ERROR: +- reason = "STATUS_DRIVER_DATABASE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_HIVE_TOO_LARGE: +- reason = "STATUS_SYSTEM_HIVE_TOO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMPORT_OF_NON_DLL: +- reason = "STATUS_INVALID_IMPORT_OF_NON_DLL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SECRETS: +- reason = "STATUS_NO_SECRETS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY: +- reason = "STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FAILED_STACK_SWITCH: +- reason = "STATUS_FAILED_STACK_SWITCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HEAP_CORRUPTION: +- reason = "STATUS_HEAP_CORRUPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_WRONG_PIN: +- reason = "STATUS_SMARTCARD_WRONG_PIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_CARD_BLOCKED: +- reason = "STATUS_SMARTCARD_CARD_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED: +- reason = "STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_CARD: +- reason = "STATUS_SMARTCARD_NO_CARD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_KEY_CONTAINER: +- reason = "STATUS_SMARTCARD_NO_KEY_CONTAINER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_CERTIFICATE: +- reason = "STATUS_SMARTCARD_NO_CERTIFICATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_KEYSET: +- reason = "STATUS_SMARTCARD_NO_KEYSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_IO_ERROR: +- reason = "STATUS_SMARTCARD_IO_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DOWNGRADE_DETECTED: +- reason = "STATUS_DOWNGRADE_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_CERT_REVOKED: +- reason = "STATUS_SMARTCARD_CERT_REVOKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ISSUING_CA_UNTRUSTED: +- reason = "STATUS_ISSUING_CA_UNTRUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REVOCATION_OFFLINE_C: +- reason = "STATUS_REVOCATION_OFFLINE_C"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PKINIT_CLIENT_FAILURE: +- reason = "STATUS_PKINIT_CLIENT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_CERT_EXPIRED: +- reason = "STATUS_SMARTCARD_CERT_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_FAILED_PRIOR_UNLOAD: +- reason = "STATUS_DRIVER_FAILED_PRIOR_UNLOAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMARTCARD_SILENT_CONTEXT: +- reason = "STATUS_SMARTCARD_SILENT_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PER_USER_TRUST_QUOTA_EXCEEDED: +- reason = "STATUS_PER_USER_TRUST_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED: +- reason = "STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED: +- reason = "STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_NAME_NOT_UNIQUE: +- reason = "STATUS_DS_NAME_NOT_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_DUPLICATE_ID_FOUND: +- reason = "STATUS_DS_DUPLICATE_ID_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_GROUP_CONVERSION_ERROR: +- reason = "STATUS_DS_GROUP_CONVERSION_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLSNAP_PREPARE_HIBERNATE: +- reason = "STATUS_VOLSNAP_PREPARE_HIBERNATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_USER2USER_REQUIRED: +- reason = "STATUS_USER2USER_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STACK_BUFFER_OVERRUN: +- reason = "STATUS_STACK_BUFFER_OVERRUN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_S4U_PROT_SUPPORT: +- reason = "STATUS_NO_S4U_PROT_SUPPORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CROSSREALM_DELEGATION_FAILURE: +- reason = "STATUS_CROSSREALM_DELEGATION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REVOCATION_OFFLINE_KDC: +- reason = "STATUS_REVOCATION_OFFLINE_KDC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ISSUING_CA_UNTRUSTED_KDC: +- reason = "STATUS_ISSUING_CA_UNTRUSTED_KDC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KDC_CERT_EXPIRED: +- reason = "STATUS_KDC_CERT_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KDC_CERT_REVOKED: +- reason = "STATUS_KDC_CERT_REVOKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PARAMETER_QUOTA_EXCEEDED: +- reason = "STATUS_PARAMETER_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HIBERNATION_FAILURE: +- reason = "STATUS_HIBERNATION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DELAY_LOAD_FAILED: +- reason = "STATUS_DELAY_LOAD_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUTHENTICATION_FIREWALL_FAILED: +- reason = "STATUS_AUTHENTICATION_FIREWALL_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VDM_DISALLOWED: +- reason = "STATUS_VDM_DISALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HUNG_DISPLAY_DRIVER_THREAD: +- reason = "STATUS_HUNG_DISPLAY_DRIVER_THREAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE: +- reason = "STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_CRUNTIME_PARAMETER: +- reason = "STATUS_INVALID_CRUNTIME_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NTLM_BLOCKED: +- reason = "STATUS_NTLM_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_SRC_SID_EXISTS_IN_FOREST: +- reason = "STATUS_DS_SRC_SID_EXISTS_IN_FOREST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST: +- reason = "STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST: +- reason = "STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_USER_PRINCIPAL_NAME: +- reason = "STATUS_INVALID_USER_PRINCIPAL_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FATAL_USER_CALLBACK_EXCEPTION: +- reason = "STATUS_FATAL_USER_CALLBACK_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ASSERTION_FAILURE: +- reason = "STATUS_ASSERTION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VERIFIER_STOP: +- reason = "STATUS_VERIFIER_STOP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_POP_STACK: +- reason = "STATUS_CALLBACK_POP_STACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_DRIVER_BLOCKED: +- reason = "STATUS_INCOMPATIBLE_DRIVER_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HIVE_UNLOADED: +- reason = "STATUS_HIVE_UNLOADED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMPRESSION_DISABLED: +- reason = "STATUS_COMPRESSION_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_LIMITATION: +- reason = "STATUS_FILE_SYSTEM_LIMITATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_HASH: +- reason = "STATUS_INVALID_IMAGE_HASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_CAPABLE: +- reason = "STATUS_NOT_CAPABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REQUEST_OUT_OF_SEQUENCE: +- reason = "STATUS_REQUEST_OUT_OF_SEQUENCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMPLEMENTATION_LIMIT: +- reason = "STATUS_IMPLEMENTATION_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ELEVATION_REQUIRED: +- reason = "STATUS_ELEVATION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SECURITY_CONTEXT: +- reason = "STATUS_NO_SECURITY_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PKU2U_CERT_FAILURE: +- reason = "STATUS_PKU2U_CERT_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BEYOND_VDL: +- reason = "STATUS_BEYOND_VDL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCOUNTERED_WRITE_IN_PROGRESS: +- reason = "STATUS_ENCOUNTERED_WRITE_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PTE_CHANGED: +- reason = "STATUS_PTE_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PURGE_FAILED: +- reason = "STATUS_PURGE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRED_REQUIRES_CONFIRMATION: +- reason = "STATUS_CRED_REQUIRES_CONFIRMATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE: +- reason = "STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER: +- reason = "STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE: +- reason = "STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE: +- reason = "STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_FILE_NOT_CSE: +- reason = "STATUS_CS_ENCRYPTION_FILE_NOT_CSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_LABEL: +- reason = "STATUS_INVALID_LABEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DRIVER_PROCESS_TERMINATED: +- reason = "STATUS_DRIVER_PROCESS_TERMINATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AMBIGUOUS_SYSTEM_DEVICE: +- reason = "STATUS_AMBIGUOUS_SYSTEM_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_DEVICE_NOT_FOUND: +- reason = "STATUS_SYSTEM_DEVICE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESTART_BOOT_APPLICATION: +- reason = "STATUS_RESTART_BOOT_APPLICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_NVRAM_RESOURCES: +- reason = "STATUS_INSUFFICIENT_NVRAM_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SESSION: +- reason = "STATUS_INVALID_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_SESSION: +- reason = "STATUS_THREAD_ALREADY_IN_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_NOT_IN_SESSION: +- reason = "STATUS_THREAD_NOT_IN_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_WEIGHT: +- reason = "STATUS_INVALID_WEIGHT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REQUEST_PAUSED: +- reason = "STATUS_REQUEST_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_RANGES_PROCESSED: +- reason = "STATUS_NO_RANGES_PROCESSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_RESOURCES_EXHAUSTED: +- reason = "STATUS_DISK_RESOURCES_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NEEDS_REMEDIATION: +- reason = "STATUS_NEEDS_REMEDIATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_FEATURE_NOT_SUPPORTED: +- reason = "STATUS_DEVICE_FEATURE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_UNREACHABLE: +- reason = "STATUS_DEVICE_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_TOKEN: +- reason = "STATUS_INVALID_TOKEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SERVER_UNAVAILABLE: +- reason = "STATUS_SERVER_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_NOT_AVAILABLE: +- reason = "STATUS_FILE_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_INSUFFICIENT_RESOURCES: +- reason = "STATUS_DEVICE_INSUFFICIENT_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PACKAGE_UPDATING: +- reason = "STATUS_PACKAGE_UPDATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_READ_FROM_COPY: +- reason = "STATUS_NOT_READ_FROM_COPY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_WRITE_FAILURE: +- reason = "STATUS_FT_WRITE_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_DI_SCAN_REQUIRED: +- reason = "STATUS_FT_DI_SCAN_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NOT_EXTERNALLY_BACKED: +- reason = "STATUS_OBJECT_NOT_EXTERNALLY_BACKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN: +- reason = "STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_BENEFICIAL: +- reason = "STATUS_COMPRESSION_NOT_BENEFICIAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DATA_CHECKSUM_ERROR: +- reason = "STATUS_DATA_CHECKSUM_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERMIXED_KERNEL_EA_OPERATION: +- reason = "STATUS_INTERMIXED_KERNEL_EA_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRIM_READ_ZERO_NOT_SUPPORTED: +- reason = "STATUS_TRIM_READ_ZERO_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TOO_MANY_SEGMENT_DESCRIPTORS: +- reason = "STATUS_TOO_MANY_SEGMENT_DESCRIPTORS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_OFFSET_ALIGNMENT: +- reason = "STATUS_INVALID_OFFSET_ALIGNMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_FIELD_IN_PARAMETER_LIST: +- reason = "STATUS_INVALID_FIELD_IN_PARAMETER_LIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPERATION_IN_PROGRESS: +- reason = "STATUS_OPERATION_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_INITIATOR_TARGET_PATH: +- reason = "STATUS_INVALID_INITIATOR_TARGET_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SCRUB_DATA_DISABLED: +- reason = "STATUS_SCRUB_DATA_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_REDUNDANT_STORAGE: +- reason = "STATUS_NOT_REDUNDANT_STORAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESIDENT_FILE_NOT_SUPPORTED: +- reason = "STATUS_RESIDENT_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMPRESSED_FILE_NOT_SUPPORTED: +- reason = "STATUS_COMPRESSED_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_SUPPORTED: +- reason = "STATUS_DIRECTORY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_OPERATION_TIMEOUT: +- reason = "STATUS_IO_OPERATION_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_NEEDS_REMEDIATION: +- reason = "STATUS_SYSTEM_NEEDS_REMEDIATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN: +- reason = "STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SHARE_UNAVAILABLE: +- reason = "STATUS_SHARE_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APISET_NOT_HOSTED: +- reason = "STATUS_APISET_NOT_HOSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APISET_NOT_PRESENT: +- reason = "STATUS_APISET_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_HARDWARE_ERROR: +- reason = "STATUS_DEVICE_HARDWARE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FIRMWARE_SLOT_INVALID: +- reason = "STATUS_FIRMWARE_SLOT_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FIRMWARE_IMAGE_INVALID: +- reason = "STATUS_FIRMWARE_IMAGE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_TOPOLOGY_ID_MISMATCH: +- reason = "STATUS_STORAGE_TOPOLOGY_ID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WIM_NOT_BOOTABLE: +- reason = "STATUS_WIM_NOT_BOOTABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BLOCKED_BY_PARENTAL_CONTROLS: +- reason = "STATUS_BLOCKED_BY_PARENTAL_CONTROLS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NEEDS_REGISTRATION: +- reason = "STATUS_NEEDS_REGISTRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUOTA_ACTIVITY: +- reason = "STATUS_QUOTA_ACTIVITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_INVOKE_INLINE: +- reason = "STATUS_CALLBACK_INVOKE_INLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BLOCK_TOO_MANY_REFERENCES: +- reason = "STATUS_BLOCK_TOO_MANY_REFERENCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MARKED_TO_DISALLOW_WRITES: +- reason = "STATUS_MARKED_TO_DISALLOW_WRITES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED_EDP: +- reason = "STATUS_NETWORK_ACCESS_DENIED_EDP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCLAVE_FAILURE: +- reason = "STATUS_ENCLAVE_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_NO_COMPAT_DRIVERS: +- reason = "STATUS_PNP_NO_COMPAT_DRIVERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND: +- reason = "STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND: +- reason = "STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE: +- reason = "STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_FUNCTION_DRIVER_REQUIRED: +- reason = "STATUS_PNP_FUNCTION_DRIVER_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_DEVICE_CONFIGURATION_PENDING: +- reason = "STATUS_PNP_DEVICE_CONFIGURATION_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL: +- reason = "STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PACKAGE_NOT_AVAILABLE: +- reason = "STATUS_PACKAGE_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_IN_MAINTENANCE: +- reason = "STATUS_DEVICE_IN_MAINTENANCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_DAX: +- reason = "STATUS_NOT_SUPPORTED_ON_DAX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FREE_SPACE_TOO_FRAGMENTED: +- reason = "STATUS_FREE_SPACE_TOO_FRAGMENTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DAX_MAPPING_EXISTS: +- reason = "STATUS_DAX_MAPPING_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CHILD_PROCESS_BLOCKED: +- reason = "STATUS_CHILD_PROCESS_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_LOST_DATA_PERSISTENCE: +- reason = "STATUS_STORAGE_LOST_DATA_PERSISTENCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VRF_CFG_AND_IO_ENABLED: +- reason = "STATUS_VRF_CFG_AND_IO_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PARTITION_TERMINATING: +- reason = "STATUS_PARTITION_TERMINATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED: +- reason = "STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCLAVE_VIOLATION: +- reason = "STATUS_ENCLAVE_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_PROTECTED_UNDER_DPL: +- reason = "STATUS_FILE_PROTECTED_UNDER_DPL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_CLUSTER_ALIGNED: +- reason = "STATUS_VOLUME_NOT_CLUSTER_ALIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND: +- reason = "STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPX_FILE_NOT_ENCRYPTED: +- reason = "STATUS_APPX_FILE_NOT_ENCRYPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED: +- reason = "STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET: +- reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE: +- reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER: +- reason = "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FT_READ_FAILURE: +- reason = "STATUS_FT_READ_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PATCH_CONFLICT: +- reason = "STATUS_PATCH_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ID_INVALID: +- reason = "STATUS_STORAGE_RESERVE_ID_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_DOES_NOT_EXIST: +- reason = "STATUS_STORAGE_RESERVE_DOES_NOT_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ALREADY_EXISTS: +- reason = "STATUS_STORAGE_RESERVE_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_NOT_EMPTY: +- reason = "STATUS_STORAGE_RESERVE_NOT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_DAX_VOLUME: +- reason = "STATUS_NOT_A_DAX_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_DAX_MAPPABLE: +- reason = "STATUS_NOT_DAX_MAPPABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CASE_DIFFERING_NAMES_IN_DIR: +- reason = "STATUS_CASE_DIFFERING_NAMES_IN_DIR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_NOT_SUPPORTED: +- reason = "STATUS_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_WITH_BTT: +- reason = "STATUS_NOT_SUPPORTED_WITH_BTT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCRYPTION_DISABLED: +- reason = "STATUS_ENCRYPTION_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCRYPTING_METADATA_DISALLOWED: +- reason = "STATUS_ENCRYPTING_METADATA_DISALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_CLEAR_ENCRYPTION_FLAG: +- reason = "STATUS_CANT_CLEAR_ENCRYPTION_FLAG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNSATISFIED_DEPENDENCIES: +- reason = "STATUS_UNSATISFIED_DEPENDENCIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CASE_SENSITIVE_PATH: +- reason = "STATUS_CASE_SENSITIVE_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HAS_SYSTEM_CRITICAL_FILES: +- reason = "STATUS_HAS_SYSTEM_CRITICAL_FILES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_TASK_NAME: +- reason = "STATUS_INVALID_TASK_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_TASK_INDEX: +- reason = "STATUS_INVALID_TASK_INDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_TASK: +- reason = "STATUS_THREAD_ALREADY_IN_TASK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_BYPASS: +- reason = "STATUS_CALLBACK_BYPASS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_UNDEFINED_SCOPE: +- reason = "STATUS_UNDEFINED_SCOPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_CAP: +- reason = "STATUS_INVALID_CAP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_GUI_PROCESS: +- reason = "STATUS_NOT_GUI_PROCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_HUNG: +- reason = "STATUS_DEVICE_HUNG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTAINER_ASSIGNED: +- reason = "STATUS_CONTAINER_ASSIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_JOB_NO_CONTAINER: +- reason = "STATUS_JOB_NO_CONTAINER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DEVICE_UNRESPONSIVE: +- reason = "STATUS_DEVICE_UNRESPONSIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_ENCOUNTERED: +- reason = "STATUS_REPARSE_POINT_ENCOUNTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ATTRIBUTE_NOT_PRESENT: +- reason = "STATUS_ATTRIBUTE_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_TIERED_VOLUME: +- reason = "STATUS_NOT_A_TIERED_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_HAS_STREAM_ID: +- reason = "STATUS_ALREADY_HAS_STREAM_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_JOB_NOT_EMPTY: +- reason = "STATUS_JOB_NOT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_INITIALIZED: +- reason = "STATUS_ALREADY_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCLAVE_NOT_TERMINATED: +- reason = "STATUS_ENCLAVE_NOT_TERMINATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCLAVE_IS_TERMINATING: +- reason = "STATUS_ENCLAVE_IS_TERMINATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMB1_NOT_AVAILABLE: +- reason = "STATUS_SMB1_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMR_GARBAGE_COLLECTION_REQUIRED: +- reason = "STATUS_SMR_GARBAGE_COLLECTION_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INTERRUPTED: +- reason = "STATUS_INTERRUPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREAD_NOT_RUNNING: +- reason = "STATUS_THREAD_NOT_RUNNING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FAIL_FAST_EXCEPTION: +- reason = "STATUS_FAIL_FAST_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_REVOKED: +- reason = "STATUS_IMAGE_CERT_REVOKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DYNAMIC_CODE_BLOCKED: +- reason = "STATUS_DYNAMIC_CODE_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_EXPIRED: +- reason = "STATUS_IMAGE_CERT_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STRICT_CFG_VIOLATION: +- reason = "STATUS_STRICT_CFG_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SET_CONTEXT_DENIED: +- reason = "STATUS_SET_CONTEXT_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CROSS_PARTITION_VIOLATION: +- reason = "STATUS_CROSS_PARTITION_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_CLOSED: +- reason = "STATUS_PORT_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MESSAGE_LOST: +- reason = "STATUS_MESSAGE_LOST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_MESSAGE: +- reason = "STATUS_INVALID_MESSAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REQUEST_CANCELED: +- reason = "STATUS_REQUEST_CANCELED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RECURSIVE_DISPATCH: +- reason = "STATUS_RECURSIVE_DISPATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPC_RECEIVE_BUFFER_EXPECTED: +- reason = "STATUS_LPC_RECEIVE_BUFFER_EXPECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPC_INVALID_CONNECTION_USAGE: +- reason = "STATUS_LPC_INVALID_CONNECTION_USAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPC_REQUESTS_NOT_ALLOWED: +- reason = "STATUS_LPC_REQUESTS_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_IN_USE: +- reason = "STATUS_RESOURCE_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HARDWARE_MEMORY_ERROR: +- reason = "STATUS_HARDWARE_MEMORY_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_HANDLE_EXCEPTION: +- reason = "STATUS_THREADPOOL_HANDLE_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED: +- reason = "STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED: +- reason = "STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED: +- reason = "STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED: +- reason = "STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASED_DURING_OPERATION: +- reason = "STATUS_THREADPOOL_RELEASED_DURING_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING: +- reason = "STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APC_RETURNED_WHILE_IMPERSONATING: +- reason = "STATUS_APC_RETURNED_WHILE_IMPERSONATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROCESS_IS_PROTECTED: +- reason = "STATUS_PROCESS_IS_PROTECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MCA_EXCEPTION: +- reason = "STATUS_MCA_EXCEPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE: +- reason = "STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYMLINK_CLASS_DISABLED: +- reason = "STATUS_SYMLINK_CLASS_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_IDN_NORMALIZATION: +- reason = "STATUS_INVALID_IDN_NORMALIZATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_UNICODE_TRANSLATION: +- reason = "STATUS_NO_UNICODE_TRANSLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ALREADY_REGISTERED: +- reason = "STATUS_ALREADY_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTEXT_MISMATCH: +- reason = "STATUS_CONTEXT_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PORT_ALREADY_HAS_COMPLETION_LIST: +- reason = "STATUS_PORT_ALREADY_HAS_COMPLETION_LIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_PRIORITY: +- reason = "STATUS_CALLBACK_RETURNED_THREAD_PRIORITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_THREAD: +- reason = "STATUS_INVALID_THREAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_TRANSACTION: +- reason = "STATUS_CALLBACK_RETURNED_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LDR_LOCK: +- reason = "STATUS_CALLBACK_RETURNED_LDR_LOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LANG: +- reason = "STATUS_CALLBACK_RETURNED_LANG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_PRI_BACK: +- reason = "STATUS_CALLBACK_RETURNED_PRI_BACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY: +- reason = "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPC_HANDLE_COUNT_EXCEEDED: +- reason = "STATUS_LPC_HANDLE_COUNT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EXECUTABLE_MEMORY_WRITE: +- reason = "STATUS_EXECUTABLE_MEMORY_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE: +- reason = "STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE: +- reason = "STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE: +- reason = "STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_DISABLED: +- reason = "STATUS_DISK_REPAIR_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS: +- reason = "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_QUOTA_EXCEEDED: +- reason = "STATUS_DISK_QUOTA_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CONTENT_BLOCKED: +- reason = "STATUS_CONTENT_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_CLUSTERS: +- reason = "STATUS_BAD_CLUSTERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLUME_DIRTY: +- reason = "STATUS_VOLUME_DIRTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_UNSUCCESSFUL: +- reason = "STATUS_DISK_REPAIR_UNSUCCESSFUL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_OVERFULL: +- reason = "STATUS_CORRUPT_LOG_OVERFULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_CORRUPTED: +- reason = "STATUS_CORRUPT_LOG_CORRUPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_UNAVAILABLE: +- reason = "STATUS_CORRUPT_LOG_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_DELETED_FULL: +- reason = "STATUS_CORRUPT_LOG_DELETED_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_CLEARED: +- reason = "STATUS_CORRUPT_LOG_CLEARED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ORPHAN_NAME_EXHAUSTED: +- reason = "STATUS_ORPHAN_NAME_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROACTIVE_SCAN_IN_PROGRESS: +- reason = "STATUS_PROACTIVE_SCAN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENCRYPTED_IO_NOT_POSSIBLE: +- reason = "STATUS_ENCRYPTED_IO_NOT_POSSIBLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_UPLEVEL_RECORDS: +- reason = "STATUS_CORRUPT_LOG_UPLEVEL_RECORDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_CHECKED_OUT: +- reason = "STATUS_FILE_CHECKED_OUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CHECKOUT_REQUIRED: +- reason = "STATUS_CHECKOUT_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_FILE_TYPE: +- reason = "STATUS_BAD_FILE_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_TOO_LARGE: +- reason = "STATUS_FILE_TOO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FORMS_AUTH_REQUIRED: +- reason = "STATUS_FORMS_AUTH_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRUS_INFECTED: +- reason = "STATUS_VIRUS_INFECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRUS_DELETED: +- reason = "STATUS_VIRUS_DELETED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_MCFG_TABLE: +- reason = "STATUS_BAD_MCFG_TABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_BREAK_OPLOCK: +- reason = "STATUS_CANNOT_BREAK_OPLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_KEY: +- reason = "STATUS_BAD_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BAD_DATA: +- reason = "STATUS_BAD_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_KEY: +- reason = "STATUS_NO_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_HANDLE_REVOKED: +- reason = "STATUS_FILE_HANDLE_REVOKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WOW_ASSERTION: +- reason = "STATUS_WOW_ASSERTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_SIGNATURE: +- reason = "STATUS_INVALID_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HMAC_NOT_SUPPORTED: +- reason = "STATUS_HMAC_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUTH_TAG_MISMATCH: +- reason = "STATUS_AUTH_TAG_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_STATE_TRANSITION: +- reason = "STATUS_INVALID_STATE_TRANSITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_KERNEL_INFO_VERSION: +- reason = "STATUS_INVALID_KERNEL_INFO_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PEP_INFO_VERSION: +- reason = "STATUS_INVALID_PEP_INFO_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HANDLE_REVOKED: +- reason = "STATUS_HANDLE_REVOKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EOF_ON_GHOSTED_RANGE: +- reason = "STATUS_EOF_ON_GHOSTED_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN: +- reason = "STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_QUEUE_OVERFLOW: +- reason = "STATUS_IPSEC_QUEUE_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ND_QUEUE_OVERFLOW: +- reason = "STATUS_ND_QUEUE_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HOPLIMIT_EXCEEDED: +- reason = "STATUS_HOPLIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PROTOCOL_NOT_SUPPORTED: +- reason = "STATUS_PROTOCOL_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FASTPATH_REJECTED: +- reason = "STATUS_FASTPATH_REJECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED: +- reason = "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR: +- reason = "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR: +- reason = "STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_XML_PARSE_ERROR: +- reason = "STATUS_XML_PARSE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_XMLDSIG_ERROR: +- reason = "STATUS_XMLDSIG_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WRONG_COMPARTMENT: +- reason = "STATUS_WRONG_COMPARTMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUTHIP_FAILURE: +- reason = "STATUS_AUTHIP_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS: +- reason = "STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DS_OID_NOT_FOUND: +- reason = "STATUS_DS_OID_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INCORRECT_ACCOUNT_TYPE: +- reason = "STATUS_INCORRECT_ACCOUNT_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HASH_NOT_SUPPORTED: +- reason = "STATUS_HASH_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HASH_NOT_PRESENT: +- reason = "STATUS_HASH_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED: +- reason = "STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_CLIENT_INFORMATION_INVALID: +- reason = "STATUS_GPIO_CLIENT_INFORMATION_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_VERSION_NOT_SUPPORTED: +- reason = "STATUS_GPIO_VERSION_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_INVALID_REGISTRATION_PACKET: +- reason = "STATUS_GPIO_INVALID_REGISTRATION_PACKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_OPERATION_DENIED: +- reason = "STATUS_GPIO_OPERATION_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE: +- reason = "STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_SWITCH_RUNLEVEL: +- reason = "STATUS_CANNOT_SWITCH_RUNLEVEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_RUNLEVEL_SETTING: +- reason = "STATUS_INVALID_RUNLEVEL_SETTING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_TIMEOUT: +- reason = "STATUS_RUNLEVEL_SWITCH_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT: +- reason = "STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_IN_PROGRESS: +- reason = "STATUS_RUNLEVEL_SWITCH_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_APPCONTAINER: +- reason = "STATUS_NOT_APPCONTAINER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_IN_APPCONTAINER: +- reason = "STATUS_NOT_SUPPORTED_IN_APPCONTAINER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_PACKAGE_SID_LENGTH: +- reason = "STATUS_INVALID_PACKAGE_SID_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LPAC_ACCESS_DENIED: +- reason = "STATUS_LPAC_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADMINLESS_ACCESS_DENIED: +- reason = "STATUS_ADMINLESS_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_DATA_NOT_FOUND: +- reason = "STATUS_APP_DATA_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_DATA_EXPIRED: +- reason = "STATUS_APP_DATA_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_DATA_CORRUPT: +- reason = "STATUS_APP_DATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_DATA_LIMIT_EXCEEDED: +- reason = "STATUS_APP_DATA_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APP_DATA_REBOOT_REQUIRED: +- reason = "STATUS_APP_DATA_REBOOT_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED: +- reason = "STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED: +- reason = "STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED: +- reason = "STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED: +- reason = "STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WOF_WIM_HEADER_CORRUPT: +- reason = "STATUS_WOF_WIM_HEADER_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT: +- reason = "STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT: +- reason = "STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CIMFS_IMAGE_CORRUPT: +- reason = "STATUS_CIMFS_IMAGE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE: +- reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT: +- reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY: +- reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN: +- reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION: +- reason = "STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT: +- reason = "STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING: +- reason = "STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_CORRUPT: +- reason = "STATUS_CLOUD_FILE_METADATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_TOO_LARGE: +- reason = "STATUS_CLOUD_FILE_METADATA_TOO_LARGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED: +- reason = "STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_FILE: +- reason = "STATUS_NOT_A_CLOUD_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_IN_SYNC: +- reason = "STATUS_CLOUD_FILE_NOT_IN_SYNC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ALREADY_CONNECTED: +- reason = "STATUS_CLOUD_FILE_ALREADY_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_SUPPORTED: +- reason = "STATUS_CLOUD_FILE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INVALID_REQUEST: +- reason = "STATUS_CLOUD_FILE_INVALID_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_READ_ONLY_VOLUME: +- reason = "STATUS_CLOUD_FILE_READ_ONLY_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY: +- reason = "STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_VALIDATION_FAILED: +- reason = "STATUS_CLOUD_FILE_VALIDATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_AUTHENTICATION_FAILED: +- reason = "STATUS_CLOUD_FILE_AUTHENTICATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES: +- reason = "STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE: +- reason = "STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_UNSUCCESSFUL: +- reason = "STATUS_CLOUD_FILE_UNSUCCESSFUL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT: +- reason = "STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_IN_USE: +- reason = "STATUS_CLOUD_FILE_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PINNED: +- reason = "STATUS_CLOUD_FILE_PINNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_ABORTED: +- reason = "STATUS_CLOUD_FILE_REQUEST_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_CORRUPT: +- reason = "STATUS_CLOUD_FILE_PROPERTY_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ACCESS_DENIED: +- reason = "STATUS_CLOUD_FILE_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS: +- reason = "STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT: +- reason = "STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_CANCELED: +- reason = "STATUS_CLOUD_FILE_REQUEST_CANCELED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_TERMINATED: +- reason = "STATUS_CLOUD_FILE_PROVIDER_TERMINATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_SYNC_ROOT: +- reason = "STATUS_NOT_A_CLOUD_SYNC_ROOT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_TIMEOUT: +- reason = "STATUS_CLOUD_FILE_REQUEST_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED: +- reason = "STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IN_PROGRESS: +- reason = "STATUS_FILE_SNAP_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED: +- reason = "STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED: +- reason = "STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IO_NOT_COORDINATED: +- reason = "STATUS_FILE_SNAP_IO_NOT_COORDINATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_UNEXPECTED_ERROR: +- reason = "STATUS_FILE_SNAP_UNEXPECTED_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_SNAP_INVALID_PARAMETER: +- reason = "STATUS_FILE_SNAP_INVALID_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_DBG_NO_STATE_CHANGE: +- reason = "DBG_NO_STATE_CHANGE"; +- break; +- case MD_NTSTATUS_WIN_DBG_APP_NOT_IDLE: +- reason = "DBG_APP_NOT_IDLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_BINDING: +- reason = "RPC_NT_INVALID_STRING_BINDING"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_WRONG_KIND_OF_BINDING: +- reason = "RPC_NT_WRONG_KIND_OF_BINDING"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_BINDING: +- reason = "RPC_NT_INVALID_BINDING"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PROTSEQ_NOT_SUPPORTED: +- reason = "RPC_NT_PROTSEQ_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_RPC_PROTSEQ: +- reason = "RPC_NT_INVALID_RPC_PROTSEQ"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_UUID: +- reason = "RPC_NT_INVALID_STRING_UUID"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_ENDPOINT_FORMAT: +- reason = "RPC_NT_INVALID_ENDPOINT_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_NET_ADDR: +- reason = "RPC_NT_INVALID_NET_ADDR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_ENDPOINT_FOUND: +- reason = "RPC_NT_NO_ENDPOINT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_TIMEOUT: +- reason = "RPC_NT_INVALID_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_OBJECT_NOT_FOUND: +- reason = "RPC_NT_OBJECT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ALREADY_REGISTERED: +- reason = "RPC_NT_ALREADY_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_TYPE_ALREADY_REGISTERED: +- reason = "RPC_NT_TYPE_ALREADY_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ALREADY_LISTENING: +- reason = "RPC_NT_ALREADY_LISTENING"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_PROTSEQS_REGISTERED: +- reason = "RPC_NT_NO_PROTSEQS_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NOT_LISTENING: +- reason = "RPC_NT_NOT_LISTENING"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_MGR_TYPE: +- reason = "RPC_NT_UNKNOWN_MGR_TYPE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_IF: +- reason = "RPC_NT_UNKNOWN_IF"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_BINDINGS: +- reason = "RPC_NT_NO_BINDINGS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_PROTSEQS: +- reason = "RPC_NT_NO_PROTSEQS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CANT_CREATE_ENDPOINT: +- reason = "RPC_NT_CANT_CREATE_ENDPOINT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_OUT_OF_RESOURCES: +- reason = "RPC_NT_OUT_OF_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SERVER_UNAVAILABLE: +- reason = "RPC_NT_SERVER_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SERVER_TOO_BUSY: +- reason = "RPC_NT_SERVER_TOO_BUSY"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_NETWORK_OPTIONS: +- reason = "RPC_NT_INVALID_NETWORK_OPTIONS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_CALL_ACTIVE: +- reason = "RPC_NT_NO_CALL_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CALL_FAILED: +- reason = "RPC_NT_CALL_FAILED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CALL_FAILED_DNE: +- reason = "RPC_NT_CALL_FAILED_DNE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PROTOCOL_ERROR: +- reason = "RPC_NT_PROTOCOL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_TRANS_SYN: +- reason = "RPC_NT_UNSUPPORTED_TRANS_SYN"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_TYPE: +- reason = "RPC_NT_UNSUPPORTED_TYPE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_TAG: +- reason = "RPC_NT_INVALID_TAG"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_BOUND: +- reason = "RPC_NT_INVALID_BOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_ENTRY_NAME: +- reason = "RPC_NT_NO_ENTRY_NAME"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_NAME_SYNTAX: +- reason = "RPC_NT_INVALID_NAME_SYNTAX"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_NAME_SYNTAX: +- reason = "RPC_NT_UNSUPPORTED_NAME_SYNTAX"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UUID_NO_ADDRESS: +- reason = "RPC_NT_UUID_NO_ADDRESS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_DUPLICATE_ENDPOINT: +- reason = "RPC_NT_DUPLICATE_ENDPOINT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_TYPE: +- reason = "RPC_NT_UNKNOWN_AUTHN_TYPE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_MAX_CALLS_TOO_SMALL: +- reason = "RPC_NT_MAX_CALLS_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_STRING_TOO_LONG: +- reason = "RPC_NT_STRING_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PROTSEQ_NOT_FOUND: +- reason = "RPC_NT_PROTSEQ_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PROCNUM_OUT_OF_RANGE: +- reason = "RPC_NT_PROCNUM_OUT_OF_RANGE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_BINDING_HAS_NO_AUTH: +- reason = "RPC_NT_BINDING_HAS_NO_AUTH"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_SERVICE: +- reason = "RPC_NT_UNKNOWN_AUTHN_SERVICE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_LEVEL: +- reason = "RPC_NT_UNKNOWN_AUTHN_LEVEL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_AUTH_IDENTITY: +- reason = "RPC_NT_INVALID_AUTH_IDENTITY"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHZ_SERVICE: +- reason = "RPC_NT_UNKNOWN_AUTHZ_SERVICE"; +- break; +- case MD_NTSTATUS_WIN_EPT_NT_INVALID_ENTRY: +- reason = "EPT_NT_INVALID_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_EPT_NT_CANT_PERFORM_OP: +- reason = "EPT_NT_CANT_PERFORM_OP"; +- break; +- case MD_NTSTATUS_WIN_EPT_NT_NOT_REGISTERED: +- reason = "EPT_NT_NOT_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NOTHING_TO_EXPORT: +- reason = "RPC_NT_NOTHING_TO_EXPORT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INCOMPLETE_NAME: +- reason = "RPC_NT_INCOMPLETE_NAME"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_VERS_OPTION: +- reason = "RPC_NT_INVALID_VERS_OPTION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_MORE_MEMBERS: +- reason = "RPC_NT_NO_MORE_MEMBERS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NOT_ALL_OBJS_UNEXPORTED: +- reason = "RPC_NT_NOT_ALL_OBJS_UNEXPORTED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INTERFACE_NOT_FOUND: +- reason = "RPC_NT_INTERFACE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ENTRY_ALREADY_EXISTS: +- reason = "RPC_NT_ENTRY_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ENTRY_NOT_FOUND: +- reason = "RPC_NT_ENTRY_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NAME_SERVICE_UNAVAILABLE: +- reason = "RPC_NT_NAME_SERVICE_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_NAF_ID: +- reason = "RPC_NT_INVALID_NAF_ID"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CANNOT_SUPPORT: +- reason = "RPC_NT_CANNOT_SUPPORT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_CONTEXT_AVAILABLE: +- reason = "RPC_NT_NO_CONTEXT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INTERNAL_ERROR: +- reason = "RPC_NT_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ZERO_DIVIDE: +- reason = "RPC_NT_ZERO_DIVIDE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ADDRESS_ERROR: +- reason = "RPC_NT_ADDRESS_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_FP_DIV_ZERO: +- reason = "RPC_NT_FP_DIV_ZERO"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_FP_UNDERFLOW: +- reason = "RPC_NT_FP_UNDERFLOW"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_FP_OVERFLOW: +- reason = "RPC_NT_FP_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CALL_IN_PROGRESS: +- reason = "RPC_NT_CALL_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_MORE_BINDINGS: +- reason = "RPC_NT_NO_MORE_BINDINGS"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_GROUP_MEMBER_NOT_FOUND: +- reason = "RPC_NT_GROUP_MEMBER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_EPT_NT_CANT_CREATE: +- reason = "EPT_NT_CANT_CREATE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_OBJECT: +- reason = "RPC_NT_INVALID_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_INTERFACES: +- reason = "RPC_NT_NO_INTERFACES"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_CALL_CANCELLED: +- reason = "RPC_NT_CALL_CANCELLED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_BINDING_INCOMPLETE: +- reason = "RPC_NT_BINDING_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_COMM_FAILURE: +- reason = "RPC_NT_COMM_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_AUTHN_LEVEL: +- reason = "RPC_NT_UNSUPPORTED_AUTHN_LEVEL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_PRINC_NAME: +- reason = "RPC_NT_NO_PRINC_NAME"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NOT_RPC_ERROR: +- reason = "RPC_NT_NOT_RPC_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SEC_PKG_ERROR: +- reason = "RPC_NT_SEC_PKG_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NOT_CANCELLED: +- reason = "RPC_NT_NOT_CANCELLED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_ASYNC_HANDLE: +- reason = "RPC_NT_INVALID_ASYNC_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_ASYNC_CALL: +- reason = "RPC_NT_INVALID_ASYNC_CALL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PROXY_ACCESS_DENIED: +- reason = "RPC_NT_PROXY_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_COOKIE_AUTH_FAILED: +- reason = "RPC_NT_COOKIE_AUTH_FAILED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NO_MORE_ENTRIES: +- reason = "RPC_NT_NO_MORE_ENTRIES"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_CHAR_TRANS_OPEN_FAIL: +- reason = "RPC_NT_SS_CHAR_TRANS_OPEN_FAIL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_CHAR_TRANS_SHORT_FILE: +- reason = "RPC_NT_SS_CHAR_TRANS_SHORT_FILE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_IN_NULL_CONTEXT: +- reason = "RPC_NT_SS_IN_NULL_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_CONTEXT_MISMATCH: +- reason = "RPC_NT_SS_CONTEXT_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_CONTEXT_DAMAGED: +- reason = "RPC_NT_SS_CONTEXT_DAMAGED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_HANDLES_MISMATCH: +- reason = "RPC_NT_SS_HANDLES_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_SS_CANNOT_GET_CALL_HANDLE: +- reason = "RPC_NT_SS_CANNOT_GET_CALL_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_NULL_REF_POINTER: +- reason = "RPC_NT_NULL_REF_POINTER"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_ENUM_VALUE_OUT_OF_RANGE: +- reason = "RPC_NT_ENUM_VALUE_OUT_OF_RANGE"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_BYTE_COUNT_TOO_SMALL: +- reason = "RPC_NT_BYTE_COUNT_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_BAD_STUB_DATA: +- reason = "RPC_NT_BAD_STUB_DATA"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_ES_ACTION: +- reason = "RPC_NT_INVALID_ES_ACTION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_WRONG_ES_VERSION: +- reason = "RPC_NT_WRONG_ES_VERSION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_WRONG_STUB_VERSION: +- reason = "RPC_NT_WRONG_STUB_VERSION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_PIPE_OBJECT: +- reason = "RPC_NT_INVALID_PIPE_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_INVALID_PIPE_OPERATION: +- reason = "RPC_NT_INVALID_PIPE_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_WRONG_PIPE_VERSION: +- reason = "RPC_NT_WRONG_PIPE_VERSION"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PIPE_CLOSED: +- reason = "RPC_NT_PIPE_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PIPE_DISCIPLINE_ERROR: +- reason = "RPC_NT_PIPE_DISCIPLINE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_RPC_NT_PIPE_EMPTY: +- reason = "RPC_NT_PIPE_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_BAD_MPS_TABLE: +- reason = "STATUS_PNP_BAD_MPS_TABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_TRANSLATION_FAILED: +- reason = "STATUS_PNP_TRANSLATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_IRQ_TRANSLATION_FAILED: +- reason = "STATUS_PNP_IRQ_TRANSLATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PNP_INVALID_ID: +- reason = "STATUS_PNP_INVALID_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_REISSUE_AS_CACHED: +- reason = "STATUS_IO_REISSUE_AS_CACHED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NAME_INVALID: +- reason = "STATUS_CTX_WINSTATION_NAME_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_INVALID_PD: +- reason = "STATUS_CTX_INVALID_PD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_PD_NOT_FOUND: +- reason = "STATUS_CTX_PD_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CLOSE_PENDING: +- reason = "STATUS_CTX_CLOSE_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_NO_OUTBUF: +- reason = "STATUS_CTX_NO_OUTBUF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_INF_NOT_FOUND: +- reason = "STATUS_CTX_MODEM_INF_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_INVALID_MODEMNAME: +- reason = "STATUS_CTX_INVALID_MODEMNAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_RESPONSE_ERROR: +- reason = "STATUS_CTX_RESPONSE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_TIMEOUT: +- reason = "STATUS_CTX_MODEM_RESPONSE_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_NO_CARRIER: +- reason = "STATUS_CTX_MODEM_RESPONSE_NO_CARRIER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE: +- reason = "STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_BUSY: +- reason = "STATUS_CTX_MODEM_RESPONSE_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_VOICE: +- reason = "STATUS_CTX_MODEM_RESPONSE_VOICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_TD_ERROR: +- reason = "STATUS_CTX_TD_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_CLIENT_INVALID: +- reason = "STATUS_CTX_LICENSE_CLIENT_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_NOT_AVAILABLE: +- reason = "STATUS_CTX_LICENSE_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_EXPIRED: +- reason = "STATUS_CTX_LICENSE_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NOT_FOUND: +- reason = "STATUS_CTX_WINSTATION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NAME_COLLISION: +- reason = "STATUS_CTX_WINSTATION_NAME_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_BUSY: +- reason = "STATUS_CTX_WINSTATION_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_BAD_VIDEO_MODE: +- reason = "STATUS_CTX_BAD_VIDEO_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_GRAPHICS_INVALID: +- reason = "STATUS_CTX_GRAPHICS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_NOT_CONSOLE: +- reason = "STATUS_CTX_NOT_CONSOLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_QUERY_TIMEOUT: +- reason = "STATUS_CTX_CLIENT_QUERY_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CONSOLE_DISCONNECT: +- reason = "STATUS_CTX_CONSOLE_DISCONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CONSOLE_CONNECT: +- reason = "STATUS_CTX_CONSOLE_CONNECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_DENIED: +- reason = "STATUS_CTX_SHADOW_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_ACCESS_DENIED: +- reason = "STATUS_CTX_WINSTATION_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_INVALID_WD: +- reason = "STATUS_CTX_INVALID_WD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_WD_NOT_FOUND: +- reason = "STATUS_CTX_WD_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_INVALID: +- reason = "STATUS_CTX_SHADOW_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_DISABLED: +- reason = "STATUS_CTX_SHADOW_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RDP_PROTOCOL_ERROR: +- reason = "STATUS_RDP_PROTOCOL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_LICENSE_NOT_SET: +- reason = "STATUS_CTX_CLIENT_LICENSE_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_LICENSE_IN_USE: +- reason = "STATUS_CTX_CLIENT_LICENSE_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE: +- reason = "STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_NOT_RUNNING: +- reason = "STATUS_CTX_SHADOW_NOT_RUNNING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_LOGON_DISABLED: +- reason = "STATUS_CTX_LOGON_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTX_SECURITY_LAYER_ERROR: +- reason = "STATUS_CTX_SECURITY_LAYER_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TS_INCOMPATIBLE_SESSIONS: +- reason = "STATUS_TS_INCOMPATIBLE_SESSIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TS_VIDEO_SUBSYSTEM_ERROR: +- reason = "STATUS_TS_VIDEO_SUBSYSTEM_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_FILE_NOT_FOUND: +- reason = "STATUS_MUI_FILE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_INVALID_FILE: +- reason = "STATUS_MUI_INVALID_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_INVALID_RC_CONFIG: +- reason = "STATUS_MUI_INVALID_RC_CONFIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_INVALID_LOCALE_NAME: +- reason = "STATUS_MUI_INVALID_LOCALE_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME: +- reason = "STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MUI_FILE_NOT_LOADED: +- reason = "STATUS_MUI_FILE_NOT_LOADED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCE_ENUM_USER_STOP: +- reason = "STATUS_RESOURCE_ENUM_USER_STOP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NODE: +- reason = "STATUS_CLUSTER_INVALID_NODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_EXISTS: +- reason = "STATUS_CLUSTER_NODE_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_JOIN_IN_PROGRESS: +- reason = "STATUS_CLUSTER_JOIN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_FOUND: +- reason = "STATUS_CLUSTER_NODE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND: +- reason = "STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_EXISTS: +- reason = "STATUS_CLUSTER_NETWORK_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_NOT_FOUND: +- reason = "STATUS_CLUSTER_NETWORK_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETINTERFACE_EXISTS: +- reason = "STATUS_CLUSTER_NETINTERFACE_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETINTERFACE_NOT_FOUND: +- reason = "STATUS_CLUSTER_NETINTERFACE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_REQUEST: +- reason = "STATUS_CLUSTER_INVALID_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NETWORK_PROVIDER: +- reason = "STATUS_CLUSTER_INVALID_NETWORK_PROVIDER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_DOWN: +- reason = "STATUS_CLUSTER_NODE_DOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_UNREACHABLE: +- reason = "STATUS_CLUSTER_NODE_UNREACHABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_MEMBER: +- reason = "STATUS_CLUSTER_NODE_NOT_MEMBER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS: +- reason = "STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NETWORK: +- reason = "STATUS_CLUSTER_INVALID_NETWORK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NO_NET_ADAPTERS: +- reason = "STATUS_CLUSTER_NO_NET_ADAPTERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_UP: +- reason = "STATUS_CLUSTER_NODE_UP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_PAUSED: +- reason = "STATUS_CLUSTER_NODE_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_PAUSED: +- reason = "STATUS_CLUSTER_NODE_NOT_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NO_SECURITY_CONTEXT: +- reason = "STATUS_CLUSTER_NO_SECURITY_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_NOT_INTERNAL: +- reason = "STATUS_CLUSTER_NETWORK_NOT_INTERNAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_POISONED: +- reason = "STATUS_CLUSTER_POISONED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_NON_CSV_PATH: +- reason = "STATUS_CLUSTER_NON_CSV_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL: +- reason = "STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS: +- reason = "STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR: +- reason = "STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_REDIRECTED: +- reason = "STATUS_CLUSTER_CSV_REDIRECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NOT_REDIRECTED: +- reason = "STATUS_CLUSTER_CSV_NOT_REDIRECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING: +- reason = "STATUS_CLUSTER_CSV_VOLUME_DRAINING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS: +- reason = "STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL: +- reason = "STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NO_SNAPSHOTS: +- reason = "STATUS_CLUSTER_CSV_NO_SNAPSHOTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CSV_IO_PAUSE_TIMEOUT: +- reason = "STATUS_CSV_IO_PAUSE_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_INVALID_HANDLE: +- reason = "STATUS_CLUSTER_CSV_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR: +- reason = "STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED: +- reason = "STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OPCODE: +- reason = "STATUS_ACPI_INVALID_OPCODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_STACK_OVERFLOW: +- reason = "STATUS_ACPI_STACK_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_ASSERT_FAILED: +- reason = "STATUS_ACPI_ASSERT_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_INDEX: +- reason = "STATUS_ACPI_INVALID_INDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGUMENT: +- reason = "STATUS_ACPI_INVALID_ARGUMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_FATAL: +- reason = "STATUS_ACPI_FATAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_SUPERNAME: +- reason = "STATUS_ACPI_INVALID_SUPERNAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGTYPE: +- reason = "STATUS_ACPI_INVALID_ARGTYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OBJTYPE: +- reason = "STATUS_ACPI_INVALID_OBJTYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_TARGETTYPE: +- reason = "STATUS_ACPI_INVALID_TARGETTYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INCORRECT_ARGUMENT_COUNT: +- reason = "STATUS_ACPI_INCORRECT_ARGUMENT_COUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_ADDRESS_NOT_MAPPED: +- reason = "STATUS_ACPI_ADDRESS_NOT_MAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_EVENTTYPE: +- reason = "STATUS_ACPI_INVALID_EVENTTYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_HANDLER_COLLISION: +- reason = "STATUS_ACPI_HANDLER_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_DATA: +- reason = "STATUS_ACPI_INVALID_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_REGION: +- reason = "STATUS_ACPI_INVALID_REGION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ACCESS_SIZE: +- reason = "STATUS_ACPI_INVALID_ACCESS_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_ACQUIRE_GLOBAL_LOCK: +- reason = "STATUS_ACPI_ACQUIRE_GLOBAL_LOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_ALREADY_INITIALIZED: +- reason = "STATUS_ACPI_ALREADY_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_NOT_INITIALIZED: +- reason = "STATUS_ACPI_NOT_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_MUTEX_LEVEL: +- reason = "STATUS_ACPI_INVALID_MUTEX_LEVEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_MUTEX_NOT_OWNED: +- reason = "STATUS_ACPI_MUTEX_NOT_OWNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_MUTEX_NOT_OWNER: +- reason = "STATUS_ACPI_MUTEX_NOT_OWNER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_RS_ACCESS: +- reason = "STATUS_ACPI_RS_ACCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_TABLE: +- reason = "STATUS_ACPI_INVALID_TABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_REG_HANDLER_FAILED: +- reason = "STATUS_ACPI_REG_HANDLER_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ACPI_POWER_REQUEST_FAILED: +- reason = "STATUS_ACPI_POWER_REQUEST_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_SECTION_NOT_FOUND: +- reason = "STATUS_SXS_SECTION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_CANT_GEN_ACTCTX: +- reason = "STATUS_SXS_CANT_GEN_ACTCTX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_INVALID_ACTCTXDATA_FORMAT: +- reason = "STATUS_SXS_INVALID_ACTCTXDATA_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_NOT_FOUND: +- reason = "STATUS_SXS_ASSEMBLY_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_FORMAT_ERROR: +- reason = "STATUS_SXS_MANIFEST_FORMAT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_PARSE_ERROR: +- reason = "STATUS_SXS_MANIFEST_PARSE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_ACTIVATION_CONTEXT_DISABLED: +- reason = "STATUS_SXS_ACTIVATION_CONTEXT_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_KEY_NOT_FOUND: +- reason = "STATUS_SXS_KEY_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_VERSION_CONFLICT: +- reason = "STATUS_SXS_VERSION_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_WRONG_SECTION_TYPE: +- reason = "STATUS_SXS_WRONG_SECTION_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_THREAD_QUERIES_DISABLED: +- reason = "STATUS_SXS_THREAD_QUERIES_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_MISSING: +- reason = "STATUS_SXS_ASSEMBLY_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET: +- reason = "STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_EARLY_DEACTIVATION: +- reason = "STATUS_SXS_EARLY_DEACTIVATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_INVALID_DEACTIVATION: +- reason = "STATUS_SXS_INVALID_DEACTIVATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_MULTIPLE_DEACTIVATION: +- reason = "STATUS_SXS_MULTIPLE_DEACTIVATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY: +- reason = "STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_PROCESS_TERMINATION_REQUESTED: +- reason = "STATUS_SXS_PROCESS_TERMINATION_REQUESTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_CORRUPT_ACTIVATION_STACK: +- reason = "STATUS_SXS_CORRUPT_ACTIVATION_STACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_CORRUPTION: +- reason = "STATUS_SXS_CORRUPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE: +- reason = "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME: +- reason = "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE: +- reason = "STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_IDENTITY_PARSE_ERROR: +- reason = "STATUS_SXS_IDENTITY_PARSE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_COMPONENT_STORE_CORRUPT: +- reason = "STATUS_SXS_COMPONENT_STORE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_FILE_HASH_MISMATCH: +- reason = "STATUS_SXS_FILE_HASH_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT: +- reason = "STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_IDENTITIES_DIFFERENT: +- reason = "STATUS_SXS_IDENTITIES_DIFFERENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT: +- reason = "STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY: +- reason = "STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ADVANCED_INSTALLER_FAILED: +- reason = "STATUS_ADVANCED_INSTALLER_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_XML_ENCODING_MISMATCH: +- reason = "STATUS_XML_ENCODING_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_TOO_BIG: +- reason = "STATUS_SXS_MANIFEST_TOO_BIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_SETTING_NOT_REGISTERED: +- reason = "STATUS_SXS_SETTING_NOT_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE: +- reason = "STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMI_PRIMITIVE_INSTALLER_FAILED: +- reason = "STATUS_SMI_PRIMITIVE_INSTALLER_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GENERIC_COMMAND_FAILED: +- reason = "STATUS_GENERIC_COMMAND_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SXS_FILE_HASH_MISSING: +- reason = "STATUS_SXS_FILE_HASH_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONAL_CONFLICT: +- reason = "STATUS_TRANSACTIONAL_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INVALID_TRANSACTION: +- reason = "STATUS_INVALID_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ACTIVE: +- reason = "STATUS_TRANSACTION_NOT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TM_INITIALIZATION_FAILED: +- reason = "STATUS_TM_INITIALIZATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RM_NOT_ACTIVE: +- reason = "STATUS_RM_NOT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RM_METADATA_CORRUPT: +- reason = "STATUS_RM_METADATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_JOINED: +- reason = "STATUS_TRANSACTION_NOT_JOINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_RM: +- reason = "STATUS_DIRECTORY_NOT_RM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE: +- reason = "STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_RESIZE_INVALID_SIZE: +- reason = "STATUS_LOG_RESIZE_INVALID_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_REMOTE_FILE_VERSION_MISMATCH: +- reason = "STATUS_REMOTE_FILE_VERSION_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRM_PROTOCOL_ALREADY_EXISTS: +- reason = "STATUS_CRM_PROTOCOL_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_PROPAGATION_FAILED: +- reason = "STATUS_TRANSACTION_PROPAGATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CRM_PROTOCOL_NOT_FOUND: +- reason = "STATUS_CRM_PROTOCOL_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_SUPERIOR_EXISTS: +- reason = "STATUS_TRANSACTION_SUPERIOR_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_REQUEST_NOT_VALID: +- reason = "STATUS_TRANSACTION_REQUEST_NOT_VALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_REQUESTED: +- reason = "STATUS_TRANSACTION_NOT_REQUESTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_ALREADY_ABORTED: +- reason = "STATUS_TRANSACTION_ALREADY_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_ALREADY_COMMITTED: +- reason = "STATUS_TRANSACTION_ALREADY_COMMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER: +- reason = "STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CURRENT_TRANSACTION_NOT_VALID: +- reason = "STATUS_CURRENT_TRANSACTION_NOT_VALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_GROWTH_FAILED: +- reason = "STATUS_LOG_GROWTH_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OBJECT_NO_LONGER_EXISTS: +- reason = "STATUS_OBJECT_NO_LONGER_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STREAM_MINIVERSION_NOT_FOUND: +- reason = "STATUS_STREAM_MINIVERSION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_STREAM_MINIVERSION_NOT_VALID: +- reason = "STATUS_STREAM_MINIVERSION_NOT_VALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION: +- reason = "STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT: +- reason = "STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS: +- reason = "STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HANDLE_NO_LONGER_VALID: +- reason = "STATUS_HANDLE_NO_LONGER_VALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CORRUPTION_DETECTED: +- reason = "STATUS_LOG_CORRUPTION_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RM_DISCONNECTED: +- reason = "STATUS_RM_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENLISTMENT_NOT_SUPERIOR: +- reason = "STATUS_ENLISTMENT_NOT_SUPERIOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FILE_IDENTITY_NOT_PERSISTENT: +- reason = "STATUS_FILE_IDENTITY_NOT_PERSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY: +- reason = "STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANT_CROSS_RM_BOUNDARY: +- reason = "STATUS_CANT_CROSS_RM_BOUNDARY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TXF_DIR_NOT_EMPTY: +- reason = "STATUS_TXF_DIR_NOT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_INDOUBT_TRANSACTIONS_EXIST: +- reason = "STATUS_INDOUBT_TRANSACTIONS_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TM_VOLATILE: +- reason = "STATUS_TM_VOLATILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ROLLBACK_TIMER_EXPIRED: +- reason = "STATUS_ROLLBACK_TIMER_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TXF_ATTRIBUTE_CORRUPT: +- reason = "STATUS_TXF_ATTRIBUTE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION: +- reason = "STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED: +- reason = "STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE: +- reason = "STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_REQUIRED_PROMOTION: +- reason = "STATUS_TRANSACTION_REQUIRED_PROMOTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION: +- reason = "STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONS_NOT_FROZEN: +- reason = "STATUS_TRANSACTIONS_NOT_FROZEN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_FREEZE_IN_PROGRESS: +- reason = "STATUS_TRANSACTION_FREEZE_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NOT_SNAPSHOT_VOLUME: +- reason = "STATUS_NOT_SNAPSHOT_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_SAVEPOINT_WITH_OPEN_FILES: +- reason = "STATUS_NO_SAVEPOINT_WITH_OPEN_FILES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION: +- reason = "STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TM_IDENTITY_MISMATCH: +- reason = "STATUS_TM_IDENTITY_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLOATED_SECTION: +- reason = "STATUS_FLOATED_SECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_ACCEPT_TRANSACTED_WORK: +- reason = "STATUS_CANNOT_ACCEPT_TRANSACTED_WORK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CANNOT_ABORT_TRANSACTIONS: +- reason = "STATUS_CANNOT_ABORT_TRANSACTIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_FOUND: +- reason = "STATUS_TRANSACTION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_NOT_FOUND: +- reason = "STATUS_RESOURCEMANAGER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_ENLISTMENT_NOT_FOUND: +- reason = "STATUS_ENLISTMENT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_NOT_FOUND: +- reason = "STATUS_TRANSACTIONMANAGER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_NOT_ONLINE: +- reason = "STATUS_TRANSACTIONMANAGER_NOT_ONLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION: +- reason = "STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ROOT: +- reason = "STATUS_TRANSACTION_NOT_ROOT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_OBJECT_EXPIRED: +- reason = "STATUS_TRANSACTION_OBJECT_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION: +- reason = "STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED: +- reason = "STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_RECORD_TOO_LONG: +- reason = "STATUS_TRANSACTION_RECORD_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_LINK_TRACKING_IN_TRANSACTION: +- reason = "STATUS_NO_LINK_TRACKING_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION: +- reason = "STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_INTEGRITY_VIOLATED: +- reason = "STATUS_TRANSACTION_INTEGRITY_VIOLATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH: +- reason = "STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT: +- reason = "STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_MUST_WRITETHROUGH: +- reason = "STATUS_TRANSACTION_MUST_WRITETHROUGH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_SUPERIOR: +- reason = "STATUS_TRANSACTION_NO_SUPERIOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_EXPIRED_HANDLE: +- reason = "STATUS_EXPIRED_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ENLISTED: +- reason = "STATUS_TRANSACTION_NOT_ENLISTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_INVALID: +- reason = "STATUS_LOG_SECTOR_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_PARITY_INVALID: +- reason = "STATUS_LOG_SECTOR_PARITY_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_REMAPPED: +- reason = "STATUS_LOG_SECTOR_REMAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_INCOMPLETE: +- reason = "STATUS_LOG_BLOCK_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_INVALID_RANGE: +- reason = "STATUS_LOG_INVALID_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_BLOCKS_EXHAUSTED: +- reason = "STATUS_LOG_BLOCKS_EXHAUSTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_READ_CONTEXT_INVALID: +- reason = "STATUS_LOG_READ_CONTEXT_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_RESTART_INVALID: +- reason = "STATUS_LOG_RESTART_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_VERSION: +- reason = "STATUS_LOG_BLOCK_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_INVALID: +- reason = "STATUS_LOG_BLOCK_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_READ_MODE_INVALID: +- reason = "STATUS_LOG_READ_MODE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_METADATA_CORRUPT: +- reason = "STATUS_LOG_METADATA_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_METADATA_INVALID: +- reason = "STATUS_LOG_METADATA_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_METADATA_INCONSISTENT: +- reason = "STATUS_LOG_METADATA_INCONSISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_RESERVATION_INVALID: +- reason = "STATUS_LOG_RESERVATION_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CANT_DELETE: +- reason = "STATUS_LOG_CANT_DELETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_LIMIT_EXCEEDED: +- reason = "STATUS_LOG_CONTAINER_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_START_OF_LOG: +- reason = "STATUS_LOG_START_OF_LOG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_POLICY_ALREADY_INSTALLED: +- reason = "STATUS_LOG_POLICY_ALREADY_INSTALLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_POLICY_NOT_INSTALLED: +- reason = "STATUS_LOG_POLICY_NOT_INSTALLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_POLICY_INVALID: +- reason = "STATUS_LOG_POLICY_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_POLICY_CONFLICT: +- reason = "STATUS_LOG_POLICY_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_PINNED_ARCHIVE_TAIL: +- reason = "STATUS_LOG_PINNED_ARCHIVE_TAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_RECORD_NONEXISTENT: +- reason = "STATUS_LOG_RECORD_NONEXISTENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_RECORDS_RESERVED_INVALID: +- reason = "STATUS_LOG_RECORDS_RESERVED_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_SPACE_RESERVED_INVALID: +- reason = "STATUS_LOG_SPACE_RESERVED_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_TAIL_INVALID: +- reason = "STATUS_LOG_TAIL_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_FULL: +- reason = "STATUS_LOG_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_MULTIPLEXED: +- reason = "STATUS_LOG_MULTIPLEXED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_DEDICATED: +- reason = "STATUS_LOG_DEDICATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS: +- reason = "STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_ARCHIVE_IN_PROGRESS: +- reason = "STATUS_LOG_ARCHIVE_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_EPHEMERAL: +- reason = "STATUS_LOG_EPHEMERAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_NOT_ENOUGH_CONTAINERS: +- reason = "STATUS_LOG_NOT_ENOUGH_CONTAINERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CLIENT_ALREADY_REGISTERED: +- reason = "STATUS_LOG_CLIENT_ALREADY_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CLIENT_NOT_REGISTERED: +- reason = "STATUS_LOG_CLIENT_NOT_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_FULL_HANDLER_IN_PROGRESS: +- reason = "STATUS_LOG_FULL_HANDLER_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_READ_FAILED: +- reason = "STATUS_LOG_CONTAINER_READ_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_WRITE_FAILED: +- reason = "STATUS_LOG_CONTAINER_WRITE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_OPEN_FAILED: +- reason = "STATUS_LOG_CONTAINER_OPEN_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_STATE_INVALID: +- reason = "STATUS_LOG_CONTAINER_STATE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_STATE_INVALID: +- reason = "STATUS_LOG_STATE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_PINNED: +- reason = "STATUS_LOG_PINNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_METADATA_FLUSH_FAILED: +- reason = "STATUS_LOG_METADATA_FLUSH_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_INCONSISTENT_SECURITY: +- reason = "STATUS_LOG_INCONSISTENT_SECURITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_APPENDED_FLUSH_FAILED: +- reason = "STATUS_LOG_APPENDED_FLUSH_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_LOG_PINNED_RESERVATION: +- reason = "STATUS_LOG_PINNED_RESERVATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD: +- reason = "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NO_HANDLER_DEFINED: +- reason = "STATUS_FLT_NO_HANDLER_DEFINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALREADY_DEFINED: +- reason = "STATUS_FLT_CONTEXT_ALREADY_DEFINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST: +- reason = "STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_DISALLOW_FAST_IO: +- reason = "STATUS_FLT_DISALLOW_FAST_IO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INVALID_NAME_REQUEST: +- reason = "STATUS_FLT_INVALID_NAME_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NOT_SAFE_TO_POST_OPERATION: +- reason = "STATUS_FLT_NOT_SAFE_TO_POST_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NOT_INITIALIZED: +- reason = "STATUS_FLT_NOT_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_FILTER_NOT_READY: +- reason = "STATUS_FLT_FILTER_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_POST_OPERATION_CLEANUP: +- reason = "STATUS_FLT_POST_OPERATION_CLEANUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INTERNAL_ERROR: +- reason = "STATUS_FLT_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_DELETING_OBJECT: +- reason = "STATUS_FLT_DELETING_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_MUST_BE_NONPAGED_POOL: +- reason = "STATUS_FLT_MUST_BE_NONPAGED_POOL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_DUPLICATE_ENTRY: +- reason = "STATUS_FLT_DUPLICATE_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_CBDQ_DISABLED: +- reason = "STATUS_FLT_CBDQ_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_DO_NOT_ATTACH: +- reason = "STATUS_FLT_DO_NOT_ATTACH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_DO_NOT_DETACH: +- reason = "STATUS_FLT_DO_NOT_DETACH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_ALTITUDE_COLLISION: +- reason = "STATUS_FLT_INSTANCE_ALTITUDE_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_NAME_COLLISION: +- reason = "STATUS_FLT_INSTANCE_NAME_COLLISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_FILTER_NOT_FOUND: +- reason = "STATUS_FLT_FILTER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_VOLUME_NOT_FOUND: +- reason = "STATUS_FLT_VOLUME_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_NOT_FOUND: +- reason = "STATUS_FLT_INSTANCE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND: +- reason = "STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_INVALID_CONTEXT_REGISTRATION: +- reason = "STATUS_FLT_INVALID_CONTEXT_REGISTRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NAME_CACHE_MISS: +- reason = "STATUS_FLT_NAME_CACHE_MISS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NO_DEVICE_OBJECT: +- reason = "STATUS_FLT_NO_DEVICE_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_VOLUME_ALREADY_MOUNTED: +- reason = "STATUS_FLT_VOLUME_ALREADY_MOUNTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_ALREADY_ENLISTED: +- reason = "STATUS_FLT_ALREADY_ENLISTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALREADY_LINKED: +- reason = "STATUS_FLT_CONTEXT_ALREADY_LINKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_NO_WAITER_FOR_REPLY: +- reason = "STATUS_FLT_NO_WAITER_FOR_REPLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FLT_REGISTRATION_BUSY: +- reason = "STATUS_FLT_REGISTRATION_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_NO_DESCRIPTOR: +- reason = "STATUS_MONITOR_NO_DESCRIPTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT: +- reason = "STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM: +- reason = "STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK: +- reason = "STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED: +- reason = "STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK: +- reason = "STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK: +- reason = "STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA: +- reason = "STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK: +- reason = "STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_MANUFACTURE_DATE: +- reason = "STATUS_MONITOR_INVALID_MANUFACTURE_DATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER: +- reason = "STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER: +- reason = "STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER: +- reason = "STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_WAS_RESET: +- reason = "STATUS_GRAPHICS_ADAPTER_WAS_RESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_DRIVER_MODEL: +- reason = "STATUS_GRAPHICS_INVALID_DRIVER_MODEL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_MODE_CHANGED: +- reason = "STATUS_GRAPHICS_PRESENT_MODE_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_OCCLUDED: +- reason = "STATUS_GRAPHICS_PRESENT_OCCLUDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_DENIED: +- reason = "STATUS_GRAPHICS_PRESENT_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANNOTCOLORCONVERT: +- reason = "STATUS_GRAPHICS_CANNOTCOLORCONVERT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DRIVER_MISMATCH: +- reason = "STATUS_GRAPHICS_DRIVER_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED: +- reason = "STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_UNOCCLUDED: +- reason = "STATUS_GRAPHICS_PRESENT_UNOCCLUDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE: +- reason = "STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED: +- reason = "STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_INVALID_WINDOW: +- reason = "STATUS_GRAPHICS_PRESENT_INVALID_WINDOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND: +- reason = "STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VAIL_STATE_CHANGED: +- reason = "STATUS_GRAPHICS_VAIL_STATE_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN: +- reason = "STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED: +- reason = "STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDEO_MEMORY: +- reason = "STATUS_GRAPHICS_NO_VIDEO_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_LOCK_MEMORY: +- reason = "STATUS_GRAPHICS_CANT_LOCK_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_BUSY: +- reason = "STATUS_GRAPHICS_ALLOCATION_BUSY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TOO_MANY_REFERENCES: +- reason = "STATUS_GRAPHICS_TOO_MANY_REFERENCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_LATER: +- reason = "STATUS_GRAPHICS_TRY_AGAIN_LATER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_NOW: +- reason = "STATUS_GRAPHICS_TRY_AGAIN_NOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_INVALID: +- reason = "STATUS_GRAPHICS_ALLOCATION_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE: +- reason = "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED: +- reason = "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION: +- reason = "STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE: +- reason = "STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION: +- reason = "STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_CLOSED: +- reason = "STATUS_GRAPHICS_ALLOCATION_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE: +- reason = "STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE: +- reason = "STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE: +- reason = "STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST: +- reason = "STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE: +- reason = "STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE: +- reason = "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET: +- reason = "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_FREQUENCY: +- reason = "STATUS_GRAPHICS_INVALID_FREQUENCY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ACTIVE_REGION: +- reason = "STATUS_GRAPHICS_INVALID_ACTIVE_REGION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_TOTAL_REGION: +- reason = "STATUS_GRAPHICS_INVALID_TOTAL_REGION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE: +- reason = "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE: +- reason = "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET: +- reason = "STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET: +- reason = "STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET: +- reason = "STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET: +- reason = "STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET: +- reason = "STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_ALREADY_IN_SET: +- reason = "STATUS_GRAPHICS_TARGET_ALREADY_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET: +- reason = "STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET: +- reason = "STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_STALE_MODESET: +- reason = "STATUS_GRAPHICS_STALE_MODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN: +- reason = "STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE: +- reason = "STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION: +- reason = "STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES: +- reason = "STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE: +- reason = "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET: +- reason = "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET: +- reason = "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR: +- reason = "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET: +- reason = "STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET: +- reason = "STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE: +- reason = "STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_RESOURCES_NOT_RELATED: +- reason = "STATUS_GRAPHICS_RESOURCES_NOT_RELATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE: +- reason = "STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE: +- reason = "STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET: +- reason = "STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER: +- reason = "STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDPNMGR: +- reason = "STATUS_GRAPHICS_NO_VIDPNMGR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_ACTIVE_VIDPN: +- reason = "STATUS_GRAPHICS_NO_ACTIVE_VIDPN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_NOT_CONNECTED: +- reason = "STATUS_GRAPHICS_MONITOR_NOT_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE: +- reason = "STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE: +- reason = "STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_STRIDE: +- reason = "STATUS_GRAPHICS_INVALID_STRIDE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PIXELFORMAT: +- reason = "STATUS_GRAPHICS_INVALID_PIXELFORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_COLORBASIS: +- reason = "STATUS_GRAPHICS_INVALID_COLORBASIS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE: +- reason = "STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY: +- reason = "STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT: +- reason = "STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE: +- reason = "STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN: +- reason = "STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL: +- reason = "STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION: +- reason = "STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_GAMMA_RAMP: +- reason = "STATUS_GRAPHICS_INVALID_GAMMA_RAMP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_IN_MODESET: +- reason = "STATUS_GRAPHICS_MODE_NOT_IN_MODESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON: +- reason = "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE: +- reason = "STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE: +- reason = "STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS: +- reason = "STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING: +- reason = "STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED: +- reason = "STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS: +- reason = "STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT: +- reason = "STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM: +- reason = "STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT: +- reason = "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED: +- reason = "STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION: +- reason = "STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_CLIENT_TYPE: +- reason = "STATUS_GRAPHICS_INVALID_CLIENT_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET: +- reason = "STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED: +- reason = "STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER: +- reason = "STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED: +- reason = "STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED: +- reason = "STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY: +- reason = "STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED: +- reason = "STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON: +- reason = "STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE: +- reason = "STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER: +- reason = "STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED: +- reason = "STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_OPM_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_COPP_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_COPP_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_UAB_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_UAB_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS: +- reason = "STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST: +- reason = "STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INTERNAL_ERROR: +- reason = "STATUS_GRAPHICS_OPM_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_HANDLE: +- reason = "STATUS_GRAPHICS_OPM_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH: +- reason = "STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED: +- reason = "STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED: +- reason = "STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PVP_HFS_FAILED: +- reason = "STATUS_GRAPHICS_PVP_HFS_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_SRM: +- reason = "STATUS_GRAPHICS_OPM_INVALID_SRM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP: +- reason = "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP: +- reason = "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA: +- reason = "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET: +- reason = "STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH: +- reason = "STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE: +- reason = "STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS: +- reason = "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS: +- reason = "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST: +- reason = "STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR: +- reason = "STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS: +- reason = "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST: +- reason = "STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_I2C_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST: +- reason = "STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA: +- reason = "STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA: +- reason = "STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_DATA: +- reason = "STATUS_GRAPHICS_DDCCI_INVALID_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE: +- reason = "STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING: +- reason = "STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MCA_INTERNAL_ERROR: +- reason = "STATUS_GRAPHICS_MCA_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND: +- reason = "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH: +- reason = "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM: +- reason = "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE: +- reason = "STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS: +- reason = "STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED: +- reason = "STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME: +- reason = "STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP: +- reason = "STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED: +- reason = "STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_POINTER: +- reason = "STATUS_GRAPHICS_INVALID_POINTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE: +- reason = "STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL: +- reason = "STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_INTERNAL_ERROR: +- reason = "STATUS_GRAPHICS_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS: +- reason = "STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_LOCKED_VOLUME: +- reason = "STATUS_FVE_LOCKED_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_ENCRYPTED: +- reason = "STATUS_FVE_NOT_ENCRYPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_BAD_INFORMATION: +- reason = "STATUS_FVE_BAD_INFORMATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TOO_SMALL: +- reason = "STATUS_FVE_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FAILED_WRONG_FS: +- reason = "STATUS_FVE_FAILED_WRONG_FS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_BAD_PARTITION_SIZE: +- reason = "STATUS_FVE_BAD_PARTITION_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FS_NOT_EXTENDED: +- reason = "STATUS_FVE_FS_NOT_EXTENDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FS_MOUNTED: +- reason = "STATUS_FVE_FS_MOUNTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NO_LICENSE: +- reason = "STATUS_FVE_NO_LICENSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_ACTION_NOT_ALLOWED: +- reason = "STATUS_FVE_ACTION_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_BAD_DATA: +- reason = "STATUS_FVE_BAD_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_NOT_BOUND: +- reason = "STATUS_FVE_VOLUME_NOT_BOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_DATA_VOLUME: +- reason = "STATUS_FVE_NOT_DATA_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_CONV_READ_ERROR: +- reason = "STATUS_FVE_CONV_READ_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_CONV_WRITE_ERROR: +- reason = "STATUS_FVE_CONV_WRITE_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_OVERLAPPED_UPDATE: +- reason = "STATUS_FVE_OVERLAPPED_UPDATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FAILED_SECTOR_SIZE: +- reason = "STATUS_FVE_FAILED_SECTOR_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FAILED_AUTHENTICATION: +- reason = "STATUS_FVE_FAILED_AUTHENTICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_OS_VOLUME: +- reason = "STATUS_FVE_NOT_OS_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_NOT_FOUND: +- reason = "STATUS_FVE_KEYFILE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_INVALID: +- reason = "STATUS_FVE_KEYFILE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_NO_VMK: +- reason = "STATUS_FVE_KEYFILE_NO_VMK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TPM_DISABLED: +- reason = "STATUS_FVE_TPM_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO: +- reason = "STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TPM_INVALID_PCR: +- reason = "STATUS_FVE_TPM_INVALID_PCR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_TPM_NO_VMK: +- reason = "STATUS_FVE_TPM_NO_VMK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_PIN_INVALID: +- reason = "STATUS_FVE_PIN_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_AUTH_INVALID_APPLICATION: +- reason = "STATUS_FVE_AUTH_INVALID_APPLICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_AUTH_INVALID_CONFIG: +- reason = "STATUS_FVE_AUTH_INVALID_CONFIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_DEBUGGER_ENABLED: +- reason = "STATUS_FVE_DEBUGGER_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_DRY_RUN_FAILED: +- reason = "STATUS_FVE_DRY_RUN_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_BAD_METADATA_POINTER: +- reason = "STATUS_FVE_BAD_METADATA_POINTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_OLD_METADATA_COPY: +- reason = "STATUS_FVE_OLD_METADATA_COPY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_REBOOT_REQUIRED: +- reason = "STATUS_FVE_REBOOT_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_RAW_ACCESS: +- reason = "STATUS_FVE_RAW_ACCESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_RAW_BLOCKED: +- reason = "STATUS_FVE_RAW_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY: +- reason = "STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_MOR_FAILED: +- reason = "STATUS_FVE_MOR_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NO_FEATURE_LICENSE: +- reason = "STATUS_FVE_NO_FEATURE_LICENSE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED: +- reason = "STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_CONV_RECOVERY_FAILED: +- reason = "STATUS_FVE_CONV_RECOVERY_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG: +- reason = "STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_INVALID_DATUM_TYPE: +- reason = "STATUS_FVE_INVALID_DATUM_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_TOO_SMALL: +- reason = "STATUS_FVE_VOLUME_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_ENH_PIN_INVALID: +- reason = "STATUS_FVE_ENH_PIN_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE: +- reason = "STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE: +- reason = "STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK: +- reason = "STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_ON_CLUSTER: +- reason = "STATUS_FVE_NOT_ALLOWED_ON_CLUSTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING: +- reason = "STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE: +- reason = "STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_EDRIVE_DRY_RUN_FAILED: +- reason = "STATUS_FVE_EDRIVE_DRY_RUN_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_DISABLED: +- reason = "STATUS_FVE_SECUREBOOT_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_CONFIG_CHANGE: +- reason = "STATUS_FVE_SECUREBOOT_CONFIG_CHANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_DEVICE_LOCKEDOUT: +- reason = "STATUS_FVE_DEVICE_LOCKEDOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT: +- reason = "STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_NOT_DE_VOLUME: +- reason = "STATUS_FVE_NOT_DE_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_DISABLED: +- reason = "STATUS_FVE_PROTECTION_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED: +- reason = "STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FVE_OSV_KSR_NOT_ALLOWED: +- reason = "STATUS_FVE_OSV_KSR_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOT_FOUND: +- reason = "STATUS_FWP_CALLOUT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CONDITION_NOT_FOUND: +- reason = "STATUS_FWP_CONDITION_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_FILTER_NOT_FOUND: +- reason = "STATUS_FWP_FILTER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_LAYER_NOT_FOUND: +- reason = "STATUS_FWP_LAYER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_NOT_FOUND: +- reason = "STATUS_FWP_PROVIDER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND: +- reason = "STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_SUBLAYER_NOT_FOUND: +- reason = "STATUS_FWP_SUBLAYER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NOT_FOUND: +- reason = "STATUS_FWP_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_ALREADY_EXISTS: +- reason = "STATUS_FWP_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_IN_USE: +- reason = "STATUS_FWP_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS: +- reason = "STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_WRONG_SESSION: +- reason = "STATUS_FWP_WRONG_SESSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NO_TXN_IN_PROGRESS: +- reason = "STATUS_FWP_NO_TXN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TXN_IN_PROGRESS: +- reason = "STATUS_FWP_TXN_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TXN_ABORTED: +- reason = "STATUS_FWP_TXN_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_SESSION_ABORTED: +- reason = "STATUS_FWP_SESSION_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_TXN: +- reason = "STATUS_FWP_INCOMPATIBLE_TXN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TIMEOUT: +- reason = "STATUS_FWP_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NET_EVENTS_DISABLED: +- reason = "STATUS_FWP_NET_EVENTS_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_LAYER: +- reason = "STATUS_FWP_INCOMPATIBLE_LAYER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_KM_CLIENTS_ONLY: +- reason = "STATUS_FWP_KM_CLIENTS_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_LIFETIME_MISMATCH: +- reason = "STATUS_FWP_LIFETIME_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_BUILTIN_OBJECT: +- reason = "STATUS_FWP_BUILTIN_OBJECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TOO_MANY_CALLOUTS: +- reason = "STATUS_FWP_TOO_MANY_CALLOUTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NOTIFICATION_DROPPED: +- reason = "STATUS_FWP_NOTIFICATION_DROPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TRAFFIC_MISMATCH: +- reason = "STATUS_FWP_TRAFFIC_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_SA_STATE: +- reason = "STATUS_FWP_INCOMPATIBLE_SA_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NULL_POINTER: +- reason = "STATUS_FWP_NULL_POINTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_ENUMERATOR: +- reason = "STATUS_FWP_INVALID_ENUMERATOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_FLAGS: +- reason = "STATUS_FWP_INVALID_FLAGS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_NET_MASK: +- reason = "STATUS_FWP_INVALID_NET_MASK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_RANGE: +- reason = "STATUS_FWP_INVALID_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_INTERVAL: +- reason = "STATUS_FWP_INVALID_INTERVAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_ZERO_LENGTH_ARRAY: +- reason = "STATUS_FWP_ZERO_LENGTH_ARRAY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NULL_DISPLAY_NAME: +- reason = "STATUS_FWP_NULL_DISPLAY_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_ACTION_TYPE: +- reason = "STATUS_FWP_INVALID_ACTION_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_WEIGHT: +- reason = "STATUS_FWP_INVALID_WEIGHT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_MATCH_TYPE_MISMATCH: +- reason = "STATUS_FWP_MATCH_TYPE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TYPE_MISMATCH: +- reason = "STATUS_FWP_TYPE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_OUT_OF_BOUNDS: +- reason = "STATUS_FWP_OUT_OF_BOUNDS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_RESERVED: +- reason = "STATUS_FWP_RESERVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_CONDITION: +- reason = "STATUS_FWP_DUPLICATE_CONDITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_KEYMOD: +- reason = "STATUS_FWP_DUPLICATE_KEYMOD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER: +- reason = "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER: +- reason = "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER: +- reason = "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT: +- reason = "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_AUTH_METHOD: +- reason = "STATUS_FWP_INCOMPATIBLE_AUTH_METHOD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_DH_GROUP: +- reason = "STATUS_FWP_INCOMPATIBLE_DH_GROUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_EM_NOT_SUPPORTED: +- reason = "STATUS_FWP_EM_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_NEVER_MATCH: +- reason = "STATUS_FWP_NEVER_MATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_CONTEXT_MISMATCH: +- reason = "STATUS_FWP_PROVIDER_CONTEXT_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_PARAMETER: +- reason = "STATUS_FWP_INVALID_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TOO_MANY_SUBLAYERS: +- reason = "STATUS_FWP_TOO_MANY_SUBLAYERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOTIFICATION_FAILED: +- reason = "STATUS_FWP_CALLOUT_NOTIFICATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_AUTH_TRANSFORM: +- reason = "STATUS_FWP_INVALID_AUTH_TRANSFORM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_CIPHER_TRANSFORM: +- reason = "STATUS_FWP_INVALID_CIPHER_TRANSFORM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM: +- reason = "STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_TRANSFORM_COMBINATION: +- reason = "STATUS_FWP_INVALID_TRANSFORM_COMBINATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_AUTH_METHOD: +- reason = "STATUS_FWP_DUPLICATE_AUTH_METHOD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_TUNNEL_ENDPOINT: +- reason = "STATUS_FWP_INVALID_TUNNEL_ENDPOINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_L2_DRIVER_NOT_READY: +- reason = "STATUS_FWP_L2_DRIVER_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED: +- reason = "STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL: +- reason = "STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CONNECTIONS_DISABLED: +- reason = "STATUS_FWP_CONNECTIONS_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INVALID_DNS_NAME: +- reason = "STATUS_FWP_INVALID_DNS_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_STILL_ON: +- reason = "STATUS_FWP_STILL_ON"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_IKEEXT_NOT_RUNNING: +- reason = "STATUS_FWP_IKEEXT_NOT_RUNNING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_TCPIP_NOT_READY: +- reason = "STATUS_FWP_TCPIP_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INJECT_HANDLE_CLOSING: +- reason = "STATUS_FWP_INJECT_HANDLE_CLOSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_INJECT_HANDLE_STALE: +- reason = "STATUS_FWP_INJECT_HANDLE_STALE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_CANNOT_PEND: +- reason = "STATUS_FWP_CANNOT_PEND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_FWP_DROP_NOICMP: +- reason = "STATUS_FWP_DROP_NOICMP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_CLOSING: +- reason = "STATUS_NDIS_CLOSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_BAD_VERSION: +- reason = "STATUS_NDIS_BAD_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_BAD_CHARACTERISTICS: +- reason = "STATUS_NDIS_BAD_CHARACTERISTICS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_NOT_FOUND: +- reason = "STATUS_NDIS_ADAPTER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_OPEN_FAILED: +- reason = "STATUS_NDIS_OPEN_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DEVICE_FAILED: +- reason = "STATUS_NDIS_DEVICE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_FULL: +- reason = "STATUS_NDIS_MULTICAST_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_EXISTS: +- reason = "STATUS_NDIS_MULTICAST_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_NOT_FOUND: +- reason = "STATUS_NDIS_MULTICAST_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_REQUEST_ABORTED: +- reason = "STATUS_NDIS_REQUEST_ABORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_RESET_IN_PROGRESS: +- reason = "STATUS_NDIS_RESET_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PACKET: +- reason = "STATUS_NDIS_INVALID_PACKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_DEVICE_REQUEST: +- reason = "STATUS_NDIS_INVALID_DEVICE_REQUEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_NOT_READY: +- reason = "STATUS_NDIS_ADAPTER_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_LENGTH: +- reason = "STATUS_NDIS_INVALID_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_DATA: +- reason = "STATUS_NDIS_INVALID_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_BUFFER_TOO_SHORT: +- reason = "STATUS_NDIS_BUFFER_TOO_SHORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_OID: +- reason = "STATUS_NDIS_INVALID_OID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_REMOVED: +- reason = "STATUS_NDIS_ADAPTER_REMOVED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_UNSUPPORTED_MEDIA: +- reason = "STATUS_NDIS_UNSUPPORTED_MEDIA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_GROUP_ADDRESS_IN_USE: +- reason = "STATUS_NDIS_GROUP_ADDRESS_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_FILE_NOT_FOUND: +- reason = "STATUS_NDIS_FILE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_ERROR_READING_FILE: +- reason = "STATUS_NDIS_ERROR_READING_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_ALREADY_MAPPED: +- reason = "STATUS_NDIS_ALREADY_MAPPED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_RESOURCE_CONFLICT: +- reason = "STATUS_NDIS_RESOURCE_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_MEDIA_DISCONNECTED: +- reason = "STATUS_NDIS_MEDIA_DISCONNECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_ADDRESS: +- reason = "STATUS_NDIS_INVALID_ADDRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_PAUSED: +- reason = "STATUS_NDIS_PAUSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INTERFACE_NOT_FOUND: +- reason = "STATUS_NDIS_INTERFACE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_UNSUPPORTED_REVISION: +- reason = "STATUS_NDIS_UNSUPPORTED_REVISION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT: +- reason = "STATUS_NDIS_INVALID_PORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT_STATE: +- reason = "STATUS_NDIS_INVALID_PORT_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_LOW_POWER_STATE: +- reason = "STATUS_NDIS_LOW_POWER_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_REINIT_REQUIRED: +- reason = "STATUS_NDIS_REINIT_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_NO_QUEUES: +- reason = "STATUS_NDIS_NO_QUEUES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_NOT_SUPPORTED: +- reason = "STATUS_NDIS_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_POLICY: +- reason = "STATUS_NDIS_OFFLOAD_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED: +- reason = "STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_PATH_REJECTED: +- reason = "STATUS_NDIS_OFFLOAD_PATH_REJECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED: +- reason = "STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_MEDIA_IN_USE: +- reason = "STATUS_NDIS_DOT11_MEDIA_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_POWER_STATE_INVALID: +- reason = "STATUS_NDIS_DOT11_POWER_STATE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL: +- reason = "STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL: +- reason = "STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE: +- reason = "STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE: +- reason = "STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED: +- reason = "STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED: +- reason = "STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUIC_HANDSHAKE_FAILURE: +- reason = "STATUS_QUIC_HANDSHAKE_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_QUIC_VER_NEG_FAILURE: +- reason = "STATUS_QUIC_VER_NEG_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_ERROR_MASK: +- reason = "STATUS_TPM_ERROR_MASK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUTHFAIL: +- reason = "STATUS_TPM_AUTHFAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BADINDEX: +- reason = "STATUS_TPM_BADINDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_PARAMETER: +- reason = "STATUS_TPM_BAD_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAILURE: +- reason = "STATUS_TPM_AUDITFAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_CLEAR_DISABLED: +- reason = "STATUS_TPM_CLEAR_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DEACTIVATED: +- reason = "STATUS_TPM_DEACTIVATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DISABLED: +- reason = "STATUS_TPM_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DISABLED_CMD: +- reason = "STATUS_TPM_DISABLED_CMD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_FAIL: +- reason = "STATUS_TPM_FAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_ORDINAL: +- reason = "STATUS_TPM_BAD_ORDINAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INSTALL_DISABLED: +- reason = "STATUS_TPM_INSTALL_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_KEYHANDLE: +- reason = "STATUS_TPM_INVALID_KEYHANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_KEYNOTFOUND: +- reason = "STATUS_TPM_KEYNOTFOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INAPPROPRIATE_ENC: +- reason = "STATUS_TPM_INAPPROPRIATE_ENC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MIGRATEFAIL: +- reason = "STATUS_TPM_MIGRATEFAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_PCR_INFO: +- reason = "STATUS_TPM_INVALID_PCR_INFO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOSPACE: +- reason = "STATUS_TPM_NOSPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOSRK: +- reason = "STATUS_TPM_NOSRK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOTSEALED_BLOB: +- reason = "STATUS_TPM_NOTSEALED_BLOB"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_OWNER_SET: +- reason = "STATUS_TPM_OWNER_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_RESOURCES: +- reason = "STATUS_TPM_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_SHORTRANDOM: +- reason = "STATUS_TPM_SHORTRANDOM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_SIZE: +- reason = "STATUS_TPM_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_WRONGPCRVAL: +- reason = "STATUS_TPM_WRONGPCRVAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_PARAM_SIZE: +- reason = "STATUS_TPM_BAD_PARAM_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_SHA_THREAD: +- reason = "STATUS_TPM_SHA_THREAD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_SHA_ERROR: +- reason = "STATUS_TPM_SHA_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_FAILEDSELFTEST: +- reason = "STATUS_TPM_FAILEDSELFTEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUTH2FAIL: +- reason = "STATUS_TPM_AUTH2FAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BADTAG: +- reason = "STATUS_TPM_BADTAG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_IOERROR: +- reason = "STATUS_TPM_IOERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_ENCRYPT_ERROR: +- reason = "STATUS_TPM_ENCRYPT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DECRYPT_ERROR: +- reason = "STATUS_TPM_DECRYPT_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_AUTHHANDLE: +- reason = "STATUS_TPM_INVALID_AUTHHANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NO_ENDORSEMENT: +- reason = "STATUS_TPM_NO_ENDORSEMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_KEYUSAGE: +- reason = "STATUS_TPM_INVALID_KEYUSAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_WRONG_ENTITYTYPE: +- reason = "STATUS_TPM_WRONG_ENTITYTYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_POSTINIT: +- reason = "STATUS_TPM_INVALID_POSTINIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INAPPROPRIATE_SIG: +- reason = "STATUS_TPM_INAPPROPRIATE_SIG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_KEY_PROPERTY: +- reason = "STATUS_TPM_BAD_KEY_PROPERTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_MIGRATION: +- reason = "STATUS_TPM_BAD_MIGRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_SCHEME: +- reason = "STATUS_TPM_BAD_SCHEME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_DATASIZE: +- reason = "STATUS_TPM_BAD_DATASIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_MODE: +- reason = "STATUS_TPM_BAD_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_PRESENCE: +- reason = "STATUS_TPM_BAD_PRESENCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_VERSION: +- reason = "STATUS_TPM_BAD_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NO_WRAP_TRANSPORT: +- reason = "STATUS_TPM_NO_WRAP_TRANSPORT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAIL_UNSUCCESSFUL: +- reason = "STATUS_TPM_AUDITFAIL_UNSUCCESSFUL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAIL_SUCCESSFUL: +- reason = "STATUS_TPM_AUDITFAIL_SUCCESSFUL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOTRESETABLE: +- reason = "STATUS_TPM_NOTRESETABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOTLOCAL: +- reason = "STATUS_TPM_NOTLOCAL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_TYPE: +- reason = "STATUS_TPM_BAD_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_RESOURCE: +- reason = "STATUS_TPM_INVALID_RESOURCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOTFIPS: +- reason = "STATUS_TPM_NOTFIPS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_FAMILY: +- reason = "STATUS_TPM_INVALID_FAMILY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NO_NV_PERMISSION: +- reason = "STATUS_TPM_NO_NV_PERMISSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_REQUIRES_SIGN: +- reason = "STATUS_TPM_REQUIRES_SIGN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_KEY_NOTSUPPORTED: +- reason = "STATUS_TPM_KEY_NOTSUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AUTH_CONFLICT: +- reason = "STATUS_TPM_AUTH_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_AREA_LOCKED: +- reason = "STATUS_TPM_AREA_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_LOCALITY: +- reason = "STATUS_TPM_BAD_LOCALITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_READ_ONLY: +- reason = "STATUS_TPM_READ_ONLY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_PER_NOWRITE: +- reason = "STATUS_TPM_PER_NOWRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_FAMILYCOUNT: +- reason = "STATUS_TPM_FAMILYCOUNT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_WRITE_LOCKED: +- reason = "STATUS_TPM_WRITE_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_ATTRIBUTES: +- reason = "STATUS_TPM_BAD_ATTRIBUTES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_STRUCTURE: +- reason = "STATUS_TPM_INVALID_STRUCTURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_KEY_OWNER_CONTROL: +- reason = "STATUS_TPM_KEY_OWNER_CONTROL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_COUNTER: +- reason = "STATUS_TPM_BAD_COUNTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOT_FULLWRITE: +- reason = "STATUS_TPM_NOT_FULLWRITE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_CONTEXT_GAP: +- reason = "STATUS_TPM_CONTEXT_GAP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MAXNVWRITES: +- reason = "STATUS_TPM_MAXNVWRITES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOOPERATOR: +- reason = "STATUS_TPM_NOOPERATOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_RESOURCEMISSING: +- reason = "STATUS_TPM_RESOURCEMISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_LOCK: +- reason = "STATUS_TPM_DELEGATE_LOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_FAMILY: +- reason = "STATUS_TPM_DELEGATE_FAMILY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_ADMIN: +- reason = "STATUS_TPM_DELEGATE_ADMIN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_TRANSPORT_NOTEXCLUSIVE: +- reason = "STATUS_TPM_TRANSPORT_NOTEXCLUSIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_OWNER_CONTROL: +- reason = "STATUS_TPM_OWNER_CONTROL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_RESOURCES: +- reason = "STATUS_TPM_DAA_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_INPUT_DATA0: +- reason = "STATUS_TPM_DAA_INPUT_DATA0"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_INPUT_DATA1: +- reason = "STATUS_TPM_DAA_INPUT_DATA1"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_ISSUER_SETTINGS: +- reason = "STATUS_TPM_DAA_ISSUER_SETTINGS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_TPM_SETTINGS: +- reason = "STATUS_TPM_DAA_TPM_SETTINGS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_STAGE: +- reason = "STATUS_TPM_DAA_STAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_ISSUER_VALIDITY: +- reason = "STATUS_TPM_DAA_ISSUER_VALIDITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DAA_WRONG_W: +- reason = "STATUS_TPM_DAA_WRONG_W"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_HANDLE: +- reason = "STATUS_TPM_BAD_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_DELEGATE: +- reason = "STATUS_TPM_BAD_DELEGATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BADCONTEXT: +- reason = "STATUS_TPM_BADCONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_TOOMANYCONTEXTS: +- reason = "STATUS_TPM_TOOMANYCONTEXTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MA_TICKET_SIGNATURE: +- reason = "STATUS_TPM_MA_TICKET_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MA_DESTINATION: +- reason = "STATUS_TPM_MA_DESTINATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MA_SOURCE: +- reason = "STATUS_TPM_MA_SOURCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_MA_AUTHORITY: +- reason = "STATUS_TPM_MA_AUTHORITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_PERMANENTEK: +- reason = "STATUS_TPM_PERMANENTEK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_BAD_SIGNATURE: +- reason = "STATUS_TPM_BAD_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOCONTEXTSPACE: +- reason = "STATUS_TPM_NOCONTEXTSPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ASYMMETRIC: +- reason = "STATUS_TPM_20_E_ASYMMETRIC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ATTRIBUTES: +- reason = "STATUS_TPM_20_E_ATTRIBUTES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HASH: +- reason = "STATUS_TPM_20_E_HASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_VALUE: +- reason = "STATUS_TPM_20_E_VALUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HIERARCHY: +- reason = "STATUS_TPM_20_E_HIERARCHY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY_SIZE: +- reason = "STATUS_TPM_20_E_KEY_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_MGF: +- reason = "STATUS_TPM_20_E_MGF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_MODE: +- reason = "STATUS_TPM_20_E_MODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TYPE: +- reason = "STATUS_TPM_20_E_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HANDLE: +- reason = "STATUS_TPM_20_E_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KDF: +- reason = "STATUS_TPM_20_E_KDF"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_RANGE: +- reason = "STATUS_TPM_20_E_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_FAIL: +- reason = "STATUS_TPM_20_E_AUTH_FAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NONCE: +- reason = "STATUS_TPM_20_E_NONCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PP: +- reason = "STATUS_TPM_20_E_PP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SCHEME: +- reason = "STATUS_TPM_20_E_SCHEME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIZE: +- reason = "STATUS_TPM_20_E_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SYMMETRIC: +- reason = "STATUS_TPM_20_E_SYMMETRIC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TAG: +- reason = "STATUS_TPM_20_E_TAG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SELECTOR: +- reason = "STATUS_TPM_20_E_SELECTOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INSUFFICIENT: +- reason = "STATUS_TPM_20_E_INSUFFICIENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIGNATURE: +- reason = "STATUS_TPM_20_E_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY: +- reason = "STATUS_TPM_20_E_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_FAIL: +- reason = "STATUS_TPM_20_E_POLICY_FAIL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INTEGRITY: +- reason = "STATUS_TPM_20_E_INTEGRITY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TICKET: +- reason = "STATUS_TPM_20_E_TICKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_RESERVED_BITS: +- reason = "STATUS_TPM_20_E_RESERVED_BITS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_AUTH: +- reason = "STATUS_TPM_20_E_BAD_AUTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXPIRED: +- reason = "STATUS_TPM_20_E_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_CC: +- reason = "STATUS_TPM_20_E_POLICY_CC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BINDING: +- reason = "STATUS_TPM_20_E_BINDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_CURVE: +- reason = "STATUS_TPM_20_E_CURVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_POINT: +- reason = "STATUS_TPM_20_E_ECC_POINT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_INITIALIZE: +- reason = "STATUS_TPM_20_E_INITIALIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_FAILURE: +- reason = "STATUS_TPM_20_E_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SEQUENCE: +- reason = "STATUS_TPM_20_E_SEQUENCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PRIVATE: +- reason = "STATUS_TPM_20_E_PRIVATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_HMAC: +- reason = "STATUS_TPM_20_E_HMAC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_DISABLED: +- reason = "STATUS_TPM_20_E_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXCLUSIVE: +- reason = "STATUS_TPM_20_E_EXCLUSIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_CURVE: +- reason = "STATUS_TPM_20_E_ECC_CURVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_TYPE: +- reason = "STATUS_TPM_20_E_AUTH_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_MISSING: +- reason = "STATUS_TPM_20_E_AUTH_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY: +- reason = "STATUS_TPM_20_E_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR: +- reason = "STATUS_TPM_20_E_PCR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR_CHANGED: +- reason = "STATUS_TPM_20_E_PCR_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_UPGRADE: +- reason = "STATUS_TPM_20_E_UPGRADE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_TOO_MANY_CONTEXTS: +- reason = "STATUS_TPM_20_E_TOO_MANY_CONTEXTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_UNAVAILABLE: +- reason = "STATUS_TPM_20_E_AUTH_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_REBOOT: +- reason = "STATUS_TPM_20_E_REBOOT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_UNBALANCED: +- reason = "STATUS_TPM_20_E_UNBALANCED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_SIZE: +- reason = "STATUS_TPM_20_E_COMMAND_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_CODE: +- reason = "STATUS_TPM_20_E_COMMAND_CODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTHSIZE: +- reason = "STATUS_TPM_20_E_AUTHSIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_CONTEXT: +- reason = "STATUS_TPM_20_E_AUTH_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_RANGE: +- reason = "STATUS_TPM_20_E_NV_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SIZE: +- reason = "STATUS_TPM_20_E_NV_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_LOCKED: +- reason = "STATUS_TPM_20_E_NV_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_AUTHORIZATION: +- reason = "STATUS_TPM_20_E_NV_AUTHORIZATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_UNINITIALIZED: +- reason = "STATUS_TPM_20_E_NV_UNINITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SPACE: +- reason = "STATUS_TPM_20_E_NV_SPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_DEFINED: +- reason = "STATUS_TPM_20_E_NV_DEFINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_CONTEXT: +- reason = "STATUS_TPM_20_E_BAD_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_CPHASH: +- reason = "STATUS_TPM_20_E_CPHASH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_PARENT: +- reason = "STATUS_TPM_20_E_PARENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NEEDS_TEST: +- reason = "STATUS_TPM_20_E_NEEDS_TEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_NO_RESULT: +- reason = "STATUS_TPM_20_E_NO_RESULT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_20_E_SENSITIVE: +- reason = "STATUS_TPM_20_E_SENSITIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_BLOCKED: +- reason = "STATUS_TPM_COMMAND_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INVALID_HANDLE: +- reason = "STATUS_TPM_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DUPLICATE_VHANDLE: +- reason = "STATUS_TPM_DUPLICATE_VHANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_BLOCKED: +- reason = "STATUS_TPM_EMBEDDED_COMMAND_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED: +- reason = "STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_RETRY: +- reason = "STATUS_TPM_RETRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NEEDS_SELFTEST: +- reason = "STATUS_TPM_NEEDS_SELFTEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DOING_SELFTEST: +- reason = "STATUS_TPM_DOING_SELFTEST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_DEFEND_LOCK_RUNNING: +- reason = "STATUS_TPM_DEFEND_LOCK_RUNNING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_CANCELED: +- reason = "STATUS_TPM_COMMAND_CANCELED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_TOO_MANY_CONTEXTS: +- reason = "STATUS_TPM_TOO_MANY_CONTEXTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_NOT_FOUND: +- reason = "STATUS_TPM_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_ACCESS_DENIED: +- reason = "STATUS_TPM_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_INSUFFICIENT_BUFFER: +- reason = "STATUS_TPM_INSUFFICIENT_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_PPI_FUNCTION_UNSUPPORTED: +- reason = "STATUS_TPM_PPI_FUNCTION_UNSUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_ERROR_MASK: +- reason = "STATUS_PCP_ERROR_MASK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_READY: +- reason = "STATUS_PCP_DEVICE_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_INVALID_HANDLE: +- reason = "STATUS_PCP_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_INVALID_PARAMETER: +- reason = "STATUS_PCP_INVALID_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_FLAG_NOT_SUPPORTED: +- reason = "STATUS_PCP_FLAG_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_NOT_SUPPORTED: +- reason = "STATUS_PCP_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_TOO_SMALL: +- reason = "STATUS_PCP_BUFFER_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_INTERNAL_ERROR: +- reason = "STATUS_PCP_INTERNAL_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_FAILED: +- reason = "STATUS_PCP_AUTHENTICATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_IGNORED: +- reason = "STATUS_PCP_AUTHENTICATION_IGNORED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_POLICY_NOT_FOUND: +- reason = "STATUS_PCP_POLICY_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_PROFILE_NOT_FOUND: +- reason = "STATUS_PCP_PROFILE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_VALIDATION_FAILED: +- reason = "STATUS_PCP_VALIDATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_FOUND: +- reason = "STATUS_PCP_DEVICE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_WRONG_PARENT: +- reason = "STATUS_PCP_WRONG_PARENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_LOADED: +- reason = "STATUS_PCP_KEY_NOT_LOADED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_NO_KEY_CERTIFICATION: +- reason = "STATUS_PCP_NO_KEY_CERTIFICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_FINALIZED: +- reason = "STATUS_PCP_KEY_NOT_FINALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET: +- reason = "STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_NOT_PCR_BOUND: +- reason = "STATUS_PCP_NOT_PCR_BOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_ALREADY_FINALIZED: +- reason = "STATUS_PCP_KEY_ALREADY_FINALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED: +- reason = "STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_INVALID: +- reason = "STATUS_PCP_KEY_USAGE_POLICY_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_SOFT_KEY_ERROR: +- reason = "STATUS_PCP_SOFT_KEY_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AUTHENTICATED: +- reason = "STATUS_PCP_KEY_NOT_AUTHENTICATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AIK: +- reason = "STATUS_PCP_KEY_NOT_AIK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_SIGNING_KEY: +- reason = "STATUS_PCP_KEY_NOT_SIGNING_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_LOCKED_OUT: +- reason = "STATUS_PCP_LOCKED_OUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED: +- reason = "STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_TPM_VERSION_NOT_SUPPORTED: +- reason = "STATUS_PCP_TPM_VERSION_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_LENGTH_MISMATCH: +- reason = "STATUS_PCP_BUFFER_LENGTH_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED: +- reason = "STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_TICKET_MISSING: +- reason = "STATUS_PCP_TICKET_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_RAW_POLICY_NOT_SUPPORTED: +- reason = "STATUS_PCP_RAW_POLICY_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PCP_KEY_HANDLE_INVALIDATED: +- reason = "STATUS_PCP_KEY_HANDLE_INVALIDATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_NO_RESULT: +- reason = "STATUS_RTPM_NO_RESULT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_PCR_READ_INCOMPLETE: +- reason = "STATUS_RTPM_PCR_READ_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_INVALID_CONTEXT: +- reason = "STATUS_RTPM_INVALID_CONTEXT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RTPM_UNSUPPORTED_CMD: +- reason = "STATUS_RTPM_UNSUPPORTED_CMD"; +- break; +- case MD_NTSTATUS_WIN_STATUS_TPM_ZERO_EXHAUST_ENABLED: +- reason = "STATUS_TPM_ZERO_EXHAUST_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_CODE: +- reason = "STATUS_HV_INVALID_HYPERCALL_CODE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_INPUT: +- reason = "STATUS_HV_INVALID_HYPERCALL_INPUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_ALIGNMENT: +- reason = "STATUS_HV_INVALID_ALIGNMENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARAMETER: +- reason = "STATUS_HV_INVALID_PARAMETER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_ACCESS_DENIED: +- reason = "STATUS_HV_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_STATE: +- reason = "STATUS_HV_INVALID_PARTITION_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_OPERATION_DENIED: +- reason = "STATUS_HV_OPERATION_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_UNKNOWN_PROPERTY: +- reason = "STATUS_HV_UNKNOWN_PROPERTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE: +- reason = "STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_MEMORY: +- reason = "STATUS_HV_INSUFFICIENT_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_PARTITION_TOO_DEEP: +- reason = "STATUS_HV_PARTITION_TOO_DEEP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_ID: +- reason = "STATUS_HV_INVALID_PARTITION_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_INDEX: +- reason = "STATUS_HV_INVALID_VP_INDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_PORT_ID: +- reason = "STATUS_HV_INVALID_PORT_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_CONNECTION_ID: +- reason = "STATUS_HV_INVALID_CONNECTION_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFERS: +- reason = "STATUS_HV_INSUFFICIENT_BUFFERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NOT_ACKNOWLEDGED: +- reason = "STATUS_HV_NOT_ACKNOWLEDGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_STATE: +- reason = "STATUS_HV_INVALID_VP_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_ACKNOWLEDGED: +- reason = "STATUS_HV_ACKNOWLEDGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_SAVE_RESTORE_STATE: +- reason = "STATUS_HV_INVALID_SAVE_RESTORE_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_SYNIC_STATE: +- reason = "STATUS_HV_INVALID_SYNIC_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_OBJECT_IN_USE: +- reason = "STATUS_HV_OBJECT_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO: +- reason = "STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NO_DATA: +- reason = "STATUS_HV_NO_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INACTIVE: +- reason = "STATUS_HV_INACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NO_RESOURCES: +- reason = "STATUS_HV_NO_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_FEATURE_UNAVAILABLE: +- reason = "STATUS_HV_FEATURE_UNAVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFER: +- reason = "STATUS_HV_INSUFFICIENT_BUFFER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS: +- reason = "STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR: +- reason = "STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR: +- reason = "STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_PROCESSOR_STARTUP_TIMEOUT: +- reason = "STATUS_HV_PROCESSOR_STARTUP_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_SMX_ENABLED: +- reason = "STATUS_HV_SMX_ENABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_LP_INDEX: +- reason = "STATUS_HV_INVALID_LP_INDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_REGISTER_VALUE: +- reason = "STATUS_HV_INVALID_REGISTER_VALUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_VTL_STATE: +- reason = "STATUS_HV_INVALID_VTL_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NX_NOT_DETECTED: +- reason = "STATUS_HV_NX_NOT_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_ID: +- reason = "STATUS_HV_INVALID_DEVICE_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_STATE: +- reason = "STATUS_HV_INVALID_DEVICE_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_PAGE_REQUEST_INVALID: +- reason = "STATUS_HV_PAGE_REQUEST_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_ID: +- reason = "STATUS_HV_INVALID_CPU_GROUP_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_STATE: +- reason = "STATUS_HV_INVALID_CPU_GROUP_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_OPERATION_FAILED: +- reason = "STATUS_HV_OPERATION_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE: +- reason = "STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_ROOT_MEMORY: +- reason = "STATUS_HV_INSUFFICIENT_ROOT_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_EVENT_BUFFER_ALREADY_FREED: +- reason = "STATUS_HV_EVENT_BUFFER_ALREADY_FREED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY: +- reason = "STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HV_NOT_PRESENT: +- reason = "STATUS_HV_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_BAD_SPI: +- reason = "STATUS_IPSEC_BAD_SPI"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_SA_LIFETIME_EXPIRED: +- reason = "STATUS_IPSEC_SA_LIFETIME_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_WRONG_SA: +- reason = "STATUS_IPSEC_WRONG_SA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_REPLAY_CHECK_FAILED: +- reason = "STATUS_IPSEC_REPLAY_CHECK_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_INVALID_PACKET: +- reason = "STATUS_IPSEC_INVALID_PACKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_INTEGRITY_CHECK_FAILED: +- reason = "STATUS_IPSEC_INTEGRITY_CHECK_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_CLEAR_TEXT_DROP: +- reason = "STATUS_IPSEC_CLEAR_TEXT_DROP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_AUTH_FIREWALL_DROP: +- reason = "STATUS_IPSEC_AUTH_FIREWALL_DROP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_THROTTLE_DROP: +- reason = "STATUS_IPSEC_THROTTLE_DROP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_BLOCK: +- reason = "STATUS_IPSEC_DOSP_BLOCK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_RECEIVED_MULTICAST: +- reason = "STATUS_IPSEC_DOSP_RECEIVED_MULTICAST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_INVALID_PACKET: +- reason = "STATUS_IPSEC_DOSP_INVALID_PACKET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED: +- reason = "STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_MAX_ENTRIES: +- reason = "STATUS_IPSEC_DOSP_MAX_ENTRIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED: +- reason = "STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES: +- reason = "STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_DUPLICATE_HANDLER: +- reason = "STATUS_VID_DUPLICATE_HANDLER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_TOO_MANY_HANDLERS: +- reason = "STATUS_VID_TOO_MANY_HANDLERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_QUEUE_FULL: +- reason = "STATUS_VID_QUEUE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_HANDLER_NOT_PRESENT: +- reason = "STATUS_VID_HANDLER_NOT_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_OBJECT_NAME: +- reason = "STATUS_VID_INVALID_OBJECT_NAME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_PARTITION_NAME_TOO_LONG: +- reason = "STATUS_VID_PARTITION_NAME_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG: +- reason = "STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_PARTITION_ALREADY_EXISTS: +- reason = "STATUS_VID_PARTITION_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_PARTITION_DOES_NOT_EXIST: +- reason = "STATUS_VID_PARTITION_DOES_NOT_EXIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_PARTITION_NAME_NOT_FOUND: +- reason = "STATUS_VID_PARTITION_NAME_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS: +- reason = "STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT: +- reason = "STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MB_STILL_REFERENCED: +- reason = "STATUS_VID_MB_STILL_REFERENCED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED: +- reason = "STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_NUMA_SETTINGS: +- reason = "STATUS_VID_INVALID_NUMA_SETTINGS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_NUMA_NODE_INDEX: +- reason = "STATUS_VID_INVALID_NUMA_NODE_INDEX"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED: +- reason = "STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE: +- reason = "STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_PAGE_RANGE_OVERFLOW: +- reason = "STATUS_VID_PAGE_RANGE_OVERFLOW"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE: +- reason = "STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_GPA_RANGE_HANDLE: +- reason = "STATUS_VID_INVALID_GPA_RANGE_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE: +- reason = "STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED: +- reason = "STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_PPM_HANDLE: +- reason = "STATUS_VID_INVALID_PPM_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MBPS_ARE_LOCKED: +- reason = "STATUS_VID_MBPS_ARE_LOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_CLOSED: +- reason = "STATUS_VID_MESSAGE_QUEUE_CLOSED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED: +- reason = "STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_STOP_PENDING: +- reason = "STATUS_VID_STOP_PENDING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_PROCESSOR_STATE: +- reason = "STATUS_VID_INVALID_PROCESSOR_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT: +- reason = "STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED: +- reason = "STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET: +- reason = "STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MMIO_RANGE_DESTROYED: +- reason = "STATUS_VID_MMIO_RANGE_DESTROYED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_INVALID_CHILD_GPA_PAGE_SET: +- reason = "STATUS_VID_INVALID_CHILD_GPA_PAGE_SET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED: +- reason = "STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL: +- reason = "STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE: +- reason = "STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT: +- reason = "STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_CORRUPT: +- reason = "STATUS_VID_SAVED_STATE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM: +- reason = "STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_INCOMPATIBLE: +- reason = "STATUS_VID_SAVED_STATE_INCOMPATIBLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VID_VTL_ACCESS_DENIED: +- reason = "STATUS_VID_VTL_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DATABASE_FULL: +- reason = "STATUS_VOLMGR_DATABASE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED: +- reason = "STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC: +- reason = "STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED: +- reason = "STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME: +- reason = "STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DUPLICATE: +- reason = "STATUS_VOLMGR_DISK_DUPLICATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DYNAMIC: +- reason = "STATUS_VOLMGR_DISK_DYNAMIC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_ID_INVALID: +- reason = "STATUS_VOLMGR_DISK_ID_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_INVALID: +- reason = "STATUS_VOLMGR_DISK_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAST_VOTER: +- reason = "STATUS_VOLMGR_DISK_LAST_VOTER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_INVALID: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS: +- reason = "STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_MISSING: +- reason = "STATUS_VOLMGR_DISK_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_NOT_EMPTY: +- reason = "STATUS_VOLMGR_DISK_NOT_EMPTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE: +- reason = "STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_REVECTORING_FAILED: +- reason = "STATUS_VOLMGR_DISK_REVECTORING_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID: +- reason = "STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_SET_NOT_CONTAINED: +- reason = "STATUS_VOLMGR_DISK_SET_NOT_CONTAINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS: +- reason = "STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES: +- reason = "STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED: +- reason = "STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_ALREADY_USED: +- reason = "STATUS_VOLMGR_EXTENT_ALREADY_USED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS: +- reason = "STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION: +- reason = "STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED: +- reason = "STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION: +- reason = "STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH: +- reason = "STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED: +- reason = "STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID: +- reason = "STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS: +- reason = "STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_IN_SYNC: +- reason = "STATUS_VOLMGR_MEMBER_IN_SYNC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE: +- reason = "STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_INDEX_INVALID: +- reason = "STATUS_VOLMGR_MEMBER_INDEX_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_MISSING: +- reason = "STATUS_VOLMGR_MEMBER_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_NOT_DETACHED: +- reason = "STATUS_VOLMGR_MEMBER_NOT_DETACHED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_REGENERATING: +- reason = "STATUS_VOLMGR_MEMBER_REGENERATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_ALL_DISKS_FAILED: +- reason = "STATUS_VOLMGR_ALL_DISKS_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_REGISTERED_USERS: +- reason = "STATUS_VOLMGR_NO_REGISTERED_USERS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_SUCH_USER: +- reason = "STATUS_VOLMGR_NO_SUCH_USER"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NOTIFICATION_RESET: +- reason = "STATUS_VOLMGR_NOTIFICATION_RESET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_DUPLICATE: +- reason = "STATUS_VOLMGR_PACK_DUPLICATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_ID_INVALID: +- reason = "STATUS_VOLMGR_PACK_ID_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_INVALID: +- reason = "STATUS_VOLMGR_PACK_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_NAME_INVALID: +- reason = "STATUS_VOLMGR_PACK_NAME_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_OFFLINE: +- reason = "STATUS_VOLMGR_PACK_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_HAS_QUORUM: +- reason = "STATUS_VOLMGR_PACK_HAS_QUORUM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_WITHOUT_QUORUM: +- reason = "STATUS_VOLMGR_PACK_WITHOUT_QUORUM"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PARTITION_STYLE_INVALID: +- reason = "STATUS_VOLMGR_PARTITION_STYLE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PARTITION_UPDATE_FAILED: +- reason = "STATUS_VOLMGR_PARTITION_UPDATE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_IN_SYNC: +- reason = "STATUS_VOLMGR_PLEX_IN_SYNC"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_INDEX_DUPLICATE: +- reason = "STATUS_VOLMGR_PLEX_INDEX_DUPLICATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_INDEX_INVALID: +- reason = "STATUS_VOLMGR_PLEX_INDEX_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_LAST_ACTIVE: +- reason = "STATUS_VOLMGR_PLEX_LAST_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_MISSING: +- reason = "STATUS_VOLMGR_PLEX_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_REGENERATING: +- reason = "STATUS_VOLMGR_PLEX_REGENERATING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_TYPE_INVALID: +- reason = "STATUS_VOLMGR_PLEX_TYPE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_RAID5: +- reason = "STATUS_VOLMGR_PLEX_NOT_RAID5"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_SIMPLE: +- reason = "STATUS_VOLMGR_PLEX_NOT_SIMPLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_STRUCTURE_SIZE_INVALID: +- reason = "STATUS_VOLMGR_STRUCTURE_SIZE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS: +- reason = "STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_TRANSACTION_IN_PROGRESS: +- reason = "STATUS_VOLMGR_TRANSACTION_IN_PROGRESS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE: +- reason = "STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK: +- reason = "STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_ID_INVALID: +- reason = "STATUS_VOLMGR_VOLUME_ID_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_LENGTH_INVALID: +- reason = "STATUS_VOLMGR_VOLUME_LENGTH_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE: +- reason = "STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_NOT_MIRRORED: +- reason = "STATUS_VOLMGR_VOLUME_NOT_MIRRORED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_NOT_RETAINED: +- reason = "STATUS_VOLMGR_VOLUME_NOT_RETAINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_OFFLINE: +- reason = "STATUS_VOLMGR_VOLUME_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_RETAINED: +- reason = "STATUS_VOLMGR_VOLUME_RETAINED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE: +- reason = "STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_BAD_BOOT_DISK: +- reason = "STATUS_VOLMGR_BAD_BOOT_DISK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_OFFLINE: +- reason = "STATUS_VOLMGR_PACK_CONFIG_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_ONLINE: +- reason = "STATUS_VOLMGR_PACK_CONFIG_ONLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NOT_PRIMARY_PACK: +- reason = "STATUS_VOLMGR_NOT_PRIMARY_PACK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED: +- reason = "STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_MIRRORED: +- reason = "STATUS_VOLMGR_VOLUME_MIRRORED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED: +- reason = "STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_VALID_LOG_COPIES: +- reason = "STATUS_VOLMGR_NO_VALID_LOG_COPIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_PRIMARY_PACK_PRESENT: +- reason = "STATUS_VOLMGR_PRIMARY_PACK_PRESENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID: +- reason = "STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_MIRROR_NOT_SUPPORTED: +- reason = "STATUS_VOLMGR_MIRROR_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLMGR_RAID5_NOT_SUPPORTED: +- reason = "STATUS_VOLMGR_RAID5_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BCD_TOO_MANY_ELEMENTS: +- reason = "STATUS_BCD_TOO_MANY_ELEMENTS"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_MISSING: +- reason = "STATUS_VHD_DRIVE_FOOTER_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH: +- reason = "STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_CORRUPT: +- reason = "STATUS_VHD_DRIVE_FOOTER_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_FORMAT_UNKNOWN: +- reason = "STATUS_VHD_FORMAT_UNKNOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_FORMAT_UNSUPPORTED_VERSION: +- reason = "STATUS_VHD_FORMAT_UNSUPPORTED_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH: +- reason = "STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION: +- reason = "STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_CORRUPT: +- reason = "STATUS_VHD_SPARSE_HEADER_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_BLOCK_ALLOCATION_FAILURE: +- reason = "STATUS_VHD_BLOCK_ALLOCATION_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT: +- reason = "STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_BLOCK_SIZE: +- reason = "STATUS_VHD_INVALID_BLOCK_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_BITMAP_MISMATCH: +- reason = "STATUS_VHD_BITMAP_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_PARENT_VHD_NOT_FOUND: +- reason = "STATUS_VHD_PARENT_VHD_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_ID_MISMATCH: +- reason = "STATUS_VHD_CHILD_PARENT_ID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH: +- reason = "STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_METADATA_READ_FAILURE: +- reason = "STATUS_VHD_METADATA_READ_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_METADATA_WRITE_FAILURE: +- reason = "STATUS_VHD_METADATA_WRITE_FAILURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_SIZE: +- reason = "STATUS_VHD_INVALID_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_FILE_SIZE: +- reason = "STATUS_VHD_INVALID_FILE_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTDISK_PROVIDER_NOT_FOUND: +- reason = "STATUS_VIRTDISK_PROVIDER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTDISK_NOT_VIRTUAL_DISK: +- reason = "STATUS_VIRTDISK_NOT_VIRTUAL_DISK"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_PARENT_VHD_ACCESS_DENIED: +- reason = "STATUS_VHD_PARENT_VHD_ACCESS_DENIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH: +- reason = "STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED: +- reason = "STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT: +- reason = "STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTUAL_DISK_LIMITATION: +- reason = "STATUS_VIRTUAL_DISK_LIMITATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_TYPE: +- reason = "STATUS_VHD_INVALID_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_STATE: +- reason = "STATUS_VHD_INVALID_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE: +- reason = "STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ALREADY_OWNED: +- reason = "STATUS_VIRTDISK_DISK_ALREADY_OWNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE: +- reason = "STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTLOG_TRACKING_NOT_INITIALIZED: +- reason = "STATUS_CTLOG_TRACKING_NOT_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE: +- reason = "STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTLOG_VHD_CHANGED_OFFLINE: +- reason = "STATUS_CTLOG_VHD_CHANGED_OFFLINE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTLOG_INVALID_TRACKING_STATE: +- reason = "STATUS_CTLOG_INVALID_TRACKING_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CTLOG_INCONSISTENT_TRACKING_FILE: +- reason = "STATUS_CTLOG_INCONSISTENT_TRACKING_FILE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_METADATA_FULL: +- reason = "STATUS_VHD_METADATA_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_INVALID_CHANGE_TRACKING_ID: +- reason = "STATUS_VHD_INVALID_CHANGE_TRACKING_ID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_CHANGE_TRACKING_DISABLED: +- reason = "STATUS_VHD_CHANGE_TRACKING_DISABLED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION: +- reason = "STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA: +- reason = "STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE: +- reason = "STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE: +- reason = "STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_KEY_NOT_FOUND: +- reason = "STATUS_RKF_KEY_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_DUPLICATE_KEY: +- reason = "STATUS_RKF_DUPLICATE_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_BLOB_FULL: +- reason = "STATUS_RKF_BLOB_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_STORE_FULL: +- reason = "STATUS_RKF_STORE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_FILE_BLOCKED: +- reason = "STATUS_RKF_FILE_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RKF_ACTIVE_KEY: +- reason = "STATUS_RKF_ACTIVE_KEY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RDBSS_RESTART_OPERATION: +- reason = "STATUS_RDBSS_RESTART_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RDBSS_CONTINUE_OPERATION: +- reason = "STATUS_RDBSS_CONTINUE_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RDBSS_POST_OPERATION: +- reason = "STATUS_RDBSS_POST_OPERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_RDBSS_RETRY_LOOKUP: +- reason = "STATUS_RDBSS_RETRY_LOOKUP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_HANDLE: +- reason = "STATUS_BTH_ATT_INVALID_HANDLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_READ_NOT_PERMITTED: +- reason = "STATUS_BTH_ATT_READ_NOT_PERMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_WRITE_NOT_PERMITTED: +- reason = "STATUS_BTH_ATT_WRITE_NOT_PERMITTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_PDU: +- reason = "STATUS_BTH_ATT_INVALID_PDU"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION: +- reason = "STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED: +- reason = "STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_OFFSET: +- reason = "STATUS_BTH_ATT_INVALID_OFFSET"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION: +- reason = "STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_PREPARE_QUEUE_FULL: +- reason = "STATUS_BTH_ATT_PREPARE_QUEUE_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND: +- reason = "STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG: +- reason = "STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE: +- reason = "STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH: +- reason = "STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNLIKELY: +- reason = "STATUS_BTH_ATT_UNLIKELY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION: +- reason = "STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE: +- reason = "STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_RESOURCES: +- reason = "STATUS_BTH_ATT_INSUFFICIENT_RESOURCES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNKNOWN_ERROR: +- reason = "STATUS_BTH_ATT_UNKNOWN_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_ROLLBACK_DETECTED: +- reason = "STATUS_SECUREBOOT_ROLLBACK_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_VIOLATION: +- reason = "STATUS_SECUREBOOT_POLICY_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_INVALID_POLICY: +- reason = "STATUS_SECUREBOOT_INVALID_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND: +- reason = "STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_SIGNED: +- reason = "STATUS_SECUREBOOT_POLICY_NOT_SIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_FILE_REPLACED: +- reason = "STATUS_SECUREBOOT_FILE_REPLACED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED: +- reason = "STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UNKNOWN: +- reason = "STATUS_SECUREBOOT_POLICY_UNKNOWN"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION: +- reason = "STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH: +- reason = "STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED: +- reason = "STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH: +- reason = "STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING: +- reason = "STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_BASE_POLICY: +- reason = "STATUS_SECUREBOOT_NOT_BASE_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY: +- reason = "STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_AUDIO_ENGINE_NODE_NOT_FOUND: +- reason = "STATUS_AUDIO_ENGINE_NODE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HDAUDIO_EMPTY_CONNECTION_LIST: +- reason = "STATUS_HDAUDIO_EMPTY_CONNECTION_LIST"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED: +- reason = "STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED: +- reason = "STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY: +- reason = "STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VSM_NOT_INITIALIZED: +- reason = "STATUS_VSM_NOT_INITIALIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VSM_DMA_PROTECTION_NOT_IN_USE: +- reason = "STATUS_VSM_DMA_PROTECTION_NOT_IN_USE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLSNAP_BOOTFILE_NOT_VALID: +- reason = "STATUS_VOLSNAP_BOOTFILE_NOT_VALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VOLSNAP_ACTIVATION_TIMEOUT: +- reason = "STATUS_VOLSNAP_ACTIVATION_TIMEOUT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_IO_PREEMPTED: +- reason = "STATUS_IO_PREEMPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_STORED: +- reason = "STATUS_SVHDX_ERROR_STORED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_NOT_AVAILABLE: +- reason = "STATUS_SVHDX_ERROR_NOT_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED: +- reason = "STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_RESERVATION_CONFLICT: +- reason = "STATUS_SVHDX_RESERVATION_CONFLICT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_WRONG_FILE_TYPE: +- reason = "STATUS_SVHDX_WRONG_FILE_TYPE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_VERSION_MISMATCH: +- reason = "STATUS_SVHDX_VERSION_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHD_SHARED: +- reason = "STATUS_VHD_SHARED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SVHDX_NO_INITIATOR: +- reason = "STATUS_SVHDX_NO_INITIATOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND: +- reason = "STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP: +- reason = "STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMB_BAD_CLUSTER_DIALECT: +- reason = "STATUS_SMB_BAD_CLUSTER_DIALECT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SMB_GUEST_LOGON_BLOCKED: +- reason = "STATUS_SMB_GUEST_LOGON_BLOCKED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID: +- reason = "STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_RESILIENCY_TYPE_INVALID: +- reason = "STATUS_SPACES_RESILIENCY_TYPE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID: +- reason = "STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_REDUNDANCY_INVALID: +- reason = "STATUS_SPACES_DRIVE_REDUNDANCY_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID: +- reason = "STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_INTERLEAVE_LENGTH_INVALID: +- reason = "STATUS_SPACES_INTERLEAVE_LENGTH_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID: +- reason = "STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_NOT_ENOUGH_DRIVES: +- reason = "STATUS_SPACES_NOT_ENOUGH_DRIVES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_EXTENDED_ERROR: +- reason = "STATUS_SPACES_EXTENDED_ERROR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_PROVISIONING_TYPE_INVALID: +- reason = "STATUS_SPACES_PROVISIONING_TYPE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_ALLOCATION_SIZE_INVALID: +- reason = "STATUS_SPACES_ALLOCATION_SIZE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_ENCLOSURE_AWARE_INVALID: +- reason = "STATUS_SPACES_ENCLOSURE_AWARE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_WRITE_CACHE_SIZE_INVALID: +- reason = "STATUS_SPACES_WRITE_CACHE_SIZE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_GROUPS_INVALID: +- reason = "STATUS_SPACES_NUMBER_OF_GROUPS_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID: +- reason = "STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_UPDATE_COLUMN_STATE: +- reason = "STATUS_SPACES_UPDATE_COLUMN_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_MAP_REQUIRED: +- reason = "STATUS_SPACES_MAP_REQUIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_UNSUPPORTED_VERSION: +- reason = "STATUS_SPACES_UNSUPPORTED_VERSION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_CORRUPT_METADATA: +- reason = "STATUS_SPACES_CORRUPT_METADATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRT_FULL: +- reason = "STATUS_SPACES_DRT_FULL"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_INCONSISTENCY: +- reason = "STATUS_SPACES_INCONSISTENCY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_LOG_NOT_READY: +- reason = "STATUS_SPACES_LOG_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_NO_REDUNDANCY: +- reason = "STATUS_SPACES_NO_REDUNDANCY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_NOT_READY: +- reason = "STATUS_SPACES_DRIVE_NOT_READY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SPLIT: +- reason = "STATUS_SPACES_DRIVE_SPLIT"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_LOST_DATA: +- reason = "STATUS_SPACES_DRIVE_LOST_DATA"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INCOMPLETE: +- reason = "STATUS_SPACES_ENTRY_INCOMPLETE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INVALID: +- reason = "STATUS_SPACES_ENTRY_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SPACES_MARK_DIRTY: +- reason = "STATUS_SPACES_MARK_DIRTY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SECCORE_INVALID_COMMAND: +- reason = "STATUS_SECCORE_INVALID_COMMAND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED: +- reason = "STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION: +- reason = "STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_INVALID_POLICY: +- reason = "STATUS_SYSTEM_INTEGRITY_INVALID_POLICY"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED: +- reason = "STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES: +- reason = "STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES"; +- break; +- case MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED: +- reason = "STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_NO_APPLICABLE_APP_LICENSES_FOUND: +- reason = "STATUS_NO_APPLICABLE_APP_LICENSES_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_FOUND: +- reason = "STATUS_CLIP_LICENSE_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_DEVICE_LICENSE_MISSING: +- reason = "STATUS_CLIP_DEVICE_LICENSE_MISSING"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_INVALID_SIGNATURE: +- reason = "STATUS_CLIP_LICENSE_INVALID_SIGNATURE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID: +- reason = "STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_EXPIRED: +- reason = "STATUS_CLIP_LICENSE_EXPIRED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE: +- reason = "STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_SIGNED: +- reason = "STATUS_CLIP_LICENSE_NOT_SIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE: +- reason = "STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH: +- reason = "STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED: +- reason = "STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_INVALID: +- reason = "STATUS_PLATFORM_MANIFEST_INVALID"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED: +- reason = "STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED: +- reason = "STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND: +- reason = "STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_ACTIVE: +- reason = "STATUS_PLATFORM_MANIFEST_NOT_ACTIVE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_SIGNED: +- reason = "STATUS_PLATFORM_MANIFEST_NOT_SIGNED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_CONDITION_NOT_SATISFIED: +- reason = "STATUS_APPEXEC_CONDITION_NOT_SATISFIED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_HANDLE_INVALIDATED: +- reason = "STATUS_APPEXEC_HANDLE_INVALIDATED"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_GENERATION: +- reason = "STATUS_APPEXEC_INVALID_HOST_GENERATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION: +- reason = "STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_STATE: +- reason = "STATUS_APPEXEC_INVALID_HOST_STATE"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_NO_DONOR: +- reason = "STATUS_APPEXEC_NO_DONOR"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_HOST_ID_MISMATCH: +- reason = "STATUS_APPEXEC_HOST_ID_MISMATCH"; +- break; +- case MD_NTSTATUS_WIN_STATUS_APPEXEC_UNKNOWN_USER: +- reason = "STATUS_APPEXEC_UNKNOWN_USER"; +- break; +- default: { +- char reason_string[11]; +- snprintf(reason_string, sizeof(reason_string), "0x%08x", ntstatus); +- reason = reason_string; +- break; +- } ++// The content of this array was created from ntstatus.h in the 10 SDK ++// (version 10.0.19041.0) with ++// ++// egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0x[048C][0-9A-F]+L\)' ntstatus.h ++// | tr -d '\r' ++// | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0x[048C][0-9A-F]+)L\).*@\2 \1@' ++// | sort ++// | sed -r 's@(0x[048C][0-9A-F]+) ([A-Z_0-9]+)@ MD_NTSTATUS_WIN_\2,@' ++// ++// With easy copy to clipboard with ++// | xclip -selection c # on linux ++// | clip # on windows ++// | pbcopy # on mac ++static const uint32_t kNTStatusValues[] = { ++ MD_NTSTATUS_WIN_STATUS_SUCCESS, ++ MD_NTSTATUS_WIN_STATUS_WAIT_0, ++ MD_NTSTATUS_WIN_STATUS_WAIT_1, ++ MD_NTSTATUS_WIN_STATUS_WAIT_2, ++ MD_NTSTATUS_WIN_STATUS_WAIT_3, ++ MD_NTSTATUS_WIN_STATUS_WAIT_63, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_0, ++ MD_NTSTATUS_WIN_STATUS_ABANDONED_WAIT_63, ++ MD_NTSTATUS_WIN_STATUS_USER_APC, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_COMPLETE, ++ MD_NTSTATUS_WIN_STATUS_KERNEL_APC, ++ MD_NTSTATUS_WIN_STATUS_ALERTED, ++ MD_NTSTATUS_WIN_STATUS_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_PENDING, ++ MD_NTSTATUS_WIN_STATUS_REPARSE, ++ MD_NTSTATUS_WIN_STATUS_MORE_ENTRIES, ++ MD_NTSTATUS_WIN_STATUS_NOT_ALL_ASSIGNED, ++ MD_NTSTATUS_WIN_STATUS_SOME_NOT_MAPPED, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_BREAK_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_MOUNTED, ++ MD_NTSTATUS_WIN_STATUS_RXACT_COMMITTED, ++ MD_NTSTATUS_WIN_STATUS_NOTIFY_CLEANUP, ++ MD_NTSTATUS_WIN_STATUS_NOTIFY_ENUM_DIR, ++ MD_NTSTATUS_WIN_STATUS_NO_QUOTAS_FOR_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_TRANSITION, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_DEMAND_ZERO, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_COPY_ON_WRITE, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_GUARD_PAGE, ++ MD_NTSTATUS_WIN_STATUS_PAGE_FAULT_PAGING_FILE, ++ MD_NTSTATUS_WIN_STATUS_CACHE_PAGE_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_CRASH_DUMP, ++ MD_NTSTATUS_WIN_STATUS_BUFFER_ALL_ZEROS, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_REQUIREMENTS_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_TRANSLATION_COMPLETE, ++ MD_NTSTATUS_WIN_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, ++ MD_NTSTATUS_WIN_STATUS_NOTHING_TO_TERMINATE, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_NOT_IN_JOB, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_IN_JOB, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_HIBERNATE_READY, ++ MD_NTSTATUS_WIN_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPT_STILL_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_CLONED, ++ MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_ONLY_READERS, ++ MD_NTSTATUS_WIN_STATUS_FILE_LOCKED_WITH_WRITERS, ++ MD_NTSTATUS_WIN_STATUS_VALID_IMAGE_HASH, ++ MD_NTSTATUS_WIN_STATUS_VALID_CATALOG_HASH, ++ MD_NTSTATUS_WIN_STATUS_VALID_STRONG_CODE_HASH, ++ MD_NTSTATUS_WIN_STATUS_GHOSTED, ++ MD_NTSTATUS_WIN_STATUS_DATA_OVERWRITTEN, ++ MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_READ_ONLY, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_FULL, ++ MD_NTSTATUS_WIN_STATUS_RING_PREVIOUSLY_ABOVE_QUOTA, ++ MD_NTSTATUS_WIN_STATUS_RING_NEWLY_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_HANDLE_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_WAIT_FOR_OPLOCK, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_GLOBAL, ++ MD_NTSTATUS_WIN_DBG_EXCEPTION_HANDLED, ++ MD_NTSTATUS_WIN_DBG_CONTINUE, ++ MD_NTSTATUS_WIN_STATUS_FLT_IO_COMPLETE, ++ MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_CONTINUE, ++ MD_NTSTATUS_WIN_STATUS_RTPM_CONTEXT_COMPLETE, ++ MD_NTSTATUS_WIN_STATUS_HV_PENDING_PAGE_REQUESTS, ++ MD_NTSTATUS_WIN_STATUS_SPACES_REPAIRED, ++ MD_NTSTATUS_WIN_STATUS_SPACES_PAUSE, ++ MD_NTSTATUS_WIN_STATUS_SPACES_COMPLETE, ++ MD_NTSTATUS_WIN_STATUS_SPACES_REDIRECT, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_THREAD_WAS_SUSPENDED, ++ MD_NTSTATUS_WIN_STATUS_WORKING_SET_LIMIT_RANGE, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_NOT_AT_BASE, ++ MD_NTSTATUS_WIN_STATUS_RXACT_STATE_CREATED, ++ MD_NTSTATUS_WIN_STATUS_SEGMENT_NOTIFICATION, ++ MD_NTSTATUS_WIN_STATUS_LOCAL_USER_SESSION_KEY, ++ MD_NTSTATUS_WIN_STATUS_BAD_CURRENT_DIRECTORY, ++ MD_NTSTATUS_WIN_STATUS_SERIAL_MORE_WRITES, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_RECOVERED, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_RECOVERY_FROM_BACKUP, ++ MD_NTSTATUS_WIN_STATUS_FT_WRITE_RECOVERY, ++ MD_NTSTATUS_WIN_STATUS_SERIAL_COUNTER_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_NULL_LM_PASSWORD, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_EXPEDITED, ++ MD_NTSTATUS_WIN_STATUS_RECEIVE_PARTIAL_EXPEDITED, ++ MD_NTSTATUS_WIN_STATUS_EVENT_DONE, ++ MD_NTSTATUS_WIN_STATUS_EVENT_PENDING, ++ MD_NTSTATUS_WIN_STATUS_CHECKING_FILE_SYSTEM, ++ MD_NTSTATUS_WIN_STATUS_FATAL_APP_EXIT, ++ MD_NTSTATUS_WIN_STATUS_PREDEFINED_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_WAS_UNLOCKED, ++ MD_NTSTATUS_WIN_STATUS_SERVICE_NOTIFICATION, ++ MD_NTSTATUS_WIN_STATUS_WAS_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_LOG_HARD_ERROR, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_WIN32, ++ MD_NTSTATUS_WIN_STATUS_WX86_UNSIMULATE, ++ MD_NTSTATUS_WIN_STATUS_WX86_CONTINUE, ++ MD_NTSTATUS_WIN_STATUS_WX86_SINGLE_STEP, ++ MD_NTSTATUS_WIN_STATUS_WX86_BREAKPOINT, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CONTINUE, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_LASTCHANCE, ++ MD_NTSTATUS_WIN_STATUS_WX86_EXCEPTION_CHAIN, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE, ++ MD_NTSTATUS_WIN_STATUS_NO_YIELD_PERFORMED, ++ MD_NTSTATUS_WIN_STATUS_TIMER_RESUME_IGNORED, ++ MD_NTSTATUS_WIN_STATUS_ARBITRATION_UNHANDLED, ++ MD_NTSTATUS_WIN_STATUS_CARDBUS_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_WX86_CREATEWX86TIB, ++ MD_NTSTATUS_WIN_STATUS_MP_PROCESSOR_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_HIBERNATED, ++ MD_NTSTATUS_WIN_STATUS_RESUME_HIBERNATION, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_UPDATED, ++ MD_NTSTATUS_WIN_STATUS_DRIVERS_LEAKING_LOCKED_PAGES, ++ MD_NTSTATUS_WIN_STATUS_MESSAGE_RETRIEVED, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_TRANSITION, ++ MD_NTSTATUS_WIN_STATUS_ALPC_CHECK_COMPLETION_LIST, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_AUDIT_BY_POLICY, ++ MD_NTSTATUS_WIN_STATUS_ABANDON_HIBERFILE, ++ MD_NTSTATUS_WIN_STATUS_BIZRULES_NOT_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_FROM_COPY, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_AT_DIFFERENT_BASE, ++ MD_NTSTATUS_WIN_STATUS_PATCH_DEFERRED, ++ MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM, ++ MD_NTSTATUS_WIN_STATUS_DS_SHUTTING_DOWN, ++ MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_REDIRECTED, ++ MD_NTSTATUS_WIN_STATUS_SERVICES_FAILED_AUTOSTART, ++ MD_NTSTATUS_WIN_DBG_REPLY_LATER, ++ MD_NTSTATUS_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE, ++ MD_NTSTATUS_WIN_DBG_TERMINATE_THREAD, ++ MD_NTSTATUS_WIN_DBG_TERMINATE_PROCESS, ++ MD_NTSTATUS_WIN_DBG_CONTROL_C, ++ MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_C, ++ MD_NTSTATUS_WIN_DBG_RIPEXCEPTION, ++ MD_NTSTATUS_WIN_DBG_CONTROL_BREAK, ++ MD_NTSTATUS_WIN_DBG_COMMAND_EXCEPTION, ++ MD_NTSTATUS_WIN_DBG_PRINTEXCEPTION_WIDE_C, ++ MD_NTSTATUS_WIN_RPC_NT_UUID_LOCAL_ONLY, ++ MD_NTSTATUS_WIN_RPC_NT_SEND_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_CTX_CDM_CONNECT, ++ MD_NTSTATUS_WIN_STATUS_CTX_CDM_DISCONNECT, ++ MD_NTSTATUS_WIN_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_HEURISTIC_DAMAGE_POSSIBLE, ++ MD_NTSTATUS_WIN_STATUS_RECOVERY_NOT_NEEDED, ++ MD_NTSTATUS_WIN_STATUS_RM_ALREADY_STARTED, ++ MD_NTSTATUS_WIN_STATUS_LOG_NO_RESTART, ++ MD_NTSTATUS_WIN_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_PINNED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_PREFERRED_MODE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DATASET_IS_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_START_DEFERRED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_START_DEFERRED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INDICATION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_PCP_UNSUPPORTED_PSS_SALT, ++ MD_NTSTATUS_WIN_STATUS_GUARD_PAGE_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT, ++ MD_NTSTATUS_WIN_STATUS_BREAKPOINT, ++ MD_NTSTATUS_WIN_STATUS_SINGLE_STEP, ++ MD_NTSTATUS_WIN_STATUS_BUFFER_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_FILES, ++ MD_NTSTATUS_WIN_STATUS_WAKE_SYSTEM_DEBUGGER, ++ MD_NTSTATUS_WIN_STATUS_HANDLES_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_NO_INHERITANCE, ++ MD_NTSTATUS_WIN_STATUS_GUID_SUBSTITUTION_MADE, ++ MD_NTSTATUS_WIN_STATUS_PARTIAL_COPY, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_PAPER_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_POWERED_OFF, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_OFF_LINE, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_BUSY, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_EAS, ++ MD_NTSTATUS_WIN_STATUS_INVALID_EA_NAME, ++ MD_NTSTATUS_WIN_STATUS_EA_LIST_INCONSISTENT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_EA_FLAG, ++ MD_NTSTATUS_WIN_STATUS_VERIFY_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_EXTRANEOUS_INFORMATION, ++ MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_NECESSARY, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_ENTRIES, ++ MD_NTSTATUS_WIN_STATUS_FILEMARK_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_MEDIA_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_BUS_RESET, ++ MD_NTSTATUS_WIN_STATUS_END_OF_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_BEGINNING_OF_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_MEDIA_CHECK, ++ MD_NTSTATUS_WIN_STATUS_SETMARK_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_NO_DATA_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_REDIRECTOR_HAS_OPEN_HANDLES, ++ MD_NTSTATUS_WIN_STATUS_SERVER_HAS_OPEN_HANDLES, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_LONGJUMP, ++ MD_NTSTATUS_WIN_STATUS_CLEANER_CARTRIDGE_INSTALLED, ++ MD_NTSTATUS_WIN_STATUS_PLUGPLAY_QUERY_VETOED, ++ MD_NTSTATUS_WIN_STATUS_UNWIND_CONSOLIDATE, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_HIVE_RECOVERED, ++ MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INSECURE, ++ MD_NTSTATUS_WIN_STATUS_DLL_MIGHT_BE_INCOMPATIBLE, ++ MD_NTSTATUS_WIN_STATUS_STOPPED_ON_SYMLINK, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK, ++ MD_NTSTATUS_WIN_STATUS_NO_ACE_CONDITION, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_SUPPORT_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_CYCLE_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_NO_WORK_DONE, ++ MD_NTSTATUS_WIN_STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_REQUIRES_CLEANING, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_DOOR_OPEN, ++ MD_NTSTATUS_WIN_STATUS_DATA_LOST_REPAIR, ++ MD_NTSTATUS_WIN_STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS, ++ MD_NTSTATUS_WIN_DBG_EXCEPTION_NOT_HANDLED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_UP, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_DOWN, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_ALREADY_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_COULD_NOT_RESIZE_LOG, ++ MD_NTSTATUS_WIN_STATUS_NO_TXF_METADATA, ++ MD_NTSTATUS_WIN_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN, ++ MD_NTSTATUS_WIN_STATUS_TXF_METADATA_ALREADY_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED, ++ MD_NTSTATUS_WIN_STATUS_FLT_BUFFER_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_FVE_PARTIAL_METADATA, ++ MD_NTSTATUS_WIN_STATUS_FVE_TRANSIENT_STATE, ++ MD_NTSTATUS_WIN_STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_REGENERATION, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION, ++ MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED, ++ MD_NTSTATUS_WIN_STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED, ++ MD_NTSTATUS_WIN_STATUS_QUERY_STORAGE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GDI_HANDLE_LEAK, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_UNSUCCESSFUL, ++ MD_NTSTATUS_WIN_STATUS_NOT_IMPLEMENTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_INFO_CLASS, ++ MD_NTSTATUS_WIN_STATUS_INFO_LENGTH_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_IN_PAGE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_PAGEFILE_QUOTA, ++ MD_NTSTATUS_WIN_STATUS_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_BAD_INITIAL_STACK, ++ MD_NTSTATUS_WIN_STATUS_BAD_INITIAL_PC, ++ MD_NTSTATUS_WIN_STATUS_INVALID_CID, ++ MD_NTSTATUS_WIN_STATUS_TIMER_NOT_CANCELED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_FILE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_END_OF_FILE, ++ MD_NTSTATUS_WIN_STATUS_WRONG_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_NO_MEDIA_IN_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_UNRECOGNIZED_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_NONEXISTENT_SECTOR, ++ MD_NTSTATUS_WIN_STATUS_MORE_PROCESSING_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_NO_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_CONFLICTING_ADDRESSES, ++ MD_NTSTATUS_WIN_STATUS_NOT_MAPPED_VIEW, ++ MD_NTSTATUS_WIN_STATUS_UNABLE_TO_FREE_VM, ++ MD_NTSTATUS_WIN_STATUS_UNABLE_TO_DELETE_SECTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SYSTEM_SERVICE, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_INSTRUCTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LOCK_SEQUENCE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_VIEW_SIZE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_FILE_FOR_SECTION, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_COMMITTED, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_BUFFER_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_TYPE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_NONCONTINUABLE_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DISPOSITION, ++ MD_NTSTATUS_WIN_STATUS_UNWIND, ++ MD_NTSTATUS_WIN_STATUS_BAD_STACK, ++ MD_NTSTATUS_WIN_STATUS_INVALID_UNWIND_TARGET, ++ MD_NTSTATUS_WIN_STATUS_NOT_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_PARITY_ERROR, ++ MD_NTSTATUS_WIN_STATUS_UNABLE_TO_DECOMMIT_VM, ++ MD_NTSTATUS_WIN_STATUS_NOT_COMMITTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PORT_ATTRIBUTES, ++ MD_NTSTATUS_WIN_STATUS_PORT_MESSAGE_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_MIX, ++ MD_NTSTATUS_WIN_STATUS_INVALID_QUOTA_LOWER, ++ MD_NTSTATUS_WIN_STATUS_DISK_CORRUPT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_INVALID, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NAME_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_PORT_DO_NOT_DISTURB, ++ MD_NTSTATUS_WIN_STATUS_PORT_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_ALREADY_ATTACHED, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_INVALID, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_PATH_SYNTAX_BAD, ++ MD_NTSTATUS_WIN_STATUS_DATA_OVERRUN, ++ MD_NTSTATUS_WIN_STATUS_DATA_LATE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DATA_ERROR, ++ MD_NTSTATUS_WIN_STATUS_CRC_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SECTION_TOO_BIG, ++ MD_NTSTATUS_WIN_STATUS_PORT_CONNECTION_REFUSED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PORT_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_SHARING_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PAGE_PROTECTION, ++ MD_NTSTATUS_WIN_STATUS_MUTANT_NOT_OWNED, ++ MD_NTSTATUS_WIN_STATUS_SEMAPHORE_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_PORT_ALREADY_SET, ++ MD_NTSTATUS_WIN_STATUS_SECTION_NOT_IMAGE, ++ MD_NTSTATUS_WIN_STATUS_SUSPEND_COUNT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_THREAD_IS_TERMINATING, ++ MD_NTSTATUS_WIN_STATUS_BAD_WORKING_SET_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_FILE_MAP, ++ MD_NTSTATUS_WIN_STATUS_SECTION_PROTECTION, ++ MD_NTSTATUS_WIN_STATUS_EAS_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_EA_TOO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_NONEXISTENT_EA_ENTRY, ++ MD_NTSTATUS_WIN_STATUS_NO_EAS_ON_FILE, ++ MD_NTSTATUS_WIN_STATUS_EA_CORRUPT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FILE_LOCK_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_LOCK_NOT_GRANTED, ++ MD_NTSTATUS_WIN_STATUS_DELETE_PENDING, ++ MD_NTSTATUS_WIN_STATUS_CTL_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_UNKNOWN_REVISION, ++ MD_NTSTATUS_WIN_STATUS_REVISION_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_INVALID_OWNER, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PRIMARY_GROUP, ++ MD_NTSTATUS_WIN_STATUS_NO_IMPERSONATION_TOKEN, ++ MD_NTSTATUS_WIN_STATUS_CANT_DISABLE_MANDATORY, ++ MD_NTSTATUS_WIN_STATUS_NO_LOGON_SERVERS, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_LOGON_SESSION, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_PRIVILEGE, ++ MD_NTSTATUS_WIN_STATUS_PRIVILEGE_NOT_HELD, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ACCOUNT_NAME, ++ MD_NTSTATUS_WIN_STATUS_USER_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_USER, ++ MD_NTSTATUS_WIN_STATUS_GROUP_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_GROUP, ++ MD_NTSTATUS_WIN_STATUS_MEMBER_IN_GROUP, ++ MD_NTSTATUS_WIN_STATUS_MEMBER_NOT_IN_GROUP, ++ MD_NTSTATUS_WIN_STATUS_LAST_ADMIN, ++ MD_NTSTATUS_WIN_STATUS_WRONG_PASSWORD, ++ MD_NTSTATUS_WIN_STATUS_ILL_FORMED_PASSWORD, ++ MD_NTSTATUS_WIN_STATUS_PASSWORD_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_LOGON_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_ACCOUNT_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LOGON_HOURS, ++ MD_NTSTATUS_WIN_STATUS_INVALID_WORKSTATION, ++ MD_NTSTATUS_WIN_STATUS_PASSWORD_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_ACCOUNT_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_NONE_MAPPED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_LUIDS_REQUESTED, ++ MD_NTSTATUS_WIN_STATUS_LUIDS_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SUB_AUTHORITY, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ACL, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SID, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SECURITY_DESCR, ++ MD_NTSTATUS_WIN_STATUS_PROCEDURE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_NO_TOKEN, ++ MD_NTSTATUS_WIN_STATUS_BAD_INHERITANCE_ACL, ++ MD_NTSTATUS_WIN_STATUS_RANGE_NOT_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_DISK_FULL, ++ MD_NTSTATUS_WIN_STATUS_SERVER_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_SERVER_NOT_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_GUIDS_REQUESTED, ++ MD_NTSTATUS_WIN_STATUS_GUIDS_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ID_AUTHORITY, ++ MD_NTSTATUS_WIN_STATUS_AGENTS_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_VOLUME_LABEL, ++ MD_NTSTATUS_WIN_STATUS_SECTION_NOT_EXTENDED, ++ MD_NTSTATUS_WIN_STATUS_NOT_MAPPED_DATA, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_DATA_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_TYPE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_NAME_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_ARRAY_BOUNDS_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_DENORMAL_OPERAND, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_DIVIDE_BY_ZERO, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_INEXACT_RESULT, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_INVALID_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_STACK_CHECK, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_UNDERFLOW, ++ MD_NTSTATUS_WIN_STATUS_INTEGER_DIVIDE_BY_ZERO, ++ MD_NTSTATUS_WIN_STATUS_INTEGER_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_PRIVILEGED_INSTRUCTION, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_PAGING_FILES, ++ MD_NTSTATUS_WIN_STATUS_FILE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_ALLOTTED_SPACE_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_DFS_EXIT_PATH_FOUND, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_DATA_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_POWER_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_FREE_VM_NOT_AT_BASE, ++ MD_NTSTATUS_WIN_STATUS_MEMORY_NOT_ALLOCATED, ++ MD_NTSTATUS_WIN_STATUS_WORKING_SET_QUOTA, ++ MD_NTSTATUS_WIN_STATUS_MEDIA_WRITE_PROTECTED, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_INVALID_GROUP_ATTRIBUTES, ++ MD_NTSTATUS_WIN_STATUS_BAD_IMPERSONATION_LEVEL, ++ MD_NTSTATUS_WIN_STATUS_CANT_OPEN_ANONYMOUS, ++ MD_NTSTATUS_WIN_STATUS_BAD_VALIDATION_CLASS, ++ MD_NTSTATUS_WIN_STATUS_BAD_TOKEN_TYPE, ++ MD_NTSTATUS_WIN_STATUS_BAD_MASTER_BOOT_RECORD, ++ MD_NTSTATUS_WIN_STATUS_INSTRUCTION_MISALIGNMENT, ++ MD_NTSTATUS_WIN_STATUS_INSTANCE_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_PIPE_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PIPE_STATE, ++ MD_NTSTATUS_WIN_STATUS_PIPE_BUSY, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_FUNCTION, ++ MD_NTSTATUS_WIN_STATUS_PIPE_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_PIPE_CLOSING, ++ MD_NTSTATUS_WIN_STATUS_PIPE_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_PIPE_LISTENING, ++ MD_NTSTATUS_WIN_STATUS_INVALID_READ_MODE, ++ MD_NTSTATUS_WIN_STATUS_IO_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_FILE_FORCED_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_PROFILING_NOT_STARTED, ++ MD_NTSTATUS_WIN_STATUS_PROFILING_NOT_STOPPED, ++ MD_NTSTATUS_WIN_STATUS_COULD_NOT_INTERPRET, ++ MD_NTSTATUS_WIN_STATUS_FILE_IS_A_DIRECTORY, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_NOT_LISTENING, ++ MD_NTSTATUS_WIN_STATUS_DUPLICATE_NAME, ++ MD_NTSTATUS_WIN_STATUS_BAD_NETWORK_PATH, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_BUSY, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_DOES_NOT_EXIST, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_COMMANDS, ++ MD_NTSTATUS_WIN_STATUS_ADAPTER_HARDWARE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_INVALID_NETWORK_RESPONSE, ++ MD_NTSTATUS_WIN_STATUS_UNEXPECTED_NETWORK_ERROR, ++ MD_NTSTATUS_WIN_STATUS_BAD_REMOTE_ADAPTER, ++ MD_NTSTATUS_WIN_STATUS_PRINT_QUEUE_FULL, ++ MD_NTSTATUS_WIN_STATUS_NO_SPOOL_SPACE, ++ MD_NTSTATUS_WIN_STATUS_PRINT_CANCELLED, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_NAME_DELETED, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_BAD_DEVICE_TYPE, ++ MD_NTSTATUS_WIN_STATUS_BAD_NETWORK_NAME, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_NAMES, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_SESSIONS, ++ MD_NTSTATUS_WIN_STATUS_SHARING_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_REQUEST_NOT_ACCEPTED, ++ MD_NTSTATUS_WIN_STATUS_REDIRECTOR_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_NET_WRITE_FAULT, ++ MD_NTSTATUS_WIN_STATUS_PROFILING_AT_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_NOT_SAME_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_FILE_RENAMED, ++ MD_NTSTATUS_WIN_STATUS_VIRTUAL_CIRCUIT_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_NO_SECURITY_ON_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_CANT_WAIT, ++ MD_NTSTATUS_WIN_STATUS_PIPE_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_CANT_ACCESS_DOMAIN_INFO, ++ MD_NTSTATUS_WIN_STATUS_CANT_TERMINATE_SELF, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SERVER_STATE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DOMAIN_STATE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DOMAIN_ROLE, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_DOMAIN, ++ MD_NTSTATUS_WIN_STATUS_DOMAIN_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_DOMAIN_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_OPLOCK_NOT_GRANTED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_OPLOCK_PROTOCOL, ++ MD_NTSTATUS_WIN_STATUS_INTERNAL_DB_CORRUPTION, ++ MD_NTSTATUS_WIN_STATUS_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GENERIC_NOT_MAPPED, ++ MD_NTSTATUS_WIN_STATUS_BAD_DESCRIPTOR_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_USER_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_UNEXPECTED_IO_ERROR, ++ MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_CREATE_ERR, ++ MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_MAP_ERROR, ++ MD_NTSTATUS_WIN_STATUS_UNEXPECTED_MM_EXTEND_ERR, ++ MD_NTSTATUS_WIN_STATUS_NOT_LOGON_PROCESS, ++ MD_NTSTATUS_WIN_STATUS_LOGON_SESSION_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_1, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_2, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_3, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_4, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_5, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_6, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_7, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_8, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_9, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_10, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_11, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PARAMETER_12, ++ MD_NTSTATUS_WIN_STATUS_REDIRECTOR_NOT_STARTED, ++ MD_NTSTATUS_WIN_STATUS_REDIRECTOR_STARTED, ++ MD_NTSTATUS_WIN_STATUS_STACK_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_PACKAGE, ++ MD_NTSTATUS_WIN_STATUS_BAD_FUNCTION_TABLE, ++ MD_NTSTATUS_WIN_STATUS_VARIABLE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_FILE_CORRUPT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_DIRECTORY, ++ MD_NTSTATUS_WIN_STATUS_BAD_LOGON_SESSION_STATE, ++ MD_NTSTATUS_WIN_STATUS_LOGON_SESSION_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_NAME_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_FILES_OPEN, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_MESSAGE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_IS_TERMINATING, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LOGON_TYPE, ++ MD_NTSTATUS_WIN_STATUS_NO_GUID_TRANSLATION, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_IMPERSONATE, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_ALREADY_LOADED, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_LID_NOT_EXIST, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_LID_ALREADY_OWNED, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_NOT_LID_OWNER, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_COMMAND, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_LID, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_ABIOS_INVALID_SELECTOR, ++ MD_NTSTATUS_WIN_STATUS_NO_LDT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LDT_SIZE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LDT_OFFSET, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LDT_DESCRIPTOR, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_NE_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_RXACT_INVALID_STATE, ++ MD_NTSTATUS_WIN_STATUS_RXACT_COMMIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_MAPPED_FILE_SIZE_ZERO, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_OPENED_FILES, ++ MD_NTSTATUS_WIN_STATUS_CANCELLED, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_DELETE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_COMPUTER_NAME, ++ MD_NTSTATUS_WIN_STATUS_FILE_DELETED, ++ MD_NTSTATUS_WIN_STATUS_SPECIAL_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_SPECIAL_GROUP, ++ MD_NTSTATUS_WIN_STATUS_SPECIAL_USER, ++ MD_NTSTATUS_WIN_STATUS_MEMBERS_PRIMARY_GROUP, ++ MD_NTSTATUS_WIN_STATUS_FILE_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_THREADS, ++ MD_NTSTATUS_WIN_STATUS_THREAD_NOT_IN_PROCESS, ++ MD_NTSTATUS_WIN_STATUS_TOKEN_ALREADY_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_PAGEFILE_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_COMMITMENT_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_LE_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_NOT_MZ, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_PROTECT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_16, ++ MD_NTSTATUS_WIN_STATUS_LOGON_SERVER_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_TIME_DIFFERENCE_AT_DC, ++ MD_NTSTATUS_WIN_STATUS_SYNCHRONIZATION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_DLL_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_OPEN_FAILED, ++ MD_NTSTATUS_WIN_STATUS_IO_PRIVILEGE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_ORDINAL_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_ENTRYPOINT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CONTROL_C_EXIT, ++ MD_NTSTATUS_WIN_STATUS_LOCAL_DISCONNECT, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_DISCONNECT, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_LINK_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LINK_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_CONNECTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS, ++ MD_NTSTATUS_WIN_STATUS_DLL_INIT_FAILED, ++ MD_NTSTATUS_WIN_STATUS_MISSING_SYSTEMFILE, ++ MD_NTSTATUS_WIN_STATUS_UNHANDLED_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_APP_INIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_PAGEFILE_CREATE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_NO_PAGEFILE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LEVEL, ++ MD_NTSTATUS_WIN_STATUS_WRONG_PASSWORD_CORE, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_FLOAT_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_PIPE_BROKEN, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_IO_FAILED, ++ MD_NTSTATUS_WIN_STATUS_NO_EVENT_PAIR, ++ MD_NTSTATUS_WIN_STATUS_UNRECOGNIZED_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_SERIAL_NO_DEVICE_INITED, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_ALIAS, ++ MD_NTSTATUS_WIN_STATUS_MEMBER_NOT_IN_ALIAS, ++ MD_NTSTATUS_WIN_STATUS_MEMBER_IN_ALIAS, ++ MD_NTSTATUS_WIN_STATUS_ALIAS_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_LOGON_NOT_GRANTED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_SECRETS, ++ MD_NTSTATUS_WIN_STATUS_SECRET_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_INTERNAL_DB_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FULLSCREEN_MODE, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_CONTEXT_IDS, ++ MD_NTSTATUS_WIN_STATUS_LOGON_TYPE_NOT_GRANTED, ++ MD_NTSTATUS_WIN_STATUS_NOT_REGISTRY_FILE, ++ MD_NTSTATUS_WIN_STATUS_NT_CROSS_ENCRYPTION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_DOMAIN_CTRLR_CONFIG_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FT_MISSING_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_ILL_FORMED_SERVICE_ENTRY, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_CHARACTER, ++ MD_NTSTATUS_WIN_STATUS_UNMAPPABLE_CHARACTER, ++ MD_NTSTATUS_WIN_STATUS_UNDEFINED_CHARACTER, ++ MD_NTSTATUS_WIN_STATUS_FLOPPY_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_FLOPPY_ID_MARK_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FLOPPY_WRONG_CYLINDER, ++ MD_NTSTATUS_WIN_STATUS_FLOPPY_UNKNOWN_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FLOPPY_BAD_REGISTERS, ++ MD_NTSTATUS_WIN_STATUS_DISK_RECALIBRATE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_DISK_OPERATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_DISK_RESET_FAILED, ++ MD_NTSTATUS_WIN_STATUS_SHARED_IRQ_BUSY, ++ MD_NTSTATUS_WIN_STATUS_FT_ORPHANING, ++ MD_NTSTATUS_WIN_STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT, ++ MD_NTSTATUS_WIN_STATUS_PARTITION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_BLOCK_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_NOT_PARTITIONED, ++ MD_NTSTATUS_WIN_STATUS_UNABLE_TO_LOCK_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_UNABLE_TO_UNLOAD_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_EOM_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_NO_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_NO_SUCH_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_INVALID_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_KEY_DELETED, ++ MD_NTSTATUS_WIN_STATUS_NO_LOG_SPACE, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_SIDS, ++ MD_NTSTATUS_WIN_STATUS_LM_CROSS_ENCRYPTION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_KEY_HAS_CHILDREN, ++ MD_NTSTATUS_WIN_STATUS_CHILD_MUST_BE_VOLATILE, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_CONFIGURATION_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_STATE, ++ MD_NTSTATUS_WIN_STATUS_IO_DEVICE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_PROTOCOL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_BACKUP_CONTROLLER, ++ MD_NTSTATUS_WIN_STATUS_LOG_FILE_FULL, ++ MD_NTSTATUS_WIN_STATUS_TOO_LATE, ++ MD_NTSTATUS_WIN_STATUS_NO_TRUST_LSA_SECRET, ++ MD_NTSTATUS_WIN_STATUS_NO_TRUST_SAM_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_TRUSTED_DOMAIN_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_TRUSTED_RELATIONSHIP_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_EVENTLOG_FILE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_EVENTLOG_CANT_START, ++ MD_NTSTATUS_WIN_STATUS_TRUST_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_MUTANT_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_NETLOGON_NOT_STARTED, ++ MD_NTSTATUS_WIN_STATUS_ACCOUNT_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_POSSIBLE_DEADLOCK, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_CREDENTIAL_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_SESSION_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_EVENTLOG_FILE_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_DOMAIN_TRUST_INCONSISTENT, ++ MD_NTSTATUS_WIN_STATUS_FS_DRIVER_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_ALREADY_LOADED_AS_DLL, ++ MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING, ++ MD_NTSTATUS_WIN_STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_SECURITY_STREAM_IS_INCONSISTENT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LOCK_RANGE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ACE_CONDITION, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_NOTIFICATION_GUID_ALREADY_DEFINED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_EXCEPTION_HANDLER, ++ MD_NTSTATUS_WIN_STATUS_DUPLICATE_PRIVILEGES, ++ MD_NTSTATUS_WIN_STATUS_NOT_ALLOWED_ON_SYSTEM_FILE, ++ MD_NTSTATUS_WIN_STATUS_REPAIR_NEEDED, ++ MD_NTSTATUS_WIN_STATUS_QUOTA_NOT_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_NO_APPLICATION_PACKAGE, ++ MD_NTSTATUS_WIN_STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_NOT_SAME_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_FATAL_MEMORY_EXHAUSTION, ++ MD_NTSTATUS_WIN_STATUS_ERROR_PROCESS_NOT_IN_JOB, ++ MD_NTSTATUS_WIN_STATUS_CPU_SET_INVALID, ++ MD_NTSTATUS_WIN_STATUS_IO_DEVICE_INVALID_DATA, ++ MD_NTSTATUS_WIN_STATUS_IO_UNALIGNED_WRITE, ++ MD_NTSTATUS_WIN_STATUS_CONTROL_STACK_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_OPEN_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_NO_USER_SESSION_KEY, ++ MD_NTSTATUS_WIN_STATUS_USER_SESSION_DELETED, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_LANG_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_INSUFF_SERVER_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_INVALID_BUFFER_SIZE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_COMPONENT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_ADDRESS_WILDCARD, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_ADDRESSES, ++ MD_NTSTATUS_WIN_STATUS_ADDRESS_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_ADDRESS_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_RESET, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_NODES, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_TIMED_OUT, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_RELEASE, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_MATCH, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_RESPONDED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_ID, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_TYPE, ++ MD_NTSTATUS_WIN_STATUS_NOT_SERVER_SESSION, ++ MD_NTSTATUS_WIN_STATUS_NOT_CLIENT_SESSION, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_LOAD_REGISTRY_FILE, ++ MD_NTSTATUS_WIN_STATUS_DEBUG_ATTACH_FAILED, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_PROCESS_TERMINATED, ++ MD_NTSTATUS_WIN_STATUS_DATA_NOT_ACCEPTED, ++ MD_NTSTATUS_WIN_STATUS_NO_BROWSER_SERVERS_FOUND, ++ MD_NTSTATUS_WIN_STATUS_VDM_HARD_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_CANCEL_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_REPLY_MESSAGE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_MAPPED_ALIGNMENT, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_CHECKSUM_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA, ++ MD_NTSTATUS_WIN_STATUS_CLIENT_SERVER_PARAMETERS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_PASSWORD_MUST_CHANGE, ++ MD_NTSTATUS_WIN_STATUS_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NOT_TINY_STREAM, ++ MD_NTSTATUS_WIN_STATUS_RECOVERY_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_STACK_OVERFLOW_READ, ++ MD_NTSTATUS_WIN_STATUS_FAIL_CHECK, ++ MD_NTSTATUS_WIN_STATUS_DUPLICATE_OBJECTID, ++ MD_NTSTATUS_WIN_STATUS_OBJECTID_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_CONVERT_TO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_RETRY, ++ MD_NTSTATUS_WIN_STATUS_FOUND_OUT_OF_SCOPE, ++ MD_NTSTATUS_WIN_STATUS_ALLOCATE_BUCKET, ++ MD_NTSTATUS_WIN_STATUS_PROPSET_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_MARSHALL_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_INVALID_VARIANT, ++ MD_NTSTATUS_WIN_STATUS_DOMAIN_CONTROLLER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_ACCOUNT_LOCKED_OUT, ++ MD_NTSTATUS_WIN_STATUS_HANDLE_NOT_CLOSABLE, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_REFUSED, ++ MD_NTSTATUS_WIN_STATUS_GRACEFUL_DISCONNECT, ++ MD_NTSTATUS_WIN_STATUS_ADDRESS_ALREADY_ASSOCIATED, ++ MD_NTSTATUS_WIN_STATUS_ADDRESS_NOT_ASSOCIATED, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_HOST_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_PROTOCOL_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_PORT_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_REQUEST_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_BAD_COMPRESSION_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_USER_MAPPED_FILE, ++ MD_NTSTATUS_WIN_STATUS_AUDIT_FAILED, ++ MD_NTSTATUS_WIN_STATUS_TIMER_RESOLUTION_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_CONNECTION_COUNT_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_LOGIN_TIME_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_LOGIN_WKSTA_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_MP_UP_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_LOGON_INFO, ++ MD_NTSTATUS_WIN_STATUS_BAD_DLL_ENTRYPOINT, ++ MD_NTSTATUS_WIN_STATUS_BAD_SERVICE_ENTRYPOINT, ++ MD_NTSTATUS_WIN_STATUS_LPC_REPLY_LOST, ++ MD_NTSTATUS_WIN_STATUS_IP_ADDRESS_CONFLICT1, ++ MD_NTSTATUS_WIN_STATUS_IP_ADDRESS_CONFLICT2, ++ MD_NTSTATUS_WIN_STATUS_REGISTRY_QUOTA_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_PATH_NOT_COVERED, ++ MD_NTSTATUS_WIN_STATUS_NO_CALLBACK_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_LICENSE_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_PWD_TOO_SHORT, ++ MD_NTSTATUS_WIN_STATUS_PWD_TOO_RECENT, ++ MD_NTSTATUS_WIN_STATUS_PWD_HISTORY_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_PLUGPLAY_NO_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_UNSUPPORTED_COMPRESSION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_HW_PROFILE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PLUGPLAY_DEVICE_PATH, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_ORDINAL_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_NOT_OWNED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_LINKS, ++ MD_NTSTATUS_WIN_STATUS_QUOTA_LIST_INCONSISTENT, ++ MD_NTSTATUS_WIN_STATUS_FILE_IS_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_EVALUATION_EXPIRATION, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_DLL_RELOCATION, ++ MD_NTSTATUS_WIN_STATUS_LICENSE_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_DLL_INIT_FAILED_LOGOFF, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_UNABLE_TO_LOAD, ++ MD_NTSTATUS_WIN_STATUS_DFS_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_DISMOUNTED, ++ MD_NTSTATUS_WIN_STATUS_WX86_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_WX86_FLOAT_STACK_CHECK, ++ MD_NTSTATUS_WIN_STATUS_VALIDATE_CONTINUE, ++ MD_NTSTATUS_WIN_STATUS_NO_MATCH, ++ MD_NTSTATUS_WIN_STATUS_NO_MORE_MATCHES, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_REPARSE_POINT, ++ MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_INVALID, ++ MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_IO_REPARSE_DATA_INVALID, ++ MD_NTSTATUS_WIN_STATUS_IO_REPARSE_TAG_NOT_HANDLED, ++ MD_NTSTATUS_WIN_STATUS_PWD_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_STOWED_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_CONTEXT_STOWED_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_NOT_RESOLVED, ++ MD_NTSTATUS_WIN_STATUS_DIRECTORY_IS_A_REPARSE_POINT, ++ MD_NTSTATUS_WIN_STATUS_RANGE_LIST_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_SOURCE_ELEMENT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_DESTINATION_ELEMENT_FULL, ++ MD_NTSTATUS_WIN_STATUS_ILLEGAL_ELEMENT_ADDRESS, ++ MD_NTSTATUS_WIN_STATUS_MAGAZINE_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_REINITIALIZATION_NEEDED, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_DECRYPTION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_RANGE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NO_RECOVERY_POLICY, ++ MD_NTSTATUS_WIN_STATUS_NO_EFS, ++ MD_NTSTATUS_WIN_STATUS_WRONG_EFS, ++ MD_NTSTATUS_WIN_STATUS_NO_USER_KEYS, ++ MD_NTSTATUS_WIN_STATUS_FILE_NOT_ENCRYPTED, ++ MD_NTSTATUS_WIN_STATUS_NOT_EXPORT_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_FILE_ENCRYPTED, ++ MD_NTSTATUS_WIN_STATUS_WMI_GUID_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_WMI_INSTANCE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_WMI_ITEMID_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_WMI_TRY_AGAIN, ++ MD_NTSTATUS_WIN_STATUS_SHARED_POLICY, ++ MD_NTSTATUS_WIN_STATUS_POLICY_OBJECT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_POLICY_ONLY_IN_DS, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_UPGRADED, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_STORAGE_NOT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_STORAGE_MEDIA_ERROR, ++ MD_NTSTATUS_WIN_STATUS_NO_TRACKING_SERVICE, ++ MD_NTSTATUS_WIN_STATUS_SERVER_SID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_ATTRIBUTE_OR_VALUE, ++ MD_NTSTATUS_WIN_STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, ++ MD_NTSTATUS_WIN_STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, ++ MD_NTSTATUS_WIN_STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_DS_BUSY, ++ MD_NTSTATUS_WIN_STATUS_DS_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_RIDS_ALLOCATED, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_MORE_RIDS, ++ MD_NTSTATUS_WIN_STATUS_DS_INCORRECT_ROLE_OWNER, ++ MD_NTSTATUS_WIN_STATUS_DS_RIDMGR_INIT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DS_OBJ_CLASS_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_DS_CANT_ON_NON_LEAF, ++ MD_NTSTATUS_WIN_STATUS_DS_CANT_ON_RDN, ++ MD_NTSTATUS_WIN_STATUS_DS_CANT_MOD_OBJ_CLASS, ++ MD_NTSTATUS_WIN_STATUS_DS_CROSS_DOM_MOVE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_DS_GC_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_DIRECTORY_SERVICE_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_ATTRIBUTE_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_CANT_ENABLE_DENY_ONLY, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_MULTIPLE_FAULTS, ++ MD_NTSTATUS_WIN_STATUS_FLOAT_MULTIPLE_TRAPS, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_REMOVED, ++ MD_NTSTATUS_WIN_STATUS_JOURNAL_DELETE_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_JOURNAL_NOT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_NOINTERFACE, ++ MD_NTSTATUS_WIN_STATUS_DS_RIDMGR_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_DS_ADMIN_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_FAILED_SLEEP, ++ MD_NTSTATUS_WIN_STATUS_MUTUAL_AUTHENTICATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_SYSTEM_FILE, ++ MD_NTSTATUS_WIN_STATUS_DATATYPE_MISALIGNMENT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_WMI_READ_ONLY, ++ MD_NTSTATUS_WIN_STATUS_WMI_SET_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_COMMITMENT_MINIMUM, ++ MD_NTSTATUS_WIN_STATUS_REG_NAT_CONSUMPTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSPORT_FULL, ++ MD_NTSTATUS_WIN_STATUS_DS_SAM_INIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_ONLY_IF_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_DS_SENSITIVE_GROUP_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_PNP_RESTART_ENUMERATION, ++ MD_NTSTATUS_WIN_STATUS_JOURNAL_ENTRY_DELETED, ++ MD_NTSTATUS_WIN_STATUS_DS_CANT_MOD_PRIMARYGROUPID, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_IMAGE_BAD_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_PNP_REBOOT_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_POWER_STATE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_DS_INVALID_GROUP_TYPE, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, ++ MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_DS_HAVE_PRIMARY_MEMBERS, ++ MD_NTSTATUS_WIN_STATUS_WMI_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_POWER, ++ MD_NTSTATUS_WIN_STATUS_SAM_NEED_BOOTKEY_PASSWORD, ++ MD_NTSTATUS_WIN_STATUS_SAM_NEED_BOOTKEY_FLOPPY, ++ MD_NTSTATUS_WIN_STATUS_DS_CANT_START, ++ MD_NTSTATUS_WIN_STATUS_DS_INIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_SAM_INIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_DS_GC_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, ++ MD_NTSTATUS_WIN_STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, ++ MD_NTSTATUS_WIN_STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_MULTIPLE_FAULT_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_CURRENT_DOMAIN_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_MAKE, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_SHUTDOWN, ++ MD_NTSTATUS_WIN_STATUS_DS_INIT_FAILURE_CONSOLE, ++ MD_NTSTATUS_WIN_STATUS_DS_SAM_INIT_FAILURE_CONSOLE, ++ MD_NTSTATUS_WIN_STATUS_UNFINISHED_CONTEXT_DELETED, ++ MD_NTSTATUS_WIN_STATUS_NO_TGT_REPLY, ++ MD_NTSTATUS_WIN_STATUS_OBJECTID_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NO_IP_ADDRESSES, ++ MD_NTSTATUS_WIN_STATUS_WRONG_CREDENTIAL_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_CRYPTO_SYSTEM_INVALID, ++ MD_NTSTATUS_WIN_STATUS_MAX_REFERRALS_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_MUST_BE_KDC, ++ MD_NTSTATUS_WIN_STATUS_STRONG_CRYPTO_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_PRINCIPALS, ++ MD_NTSTATUS_WIN_STATUS_NO_PA_DATA, ++ MD_NTSTATUS_WIN_STATUS_PKINIT_NAME_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_LOGON_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_KDC_INVALID_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_KDC_UNABLE_TO_REFER, ++ MD_NTSTATUS_WIN_STATUS_KDC_UNKNOWN_ETYPE, ++ MD_NTSTATUS_WIN_STATUS_SHUTDOWN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_SERVER_SHUTDOWN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_SBS, ++ MD_NTSTATUS_WIN_STATUS_WMI_GUID_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_WMI_ALREADY_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_WMI_ALREADY_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_MFT_TOO_FRAGMENTED, ++ MD_NTSTATUS_WIN_STATUS_COPY_PROTECTION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_CSS_AUTHENTICATION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_CSS_KEY_NOT_ESTABLISHED, ++ MD_NTSTATUS_WIN_STATUS_CSS_SCRAMBLED_SECTOR, ++ MD_NTSTATUS_WIN_STATUS_CSS_REGION_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_CSS_RESETS_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_PASSWORD_CHANGE_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_LOST_MODE_LOGON_RESTRICTION, ++ MD_NTSTATUS_WIN_STATUS_PKINIT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_SUBSYSTEM_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_NO_KERB_KEY, ++ MD_NTSTATUS_WIN_STATUS_HOST_DOWN, ++ MD_NTSTATUS_WIN_STATUS_UNSUPPORTED_PREAUTH, ++ MD_NTSTATUS_WIN_STATUS_EFS_ALG_BLOB_TOO_BIG, ++ MD_NTSTATUS_WIN_STATUS_PORT_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_DEBUGGER_INACTIVE, ++ MD_NTSTATUS_WIN_STATUS_DS_VERSION_CHECK_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_AUDITING_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_PRENT4_MACHINE_ACCOUNT, ++ MD_NTSTATUS_WIN_STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_32, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_WIN_64, ++ MD_NTSTATUS_WIN_STATUS_BAD_BINDINGS, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_SESSION_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_APPHELP_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_ALL_SIDS_FILTERED, ++ MD_NTSTATUS_WIN_STATUS_NOT_SAFE_MODE_DRIVER, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_PATH, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, ++ MD_NTSTATUS_WIN_STATUS_FAILED_DRIVER_ENTRY, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_ENUMERATION_ERROR, ++ MD_NTSTATUS_WIN_STATUS_MOUNT_POINT_NOT_RESOLVED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_DEVICE_OBJECT_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_MCA_OCCURED, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_BLOCKED_CRITICAL, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_DATABASE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_HIVE_TOO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMPORT_OF_NON_DLL, ++ MD_NTSTATUS_WIN_STATUS_NO_SECRETS, ++ MD_NTSTATUS_WIN_STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, ++ MD_NTSTATUS_WIN_STATUS_FAILED_STACK_SWITCH, ++ MD_NTSTATUS_WIN_STATUS_HEAP_CORRUPTION, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_WRONG_PIN, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_CARD_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_CARD, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_KEY_CONTAINER, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_CERTIFICATE, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_NO_KEYSET, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_IO_ERROR, ++ MD_NTSTATUS_WIN_STATUS_DOWNGRADE_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_CERT_REVOKED, ++ MD_NTSTATUS_WIN_STATUS_ISSUING_CA_UNTRUSTED, ++ MD_NTSTATUS_WIN_STATUS_REVOCATION_OFFLINE_C, ++ MD_NTSTATUS_WIN_STATUS_PKINIT_CLIENT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_CERT_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_FAILED_PRIOR_UNLOAD, ++ MD_NTSTATUS_WIN_STATUS_SMARTCARD_SILENT_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_PER_USER_TRUST_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_DS_NAME_NOT_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_DS_DUPLICATE_ID_FOUND, ++ MD_NTSTATUS_WIN_STATUS_DS_GROUP_CONVERSION_ERROR, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_PREPARE_HIBERNATE, ++ MD_NTSTATUS_WIN_STATUS_USER2USER_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_STACK_BUFFER_OVERRUN, ++ MD_NTSTATUS_WIN_STATUS_NO_S4U_PROT_SUPPORT, ++ MD_NTSTATUS_WIN_STATUS_CROSSREALM_DELEGATION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_REVOCATION_OFFLINE_KDC, ++ MD_NTSTATUS_WIN_STATUS_ISSUING_CA_UNTRUSTED_KDC, ++ MD_NTSTATUS_WIN_STATUS_KDC_CERT_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_KDC_CERT_REVOKED, ++ MD_NTSTATUS_WIN_STATUS_PARAMETER_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_HIBERNATION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_DELAY_LOAD_FAILED, ++ MD_NTSTATUS_WIN_STATUS_AUTHENTICATION_FIREWALL_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VDM_DISALLOWED, ++ MD_NTSTATUS_WIN_STATUS_HUNG_DISPLAY_DRIVER_THREAD, ++ MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_CRUNTIME_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_NTLM_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_DS_SRC_SID_EXISTS_IN_FOREST, ++ MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST, ++ MD_NTSTATUS_WIN_STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST, ++ MD_NTSTATUS_WIN_STATUS_INVALID_USER_PRINCIPAL_NAME, ++ MD_NTSTATUS_WIN_STATUS_FATAL_USER_CALLBACK_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_ASSERTION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_VERIFIER_STOP, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_POP_STACK, ++ MD_NTSTATUS_WIN_STATUS_INCOMPATIBLE_DRIVER_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_HIVE_UNLOADED, ++ MD_NTSTATUS_WIN_STATUS_COMPRESSION_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_LIMITATION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IMAGE_HASH, ++ MD_NTSTATUS_WIN_STATUS_NOT_CAPABLE, ++ MD_NTSTATUS_WIN_STATUS_REQUEST_OUT_OF_SEQUENCE, ++ MD_NTSTATUS_WIN_STATUS_IMPLEMENTATION_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_ELEVATION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_NO_SECURITY_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_PKU2U_CERT_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_BEYOND_VDL, ++ MD_NTSTATUS_WIN_STATUS_ENCOUNTERED_WRITE_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_PTE_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_PURGE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_CRED_REQUIRES_CONFIRMATION, ++ MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, ++ MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER, ++ MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, ++ MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, ++ MD_NTSTATUS_WIN_STATUS_CS_ENCRYPTION_FILE_NOT_CSE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_LABEL, ++ MD_NTSTATUS_WIN_STATUS_DRIVER_PROCESS_TERMINATED, ++ MD_NTSTATUS_WIN_STATUS_AMBIGUOUS_SYSTEM_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_DEVICE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RESTART_BOOT_APPLICATION, ++ MD_NTSTATUS_WIN_STATUS_INSUFFICIENT_NVRAM_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SESSION, ++ MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_SESSION, ++ MD_NTSTATUS_WIN_STATUS_THREAD_NOT_IN_SESSION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_WEIGHT, ++ MD_NTSTATUS_WIN_STATUS_REQUEST_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_NO_RANGES_PROCESSED, ++ MD_NTSTATUS_WIN_STATUS_DISK_RESOURCES_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_NEEDS_REMEDIATION, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_FEATURE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_TOKEN, ++ MD_NTSTATUS_WIN_STATUS_SERVER_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_FILE_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_INSUFFICIENT_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_PACKAGE_UPDATING, ++ MD_NTSTATUS_WIN_STATUS_NOT_READ_FROM_COPY, ++ MD_NTSTATUS_WIN_STATUS_FT_WRITE_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_FT_DI_SCAN_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NOT_EXTERNALLY_BACKED, ++ MD_NTSTATUS_WIN_STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN, ++ MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_BENEFICIAL, ++ MD_NTSTATUS_WIN_STATUS_DATA_CHECKSUM_ERROR, ++ MD_NTSTATUS_WIN_STATUS_INTERMIXED_KERNEL_EA_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_TRIM_READ_ZERO_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_TOO_MANY_SEGMENT_DESCRIPTORS, ++ MD_NTSTATUS_WIN_STATUS_INVALID_OFFSET_ALIGNMENT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_FIELD_IN_PARAMETER_LIST, ++ MD_NTSTATUS_WIN_STATUS_OPERATION_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_INVALID_INITIATOR_TARGET_PATH, ++ MD_NTSTATUS_WIN_STATUS_SCRUB_DATA_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_NOT_REDUNDANT_STORAGE, ++ MD_NTSTATUS_WIN_STATUS_RESIDENT_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_COMPRESSED_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_IO_OPERATION_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_NEEDS_REMEDIATION, ++ MD_NTSTATUS_WIN_STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN, ++ MD_NTSTATUS_WIN_STATUS_SHARE_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_APISET_NOT_HOSTED, ++ MD_NTSTATUS_WIN_STATUS_APISET_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_HARDWARE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_SLOT_INVALID, ++ MD_NTSTATUS_WIN_STATUS_FIRMWARE_IMAGE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_TOPOLOGY_ID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_WIM_NOT_BOOTABLE, ++ MD_NTSTATUS_WIN_STATUS_BLOCKED_BY_PARENTAL_CONTROLS, ++ MD_NTSTATUS_WIN_STATUS_NEEDS_REGISTRATION, ++ MD_NTSTATUS_WIN_STATUS_QUOTA_ACTIVITY, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_INVOKE_INLINE, ++ MD_NTSTATUS_WIN_STATUS_BLOCK_TOO_MANY_REFERENCES, ++ MD_NTSTATUS_WIN_STATUS_MARKED_TO_DISALLOW_WRITES, ++ MD_NTSTATUS_WIN_STATUS_NETWORK_ACCESS_DENIED_EDP, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_PNP_NO_COMPAT_DRIVERS, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_PNP_FUNCTION_DRIVER_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_PNP_DEVICE_CONFIGURATION_PENDING, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_PACKAGE_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_IN_MAINTENANCE, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_ON_DAX, ++ MD_NTSTATUS_WIN_STATUS_FREE_SPACE_TOO_FRAGMENTED, ++ MD_NTSTATUS_WIN_STATUS_DAX_MAPPING_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_CHILD_PROCESS_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_LOST_DATA_PERSISTENCE, ++ MD_NTSTATUS_WIN_STATUS_VRF_CFG_AND_IO_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_PARTITION_TERMINATING, ++ MD_NTSTATUS_WIN_STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_FILE_PROTECTED_UNDER_DPL, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_NOT_CLUSTER_ALIGNED, ++ MD_NTSTATUS_WIN_STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND, ++ MD_NTSTATUS_WIN_STATUS_APPX_FILE_NOT_ENCRYPTED, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE, ++ MD_NTSTATUS_WIN_STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_FT_READ_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_PATCH_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ID_INVALID, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_DOES_NOT_EXIST, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_STORAGE_RESERVE_NOT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_DAX_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_NOT_DAX_MAPPABLE, ++ MD_NTSTATUS_WIN_STATUS_CASE_DIFFERING_NAMES_IN_DIR, ++ MD_NTSTATUS_WIN_STATUS_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_WITH_BTT, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTION_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTING_METADATA_DISALLOWED, ++ MD_NTSTATUS_WIN_STATUS_CANT_CLEAR_ENCRYPTION_FLAG, ++ MD_NTSTATUS_WIN_STATUS_UNSATISFIED_DEPENDENCIES, ++ MD_NTSTATUS_WIN_STATUS_CASE_SENSITIVE_PATH, ++ MD_NTSTATUS_WIN_STATUS_HAS_SYSTEM_CRITICAL_FILES, ++ MD_NTSTATUS_WIN_STATUS_INVALID_TASK_NAME, ++ MD_NTSTATUS_WIN_STATUS_INVALID_TASK_INDEX, ++ MD_NTSTATUS_WIN_STATUS_THREAD_ALREADY_IN_TASK, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_BYPASS, ++ MD_NTSTATUS_WIN_STATUS_UNDEFINED_SCOPE, ++ MD_NTSTATUS_WIN_STATUS_INVALID_CAP, ++ MD_NTSTATUS_WIN_STATUS_NOT_GUI_PROCESS, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_HUNG, ++ MD_NTSTATUS_WIN_STATUS_CONTAINER_ASSIGNED, ++ MD_NTSTATUS_WIN_STATUS_JOB_NO_CONTAINER, ++ MD_NTSTATUS_WIN_STATUS_DEVICE_UNRESPONSIVE, ++ MD_NTSTATUS_WIN_STATUS_REPARSE_POINT_ENCOUNTERED, ++ MD_NTSTATUS_WIN_STATUS_ATTRIBUTE_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_TIERED_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_HAS_STREAM_ID, ++ MD_NTSTATUS_WIN_STATUS_JOB_NOT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_NOT_TERMINATED, ++ MD_NTSTATUS_WIN_STATUS_ENCLAVE_IS_TERMINATING, ++ MD_NTSTATUS_WIN_STATUS_SMB1_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_SMR_GARBAGE_COLLECTION_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_INTERRUPTED, ++ MD_NTSTATUS_WIN_STATUS_THREAD_NOT_RUNNING, ++ MD_NTSTATUS_WIN_STATUS_FAIL_FAST_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_REVOKED, ++ MD_NTSTATUS_WIN_STATUS_DYNAMIC_CODE_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_IMAGE_CERT_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_STRICT_CFG_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_SET_CONTEXT_DENIED, ++ MD_NTSTATUS_WIN_STATUS_CROSS_PARTITION_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_PORT_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_MESSAGE_LOST, ++ MD_NTSTATUS_WIN_STATUS_INVALID_MESSAGE, ++ MD_NTSTATUS_WIN_STATUS_REQUEST_CANCELED, ++ MD_NTSTATUS_WIN_STATUS_RECURSIVE_DISPATCH, ++ MD_NTSTATUS_WIN_STATUS_LPC_RECEIVE_BUFFER_EXPECTED, ++ MD_NTSTATUS_WIN_STATUS_LPC_INVALID_CONNECTION_USAGE, ++ MD_NTSTATUS_WIN_STATUS_LPC_REQUESTS_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_HARDWARE_MEMORY_ERROR, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_HANDLE_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_THREADPOOL_RELEASED_DURING_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING, ++ MD_NTSTATUS_WIN_STATUS_APC_RETURNED_WHILE_IMPERSONATING, ++ MD_NTSTATUS_WIN_STATUS_PROCESS_IS_PROTECTED, ++ MD_NTSTATUS_WIN_STATUS_MCA_EXCEPTION, ++ MD_NTSTATUS_WIN_STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_SYMLINK_CLASS_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_INVALID_IDN_NORMALIZATION, ++ MD_NTSTATUS_WIN_STATUS_NO_UNICODE_TRANSLATION, ++ MD_NTSTATUS_WIN_STATUS_ALREADY_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_CONTEXT_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_PORT_ALREADY_HAS_COMPLETION_LIST, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_PRIORITY, ++ MD_NTSTATUS_WIN_STATUS_INVALID_THREAD, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LDR_LOCK, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_LANG, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_PRI_BACK, ++ MD_NTSTATUS_WIN_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY, ++ MD_NTSTATUS_WIN_STATUS_LPC_HANDLE_COUNT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_EXECUTABLE_MEMORY_WRITE, ++ MD_NTSTATUS_WIN_STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE, ++ MD_NTSTATUS_WIN_STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE, ++ MD_NTSTATUS_WIN_STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE, ++ MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_DISK_QUOTA_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_CONTENT_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_BAD_CLUSTERS, ++ MD_NTSTATUS_WIN_STATUS_VOLUME_DIRTY, ++ MD_NTSTATUS_WIN_STATUS_DISK_REPAIR_UNSUCCESSFUL, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_OVERFULL, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_CORRUPTED, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_DELETED_FULL, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_CLEARED, ++ MD_NTSTATUS_WIN_STATUS_ORPHAN_NAME_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_PROACTIVE_SCAN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_ENCRYPTED_IO_NOT_POSSIBLE, ++ MD_NTSTATUS_WIN_STATUS_CORRUPT_LOG_UPLEVEL_RECORDS, ++ MD_NTSTATUS_WIN_STATUS_FILE_CHECKED_OUT, ++ MD_NTSTATUS_WIN_STATUS_CHECKOUT_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_BAD_FILE_TYPE, ++ MD_NTSTATUS_WIN_STATUS_FILE_TOO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_FORMS_AUTH_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_VIRUS_INFECTED, ++ MD_NTSTATUS_WIN_STATUS_VIRUS_DELETED, ++ MD_NTSTATUS_WIN_STATUS_BAD_MCFG_TABLE, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_BREAK_OPLOCK, ++ MD_NTSTATUS_WIN_STATUS_BAD_KEY, ++ MD_NTSTATUS_WIN_STATUS_BAD_DATA, ++ MD_NTSTATUS_WIN_STATUS_NO_KEY, ++ MD_NTSTATUS_WIN_STATUS_FILE_HANDLE_REVOKED, ++ MD_NTSTATUS_WIN_STATUS_WOW_ASSERTION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_HMAC_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_AUTH_TAG_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_INVALID_STATE_TRANSITION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_KERNEL_INFO_VERSION, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PEP_INFO_VERSION, ++ MD_NTSTATUS_WIN_STATUS_HANDLE_REVOKED, ++ MD_NTSTATUS_WIN_STATUS_EOF_ON_GHOSTED_RANGE, ++ MD_NTSTATUS_WIN_STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_QUEUE_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_ND_QUEUE_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_HOPLIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_PROTOCOL_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_FASTPATH_REJECTED, ++ MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, ++ MD_NTSTATUS_WIN_STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, ++ MD_NTSTATUS_WIN_STATUS_XML_PARSE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_XMLDSIG_ERROR, ++ MD_NTSTATUS_WIN_STATUS_WRONG_COMPARTMENT, ++ MD_NTSTATUS_WIN_STATUS_AUTHIP_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS, ++ MD_NTSTATUS_WIN_STATUS_DS_OID_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_INCORRECT_ACCOUNT_TYPE, ++ MD_NTSTATUS_WIN_STATUS_HASH_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_HASH_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_GPIO_CLIENT_INFORMATION_INVALID, ++ MD_NTSTATUS_WIN_STATUS_GPIO_VERSION_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GPIO_INVALID_REGISTRATION_PACKET, ++ MD_NTSTATUS_WIN_STATUS_GPIO_OPERATION_DENIED, ++ MD_NTSTATUS_WIN_STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_SWITCH_RUNLEVEL, ++ MD_NTSTATUS_WIN_STATUS_INVALID_RUNLEVEL_SETTING, ++ MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_RUNLEVEL_SWITCH_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_NOT_APPCONTAINER, ++ MD_NTSTATUS_WIN_STATUS_NOT_SUPPORTED_IN_APPCONTAINER, ++ MD_NTSTATUS_WIN_STATUS_INVALID_PACKAGE_SID_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_LPAC_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_ADMINLESS_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_APP_DATA_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_APP_DATA_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_APP_DATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_APP_DATA_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_APP_DATA_REBOOT_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_WOF_WIM_HEADER_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_CIMFS_IMAGE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN, ++ MD_NTSTATUS_WIN_STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_METADATA_TOO_LARGE, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_FILE, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_IN_SYNC, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ALREADY_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INVALID_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_READ_ONLY_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_VALIDATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_AUTHENTICATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_UNSUCCESSFUL, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PINNED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_CANCELED, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_PROVIDER_TERMINATED, ++ MD_NTSTATUS_WIN_STATUS_NOT_A_CLOUD_SYNC_ROOT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_REQUEST_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_IO_NOT_COORDINATED, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_UNEXPECTED_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FILE_SNAP_INVALID_PARAMETER, ++ MD_NTSTATUS_WIN_DBG_NO_STATE_CHANGE, ++ MD_NTSTATUS_WIN_DBG_APP_NOT_IDLE, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_BINDING, ++ MD_NTSTATUS_WIN_RPC_NT_WRONG_KIND_OF_BINDING, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_BINDING, ++ MD_NTSTATUS_WIN_RPC_NT_PROTSEQ_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_RPC_PROTSEQ, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_STRING_UUID, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_ENDPOINT_FORMAT, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_NET_ADDR, ++ MD_NTSTATUS_WIN_RPC_NT_NO_ENDPOINT_FOUND, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_TIMEOUT, ++ MD_NTSTATUS_WIN_RPC_NT_OBJECT_NOT_FOUND, ++ MD_NTSTATUS_WIN_RPC_NT_ALREADY_REGISTERED, ++ MD_NTSTATUS_WIN_RPC_NT_TYPE_ALREADY_REGISTERED, ++ MD_NTSTATUS_WIN_RPC_NT_ALREADY_LISTENING, ++ MD_NTSTATUS_WIN_RPC_NT_NO_PROTSEQS_REGISTERED, ++ MD_NTSTATUS_WIN_RPC_NT_NOT_LISTENING, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_MGR_TYPE, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_IF, ++ MD_NTSTATUS_WIN_RPC_NT_NO_BINDINGS, ++ MD_NTSTATUS_WIN_RPC_NT_NO_PROTSEQS, ++ MD_NTSTATUS_WIN_RPC_NT_CANT_CREATE_ENDPOINT, ++ MD_NTSTATUS_WIN_RPC_NT_OUT_OF_RESOURCES, ++ MD_NTSTATUS_WIN_RPC_NT_SERVER_UNAVAILABLE, ++ MD_NTSTATUS_WIN_RPC_NT_SERVER_TOO_BUSY, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_NETWORK_OPTIONS, ++ MD_NTSTATUS_WIN_RPC_NT_NO_CALL_ACTIVE, ++ MD_NTSTATUS_WIN_RPC_NT_CALL_FAILED, ++ MD_NTSTATUS_WIN_RPC_NT_CALL_FAILED_DNE, ++ MD_NTSTATUS_WIN_RPC_NT_PROTOCOL_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_TRANS_SYN, ++ MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_TYPE, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_TAG, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_BOUND, ++ MD_NTSTATUS_WIN_RPC_NT_NO_ENTRY_NAME, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_NAME_SYNTAX, ++ MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_NAME_SYNTAX, ++ MD_NTSTATUS_WIN_RPC_NT_UUID_NO_ADDRESS, ++ MD_NTSTATUS_WIN_RPC_NT_DUPLICATE_ENDPOINT, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_TYPE, ++ MD_NTSTATUS_WIN_RPC_NT_MAX_CALLS_TOO_SMALL, ++ MD_NTSTATUS_WIN_RPC_NT_STRING_TOO_LONG, ++ MD_NTSTATUS_WIN_RPC_NT_PROTSEQ_NOT_FOUND, ++ MD_NTSTATUS_WIN_RPC_NT_PROCNUM_OUT_OF_RANGE, ++ MD_NTSTATUS_WIN_RPC_NT_BINDING_HAS_NO_AUTH, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_SERVICE, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHN_LEVEL, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_AUTH_IDENTITY, ++ MD_NTSTATUS_WIN_RPC_NT_UNKNOWN_AUTHZ_SERVICE, ++ MD_NTSTATUS_WIN_EPT_NT_INVALID_ENTRY, ++ MD_NTSTATUS_WIN_EPT_NT_CANT_PERFORM_OP, ++ MD_NTSTATUS_WIN_EPT_NT_NOT_REGISTERED, ++ MD_NTSTATUS_WIN_RPC_NT_NOTHING_TO_EXPORT, ++ MD_NTSTATUS_WIN_RPC_NT_INCOMPLETE_NAME, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_VERS_OPTION, ++ MD_NTSTATUS_WIN_RPC_NT_NO_MORE_MEMBERS, ++ MD_NTSTATUS_WIN_RPC_NT_NOT_ALL_OBJS_UNEXPORTED, ++ MD_NTSTATUS_WIN_RPC_NT_INTERFACE_NOT_FOUND, ++ MD_NTSTATUS_WIN_RPC_NT_ENTRY_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_RPC_NT_ENTRY_NOT_FOUND, ++ MD_NTSTATUS_WIN_RPC_NT_NAME_SERVICE_UNAVAILABLE, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_NAF_ID, ++ MD_NTSTATUS_WIN_RPC_NT_CANNOT_SUPPORT, ++ MD_NTSTATUS_WIN_RPC_NT_NO_CONTEXT_AVAILABLE, ++ MD_NTSTATUS_WIN_RPC_NT_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_ZERO_DIVIDE, ++ MD_NTSTATUS_WIN_RPC_NT_ADDRESS_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_FP_DIV_ZERO, ++ MD_NTSTATUS_WIN_RPC_NT_FP_UNDERFLOW, ++ MD_NTSTATUS_WIN_RPC_NT_FP_OVERFLOW, ++ MD_NTSTATUS_WIN_RPC_NT_CALL_IN_PROGRESS, ++ MD_NTSTATUS_WIN_RPC_NT_NO_MORE_BINDINGS, ++ MD_NTSTATUS_WIN_RPC_NT_GROUP_MEMBER_NOT_FOUND, ++ MD_NTSTATUS_WIN_EPT_NT_CANT_CREATE, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_OBJECT, ++ MD_NTSTATUS_WIN_RPC_NT_NO_INTERFACES, ++ MD_NTSTATUS_WIN_RPC_NT_CALL_CANCELLED, ++ MD_NTSTATUS_WIN_RPC_NT_BINDING_INCOMPLETE, ++ MD_NTSTATUS_WIN_RPC_NT_COMM_FAILURE, ++ MD_NTSTATUS_WIN_RPC_NT_UNSUPPORTED_AUTHN_LEVEL, ++ MD_NTSTATUS_WIN_RPC_NT_NO_PRINC_NAME, ++ MD_NTSTATUS_WIN_RPC_NT_NOT_RPC_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_SEC_PKG_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_NOT_CANCELLED, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_ASYNC_HANDLE, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_ASYNC_CALL, ++ MD_NTSTATUS_WIN_RPC_NT_PROXY_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_RPC_NT_COOKIE_AUTH_FAILED, ++ MD_NTSTATUS_WIN_RPC_NT_NO_MORE_ENTRIES, ++ MD_NTSTATUS_WIN_RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, ++ MD_NTSTATUS_WIN_RPC_NT_SS_CHAR_TRANS_SHORT_FILE, ++ MD_NTSTATUS_WIN_RPC_NT_SS_IN_NULL_CONTEXT, ++ MD_NTSTATUS_WIN_RPC_NT_SS_CONTEXT_MISMATCH, ++ MD_NTSTATUS_WIN_RPC_NT_SS_CONTEXT_DAMAGED, ++ MD_NTSTATUS_WIN_RPC_NT_SS_HANDLES_MISMATCH, ++ MD_NTSTATUS_WIN_RPC_NT_SS_CANNOT_GET_CALL_HANDLE, ++ MD_NTSTATUS_WIN_RPC_NT_NULL_REF_POINTER, ++ MD_NTSTATUS_WIN_RPC_NT_ENUM_VALUE_OUT_OF_RANGE, ++ MD_NTSTATUS_WIN_RPC_NT_BYTE_COUNT_TOO_SMALL, ++ MD_NTSTATUS_WIN_RPC_NT_BAD_STUB_DATA, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_ES_ACTION, ++ MD_NTSTATUS_WIN_RPC_NT_WRONG_ES_VERSION, ++ MD_NTSTATUS_WIN_RPC_NT_WRONG_STUB_VERSION, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_PIPE_OBJECT, ++ MD_NTSTATUS_WIN_RPC_NT_INVALID_PIPE_OPERATION, ++ MD_NTSTATUS_WIN_RPC_NT_WRONG_PIPE_VERSION, ++ MD_NTSTATUS_WIN_RPC_NT_PIPE_CLOSED, ++ MD_NTSTATUS_WIN_RPC_NT_PIPE_DISCIPLINE_ERROR, ++ MD_NTSTATUS_WIN_RPC_NT_PIPE_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_PNP_BAD_MPS_TABLE, ++ MD_NTSTATUS_WIN_STATUS_PNP_TRANSLATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_PNP_IRQ_TRANSLATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_PNP_INVALID_ID, ++ MD_NTSTATUS_WIN_STATUS_IO_REISSUE_AS_CACHED, ++ MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NAME_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CTX_INVALID_PD, ++ MD_NTSTATUS_WIN_STATUS_CTX_PD_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CTX_CLOSE_PENDING, ++ MD_NTSTATUS_WIN_STATUS_CTX_NO_OUTBUF, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_INF_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CTX_INVALID_MODEMNAME, ++ MD_NTSTATUS_WIN_STATUS_CTX_RESPONSE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_BUSY, ++ MD_NTSTATUS_WIN_STATUS_CTX_MODEM_RESPONSE_VOICE, ++ MD_NTSTATUS_WIN_STATUS_CTX_TD_ERROR, ++ MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_CLIENT_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_CTX_LICENSE_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_NAME_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_BUSY, ++ MD_NTSTATUS_WIN_STATUS_CTX_BAD_VIDEO_MODE, ++ MD_NTSTATUS_WIN_STATUS_CTX_GRAPHICS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CTX_NOT_CONSOLE, ++ MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_QUERY_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_CTX_CONSOLE_DISCONNECT, ++ MD_NTSTATUS_WIN_STATUS_CTX_CONSOLE_CONNECT, ++ MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_DENIED, ++ MD_NTSTATUS_WIN_STATUS_CTX_WINSTATION_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_CTX_INVALID_WD, ++ MD_NTSTATUS_WIN_STATUS_CTX_WD_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_RDP_PROTOCOL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_LICENSE_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_CTX_CLIENT_LICENSE_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, ++ MD_NTSTATUS_WIN_STATUS_CTX_SHADOW_NOT_RUNNING, ++ MD_NTSTATUS_WIN_STATUS_CTX_LOGON_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_CTX_SECURITY_LAYER_ERROR, ++ MD_NTSTATUS_WIN_STATUS_TS_INCOMPATIBLE_SESSIONS, ++ MD_NTSTATUS_WIN_STATUS_TS_VIDEO_SUBSYSTEM_ERROR, ++ MD_NTSTATUS_WIN_STATUS_MUI_FILE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_MUI_INVALID_FILE, ++ MD_NTSTATUS_WIN_STATUS_MUI_INVALID_RC_CONFIG, ++ MD_NTSTATUS_WIN_STATUS_MUI_INVALID_LOCALE_NAME, ++ MD_NTSTATUS_WIN_STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME, ++ MD_NTSTATUS_WIN_STATUS_MUI_FILE_NOT_LOADED, ++ MD_NTSTATUS_WIN_STATUS_RESOURCE_ENUM_USER_STOP, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NODE, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_JOIN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETINTERFACE_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NETWORK_PROVIDER, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_DOWN, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_UNREACHABLE, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_MEMBER, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_INVALID_NETWORK, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NO_NET_ADAPTERS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_UP, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NODE_NOT_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NO_SECURITY_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NETWORK_NOT_INTERNAL, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_POISONED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_NON_CSV_PATH, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_REDIRECTED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NOT_REDIRECTED, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_NO_SNAPSHOTS, ++ MD_NTSTATUS_WIN_STATUS_CSV_IO_PAUSE_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR, ++ MD_NTSTATUS_WIN_STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OPCODE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_STACK_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_ACPI_ASSERT_FAILED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_INDEX, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGUMENT, ++ MD_NTSTATUS_WIN_STATUS_ACPI_FATAL, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_SUPERNAME, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ARGTYPE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_OBJTYPE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_TARGETTYPE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INCORRECT_ARGUMENT_COUNT, ++ MD_NTSTATUS_WIN_STATUS_ACPI_ADDRESS_NOT_MAPPED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_EVENTTYPE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_HANDLER_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_DATA, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_REGION, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_ACCESS_SIZE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_ACQUIRE_GLOBAL_LOCK, ++ MD_NTSTATUS_WIN_STATUS_ACPI_ALREADY_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_NOT_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_MUTEX_LEVEL, ++ MD_NTSTATUS_WIN_STATUS_ACPI_MUTEX_NOT_OWNED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_MUTEX_NOT_OWNER, ++ MD_NTSTATUS_WIN_STATUS_ACPI_RS_ACCESS, ++ MD_NTSTATUS_WIN_STATUS_ACPI_INVALID_TABLE, ++ MD_NTSTATUS_WIN_STATUS_ACPI_REG_HANDLER_FAILED, ++ MD_NTSTATUS_WIN_STATUS_ACPI_POWER_REQUEST_FAILED, ++ MD_NTSTATUS_WIN_STATUS_SXS_SECTION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_SXS_CANT_GEN_ACTCTX, ++ MD_NTSTATUS_WIN_STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_FORMAT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_PARSE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_SXS_KEY_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_SXS_VERSION_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_SXS_WRONG_SECTION_TYPE, ++ MD_NTSTATUS_WIN_STATUS_SXS_THREAD_QUERIES_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_MISSING, ++ MD_NTSTATUS_WIN_STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, ++ MD_NTSTATUS_WIN_STATUS_SXS_EARLY_DEACTIVATION, ++ MD_NTSTATUS_WIN_STATUS_SXS_INVALID_DEACTIVATION, ++ MD_NTSTATUS_WIN_STATUS_SXS_MULTIPLE_DEACTIVATION, ++ MD_NTSTATUS_WIN_STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_SXS_PROCESS_TERMINATION_REQUESTED, ++ MD_NTSTATUS_WIN_STATUS_SXS_CORRUPT_ACTIVATION_STACK, ++ MD_NTSTATUS_WIN_STATUS_SXS_CORRUPTION, ++ MD_NTSTATUS_WIN_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, ++ MD_NTSTATUS_WIN_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, ++ MD_NTSTATUS_WIN_STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, ++ MD_NTSTATUS_WIN_STATUS_SXS_IDENTITY_PARSE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SXS_COMPONENT_STORE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_SXS_FILE_HASH_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, ++ MD_NTSTATUS_WIN_STATUS_SXS_IDENTITIES_DIFFERENT, ++ MD_NTSTATUS_WIN_STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, ++ MD_NTSTATUS_WIN_STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY, ++ MD_NTSTATUS_WIN_STATUS_ADVANCED_INSTALLER_FAILED, ++ MD_NTSTATUS_WIN_STATUS_XML_ENCODING_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_SXS_MANIFEST_TOO_BIG, ++ MD_NTSTATUS_WIN_STATUS_SXS_SETTING_NOT_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_SMI_PRIMITIVE_INSTALLER_FAILED, ++ MD_NTSTATUS_WIN_STATUS_GENERIC_COMMAND_FAILED, ++ MD_NTSTATUS_WIN_STATUS_SXS_FILE_HASH_MISSING, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONAL_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_INVALID_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_TM_INITIALIZATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_RM_NOT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_RM_METADATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_JOINED, ++ MD_NTSTATUS_WIN_STATUS_DIRECTORY_NOT_RM, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE, ++ MD_NTSTATUS_WIN_STATUS_LOG_RESIZE_INVALID_SIZE, ++ MD_NTSTATUS_WIN_STATUS_REMOTE_FILE_VERSION_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_CRM_PROTOCOL_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_PROPAGATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_CRM_PROTOCOL_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_SUPERIOR_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_REQUEST_NOT_VALID, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_REQUESTED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_ALREADY_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_ALREADY_COMMITTED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_CURRENT_TRANSACTION_NOT_VALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_GROWTH_FAILED, ++ MD_NTSTATUS_WIN_STATUS_OBJECT_NO_LONGER_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_STREAM_MINIVERSION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_STREAM_MINIVERSION_NOT_VALID, ++ MD_NTSTATUS_WIN_STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, ++ MD_NTSTATUS_WIN_STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS, ++ MD_NTSTATUS_WIN_STATUS_HANDLE_NO_LONGER_VALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_CORRUPTION_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_RM_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_ENLISTMENT_NOT_SUPERIOR, ++ MD_NTSTATUS_WIN_STATUS_FILE_IDENTITY_NOT_PERSISTENT, ++ MD_NTSTATUS_WIN_STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, ++ MD_NTSTATUS_WIN_STATUS_CANT_CROSS_RM_BOUNDARY, ++ MD_NTSTATUS_WIN_STATUS_TXF_DIR_NOT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_INDOUBT_TRANSACTIONS_EXIST, ++ MD_NTSTATUS_WIN_STATUS_TM_VOLATILE, ++ MD_NTSTATUS_WIN_STATUS_ROLLBACK_TIMER_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_TXF_ATTRIBUTE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_REQUIRED_PROMOTION, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONS_NOT_FROZEN, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_FREEZE_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_NOT_SNAPSHOT_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_NO_SAVEPOINT_WITH_OPEN_FILES, ++ MD_NTSTATUS_WIN_STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TM_IDENTITY_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FLOATED_SECTION, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_ACCEPT_TRANSACTED_WORK, ++ MD_NTSTATUS_WIN_STATUS_CANNOT_ABORT_TRANSACTIONS, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RESOURCEMANAGER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_ENLISTMENT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_NOT_ONLINE, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ROOT, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_OBJECT_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_RECORD_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_NO_LINK_TRACKING_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_INTEGRITY_VIOLATED, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_MUST_WRITETHROUGH, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NO_SUPERIOR, ++ MD_NTSTATUS_WIN_STATUS_EXPIRED_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_TRANSACTION_NOT_ENLISTED, ++ MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_PARITY_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_SECTOR_REMAPPED, ++ MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_LOG_INVALID_RANGE, ++ MD_NTSTATUS_WIN_STATUS_LOG_BLOCKS_EXHAUSTED, ++ MD_NTSTATUS_WIN_STATUS_LOG_READ_CONTEXT_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_RESTART_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_VERSION, ++ MD_NTSTATUS_WIN_STATUS_LOG_BLOCK_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_READ_MODE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_METADATA_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_LOG_METADATA_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_METADATA_INCONSISTENT, ++ MD_NTSTATUS_WIN_STATUS_LOG_RESERVATION_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_CANT_DELETE, ++ MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_LOG_START_OF_LOG, ++ MD_NTSTATUS_WIN_STATUS_LOG_POLICY_ALREADY_INSTALLED, ++ MD_NTSTATUS_WIN_STATUS_LOG_POLICY_NOT_INSTALLED, ++ MD_NTSTATUS_WIN_STATUS_LOG_POLICY_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_POLICY_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_LOG_PINNED_ARCHIVE_TAIL, ++ MD_NTSTATUS_WIN_STATUS_LOG_RECORD_NONEXISTENT, ++ MD_NTSTATUS_WIN_STATUS_LOG_RECORDS_RESERVED_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_SPACE_RESERVED_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_TAIL_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_FULL, ++ MD_NTSTATUS_WIN_STATUS_LOG_MULTIPLEXED, ++ MD_NTSTATUS_WIN_STATUS_LOG_DEDICATED, ++ MD_NTSTATUS_WIN_STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_LOG_ARCHIVE_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_LOG_EPHEMERAL, ++ MD_NTSTATUS_WIN_STATUS_LOG_NOT_ENOUGH_CONTAINERS, ++ MD_NTSTATUS_WIN_STATUS_LOG_CLIENT_ALREADY_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_LOG_CLIENT_NOT_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_LOG_FULL_HANDLER_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_READ_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_WRITE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_OPEN_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LOG_CONTAINER_STATE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_STATE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_LOG_PINNED, ++ MD_NTSTATUS_WIN_STATUS_LOG_METADATA_FLUSH_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LOG_INCONSISTENT_SECURITY, ++ MD_NTSTATUS_WIN_STATUS_LOG_APPENDED_FLUSH_FAILED, ++ MD_NTSTATUS_WIN_STATUS_LOG_PINNED_RESERVATION, ++ MD_NTSTATUS_WIN_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD, ++ MD_NTSTATUS_WIN_STATUS_FLT_NO_HANDLER_DEFINED, ++ MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALREADY_DEFINED, ++ MD_NTSTATUS_WIN_STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_FLT_DISALLOW_FAST_IO, ++ MD_NTSTATUS_WIN_STATUS_FLT_INVALID_NAME_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_FLT_NOT_SAFE_TO_POST_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_FLT_NOT_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_FLT_FILTER_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_FLT_POST_OPERATION_CLEANUP, ++ MD_NTSTATUS_WIN_STATUS_FLT_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FLT_DELETING_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_FLT_MUST_BE_NONPAGED_POOL, ++ MD_NTSTATUS_WIN_STATUS_FLT_DUPLICATE_ENTRY, ++ MD_NTSTATUS_WIN_STATUS_FLT_CBDQ_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FLT_DO_NOT_ATTACH, ++ MD_NTSTATUS_WIN_STATUS_FLT_DO_NOT_DETACH, ++ MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_ALTITUDE_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_NAME_COLLISION, ++ MD_NTSTATUS_WIN_STATUS_FLT_FILTER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FLT_VOLUME_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FLT_INSTANCE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FLT_INVALID_CONTEXT_REGISTRATION, ++ MD_NTSTATUS_WIN_STATUS_FLT_NAME_CACHE_MISS, ++ MD_NTSTATUS_WIN_STATUS_FLT_NO_DEVICE_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_FLT_VOLUME_ALREADY_MOUNTED, ++ MD_NTSTATUS_WIN_STATUS_FLT_ALREADY_ENLISTED, ++ MD_NTSTATUS_WIN_STATUS_FLT_CONTEXT_ALREADY_LINKED, ++ MD_NTSTATUS_WIN_STATUS_FLT_NO_WAITER_FOR_REPLY, ++ MD_NTSTATUS_WIN_STATUS_FLT_REGISTRATION_BUSY, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_NO_DESCRIPTOR, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_MONITOR_INVALID_MANUFACTURE_DATE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_WAS_RESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_DRIVER_MODEL, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_MODE_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_OCCLUDED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_DENIED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANNOTCOLORCONVERT, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DRIVER_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_UNOCCLUDED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_INVALID_WINDOW, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VAIL_STATE_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDEO_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_LOCK_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_BUSY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TOO_MANY_REFERENCES, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_LATER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TRY_AGAIN_NOW, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_INVALID, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_FREQUENCY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_ACTIVE_REGION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_TOTAL_REGION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_ALREADY_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_STALE_MODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_RESOURCES_NOT_RELATED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_VIDPNMGR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_ACTIVE_VIDPN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_NOT_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_STRIDE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PIXELFORMAT, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_COLORBASIS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_GAMMA_RAMP, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MODE_NOT_IN_MODESET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_CLIENT_TYPE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_COPP_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_UAB_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PVP_HFS_FAILED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_SRM, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_DATA, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MCA_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INVALID_POINTER, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_FVE_LOCKED_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_ENCRYPTED, ++ MD_NTSTATUS_WIN_STATUS_FVE_BAD_INFORMATION, ++ MD_NTSTATUS_WIN_STATUS_FVE_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_FVE_FAILED_WRONG_FS, ++ MD_NTSTATUS_WIN_STATUS_FVE_BAD_PARTITION_SIZE, ++ MD_NTSTATUS_WIN_STATUS_FVE_FS_NOT_EXTENDED, ++ MD_NTSTATUS_WIN_STATUS_FVE_FS_MOUNTED, ++ MD_NTSTATUS_WIN_STATUS_FVE_NO_LICENSE, ++ MD_NTSTATUS_WIN_STATUS_FVE_ACTION_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_FVE_BAD_DATA, ++ MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_NOT_BOUND, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_DATA_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_FVE_CONV_READ_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FVE_CONV_WRITE_ERROR, ++ MD_NTSTATUS_WIN_STATUS_FVE_OVERLAPPED_UPDATE, ++ MD_NTSTATUS_WIN_STATUS_FVE_FAILED_SECTOR_SIZE, ++ MD_NTSTATUS_WIN_STATUS_FVE_FAILED_AUTHENTICATION, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_OS_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_FVE_KEYFILE_NO_VMK, ++ MD_NTSTATUS_WIN_STATUS_FVE_TPM_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO, ++ MD_NTSTATUS_WIN_STATUS_FVE_TPM_INVALID_PCR, ++ MD_NTSTATUS_WIN_STATUS_FVE_TPM_NO_VMK, ++ MD_NTSTATUS_WIN_STATUS_FVE_PIN_INVALID, ++ MD_NTSTATUS_WIN_STATUS_FVE_AUTH_INVALID_APPLICATION, ++ MD_NTSTATUS_WIN_STATUS_FVE_AUTH_INVALID_CONFIG, ++ MD_NTSTATUS_WIN_STATUS_FVE_DEBUGGER_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_FVE_DRY_RUN_FAILED, ++ MD_NTSTATUS_WIN_STATUS_FVE_BAD_METADATA_POINTER, ++ MD_NTSTATUS_WIN_STATUS_FVE_OLD_METADATA_COPY, ++ MD_NTSTATUS_WIN_STATUS_FVE_REBOOT_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_FVE_RAW_ACCESS, ++ MD_NTSTATUS_WIN_STATUS_FVE_RAW_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY, ++ MD_NTSTATUS_WIN_STATUS_FVE_MOR_FAILED, ++ MD_NTSTATUS_WIN_STATUS_FVE_NO_FEATURE_LICENSE, ++ MD_NTSTATUS_WIN_STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_FVE_CONV_RECOVERY_FAILED, ++ MD_NTSTATUS_WIN_STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG, ++ MD_NTSTATUS_WIN_STATUS_FVE_INVALID_DATUM_TYPE, ++ MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_FVE_ENH_PIN_INVALID, ++ MD_NTSTATUS_WIN_STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE, ++ MD_NTSTATUS_WIN_STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_ON_CLUSTER, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING, ++ MD_NTSTATUS_WIN_STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE, ++ MD_NTSTATUS_WIN_STATUS_FVE_EDRIVE_DRY_RUN_FAILED, ++ MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FVE_SECUREBOOT_CONFIG_CHANGE, ++ MD_NTSTATUS_WIN_STATUS_FVE_DEVICE_LOCKEDOUT, ++ MD_NTSTATUS_WIN_STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT, ++ MD_NTSTATUS_WIN_STATUS_FVE_NOT_DE_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FVE_OSV_KSR_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_CONDITION_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_FILTER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_LAYER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_SUBLAYER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_FWP_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_FWP_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_FWP_WRONG_SESSION, ++ MD_NTSTATUS_WIN_STATUS_FWP_NO_TXN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_FWP_TXN_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_FWP_TXN_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_FWP_SESSION_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_TXN, ++ MD_NTSTATUS_WIN_STATUS_FWP_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_FWP_NET_EVENTS_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_LAYER, ++ MD_NTSTATUS_WIN_STATUS_FWP_KM_CLIENTS_ONLY, ++ MD_NTSTATUS_WIN_STATUS_FWP_LIFETIME_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_BUILTIN_OBJECT, ++ MD_NTSTATUS_WIN_STATUS_FWP_TOO_MANY_CALLOUTS, ++ MD_NTSTATUS_WIN_STATUS_FWP_NOTIFICATION_DROPPED, ++ MD_NTSTATUS_WIN_STATUS_FWP_TRAFFIC_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_SA_STATE, ++ MD_NTSTATUS_WIN_STATUS_FWP_NULL_POINTER, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_ENUMERATOR, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_FLAGS, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_NET_MASK, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_RANGE, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_INTERVAL, ++ MD_NTSTATUS_WIN_STATUS_FWP_ZERO_LENGTH_ARRAY, ++ MD_NTSTATUS_WIN_STATUS_FWP_NULL_DISPLAY_NAME, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_ACTION_TYPE, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_WEIGHT, ++ MD_NTSTATUS_WIN_STATUS_FWP_MATCH_TYPE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_TYPE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_OUT_OF_BOUNDS, ++ MD_NTSTATUS_WIN_STATUS_FWP_RESERVED, ++ MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_CONDITION, ++ MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_KEYMOD, ++ MD_NTSTATUS_WIN_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER, ++ MD_NTSTATUS_WIN_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER, ++ MD_NTSTATUS_WIN_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER, ++ MD_NTSTATUS_WIN_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_AUTH_METHOD, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_DH_GROUP, ++ MD_NTSTATUS_WIN_STATUS_FWP_EM_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_FWP_NEVER_MATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_PROVIDER_CONTEXT_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_FWP_TOO_MANY_SUBLAYERS, ++ MD_NTSTATUS_WIN_STATUS_FWP_CALLOUT_NOTIFICATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_AUTH_TRANSFORM, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_CIPHER_TRANSFORM, ++ MD_NTSTATUS_WIN_STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_TRANSFORM_COMBINATION, ++ MD_NTSTATUS_WIN_STATUS_FWP_DUPLICATE_AUTH_METHOD, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_TUNNEL_ENDPOINT, ++ MD_NTSTATUS_WIN_STATUS_FWP_L2_DRIVER_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED, ++ MD_NTSTATUS_WIN_STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL, ++ MD_NTSTATUS_WIN_STATUS_FWP_CONNECTIONS_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_FWP_INVALID_DNS_NAME, ++ MD_NTSTATUS_WIN_STATUS_FWP_STILL_ON, ++ MD_NTSTATUS_WIN_STATUS_FWP_IKEEXT_NOT_RUNNING, ++ MD_NTSTATUS_WIN_STATUS_FWP_TCPIP_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_FWP_INJECT_HANDLE_CLOSING, ++ MD_NTSTATUS_WIN_STATUS_FWP_INJECT_HANDLE_STALE, ++ MD_NTSTATUS_WIN_STATUS_FWP_CANNOT_PEND, ++ MD_NTSTATUS_WIN_STATUS_FWP_DROP_NOICMP, ++ MD_NTSTATUS_WIN_STATUS_NDIS_CLOSING, ++ MD_NTSTATUS_WIN_STATUS_NDIS_BAD_VERSION, ++ MD_NTSTATUS_WIN_STATUS_NDIS_BAD_CHARACTERISTICS, ++ MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NDIS_OPEN_FAILED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DEVICE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_FULL, ++ MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_NDIS_MULTICAST_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NDIS_REQUEST_ABORTED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_RESET_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PACKET, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_DEVICE_REQUEST, ++ MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_DATA, ++ MD_NTSTATUS_WIN_STATUS_NDIS_BUFFER_TOO_SHORT, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_OID, ++ MD_NTSTATUS_WIN_STATUS_NDIS_ADAPTER_REMOVED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_UNSUPPORTED_MEDIA, ++ MD_NTSTATUS_WIN_STATUS_NDIS_GROUP_ADDRESS_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_FILE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NDIS_ERROR_READING_FILE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_ALREADY_MAPPED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_RESOURCE_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_NDIS_MEDIA_DISCONNECTED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_ADDRESS, ++ MD_NTSTATUS_WIN_STATUS_NDIS_PAUSED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INTERFACE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_NDIS_UNSUPPORTED_REVISION, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT, ++ MD_NTSTATUS_WIN_STATUS_NDIS_INVALID_PORT_STATE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_LOW_POWER_STATE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_REINIT_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_NO_QUEUES, ++ MD_NTSTATUS_WIN_STATUS_NDIS_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_POLICY, ++ MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_OFFLOAD_PATH_REJECTED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_MEDIA_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_POWER_STATE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL, ++ MD_NTSTATUS_WIN_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_QUIC_HANDSHAKE_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_QUIC_VER_NEG_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_ERROR_MASK, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUTHFAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BADINDEX, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAILURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_CLEAR_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_TPM_DEACTIVATED, ++ MD_NTSTATUS_WIN_STATUS_TPM_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_TPM_DISABLED_CMD, ++ MD_NTSTATUS_WIN_STATUS_TPM_FAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_ORDINAL, ++ MD_NTSTATUS_WIN_STATUS_TPM_INSTALL_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_KEYHANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_KEYNOTFOUND, ++ MD_NTSTATUS_WIN_STATUS_TPM_INAPPROPRIATE_ENC, ++ MD_NTSTATUS_WIN_STATUS_TPM_MIGRATEFAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_PCR_INFO, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOSPACE, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOSRK, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOTSEALED_BLOB, ++ MD_NTSTATUS_WIN_STATUS_TPM_OWNER_SET, ++ MD_NTSTATUS_WIN_STATUS_TPM_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_TPM_SHORTRANDOM, ++ MD_NTSTATUS_WIN_STATUS_TPM_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_WRONGPCRVAL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_PARAM_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_SHA_THREAD, ++ MD_NTSTATUS_WIN_STATUS_TPM_SHA_ERROR, ++ MD_NTSTATUS_WIN_STATUS_TPM_FAILEDSELFTEST, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUTH2FAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BADTAG, ++ MD_NTSTATUS_WIN_STATUS_TPM_IOERROR, ++ MD_NTSTATUS_WIN_STATUS_TPM_ENCRYPT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_TPM_DECRYPT_ERROR, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_AUTHHANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_NO_ENDORSEMENT, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_KEYUSAGE, ++ MD_NTSTATUS_WIN_STATUS_TPM_WRONG_ENTITYTYPE, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_POSTINIT, ++ MD_NTSTATUS_WIN_STATUS_TPM_INAPPROPRIATE_SIG, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_KEY_PROPERTY, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_MIGRATION, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_SCHEME, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_DATASIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_MODE, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_PRESENCE, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_VERSION, ++ MD_NTSTATUS_WIN_STATUS_TPM_NO_WRAP_TRANSPORT, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAIL_UNSUCCESSFUL, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUDITFAIL_SUCCESSFUL, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOTRESETABLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOTLOCAL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_TYPE, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_RESOURCE, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOTFIPS, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_FAMILY, ++ MD_NTSTATUS_WIN_STATUS_TPM_NO_NV_PERMISSION, ++ MD_NTSTATUS_WIN_STATUS_TPM_REQUIRES_SIGN, ++ MD_NTSTATUS_WIN_STATUS_TPM_KEY_NOTSUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_TPM_AUTH_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_TPM_AREA_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_LOCALITY, ++ MD_NTSTATUS_WIN_STATUS_TPM_READ_ONLY, ++ MD_NTSTATUS_WIN_STATUS_TPM_PER_NOWRITE, ++ MD_NTSTATUS_WIN_STATUS_TPM_FAMILYCOUNT, ++ MD_NTSTATUS_WIN_STATUS_TPM_WRITE_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_ATTRIBUTES, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_STRUCTURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_KEY_OWNER_CONTROL, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_COUNTER, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOT_FULLWRITE, ++ MD_NTSTATUS_WIN_STATUS_TPM_CONTEXT_GAP, ++ MD_NTSTATUS_WIN_STATUS_TPM_MAXNVWRITES, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOOPERATOR, ++ MD_NTSTATUS_WIN_STATUS_TPM_RESOURCEMISSING, ++ MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_LOCK, ++ MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_FAMILY, ++ MD_NTSTATUS_WIN_STATUS_TPM_DELEGATE_ADMIN, ++ MD_NTSTATUS_WIN_STATUS_TPM_TRANSPORT_NOTEXCLUSIVE, ++ MD_NTSTATUS_WIN_STATUS_TPM_OWNER_CONTROL, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_INPUT_DATA0, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_INPUT_DATA1, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_ISSUER_SETTINGS, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_TPM_SETTINGS, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_STAGE, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_ISSUER_VALIDITY, ++ MD_NTSTATUS_WIN_STATUS_TPM_DAA_WRONG_W, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_DELEGATE, ++ MD_NTSTATUS_WIN_STATUS_TPM_BADCONTEXT, ++ MD_NTSTATUS_WIN_STATUS_TPM_TOOMANYCONTEXTS, ++ MD_NTSTATUS_WIN_STATUS_TPM_MA_TICKET_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_MA_DESTINATION, ++ MD_NTSTATUS_WIN_STATUS_TPM_MA_SOURCE, ++ MD_NTSTATUS_WIN_STATUS_TPM_MA_AUTHORITY, ++ MD_NTSTATUS_WIN_STATUS_TPM_PERMANENTEK, ++ MD_NTSTATUS_WIN_STATUS_TPM_BAD_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOCONTEXTSPACE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ASYMMETRIC, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ATTRIBUTES, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HASH, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_VALUE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HIERARCHY, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_MGF, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_MODE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TYPE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KDF, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_RANGE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_FAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NONCE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PP, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SCHEME, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SYMMETRIC, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TAG, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SELECTOR, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INSUFFICIENT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_KEY, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_FAIL, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INTEGRITY, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TICKET, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_RESERVED_BITS, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_AUTH, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY_CC, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BINDING, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_CURVE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_POINT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_INITIALIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SEQUENCE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PRIVATE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_HMAC, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_EXCLUSIVE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_ECC_CURVE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_TYPE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_MISSING, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_POLICY, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PCR_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_UPGRADE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_TOO_MANY_CONTEXTS, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_REBOOT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_UNBALANCED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_COMMAND_CODE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTHSIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_AUTH_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_RANGE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SIZE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_AUTHORIZATION, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_UNINITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_SPACE, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NV_DEFINED, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_BAD_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_CPHASH, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_PARENT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NEEDS_TEST, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_NO_RESULT, ++ MD_NTSTATUS_WIN_STATUS_TPM_20_E_SENSITIVE, ++ MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_TPM_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_DUPLICATE_VHANDLE, ++ MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_TPM_RETRY, ++ MD_NTSTATUS_WIN_STATUS_TPM_NEEDS_SELFTEST, ++ MD_NTSTATUS_WIN_STATUS_TPM_DOING_SELFTEST, ++ MD_NTSTATUS_WIN_STATUS_TPM_DEFEND_LOCK_RUNNING, ++ MD_NTSTATUS_WIN_STATUS_TPM_COMMAND_CANCELED, ++ MD_NTSTATUS_WIN_STATUS_TPM_TOO_MANY_CONTEXTS, ++ MD_NTSTATUS_WIN_STATUS_TPM_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_TPM_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_TPM_INSUFFICIENT_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_TPM_PPI_FUNCTION_UNSUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_ERROR_MASK, ++ MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_PCP_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_PCP_INVALID_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_PCP_FLAG_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_PCP_INTERNAL_ERROR, ++ MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_PCP_AUTHENTICATION_IGNORED, ++ MD_NTSTATUS_WIN_STATUS_PCP_POLICY_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PCP_PROFILE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PCP_VALIDATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_PCP_DEVICE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PCP_WRONG_PARENT, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_LOADED, ++ MD_NTSTATUS_WIN_STATUS_PCP_NO_KEY_CERTIFICATION, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_FINALIZED, ++ MD_NTSTATUS_WIN_STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET, ++ MD_NTSTATUS_WIN_STATUS_PCP_NOT_PCR_BOUND, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_ALREADY_FINALIZED, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_USAGE_POLICY_INVALID, ++ MD_NTSTATUS_WIN_STATUS_PCP_SOFT_KEY_ERROR, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AUTHENTICATED, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_AIK, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_NOT_SIGNING_KEY, ++ MD_NTSTATUS_WIN_STATUS_PCP_LOCKED_OUT, ++ MD_NTSTATUS_WIN_STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_TPM_VERSION_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_BUFFER_LENGTH_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_PCP_TICKET_MISSING, ++ MD_NTSTATUS_WIN_STATUS_PCP_RAW_POLICY_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_PCP_KEY_HANDLE_INVALIDATED, ++ MD_NTSTATUS_WIN_STATUS_RTPM_NO_RESULT, ++ MD_NTSTATUS_WIN_STATUS_RTPM_PCR_READ_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_RTPM_INVALID_CONTEXT, ++ MD_NTSTATUS_WIN_STATUS_RTPM_UNSUPPORTED_CMD, ++ MD_NTSTATUS_WIN_STATUS_TPM_ZERO_EXHAUST_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_CODE, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_HYPERCALL_INPUT, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_ALIGNMENT, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARAMETER, ++ MD_NTSTATUS_WIN_STATUS_HV_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_OPERATION_DENIED, ++ MD_NTSTATUS_WIN_STATUS_HV_UNKNOWN_PROPERTY, ++ MD_NTSTATUS_WIN_STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_HV_PARTITION_TOO_DEEP, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_PARTITION_ID, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_INDEX, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_PORT_ID, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_CONNECTION_ID, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFERS, ++ MD_NTSTATUS_WIN_STATUS_HV_NOT_ACKNOWLEDGED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_VP_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_ACKNOWLEDGED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_SAVE_RESTORE_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_SYNIC_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_OBJECT_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO, ++ MD_NTSTATUS_WIN_STATUS_HV_NO_DATA, ++ MD_NTSTATUS_WIN_STATUS_HV_INACTIVE, ++ MD_NTSTATUS_WIN_STATUS_HV_NO_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_HV_FEATURE_UNAVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_BUFFER, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS, ++ MD_NTSTATUS_WIN_STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR, ++ MD_NTSTATUS_WIN_STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR, ++ MD_NTSTATUS_WIN_STATUS_HV_PROCESSOR_STARTUP_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_HV_SMX_ENABLED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_LP_INDEX, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_REGISTER_VALUE, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_VTL_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_NX_NOT_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_ID, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_DEVICE_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_PAGE_REQUEST_INVALID, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_ID, ++ MD_NTSTATUS_WIN_STATUS_HV_INVALID_CPU_GROUP_STATE, ++ MD_NTSTATUS_WIN_STATUS_HV_OPERATION_FAILED, ++ MD_NTSTATUS_WIN_STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_ROOT_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_HV_EVENT_BUFFER_ALREADY_FREED, ++ MD_NTSTATUS_WIN_STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY, ++ MD_NTSTATUS_WIN_STATUS_HV_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_BAD_SPI, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_SA_LIFETIME_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_WRONG_SA, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_REPLAY_CHECK_FAILED, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_INVALID_PACKET, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_INTEGRITY_CHECK_FAILED, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_CLEAR_TEXT_DROP, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_AUTH_FIREWALL_DROP, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_THROTTLE_DROP, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_BLOCK, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_RECEIVED_MULTICAST, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_INVALID_PACKET, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_MAX_ENTRIES, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED, ++ MD_NTSTATUS_WIN_STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES, ++ MD_NTSTATUS_WIN_STATUS_VID_DUPLICATE_HANDLER, ++ MD_NTSTATUS_WIN_STATUS_VID_TOO_MANY_HANDLERS, ++ MD_NTSTATUS_WIN_STATUS_VID_QUEUE_FULL, ++ MD_NTSTATUS_WIN_STATUS_VID_HANDLER_NOT_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_OBJECT_NAME, ++ MD_NTSTATUS_WIN_STATUS_VID_PARTITION_NAME_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG, ++ MD_NTSTATUS_WIN_STATUS_VID_PARTITION_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_VID_PARTITION_DOES_NOT_EXIST, ++ MD_NTSTATUS_WIN_STATUS_VID_PARTITION_NAME_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS, ++ MD_NTSTATUS_WIN_STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_VID_MB_STILL_REFERENCED, ++ MD_NTSTATUS_WIN_STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_NUMA_SETTINGS, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_NUMA_NODE_INDEX, ++ MD_NTSTATUS_WIN_STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_VID_PAGE_RANGE_OVERFLOW, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_GPA_RANGE_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE, ++ MD_NTSTATUS_WIN_STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_PPM_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_VID_MBPS_ARE_LOCKED, ++ MD_NTSTATUS_WIN_STATUS_VID_MESSAGE_QUEUE_CLOSED, ++ MD_NTSTATUS_WIN_STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED, ++ MD_NTSTATUS_WIN_STATUS_VID_STOP_PENDING, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_PROCESSOR_STATE, ++ MD_NTSTATUS_WIN_STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET, ++ MD_NTSTATUS_WIN_STATUS_VID_MMIO_RANGE_DESTROYED, ++ MD_NTSTATUS_WIN_STATUS_VID_INVALID_CHILD_GPA_PAGE_SET, ++ MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED, ++ MD_NTSTATUS_WIN_STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE, ++ MD_NTSTATUS_WIN_STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT, ++ MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM, ++ MD_NTSTATUS_WIN_STATUS_VID_SAVED_STATE_INCOMPATIBLE, ++ MD_NTSTATUS_WIN_STATUS_VID_VTL_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DATABASE_FULL, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DUPLICATE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_DYNAMIC, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_ID_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAST_VOTER, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_MISSING, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_NOT_EMPTY, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_REVECTORING_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_SET_NOT_CONTAINED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_ALREADY_USED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_IN_SYNC, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_INDEX_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_MISSING, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_NOT_DETACHED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MEMBER_REGENERATING, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_ALL_DISKS_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_REGISTERED_USERS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_SUCH_USER, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NOTIFICATION_RESET, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_DUPLICATE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_ID_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_NAME_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_HAS_QUORUM, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_WITHOUT_QUORUM, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PARTITION_STYLE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PARTITION_UPDATE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_IN_SYNC, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_INDEX_DUPLICATE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_INDEX_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_LAST_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_MISSING, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_REGENERATING, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_TYPE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_RAID5, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_SIMPLE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_STRUCTURE_SIZE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_TRANSACTION_IN_PROGRESS, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_ID_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_LENGTH_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_NOT_MIRRORED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_NOT_RETAINED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_RETAINED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_BAD_BOOT_DISK, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_CONFIG_ONLINE, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NOT_PRIMARY_PACK, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_VOLUME_MIRRORED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NO_VALID_LOG_COPIES, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_PRIMARY_PACK_PRESENT, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_MIRROR_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_VOLMGR_RAID5_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_BCD_TOO_MANY_ELEMENTS, ++ MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_MISSING, ++ MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_DRIVE_FOOTER_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_VHD_FORMAT_UNKNOWN, ++ MD_NTSTATUS_WIN_STATUS_VHD_FORMAT_UNSUPPORTED_VERSION, ++ MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION, ++ MD_NTSTATUS_WIN_STATUS_VHD_SPARSE_HEADER_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_VHD_BLOCK_ALLOCATION_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_BLOCK_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VHD_BITMAP_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_PARENT_VHD_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_ID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_METADATA_READ_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_VHD_METADATA_WRITE_FAILURE, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_FILE_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VIRTDISK_PROVIDER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_VIRTDISK_NOT_VIRTUAL_DISK, ++ MD_NTSTATUS_WIN_STATUS_VHD_PARENT_VHD_ACCESS_DENIED, ++ MD_NTSTATUS_WIN_STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT, ++ MD_NTSTATUS_WIN_STATUS_VIRTUAL_DISK_LIMITATION, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_TYPE, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_STATE, ++ MD_NTSTATUS_WIN_STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ALREADY_OWNED, ++ MD_NTSTATUS_WIN_STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE, ++ MD_NTSTATUS_WIN_STATUS_CTLOG_TRACKING_NOT_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE, ++ MD_NTSTATUS_WIN_STATUS_CTLOG_VHD_CHANGED_OFFLINE, ++ MD_NTSTATUS_WIN_STATUS_CTLOG_INVALID_TRACKING_STATE, ++ MD_NTSTATUS_WIN_STATUS_CTLOG_INCONSISTENT_TRACKING_FILE, ++ MD_NTSTATUS_WIN_STATUS_VHD_METADATA_FULL, ++ MD_NTSTATUS_WIN_STATUS_VHD_INVALID_CHANGE_TRACKING_ID, ++ MD_NTSTATUS_WIN_STATUS_VHD_CHANGE_TRACKING_DISABLED, ++ MD_NTSTATUS_WIN_STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION, ++ MD_NTSTATUS_WIN_STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA, ++ MD_NTSTATUS_WIN_STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE, ++ MD_NTSTATUS_WIN_STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE, ++ MD_NTSTATUS_WIN_STATUS_RKF_KEY_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_RKF_DUPLICATE_KEY, ++ MD_NTSTATUS_WIN_STATUS_RKF_BLOB_FULL, ++ MD_NTSTATUS_WIN_STATUS_RKF_STORE_FULL, ++ MD_NTSTATUS_WIN_STATUS_RKF_FILE_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_RKF_ACTIVE_KEY, ++ MD_NTSTATUS_WIN_STATUS_RDBSS_RESTART_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_RDBSS_CONTINUE_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_RDBSS_POST_OPERATION, ++ MD_NTSTATUS_WIN_STATUS_RDBSS_RETRY_LOOKUP, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_HANDLE, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_READ_NOT_PERMITTED, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_WRITE_NOT_PERMITTED, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_PDU, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_OFFSET, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_PREPARE_QUEUE_FULL, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNLIKELY, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_INSUFFICIENT_RESOURCES, ++ MD_NTSTATUS_WIN_STATUS_BTH_ATT_UNKNOWN_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_ROLLBACK_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_INVALID_POLICY, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_SIGNED, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_FILE_REPLACED, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UNKNOWN, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_BASE_POLICY, ++ MD_NTSTATUS_WIN_STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY, ++ MD_NTSTATUS_WIN_STATUS_AUDIO_ENGINE_NODE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_HDAUDIO_EMPTY_CONNECTION_LIST, ++ MD_NTSTATUS_WIN_STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED, ++ MD_NTSTATUS_WIN_STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED, ++ MD_NTSTATUS_WIN_STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY, ++ MD_NTSTATUS_WIN_STATUS_VSM_NOT_INITIALIZED, ++ MD_NTSTATUS_WIN_STATUS_VSM_DMA_PROTECTION_NOT_IN_USE, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_BOOTFILE_NOT_VALID, ++ MD_NTSTATUS_WIN_STATUS_VOLSNAP_ACTIVATION_TIMEOUT, ++ MD_NTSTATUS_WIN_STATUS_IO_PREEMPTED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_STORED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_ERROR_NOT_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_RESERVATION_CONFLICT, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_WRONG_FILE_TYPE, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_VERSION_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_VHD_SHARED, ++ MD_NTSTATUS_WIN_STATUS_SVHDX_NO_INITIATOR, ++ MD_NTSTATUS_WIN_STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP, ++ MD_NTSTATUS_WIN_STATUS_SMB_BAD_CLUSTER_DIALECT, ++ MD_NTSTATUS_WIN_STATUS_SMB_GUEST_LOGON_BLOCKED, ++ MD_NTSTATUS_WIN_STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_RESILIENCY_TYPE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_REDUNDANCY_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_INTERLEAVE_LENGTH_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NOT_ENOUGH_DRIVES, ++ MD_NTSTATUS_WIN_STATUS_SPACES_EXTENDED_ERROR, ++ MD_NTSTATUS_WIN_STATUS_SPACES_PROVISIONING_TYPE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ALLOCATION_SIZE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENCLOSURE_AWARE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_WRITE_CACHE_SIZE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NUMBER_OF_GROUPS_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_UPDATE_COLUMN_STATE, ++ MD_NTSTATUS_WIN_STATUS_SPACES_MAP_REQUIRED, ++ MD_NTSTATUS_WIN_STATUS_SPACES_UNSUPPORTED_VERSION, ++ MD_NTSTATUS_WIN_STATUS_SPACES_CORRUPT_METADATA, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRT_FULL, ++ MD_NTSTATUS_WIN_STATUS_SPACES_INCONSISTENCY, ++ MD_NTSTATUS_WIN_STATUS_SPACES_LOG_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_SPACES_NO_REDUNDANCY, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_NOT_READY, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_SPLIT, ++ MD_NTSTATUS_WIN_STATUS_SPACES_DRIVE_LOST_DATA, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INCOMPLETE, ++ MD_NTSTATUS_WIN_STATUS_SPACES_ENTRY_INVALID, ++ MD_NTSTATUS_WIN_STATUS_SPACES_MARK_DIRTY, ++ MD_NTSTATUS_WIN_STATUS_SECCORE_INVALID_COMMAND, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_INVALID_POLICY, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES, ++ MD_NTSTATUS_WIN_STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED, ++ MD_NTSTATUS_WIN_STATUS_NO_APPLICABLE_APP_LICENSES_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_CLIP_DEVICE_LICENSE_MISSING, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_INVALID_SIGNATURE, ++ MD_NTSTATUS_WIN_STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_EXPIRED, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_NOT_SIGNED, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE, ++ MD_NTSTATUS_WIN_STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_INVALID, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_ACTIVE, ++ MD_NTSTATUS_WIN_STATUS_PLATFORM_MANIFEST_NOT_SIGNED, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_CONDITION_NOT_SATISFIED, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_HANDLE_INVALIDATED, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_GENERATION, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_INVALID_HOST_STATE, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_NO_DONOR, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_HOST_ID_MISMATCH, ++ MD_NTSTATUS_WIN_STATUS_APPEXEC_UNKNOWN_USER, ++}; ++ ++// The content of this array was created from ntstatus.h in the 10 SDK ++// (version 10.0.19041.0) with ++// ++// egrep '#define [A-Z_0-9]+\s+\(\(NTSTATUS\)0x[048C][0-9A-F]+L\)' ntstatus.h ++// | tr -d '\r' ++// | sed -r 's@#define ([A-Z_0-9]+)\s+\(\(NTSTATUS\)(0x[048C][0-9A-F]+)L\).*@\2 \1@' ++// | sort ++// | sed -r 's@(0x[048C][0-9A-F]+) ([A-Z_0-9]+)@ "\2",@' ++// ++// With easy copy to clipboard with ++// | xclip -selection c # on linux ++// | clip # on windows ++// | pbcopy # on mac ++static const char* kNTStatusStrings[] = { ++ "STATUS_SUCCESS", ++ "STATUS_WAIT_0", ++ "STATUS_WAIT_1", ++ "STATUS_WAIT_2", ++ "STATUS_WAIT_3", ++ "STATUS_WAIT_63", ++ "STATUS_ABANDONED", ++ "STATUS_ABANDONED_WAIT_0", ++ "STATUS_ABANDONED_WAIT_63", ++ "STATUS_USER_APC", ++ "STATUS_ALREADY_COMPLETE", ++ "STATUS_KERNEL_APC", ++ "STATUS_ALERTED", ++ "STATUS_TIMEOUT", ++ "STATUS_PENDING", ++ "STATUS_REPARSE", ++ "STATUS_MORE_ENTRIES", ++ "STATUS_NOT_ALL_ASSIGNED", ++ "STATUS_SOME_NOT_MAPPED", ++ "STATUS_OPLOCK_BREAK_IN_PROGRESS", ++ "STATUS_VOLUME_MOUNTED", ++ "STATUS_RXACT_COMMITTED", ++ "STATUS_NOTIFY_CLEANUP", ++ "STATUS_NOTIFY_ENUM_DIR", ++ "STATUS_NO_QUOTAS_FOR_ACCOUNT", ++ "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED", ++ "STATUS_PAGE_FAULT_TRANSITION", ++ "STATUS_PAGE_FAULT_DEMAND_ZERO", ++ "STATUS_PAGE_FAULT_COPY_ON_WRITE", ++ "STATUS_PAGE_FAULT_GUARD_PAGE", ++ "STATUS_PAGE_FAULT_PAGING_FILE", ++ "STATUS_CACHE_PAGE_LOCKED", ++ "STATUS_CRASH_DUMP", ++ "STATUS_BUFFER_ALL_ZEROS", ++ "STATUS_REPARSE_OBJECT", ++ "STATUS_RESOURCE_REQUIREMENTS_CHANGED", ++ "STATUS_TRANSLATION_COMPLETE", ++ "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY", ++ "STATUS_NOTHING_TO_TERMINATE", ++ "STATUS_PROCESS_NOT_IN_JOB", ++ "STATUS_PROCESS_IN_JOB", ++ "STATUS_VOLSNAP_HIBERNATE_READY", ++ "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY", ++ "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED", ++ "STATUS_INTERRUPT_STILL_CONNECTED", ++ "STATUS_PROCESS_CLONED", ++ "STATUS_FILE_LOCKED_WITH_ONLY_READERS", ++ "STATUS_FILE_LOCKED_WITH_WRITERS", ++ "STATUS_VALID_IMAGE_HASH", ++ "STATUS_VALID_CATALOG_HASH", ++ "STATUS_VALID_STRONG_CODE_HASH", ++ "STATUS_GHOSTED", ++ "STATUS_DATA_OVERWRITTEN", ++ "STATUS_RESOURCEMANAGER_READ_ONLY", ++ "STATUS_RING_PREVIOUSLY_EMPTY", ++ "STATUS_RING_PREVIOUSLY_FULL", ++ "STATUS_RING_PREVIOUSLY_ABOVE_QUOTA", ++ "STATUS_RING_NEWLY_EMPTY", ++ "STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT", ++ "STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE", ++ "STATUS_OPLOCK_HANDLE_CLOSED", ++ "STATUS_WAIT_FOR_OPLOCK", ++ "STATUS_REPARSE_GLOBAL", ++ "DBG_EXCEPTION_HANDLED", ++ "DBG_CONTINUE", ++ "STATUS_FLT_IO_COMPLETE", ++ "STATUS_RTPM_CONTEXT_CONTINUE", ++ "STATUS_RTPM_CONTEXT_COMPLETE", ++ "STATUS_HV_PENDING_PAGE_REQUESTS", ++ "STATUS_SPACES_REPAIRED", ++ "STATUS_SPACES_PAUSE", ++ "STATUS_SPACES_COMPLETE", ++ "STATUS_SPACES_REDIRECT", ++ "STATUS_OBJECT_NAME_EXISTS", ++ "STATUS_THREAD_WAS_SUSPENDED", ++ "STATUS_WORKING_SET_LIMIT_RANGE", ++ "STATUS_IMAGE_NOT_AT_BASE", ++ "STATUS_RXACT_STATE_CREATED", ++ "STATUS_SEGMENT_NOTIFICATION", ++ "STATUS_LOCAL_USER_SESSION_KEY", ++ "STATUS_BAD_CURRENT_DIRECTORY", ++ "STATUS_SERIAL_MORE_WRITES", ++ "STATUS_REGISTRY_RECOVERED", ++ "STATUS_FT_READ_RECOVERY_FROM_BACKUP", ++ "STATUS_FT_WRITE_RECOVERY", ++ "STATUS_SERIAL_COUNTER_TIMEOUT", ++ "STATUS_NULL_LM_PASSWORD", ++ "STATUS_IMAGE_MACHINE_TYPE_MISMATCH", ++ "STATUS_RECEIVE_PARTIAL", ++ "STATUS_RECEIVE_EXPEDITED", ++ "STATUS_RECEIVE_PARTIAL_EXPEDITED", ++ "STATUS_EVENT_DONE", ++ "STATUS_EVENT_PENDING", ++ "STATUS_CHECKING_FILE_SYSTEM", ++ "STATUS_FATAL_APP_EXIT", ++ "STATUS_PREDEFINED_HANDLE", ++ "STATUS_WAS_UNLOCKED", ++ "STATUS_SERVICE_NOTIFICATION", ++ "STATUS_WAS_LOCKED", ++ "STATUS_LOG_HARD_ERROR", ++ "STATUS_ALREADY_WIN32", ++ "STATUS_WX86_UNSIMULATE", ++ "STATUS_WX86_CONTINUE", ++ "STATUS_WX86_SINGLE_STEP", ++ "STATUS_WX86_BREAKPOINT", ++ "STATUS_WX86_EXCEPTION_CONTINUE", ++ "STATUS_WX86_EXCEPTION_LASTCHANCE", ++ "STATUS_WX86_EXCEPTION_CHAIN", ++ "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE", ++ "STATUS_NO_YIELD_PERFORMED", ++ "STATUS_TIMER_RESUME_IGNORED", ++ "STATUS_ARBITRATION_UNHANDLED", ++ "STATUS_CARDBUS_NOT_SUPPORTED", ++ "STATUS_WX86_CREATEWX86TIB", ++ "STATUS_MP_PROCESSOR_MISMATCH", ++ "STATUS_HIBERNATED", ++ "STATUS_RESUME_HIBERNATION", ++ "STATUS_FIRMWARE_UPDATED", ++ "STATUS_DRIVERS_LEAKING_LOCKED_PAGES", ++ "STATUS_MESSAGE_RETRIEVED", ++ "STATUS_SYSTEM_POWERSTATE_TRANSITION", ++ "STATUS_ALPC_CHECK_COMPLETION_LIST", ++ "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION", ++ "STATUS_ACCESS_AUDIT_BY_POLICY", ++ "STATUS_ABANDON_HIBERFILE", ++ "STATUS_BIZRULES_NOT_ENABLED", ++ "STATUS_FT_READ_FROM_COPY", ++ "STATUS_IMAGE_AT_DIFFERENT_BASE", ++ "STATUS_PATCH_DEFERRED", ++ "STATUS_WAKE_SYSTEM", ++ "STATUS_DS_SHUTTING_DOWN", ++ "STATUS_DISK_REPAIR_REDIRECTED", ++ "STATUS_SERVICES_FAILED_AUTOSTART", ++ "DBG_REPLY_LATER", ++ "DBG_UNABLE_TO_PROVIDE_HANDLE", ++ "DBG_TERMINATE_THREAD", ++ "DBG_TERMINATE_PROCESS", ++ "DBG_CONTROL_C", ++ "DBG_PRINTEXCEPTION_C", ++ "DBG_RIPEXCEPTION", ++ "DBG_CONTROL_BREAK", ++ "DBG_COMMAND_EXCEPTION", ++ "DBG_PRINTEXCEPTION_WIDE_C", ++ "RPC_NT_UUID_LOCAL_ONLY", ++ "RPC_NT_SEND_INCOMPLETE", ++ "STATUS_CTX_CDM_CONNECT", ++ "STATUS_CTX_CDM_DISCONNECT", ++ "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT", ++ "STATUS_HEURISTIC_DAMAGE_POSSIBLE", ++ "STATUS_RECOVERY_NOT_NEEDED", ++ "STATUS_RM_ALREADY_STARTED", ++ "STATUS_LOG_NO_RESTART", ++ "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST", ++ "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED", ++ "STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION", ++ "STATUS_GRAPHICS_MODE_NOT_PINNED", ++ "STATUS_GRAPHICS_NO_PREFERRED_MODE", ++ "STATUS_GRAPHICS_DATASET_IS_EMPTY", ++ "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET", ++ "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED", ++ "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS", ++ "STATUS_GRAPHICS_LEADLINK_START_DEFERRED", ++ "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY", ++ "STATUS_GRAPHICS_START_DEFERRED", ++ "STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS", ++ "STATUS_NDIS_INDICATION_REQUIRED", ++ "STATUS_PCP_UNSUPPORTED_PSS_SALT", ++ "STATUS_GUARD_PAGE_VIOLATION", ++ "STATUS_DATATYPE_MISALIGNMENT", ++ "STATUS_BREAKPOINT", ++ "STATUS_SINGLE_STEP", ++ "STATUS_BUFFER_OVERFLOW", ++ "STATUS_NO_MORE_FILES", ++ "STATUS_WAKE_SYSTEM_DEBUGGER", ++ "STATUS_HANDLES_CLOSED", ++ "STATUS_NO_INHERITANCE", ++ "STATUS_GUID_SUBSTITUTION_MADE", ++ "STATUS_PARTIAL_COPY", ++ "STATUS_DEVICE_PAPER_EMPTY", ++ "STATUS_DEVICE_POWERED_OFF", ++ "STATUS_DEVICE_OFF_LINE", ++ "STATUS_DEVICE_BUSY", ++ "STATUS_NO_MORE_EAS", ++ "STATUS_INVALID_EA_NAME", ++ "STATUS_EA_LIST_INCONSISTENT", ++ "STATUS_INVALID_EA_FLAG", ++ "STATUS_VERIFY_REQUIRED", ++ "STATUS_EXTRANEOUS_INFORMATION", ++ "STATUS_RXACT_COMMIT_NECESSARY", ++ "STATUS_NO_MORE_ENTRIES", ++ "STATUS_FILEMARK_DETECTED", ++ "STATUS_MEDIA_CHANGED", ++ "STATUS_BUS_RESET", ++ "STATUS_END_OF_MEDIA", ++ "STATUS_BEGINNING_OF_MEDIA", ++ "STATUS_MEDIA_CHECK", ++ "STATUS_SETMARK_DETECTED", ++ "STATUS_NO_DATA_DETECTED", ++ "STATUS_REDIRECTOR_HAS_OPEN_HANDLES", ++ "STATUS_SERVER_HAS_OPEN_HANDLES", ++ "STATUS_ALREADY_DISCONNECTED", ++ "STATUS_LONGJUMP", ++ "STATUS_CLEANER_CARTRIDGE_INSTALLED", ++ "STATUS_PLUGPLAY_QUERY_VETOED", ++ "STATUS_UNWIND_CONSOLIDATE", ++ "STATUS_REGISTRY_HIVE_RECOVERED", ++ "STATUS_DLL_MIGHT_BE_INSECURE", ++ "STATUS_DLL_MIGHT_BE_INCOMPATIBLE", ++ "STATUS_STOPPED_ON_SYMLINK", ++ "STATUS_CANNOT_GRANT_REQUESTED_OPLOCK", ++ "STATUS_NO_ACE_CONDITION", ++ "STATUS_DEVICE_SUPPORT_IN_PROGRESS", ++ "STATUS_DEVICE_POWER_CYCLE_REQUIRED", ++ "STATUS_NO_WORK_DONE", ++ "STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT", ++ "STATUS_DEVICE_REQUIRES_CLEANING", ++ "STATUS_DEVICE_DOOR_OPEN", ++ "STATUS_DATA_LOST_REPAIR", ++ "STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED", ++ "STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH", ++ "STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE", ++ "STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS", ++ "DBG_EXCEPTION_NOT_HANDLED", ++ "STATUS_CLUSTER_NODE_ALREADY_UP", ++ "STATUS_CLUSTER_NODE_ALREADY_DOWN", ++ "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE", ++ "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE", ++ "STATUS_CLUSTER_NODE_ALREADY_MEMBER", ++ "STATUS_COULD_NOT_RESIZE_LOG", ++ "STATUS_NO_TXF_METADATA", ++ "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN", ++ "STATUS_TXF_METADATA_ALREADY_PRESENT", ++ "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET", ++ "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED", ++ "STATUS_FLT_BUFFER_TOO_SMALL", ++ "STATUS_FVE_PARTIAL_METADATA", ++ "STATUS_FVE_TRANSIENT_STATE", ++ "STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED", ++ "STATUS_VOLMGR_INCOMPLETE_REGENERATION", ++ "STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION", ++ "STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED", ++ "STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED", ++ "STATUS_QUERY_STORAGE_ERROR", ++ "STATUS_GDI_HANDLE_LEAK", ++ "STATUS_SECUREBOOT_NOT_ENABLED", ++ "STATUS_UNSUCCESSFUL", ++ "STATUS_NOT_IMPLEMENTED", ++ "STATUS_INVALID_INFO_CLASS", ++ "STATUS_INFO_LENGTH_MISMATCH", ++ "STATUS_ACCESS_VIOLATION", ++ "STATUS_IN_PAGE_ERROR", ++ "STATUS_PAGEFILE_QUOTA", ++ "STATUS_INVALID_HANDLE", ++ "STATUS_BAD_INITIAL_STACK", ++ "STATUS_BAD_INITIAL_PC", ++ "STATUS_INVALID_CID", ++ "STATUS_TIMER_NOT_CANCELED", ++ "STATUS_INVALID_PARAMETER", ++ "STATUS_NO_SUCH_DEVICE", ++ "STATUS_NO_SUCH_FILE", ++ "STATUS_INVALID_DEVICE_REQUEST", ++ "STATUS_END_OF_FILE", ++ "STATUS_WRONG_VOLUME", ++ "STATUS_NO_MEDIA_IN_DEVICE", ++ "STATUS_UNRECOGNIZED_MEDIA", ++ "STATUS_NONEXISTENT_SECTOR", ++ "STATUS_MORE_PROCESSING_REQUIRED", ++ "STATUS_NO_MEMORY", ++ "STATUS_CONFLICTING_ADDRESSES", ++ "STATUS_NOT_MAPPED_VIEW", ++ "STATUS_UNABLE_TO_FREE_VM", ++ "STATUS_UNABLE_TO_DELETE_SECTION", ++ "STATUS_INVALID_SYSTEM_SERVICE", ++ "STATUS_ILLEGAL_INSTRUCTION", ++ "STATUS_INVALID_LOCK_SEQUENCE", ++ "STATUS_INVALID_VIEW_SIZE", ++ "STATUS_INVALID_FILE_FOR_SECTION", ++ "STATUS_ALREADY_COMMITTED", ++ "STATUS_ACCESS_DENIED", ++ "STATUS_BUFFER_TOO_SMALL", ++ "STATUS_OBJECT_TYPE_MISMATCH", ++ "STATUS_NONCONTINUABLE_EXCEPTION", ++ "STATUS_INVALID_DISPOSITION", ++ "STATUS_UNWIND", ++ "STATUS_BAD_STACK", ++ "STATUS_INVALID_UNWIND_TARGET", ++ "STATUS_NOT_LOCKED", ++ "STATUS_PARITY_ERROR", ++ "STATUS_UNABLE_TO_DECOMMIT_VM", ++ "STATUS_NOT_COMMITTED", ++ "STATUS_INVALID_PORT_ATTRIBUTES", ++ "STATUS_PORT_MESSAGE_TOO_LONG", ++ "STATUS_INVALID_PARAMETER_MIX", ++ "STATUS_INVALID_QUOTA_LOWER", ++ "STATUS_DISK_CORRUPT_ERROR", ++ "STATUS_OBJECT_NAME_INVALID", ++ "STATUS_OBJECT_NAME_NOT_FOUND", ++ "STATUS_OBJECT_NAME_COLLISION", ++ "STATUS_PORT_DO_NOT_DISTURB", ++ "STATUS_PORT_DISCONNECTED", ++ "STATUS_DEVICE_ALREADY_ATTACHED", ++ "STATUS_OBJECT_PATH_INVALID", ++ "STATUS_OBJECT_PATH_NOT_FOUND", ++ "STATUS_OBJECT_PATH_SYNTAX_BAD", ++ "STATUS_DATA_OVERRUN", ++ "STATUS_DATA_LATE_ERROR", ++ "STATUS_DATA_ERROR", ++ "STATUS_CRC_ERROR", ++ "STATUS_SECTION_TOO_BIG", ++ "STATUS_PORT_CONNECTION_REFUSED", ++ "STATUS_INVALID_PORT_HANDLE", ++ "STATUS_SHARING_VIOLATION", ++ "STATUS_QUOTA_EXCEEDED", ++ "STATUS_INVALID_PAGE_PROTECTION", ++ "STATUS_MUTANT_NOT_OWNED", ++ "STATUS_SEMAPHORE_LIMIT_EXCEEDED", ++ "STATUS_PORT_ALREADY_SET", ++ "STATUS_SECTION_NOT_IMAGE", ++ "STATUS_SUSPEND_COUNT_EXCEEDED", ++ "STATUS_THREAD_IS_TERMINATING", ++ "STATUS_BAD_WORKING_SET_LIMIT", ++ "STATUS_INCOMPATIBLE_FILE_MAP", ++ "STATUS_SECTION_PROTECTION", ++ "STATUS_EAS_NOT_SUPPORTED", ++ "STATUS_EA_TOO_LARGE", ++ "STATUS_NONEXISTENT_EA_ENTRY", ++ "STATUS_NO_EAS_ON_FILE", ++ "STATUS_EA_CORRUPT_ERROR", ++ "STATUS_FILE_LOCK_CONFLICT", ++ "STATUS_LOCK_NOT_GRANTED", ++ "STATUS_DELETE_PENDING", ++ "STATUS_CTL_FILE_NOT_SUPPORTED", ++ "STATUS_UNKNOWN_REVISION", ++ "STATUS_REVISION_MISMATCH", ++ "STATUS_INVALID_OWNER", ++ "STATUS_INVALID_PRIMARY_GROUP", ++ "STATUS_NO_IMPERSONATION_TOKEN", ++ "STATUS_CANT_DISABLE_MANDATORY", ++ "STATUS_NO_LOGON_SERVERS", ++ "STATUS_NO_SUCH_LOGON_SESSION", ++ "STATUS_NO_SUCH_PRIVILEGE", ++ "STATUS_PRIVILEGE_NOT_HELD", ++ "STATUS_INVALID_ACCOUNT_NAME", ++ "STATUS_USER_EXISTS", ++ "STATUS_NO_SUCH_USER", ++ "STATUS_GROUP_EXISTS", ++ "STATUS_NO_SUCH_GROUP", ++ "STATUS_MEMBER_IN_GROUP", ++ "STATUS_MEMBER_NOT_IN_GROUP", ++ "STATUS_LAST_ADMIN", ++ "STATUS_WRONG_PASSWORD", ++ "STATUS_ILL_FORMED_PASSWORD", ++ "STATUS_PASSWORD_RESTRICTION", ++ "STATUS_LOGON_FAILURE", ++ "STATUS_ACCOUNT_RESTRICTION", ++ "STATUS_INVALID_LOGON_HOURS", ++ "STATUS_INVALID_WORKSTATION", ++ "STATUS_PASSWORD_EXPIRED", ++ "STATUS_ACCOUNT_DISABLED", ++ "STATUS_NONE_MAPPED", ++ "STATUS_TOO_MANY_LUIDS_REQUESTED", ++ "STATUS_LUIDS_EXHAUSTED", ++ "STATUS_INVALID_SUB_AUTHORITY", ++ "STATUS_INVALID_ACL", ++ "STATUS_INVALID_SID", ++ "STATUS_INVALID_SECURITY_DESCR", ++ "STATUS_PROCEDURE_NOT_FOUND", ++ "STATUS_INVALID_IMAGE_FORMAT", ++ "STATUS_NO_TOKEN", ++ "STATUS_BAD_INHERITANCE_ACL", ++ "STATUS_RANGE_NOT_LOCKED", ++ "STATUS_DISK_FULL", ++ "STATUS_SERVER_DISABLED", ++ "STATUS_SERVER_NOT_DISABLED", ++ "STATUS_TOO_MANY_GUIDS_REQUESTED", ++ "STATUS_GUIDS_EXHAUSTED", ++ "STATUS_INVALID_ID_AUTHORITY", ++ "STATUS_AGENTS_EXHAUSTED", ++ "STATUS_INVALID_VOLUME_LABEL", ++ "STATUS_SECTION_NOT_EXTENDED", ++ "STATUS_NOT_MAPPED_DATA", ++ "STATUS_RESOURCE_DATA_NOT_FOUND", ++ "STATUS_RESOURCE_TYPE_NOT_FOUND", ++ "STATUS_RESOURCE_NAME_NOT_FOUND", ++ "STATUS_ARRAY_BOUNDS_EXCEEDED", ++ "STATUS_FLOAT_DENORMAL_OPERAND", ++ "STATUS_FLOAT_DIVIDE_BY_ZERO", ++ "STATUS_FLOAT_INEXACT_RESULT", ++ "STATUS_FLOAT_INVALID_OPERATION", ++ "STATUS_FLOAT_OVERFLOW", ++ "STATUS_FLOAT_STACK_CHECK", ++ "STATUS_FLOAT_UNDERFLOW", ++ "STATUS_INTEGER_DIVIDE_BY_ZERO", ++ "STATUS_INTEGER_OVERFLOW", ++ "STATUS_PRIVILEGED_INSTRUCTION", ++ "STATUS_TOO_MANY_PAGING_FILES", ++ "STATUS_FILE_INVALID", ++ "STATUS_ALLOTTED_SPACE_EXCEEDED", ++ "STATUS_INSUFFICIENT_RESOURCES", ++ "STATUS_DFS_EXIT_PATH_FOUND", ++ "STATUS_DEVICE_DATA_ERROR", ++ "STATUS_DEVICE_NOT_CONNECTED", ++ "STATUS_DEVICE_POWER_FAILURE", ++ "STATUS_FREE_VM_NOT_AT_BASE", ++ "STATUS_MEMORY_NOT_ALLOCATED", ++ "STATUS_WORKING_SET_QUOTA", ++ "STATUS_MEDIA_WRITE_PROTECTED", ++ "STATUS_DEVICE_NOT_READY", ++ "STATUS_INVALID_GROUP_ATTRIBUTES", ++ "STATUS_BAD_IMPERSONATION_LEVEL", ++ "STATUS_CANT_OPEN_ANONYMOUS", ++ "STATUS_BAD_VALIDATION_CLASS", ++ "STATUS_BAD_TOKEN_TYPE", ++ "STATUS_BAD_MASTER_BOOT_RECORD", ++ "STATUS_INSTRUCTION_MISALIGNMENT", ++ "STATUS_INSTANCE_NOT_AVAILABLE", ++ "STATUS_PIPE_NOT_AVAILABLE", ++ "STATUS_INVALID_PIPE_STATE", ++ "STATUS_PIPE_BUSY", ++ "STATUS_ILLEGAL_FUNCTION", ++ "STATUS_PIPE_DISCONNECTED", ++ "STATUS_PIPE_CLOSING", ++ "STATUS_PIPE_CONNECTED", ++ "STATUS_PIPE_LISTENING", ++ "STATUS_INVALID_READ_MODE", ++ "STATUS_IO_TIMEOUT", ++ "STATUS_FILE_FORCED_CLOSED", ++ "STATUS_PROFILING_NOT_STARTED", ++ "STATUS_PROFILING_NOT_STOPPED", ++ "STATUS_COULD_NOT_INTERPRET", ++ "STATUS_FILE_IS_A_DIRECTORY", ++ "STATUS_NOT_SUPPORTED", ++ "STATUS_REMOTE_NOT_LISTENING", ++ "STATUS_DUPLICATE_NAME", ++ "STATUS_BAD_NETWORK_PATH", ++ "STATUS_NETWORK_BUSY", ++ "STATUS_DEVICE_DOES_NOT_EXIST", ++ "STATUS_TOO_MANY_COMMANDS", ++ "STATUS_ADAPTER_HARDWARE_ERROR", ++ "STATUS_INVALID_NETWORK_RESPONSE", ++ "STATUS_UNEXPECTED_NETWORK_ERROR", ++ "STATUS_BAD_REMOTE_ADAPTER", ++ "STATUS_PRINT_QUEUE_FULL", ++ "STATUS_NO_SPOOL_SPACE", ++ "STATUS_PRINT_CANCELLED", ++ "STATUS_NETWORK_NAME_DELETED", ++ "STATUS_NETWORK_ACCESS_DENIED", ++ "STATUS_BAD_DEVICE_TYPE", ++ "STATUS_BAD_NETWORK_NAME", ++ "STATUS_TOO_MANY_NAMES", ++ "STATUS_TOO_MANY_SESSIONS", ++ "STATUS_SHARING_PAUSED", ++ "STATUS_REQUEST_NOT_ACCEPTED", ++ "STATUS_REDIRECTOR_PAUSED", ++ "STATUS_NET_WRITE_FAULT", ++ "STATUS_PROFILING_AT_LIMIT", ++ "STATUS_NOT_SAME_DEVICE", ++ "STATUS_FILE_RENAMED", ++ "STATUS_VIRTUAL_CIRCUIT_CLOSED", ++ "STATUS_NO_SECURITY_ON_OBJECT", ++ "STATUS_CANT_WAIT", ++ "STATUS_PIPE_EMPTY", ++ "STATUS_CANT_ACCESS_DOMAIN_INFO", ++ "STATUS_CANT_TERMINATE_SELF", ++ "STATUS_INVALID_SERVER_STATE", ++ "STATUS_INVALID_DOMAIN_STATE", ++ "STATUS_INVALID_DOMAIN_ROLE", ++ "STATUS_NO_SUCH_DOMAIN", ++ "STATUS_DOMAIN_EXISTS", ++ "STATUS_DOMAIN_LIMIT_EXCEEDED", ++ "STATUS_OPLOCK_NOT_GRANTED", ++ "STATUS_INVALID_OPLOCK_PROTOCOL", ++ "STATUS_INTERNAL_DB_CORRUPTION", ++ "STATUS_INTERNAL_ERROR", ++ "STATUS_GENERIC_NOT_MAPPED", ++ "STATUS_BAD_DESCRIPTOR_FORMAT", ++ "STATUS_INVALID_USER_BUFFER", ++ "STATUS_UNEXPECTED_IO_ERROR", ++ "STATUS_UNEXPECTED_MM_CREATE_ERR", ++ "STATUS_UNEXPECTED_MM_MAP_ERROR", ++ "STATUS_UNEXPECTED_MM_EXTEND_ERR", ++ "STATUS_NOT_LOGON_PROCESS", ++ "STATUS_LOGON_SESSION_EXISTS", ++ "STATUS_INVALID_PARAMETER_1", ++ "STATUS_INVALID_PARAMETER_2", ++ "STATUS_INVALID_PARAMETER_3", ++ "STATUS_INVALID_PARAMETER_4", ++ "STATUS_INVALID_PARAMETER_5", ++ "STATUS_INVALID_PARAMETER_6", ++ "STATUS_INVALID_PARAMETER_7", ++ "STATUS_INVALID_PARAMETER_8", ++ "STATUS_INVALID_PARAMETER_9", ++ "STATUS_INVALID_PARAMETER_10", ++ "STATUS_INVALID_PARAMETER_11", ++ "STATUS_INVALID_PARAMETER_12", ++ "STATUS_REDIRECTOR_NOT_STARTED", ++ "STATUS_REDIRECTOR_STARTED", ++ "STATUS_STACK_OVERFLOW", ++ "STATUS_NO_SUCH_PACKAGE", ++ "STATUS_BAD_FUNCTION_TABLE", ++ "STATUS_VARIABLE_NOT_FOUND", ++ "STATUS_DIRECTORY_NOT_EMPTY", ++ "STATUS_FILE_CORRUPT_ERROR", ++ "STATUS_NOT_A_DIRECTORY", ++ "STATUS_BAD_LOGON_SESSION_STATE", ++ "STATUS_LOGON_SESSION_COLLISION", ++ "STATUS_NAME_TOO_LONG", ++ "STATUS_FILES_OPEN", ++ "STATUS_CONNECTION_IN_USE", ++ "STATUS_MESSAGE_NOT_FOUND", ++ "STATUS_PROCESS_IS_TERMINATING", ++ "STATUS_INVALID_LOGON_TYPE", ++ "STATUS_NO_GUID_TRANSLATION", ++ "STATUS_CANNOT_IMPERSONATE", ++ "STATUS_IMAGE_ALREADY_LOADED", ++ "STATUS_ABIOS_NOT_PRESENT", ++ "STATUS_ABIOS_LID_NOT_EXIST", ++ "STATUS_ABIOS_LID_ALREADY_OWNED", ++ "STATUS_ABIOS_NOT_LID_OWNER", ++ "STATUS_ABIOS_INVALID_COMMAND", ++ "STATUS_ABIOS_INVALID_LID", ++ "STATUS_ABIOS_SELECTOR_NOT_AVAILABLE", ++ "STATUS_ABIOS_INVALID_SELECTOR", ++ "STATUS_NO_LDT", ++ "STATUS_INVALID_LDT_SIZE", ++ "STATUS_INVALID_LDT_OFFSET", ++ "STATUS_INVALID_LDT_DESCRIPTOR", ++ "STATUS_INVALID_IMAGE_NE_FORMAT", ++ "STATUS_RXACT_INVALID_STATE", ++ "STATUS_RXACT_COMMIT_FAILURE", ++ "STATUS_MAPPED_FILE_SIZE_ZERO", ++ "STATUS_TOO_MANY_OPENED_FILES", ++ "STATUS_CANCELLED", ++ "STATUS_CANNOT_DELETE", ++ "STATUS_INVALID_COMPUTER_NAME", ++ "STATUS_FILE_DELETED", ++ "STATUS_SPECIAL_ACCOUNT", ++ "STATUS_SPECIAL_GROUP", ++ "STATUS_SPECIAL_USER", ++ "STATUS_MEMBERS_PRIMARY_GROUP", ++ "STATUS_FILE_CLOSED", ++ "STATUS_TOO_MANY_THREADS", ++ "STATUS_THREAD_NOT_IN_PROCESS", ++ "STATUS_TOKEN_ALREADY_IN_USE", ++ "STATUS_PAGEFILE_QUOTA_EXCEEDED", ++ "STATUS_COMMITMENT_LIMIT", ++ "STATUS_INVALID_IMAGE_LE_FORMAT", ++ "STATUS_INVALID_IMAGE_NOT_MZ", ++ "STATUS_INVALID_IMAGE_PROTECT", ++ "STATUS_INVALID_IMAGE_WIN_16", ++ "STATUS_LOGON_SERVER_CONFLICT", ++ "STATUS_TIME_DIFFERENCE_AT_DC", ++ "STATUS_SYNCHRONIZATION_REQUIRED", ++ "STATUS_DLL_NOT_FOUND", ++ "STATUS_OPEN_FAILED", ++ "STATUS_IO_PRIVILEGE_FAILED", ++ "STATUS_ORDINAL_NOT_FOUND", ++ "STATUS_ENTRYPOINT_NOT_FOUND", ++ "STATUS_CONTROL_C_EXIT", ++ "STATUS_LOCAL_DISCONNECT", ++ "STATUS_REMOTE_DISCONNECT", ++ "STATUS_REMOTE_RESOURCES", ++ "STATUS_LINK_FAILED", ++ "STATUS_LINK_TIMEOUT", ++ "STATUS_INVALID_CONNECTION", ++ "STATUS_INVALID_ADDRESS", ++ "STATUS_DLL_INIT_FAILED", ++ "STATUS_MISSING_SYSTEMFILE", ++ "STATUS_UNHANDLED_EXCEPTION", ++ "STATUS_APP_INIT_FAILURE", ++ "STATUS_PAGEFILE_CREATE_FAILED", ++ "STATUS_NO_PAGEFILE", ++ "STATUS_INVALID_LEVEL", ++ "STATUS_WRONG_PASSWORD_CORE", ++ "STATUS_ILLEGAL_FLOAT_CONTEXT", ++ "STATUS_PIPE_BROKEN", ++ "STATUS_REGISTRY_CORRUPT", ++ "STATUS_REGISTRY_IO_FAILED", ++ "STATUS_NO_EVENT_PAIR", ++ "STATUS_UNRECOGNIZED_VOLUME", ++ "STATUS_SERIAL_NO_DEVICE_INITED", ++ "STATUS_NO_SUCH_ALIAS", ++ "STATUS_MEMBER_NOT_IN_ALIAS", ++ "STATUS_MEMBER_IN_ALIAS", ++ "STATUS_ALIAS_EXISTS", ++ "STATUS_LOGON_NOT_GRANTED", ++ "STATUS_TOO_MANY_SECRETS", ++ "STATUS_SECRET_TOO_LONG", ++ "STATUS_INTERNAL_DB_ERROR", ++ "STATUS_FULLSCREEN_MODE", ++ "STATUS_TOO_MANY_CONTEXT_IDS", ++ "STATUS_LOGON_TYPE_NOT_GRANTED", ++ "STATUS_NOT_REGISTRY_FILE", ++ "STATUS_NT_CROSS_ENCRYPTION_REQUIRED", ++ "STATUS_DOMAIN_CTRLR_CONFIG_ERROR", ++ "STATUS_FT_MISSING_MEMBER", ++ "STATUS_ILL_FORMED_SERVICE_ENTRY", ++ "STATUS_ILLEGAL_CHARACTER", ++ "STATUS_UNMAPPABLE_CHARACTER", ++ "STATUS_UNDEFINED_CHARACTER", ++ "STATUS_FLOPPY_VOLUME", ++ "STATUS_FLOPPY_ID_MARK_NOT_FOUND", ++ "STATUS_FLOPPY_WRONG_CYLINDER", ++ "STATUS_FLOPPY_UNKNOWN_ERROR", ++ "STATUS_FLOPPY_BAD_REGISTERS", ++ "STATUS_DISK_RECALIBRATE_FAILED", ++ "STATUS_DISK_OPERATION_FAILED", ++ "STATUS_DISK_RESET_FAILED", ++ "STATUS_SHARED_IRQ_BUSY", ++ "STATUS_FT_ORPHANING", ++ "STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT", ++ "STATUS_PARTITION_FAILURE", ++ "STATUS_INVALID_BLOCK_LENGTH", ++ "STATUS_DEVICE_NOT_PARTITIONED", ++ "STATUS_UNABLE_TO_LOCK_MEDIA", ++ "STATUS_UNABLE_TO_UNLOAD_MEDIA", ++ "STATUS_EOM_OVERFLOW", ++ "STATUS_NO_MEDIA", ++ "STATUS_NO_SUCH_MEMBER", ++ "STATUS_INVALID_MEMBER", ++ "STATUS_KEY_DELETED", ++ "STATUS_NO_LOG_SPACE", ++ "STATUS_TOO_MANY_SIDS", ++ "STATUS_LM_CROSS_ENCRYPTION_REQUIRED", ++ "STATUS_KEY_HAS_CHILDREN", ++ "STATUS_CHILD_MUST_BE_VOLATILE", ++ "STATUS_DEVICE_CONFIGURATION_ERROR", ++ "STATUS_DRIVER_INTERNAL_ERROR", ++ "STATUS_INVALID_DEVICE_STATE", ++ "STATUS_IO_DEVICE_ERROR", ++ "STATUS_DEVICE_PROTOCOL_ERROR", ++ "STATUS_BACKUP_CONTROLLER", ++ "STATUS_LOG_FILE_FULL", ++ "STATUS_TOO_LATE", ++ "STATUS_NO_TRUST_LSA_SECRET", ++ "STATUS_NO_TRUST_SAM_ACCOUNT", ++ "STATUS_TRUSTED_DOMAIN_FAILURE", ++ "STATUS_TRUSTED_RELATIONSHIP_FAILURE", ++ "STATUS_EVENTLOG_FILE_CORRUPT", ++ "STATUS_EVENTLOG_CANT_START", ++ "STATUS_TRUST_FAILURE", ++ "STATUS_MUTANT_LIMIT_EXCEEDED", ++ "STATUS_NETLOGON_NOT_STARTED", ++ "STATUS_ACCOUNT_EXPIRED", ++ "STATUS_POSSIBLE_DEADLOCK", ++ "STATUS_NETWORK_CREDENTIAL_CONFLICT", ++ "STATUS_REMOTE_SESSION_LIMIT", ++ "STATUS_EVENTLOG_FILE_CHANGED", ++ "STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT", ++ "STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT", ++ "STATUS_NOLOGON_SERVER_TRUST_ACCOUNT", ++ "STATUS_DOMAIN_TRUST_INCONSISTENT", ++ "STATUS_FS_DRIVER_REQUIRED", ++ "STATUS_IMAGE_ALREADY_LOADED_AS_DLL", ++ "STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING", ++ "STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME", ++ "STATUS_SECURITY_STREAM_IS_INCONSISTENT", ++ "STATUS_INVALID_LOCK_RANGE", ++ "STATUS_INVALID_ACE_CONDITION", ++ "STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT", ++ "STATUS_NOTIFICATION_GUID_ALREADY_DEFINED", ++ "STATUS_INVALID_EXCEPTION_HANDLER", ++ "STATUS_DUPLICATE_PRIVILEGES", ++ "STATUS_NOT_ALLOWED_ON_SYSTEM_FILE", ++ "STATUS_REPAIR_NEEDED", ++ "STATUS_QUOTA_NOT_ENABLED", ++ "STATUS_NO_APPLICATION_PACKAGE", ++ "STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS", ++ "STATUS_NOT_SAME_OBJECT", ++ "STATUS_FATAL_MEMORY_EXHAUSTION", ++ "STATUS_ERROR_PROCESS_NOT_IN_JOB", ++ "STATUS_CPU_SET_INVALID", ++ "STATUS_IO_DEVICE_INVALID_DATA", ++ "STATUS_IO_UNALIGNED_WRITE", ++ "STATUS_CONTROL_STACK_VIOLATION", ++ "STATUS_NETWORK_OPEN_RESTRICTION", ++ "STATUS_NO_USER_SESSION_KEY", ++ "STATUS_USER_SESSION_DELETED", ++ "STATUS_RESOURCE_LANG_NOT_FOUND", ++ "STATUS_INSUFF_SERVER_RESOURCES", ++ "STATUS_INVALID_BUFFER_SIZE", ++ "STATUS_INVALID_ADDRESS_COMPONENT", ++ "STATUS_INVALID_ADDRESS_WILDCARD", ++ "STATUS_TOO_MANY_ADDRESSES", ++ "STATUS_ADDRESS_ALREADY_EXISTS", ++ "STATUS_ADDRESS_CLOSED", ++ "STATUS_CONNECTION_DISCONNECTED", ++ "STATUS_CONNECTION_RESET", ++ "STATUS_TOO_MANY_NODES", ++ "STATUS_TRANSACTION_ABORTED", ++ "STATUS_TRANSACTION_TIMED_OUT", ++ "STATUS_TRANSACTION_NO_RELEASE", ++ "STATUS_TRANSACTION_NO_MATCH", ++ "STATUS_TRANSACTION_RESPONDED", ++ "STATUS_TRANSACTION_INVALID_ID", ++ "STATUS_TRANSACTION_INVALID_TYPE", ++ "STATUS_NOT_SERVER_SESSION", ++ "STATUS_NOT_CLIENT_SESSION", ++ "STATUS_CANNOT_LOAD_REGISTRY_FILE", ++ "STATUS_DEBUG_ATTACH_FAILED", ++ "STATUS_SYSTEM_PROCESS_TERMINATED", ++ "STATUS_DATA_NOT_ACCEPTED", ++ "STATUS_NO_BROWSER_SERVERS_FOUND", ++ "STATUS_VDM_HARD_ERROR", ++ "STATUS_DRIVER_CANCEL_TIMEOUT", ++ "STATUS_REPLY_MESSAGE_MISMATCH", ++ "STATUS_MAPPED_ALIGNMENT", ++ "STATUS_IMAGE_CHECKSUM_MISMATCH", ++ "STATUS_LOST_WRITEBEHIND_DATA", ++ "STATUS_CLIENT_SERVER_PARAMETERS_INVALID", ++ "STATUS_PASSWORD_MUST_CHANGE", ++ "STATUS_NOT_FOUND", ++ "STATUS_NOT_TINY_STREAM", ++ "STATUS_RECOVERY_FAILURE", ++ "STATUS_STACK_OVERFLOW_READ", ++ "STATUS_FAIL_CHECK", ++ "STATUS_DUPLICATE_OBJECTID", ++ "STATUS_OBJECTID_EXISTS", ++ "STATUS_CONVERT_TO_LARGE", ++ "STATUS_RETRY", ++ "STATUS_FOUND_OUT_OF_SCOPE", ++ "STATUS_ALLOCATE_BUCKET", ++ "STATUS_PROPSET_NOT_FOUND", ++ "STATUS_MARSHALL_OVERFLOW", ++ "STATUS_INVALID_VARIANT", ++ "STATUS_DOMAIN_CONTROLLER_NOT_FOUND", ++ "STATUS_ACCOUNT_LOCKED_OUT", ++ "STATUS_HANDLE_NOT_CLOSABLE", ++ "STATUS_CONNECTION_REFUSED", ++ "STATUS_GRACEFUL_DISCONNECT", ++ "STATUS_ADDRESS_ALREADY_ASSOCIATED", ++ "STATUS_ADDRESS_NOT_ASSOCIATED", ++ "STATUS_CONNECTION_INVALID", ++ "STATUS_CONNECTION_ACTIVE", ++ "STATUS_NETWORK_UNREACHABLE", ++ "STATUS_HOST_UNREACHABLE", ++ "STATUS_PROTOCOL_UNREACHABLE", ++ "STATUS_PORT_UNREACHABLE", ++ "STATUS_REQUEST_ABORTED", ++ "STATUS_CONNECTION_ABORTED", ++ "STATUS_BAD_COMPRESSION_BUFFER", ++ "STATUS_USER_MAPPED_FILE", ++ "STATUS_AUDIT_FAILED", ++ "STATUS_TIMER_RESOLUTION_NOT_SET", ++ "STATUS_CONNECTION_COUNT_LIMIT", ++ "STATUS_LOGIN_TIME_RESTRICTION", ++ "STATUS_LOGIN_WKSTA_RESTRICTION", ++ "STATUS_IMAGE_MP_UP_MISMATCH", ++ "STATUS_INSUFFICIENT_LOGON_INFO", ++ "STATUS_BAD_DLL_ENTRYPOINT", ++ "STATUS_BAD_SERVICE_ENTRYPOINT", ++ "STATUS_LPC_REPLY_LOST", ++ "STATUS_IP_ADDRESS_CONFLICT1", ++ "STATUS_IP_ADDRESS_CONFLICT2", ++ "STATUS_REGISTRY_QUOTA_LIMIT", ++ "STATUS_PATH_NOT_COVERED", ++ "STATUS_NO_CALLBACK_ACTIVE", ++ "STATUS_LICENSE_QUOTA_EXCEEDED", ++ "STATUS_PWD_TOO_SHORT", ++ "STATUS_PWD_TOO_RECENT", ++ "STATUS_PWD_HISTORY_CONFLICT", ++ "STATUS_PLUGPLAY_NO_DEVICE", ++ "STATUS_UNSUPPORTED_COMPRESSION", ++ "STATUS_INVALID_HW_PROFILE", ++ "STATUS_INVALID_PLUGPLAY_DEVICE_PATH", ++ "STATUS_DRIVER_ORDINAL_NOT_FOUND", ++ "STATUS_DRIVER_ENTRYPOINT_NOT_FOUND", ++ "STATUS_RESOURCE_NOT_OWNED", ++ "STATUS_TOO_MANY_LINKS", ++ "STATUS_QUOTA_LIST_INCONSISTENT", ++ "STATUS_FILE_IS_OFFLINE", ++ "STATUS_EVALUATION_EXPIRATION", ++ "STATUS_ILLEGAL_DLL_RELOCATION", ++ "STATUS_LICENSE_VIOLATION", ++ "STATUS_DLL_INIT_FAILED_LOGOFF", ++ "STATUS_DRIVER_UNABLE_TO_LOAD", ++ "STATUS_DFS_UNAVAILABLE", ++ "STATUS_VOLUME_DISMOUNTED", ++ "STATUS_WX86_INTERNAL_ERROR", ++ "STATUS_WX86_FLOAT_STACK_CHECK", ++ "STATUS_VALIDATE_CONTINUE", ++ "STATUS_NO_MATCH", ++ "STATUS_NO_MORE_MATCHES", ++ "STATUS_NOT_A_REPARSE_POINT", ++ "STATUS_IO_REPARSE_TAG_INVALID", ++ "STATUS_IO_REPARSE_TAG_MISMATCH", ++ "STATUS_IO_REPARSE_DATA_INVALID", ++ "STATUS_IO_REPARSE_TAG_NOT_HANDLED", ++ "STATUS_PWD_TOO_LONG", ++ "STATUS_STOWED_EXCEPTION", ++ "STATUS_CONTEXT_STOWED_EXCEPTION", ++ "STATUS_REPARSE_POINT_NOT_RESOLVED", ++ "STATUS_DIRECTORY_IS_A_REPARSE_POINT", ++ "STATUS_RANGE_LIST_CONFLICT", ++ "STATUS_SOURCE_ELEMENT_EMPTY", ++ "STATUS_DESTINATION_ELEMENT_FULL", ++ "STATUS_ILLEGAL_ELEMENT_ADDRESS", ++ "STATUS_MAGAZINE_NOT_PRESENT", ++ "STATUS_REINITIALIZATION_NEEDED", ++ "STATUS_ENCRYPTION_FAILED", ++ "STATUS_DECRYPTION_FAILED", ++ "STATUS_RANGE_NOT_FOUND", ++ "STATUS_NO_RECOVERY_POLICY", ++ "STATUS_NO_EFS", ++ "STATUS_WRONG_EFS", ++ "STATUS_NO_USER_KEYS", ++ "STATUS_FILE_NOT_ENCRYPTED", ++ "STATUS_NOT_EXPORT_FORMAT", ++ "STATUS_FILE_ENCRYPTED", ++ "STATUS_WMI_GUID_NOT_FOUND", ++ "STATUS_WMI_INSTANCE_NOT_FOUND", ++ "STATUS_WMI_ITEMID_NOT_FOUND", ++ "STATUS_WMI_TRY_AGAIN", ++ "STATUS_SHARED_POLICY", ++ "STATUS_POLICY_OBJECT_NOT_FOUND", ++ "STATUS_POLICY_ONLY_IN_DS", ++ "STATUS_VOLUME_NOT_UPGRADED", ++ "STATUS_REMOTE_STORAGE_NOT_ACTIVE", ++ "STATUS_REMOTE_STORAGE_MEDIA_ERROR", ++ "STATUS_NO_TRACKING_SERVICE", ++ "STATUS_SERVER_SID_MISMATCH", ++ "STATUS_DS_NO_ATTRIBUTE_OR_VALUE", ++ "STATUS_DS_INVALID_ATTRIBUTE_SYNTAX", ++ "STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED", ++ "STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS", ++ "STATUS_DS_BUSY", ++ "STATUS_DS_UNAVAILABLE", ++ "STATUS_DS_NO_RIDS_ALLOCATED", ++ "STATUS_DS_NO_MORE_RIDS", ++ "STATUS_DS_INCORRECT_ROLE_OWNER", ++ "STATUS_DS_RIDMGR_INIT_ERROR", ++ "STATUS_DS_OBJ_CLASS_VIOLATION", ++ "STATUS_DS_CANT_ON_NON_LEAF", ++ "STATUS_DS_CANT_ON_RDN", ++ "STATUS_DS_CANT_MOD_OBJ_CLASS", ++ "STATUS_DS_CROSS_DOM_MOVE_FAILED", ++ "STATUS_DS_GC_NOT_AVAILABLE", ++ "STATUS_DIRECTORY_SERVICE_REQUIRED", ++ "STATUS_REPARSE_ATTRIBUTE_CONFLICT", ++ "STATUS_CANT_ENABLE_DENY_ONLY", ++ "STATUS_FLOAT_MULTIPLE_FAULTS", ++ "STATUS_FLOAT_MULTIPLE_TRAPS", ++ "STATUS_DEVICE_REMOVED", ++ "STATUS_JOURNAL_DELETE_IN_PROGRESS", ++ "STATUS_JOURNAL_NOT_ACTIVE", ++ "STATUS_NOINTERFACE", ++ "STATUS_DS_RIDMGR_DISABLED", ++ "STATUS_DS_ADMIN_LIMIT_EXCEEDED", ++ "STATUS_DRIVER_FAILED_SLEEP", ++ "STATUS_MUTUAL_AUTHENTICATION_FAILED", ++ "STATUS_CORRUPT_SYSTEM_FILE", ++ "STATUS_DATATYPE_MISALIGNMENT_ERROR", ++ "STATUS_WMI_READ_ONLY", ++ "STATUS_WMI_SET_FAILURE", ++ "STATUS_COMMITMENT_MINIMUM", ++ "STATUS_REG_NAT_CONSUMPTION", ++ "STATUS_TRANSPORT_FULL", ++ "STATUS_DS_SAM_INIT_FAILURE", ++ "STATUS_ONLY_IF_CONNECTED", ++ "STATUS_DS_SENSITIVE_GROUP_VIOLATION", ++ "STATUS_PNP_RESTART_ENUMERATION", ++ "STATUS_JOURNAL_ENTRY_DELETED", ++ "STATUS_DS_CANT_MOD_PRIMARYGROUPID", ++ "STATUS_SYSTEM_IMAGE_BAD_SIGNATURE", ++ "STATUS_PNP_REBOOT_REQUIRED", ++ "STATUS_POWER_STATE_INVALID", ++ "STATUS_DS_INVALID_GROUP_TYPE", ++ "STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN", ++ "STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN", ++ "STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER", ++ "STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER", ++ "STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER", ++ "STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER", ++ "STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER", ++ "STATUS_DS_HAVE_PRIMARY_MEMBERS", ++ "STATUS_WMI_NOT_SUPPORTED", ++ "STATUS_INSUFFICIENT_POWER", ++ "STATUS_SAM_NEED_BOOTKEY_PASSWORD", ++ "STATUS_SAM_NEED_BOOTKEY_FLOPPY", ++ "STATUS_DS_CANT_START", ++ "STATUS_DS_INIT_FAILURE", ++ "STATUS_SAM_INIT_FAILURE", ++ "STATUS_DS_GC_REQUIRED", ++ "STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY", ++ "STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS", ++ "STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED", ++ "STATUS_MULTIPLE_FAULT_VIOLATION", ++ "STATUS_CURRENT_DOMAIN_NOT_ALLOWED", ++ "STATUS_CANNOT_MAKE", ++ "STATUS_SYSTEM_SHUTDOWN", ++ "STATUS_DS_INIT_FAILURE_CONSOLE", ++ "STATUS_DS_SAM_INIT_FAILURE_CONSOLE", ++ "STATUS_UNFINISHED_CONTEXT_DELETED", ++ "STATUS_NO_TGT_REPLY", ++ "STATUS_OBJECTID_NOT_FOUND", ++ "STATUS_NO_IP_ADDRESSES", ++ "STATUS_WRONG_CREDENTIAL_HANDLE", ++ "STATUS_CRYPTO_SYSTEM_INVALID", ++ "STATUS_MAX_REFERRALS_EXCEEDED", ++ "STATUS_MUST_BE_KDC", ++ "STATUS_STRONG_CRYPTO_NOT_SUPPORTED", ++ "STATUS_TOO_MANY_PRINCIPALS", ++ "STATUS_NO_PA_DATA", ++ "STATUS_PKINIT_NAME_MISMATCH", ++ "STATUS_SMARTCARD_LOGON_REQUIRED", ++ "STATUS_KDC_INVALID_REQUEST", ++ "STATUS_KDC_UNABLE_TO_REFER", ++ "STATUS_KDC_UNKNOWN_ETYPE", ++ "STATUS_SHUTDOWN_IN_PROGRESS", ++ "STATUS_SERVER_SHUTDOWN_IN_PROGRESS", ++ "STATUS_NOT_SUPPORTED_ON_SBS", ++ "STATUS_WMI_GUID_DISCONNECTED", ++ "STATUS_WMI_ALREADY_DISABLED", ++ "STATUS_WMI_ALREADY_ENABLED", ++ "STATUS_MFT_TOO_FRAGMENTED", ++ "STATUS_COPY_PROTECTION_FAILURE", ++ "STATUS_CSS_AUTHENTICATION_FAILURE", ++ "STATUS_CSS_KEY_NOT_PRESENT", ++ "STATUS_CSS_KEY_NOT_ESTABLISHED", ++ "STATUS_CSS_SCRAMBLED_SECTOR", ++ "STATUS_CSS_REGION_MISMATCH", ++ "STATUS_CSS_RESETS_EXHAUSTED", ++ "STATUS_PASSWORD_CHANGE_REQUIRED", ++ "STATUS_LOST_MODE_LOGON_RESTRICTION", ++ "STATUS_PKINIT_FAILURE", ++ "STATUS_SMARTCARD_SUBSYSTEM_FAILURE", ++ "STATUS_NO_KERB_KEY", ++ "STATUS_HOST_DOWN", ++ "STATUS_UNSUPPORTED_PREAUTH", ++ "STATUS_EFS_ALG_BLOB_TOO_BIG", ++ "STATUS_PORT_NOT_SET", ++ "STATUS_DEBUGGER_INACTIVE", ++ "STATUS_DS_VERSION_CHECK_FAILURE", ++ "STATUS_AUDITING_DISABLED", ++ "STATUS_PRENT4_MACHINE_ACCOUNT", ++ "STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER", ++ "STATUS_INVALID_IMAGE_WIN_32", ++ "STATUS_INVALID_IMAGE_WIN_64", ++ "STATUS_BAD_BINDINGS", ++ "STATUS_NETWORK_SESSION_EXPIRED", ++ "STATUS_APPHELP_BLOCK", ++ "STATUS_ALL_SIDS_FILTERED", ++ "STATUS_NOT_SAFE_MODE_DRIVER", ++ "STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT", ++ "STATUS_ACCESS_DISABLED_BY_POLICY_PATH", ++ "STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER", ++ "STATUS_ACCESS_DISABLED_BY_POLICY_OTHER", ++ "STATUS_FAILED_DRIVER_ENTRY", ++ "STATUS_DEVICE_ENUMERATION_ERROR", ++ "STATUS_MOUNT_POINT_NOT_RESOLVED", ++ "STATUS_INVALID_DEVICE_OBJECT_PARAMETER", ++ "STATUS_MCA_OCCURED", ++ "STATUS_DRIVER_BLOCKED_CRITICAL", ++ "STATUS_DRIVER_BLOCKED", ++ "STATUS_DRIVER_DATABASE_ERROR", ++ "STATUS_SYSTEM_HIVE_TOO_LARGE", ++ "STATUS_INVALID_IMPORT_OF_NON_DLL", ++ "STATUS_NO_SECRETS", ++ "STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY", ++ "STATUS_FAILED_STACK_SWITCH", ++ "STATUS_HEAP_CORRUPTION", ++ "STATUS_SMARTCARD_WRONG_PIN", ++ "STATUS_SMARTCARD_CARD_BLOCKED", ++ "STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED", ++ "STATUS_SMARTCARD_NO_CARD", ++ "STATUS_SMARTCARD_NO_KEY_CONTAINER", ++ "STATUS_SMARTCARD_NO_CERTIFICATE", ++ "STATUS_SMARTCARD_NO_KEYSET", ++ "STATUS_SMARTCARD_IO_ERROR", ++ "STATUS_DOWNGRADE_DETECTED", ++ "STATUS_SMARTCARD_CERT_REVOKED", ++ "STATUS_ISSUING_CA_UNTRUSTED", ++ "STATUS_REVOCATION_OFFLINE_C", ++ "STATUS_PKINIT_CLIENT_FAILURE", ++ "STATUS_SMARTCARD_CERT_EXPIRED", ++ "STATUS_DRIVER_FAILED_PRIOR_UNLOAD", ++ "STATUS_SMARTCARD_SILENT_CONTEXT", ++ "STATUS_PER_USER_TRUST_QUOTA_EXCEEDED", ++ "STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED", ++ "STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED", ++ "STATUS_DS_NAME_NOT_UNIQUE", ++ "STATUS_DS_DUPLICATE_ID_FOUND", ++ "STATUS_DS_GROUP_CONVERSION_ERROR", ++ "STATUS_VOLSNAP_PREPARE_HIBERNATE", ++ "STATUS_USER2USER_REQUIRED", ++ "STATUS_STACK_BUFFER_OVERRUN", ++ "STATUS_NO_S4U_PROT_SUPPORT", ++ "STATUS_CROSSREALM_DELEGATION_FAILURE", ++ "STATUS_REVOCATION_OFFLINE_KDC", ++ "STATUS_ISSUING_CA_UNTRUSTED_KDC", ++ "STATUS_KDC_CERT_EXPIRED", ++ "STATUS_KDC_CERT_REVOKED", ++ "STATUS_PARAMETER_QUOTA_EXCEEDED", ++ "STATUS_HIBERNATION_FAILURE", ++ "STATUS_DELAY_LOAD_FAILED", ++ "STATUS_AUTHENTICATION_FIREWALL_FAILED", ++ "STATUS_VDM_DISALLOWED", ++ "STATUS_HUNG_DISPLAY_DRIVER_THREAD", ++ "STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE", ++ "STATUS_INVALID_CRUNTIME_PARAMETER", ++ "STATUS_NTLM_BLOCKED", ++ "STATUS_DS_SRC_SID_EXISTS_IN_FOREST", ++ "STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST", ++ "STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST", ++ "STATUS_INVALID_USER_PRINCIPAL_NAME", ++ "STATUS_FATAL_USER_CALLBACK_EXCEPTION", ++ "STATUS_ASSERTION_FAILURE", ++ "STATUS_VERIFIER_STOP", ++ "STATUS_CALLBACK_POP_STACK", ++ "STATUS_INCOMPATIBLE_DRIVER_BLOCKED", ++ "STATUS_HIVE_UNLOADED", ++ "STATUS_COMPRESSION_DISABLED", ++ "STATUS_FILE_SYSTEM_LIMITATION", ++ "STATUS_INVALID_IMAGE_HASH", ++ "STATUS_NOT_CAPABLE", ++ "STATUS_REQUEST_OUT_OF_SEQUENCE", ++ "STATUS_IMPLEMENTATION_LIMIT", ++ "STATUS_ELEVATION_REQUIRED", ++ "STATUS_NO_SECURITY_CONTEXT", ++ "STATUS_PKU2U_CERT_FAILURE", ++ "STATUS_BEYOND_VDL", ++ "STATUS_ENCOUNTERED_WRITE_IN_PROGRESS", ++ "STATUS_PTE_CHANGED", ++ "STATUS_PURGE_FAILED", ++ "STATUS_CRED_REQUIRES_CONFIRMATION", ++ "STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE", ++ "STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER", ++ "STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE", ++ "STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE", ++ "STATUS_CS_ENCRYPTION_FILE_NOT_CSE", ++ "STATUS_INVALID_LABEL", ++ "STATUS_DRIVER_PROCESS_TERMINATED", ++ "STATUS_AMBIGUOUS_SYSTEM_DEVICE", ++ "STATUS_SYSTEM_DEVICE_NOT_FOUND", ++ "STATUS_RESTART_BOOT_APPLICATION", ++ "STATUS_INSUFFICIENT_NVRAM_RESOURCES", ++ "STATUS_INVALID_SESSION", ++ "STATUS_THREAD_ALREADY_IN_SESSION", ++ "STATUS_THREAD_NOT_IN_SESSION", ++ "STATUS_INVALID_WEIGHT", ++ "STATUS_REQUEST_PAUSED", ++ "STATUS_NO_RANGES_PROCESSED", ++ "STATUS_DISK_RESOURCES_EXHAUSTED", ++ "STATUS_NEEDS_REMEDIATION", ++ "STATUS_DEVICE_FEATURE_NOT_SUPPORTED", ++ "STATUS_DEVICE_UNREACHABLE", ++ "STATUS_INVALID_TOKEN", ++ "STATUS_SERVER_UNAVAILABLE", ++ "STATUS_FILE_NOT_AVAILABLE", ++ "STATUS_DEVICE_INSUFFICIENT_RESOURCES", ++ "STATUS_PACKAGE_UPDATING", ++ "STATUS_NOT_READ_FROM_COPY", ++ "STATUS_FT_WRITE_FAILURE", ++ "STATUS_FT_DI_SCAN_REQUIRED", ++ "STATUS_OBJECT_NOT_EXTERNALLY_BACKED", ++ "STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN", ++ "STATUS_COMPRESSION_NOT_BENEFICIAL", ++ "STATUS_DATA_CHECKSUM_ERROR", ++ "STATUS_INTERMIXED_KERNEL_EA_OPERATION", ++ "STATUS_TRIM_READ_ZERO_NOT_SUPPORTED", ++ "STATUS_TOO_MANY_SEGMENT_DESCRIPTORS", ++ "STATUS_INVALID_OFFSET_ALIGNMENT", ++ "STATUS_INVALID_FIELD_IN_PARAMETER_LIST", ++ "STATUS_OPERATION_IN_PROGRESS", ++ "STATUS_INVALID_INITIATOR_TARGET_PATH", ++ "STATUS_SCRUB_DATA_DISABLED", ++ "STATUS_NOT_REDUNDANT_STORAGE", ++ "STATUS_RESIDENT_FILE_NOT_SUPPORTED", ++ "STATUS_COMPRESSED_FILE_NOT_SUPPORTED", ++ "STATUS_DIRECTORY_NOT_SUPPORTED", ++ "STATUS_IO_OPERATION_TIMEOUT", ++ "STATUS_SYSTEM_NEEDS_REMEDIATION", ++ "STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN", ++ "STATUS_SHARE_UNAVAILABLE", ++ "STATUS_APISET_NOT_HOSTED", ++ "STATUS_APISET_NOT_PRESENT", ++ "STATUS_DEVICE_HARDWARE_ERROR", ++ "STATUS_FIRMWARE_SLOT_INVALID", ++ "STATUS_FIRMWARE_IMAGE_INVALID", ++ "STATUS_STORAGE_TOPOLOGY_ID_MISMATCH", ++ "STATUS_WIM_NOT_BOOTABLE", ++ "STATUS_BLOCKED_BY_PARENTAL_CONTROLS", ++ "STATUS_NEEDS_REGISTRATION", ++ "STATUS_QUOTA_ACTIVITY", ++ "STATUS_CALLBACK_INVOKE_INLINE", ++ "STATUS_BLOCK_TOO_MANY_REFERENCES", ++ "STATUS_MARKED_TO_DISALLOW_WRITES", ++ "STATUS_NETWORK_ACCESS_DENIED_EDP", ++ "STATUS_ENCLAVE_FAILURE", ++ "STATUS_PNP_NO_COMPAT_DRIVERS", ++ "STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND", ++ "STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND", ++ "STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE", ++ "STATUS_PNP_FUNCTION_DRIVER_REQUIRED", ++ "STATUS_PNP_DEVICE_CONFIGURATION_PENDING", ++ "STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL", ++ "STATUS_PACKAGE_NOT_AVAILABLE", ++ "STATUS_DEVICE_IN_MAINTENANCE", ++ "STATUS_NOT_SUPPORTED_ON_DAX", ++ "STATUS_FREE_SPACE_TOO_FRAGMENTED", ++ "STATUS_DAX_MAPPING_EXISTS", ++ "STATUS_CHILD_PROCESS_BLOCKED", ++ "STATUS_STORAGE_LOST_DATA_PERSISTENCE", ++ "STATUS_VRF_CFG_AND_IO_ENABLED", ++ "STATUS_PARTITION_TERMINATING", ++ "STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED", ++ "STATUS_ENCLAVE_VIOLATION", ++ "STATUS_FILE_PROTECTED_UNDER_DPL", ++ "STATUS_VOLUME_NOT_CLUSTER_ALIGNED", ++ "STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND", ++ "STATUS_APPX_FILE_NOT_ENCRYPTED", ++ "STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED", ++ "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET", ++ "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE", ++ "STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER", ++ "STATUS_FT_READ_FAILURE", ++ "STATUS_PATCH_CONFLICT", ++ "STATUS_STORAGE_RESERVE_ID_INVALID", ++ "STATUS_STORAGE_RESERVE_DOES_NOT_EXIST", ++ "STATUS_STORAGE_RESERVE_ALREADY_EXISTS", ++ "STATUS_STORAGE_RESERVE_NOT_EMPTY", ++ "STATUS_NOT_A_DAX_VOLUME", ++ "STATUS_NOT_DAX_MAPPABLE", ++ "STATUS_CASE_DIFFERING_NAMES_IN_DIR", ++ "STATUS_FILE_NOT_SUPPORTED", ++ "STATUS_NOT_SUPPORTED_WITH_BTT", ++ "STATUS_ENCRYPTION_DISABLED", ++ "STATUS_ENCRYPTING_METADATA_DISALLOWED", ++ "STATUS_CANT_CLEAR_ENCRYPTION_FLAG", ++ "STATUS_UNSATISFIED_DEPENDENCIES", ++ "STATUS_CASE_SENSITIVE_PATH", ++ "STATUS_HAS_SYSTEM_CRITICAL_FILES", ++ "STATUS_INVALID_TASK_NAME", ++ "STATUS_INVALID_TASK_INDEX", ++ "STATUS_THREAD_ALREADY_IN_TASK", ++ "STATUS_CALLBACK_BYPASS", ++ "STATUS_UNDEFINED_SCOPE", ++ "STATUS_INVALID_CAP", ++ "STATUS_NOT_GUI_PROCESS", ++ "STATUS_DEVICE_HUNG", ++ "STATUS_CONTAINER_ASSIGNED", ++ "STATUS_JOB_NO_CONTAINER", ++ "STATUS_DEVICE_UNRESPONSIVE", ++ "STATUS_REPARSE_POINT_ENCOUNTERED", ++ "STATUS_ATTRIBUTE_NOT_PRESENT", ++ "STATUS_NOT_A_TIERED_VOLUME", ++ "STATUS_ALREADY_HAS_STREAM_ID", ++ "STATUS_JOB_NOT_EMPTY", ++ "STATUS_ALREADY_INITIALIZED", ++ "STATUS_ENCLAVE_NOT_TERMINATED", ++ "STATUS_ENCLAVE_IS_TERMINATING", ++ "STATUS_SMB1_NOT_AVAILABLE", ++ "STATUS_SMR_GARBAGE_COLLECTION_REQUIRED", ++ "STATUS_INTERRUPTED", ++ "STATUS_THREAD_NOT_RUNNING", ++ "STATUS_FAIL_FAST_EXCEPTION", ++ "STATUS_IMAGE_CERT_REVOKED", ++ "STATUS_DYNAMIC_CODE_BLOCKED", ++ "STATUS_IMAGE_CERT_EXPIRED", ++ "STATUS_STRICT_CFG_VIOLATION", ++ "STATUS_SET_CONTEXT_DENIED", ++ "STATUS_CROSS_PARTITION_VIOLATION", ++ "STATUS_PORT_CLOSED", ++ "STATUS_MESSAGE_LOST", ++ "STATUS_INVALID_MESSAGE", ++ "STATUS_REQUEST_CANCELED", ++ "STATUS_RECURSIVE_DISPATCH", ++ "STATUS_LPC_RECEIVE_BUFFER_EXPECTED", ++ "STATUS_LPC_INVALID_CONNECTION_USAGE", ++ "STATUS_LPC_REQUESTS_NOT_ALLOWED", ++ "STATUS_RESOURCE_IN_USE", ++ "STATUS_HARDWARE_MEMORY_ERROR", ++ "STATUS_THREADPOOL_HANDLE_EXCEPTION", ++ "STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED", ++ "STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED", ++ "STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED", ++ "STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED", ++ "STATUS_THREADPOOL_RELEASED_DURING_OPERATION", ++ "STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING", ++ "STATUS_APC_RETURNED_WHILE_IMPERSONATING", ++ "STATUS_PROCESS_IS_PROTECTED", ++ "STATUS_MCA_EXCEPTION", ++ "STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE", ++ "STATUS_SYMLINK_CLASS_DISABLED", ++ "STATUS_INVALID_IDN_NORMALIZATION", ++ "STATUS_NO_UNICODE_TRANSLATION", ++ "STATUS_ALREADY_REGISTERED", ++ "STATUS_CONTEXT_MISMATCH", ++ "STATUS_PORT_ALREADY_HAS_COMPLETION_LIST", ++ "STATUS_CALLBACK_RETURNED_THREAD_PRIORITY", ++ "STATUS_INVALID_THREAD", ++ "STATUS_CALLBACK_RETURNED_TRANSACTION", ++ "STATUS_CALLBACK_RETURNED_LDR_LOCK", ++ "STATUS_CALLBACK_RETURNED_LANG", ++ "STATUS_CALLBACK_RETURNED_PRI_BACK", ++ "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY", ++ "STATUS_LPC_HANDLE_COUNT_EXCEEDED", ++ "STATUS_EXECUTABLE_MEMORY_WRITE", ++ "STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE", ++ "STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE", ++ "STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE", ++ "STATUS_DISK_REPAIR_DISABLED", ++ "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS", ++ "STATUS_DISK_QUOTA_EXCEEDED", ++ "STATUS_CONTENT_BLOCKED", ++ "STATUS_BAD_CLUSTERS", ++ "STATUS_VOLUME_DIRTY", ++ "STATUS_DISK_REPAIR_UNSUCCESSFUL", ++ "STATUS_CORRUPT_LOG_OVERFULL", ++ "STATUS_CORRUPT_LOG_CORRUPTED", ++ "STATUS_CORRUPT_LOG_UNAVAILABLE", ++ "STATUS_CORRUPT_LOG_DELETED_FULL", ++ "STATUS_CORRUPT_LOG_CLEARED", ++ "STATUS_ORPHAN_NAME_EXHAUSTED", ++ "STATUS_PROACTIVE_SCAN_IN_PROGRESS", ++ "STATUS_ENCRYPTED_IO_NOT_POSSIBLE", ++ "STATUS_CORRUPT_LOG_UPLEVEL_RECORDS", ++ "STATUS_FILE_CHECKED_OUT", ++ "STATUS_CHECKOUT_REQUIRED", ++ "STATUS_BAD_FILE_TYPE", ++ "STATUS_FILE_TOO_LARGE", ++ "STATUS_FORMS_AUTH_REQUIRED", ++ "STATUS_VIRUS_INFECTED", ++ "STATUS_VIRUS_DELETED", ++ "STATUS_BAD_MCFG_TABLE", ++ "STATUS_CANNOT_BREAK_OPLOCK", ++ "STATUS_BAD_KEY", ++ "STATUS_BAD_DATA", ++ "STATUS_NO_KEY", ++ "STATUS_FILE_HANDLE_REVOKED", ++ "STATUS_WOW_ASSERTION", ++ "STATUS_INVALID_SIGNATURE", ++ "STATUS_HMAC_NOT_SUPPORTED", ++ "STATUS_AUTH_TAG_MISMATCH", ++ "STATUS_INVALID_STATE_TRANSITION", ++ "STATUS_INVALID_KERNEL_INFO_VERSION", ++ "STATUS_INVALID_PEP_INFO_VERSION", ++ "STATUS_HANDLE_REVOKED", ++ "STATUS_EOF_ON_GHOSTED_RANGE", ++ "STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN", ++ "STATUS_IPSEC_QUEUE_OVERFLOW", ++ "STATUS_ND_QUEUE_OVERFLOW", ++ "STATUS_HOPLIMIT_EXCEEDED", ++ "STATUS_PROTOCOL_NOT_SUPPORTED", ++ "STATUS_FASTPATH_REJECTED", ++ "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED", ++ "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR", ++ "STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR", ++ "STATUS_XML_PARSE_ERROR", ++ "STATUS_XMLDSIG_ERROR", ++ "STATUS_WRONG_COMPARTMENT", ++ "STATUS_AUTHIP_FAILURE", ++ "STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS", ++ "STATUS_DS_OID_NOT_FOUND", ++ "STATUS_INCORRECT_ACCOUNT_TYPE", ++ "STATUS_HASH_NOT_SUPPORTED", ++ "STATUS_HASH_NOT_PRESENT", ++ "STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED", ++ "STATUS_GPIO_CLIENT_INFORMATION_INVALID", ++ "STATUS_GPIO_VERSION_NOT_SUPPORTED", ++ "STATUS_GPIO_INVALID_REGISTRATION_PACKET", ++ "STATUS_GPIO_OPERATION_DENIED", ++ "STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE", ++ "STATUS_CANNOT_SWITCH_RUNLEVEL", ++ "STATUS_INVALID_RUNLEVEL_SETTING", ++ "STATUS_RUNLEVEL_SWITCH_TIMEOUT", ++ "STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT", ++ "STATUS_RUNLEVEL_SWITCH_IN_PROGRESS", ++ "STATUS_NOT_APPCONTAINER", ++ "STATUS_NOT_SUPPORTED_IN_APPCONTAINER", ++ "STATUS_INVALID_PACKAGE_SID_LENGTH", ++ "STATUS_LPAC_ACCESS_DENIED", ++ "STATUS_ADMINLESS_ACCESS_DENIED", ++ "STATUS_APP_DATA_NOT_FOUND", ++ "STATUS_APP_DATA_EXPIRED", ++ "STATUS_APP_DATA_CORRUPT", ++ "STATUS_APP_DATA_LIMIT_EXCEEDED", ++ "STATUS_APP_DATA_REBOOT_REQUIRED", ++ "STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED", ++ "STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED", ++ "STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED", ++ "STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED", ++ "STATUS_WOF_WIM_HEADER_CORRUPT", ++ "STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT", ++ "STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT", ++ "STATUS_CIMFS_IMAGE_CORRUPT", ++ "STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE", ++ "STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT", ++ "STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY", ++ "STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN", ++ "STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION", ++ "STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT", ++ "STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING", ++ "STATUS_CLOUD_FILE_METADATA_CORRUPT", ++ "STATUS_CLOUD_FILE_METADATA_TOO_LARGE", ++ "STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED", ++ "STATUS_NOT_A_CLOUD_FILE", ++ "STATUS_CLOUD_FILE_NOT_IN_SYNC", ++ "STATUS_CLOUD_FILE_ALREADY_CONNECTED", ++ "STATUS_CLOUD_FILE_NOT_SUPPORTED", ++ "STATUS_CLOUD_FILE_INVALID_REQUEST", ++ "STATUS_CLOUD_FILE_READ_ONLY_VOLUME", ++ "STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY", ++ "STATUS_CLOUD_FILE_VALIDATION_FAILED", ++ "STATUS_CLOUD_FILE_AUTHENTICATION_FAILED", ++ "STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES", ++ "STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE", ++ "STATUS_CLOUD_FILE_UNSUCCESSFUL", ++ "STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT", ++ "STATUS_CLOUD_FILE_IN_USE", ++ "STATUS_CLOUD_FILE_PINNED", ++ "STATUS_CLOUD_FILE_REQUEST_ABORTED", ++ "STATUS_CLOUD_FILE_PROPERTY_CORRUPT", ++ "STATUS_CLOUD_FILE_ACCESS_DENIED", ++ "STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS", ++ "STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT", ++ "STATUS_CLOUD_FILE_REQUEST_CANCELED", ++ "STATUS_CLOUD_FILE_PROVIDER_TERMINATED", ++ "STATUS_NOT_A_CLOUD_SYNC_ROOT", ++ "STATUS_CLOUD_FILE_REQUEST_TIMEOUT", ++ "STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED", ++ "STATUS_FILE_SNAP_IN_PROGRESS", ++ "STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED", ++ "STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED", ++ "STATUS_FILE_SNAP_IO_NOT_COORDINATED", ++ "STATUS_FILE_SNAP_UNEXPECTED_ERROR", ++ "STATUS_FILE_SNAP_INVALID_PARAMETER", ++ "DBG_NO_STATE_CHANGE", ++ "DBG_APP_NOT_IDLE", ++ "RPC_NT_INVALID_STRING_BINDING", ++ "RPC_NT_WRONG_KIND_OF_BINDING", ++ "RPC_NT_INVALID_BINDING", ++ "RPC_NT_PROTSEQ_NOT_SUPPORTED", ++ "RPC_NT_INVALID_RPC_PROTSEQ", ++ "RPC_NT_INVALID_STRING_UUID", ++ "RPC_NT_INVALID_ENDPOINT_FORMAT", ++ "RPC_NT_INVALID_NET_ADDR", ++ "RPC_NT_NO_ENDPOINT_FOUND", ++ "RPC_NT_INVALID_TIMEOUT", ++ "RPC_NT_OBJECT_NOT_FOUND", ++ "RPC_NT_ALREADY_REGISTERED", ++ "RPC_NT_TYPE_ALREADY_REGISTERED", ++ "RPC_NT_ALREADY_LISTENING", ++ "RPC_NT_NO_PROTSEQS_REGISTERED", ++ "RPC_NT_NOT_LISTENING", ++ "RPC_NT_UNKNOWN_MGR_TYPE", ++ "RPC_NT_UNKNOWN_IF", ++ "RPC_NT_NO_BINDINGS", ++ "RPC_NT_NO_PROTSEQS", ++ "RPC_NT_CANT_CREATE_ENDPOINT", ++ "RPC_NT_OUT_OF_RESOURCES", ++ "RPC_NT_SERVER_UNAVAILABLE", ++ "RPC_NT_SERVER_TOO_BUSY", ++ "RPC_NT_INVALID_NETWORK_OPTIONS", ++ "RPC_NT_NO_CALL_ACTIVE", ++ "RPC_NT_CALL_FAILED", ++ "RPC_NT_CALL_FAILED_DNE", ++ "RPC_NT_PROTOCOL_ERROR", ++ "RPC_NT_UNSUPPORTED_TRANS_SYN", ++ "RPC_NT_UNSUPPORTED_TYPE", ++ "RPC_NT_INVALID_TAG", ++ "RPC_NT_INVALID_BOUND", ++ "RPC_NT_NO_ENTRY_NAME", ++ "RPC_NT_INVALID_NAME_SYNTAX", ++ "RPC_NT_UNSUPPORTED_NAME_SYNTAX", ++ "RPC_NT_UUID_NO_ADDRESS", ++ "RPC_NT_DUPLICATE_ENDPOINT", ++ "RPC_NT_UNKNOWN_AUTHN_TYPE", ++ "RPC_NT_MAX_CALLS_TOO_SMALL", ++ "RPC_NT_STRING_TOO_LONG", ++ "RPC_NT_PROTSEQ_NOT_FOUND", ++ "RPC_NT_PROCNUM_OUT_OF_RANGE", ++ "RPC_NT_BINDING_HAS_NO_AUTH", ++ "RPC_NT_UNKNOWN_AUTHN_SERVICE", ++ "RPC_NT_UNKNOWN_AUTHN_LEVEL", ++ "RPC_NT_INVALID_AUTH_IDENTITY", ++ "RPC_NT_UNKNOWN_AUTHZ_SERVICE", ++ "EPT_NT_INVALID_ENTRY", ++ "EPT_NT_CANT_PERFORM_OP", ++ "EPT_NT_NOT_REGISTERED", ++ "RPC_NT_NOTHING_TO_EXPORT", ++ "RPC_NT_INCOMPLETE_NAME", ++ "RPC_NT_INVALID_VERS_OPTION", ++ "RPC_NT_NO_MORE_MEMBERS", ++ "RPC_NT_NOT_ALL_OBJS_UNEXPORTED", ++ "RPC_NT_INTERFACE_NOT_FOUND", ++ "RPC_NT_ENTRY_ALREADY_EXISTS", ++ "RPC_NT_ENTRY_NOT_FOUND", ++ "RPC_NT_NAME_SERVICE_UNAVAILABLE", ++ "RPC_NT_INVALID_NAF_ID", ++ "RPC_NT_CANNOT_SUPPORT", ++ "RPC_NT_NO_CONTEXT_AVAILABLE", ++ "RPC_NT_INTERNAL_ERROR", ++ "RPC_NT_ZERO_DIVIDE", ++ "RPC_NT_ADDRESS_ERROR", ++ "RPC_NT_FP_DIV_ZERO", ++ "RPC_NT_FP_UNDERFLOW", ++ "RPC_NT_FP_OVERFLOW", ++ "RPC_NT_CALL_IN_PROGRESS", ++ "RPC_NT_NO_MORE_BINDINGS", ++ "RPC_NT_GROUP_MEMBER_NOT_FOUND", ++ "EPT_NT_CANT_CREATE", ++ "RPC_NT_INVALID_OBJECT", ++ "RPC_NT_NO_INTERFACES", ++ "RPC_NT_CALL_CANCELLED", ++ "RPC_NT_BINDING_INCOMPLETE", ++ "RPC_NT_COMM_FAILURE", ++ "RPC_NT_UNSUPPORTED_AUTHN_LEVEL", ++ "RPC_NT_NO_PRINC_NAME", ++ "RPC_NT_NOT_RPC_ERROR", ++ "RPC_NT_SEC_PKG_ERROR", ++ "RPC_NT_NOT_CANCELLED", ++ "RPC_NT_INVALID_ASYNC_HANDLE", ++ "RPC_NT_INVALID_ASYNC_CALL", ++ "RPC_NT_PROXY_ACCESS_DENIED", ++ "RPC_NT_COOKIE_AUTH_FAILED", ++ "RPC_NT_NO_MORE_ENTRIES", ++ "RPC_NT_SS_CHAR_TRANS_OPEN_FAIL", ++ "RPC_NT_SS_CHAR_TRANS_SHORT_FILE", ++ "RPC_NT_SS_IN_NULL_CONTEXT", ++ "RPC_NT_SS_CONTEXT_MISMATCH", ++ "RPC_NT_SS_CONTEXT_DAMAGED", ++ "RPC_NT_SS_HANDLES_MISMATCH", ++ "RPC_NT_SS_CANNOT_GET_CALL_HANDLE", ++ "RPC_NT_NULL_REF_POINTER", ++ "RPC_NT_ENUM_VALUE_OUT_OF_RANGE", ++ "RPC_NT_BYTE_COUNT_TOO_SMALL", ++ "RPC_NT_BAD_STUB_DATA", ++ "RPC_NT_INVALID_ES_ACTION", ++ "RPC_NT_WRONG_ES_VERSION", ++ "RPC_NT_WRONG_STUB_VERSION", ++ "RPC_NT_INVALID_PIPE_OBJECT", ++ "RPC_NT_INVALID_PIPE_OPERATION", ++ "RPC_NT_WRONG_PIPE_VERSION", ++ "RPC_NT_PIPE_CLOSED", ++ "RPC_NT_PIPE_DISCIPLINE_ERROR", ++ "RPC_NT_PIPE_EMPTY", ++ "STATUS_PNP_BAD_MPS_TABLE", ++ "STATUS_PNP_TRANSLATION_FAILED", ++ "STATUS_PNP_IRQ_TRANSLATION_FAILED", ++ "STATUS_PNP_INVALID_ID", ++ "STATUS_IO_REISSUE_AS_CACHED", ++ "STATUS_CTX_WINSTATION_NAME_INVALID", ++ "STATUS_CTX_INVALID_PD", ++ "STATUS_CTX_PD_NOT_FOUND", ++ "STATUS_CTX_CLOSE_PENDING", ++ "STATUS_CTX_NO_OUTBUF", ++ "STATUS_CTX_MODEM_INF_NOT_FOUND", ++ "STATUS_CTX_INVALID_MODEMNAME", ++ "STATUS_CTX_RESPONSE_ERROR", ++ "STATUS_CTX_MODEM_RESPONSE_TIMEOUT", ++ "STATUS_CTX_MODEM_RESPONSE_NO_CARRIER", ++ "STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE", ++ "STATUS_CTX_MODEM_RESPONSE_BUSY", ++ "STATUS_CTX_MODEM_RESPONSE_VOICE", ++ "STATUS_CTX_TD_ERROR", ++ "STATUS_CTX_LICENSE_CLIENT_INVALID", ++ "STATUS_CTX_LICENSE_NOT_AVAILABLE", ++ "STATUS_CTX_LICENSE_EXPIRED", ++ "STATUS_CTX_WINSTATION_NOT_FOUND", ++ "STATUS_CTX_WINSTATION_NAME_COLLISION", ++ "STATUS_CTX_WINSTATION_BUSY", ++ "STATUS_CTX_BAD_VIDEO_MODE", ++ "STATUS_CTX_GRAPHICS_INVALID", ++ "STATUS_CTX_NOT_CONSOLE", ++ "STATUS_CTX_CLIENT_QUERY_TIMEOUT", ++ "STATUS_CTX_CONSOLE_DISCONNECT", ++ "STATUS_CTX_CONSOLE_CONNECT", ++ "STATUS_CTX_SHADOW_DENIED", ++ "STATUS_CTX_WINSTATION_ACCESS_DENIED", ++ "STATUS_CTX_INVALID_WD", ++ "STATUS_CTX_WD_NOT_FOUND", ++ "STATUS_CTX_SHADOW_INVALID", ++ "STATUS_CTX_SHADOW_DISABLED", ++ "STATUS_RDP_PROTOCOL_ERROR", ++ "STATUS_CTX_CLIENT_LICENSE_NOT_SET", ++ "STATUS_CTX_CLIENT_LICENSE_IN_USE", ++ "STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE", ++ "STATUS_CTX_SHADOW_NOT_RUNNING", ++ "STATUS_CTX_LOGON_DISABLED", ++ "STATUS_CTX_SECURITY_LAYER_ERROR", ++ "STATUS_TS_INCOMPATIBLE_SESSIONS", ++ "STATUS_TS_VIDEO_SUBSYSTEM_ERROR", ++ "STATUS_MUI_FILE_NOT_FOUND", ++ "STATUS_MUI_INVALID_FILE", ++ "STATUS_MUI_INVALID_RC_CONFIG", ++ "STATUS_MUI_INVALID_LOCALE_NAME", ++ "STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME", ++ "STATUS_MUI_FILE_NOT_LOADED", ++ "STATUS_RESOURCE_ENUM_USER_STOP", ++ "STATUS_CLUSTER_INVALID_NODE", ++ "STATUS_CLUSTER_NODE_EXISTS", ++ "STATUS_CLUSTER_JOIN_IN_PROGRESS", ++ "STATUS_CLUSTER_NODE_NOT_FOUND", ++ "STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND", ++ "STATUS_CLUSTER_NETWORK_EXISTS", ++ "STATUS_CLUSTER_NETWORK_NOT_FOUND", ++ "STATUS_CLUSTER_NETINTERFACE_EXISTS", ++ "STATUS_CLUSTER_NETINTERFACE_NOT_FOUND", ++ "STATUS_CLUSTER_INVALID_REQUEST", ++ "STATUS_CLUSTER_INVALID_NETWORK_PROVIDER", ++ "STATUS_CLUSTER_NODE_DOWN", ++ "STATUS_CLUSTER_NODE_UNREACHABLE", ++ "STATUS_CLUSTER_NODE_NOT_MEMBER", ++ "STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS", ++ "STATUS_CLUSTER_INVALID_NETWORK", ++ "STATUS_CLUSTER_NO_NET_ADAPTERS", ++ "STATUS_CLUSTER_NODE_UP", ++ "STATUS_CLUSTER_NODE_PAUSED", ++ "STATUS_CLUSTER_NODE_NOT_PAUSED", ++ "STATUS_CLUSTER_NO_SECURITY_CONTEXT", ++ "STATUS_CLUSTER_NETWORK_NOT_INTERNAL", ++ "STATUS_CLUSTER_POISONED", ++ "STATUS_CLUSTER_NON_CSV_PATH", ++ "STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL", ++ "STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS", ++ "STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR", ++ "STATUS_CLUSTER_CSV_REDIRECTED", ++ "STATUS_CLUSTER_CSV_NOT_REDIRECTED", ++ "STATUS_CLUSTER_CSV_VOLUME_DRAINING", ++ "STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS", ++ "STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL", ++ "STATUS_CLUSTER_CSV_NO_SNAPSHOTS", ++ "STATUS_CSV_IO_PAUSE_TIMEOUT", ++ "STATUS_CLUSTER_CSV_INVALID_HANDLE", ++ "STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR", ++ "STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED", ++ "STATUS_ACPI_INVALID_OPCODE", ++ "STATUS_ACPI_STACK_OVERFLOW", ++ "STATUS_ACPI_ASSERT_FAILED", ++ "STATUS_ACPI_INVALID_INDEX", ++ "STATUS_ACPI_INVALID_ARGUMENT", ++ "STATUS_ACPI_FATAL", ++ "STATUS_ACPI_INVALID_SUPERNAME", ++ "STATUS_ACPI_INVALID_ARGTYPE", ++ "STATUS_ACPI_INVALID_OBJTYPE", ++ "STATUS_ACPI_INVALID_TARGETTYPE", ++ "STATUS_ACPI_INCORRECT_ARGUMENT_COUNT", ++ "STATUS_ACPI_ADDRESS_NOT_MAPPED", ++ "STATUS_ACPI_INVALID_EVENTTYPE", ++ "STATUS_ACPI_HANDLER_COLLISION", ++ "STATUS_ACPI_INVALID_DATA", ++ "STATUS_ACPI_INVALID_REGION", ++ "STATUS_ACPI_INVALID_ACCESS_SIZE", ++ "STATUS_ACPI_ACQUIRE_GLOBAL_LOCK", ++ "STATUS_ACPI_ALREADY_INITIALIZED", ++ "STATUS_ACPI_NOT_INITIALIZED", ++ "STATUS_ACPI_INVALID_MUTEX_LEVEL", ++ "STATUS_ACPI_MUTEX_NOT_OWNED", ++ "STATUS_ACPI_MUTEX_NOT_OWNER", ++ "STATUS_ACPI_RS_ACCESS", ++ "STATUS_ACPI_INVALID_TABLE", ++ "STATUS_ACPI_REG_HANDLER_FAILED", ++ "STATUS_ACPI_POWER_REQUEST_FAILED", ++ "STATUS_SXS_SECTION_NOT_FOUND", ++ "STATUS_SXS_CANT_GEN_ACTCTX", ++ "STATUS_SXS_INVALID_ACTCTXDATA_FORMAT", ++ "STATUS_SXS_ASSEMBLY_NOT_FOUND", ++ "STATUS_SXS_MANIFEST_FORMAT_ERROR", ++ "STATUS_SXS_MANIFEST_PARSE_ERROR", ++ "STATUS_SXS_ACTIVATION_CONTEXT_DISABLED", ++ "STATUS_SXS_KEY_NOT_FOUND", ++ "STATUS_SXS_VERSION_CONFLICT", ++ "STATUS_SXS_WRONG_SECTION_TYPE", ++ "STATUS_SXS_THREAD_QUERIES_DISABLED", ++ "STATUS_SXS_ASSEMBLY_MISSING", ++ "STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET", ++ "STATUS_SXS_EARLY_DEACTIVATION", ++ "STATUS_SXS_INVALID_DEACTIVATION", ++ "STATUS_SXS_MULTIPLE_DEACTIVATION", ++ "STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY", ++ "STATUS_SXS_PROCESS_TERMINATION_REQUESTED", ++ "STATUS_SXS_CORRUPT_ACTIVATION_STACK", ++ "STATUS_SXS_CORRUPTION", ++ "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE", ++ "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME", ++ "STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE", ++ "STATUS_SXS_IDENTITY_PARSE_ERROR", ++ "STATUS_SXS_COMPONENT_STORE_CORRUPT", ++ "STATUS_SXS_FILE_HASH_MISMATCH", ++ "STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT", ++ "STATUS_SXS_IDENTITIES_DIFFERENT", ++ "STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT", ++ "STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY", ++ "STATUS_ADVANCED_INSTALLER_FAILED", ++ "STATUS_XML_ENCODING_MISMATCH", ++ "STATUS_SXS_MANIFEST_TOO_BIG", ++ "STATUS_SXS_SETTING_NOT_REGISTERED", ++ "STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE", ++ "STATUS_SMI_PRIMITIVE_INSTALLER_FAILED", ++ "STATUS_GENERIC_COMMAND_FAILED", ++ "STATUS_SXS_FILE_HASH_MISSING", ++ "STATUS_TRANSACTIONAL_CONFLICT", ++ "STATUS_INVALID_TRANSACTION", ++ "STATUS_TRANSACTION_NOT_ACTIVE", ++ "STATUS_TM_INITIALIZATION_FAILED", ++ "STATUS_RM_NOT_ACTIVE", ++ "STATUS_RM_METADATA_CORRUPT", ++ "STATUS_TRANSACTION_NOT_JOINED", ++ "STATUS_DIRECTORY_NOT_RM", ++ "STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE", ++ "STATUS_LOG_RESIZE_INVALID_SIZE", ++ "STATUS_REMOTE_FILE_VERSION_MISMATCH", ++ "STATUS_CRM_PROTOCOL_ALREADY_EXISTS", ++ "STATUS_TRANSACTION_PROPAGATION_FAILED", ++ "STATUS_CRM_PROTOCOL_NOT_FOUND", ++ "STATUS_TRANSACTION_SUPERIOR_EXISTS", ++ "STATUS_TRANSACTION_REQUEST_NOT_VALID", ++ "STATUS_TRANSACTION_NOT_REQUESTED", ++ "STATUS_TRANSACTION_ALREADY_ABORTED", ++ "STATUS_TRANSACTION_ALREADY_COMMITTED", ++ "STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER", ++ "STATUS_CURRENT_TRANSACTION_NOT_VALID", ++ "STATUS_LOG_GROWTH_FAILED", ++ "STATUS_OBJECT_NO_LONGER_EXISTS", ++ "STATUS_STREAM_MINIVERSION_NOT_FOUND", ++ "STATUS_STREAM_MINIVERSION_NOT_VALID", ++ "STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION", ++ "STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT", ++ "STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS", ++ "STATUS_HANDLE_NO_LONGER_VALID", ++ "STATUS_LOG_CORRUPTION_DETECTED", ++ "STATUS_RM_DISCONNECTED", ++ "STATUS_ENLISTMENT_NOT_SUPERIOR", ++ "STATUS_FILE_IDENTITY_NOT_PERSISTENT", ++ "STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY", ++ "STATUS_CANT_CROSS_RM_BOUNDARY", ++ "STATUS_TXF_DIR_NOT_EMPTY", ++ "STATUS_INDOUBT_TRANSACTIONS_EXIST", ++ "STATUS_TM_VOLATILE", ++ "STATUS_ROLLBACK_TIMER_EXPIRED", ++ "STATUS_TXF_ATTRIBUTE_CORRUPT", ++ "STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION", ++ "STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED", ++ "STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE", ++ "STATUS_TRANSACTION_REQUIRED_PROMOTION", ++ "STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION", ++ "STATUS_TRANSACTIONS_NOT_FROZEN", ++ "STATUS_TRANSACTION_FREEZE_IN_PROGRESS", ++ "STATUS_NOT_SNAPSHOT_VOLUME", ++ "STATUS_NO_SAVEPOINT_WITH_OPEN_FILES", ++ "STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION", ++ "STATUS_TM_IDENTITY_MISMATCH", ++ "STATUS_FLOATED_SECTION", ++ "STATUS_CANNOT_ACCEPT_TRANSACTED_WORK", ++ "STATUS_CANNOT_ABORT_TRANSACTIONS", ++ "STATUS_TRANSACTION_NOT_FOUND", ++ "STATUS_RESOURCEMANAGER_NOT_FOUND", ++ "STATUS_ENLISTMENT_NOT_FOUND", ++ "STATUS_TRANSACTIONMANAGER_NOT_FOUND", ++ "STATUS_TRANSACTIONMANAGER_NOT_ONLINE", ++ "STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION", ++ "STATUS_TRANSACTION_NOT_ROOT", ++ "STATUS_TRANSACTION_OBJECT_EXPIRED", ++ "STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION", ++ "STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED", ++ "STATUS_TRANSACTION_RECORD_TOO_LONG", ++ "STATUS_NO_LINK_TRACKING_IN_TRANSACTION", ++ "STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION", ++ "STATUS_TRANSACTION_INTEGRITY_VIOLATED", ++ "STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH", ++ "STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT", ++ "STATUS_TRANSACTION_MUST_WRITETHROUGH", ++ "STATUS_TRANSACTION_NO_SUPERIOR", ++ "STATUS_EXPIRED_HANDLE", ++ "STATUS_TRANSACTION_NOT_ENLISTED", ++ "STATUS_LOG_SECTOR_INVALID", ++ "STATUS_LOG_SECTOR_PARITY_INVALID", ++ "STATUS_LOG_SECTOR_REMAPPED", ++ "STATUS_LOG_BLOCK_INCOMPLETE", ++ "STATUS_LOG_INVALID_RANGE", ++ "STATUS_LOG_BLOCKS_EXHAUSTED", ++ "STATUS_LOG_READ_CONTEXT_INVALID", ++ "STATUS_LOG_RESTART_INVALID", ++ "STATUS_LOG_BLOCK_VERSION", ++ "STATUS_LOG_BLOCK_INVALID", ++ "STATUS_LOG_READ_MODE_INVALID", ++ "STATUS_LOG_METADATA_CORRUPT", ++ "STATUS_LOG_METADATA_INVALID", ++ "STATUS_LOG_METADATA_INCONSISTENT", ++ "STATUS_LOG_RESERVATION_INVALID", ++ "STATUS_LOG_CANT_DELETE", ++ "STATUS_LOG_CONTAINER_LIMIT_EXCEEDED", ++ "STATUS_LOG_START_OF_LOG", ++ "STATUS_LOG_POLICY_ALREADY_INSTALLED", ++ "STATUS_LOG_POLICY_NOT_INSTALLED", ++ "STATUS_LOG_POLICY_INVALID", ++ "STATUS_LOG_POLICY_CONFLICT", ++ "STATUS_LOG_PINNED_ARCHIVE_TAIL", ++ "STATUS_LOG_RECORD_NONEXISTENT", ++ "STATUS_LOG_RECORDS_RESERVED_INVALID", ++ "STATUS_LOG_SPACE_RESERVED_INVALID", ++ "STATUS_LOG_TAIL_INVALID", ++ "STATUS_LOG_FULL", ++ "STATUS_LOG_MULTIPLEXED", ++ "STATUS_LOG_DEDICATED", ++ "STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS", ++ "STATUS_LOG_ARCHIVE_IN_PROGRESS", ++ "STATUS_LOG_EPHEMERAL", ++ "STATUS_LOG_NOT_ENOUGH_CONTAINERS", ++ "STATUS_LOG_CLIENT_ALREADY_REGISTERED", ++ "STATUS_LOG_CLIENT_NOT_REGISTERED", ++ "STATUS_LOG_FULL_HANDLER_IN_PROGRESS", ++ "STATUS_LOG_CONTAINER_READ_FAILED", ++ "STATUS_LOG_CONTAINER_WRITE_FAILED", ++ "STATUS_LOG_CONTAINER_OPEN_FAILED", ++ "STATUS_LOG_CONTAINER_STATE_INVALID", ++ "STATUS_LOG_STATE_INVALID", ++ "STATUS_LOG_PINNED", ++ "STATUS_LOG_METADATA_FLUSH_FAILED", ++ "STATUS_LOG_INCONSISTENT_SECURITY", ++ "STATUS_LOG_APPENDED_FLUSH_FAILED", ++ "STATUS_LOG_PINNED_RESERVATION", ++ "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD", ++ "STATUS_FLT_NO_HANDLER_DEFINED", ++ "STATUS_FLT_CONTEXT_ALREADY_DEFINED", ++ "STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST", ++ "STATUS_FLT_DISALLOW_FAST_IO", ++ "STATUS_FLT_INVALID_NAME_REQUEST", ++ "STATUS_FLT_NOT_SAFE_TO_POST_OPERATION", ++ "STATUS_FLT_NOT_INITIALIZED", ++ "STATUS_FLT_FILTER_NOT_READY", ++ "STATUS_FLT_POST_OPERATION_CLEANUP", ++ "STATUS_FLT_INTERNAL_ERROR", ++ "STATUS_FLT_DELETING_OBJECT", ++ "STATUS_FLT_MUST_BE_NONPAGED_POOL", ++ "STATUS_FLT_DUPLICATE_ENTRY", ++ "STATUS_FLT_CBDQ_DISABLED", ++ "STATUS_FLT_DO_NOT_ATTACH", ++ "STATUS_FLT_DO_NOT_DETACH", ++ "STATUS_FLT_INSTANCE_ALTITUDE_COLLISION", ++ "STATUS_FLT_INSTANCE_NAME_COLLISION", ++ "STATUS_FLT_FILTER_NOT_FOUND", ++ "STATUS_FLT_VOLUME_NOT_FOUND", ++ "STATUS_FLT_INSTANCE_NOT_FOUND", ++ "STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND", ++ "STATUS_FLT_INVALID_CONTEXT_REGISTRATION", ++ "STATUS_FLT_NAME_CACHE_MISS", ++ "STATUS_FLT_NO_DEVICE_OBJECT", ++ "STATUS_FLT_VOLUME_ALREADY_MOUNTED", ++ "STATUS_FLT_ALREADY_ENLISTED", ++ "STATUS_FLT_CONTEXT_ALREADY_LINKED", ++ "STATUS_FLT_NO_WAITER_FOR_REPLY", ++ "STATUS_FLT_REGISTRATION_BUSY", ++ "STATUS_MONITOR_NO_DESCRIPTOR", ++ "STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT", ++ "STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM", ++ "STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK", ++ "STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED", ++ "STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK", ++ "STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK", ++ "STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA", ++ "STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK", ++ "STATUS_MONITOR_INVALID_MANUFACTURE_DATE", ++ "STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER", ++ "STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER", ++ "STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER", ++ "STATUS_GRAPHICS_ADAPTER_WAS_RESET", ++ "STATUS_GRAPHICS_INVALID_DRIVER_MODEL", ++ "STATUS_GRAPHICS_PRESENT_MODE_CHANGED", ++ "STATUS_GRAPHICS_PRESENT_OCCLUDED", ++ "STATUS_GRAPHICS_PRESENT_DENIED", ++ "STATUS_GRAPHICS_CANNOTCOLORCONVERT", ++ "STATUS_GRAPHICS_DRIVER_MISMATCH", ++ "STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED", ++ "STATUS_GRAPHICS_PRESENT_UNOCCLUDED", ++ "STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE", ++ "STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED", ++ "STATUS_GRAPHICS_PRESENT_INVALID_WINDOW", ++ "STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND", ++ "STATUS_GRAPHICS_VAIL_STATE_CHANGED", ++ "STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN", ++ "STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED", ++ "STATUS_GRAPHICS_NO_VIDEO_MEMORY", ++ "STATUS_GRAPHICS_CANT_LOCK_MEMORY", ++ "STATUS_GRAPHICS_ALLOCATION_BUSY", ++ "STATUS_GRAPHICS_TOO_MANY_REFERENCES", ++ "STATUS_GRAPHICS_TRY_AGAIN_LATER", ++ "STATUS_GRAPHICS_TRY_AGAIN_NOW", ++ "STATUS_GRAPHICS_ALLOCATION_INVALID", ++ "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE", ++ "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED", ++ "STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION", ++ "STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE", ++ "STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION", ++ "STATUS_GRAPHICS_ALLOCATION_CLOSED", ++ "STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE", ++ "STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE", ++ "STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE", ++ "STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST", ++ "STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE", ++ "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY", ++ "STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_INVALID_VIDPN", ++ "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE", ++ "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET", ++ "STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET", ++ "STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET", ++ "STATUS_GRAPHICS_INVALID_FREQUENCY", ++ "STATUS_GRAPHICS_INVALID_ACTIVE_REGION", ++ "STATUS_GRAPHICS_INVALID_TOTAL_REGION", ++ "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE", ++ "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE", ++ "STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET", ++ "STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY", ++ "STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET", ++ "STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET", ++ "STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET", ++ "STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET", ++ "STATUS_GRAPHICS_TARGET_ALREADY_IN_SET", ++ "STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH", ++ "STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY", ++ "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET", ++ "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE", ++ "STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET", ++ "STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET", ++ "STATUS_GRAPHICS_STALE_MODESET", ++ "STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET", ++ "STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE", ++ "STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN", ++ "STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE", ++ "STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION", ++ "STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES", ++ "STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY", ++ "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE", ++ "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET", ++ "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET", ++ "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR", ++ "STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET", ++ "STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET", ++ "STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE", ++ "STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE", ++ "STATUS_GRAPHICS_RESOURCES_NOT_RELATED", ++ "STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE", ++ "STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE", ++ "STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET", ++ "STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER", ++ "STATUS_GRAPHICS_NO_VIDPNMGR", ++ "STATUS_GRAPHICS_NO_ACTIVE_VIDPN", ++ "STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY", ++ "STATUS_GRAPHICS_MONITOR_NOT_CONNECTED", ++ "STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY", ++ "STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE", ++ "STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE", ++ "STATUS_GRAPHICS_INVALID_STRIDE", ++ "STATUS_GRAPHICS_INVALID_PIXELFORMAT", ++ "STATUS_GRAPHICS_INVALID_COLORBASIS", ++ "STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE", ++ "STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY", ++ "STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT", ++ "STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE", ++ "STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN", ++ "STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL", ++ "STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION", ++ "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_INVALID_GAMMA_RAMP", ++ "STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_MODE_NOT_IN_MODESET", ++ "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON", ++ "STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE", ++ "STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE", ++ "STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS", ++ "STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING", ++ "STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED", ++ "STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS", ++ "STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT", ++ "STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM", ++ "STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN", ++ "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT", ++ "STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED", ++ "STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION", ++ "STATUS_GRAPHICS_INVALID_CLIENT_TYPE", ++ "STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET", ++ "STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED", ++ "STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER", ++ "STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED", ++ "STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED", ++ "STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY", ++ "STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED", ++ "STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON", ++ "STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE", ++ "STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER", ++ "STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED", ++ "STATUS_GRAPHICS_OPM_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_COPP_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_UAB_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS", ++ "STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST", ++ "STATUS_GRAPHICS_OPM_INTERNAL_ERROR", ++ "STATUS_GRAPHICS_OPM_INVALID_HANDLE", ++ "STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH", ++ "STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED", ++ "STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED", ++ "STATUS_GRAPHICS_PVP_HFS_FAILED", ++ "STATUS_GRAPHICS_OPM_INVALID_SRM", ++ "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP", ++ "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP", ++ "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA", ++ "STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET", ++ "STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH", ++ "STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE", ++ "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS", ++ "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS", ++ "STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST", ++ "STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR", ++ "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS", ++ "STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST", ++ "STATUS_GRAPHICS_I2C_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST", ++ "STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA", ++ "STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA", ++ "STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_DDCCI_INVALID_DATA", ++ "STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE", ++ "STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING", ++ "STATUS_GRAPHICS_MCA_INTERNAL_ERROR", ++ "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND", ++ "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH", ++ "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM", ++ "STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE", ++ "STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS", ++ "STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED", ++ "STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME", ++ "STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP", ++ "STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED", ++ "STATUS_GRAPHICS_INVALID_POINTER", ++ "STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE", ++ "STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL", ++ "STATUS_GRAPHICS_INTERNAL_ERROR", ++ "STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS", ++ "STATUS_FVE_LOCKED_VOLUME", ++ "STATUS_FVE_NOT_ENCRYPTED", ++ "STATUS_FVE_BAD_INFORMATION", ++ "STATUS_FVE_TOO_SMALL", ++ "STATUS_FVE_FAILED_WRONG_FS", ++ "STATUS_FVE_BAD_PARTITION_SIZE", ++ "STATUS_FVE_FS_NOT_EXTENDED", ++ "STATUS_FVE_FS_MOUNTED", ++ "STATUS_FVE_NO_LICENSE", ++ "STATUS_FVE_ACTION_NOT_ALLOWED", ++ "STATUS_FVE_BAD_DATA", ++ "STATUS_FVE_VOLUME_NOT_BOUND", ++ "STATUS_FVE_NOT_DATA_VOLUME", ++ "STATUS_FVE_CONV_READ_ERROR", ++ "STATUS_FVE_CONV_WRITE_ERROR", ++ "STATUS_FVE_OVERLAPPED_UPDATE", ++ "STATUS_FVE_FAILED_SECTOR_SIZE", ++ "STATUS_FVE_FAILED_AUTHENTICATION", ++ "STATUS_FVE_NOT_OS_VOLUME", ++ "STATUS_FVE_KEYFILE_NOT_FOUND", ++ "STATUS_FVE_KEYFILE_INVALID", ++ "STATUS_FVE_KEYFILE_NO_VMK", ++ "STATUS_FVE_TPM_DISABLED", ++ "STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO", ++ "STATUS_FVE_TPM_INVALID_PCR", ++ "STATUS_FVE_TPM_NO_VMK", ++ "STATUS_FVE_PIN_INVALID", ++ "STATUS_FVE_AUTH_INVALID_APPLICATION", ++ "STATUS_FVE_AUTH_INVALID_CONFIG", ++ "STATUS_FVE_DEBUGGER_ENABLED", ++ "STATUS_FVE_DRY_RUN_FAILED", ++ "STATUS_FVE_BAD_METADATA_POINTER", ++ "STATUS_FVE_OLD_METADATA_COPY", ++ "STATUS_FVE_REBOOT_REQUIRED", ++ "STATUS_FVE_RAW_ACCESS", ++ "STATUS_FVE_RAW_BLOCKED", ++ "STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY", ++ "STATUS_FVE_MOR_FAILED", ++ "STATUS_FVE_NO_FEATURE_LICENSE", ++ "STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED", ++ "STATUS_FVE_CONV_RECOVERY_FAILED", ++ "STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG", ++ "STATUS_FVE_INVALID_DATUM_TYPE", ++ "STATUS_FVE_VOLUME_TOO_SMALL", ++ "STATUS_FVE_ENH_PIN_INVALID", ++ "STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE", ++ "STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE", ++ "STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK", ++ "STATUS_FVE_NOT_ALLOWED_ON_CLUSTER", ++ "STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING", ++ "STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE", ++ "STATUS_FVE_EDRIVE_DRY_RUN_FAILED", ++ "STATUS_FVE_SECUREBOOT_DISABLED", ++ "STATUS_FVE_SECUREBOOT_CONFIG_CHANGE", ++ "STATUS_FVE_DEVICE_LOCKEDOUT", ++ "STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT", ++ "STATUS_FVE_NOT_DE_VOLUME", ++ "STATUS_FVE_PROTECTION_DISABLED", ++ "STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED", ++ "STATUS_FVE_OSV_KSR_NOT_ALLOWED", ++ "STATUS_FWP_CALLOUT_NOT_FOUND", ++ "STATUS_FWP_CONDITION_NOT_FOUND", ++ "STATUS_FWP_FILTER_NOT_FOUND", ++ "STATUS_FWP_LAYER_NOT_FOUND", ++ "STATUS_FWP_PROVIDER_NOT_FOUND", ++ "STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND", ++ "STATUS_FWP_SUBLAYER_NOT_FOUND", ++ "STATUS_FWP_NOT_FOUND", ++ "STATUS_FWP_ALREADY_EXISTS", ++ "STATUS_FWP_IN_USE", ++ "STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS", ++ "STATUS_FWP_WRONG_SESSION", ++ "STATUS_FWP_NO_TXN_IN_PROGRESS", ++ "STATUS_FWP_TXN_IN_PROGRESS", ++ "STATUS_FWP_TXN_ABORTED", ++ "STATUS_FWP_SESSION_ABORTED", ++ "STATUS_FWP_INCOMPATIBLE_TXN", ++ "STATUS_FWP_TIMEOUT", ++ "STATUS_FWP_NET_EVENTS_DISABLED", ++ "STATUS_FWP_INCOMPATIBLE_LAYER", ++ "STATUS_FWP_KM_CLIENTS_ONLY", ++ "STATUS_FWP_LIFETIME_MISMATCH", ++ "STATUS_FWP_BUILTIN_OBJECT", ++ "STATUS_FWP_TOO_MANY_CALLOUTS", ++ "STATUS_FWP_NOTIFICATION_DROPPED", ++ "STATUS_FWP_TRAFFIC_MISMATCH", ++ "STATUS_FWP_INCOMPATIBLE_SA_STATE", ++ "STATUS_FWP_NULL_POINTER", ++ "STATUS_FWP_INVALID_ENUMERATOR", ++ "STATUS_FWP_INVALID_FLAGS", ++ "STATUS_FWP_INVALID_NET_MASK", ++ "STATUS_FWP_INVALID_RANGE", ++ "STATUS_FWP_INVALID_INTERVAL", ++ "STATUS_FWP_ZERO_LENGTH_ARRAY", ++ "STATUS_FWP_NULL_DISPLAY_NAME", ++ "STATUS_FWP_INVALID_ACTION_TYPE", ++ "STATUS_FWP_INVALID_WEIGHT", ++ "STATUS_FWP_MATCH_TYPE_MISMATCH", ++ "STATUS_FWP_TYPE_MISMATCH", ++ "STATUS_FWP_OUT_OF_BOUNDS", ++ "STATUS_FWP_RESERVED", ++ "STATUS_FWP_DUPLICATE_CONDITION", ++ "STATUS_FWP_DUPLICATE_KEYMOD", ++ "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER", ++ "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER", ++ "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER", ++ "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT", ++ "STATUS_FWP_INCOMPATIBLE_AUTH_METHOD", ++ "STATUS_FWP_INCOMPATIBLE_DH_GROUP", ++ "STATUS_FWP_EM_NOT_SUPPORTED", ++ "STATUS_FWP_NEVER_MATCH", ++ "STATUS_FWP_PROVIDER_CONTEXT_MISMATCH", ++ "STATUS_FWP_INVALID_PARAMETER", ++ "STATUS_FWP_TOO_MANY_SUBLAYERS", ++ "STATUS_FWP_CALLOUT_NOTIFICATION_FAILED", ++ "STATUS_FWP_INVALID_AUTH_TRANSFORM", ++ "STATUS_FWP_INVALID_CIPHER_TRANSFORM", ++ "STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM", ++ "STATUS_FWP_INVALID_TRANSFORM_COMBINATION", ++ "STATUS_FWP_DUPLICATE_AUTH_METHOD", ++ "STATUS_FWP_INVALID_TUNNEL_ENDPOINT", ++ "STATUS_FWP_L2_DRIVER_NOT_READY", ++ "STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED", ++ "STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL", ++ "STATUS_FWP_CONNECTIONS_DISABLED", ++ "STATUS_FWP_INVALID_DNS_NAME", ++ "STATUS_FWP_STILL_ON", ++ "STATUS_FWP_IKEEXT_NOT_RUNNING", ++ "STATUS_FWP_TCPIP_NOT_READY", ++ "STATUS_FWP_INJECT_HANDLE_CLOSING", ++ "STATUS_FWP_INJECT_HANDLE_STALE", ++ "STATUS_FWP_CANNOT_PEND", ++ "STATUS_FWP_DROP_NOICMP", ++ "STATUS_NDIS_CLOSING", ++ "STATUS_NDIS_BAD_VERSION", ++ "STATUS_NDIS_BAD_CHARACTERISTICS", ++ "STATUS_NDIS_ADAPTER_NOT_FOUND", ++ "STATUS_NDIS_OPEN_FAILED", ++ "STATUS_NDIS_DEVICE_FAILED", ++ "STATUS_NDIS_MULTICAST_FULL", ++ "STATUS_NDIS_MULTICAST_EXISTS", ++ "STATUS_NDIS_MULTICAST_NOT_FOUND", ++ "STATUS_NDIS_REQUEST_ABORTED", ++ "STATUS_NDIS_RESET_IN_PROGRESS", ++ "STATUS_NDIS_INVALID_PACKET", ++ "STATUS_NDIS_INVALID_DEVICE_REQUEST", ++ "STATUS_NDIS_ADAPTER_NOT_READY", ++ "STATUS_NDIS_INVALID_LENGTH", ++ "STATUS_NDIS_INVALID_DATA", ++ "STATUS_NDIS_BUFFER_TOO_SHORT", ++ "STATUS_NDIS_INVALID_OID", ++ "STATUS_NDIS_ADAPTER_REMOVED", ++ "STATUS_NDIS_UNSUPPORTED_MEDIA", ++ "STATUS_NDIS_GROUP_ADDRESS_IN_USE", ++ "STATUS_NDIS_FILE_NOT_FOUND", ++ "STATUS_NDIS_ERROR_READING_FILE", ++ "STATUS_NDIS_ALREADY_MAPPED", ++ "STATUS_NDIS_RESOURCE_CONFLICT", ++ "STATUS_NDIS_MEDIA_DISCONNECTED", ++ "STATUS_NDIS_INVALID_ADDRESS", ++ "STATUS_NDIS_PAUSED", ++ "STATUS_NDIS_INTERFACE_NOT_FOUND", ++ "STATUS_NDIS_UNSUPPORTED_REVISION", ++ "STATUS_NDIS_INVALID_PORT", ++ "STATUS_NDIS_INVALID_PORT_STATE", ++ "STATUS_NDIS_LOW_POWER_STATE", ++ "STATUS_NDIS_REINIT_REQUIRED", ++ "STATUS_NDIS_NO_QUEUES", ++ "STATUS_NDIS_NOT_SUPPORTED", ++ "STATUS_NDIS_OFFLOAD_POLICY", ++ "STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED", ++ "STATUS_NDIS_OFFLOAD_PATH_REJECTED", ++ "STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED", ++ "STATUS_NDIS_DOT11_MEDIA_IN_USE", ++ "STATUS_NDIS_DOT11_POWER_STATE_INVALID", ++ "STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL", ++ "STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL", ++ "STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE", ++ "STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE", ++ "STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED", ++ "STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED", ++ "STATUS_QUIC_HANDSHAKE_FAILURE", ++ "STATUS_QUIC_VER_NEG_FAILURE", ++ "STATUS_TPM_ERROR_MASK", ++ "STATUS_TPM_AUTHFAIL", ++ "STATUS_TPM_BADINDEX", ++ "STATUS_TPM_BAD_PARAMETER", ++ "STATUS_TPM_AUDITFAILURE", ++ "STATUS_TPM_CLEAR_DISABLED", ++ "STATUS_TPM_DEACTIVATED", ++ "STATUS_TPM_DISABLED", ++ "STATUS_TPM_DISABLED_CMD", ++ "STATUS_TPM_FAIL", ++ "STATUS_TPM_BAD_ORDINAL", ++ "STATUS_TPM_INSTALL_DISABLED", ++ "STATUS_TPM_INVALID_KEYHANDLE", ++ "STATUS_TPM_KEYNOTFOUND", ++ "STATUS_TPM_INAPPROPRIATE_ENC", ++ "STATUS_TPM_MIGRATEFAIL", ++ "STATUS_TPM_INVALID_PCR_INFO", ++ "STATUS_TPM_NOSPACE", ++ "STATUS_TPM_NOSRK", ++ "STATUS_TPM_NOTSEALED_BLOB", ++ "STATUS_TPM_OWNER_SET", ++ "STATUS_TPM_RESOURCES", ++ "STATUS_TPM_SHORTRANDOM", ++ "STATUS_TPM_SIZE", ++ "STATUS_TPM_WRONGPCRVAL", ++ "STATUS_TPM_BAD_PARAM_SIZE", ++ "STATUS_TPM_SHA_THREAD", ++ "STATUS_TPM_SHA_ERROR", ++ "STATUS_TPM_FAILEDSELFTEST", ++ "STATUS_TPM_AUTH2FAIL", ++ "STATUS_TPM_BADTAG", ++ "STATUS_TPM_IOERROR", ++ "STATUS_TPM_ENCRYPT_ERROR", ++ "STATUS_TPM_DECRYPT_ERROR", ++ "STATUS_TPM_INVALID_AUTHHANDLE", ++ "STATUS_TPM_NO_ENDORSEMENT", ++ "STATUS_TPM_INVALID_KEYUSAGE", ++ "STATUS_TPM_WRONG_ENTITYTYPE", ++ "STATUS_TPM_INVALID_POSTINIT", ++ "STATUS_TPM_INAPPROPRIATE_SIG", ++ "STATUS_TPM_BAD_KEY_PROPERTY", ++ "STATUS_TPM_BAD_MIGRATION", ++ "STATUS_TPM_BAD_SCHEME", ++ "STATUS_TPM_BAD_DATASIZE", ++ "STATUS_TPM_BAD_MODE", ++ "STATUS_TPM_BAD_PRESENCE", ++ "STATUS_TPM_BAD_VERSION", ++ "STATUS_TPM_NO_WRAP_TRANSPORT", ++ "STATUS_TPM_AUDITFAIL_UNSUCCESSFUL", ++ "STATUS_TPM_AUDITFAIL_SUCCESSFUL", ++ "STATUS_TPM_NOTRESETABLE", ++ "STATUS_TPM_NOTLOCAL", ++ "STATUS_TPM_BAD_TYPE", ++ "STATUS_TPM_INVALID_RESOURCE", ++ "STATUS_TPM_NOTFIPS", ++ "STATUS_TPM_INVALID_FAMILY", ++ "STATUS_TPM_NO_NV_PERMISSION", ++ "STATUS_TPM_REQUIRES_SIGN", ++ "STATUS_TPM_KEY_NOTSUPPORTED", ++ "STATUS_TPM_AUTH_CONFLICT", ++ "STATUS_TPM_AREA_LOCKED", ++ "STATUS_TPM_BAD_LOCALITY", ++ "STATUS_TPM_READ_ONLY", ++ "STATUS_TPM_PER_NOWRITE", ++ "STATUS_TPM_FAMILYCOUNT", ++ "STATUS_TPM_WRITE_LOCKED", ++ "STATUS_TPM_BAD_ATTRIBUTES", ++ "STATUS_TPM_INVALID_STRUCTURE", ++ "STATUS_TPM_KEY_OWNER_CONTROL", ++ "STATUS_TPM_BAD_COUNTER", ++ "STATUS_TPM_NOT_FULLWRITE", ++ "STATUS_TPM_CONTEXT_GAP", ++ "STATUS_TPM_MAXNVWRITES", ++ "STATUS_TPM_NOOPERATOR", ++ "STATUS_TPM_RESOURCEMISSING", ++ "STATUS_TPM_DELEGATE_LOCK", ++ "STATUS_TPM_DELEGATE_FAMILY", ++ "STATUS_TPM_DELEGATE_ADMIN", ++ "STATUS_TPM_TRANSPORT_NOTEXCLUSIVE", ++ "STATUS_TPM_OWNER_CONTROL", ++ "STATUS_TPM_DAA_RESOURCES", ++ "STATUS_TPM_DAA_INPUT_DATA0", ++ "STATUS_TPM_DAA_INPUT_DATA1", ++ "STATUS_TPM_DAA_ISSUER_SETTINGS", ++ "STATUS_TPM_DAA_TPM_SETTINGS", ++ "STATUS_TPM_DAA_STAGE", ++ "STATUS_TPM_DAA_ISSUER_VALIDITY", ++ "STATUS_TPM_DAA_WRONG_W", ++ "STATUS_TPM_BAD_HANDLE", ++ "STATUS_TPM_BAD_DELEGATE", ++ "STATUS_TPM_BADCONTEXT", ++ "STATUS_TPM_TOOMANYCONTEXTS", ++ "STATUS_TPM_MA_TICKET_SIGNATURE", ++ "STATUS_TPM_MA_DESTINATION", ++ "STATUS_TPM_MA_SOURCE", ++ "STATUS_TPM_MA_AUTHORITY", ++ "STATUS_TPM_PERMANENTEK", ++ "STATUS_TPM_BAD_SIGNATURE", ++ "STATUS_TPM_NOCONTEXTSPACE", ++ "STATUS_TPM_20_E_ASYMMETRIC", ++ "STATUS_TPM_20_E_ATTRIBUTES", ++ "STATUS_TPM_20_E_HASH", ++ "STATUS_TPM_20_E_VALUE", ++ "STATUS_TPM_20_E_HIERARCHY", ++ "STATUS_TPM_20_E_KEY_SIZE", ++ "STATUS_TPM_20_E_MGF", ++ "STATUS_TPM_20_E_MODE", ++ "STATUS_TPM_20_E_TYPE", ++ "STATUS_TPM_20_E_HANDLE", ++ "STATUS_TPM_20_E_KDF", ++ "STATUS_TPM_20_E_RANGE", ++ "STATUS_TPM_20_E_AUTH_FAIL", ++ "STATUS_TPM_20_E_NONCE", ++ "STATUS_TPM_20_E_PP", ++ "STATUS_TPM_20_E_SCHEME", ++ "STATUS_TPM_20_E_SIZE", ++ "STATUS_TPM_20_E_SYMMETRIC", ++ "STATUS_TPM_20_E_TAG", ++ "STATUS_TPM_20_E_SELECTOR", ++ "STATUS_TPM_20_E_INSUFFICIENT", ++ "STATUS_TPM_20_E_SIGNATURE", ++ "STATUS_TPM_20_E_KEY", ++ "STATUS_TPM_20_E_POLICY_FAIL", ++ "STATUS_TPM_20_E_INTEGRITY", ++ "STATUS_TPM_20_E_TICKET", ++ "STATUS_TPM_20_E_RESERVED_BITS", ++ "STATUS_TPM_20_E_BAD_AUTH", ++ "STATUS_TPM_20_E_EXPIRED", ++ "STATUS_TPM_20_E_POLICY_CC", ++ "STATUS_TPM_20_E_BINDING", ++ "STATUS_TPM_20_E_CURVE", ++ "STATUS_TPM_20_E_ECC_POINT", ++ "STATUS_TPM_20_E_INITIALIZE", ++ "STATUS_TPM_20_E_FAILURE", ++ "STATUS_TPM_20_E_SEQUENCE", ++ "STATUS_TPM_20_E_PRIVATE", ++ "STATUS_TPM_20_E_HMAC", ++ "STATUS_TPM_20_E_DISABLED", ++ "STATUS_TPM_20_E_EXCLUSIVE", ++ "STATUS_TPM_20_E_ECC_CURVE", ++ "STATUS_TPM_20_E_AUTH_TYPE", ++ "STATUS_TPM_20_E_AUTH_MISSING", ++ "STATUS_TPM_20_E_POLICY", ++ "STATUS_TPM_20_E_PCR", ++ "STATUS_TPM_20_E_PCR_CHANGED", ++ "STATUS_TPM_20_E_UPGRADE", ++ "STATUS_TPM_20_E_TOO_MANY_CONTEXTS", ++ "STATUS_TPM_20_E_AUTH_UNAVAILABLE", ++ "STATUS_TPM_20_E_REBOOT", ++ "STATUS_TPM_20_E_UNBALANCED", ++ "STATUS_TPM_20_E_COMMAND_SIZE", ++ "STATUS_TPM_20_E_COMMAND_CODE", ++ "STATUS_TPM_20_E_AUTHSIZE", ++ "STATUS_TPM_20_E_AUTH_CONTEXT", ++ "STATUS_TPM_20_E_NV_RANGE", ++ "STATUS_TPM_20_E_NV_SIZE", ++ "STATUS_TPM_20_E_NV_LOCKED", ++ "STATUS_TPM_20_E_NV_AUTHORIZATION", ++ "STATUS_TPM_20_E_NV_UNINITIALIZED", ++ "STATUS_TPM_20_E_NV_SPACE", ++ "STATUS_TPM_20_E_NV_DEFINED", ++ "STATUS_TPM_20_E_BAD_CONTEXT", ++ "STATUS_TPM_20_E_CPHASH", ++ "STATUS_TPM_20_E_PARENT", ++ "STATUS_TPM_20_E_NEEDS_TEST", ++ "STATUS_TPM_20_E_NO_RESULT", ++ "STATUS_TPM_20_E_SENSITIVE", ++ "STATUS_TPM_COMMAND_BLOCKED", ++ "STATUS_TPM_INVALID_HANDLE", ++ "STATUS_TPM_DUPLICATE_VHANDLE", ++ "STATUS_TPM_EMBEDDED_COMMAND_BLOCKED", ++ "STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED", ++ "STATUS_TPM_RETRY", ++ "STATUS_TPM_NEEDS_SELFTEST", ++ "STATUS_TPM_DOING_SELFTEST", ++ "STATUS_TPM_DEFEND_LOCK_RUNNING", ++ "STATUS_TPM_COMMAND_CANCELED", ++ "STATUS_TPM_TOO_MANY_CONTEXTS", ++ "STATUS_TPM_NOT_FOUND", ++ "STATUS_TPM_ACCESS_DENIED", ++ "STATUS_TPM_INSUFFICIENT_BUFFER", ++ "STATUS_TPM_PPI_FUNCTION_UNSUPPORTED", ++ "STATUS_PCP_ERROR_MASK", ++ "STATUS_PCP_DEVICE_NOT_READY", ++ "STATUS_PCP_INVALID_HANDLE", ++ "STATUS_PCP_INVALID_PARAMETER", ++ "STATUS_PCP_FLAG_NOT_SUPPORTED", ++ "STATUS_PCP_NOT_SUPPORTED", ++ "STATUS_PCP_BUFFER_TOO_SMALL", ++ "STATUS_PCP_INTERNAL_ERROR", ++ "STATUS_PCP_AUTHENTICATION_FAILED", ++ "STATUS_PCP_AUTHENTICATION_IGNORED", ++ "STATUS_PCP_POLICY_NOT_FOUND", ++ "STATUS_PCP_PROFILE_NOT_FOUND", ++ "STATUS_PCP_VALIDATION_FAILED", ++ "STATUS_PCP_DEVICE_NOT_FOUND", ++ "STATUS_PCP_WRONG_PARENT", ++ "STATUS_PCP_KEY_NOT_LOADED", ++ "STATUS_PCP_NO_KEY_CERTIFICATION", ++ "STATUS_PCP_KEY_NOT_FINALIZED", ++ "STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET", ++ "STATUS_PCP_NOT_PCR_BOUND", ++ "STATUS_PCP_KEY_ALREADY_FINALIZED", ++ "STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED", ++ "STATUS_PCP_KEY_USAGE_POLICY_INVALID", ++ "STATUS_PCP_SOFT_KEY_ERROR", ++ "STATUS_PCP_KEY_NOT_AUTHENTICATED", ++ "STATUS_PCP_KEY_NOT_AIK", ++ "STATUS_PCP_KEY_NOT_SIGNING_KEY", ++ "STATUS_PCP_LOCKED_OUT", ++ "STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED", ++ "STATUS_PCP_TPM_VERSION_NOT_SUPPORTED", ++ "STATUS_PCP_BUFFER_LENGTH_MISMATCH", ++ "STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED", ++ "STATUS_PCP_TICKET_MISSING", ++ "STATUS_PCP_RAW_POLICY_NOT_SUPPORTED", ++ "STATUS_PCP_KEY_HANDLE_INVALIDATED", ++ "STATUS_RTPM_NO_RESULT", ++ "STATUS_RTPM_PCR_READ_INCOMPLETE", ++ "STATUS_RTPM_INVALID_CONTEXT", ++ "STATUS_RTPM_UNSUPPORTED_CMD", ++ "STATUS_TPM_ZERO_EXHAUST_ENABLED", ++ "STATUS_HV_INVALID_HYPERCALL_CODE", ++ "STATUS_HV_INVALID_HYPERCALL_INPUT", ++ "STATUS_HV_INVALID_ALIGNMENT", ++ "STATUS_HV_INVALID_PARAMETER", ++ "STATUS_HV_ACCESS_DENIED", ++ "STATUS_HV_INVALID_PARTITION_STATE", ++ "STATUS_HV_OPERATION_DENIED", ++ "STATUS_HV_UNKNOWN_PROPERTY", ++ "STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE", ++ "STATUS_HV_INSUFFICIENT_MEMORY", ++ "STATUS_HV_PARTITION_TOO_DEEP", ++ "STATUS_HV_INVALID_PARTITION_ID", ++ "STATUS_HV_INVALID_VP_INDEX", ++ "STATUS_HV_INVALID_PORT_ID", ++ "STATUS_HV_INVALID_CONNECTION_ID", ++ "STATUS_HV_INSUFFICIENT_BUFFERS", ++ "STATUS_HV_NOT_ACKNOWLEDGED", ++ "STATUS_HV_INVALID_VP_STATE", ++ "STATUS_HV_ACKNOWLEDGED", ++ "STATUS_HV_INVALID_SAVE_RESTORE_STATE", ++ "STATUS_HV_INVALID_SYNIC_STATE", ++ "STATUS_HV_OBJECT_IN_USE", ++ "STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO", ++ "STATUS_HV_NO_DATA", ++ "STATUS_HV_INACTIVE", ++ "STATUS_HV_NO_RESOURCES", ++ "STATUS_HV_FEATURE_UNAVAILABLE", ++ "STATUS_HV_INSUFFICIENT_BUFFER", ++ "STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS", ++ "STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR", ++ "STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR", ++ "STATUS_HV_PROCESSOR_STARTUP_TIMEOUT", ++ "STATUS_HV_SMX_ENABLED", ++ "STATUS_HV_INVALID_LP_INDEX", ++ "STATUS_HV_INVALID_REGISTER_VALUE", ++ "STATUS_HV_INVALID_VTL_STATE", ++ "STATUS_HV_NX_NOT_DETECTED", ++ "STATUS_HV_INVALID_DEVICE_ID", ++ "STATUS_HV_INVALID_DEVICE_STATE", ++ "STATUS_HV_PAGE_REQUEST_INVALID", ++ "STATUS_HV_INVALID_CPU_GROUP_ID", ++ "STATUS_HV_INVALID_CPU_GROUP_STATE", ++ "STATUS_HV_OPERATION_FAILED", ++ "STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE", ++ "STATUS_HV_INSUFFICIENT_ROOT_MEMORY", ++ "STATUS_HV_EVENT_BUFFER_ALREADY_FREED", ++ "STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY", ++ "STATUS_HV_NOT_PRESENT", ++ "STATUS_IPSEC_BAD_SPI", ++ "STATUS_IPSEC_SA_LIFETIME_EXPIRED", ++ "STATUS_IPSEC_WRONG_SA", ++ "STATUS_IPSEC_REPLAY_CHECK_FAILED", ++ "STATUS_IPSEC_INVALID_PACKET", ++ "STATUS_IPSEC_INTEGRITY_CHECK_FAILED", ++ "STATUS_IPSEC_CLEAR_TEXT_DROP", ++ "STATUS_IPSEC_AUTH_FIREWALL_DROP", ++ "STATUS_IPSEC_THROTTLE_DROP", ++ "STATUS_IPSEC_DOSP_BLOCK", ++ "STATUS_IPSEC_DOSP_RECEIVED_MULTICAST", ++ "STATUS_IPSEC_DOSP_INVALID_PACKET", ++ "STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED", ++ "STATUS_IPSEC_DOSP_MAX_ENTRIES", ++ "STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED", ++ "STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES", ++ "STATUS_VID_DUPLICATE_HANDLER", ++ "STATUS_VID_TOO_MANY_HANDLERS", ++ "STATUS_VID_QUEUE_FULL", ++ "STATUS_VID_HANDLER_NOT_PRESENT", ++ "STATUS_VID_INVALID_OBJECT_NAME", ++ "STATUS_VID_PARTITION_NAME_TOO_LONG", ++ "STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG", ++ "STATUS_VID_PARTITION_ALREADY_EXISTS", ++ "STATUS_VID_PARTITION_DOES_NOT_EXIST", ++ "STATUS_VID_PARTITION_NAME_NOT_FOUND", ++ "STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS", ++ "STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT", ++ "STATUS_VID_MB_STILL_REFERENCED", ++ "STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED", ++ "STATUS_VID_INVALID_NUMA_SETTINGS", ++ "STATUS_VID_INVALID_NUMA_NODE_INDEX", ++ "STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED", ++ "STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE", ++ "STATUS_VID_PAGE_RANGE_OVERFLOW", ++ "STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE", ++ "STATUS_VID_INVALID_GPA_RANGE_HANDLE", ++ "STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE", ++ "STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED", ++ "STATUS_VID_INVALID_PPM_HANDLE", ++ "STATUS_VID_MBPS_ARE_LOCKED", ++ "STATUS_VID_MESSAGE_QUEUE_CLOSED", ++ "STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED", ++ "STATUS_VID_STOP_PENDING", ++ "STATUS_VID_INVALID_PROCESSOR_STATE", ++ "STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT", ++ "STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED", ++ "STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET", ++ "STATUS_VID_MMIO_RANGE_DESTROYED", ++ "STATUS_VID_INVALID_CHILD_GPA_PAGE_SET", ++ "STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED", ++ "STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL", ++ "STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE", ++ "STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT", ++ "STATUS_VID_SAVED_STATE_CORRUPT", ++ "STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM", ++ "STATUS_VID_SAVED_STATE_INCOMPATIBLE", ++ "STATUS_VID_VTL_ACCESS_DENIED", ++ "STATUS_VOLMGR_DATABASE_FULL", ++ "STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED", ++ "STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC", ++ "STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED", ++ "STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME", ++ "STATUS_VOLMGR_DISK_DUPLICATE", ++ "STATUS_VOLMGR_DISK_DYNAMIC", ++ "STATUS_VOLMGR_DISK_ID_INVALID", ++ "STATUS_VOLMGR_DISK_INVALID", ++ "STATUS_VOLMGR_DISK_LAST_VOTER", ++ "STATUS_VOLMGR_DISK_LAYOUT_INVALID", ++ "STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS", ++ "STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED", ++ "STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL", ++ "STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS", ++ "STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS", ++ "STATUS_VOLMGR_DISK_MISSING", ++ "STATUS_VOLMGR_DISK_NOT_EMPTY", ++ "STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE", ++ "STATUS_VOLMGR_DISK_REVECTORING_FAILED", ++ "STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID", ++ "STATUS_VOLMGR_DISK_SET_NOT_CONTAINED", ++ "STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS", ++ "STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES", ++ "STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED", ++ "STATUS_VOLMGR_EXTENT_ALREADY_USED", ++ "STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS", ++ "STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION", ++ "STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED", ++ "STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION", ++ "STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH", ++ "STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED", ++ "STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID", ++ "STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS", ++ "STATUS_VOLMGR_MEMBER_IN_SYNC", ++ "STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE", ++ "STATUS_VOLMGR_MEMBER_INDEX_INVALID", ++ "STATUS_VOLMGR_MEMBER_MISSING", ++ "STATUS_VOLMGR_MEMBER_NOT_DETACHED", ++ "STATUS_VOLMGR_MEMBER_REGENERATING", ++ "STATUS_VOLMGR_ALL_DISKS_FAILED", ++ "STATUS_VOLMGR_NO_REGISTERED_USERS", ++ "STATUS_VOLMGR_NO_SUCH_USER", ++ "STATUS_VOLMGR_NOTIFICATION_RESET", ++ "STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID", ++ "STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID", ++ "STATUS_VOLMGR_PACK_DUPLICATE", ++ "STATUS_VOLMGR_PACK_ID_INVALID", ++ "STATUS_VOLMGR_PACK_INVALID", ++ "STATUS_VOLMGR_PACK_NAME_INVALID", ++ "STATUS_VOLMGR_PACK_OFFLINE", ++ "STATUS_VOLMGR_PACK_HAS_QUORUM", ++ "STATUS_VOLMGR_PACK_WITHOUT_QUORUM", ++ "STATUS_VOLMGR_PARTITION_STYLE_INVALID", ++ "STATUS_VOLMGR_PARTITION_UPDATE_FAILED", ++ "STATUS_VOLMGR_PLEX_IN_SYNC", ++ "STATUS_VOLMGR_PLEX_INDEX_DUPLICATE", ++ "STATUS_VOLMGR_PLEX_INDEX_INVALID", ++ "STATUS_VOLMGR_PLEX_LAST_ACTIVE", ++ "STATUS_VOLMGR_PLEX_MISSING", ++ "STATUS_VOLMGR_PLEX_REGENERATING", ++ "STATUS_VOLMGR_PLEX_TYPE_INVALID", ++ "STATUS_VOLMGR_PLEX_NOT_RAID5", ++ "STATUS_VOLMGR_PLEX_NOT_SIMPLE", ++ "STATUS_VOLMGR_STRUCTURE_SIZE_INVALID", ++ "STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS", ++ "STATUS_VOLMGR_TRANSACTION_IN_PROGRESS", ++ "STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE", ++ "STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK", ++ "STATUS_VOLMGR_VOLUME_ID_INVALID", ++ "STATUS_VOLMGR_VOLUME_LENGTH_INVALID", ++ "STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE", ++ "STATUS_VOLMGR_VOLUME_NOT_MIRRORED", ++ "STATUS_VOLMGR_VOLUME_NOT_RETAINED", ++ "STATUS_VOLMGR_VOLUME_OFFLINE", ++ "STATUS_VOLMGR_VOLUME_RETAINED", ++ "STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID", ++ "STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE", ++ "STATUS_VOLMGR_BAD_BOOT_DISK", ++ "STATUS_VOLMGR_PACK_CONFIG_OFFLINE", ++ "STATUS_VOLMGR_PACK_CONFIG_ONLINE", ++ "STATUS_VOLMGR_NOT_PRIMARY_PACK", ++ "STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED", ++ "STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID", ++ "STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID", ++ "STATUS_VOLMGR_VOLUME_MIRRORED", ++ "STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED", ++ "STATUS_VOLMGR_NO_VALID_LOG_COPIES", ++ "STATUS_VOLMGR_PRIMARY_PACK_PRESENT", ++ "STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID", ++ "STATUS_VOLMGR_MIRROR_NOT_SUPPORTED", ++ "STATUS_VOLMGR_RAID5_NOT_SUPPORTED", ++ "STATUS_BCD_TOO_MANY_ELEMENTS", ++ "STATUS_VHD_DRIVE_FOOTER_MISSING", ++ "STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH", ++ "STATUS_VHD_DRIVE_FOOTER_CORRUPT", ++ "STATUS_VHD_FORMAT_UNKNOWN", ++ "STATUS_VHD_FORMAT_UNSUPPORTED_VERSION", ++ "STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH", ++ "STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION", ++ "STATUS_VHD_SPARSE_HEADER_CORRUPT", ++ "STATUS_VHD_BLOCK_ALLOCATION_FAILURE", ++ "STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT", ++ "STATUS_VHD_INVALID_BLOCK_SIZE", ++ "STATUS_VHD_BITMAP_MISMATCH", ++ "STATUS_VHD_PARENT_VHD_NOT_FOUND", ++ "STATUS_VHD_CHILD_PARENT_ID_MISMATCH", ++ "STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH", ++ "STATUS_VHD_METADATA_READ_FAILURE", ++ "STATUS_VHD_METADATA_WRITE_FAILURE", ++ "STATUS_VHD_INVALID_SIZE", ++ "STATUS_VHD_INVALID_FILE_SIZE", ++ "STATUS_VIRTDISK_PROVIDER_NOT_FOUND", ++ "STATUS_VIRTDISK_NOT_VIRTUAL_DISK", ++ "STATUS_VHD_PARENT_VHD_ACCESS_DENIED", ++ "STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH", ++ "STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED", ++ "STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT", ++ "STATUS_VIRTUAL_DISK_LIMITATION", ++ "STATUS_VHD_INVALID_TYPE", ++ "STATUS_VHD_INVALID_STATE", ++ "STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE", ++ "STATUS_VIRTDISK_DISK_ALREADY_OWNED", ++ "STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE", ++ "STATUS_CTLOG_TRACKING_NOT_INITIALIZED", ++ "STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE", ++ "STATUS_CTLOG_VHD_CHANGED_OFFLINE", ++ "STATUS_CTLOG_INVALID_TRACKING_STATE", ++ "STATUS_CTLOG_INCONSISTENT_TRACKING_FILE", ++ "STATUS_VHD_METADATA_FULL", ++ "STATUS_VHD_INVALID_CHANGE_TRACKING_ID", ++ "STATUS_VHD_CHANGE_TRACKING_DISABLED", ++ "STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION", ++ "STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA", ++ "STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE", ++ "STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE", ++ "STATUS_RKF_KEY_NOT_FOUND", ++ "STATUS_RKF_DUPLICATE_KEY", ++ "STATUS_RKF_BLOB_FULL", ++ "STATUS_RKF_STORE_FULL", ++ "STATUS_RKF_FILE_BLOCKED", ++ "STATUS_RKF_ACTIVE_KEY", ++ "STATUS_RDBSS_RESTART_OPERATION", ++ "STATUS_RDBSS_CONTINUE_OPERATION", ++ "STATUS_RDBSS_POST_OPERATION", ++ "STATUS_RDBSS_RETRY_LOOKUP", ++ "STATUS_BTH_ATT_INVALID_HANDLE", ++ "STATUS_BTH_ATT_READ_NOT_PERMITTED", ++ "STATUS_BTH_ATT_WRITE_NOT_PERMITTED", ++ "STATUS_BTH_ATT_INVALID_PDU", ++ "STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION", ++ "STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED", ++ "STATUS_BTH_ATT_INVALID_OFFSET", ++ "STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION", ++ "STATUS_BTH_ATT_PREPARE_QUEUE_FULL", ++ "STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND", ++ "STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG", ++ "STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE", ++ "STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH", ++ "STATUS_BTH_ATT_UNLIKELY", ++ "STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION", ++ "STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE", ++ "STATUS_BTH_ATT_INSUFFICIENT_RESOURCES", ++ "STATUS_BTH_ATT_UNKNOWN_ERROR", ++ "STATUS_SECUREBOOT_ROLLBACK_DETECTED", ++ "STATUS_SECUREBOOT_POLICY_VIOLATION", ++ "STATUS_SECUREBOOT_INVALID_POLICY", ++ "STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND", ++ "STATUS_SECUREBOOT_POLICY_NOT_SIGNED", ++ "STATUS_SECUREBOOT_FILE_REPLACED", ++ "STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED", ++ "STATUS_SECUREBOOT_POLICY_UNKNOWN", ++ "STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION", ++ "STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH", ++ "STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED", ++ "STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH", ++ "STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING", ++ "STATUS_SECUREBOOT_NOT_BASE_POLICY", ++ "STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY", ++ "STATUS_AUDIO_ENGINE_NODE_NOT_FOUND", ++ "STATUS_HDAUDIO_EMPTY_CONNECTION_LIST", ++ "STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED", ++ "STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED", ++ "STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY", ++ "STATUS_VSM_NOT_INITIALIZED", ++ "STATUS_VSM_DMA_PROTECTION_NOT_IN_USE", ++ "STATUS_VOLSNAP_BOOTFILE_NOT_VALID", ++ "STATUS_VOLSNAP_ACTIVATION_TIMEOUT", ++ "STATUS_IO_PREEMPTED", ++ "STATUS_SVHDX_ERROR_STORED", ++ "STATUS_SVHDX_ERROR_NOT_AVAILABLE", ++ "STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE", ++ "STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED", ++ "STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED", ++ "STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED", ++ "STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED", ++ "STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED", ++ "STATUS_SVHDX_RESERVATION_CONFLICT", ++ "STATUS_SVHDX_WRONG_FILE_TYPE", ++ "STATUS_SVHDX_VERSION_MISMATCH", ++ "STATUS_VHD_SHARED", ++ "STATUS_SVHDX_NO_INITIATOR", ++ "STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND", ++ "STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP", ++ "STATUS_SMB_BAD_CLUSTER_DIALECT", ++ "STATUS_SMB_GUEST_LOGON_BLOCKED", ++ "STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID", ++ "STATUS_SPACES_RESILIENCY_TYPE_INVALID", ++ "STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID", ++ "STATUS_SPACES_DRIVE_REDUNDANCY_INVALID", ++ "STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID", ++ "STATUS_SPACES_INTERLEAVE_LENGTH_INVALID", ++ "STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID", ++ "STATUS_SPACES_NOT_ENOUGH_DRIVES", ++ "STATUS_SPACES_EXTENDED_ERROR", ++ "STATUS_SPACES_PROVISIONING_TYPE_INVALID", ++ "STATUS_SPACES_ALLOCATION_SIZE_INVALID", ++ "STATUS_SPACES_ENCLOSURE_AWARE_INVALID", ++ "STATUS_SPACES_WRITE_CACHE_SIZE_INVALID", ++ "STATUS_SPACES_NUMBER_OF_GROUPS_INVALID", ++ "STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID", ++ "STATUS_SPACES_UPDATE_COLUMN_STATE", ++ "STATUS_SPACES_MAP_REQUIRED", ++ "STATUS_SPACES_UNSUPPORTED_VERSION", ++ "STATUS_SPACES_CORRUPT_METADATA", ++ "STATUS_SPACES_DRT_FULL", ++ "STATUS_SPACES_INCONSISTENCY", ++ "STATUS_SPACES_LOG_NOT_READY", ++ "STATUS_SPACES_NO_REDUNDANCY", ++ "STATUS_SPACES_DRIVE_NOT_READY", ++ "STATUS_SPACES_DRIVE_SPLIT", ++ "STATUS_SPACES_DRIVE_LOST_DATA", ++ "STATUS_SPACES_ENTRY_INCOMPLETE", ++ "STATUS_SPACES_ENTRY_INVALID", ++ "STATUS_SPACES_MARK_DIRTY", ++ "STATUS_SECCORE_INVALID_COMMAND", ++ "STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED", ++ "STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION", ++ "STATUS_SYSTEM_INTEGRITY_INVALID_POLICY", ++ "STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED", ++ "STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES", ++ "STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED", ++ "STATUS_NO_APPLICABLE_APP_LICENSES_FOUND", ++ "STATUS_CLIP_LICENSE_NOT_FOUND", ++ "STATUS_CLIP_DEVICE_LICENSE_MISSING", ++ "STATUS_CLIP_LICENSE_INVALID_SIGNATURE", ++ "STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID", ++ "STATUS_CLIP_LICENSE_EXPIRED", ++ "STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE", ++ "STATUS_CLIP_LICENSE_NOT_SIGNED", ++ "STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE", ++ "STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH", ++ "STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED", ++ "STATUS_PLATFORM_MANIFEST_INVALID", ++ "STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED", ++ "STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED", ++ "STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND", ++ "STATUS_PLATFORM_MANIFEST_NOT_ACTIVE", ++ "STATUS_PLATFORM_MANIFEST_NOT_SIGNED", ++ "STATUS_APPEXEC_CONDITION_NOT_SATISFIED", ++ "STATUS_APPEXEC_HANDLE_INVALIDATED", ++ "STATUS_APPEXEC_INVALID_HOST_GENERATION", ++ "STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION", ++ "STATUS_APPEXEC_INVALID_HOST_STATE", ++ "STATUS_APPEXEC_NO_DONOR", ++ "STATUS_APPEXEC_HOST_ID_MISMATCH", ++ "STATUS_APPEXEC_UNKNOWN_USER", ++}; ++ ++const char* NTStatusToString(uint32_t ntstatus) { ++ auto itr = std::find(std::begin(kNTStatusValues), ++ std::end(kNTStatusValues), ++ ntstatus); ++ if (itr == std::end(kNTStatusValues)) { ++ return nullptr; + } +- return reason; ++ ++ return kNTStatusStrings[itr - std::begin(kNTStatusValues)]; + } + +-string FastFailToString(uint32_t fast_fail_code) { +- string code_string; +- // The content of this switch was created from winnt.h in the 10 SDK +- // (version 10.0.19041.0) with +- // +- // egrep '#define FAST_FAIL_[A-Z_0-9]+\s+[0-9]' winnt.h +- // | tr -d '\r' +- // | sed -r 's@#define FAST_FAIL_([A-Z_0-9]+)\s+([0-9]+).*@\2 \1@' +- // | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ case MD_FAST_FAIL_WIN_\2:\n code_string = "FAST_FAIL_\2";\n break;@' +- // +- // and then the default case added. +- switch (fast_fail_code) { +- case MD_FAST_FAIL_WIN_LEGACY_GS_VIOLATION: +- code_string = "FAST_FAIL_LEGACY_GS_VIOLATION"; +- break; +- case MD_FAST_FAIL_WIN_VTGUARD_CHECK_FAILURE: +- code_string = "FAST_FAIL_VTGUARD_CHECK_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_STACK_COOKIE_CHECK_FAILURE: +- code_string = "FAST_FAIL_STACK_COOKIE_CHECK_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_CORRUPT_LIST_ENTRY: +- code_string = "FAST_FAIL_CORRUPT_LIST_ENTRY"; +- break; +- case MD_FAST_FAIL_WIN_INCORRECT_STACK: +- code_string = "FAST_FAIL_INCORRECT_STACK"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_ARG: +- code_string = "FAST_FAIL_INVALID_ARG"; +- break; +- case MD_FAST_FAIL_WIN_GS_COOKIE_INIT: +- code_string = "FAST_FAIL_GS_COOKIE_INIT"; +- break; +- case MD_FAST_FAIL_WIN_FATAL_APP_EXIT: +- code_string = "FAST_FAIL_FATAL_APP_EXIT"; +- break; +- case MD_FAST_FAIL_WIN_RANGE_CHECK_FAILURE: +- code_string = "FAST_FAIL_RANGE_CHECK_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_UNSAFE_REGISTRY_ACCESS: +- code_string = "FAST_FAIL_UNSAFE_REGISTRY_ACCESS"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_FAILURE: +- code_string = "FAST_FAIL_GUARD_ICALL_CHECK_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_WRITE_CHECK_FAILURE: +- code_string = "FAST_FAIL_GUARD_WRITE_CHECK_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_FIBER_SWITCH: +- code_string = "FAST_FAIL_INVALID_FIBER_SWITCH"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_SET_OF_CONTEXT: +- code_string = "FAST_FAIL_INVALID_SET_OF_CONTEXT"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_REFERENCE_COUNT: +- code_string = "FAST_FAIL_INVALID_REFERENCE_COUNT"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_JUMP_BUFFER: +- code_string = "FAST_FAIL_INVALID_JUMP_BUFFER"; +- break; +- case MD_FAST_FAIL_WIN_MRDATA_MODIFIED: +- code_string = "FAST_FAIL_MRDATA_MODIFIED"; +- break; +- case MD_FAST_FAIL_WIN_CERTIFICATION_FAILURE: +- code_string = "FAST_FAIL_CERTIFICATION_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_EXCEPTION_CHAIN: +- code_string = "FAST_FAIL_INVALID_EXCEPTION_CHAIN"; +- break; +- case MD_FAST_FAIL_WIN_CRYPTO_LIBRARY: +- code_string = "FAST_FAIL_CRYPTO_LIBRARY"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_CALL_IN_DLL_CALLOUT: +- code_string = "FAST_FAIL_INVALID_CALL_IN_DLL_CALLOUT"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_IMAGE_BASE: +- code_string = "FAST_FAIL_INVALID_IMAGE_BASE"; +- break; +- case MD_FAST_FAIL_WIN_DLOAD_PROTECTION_FAILURE: +- code_string = "FAST_FAIL_DLOAD_PROTECTION_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_UNSAFE_EXTENSION_CALL: +- code_string = "FAST_FAIL_UNSAFE_EXTENSION_CALL"; +- break; +- case MD_FAST_FAIL_WIN_DEPRECATED_SERVICE_INVOKED: +- code_string = "FAST_FAIL_DEPRECATED_SERVICE_INVOKED"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_BUFFER_ACCESS: +- code_string = "FAST_FAIL_INVALID_BUFFER_ACCESS"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_BALANCED_TREE: +- code_string = "FAST_FAIL_INVALID_BALANCED_TREE"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_NEXT_THREAD: +- code_string = "FAST_FAIL_INVALID_NEXT_THREAD"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_SUPPRESSED: +- code_string = "FAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSED"; +- break; +- case MD_FAST_FAIL_WIN_APCS_DISABLED: +- code_string = "FAST_FAIL_APCS_DISABLED"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_IDLE_STATE: +- code_string = "FAST_FAIL_INVALID_IDLE_STATE"; +- break; +- case MD_FAST_FAIL_WIN_MRDATA_PROTECTION_FAILURE: +- code_string = "FAST_FAIL_MRDATA_PROTECTION_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_UNEXPECTED_HEAP_EXCEPTION: +- code_string = "FAST_FAIL_UNEXPECTED_HEAP_EXCEPTION"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_LOCK_STATE: +- code_string = "FAST_FAIL_INVALID_LOCK_STATE"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_JUMPTABLE: +- code_string = "FAST_FAIL_GUARD_JUMPTABLE"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_LONGJUMP_TARGET: +- code_string = "FAST_FAIL_INVALID_LONGJUMP_TARGET"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_DISPATCH_CONTEXT: +- code_string = "FAST_FAIL_INVALID_DISPATCH_CONTEXT"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_THREAD: +- code_string = "FAST_FAIL_INVALID_THREAD"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_SYSCALL_NUMBER: +- code_string = "FAST_FAIL_INVALID_SYSCALL_NUMBER"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_FILE_OPERATION: +- code_string = "FAST_FAIL_INVALID_FILE_OPERATION"; +- break; +- case MD_FAST_FAIL_WIN_LPAC_ACCESS_DENIED: +- code_string = "FAST_FAIL_LPAC_ACCESS_DENIED"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_SS_FAILURE: +- code_string = "FAST_FAIL_GUARD_SS_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_LOADER_CONTINUITY_FAILURE: +- code_string = "FAST_FAIL_LOADER_CONTINUITY_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_GUARD_EXPORT_SUPPRESSION_FAILURE: +- code_string = "FAST_FAIL_GUARD_EXPORT_SUPPRESSION_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_CONTROL_STACK: +- code_string = "FAST_FAIL_INVALID_CONTROL_STACK"; +- break; +- case MD_FAST_FAIL_WIN_SET_CONTEXT_DENIED: +- code_string = "FAST_FAIL_SET_CONTEXT_DENIED"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_IAT: +- code_string = "FAST_FAIL_INVALID_IAT"; +- break; +- case MD_FAST_FAIL_WIN_HEAP_METADATA_CORRUPTION: +- code_string = "FAST_FAIL_HEAP_METADATA_CORRUPTION"; +- break; +- case MD_FAST_FAIL_WIN_PAYLOAD_RESTRICTION_VIOLATION: +- code_string = "FAST_FAIL_PAYLOAD_RESTRICTION_VIOLATION"; +- break; +- case MD_FAST_FAIL_WIN_LOW_LABEL_ACCESS_DENIED: +- code_string = "FAST_FAIL_LOW_LABEL_ACCESS_DENIED"; +- break; +- case MD_FAST_FAIL_WIN_ENCLAVE_CALL_FAILURE: +- code_string = "FAST_FAIL_ENCLAVE_CALL_FAILURE"; +- break; +- case MD_FAST_FAIL_WIN_UNHANDLED_LSS_EXCEPTON: +- code_string = "FAST_FAIL_UNHANDLED_LSS_EXCEPTON"; +- break; +- case MD_FAST_FAIL_WIN_ADMINLESS_ACCESS_DENIED: +- code_string = "FAST_FAIL_ADMINLESS_ACCESS_DENIED"; +- break; +- case MD_FAST_FAIL_WIN_UNEXPECTED_CALL: +- code_string = "FAST_FAIL_UNEXPECTED_CALL"; +- break; +- case MD_FAST_FAIL_WIN_CONTROL_INVALID_RETURN_ADDRESS: +- code_string = "FAST_FAIL_CONTROL_INVALID_RETURN_ADDRESS"; +- break; +- case MD_FAST_FAIL_WIN_UNEXPECTED_HOST_BEHAVIOR: +- code_string = "FAST_FAIL_UNEXPECTED_HOST_BEHAVIOR"; +- break; +- case MD_FAST_FAIL_WIN_FLAGS_CORRUPTION: +- code_string = "FAST_FAIL_FLAGS_CORRUPTION"; +- break; +- case MD_FAST_FAIL_WIN_VEH_CORRUPTION: +- code_string = "FAST_FAIL_VEH_CORRUPTION"; +- break; +- case MD_FAST_FAIL_WIN_ETW_CORRUPTION: +- code_string = "FAST_FAIL_ETW_CORRUPTION"; +- break; +- case MD_FAST_FAIL_WIN_RIO_ABORT: +- code_string = "FAST_FAIL_RIO_ABORT"; +- break; +- case MD_FAST_FAIL_WIN_INVALID_PFN: +- code_string = "FAST_FAIL_INVALID_PFN"; +- break; +- default: { +- char buffer[11]; +- snprintf(buffer, sizeof(buffer), "%u", fast_fail_code); +- code_string = buffer; +- break; +- } ++// The content of this array was created from winnt.h in the 10 SDK ++// (version 10.0.19041.0) with the following script: ++// ++// egrep '#define FAST_FAIL_[A-Z_0-9]+\s+[0-9]' winnt.h ++// | tr -d '\r' ++// | sed -r 's@#define FAST_FAIL_([A-Z_0-9]+)\s+([0-9]+).*@\2 \1@' ++// | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ MD_FAST_FAIL_WIN_\2,@' ++// | head -n -1 ++static const uint8_t kFastFailValues[] = { ++ MD_FAST_FAIL_WIN_LEGACY_GS_VIOLATION, ++ MD_FAST_FAIL_WIN_VTGUARD_CHECK_FAILURE, ++ MD_FAST_FAIL_WIN_STACK_COOKIE_CHECK_FAILURE, ++ MD_FAST_FAIL_WIN_CORRUPT_LIST_ENTRY, ++ MD_FAST_FAIL_WIN_INCORRECT_STACK, ++ MD_FAST_FAIL_WIN_INVALID_ARG, ++ MD_FAST_FAIL_WIN_GS_COOKIE_INIT, ++ MD_FAST_FAIL_WIN_FATAL_APP_EXIT, ++ MD_FAST_FAIL_WIN_RANGE_CHECK_FAILURE, ++ MD_FAST_FAIL_WIN_UNSAFE_REGISTRY_ACCESS, ++ MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_FAILURE, ++ MD_FAST_FAIL_WIN_GUARD_WRITE_CHECK_FAILURE, ++ MD_FAST_FAIL_WIN_INVALID_FIBER_SWITCH, ++ MD_FAST_FAIL_WIN_INVALID_SET_OF_CONTEXT, ++ MD_FAST_FAIL_WIN_INVALID_REFERENCE_COUNT, ++ MD_FAST_FAIL_WIN_INVALID_JUMP_BUFFER, ++ MD_FAST_FAIL_WIN_MRDATA_MODIFIED, ++ MD_FAST_FAIL_WIN_CERTIFICATION_FAILURE, ++ MD_FAST_FAIL_WIN_INVALID_EXCEPTION_CHAIN, ++ MD_FAST_FAIL_WIN_CRYPTO_LIBRARY, ++ MD_FAST_FAIL_WIN_INVALID_CALL_IN_DLL_CALLOUT, ++ MD_FAST_FAIL_WIN_INVALID_IMAGE_BASE, ++ MD_FAST_FAIL_WIN_DLOAD_PROTECTION_FAILURE, ++ MD_FAST_FAIL_WIN_UNSAFE_EXTENSION_CALL, ++ MD_FAST_FAIL_WIN_DEPRECATED_SERVICE_INVOKED, ++ MD_FAST_FAIL_WIN_INVALID_BUFFER_ACCESS, ++ MD_FAST_FAIL_WIN_INVALID_BALANCED_TREE, ++ MD_FAST_FAIL_WIN_INVALID_NEXT_THREAD, ++ MD_FAST_FAIL_WIN_GUARD_ICALL_CHECK_SUPPRESSED, ++ MD_FAST_FAIL_WIN_APCS_DISABLED, ++ MD_FAST_FAIL_WIN_INVALID_IDLE_STATE, ++ MD_FAST_FAIL_WIN_MRDATA_PROTECTION_FAILURE, ++ MD_FAST_FAIL_WIN_UNEXPECTED_HEAP_EXCEPTION, ++ MD_FAST_FAIL_WIN_INVALID_LOCK_STATE, ++ MD_FAST_FAIL_WIN_GUARD_JUMPTABLE, ++ MD_FAST_FAIL_WIN_INVALID_LONGJUMP_TARGET, ++ MD_FAST_FAIL_WIN_INVALID_DISPATCH_CONTEXT, ++ MD_FAST_FAIL_WIN_INVALID_THREAD, ++ MD_FAST_FAIL_WIN_INVALID_SYSCALL_NUMBER, ++ MD_FAST_FAIL_WIN_INVALID_FILE_OPERATION, ++ MD_FAST_FAIL_WIN_LPAC_ACCESS_DENIED, ++ MD_FAST_FAIL_WIN_GUARD_SS_FAILURE, ++ MD_FAST_FAIL_WIN_LOADER_CONTINUITY_FAILURE, ++ MD_FAST_FAIL_WIN_GUARD_EXPORT_SUPPRESSION_FAILURE, ++ MD_FAST_FAIL_WIN_INVALID_CONTROL_STACK, ++ MD_FAST_FAIL_WIN_SET_CONTEXT_DENIED, ++ MD_FAST_FAIL_WIN_INVALID_IAT, ++ MD_FAST_FAIL_WIN_HEAP_METADATA_CORRUPTION, ++ MD_FAST_FAIL_WIN_PAYLOAD_RESTRICTION_VIOLATION, ++ MD_FAST_FAIL_WIN_LOW_LABEL_ACCESS_DENIED, ++ MD_FAST_FAIL_WIN_ENCLAVE_CALL_FAILURE, ++ MD_FAST_FAIL_WIN_UNHANDLED_LSS_EXCEPTON, ++ MD_FAST_FAIL_WIN_ADMINLESS_ACCESS_DENIED, ++ MD_FAST_FAIL_WIN_UNEXPECTED_CALL, ++ MD_FAST_FAIL_WIN_CONTROL_INVALID_RETURN_ADDRESS, ++ MD_FAST_FAIL_WIN_UNEXPECTED_HOST_BEHAVIOR, ++ MD_FAST_FAIL_WIN_FLAGS_CORRUPTION, ++ MD_FAST_FAIL_WIN_VEH_CORRUPTION, ++ MD_FAST_FAIL_WIN_ETW_CORRUPTION, ++ MD_FAST_FAIL_WIN_RIO_ABORT, ++ MD_FAST_FAIL_WIN_INVALID_PFN, ++}; ++ ++// The content of this array was created from winnt.h in the 10 SDK ++// (version 10.0.19041.0) with the following script: ++// ++// egrep '#define FAST_FAIL_[A-Z_0-9]+\s+[0-9]' winnt.h ++// | tr -d '\r' ++// | sed -r 's@#define FAST_FAIL_([A-Z_0-9]+)\s+([0-9]+).*@\2 \1@' ++// | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ "FAST_FAIL_\2",@' ++// | head -n -1 ++static const char* kFastFailStrings[] = { ++ "FAST_FAIL_LEGACY_GS_VIOLATION", ++ "FAST_FAIL_VTGUARD_CHECK_FAILURE", ++ "FAST_FAIL_STACK_COOKIE_CHECK_FAILURE", ++ "FAST_FAIL_CORRUPT_LIST_ENTRY", ++ "FAST_FAIL_INCORRECT_STACK", ++ "FAST_FAIL_INVALID_ARG", ++ "FAST_FAIL_GS_COOKIE_INIT", ++ "FAST_FAIL_FATAL_APP_EXIT", ++ "FAST_FAIL_RANGE_CHECK_FAILURE", ++ "FAST_FAIL_UNSAFE_REGISTRY_ACCESS", ++ "FAST_FAIL_GUARD_ICALL_CHECK_FAILURE", ++ "FAST_FAIL_GUARD_WRITE_CHECK_FAILURE", ++ "FAST_FAIL_INVALID_FIBER_SWITCH", ++ "FAST_FAIL_INVALID_SET_OF_CONTEXT", ++ "FAST_FAIL_INVALID_REFERENCE_COUNT", ++ "FAST_FAIL_INVALID_JUMP_BUFFER", ++ "FAST_FAIL_MRDATA_MODIFIED", ++ "FAST_FAIL_CERTIFICATION_FAILURE", ++ "FAST_FAIL_INVALID_EXCEPTION_CHAIN", ++ "FAST_FAIL_CRYPTO_LIBRARY", ++ "FAST_FAIL_INVALID_CALL_IN_DLL_CALLOUT", ++ "FAST_FAIL_INVALID_IMAGE_BASE", ++ "FAST_FAIL_DLOAD_PROTECTION_FAILURE", ++ "FAST_FAIL_UNSAFE_EXTENSION_CALL", ++ "FAST_FAIL_DEPRECATED_SERVICE_INVOKED", ++ "FAST_FAIL_INVALID_BUFFER_ACCESS", ++ "FAST_FAIL_INVALID_BALANCED_TREE", ++ "FAST_FAIL_INVALID_NEXT_THREAD", ++ "FAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSED", ++ "FAST_FAIL_APCS_DISABLED", ++ "FAST_FAIL_INVALID_IDLE_STATE", ++ "FAST_FAIL_MRDATA_PROTECTION_FAILURE", ++ "FAST_FAIL_UNEXPECTED_HEAP_EXCEPTION", ++ "FAST_FAIL_INVALID_LOCK_STATE", ++ "FAST_FAIL_GUARD_JUMPTABLE", ++ "FAST_FAIL_INVALID_LONGJUMP_TARGET", ++ "FAST_FAIL_INVALID_DISPATCH_CONTEXT", ++ "FAST_FAIL_INVALID_THREAD", ++ "FAST_FAIL_INVALID_SYSCALL_NUMBER", ++ "FAST_FAIL_INVALID_FILE_OPERATION", ++ "FAST_FAIL_LPAC_ACCESS_DENIED", ++ "FAST_FAIL_GUARD_SS_FAILURE", ++ "FAST_FAIL_LOADER_CONTINUITY_FAILURE", ++ "FAST_FAIL_GUARD_EXPORT_SUPPRESSION_FAILURE", ++ "FAST_FAIL_INVALID_CONTROL_STACK", ++ "FAST_FAIL_SET_CONTEXT_DENIED", ++ "FAST_FAIL_INVALID_IAT", ++ "FAST_FAIL_HEAP_METADATA_CORRUPTION", ++ "FAST_FAIL_PAYLOAD_RESTRICTION_VIOLATION", ++ "FAST_FAIL_LOW_LABEL_ACCESS_DENIED", ++ "FAST_FAIL_ENCLAVE_CALL_FAILURE", ++ "FAST_FAIL_UNHANDLED_LSS_EXCEPTON", ++ "FAST_FAIL_ADMINLESS_ACCESS_DENIED", ++ "FAST_FAIL_UNEXPECTED_CALL", ++ "FAST_FAIL_CONTROL_INVALID_RETURN_ADDRESS", ++ "FAST_FAIL_UNEXPECTED_HOST_BEHAVIOR", ++ "FAST_FAIL_FLAGS_CORRUPTION", ++ "FAST_FAIL_VEH_CORRUPTION", ++ "FAST_FAIL_ETW_CORRUPTION", ++ "FAST_FAIL_RIO_ABORT", ++ "FAST_FAIL_INVALID_PFN", ++}; ++ ++const char* FastFailToString(uint32_t fast_fail_code) { ++ auto itr = std::find(std::begin(kFastFailValues), ++ std::end(kFastFailValues), ++ fast_fail_code); ++ if (itr == std::end(kFastFailValues)) { ++ return nullptr; + } +- return code_string; ++ ++ return kFastFailStrings[itr - std::begin(kFastFailValues)]; ++} ++ ++// The content of this array was created from winerror.h in the 10 SDK ++// (version 10.0.19041.0) with the following script: ++// ++// egrep -o '#define ERROR_[A-Z_0-9]+\s+[0-9]+L' winerror.h ++// | tr -d '\r' ++// | sed -r 's@#define ERROR_([A-Z_0-9]+)\s+([0-9]+)L@\2 \1@' ++// | sort -n ++// | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ MD_ERROR_WIN_\2,@' ++static const uint16_t kWinErrorValues[] = { ++ MD_ERROR_WIN_SUCCESS, ++ MD_ERROR_WIN_INVALID_FUNCTION, ++ MD_ERROR_WIN_FILE_NOT_FOUND, ++ MD_ERROR_WIN_PATH_NOT_FOUND, ++ MD_ERROR_WIN_TOO_MANY_OPEN_FILES, ++ MD_ERROR_WIN_ACCESS_DENIED, ++ MD_ERROR_WIN_INVALID_HANDLE, ++ MD_ERROR_WIN_ARENA_TRASHED, ++ MD_ERROR_WIN_NOT_ENOUGH_MEMORY, ++ MD_ERROR_WIN_INVALID_BLOCK, ++ MD_ERROR_WIN_BAD_ENVIRONMENT, ++ MD_ERROR_WIN_BAD_FORMAT, ++ MD_ERROR_WIN_INVALID_ACCESS, ++ MD_ERROR_WIN_INVALID_DATA, ++ MD_ERROR_WIN_OUTOFMEMORY, ++ MD_ERROR_WIN_INVALID_DRIVE, ++ MD_ERROR_WIN_CURRENT_DIRECTORY, ++ MD_ERROR_WIN_NOT_SAME_DEVICE, ++ MD_ERROR_WIN_NO_MORE_FILES, ++ MD_ERROR_WIN_WRITE_PROTECT, ++ MD_ERROR_WIN_BAD_UNIT, ++ MD_ERROR_WIN_NOT_READY, ++ MD_ERROR_WIN_BAD_COMMAND, ++ MD_ERROR_WIN_CRC, ++ MD_ERROR_WIN_BAD_LENGTH, ++ MD_ERROR_WIN_SEEK, ++ MD_ERROR_WIN_NOT_DOS_DISK, ++ MD_ERROR_WIN_SECTOR_NOT_FOUND, ++ MD_ERROR_WIN_OUT_OF_PAPER, ++ MD_ERROR_WIN_WRITE_FAULT, ++ MD_ERROR_WIN_READ_FAULT, ++ MD_ERROR_WIN_GEN_FAILURE, ++ MD_ERROR_WIN_SHARING_VIOLATION, ++ MD_ERROR_WIN_LOCK_VIOLATION, ++ MD_ERROR_WIN_WRONG_DISK, ++ MD_ERROR_WIN_SHARING_BUFFER_EXCEEDED, ++ MD_ERROR_WIN_HANDLE_EOF, ++ MD_ERROR_WIN_HANDLE_DISK_FULL, ++ MD_ERROR_WIN_NOT_SUPPORTED, ++ MD_ERROR_WIN_REM_NOT_LIST, ++ MD_ERROR_WIN_DUP_NAME, ++ MD_ERROR_WIN_BAD_NETPATH, ++ MD_ERROR_WIN_NETWORK_BUSY, ++ MD_ERROR_WIN_DEV_NOT_EXIST, ++ MD_ERROR_WIN_TOO_MANY_CMDS, ++ MD_ERROR_WIN_ADAP_HDW_ERR, ++ MD_ERROR_WIN_BAD_NET_RESP, ++ MD_ERROR_WIN_UNEXP_NET_ERR, ++ MD_ERROR_WIN_BAD_REM_ADAP, ++ MD_ERROR_WIN_PRINTQ_FULL, ++ MD_ERROR_WIN_NO_SPOOL_SPACE, ++ MD_ERROR_WIN_PRINT_CANCELLED, ++ MD_ERROR_WIN_NETNAME_DELETED, ++ MD_ERROR_WIN_NETWORK_ACCESS_DENIED, ++ MD_ERROR_WIN_BAD_DEV_TYPE, ++ MD_ERROR_WIN_BAD_NET_NAME, ++ MD_ERROR_WIN_TOO_MANY_NAMES, ++ MD_ERROR_WIN_TOO_MANY_SESS, ++ MD_ERROR_WIN_SHARING_PAUSED, ++ MD_ERROR_WIN_REQ_NOT_ACCEP, ++ MD_ERROR_WIN_REDIR_PAUSED, ++ MD_ERROR_WIN_FILE_EXISTS, ++ MD_ERROR_WIN_CANNOT_MAKE, ++ MD_ERROR_WIN_FAIL_I24, ++ MD_ERROR_WIN_OUT_OF_STRUCTURES, ++ MD_ERROR_WIN_ALREADY_ASSIGNED, ++ MD_ERROR_WIN_INVALID_PASSWORD, ++ MD_ERROR_WIN_INVALID_PARAMETER, ++ MD_ERROR_WIN_NET_WRITE_FAULT, ++ MD_ERROR_WIN_NO_PROC_SLOTS, ++ MD_ERROR_WIN_TOO_MANY_SEMAPHORES, ++ MD_ERROR_WIN_EXCL_SEM_ALREADY_OWNED, ++ MD_ERROR_WIN_SEM_IS_SET, ++ MD_ERROR_WIN_TOO_MANY_SEM_REQUESTS, ++ MD_ERROR_WIN_INVALID_AT_INTERRUPT_TIME, ++ MD_ERROR_WIN_SEM_OWNER_DIED, ++ MD_ERROR_WIN_SEM_USER_LIMIT, ++ MD_ERROR_WIN_DISK_CHANGE, ++ MD_ERROR_WIN_DRIVE_LOCKED, ++ MD_ERROR_WIN_BROKEN_PIPE, ++ MD_ERROR_WIN_OPEN_FAILED, ++ MD_ERROR_WIN_BUFFER_OVERFLOW, ++ MD_ERROR_WIN_DISK_FULL, ++ MD_ERROR_WIN_NO_MORE_SEARCH_HANDLES, ++ MD_ERROR_WIN_INVALID_TARGET_HANDLE, ++ MD_ERROR_WIN_INVALID_CATEGORY, ++ MD_ERROR_WIN_INVALID_VERIFY_SWITCH, ++ MD_ERROR_WIN_BAD_DRIVER_LEVEL, ++ MD_ERROR_WIN_CALL_NOT_IMPLEMENTED, ++ MD_ERROR_WIN_SEM_TIMEOUT, ++ MD_ERROR_WIN_INSUFFICIENT_BUFFER, ++ MD_ERROR_WIN_INVALID_NAME, ++ MD_ERROR_WIN_INVALID_LEVEL, ++ MD_ERROR_WIN_NO_VOLUME_LABEL, ++ MD_ERROR_WIN_MOD_NOT_FOUND, ++ MD_ERROR_WIN_PROC_NOT_FOUND, ++ MD_ERROR_WIN_WAIT_NO_CHILDREN, ++ MD_ERROR_WIN_CHILD_NOT_COMPLETE, ++ MD_ERROR_WIN_DIRECT_ACCESS_HANDLE, ++ MD_ERROR_WIN_NEGATIVE_SEEK, ++ MD_ERROR_WIN_SEEK_ON_DEVICE, ++ MD_ERROR_WIN_IS_JOIN_TARGET, ++ MD_ERROR_WIN_IS_JOINED, ++ MD_ERROR_WIN_IS_SUBSTED, ++ MD_ERROR_WIN_NOT_JOINED, ++ MD_ERROR_WIN_NOT_SUBSTED, ++ MD_ERROR_WIN_JOIN_TO_JOIN, ++ MD_ERROR_WIN_SUBST_TO_SUBST, ++ MD_ERROR_WIN_JOIN_TO_SUBST, ++ MD_ERROR_WIN_SUBST_TO_JOIN, ++ MD_ERROR_WIN_BUSY_DRIVE, ++ MD_ERROR_WIN_SAME_DRIVE, ++ MD_ERROR_WIN_DIR_NOT_ROOT, ++ MD_ERROR_WIN_DIR_NOT_EMPTY, ++ MD_ERROR_WIN_IS_SUBST_PATH, ++ MD_ERROR_WIN_IS_JOIN_PATH, ++ MD_ERROR_WIN_PATH_BUSY, ++ MD_ERROR_WIN_IS_SUBST_TARGET, ++ MD_ERROR_WIN_SYSTEM_TRACE, ++ MD_ERROR_WIN_INVALID_EVENT_COUNT, ++ MD_ERROR_WIN_TOO_MANY_MUXWAITERS, ++ MD_ERROR_WIN_INVALID_LIST_FORMAT, ++ MD_ERROR_WIN_LABEL_TOO_LONG, ++ MD_ERROR_WIN_TOO_MANY_TCBS, ++ MD_ERROR_WIN_SIGNAL_REFUSED, ++ MD_ERROR_WIN_DISCARDED, ++ MD_ERROR_WIN_NOT_LOCKED, ++ MD_ERROR_WIN_BAD_THREADID_ADDR, ++ MD_ERROR_WIN_BAD_ARGUMENTS, ++ MD_ERROR_WIN_BAD_PATHNAME, ++ MD_ERROR_WIN_SIGNAL_PENDING, ++ MD_ERROR_WIN_MAX_THRDS_REACHED, ++ MD_ERROR_WIN_LOCK_FAILED, ++ MD_ERROR_WIN_BUSY, ++ MD_ERROR_WIN_DEVICE_SUPPORT_IN_PROGRESS, ++ MD_ERROR_WIN_CANCEL_VIOLATION, ++ MD_ERROR_WIN_ATOMIC_LOCKS_NOT_SUPPORTED, ++ MD_ERROR_WIN_INVALID_SEGMENT_NUMBER, ++ MD_ERROR_WIN_INVALID_ORDINAL, ++ MD_ERROR_WIN_ALREADY_EXISTS, ++ MD_ERROR_WIN_INVALID_FLAG_NUMBER, ++ MD_ERROR_WIN_SEM_NOT_FOUND, ++ MD_ERROR_WIN_INVALID_STARTING_CODESEG, ++ MD_ERROR_WIN_INVALID_STACKSEG, ++ MD_ERROR_WIN_INVALID_MODULETYPE, ++ MD_ERROR_WIN_INVALID_EXE_SIGNATURE, ++ MD_ERROR_WIN_EXE_MARKED_INVALID, ++ MD_ERROR_WIN_BAD_EXE_FORMAT, ++ MD_ERROR_WIN_INVALID_MINALLOCSIZE, ++ MD_ERROR_WIN_DYNLINK_FROM_INVALID_RING, ++ MD_ERROR_WIN_IOPL_NOT_ENABLED, ++ MD_ERROR_WIN_INVALID_SEGDPL, ++ MD_ERROR_WIN_RING2SEG_MUST_BE_MOVABLE, ++ MD_ERROR_WIN_RELOC_CHAIN_XEEDS_SEGLIM, ++ MD_ERROR_WIN_INFLOOP_IN_RELOC_CHAIN, ++ MD_ERROR_WIN_ENVVAR_NOT_FOUND, ++ MD_ERROR_WIN_NO_SIGNAL_SENT, ++ MD_ERROR_WIN_FILENAME_EXCED_RANGE, ++ MD_ERROR_WIN_RING2_STACK_IN_USE, ++ MD_ERROR_WIN_META_EXPANSION_TOO_LONG, ++ MD_ERROR_WIN_INVALID_SIGNAL_NUMBER, ++ MD_ERROR_WIN_THREAD_1_INACTIVE, ++ MD_ERROR_WIN_LOCKED, ++ MD_ERROR_WIN_TOO_MANY_MODULES, ++ MD_ERROR_WIN_NESTING_NOT_ALLOWED, ++ MD_ERROR_WIN_EXE_MACHINE_TYPE_MISMATCH, ++ MD_ERROR_WIN_EXE_CANNOT_MODIFY_SIGNED_BINARY, ++ MD_ERROR_WIN_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY, ++ MD_ERROR_WIN_FILE_CHECKED_OUT, ++ MD_ERROR_WIN_CHECKOUT_REQUIRED, ++ MD_ERROR_WIN_BAD_FILE_TYPE, ++ MD_ERROR_WIN_FILE_TOO_LARGE, ++ MD_ERROR_WIN_FORMS_AUTH_REQUIRED, ++ MD_ERROR_WIN_VIRUS_INFECTED, ++ MD_ERROR_WIN_VIRUS_DELETED, ++ MD_ERROR_WIN_PIPE_LOCAL, ++ MD_ERROR_WIN_BAD_PIPE, ++ MD_ERROR_WIN_PIPE_BUSY, ++ MD_ERROR_WIN_NO_DATA, ++ MD_ERROR_WIN_PIPE_NOT_CONNECTED, ++ MD_ERROR_WIN_MORE_DATA, ++ MD_ERROR_WIN_NO_WORK_DONE, ++ MD_ERROR_WIN_VC_DISCONNECTED, ++ MD_ERROR_WIN_INVALID_EA_NAME, ++ MD_ERROR_WIN_EA_LIST_INCONSISTENT, ++ MD_ERROR_WIN_NO_MORE_ITEMS, ++ MD_ERROR_WIN_CANNOT_COPY, ++ MD_ERROR_WIN_DIRECTORY, ++ MD_ERROR_WIN_EAS_DIDNT_FIT, ++ MD_ERROR_WIN_EA_FILE_CORRUPT, ++ MD_ERROR_WIN_EA_TABLE_FULL, ++ MD_ERROR_WIN_INVALID_EA_HANDLE, ++ MD_ERROR_WIN_EAS_NOT_SUPPORTED, ++ MD_ERROR_WIN_NOT_OWNER, ++ MD_ERROR_WIN_TOO_MANY_POSTS, ++ MD_ERROR_WIN_PARTIAL_COPY, ++ MD_ERROR_WIN_OPLOCK_NOT_GRANTED, ++ MD_ERROR_WIN_INVALID_OPLOCK_PROTOCOL, ++ MD_ERROR_WIN_DISK_TOO_FRAGMENTED, ++ MD_ERROR_WIN_DELETE_PENDING, ++ MD_ERROR_WIN_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING, ++ MD_ERROR_WIN_SHORT_NAMES_NOT_ENABLED_ON_VOLUME, ++ MD_ERROR_WIN_SECURITY_STREAM_IS_INCONSISTENT, ++ MD_ERROR_WIN_INVALID_LOCK_RANGE, ++ MD_ERROR_WIN_IMAGE_SUBSYSTEM_NOT_PRESENT, ++ MD_ERROR_WIN_NOTIFICATION_GUID_ALREADY_DEFINED, ++ MD_ERROR_WIN_INVALID_EXCEPTION_HANDLER, ++ MD_ERROR_WIN_DUPLICATE_PRIVILEGES, ++ MD_ERROR_WIN_NO_RANGES_PROCESSED, ++ MD_ERROR_WIN_NOT_ALLOWED_ON_SYSTEM_FILE, ++ MD_ERROR_WIN_DISK_RESOURCES_EXHAUSTED, ++ MD_ERROR_WIN_INVALID_TOKEN, ++ MD_ERROR_WIN_DEVICE_FEATURE_NOT_SUPPORTED, ++ MD_ERROR_WIN_MR_MID_NOT_FOUND, ++ MD_ERROR_WIN_SCOPE_NOT_FOUND, ++ MD_ERROR_WIN_UNDEFINED_SCOPE, ++ MD_ERROR_WIN_INVALID_CAP, ++ MD_ERROR_WIN_DEVICE_UNREACHABLE, ++ MD_ERROR_WIN_DEVICE_NO_RESOURCES, ++ MD_ERROR_WIN_DATA_CHECKSUM_ERROR, ++ MD_ERROR_WIN_INTERMIXED_KERNEL_EA_OPERATION, ++ MD_ERROR_WIN_FILE_LEVEL_TRIM_NOT_SUPPORTED, ++ MD_ERROR_WIN_OFFSET_ALIGNMENT_VIOLATION, ++ MD_ERROR_WIN_INVALID_FIELD_IN_PARAMETER_LIST, ++ MD_ERROR_WIN_OPERATION_IN_PROGRESS, ++ MD_ERROR_WIN_BAD_DEVICE_PATH, ++ MD_ERROR_WIN_TOO_MANY_DESCRIPTORS, ++ MD_ERROR_WIN_SCRUB_DATA_DISABLED, ++ MD_ERROR_WIN_NOT_REDUNDANT_STORAGE, ++ MD_ERROR_WIN_RESIDENT_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_COMPRESSED_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_DIRECTORY_NOT_SUPPORTED, ++ MD_ERROR_WIN_NOT_READ_FROM_COPY, ++ MD_ERROR_WIN_FT_WRITE_FAILURE, ++ MD_ERROR_WIN_FT_DI_SCAN_REQUIRED, ++ MD_ERROR_WIN_INVALID_KERNEL_INFO_VERSION, ++ MD_ERROR_WIN_INVALID_PEP_INFO_VERSION, ++ MD_ERROR_WIN_OBJECT_NOT_EXTERNALLY_BACKED, ++ MD_ERROR_WIN_EXTERNAL_BACKING_PROVIDER_UNKNOWN, ++ MD_ERROR_WIN_COMPRESSION_NOT_BENEFICIAL, ++ MD_ERROR_WIN_STORAGE_TOPOLOGY_ID_MISMATCH, ++ MD_ERROR_WIN_BLOCKED_BY_PARENTAL_CONTROLS, ++ MD_ERROR_WIN_BLOCK_TOO_MANY_REFERENCES, ++ MD_ERROR_WIN_MARKED_TO_DISALLOW_WRITES, ++ MD_ERROR_WIN_ENCLAVE_FAILURE, ++ MD_ERROR_WIN_FAIL_NOACTION_REBOOT, ++ MD_ERROR_WIN_FAIL_SHUTDOWN, ++ MD_ERROR_WIN_FAIL_RESTART, ++ MD_ERROR_WIN_MAX_SESSIONS_REACHED, ++ MD_ERROR_WIN_NETWORK_ACCESS_DENIED_EDP, ++ MD_ERROR_WIN_DEVICE_HINT_NAME_BUFFER_TOO_SMALL, ++ MD_ERROR_WIN_EDP_POLICY_DENIES_OPERATION, ++ MD_ERROR_WIN_EDP_DPL_POLICY_CANT_BE_SATISFIED, ++ MD_ERROR_WIN_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT, ++ MD_ERROR_WIN_DEVICE_IN_MAINTENANCE, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_DAX, ++ MD_ERROR_WIN_DAX_MAPPING_EXISTS, ++ MD_ERROR_WIN_CLOUD_FILE_PROVIDER_NOT_RUNNING, ++ MD_ERROR_WIN_CLOUD_FILE_METADATA_CORRUPT, ++ MD_ERROR_WIN_CLOUD_FILE_METADATA_TOO_LARGE, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH, ++ MD_ERROR_WIN_CHILD_PROCESS_BLOCKED, ++ MD_ERROR_WIN_STORAGE_LOST_DATA_PERSISTENCE, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_BUSY, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN, ++ MD_ERROR_WIN_GDI_HANDLE_LEAK, ++ MD_ERROR_WIN_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED, ++ MD_ERROR_WIN_NOT_A_CLOUD_FILE, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_IN_SYNC, ++ MD_ERROR_WIN_CLOUD_FILE_ALREADY_CONNECTED, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLOUD_FILE_INVALID_REQUEST, ++ MD_ERROR_WIN_CLOUD_FILE_READ_ONLY_VOLUME, ++ MD_ERROR_WIN_CLOUD_FILE_CONNECTED_PROVIDER_ONLY, ++ MD_ERROR_WIN_CLOUD_FILE_VALIDATION_FAILED, ++ MD_ERROR_WIN_SMB1_NOT_AVAILABLE, ++ MD_ERROR_WIN_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION, ++ MD_ERROR_WIN_CLOUD_FILE_AUTHENTICATION_FAILED, ++ MD_ERROR_WIN_CLOUD_FILE_INSUFFICIENT_RESOURCES, ++ MD_ERROR_WIN_CLOUD_FILE_NETWORK_UNAVAILABLE, ++ MD_ERROR_WIN_CLOUD_FILE_UNSUCCESSFUL, ++ MD_ERROR_WIN_CLOUD_FILE_NOT_UNDER_SYNC_ROOT, ++ MD_ERROR_WIN_CLOUD_FILE_IN_USE, ++ MD_ERROR_WIN_CLOUD_FILE_PINNED, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_ABORTED, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_CORRUPT, ++ MD_ERROR_WIN_CLOUD_FILE_ACCESS_DENIED, ++ MD_ERROR_WIN_CLOUD_FILE_INCOMPATIBLE_HARDLINKS, ++ MD_ERROR_WIN_CLOUD_FILE_PROPERTY_LOCK_CONFLICT, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_CANCELED, ++ MD_ERROR_WIN_EXTERNAL_SYSKEY_NOT_SUPPORTED, ++ MD_ERROR_WIN_THREAD_MODE_ALREADY_BACKGROUND, ++ MD_ERROR_WIN_THREAD_MODE_NOT_BACKGROUND, ++ MD_ERROR_WIN_PROCESS_MODE_ALREADY_BACKGROUND, ++ MD_ERROR_WIN_PROCESS_MODE_NOT_BACKGROUND, ++ MD_ERROR_WIN_CLOUD_FILE_PROVIDER_TERMINATED, ++ MD_ERROR_WIN_NOT_A_CLOUD_SYNC_ROOT, ++ MD_ERROR_WIN_FILE_PROTECTED_UNDER_DPL, ++ MD_ERROR_WIN_VOLUME_NOT_CLUSTER_ALIGNED, ++ MD_ERROR_WIN_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND, ++ MD_ERROR_WIN_APPX_FILE_NOT_ENCRYPTED, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE, ++ MD_ERROR_WIN_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER, ++ MD_ERROR_WIN_LINUX_SUBSYSTEM_NOT_PRESENT, ++ MD_ERROR_WIN_FT_READ_FAILURE, ++ MD_ERROR_WIN_STORAGE_RESERVE_ID_INVALID, ++ MD_ERROR_WIN_STORAGE_RESERVE_DOES_NOT_EXIST, ++ MD_ERROR_WIN_STORAGE_RESERVE_ALREADY_EXISTS, ++ MD_ERROR_WIN_STORAGE_RESERVE_NOT_EMPTY, ++ MD_ERROR_WIN_NOT_A_DAX_VOLUME, ++ MD_ERROR_WIN_NOT_DAX_MAPPABLE, ++ MD_ERROR_WIN_TIME_SENSITIVE_THREAD, ++ MD_ERROR_WIN_DPL_NOT_SUPPORTED_FOR_USER, ++ MD_ERROR_WIN_CASE_DIFFERING_NAMES_IN_DIR, ++ MD_ERROR_WIN_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLOUD_FILE_REQUEST_TIMEOUT, ++ MD_ERROR_WIN_NO_TASK_QUEUE, ++ MD_ERROR_WIN_SRC_SRV_DLL_LOAD_FAILED, ++ MD_ERROR_WIN_NOT_SUPPORTED_WITH_BTT, ++ MD_ERROR_WIN_ENCRYPTION_DISABLED, ++ MD_ERROR_WIN_ENCRYPTING_METADATA_DISALLOWED, ++ MD_ERROR_WIN_CANT_CLEAR_ENCRYPTION_FLAG, ++ MD_ERROR_WIN_NO_SUCH_DEVICE, ++ MD_ERROR_WIN_CLOUD_FILE_DEHYDRATION_DISALLOWED, ++ MD_ERROR_WIN_FILE_SNAP_IN_PROGRESS, ++ MD_ERROR_WIN_FILE_SNAP_USER_SECTION_NOT_SUPPORTED, ++ MD_ERROR_WIN_FILE_SNAP_MODIFY_NOT_SUPPORTED, ++ MD_ERROR_WIN_FILE_SNAP_IO_NOT_COORDINATED, ++ MD_ERROR_WIN_FILE_SNAP_UNEXPECTED_ERROR, ++ MD_ERROR_WIN_FILE_SNAP_INVALID_PARAMETER, ++ MD_ERROR_WIN_UNSATISFIED_DEPENDENCIES, ++ MD_ERROR_WIN_CASE_SENSITIVE_PATH, ++ MD_ERROR_WIN_UNEXPECTED_NTCACHEMANAGER_ERROR, ++ MD_ERROR_WIN_LINUX_SUBSYSTEM_UPDATE_REQUIRED, ++ MD_ERROR_WIN_DLP_POLICY_WARNS_AGAINST_OPERATION, ++ MD_ERROR_WIN_DLP_POLICY_DENIES_OPERATION, ++ MD_ERROR_WIN_DLP_POLICY_SILENTLY_FAIL, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_DEVUNLOCKED, ++ MD_ERROR_WIN_CAPAUTHZ_CHANGE_TYPE, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_PROVISIONED, ++ MD_ERROR_WIN_CAPAUTHZ_NOT_AUTHORIZED, ++ MD_ERROR_WIN_CAPAUTHZ_NO_POLICY, ++ MD_ERROR_WIN_CAPAUTHZ_DB_CORRUPTED, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_INVALID_CATALOG, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_NO_AUTH_ENTITY, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_PARSE_ERROR, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_DEV_MODE_REQUIRED, ++ MD_ERROR_WIN_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCH, ++ MD_ERROR_WIN_CIMFS_IMAGE_CORRUPT, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_DEVICE_TIMEOUT, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUT, ++ MD_ERROR_WIN_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUT, ++ MD_ERROR_WIN_DEVICE_HARDWARE_ERROR, ++ MD_ERROR_WIN_INVALID_ADDRESS, ++ MD_ERROR_WIN_HAS_SYSTEM_CRITICAL_FILES, ++ MD_ERROR_WIN_USER_PROFILE_LOAD, ++ MD_ERROR_WIN_ARITHMETIC_OVERFLOW, ++ MD_ERROR_WIN_PIPE_CONNECTED, ++ MD_ERROR_WIN_PIPE_LISTENING, ++ MD_ERROR_WIN_VERIFIER_STOP, ++ MD_ERROR_WIN_ABIOS_ERROR, ++ MD_ERROR_WIN_WX86_WARNING, ++ MD_ERROR_WIN_WX86_ERROR, ++ MD_ERROR_WIN_TIMER_NOT_CANCELED, ++ MD_ERROR_WIN_UNWIND, ++ MD_ERROR_WIN_BAD_STACK, ++ MD_ERROR_WIN_INVALID_UNWIND_TARGET, ++ MD_ERROR_WIN_INVALID_PORT_ATTRIBUTES, ++ MD_ERROR_WIN_PORT_MESSAGE_TOO_LONG, ++ MD_ERROR_WIN_INVALID_QUOTA_LOWER, ++ MD_ERROR_WIN_DEVICE_ALREADY_ATTACHED, ++ MD_ERROR_WIN_INSTRUCTION_MISALIGNMENT, ++ MD_ERROR_WIN_PROFILING_NOT_STARTED, ++ MD_ERROR_WIN_PROFILING_NOT_STOPPED, ++ MD_ERROR_WIN_COULD_NOT_INTERPRET, ++ MD_ERROR_WIN_PROFILING_AT_LIMIT, ++ MD_ERROR_WIN_CANT_WAIT, ++ MD_ERROR_WIN_CANT_TERMINATE_SELF, ++ MD_ERROR_WIN_UNEXPECTED_MM_CREATE_ERR, ++ MD_ERROR_WIN_UNEXPECTED_MM_MAP_ERROR, ++ MD_ERROR_WIN_UNEXPECTED_MM_EXTEND_ERR, ++ MD_ERROR_WIN_BAD_FUNCTION_TABLE, ++ MD_ERROR_WIN_NO_GUID_TRANSLATION, ++ MD_ERROR_WIN_INVALID_LDT_SIZE, ++ MD_ERROR_WIN_INVALID_LDT_OFFSET, ++ MD_ERROR_WIN_INVALID_LDT_DESCRIPTOR, ++ MD_ERROR_WIN_TOO_MANY_THREADS, ++ MD_ERROR_WIN_THREAD_NOT_IN_PROCESS, ++ MD_ERROR_WIN_PAGEFILE_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_LOGON_SERVER_CONFLICT, ++ MD_ERROR_WIN_SYNCHRONIZATION_REQUIRED, ++ MD_ERROR_WIN_NET_OPEN_FAILED, ++ MD_ERROR_WIN_IO_PRIVILEGE_FAILED, ++ MD_ERROR_WIN_CONTROL_C_EXIT, ++ MD_ERROR_WIN_MISSING_SYSTEMFILE, ++ MD_ERROR_WIN_UNHANDLED_EXCEPTION, ++ MD_ERROR_WIN_APP_INIT_FAILURE, ++ MD_ERROR_WIN_PAGEFILE_CREATE_FAILED, ++ MD_ERROR_WIN_INVALID_IMAGE_HASH, ++ MD_ERROR_WIN_NO_PAGEFILE, ++ MD_ERROR_WIN_ILLEGAL_FLOAT_CONTEXT, ++ MD_ERROR_WIN_NO_EVENT_PAIR, ++ MD_ERROR_WIN_DOMAIN_CTRLR_CONFIG_ERROR, ++ MD_ERROR_WIN_ILLEGAL_CHARACTER, ++ MD_ERROR_WIN_UNDEFINED_CHARACTER, ++ MD_ERROR_WIN_FLOPPY_VOLUME, ++ MD_ERROR_WIN_BIOS_FAILED_TO_CONNECT_INTERRUPT, ++ MD_ERROR_WIN_BACKUP_CONTROLLER, ++ MD_ERROR_WIN_MUTANT_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_FS_DRIVER_REQUIRED, ++ MD_ERROR_WIN_CANNOT_LOAD_REGISTRY_FILE, ++ MD_ERROR_WIN_DEBUG_ATTACH_FAILED, ++ MD_ERROR_WIN_SYSTEM_PROCESS_TERMINATED, ++ MD_ERROR_WIN_DATA_NOT_ACCEPTED, ++ MD_ERROR_WIN_VDM_HARD_ERROR, ++ MD_ERROR_WIN_DRIVER_CANCEL_TIMEOUT, ++ MD_ERROR_WIN_REPLY_MESSAGE_MISMATCH, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA, ++ MD_ERROR_WIN_CLIENT_SERVER_PARAMETERS_INVALID, ++ MD_ERROR_WIN_NOT_TINY_STREAM, ++ MD_ERROR_WIN_STACK_OVERFLOW_READ, ++ MD_ERROR_WIN_CONVERT_TO_LARGE, ++ MD_ERROR_WIN_FOUND_OUT_OF_SCOPE, ++ MD_ERROR_WIN_ALLOCATE_BUCKET, ++ MD_ERROR_WIN_MARSHALL_OVERFLOW, ++ MD_ERROR_WIN_INVALID_VARIANT, ++ MD_ERROR_WIN_BAD_COMPRESSION_BUFFER, ++ MD_ERROR_WIN_AUDIT_FAILED, ++ MD_ERROR_WIN_TIMER_RESOLUTION_NOT_SET, ++ MD_ERROR_WIN_INSUFFICIENT_LOGON_INFO, ++ MD_ERROR_WIN_BAD_DLL_ENTRYPOINT, ++ MD_ERROR_WIN_BAD_SERVICE_ENTRYPOINT, ++ MD_ERROR_WIN_IP_ADDRESS_CONFLICT1, ++ MD_ERROR_WIN_IP_ADDRESS_CONFLICT2, ++ MD_ERROR_WIN_REGISTRY_QUOTA_LIMIT, ++ MD_ERROR_WIN_NO_CALLBACK_ACTIVE, ++ MD_ERROR_WIN_PWD_TOO_SHORT, ++ MD_ERROR_WIN_PWD_TOO_RECENT, ++ MD_ERROR_WIN_PWD_HISTORY_CONFLICT, ++ MD_ERROR_WIN_UNSUPPORTED_COMPRESSION, ++ MD_ERROR_WIN_INVALID_HW_PROFILE, ++ MD_ERROR_WIN_INVALID_PLUGPLAY_DEVICE_PATH, ++ MD_ERROR_WIN_QUOTA_LIST_INCONSISTENT, ++ MD_ERROR_WIN_EVALUATION_EXPIRATION, ++ MD_ERROR_WIN_ILLEGAL_DLL_RELOCATION, ++ MD_ERROR_WIN_DLL_INIT_FAILED_LOGOFF, ++ MD_ERROR_WIN_VALIDATE_CONTINUE, ++ MD_ERROR_WIN_NO_MORE_MATCHES, ++ MD_ERROR_WIN_RANGE_LIST_CONFLICT, ++ MD_ERROR_WIN_SERVER_SID_MISMATCH, ++ MD_ERROR_WIN_CANT_ENABLE_DENY_ONLY, ++ MD_ERROR_WIN_FLOAT_MULTIPLE_FAULTS, ++ MD_ERROR_WIN_FLOAT_MULTIPLE_TRAPS, ++ MD_ERROR_WIN_NOINTERFACE, ++ MD_ERROR_WIN_DRIVER_FAILED_SLEEP, ++ MD_ERROR_WIN_CORRUPT_SYSTEM_FILE, ++ MD_ERROR_WIN_COMMITMENT_MINIMUM, ++ MD_ERROR_WIN_PNP_RESTART_ENUMERATION, ++ MD_ERROR_WIN_SYSTEM_IMAGE_BAD_SIGNATURE, ++ MD_ERROR_WIN_PNP_REBOOT_REQUIRED, ++ MD_ERROR_WIN_INSUFFICIENT_POWER, ++ MD_ERROR_WIN_MULTIPLE_FAULT_VIOLATION, ++ MD_ERROR_WIN_SYSTEM_SHUTDOWN, ++ MD_ERROR_WIN_PORT_NOT_SET, ++ MD_ERROR_WIN_DS_VERSION_CHECK_FAILURE, ++ MD_ERROR_WIN_RANGE_NOT_FOUND, ++ MD_ERROR_WIN_NOT_SAFE_MODE_DRIVER, ++ MD_ERROR_WIN_FAILED_DRIVER_ENTRY, ++ MD_ERROR_WIN_DEVICE_ENUMERATION_ERROR, ++ MD_ERROR_WIN_MOUNT_POINT_NOT_RESOLVED, ++ MD_ERROR_WIN_INVALID_DEVICE_OBJECT_PARAMETER, ++ MD_ERROR_WIN_MCA_OCCURED, ++ MD_ERROR_WIN_DRIVER_DATABASE_ERROR, ++ MD_ERROR_WIN_SYSTEM_HIVE_TOO_LARGE, ++ MD_ERROR_WIN_DRIVER_FAILED_PRIOR_UNLOAD, ++ MD_ERROR_WIN_VOLSNAP_PREPARE_HIBERNATE, ++ MD_ERROR_WIN_HIBERNATION_FAILURE, ++ MD_ERROR_WIN_PWD_TOO_LONG, ++ MD_ERROR_WIN_FILE_SYSTEM_LIMITATION, ++ MD_ERROR_WIN_ASSERTION_FAILURE, ++ MD_ERROR_WIN_ACPI_ERROR, ++ MD_ERROR_WIN_WOW_ASSERTION, ++ MD_ERROR_WIN_PNP_BAD_MPS_TABLE, ++ MD_ERROR_WIN_PNP_TRANSLATION_FAILED, ++ MD_ERROR_WIN_PNP_IRQ_TRANSLATION_FAILED, ++ MD_ERROR_WIN_PNP_INVALID_ID, ++ MD_ERROR_WIN_WAKE_SYSTEM_DEBUGGER, ++ MD_ERROR_WIN_HANDLES_CLOSED, ++ MD_ERROR_WIN_EXTRANEOUS_INFORMATION, ++ MD_ERROR_WIN_RXACT_COMMIT_NECESSARY, ++ MD_ERROR_WIN_MEDIA_CHECK, ++ MD_ERROR_WIN_GUID_SUBSTITUTION_MADE, ++ MD_ERROR_WIN_STOPPED_ON_SYMLINK, ++ MD_ERROR_WIN_LONGJUMP, ++ MD_ERROR_WIN_PLUGPLAY_QUERY_VETOED, ++ MD_ERROR_WIN_UNWIND_CONSOLIDATE, ++ MD_ERROR_WIN_REGISTRY_HIVE_RECOVERED, ++ MD_ERROR_WIN_DLL_MIGHT_BE_INSECURE, ++ MD_ERROR_WIN_DLL_MIGHT_BE_INCOMPATIBLE, ++ MD_ERROR_WIN_DBG_EXCEPTION_NOT_HANDLED, ++ MD_ERROR_WIN_DBG_REPLY_LATER, ++ MD_ERROR_WIN_DBG_UNABLE_TO_PROVIDE_HANDLE, ++ MD_ERROR_WIN_DBG_TERMINATE_THREAD, ++ MD_ERROR_WIN_DBG_TERMINATE_PROCESS, ++ MD_ERROR_WIN_DBG_CONTROL_C, ++ MD_ERROR_WIN_DBG_PRINTEXCEPTION_C, ++ MD_ERROR_WIN_DBG_RIPEXCEPTION, ++ MD_ERROR_WIN_DBG_CONTROL_BREAK, ++ MD_ERROR_WIN_DBG_COMMAND_EXCEPTION, ++ MD_ERROR_WIN_OBJECT_NAME_EXISTS, ++ MD_ERROR_WIN_THREAD_WAS_SUSPENDED, ++ MD_ERROR_WIN_IMAGE_NOT_AT_BASE, ++ MD_ERROR_WIN_RXACT_STATE_CREATED, ++ MD_ERROR_WIN_SEGMENT_NOTIFICATION, ++ MD_ERROR_WIN_BAD_CURRENT_DIRECTORY, ++ MD_ERROR_WIN_FT_READ_RECOVERY_FROM_BACKUP, ++ MD_ERROR_WIN_FT_WRITE_RECOVERY, ++ MD_ERROR_WIN_IMAGE_MACHINE_TYPE_MISMATCH, ++ MD_ERROR_WIN_RECEIVE_PARTIAL, ++ MD_ERROR_WIN_RECEIVE_EXPEDITED, ++ MD_ERROR_WIN_RECEIVE_PARTIAL_EXPEDITED, ++ MD_ERROR_WIN_EVENT_DONE, ++ MD_ERROR_WIN_EVENT_PENDING, ++ MD_ERROR_WIN_CHECKING_FILE_SYSTEM, ++ MD_ERROR_WIN_FATAL_APP_EXIT, ++ MD_ERROR_WIN_PREDEFINED_HANDLE, ++ MD_ERROR_WIN_WAS_UNLOCKED, ++ MD_ERROR_WIN_SERVICE_NOTIFICATION, ++ MD_ERROR_WIN_WAS_LOCKED, ++ MD_ERROR_WIN_LOG_HARD_ERROR, ++ MD_ERROR_WIN_ALREADY_WIN32, ++ MD_ERROR_WIN_IMAGE_MACHINE_TYPE_MISMATCH_EXE, ++ MD_ERROR_WIN_NO_YIELD_PERFORMED, ++ MD_ERROR_WIN_TIMER_RESUME_IGNORED, ++ MD_ERROR_WIN_ARBITRATION_UNHANDLED, ++ MD_ERROR_WIN_CARDBUS_NOT_SUPPORTED, ++ MD_ERROR_WIN_MP_PROCESSOR_MISMATCH, ++ MD_ERROR_WIN_HIBERNATED, ++ MD_ERROR_WIN_RESUME_HIBERNATION, ++ MD_ERROR_WIN_FIRMWARE_UPDATED, ++ MD_ERROR_WIN_DRIVERS_LEAKING_LOCKED_PAGES, ++ MD_ERROR_WIN_WAKE_SYSTEM, ++ MD_ERROR_WIN_WAIT_1, ++ MD_ERROR_WIN_WAIT_2, ++ MD_ERROR_WIN_WAIT_3, ++ MD_ERROR_WIN_WAIT_63, ++ MD_ERROR_WIN_ABANDONED_WAIT_0, ++ MD_ERROR_WIN_ABANDONED_WAIT_63, ++ MD_ERROR_WIN_USER_APC, ++ MD_ERROR_WIN_KERNEL_APC, ++ MD_ERROR_WIN_ALERTED, ++ MD_ERROR_WIN_ELEVATION_REQUIRED, ++ MD_ERROR_WIN_REPARSE, ++ MD_ERROR_WIN_OPLOCK_BREAK_IN_PROGRESS, ++ MD_ERROR_WIN_VOLUME_MOUNTED, ++ MD_ERROR_WIN_RXACT_COMMITTED, ++ MD_ERROR_WIN_NOTIFY_CLEANUP, ++ MD_ERROR_WIN_PRIMARY_TRANSPORT_CONNECT_FAILED, ++ MD_ERROR_WIN_PAGE_FAULT_TRANSITION, ++ MD_ERROR_WIN_PAGE_FAULT_DEMAND_ZERO, ++ MD_ERROR_WIN_PAGE_FAULT_COPY_ON_WRITE, ++ MD_ERROR_WIN_PAGE_FAULT_GUARD_PAGE, ++ MD_ERROR_WIN_PAGE_FAULT_PAGING_FILE, ++ MD_ERROR_WIN_CACHE_PAGE_LOCKED, ++ MD_ERROR_WIN_CRASH_DUMP, ++ MD_ERROR_WIN_BUFFER_ALL_ZEROS, ++ MD_ERROR_WIN_REPARSE_OBJECT, ++ MD_ERROR_WIN_RESOURCE_REQUIREMENTS_CHANGED, ++ MD_ERROR_WIN_TRANSLATION_COMPLETE, ++ MD_ERROR_WIN_NOTHING_TO_TERMINATE, ++ MD_ERROR_WIN_PROCESS_NOT_IN_JOB, ++ MD_ERROR_WIN_PROCESS_IN_JOB, ++ MD_ERROR_WIN_VOLSNAP_HIBERNATE_READY, ++ MD_ERROR_WIN_FSFILTER_OP_COMPLETED_SUCCESSFULLY, ++ MD_ERROR_WIN_INTERRUPT_VECTOR_ALREADY_CONNECTED, ++ MD_ERROR_WIN_INTERRUPT_STILL_CONNECTED, ++ MD_ERROR_WIN_WAIT_FOR_OPLOCK, ++ MD_ERROR_WIN_DBG_EXCEPTION_HANDLED, ++ MD_ERROR_WIN_DBG_CONTINUE, ++ MD_ERROR_WIN_CALLBACK_POP_STACK, ++ MD_ERROR_WIN_COMPRESSION_DISABLED, ++ MD_ERROR_WIN_CANTFETCHBACKWARDS, ++ MD_ERROR_WIN_CANTSCROLLBACKWARDS, ++ MD_ERROR_WIN_ROWSNOTRELEASED, ++ MD_ERROR_WIN_BAD_ACCESSOR_FLAGS, ++ MD_ERROR_WIN_ERRORS_ENCOUNTERED, ++ MD_ERROR_WIN_NOT_CAPABLE, ++ MD_ERROR_WIN_REQUEST_OUT_OF_SEQUENCE, ++ MD_ERROR_WIN_VERSION_PARSE_ERROR, ++ MD_ERROR_WIN_BADSTARTPOSITION, ++ MD_ERROR_WIN_MEMORY_HARDWARE, ++ MD_ERROR_WIN_DISK_REPAIR_DISABLED, ++ MD_ERROR_WIN_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, ++ MD_ERROR_WIN_SYSTEM_POWERSTATE_TRANSITION, ++ MD_ERROR_WIN_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, ++ MD_ERROR_WIN_MCA_EXCEPTION, ++ MD_ERROR_WIN_ACCESS_AUDIT_BY_POLICY, ++ MD_ERROR_WIN_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, ++ MD_ERROR_WIN_ABANDON_HIBERFILE, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, ++ MD_ERROR_WIN_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, ++ MD_ERROR_WIN_BAD_MCFG_TABLE, ++ MD_ERROR_WIN_DISK_REPAIR_REDIRECTED, ++ MD_ERROR_WIN_DISK_REPAIR_UNSUCCESSFUL, ++ MD_ERROR_WIN_CORRUPT_LOG_OVERFULL, ++ MD_ERROR_WIN_CORRUPT_LOG_CORRUPTED, ++ MD_ERROR_WIN_CORRUPT_LOG_UNAVAILABLE, ++ MD_ERROR_WIN_CORRUPT_LOG_DELETED_FULL, ++ MD_ERROR_WIN_CORRUPT_LOG_CLEARED, ++ MD_ERROR_WIN_ORPHAN_NAME_EXHAUSTED, ++ MD_ERROR_WIN_OPLOCK_SWITCHED_TO_NEW_HANDLE, ++ MD_ERROR_WIN_CANNOT_GRANT_REQUESTED_OPLOCK, ++ MD_ERROR_WIN_CANNOT_BREAK_OPLOCK, ++ MD_ERROR_WIN_OPLOCK_HANDLE_CLOSED, ++ MD_ERROR_WIN_NO_ACE_CONDITION, ++ MD_ERROR_WIN_INVALID_ACE_CONDITION, ++ MD_ERROR_WIN_FILE_HANDLE_REVOKED, ++ MD_ERROR_WIN_IMAGE_AT_DIFFERENT_BASE, ++ MD_ERROR_WIN_ENCRYPTED_IO_NOT_POSSIBLE, ++ MD_ERROR_WIN_FILE_METADATA_OPTIMIZATION_IN_PROGRESS, ++ MD_ERROR_WIN_QUOTA_ACTIVITY, ++ MD_ERROR_WIN_HANDLE_REVOKED, ++ MD_ERROR_WIN_CALLBACK_INVOKE_INLINE, ++ MD_ERROR_WIN_CPU_SET_INVALID, ++ MD_ERROR_WIN_ENCLAVE_NOT_TERMINATED, ++ MD_ERROR_WIN_ENCLAVE_VIOLATION, ++ MD_ERROR_WIN_EA_ACCESS_DENIED, ++ MD_ERROR_WIN_OPERATION_ABORTED, ++ MD_ERROR_WIN_IO_INCOMPLETE, ++ MD_ERROR_WIN_IO_PENDING, ++ MD_ERROR_WIN_NOACCESS, ++ MD_ERROR_WIN_SWAPERROR, ++ MD_ERROR_WIN_STACK_OVERFLOW, ++ MD_ERROR_WIN_INVALID_MESSAGE, ++ MD_ERROR_WIN_CAN_NOT_COMPLETE, ++ MD_ERROR_WIN_INVALID_FLAGS, ++ MD_ERROR_WIN_UNRECOGNIZED_VOLUME, ++ MD_ERROR_WIN_FILE_INVALID, ++ MD_ERROR_WIN_FULLSCREEN_MODE, ++ MD_ERROR_WIN_NO_TOKEN, ++ MD_ERROR_WIN_BADDB, ++ MD_ERROR_WIN_BADKEY, ++ MD_ERROR_WIN_CANTOPEN, ++ MD_ERROR_WIN_CANTREAD, ++ MD_ERROR_WIN_CANTWRITE, ++ MD_ERROR_WIN_REGISTRY_RECOVERED, ++ MD_ERROR_WIN_REGISTRY_CORRUPT, ++ MD_ERROR_WIN_REGISTRY_IO_FAILED, ++ MD_ERROR_WIN_NOT_REGISTRY_FILE, ++ MD_ERROR_WIN_KEY_DELETED, ++ MD_ERROR_WIN_NO_LOG_SPACE, ++ MD_ERROR_WIN_KEY_HAS_CHILDREN, ++ MD_ERROR_WIN_CHILD_MUST_BE_VOLATILE, ++ MD_ERROR_WIN_NOTIFY_ENUM_DIR, ++ MD_ERROR_WIN_DEPENDENT_SERVICES_RUNNING, ++ MD_ERROR_WIN_INVALID_SERVICE_CONTROL, ++ MD_ERROR_WIN_SERVICE_REQUEST_TIMEOUT, ++ MD_ERROR_WIN_SERVICE_NO_THREAD, ++ MD_ERROR_WIN_SERVICE_DATABASE_LOCKED, ++ MD_ERROR_WIN_SERVICE_ALREADY_RUNNING, ++ MD_ERROR_WIN_INVALID_SERVICE_ACCOUNT, ++ MD_ERROR_WIN_SERVICE_DISABLED, ++ MD_ERROR_WIN_CIRCULAR_DEPENDENCY, ++ MD_ERROR_WIN_SERVICE_DOES_NOT_EXIST, ++ MD_ERROR_WIN_SERVICE_CANNOT_ACCEPT_CTRL, ++ MD_ERROR_WIN_SERVICE_NOT_ACTIVE, ++ MD_ERROR_WIN_FAILED_SERVICE_CONTROLLER_CONNECT, ++ MD_ERROR_WIN_EXCEPTION_IN_SERVICE, ++ MD_ERROR_WIN_DATABASE_DOES_NOT_EXIST, ++ MD_ERROR_WIN_SERVICE_SPECIFIC_ERROR, ++ MD_ERROR_WIN_PROCESS_ABORTED, ++ MD_ERROR_WIN_SERVICE_DEPENDENCY_FAIL, ++ MD_ERROR_WIN_SERVICE_LOGON_FAILED, ++ MD_ERROR_WIN_SERVICE_START_HANG, ++ MD_ERROR_WIN_INVALID_SERVICE_LOCK, ++ MD_ERROR_WIN_SERVICE_MARKED_FOR_DELETE, ++ MD_ERROR_WIN_SERVICE_EXISTS, ++ MD_ERROR_WIN_ALREADY_RUNNING_LKG, ++ MD_ERROR_WIN_SERVICE_DEPENDENCY_DELETED, ++ MD_ERROR_WIN_BOOT_ALREADY_ACCEPTED, ++ MD_ERROR_WIN_SERVICE_NEVER_STARTED, ++ MD_ERROR_WIN_DUPLICATE_SERVICE_NAME, ++ MD_ERROR_WIN_DIFFERENT_SERVICE_ACCOUNT, ++ MD_ERROR_WIN_CANNOT_DETECT_DRIVER_FAILURE, ++ MD_ERROR_WIN_CANNOT_DETECT_PROCESS_ABORT, ++ MD_ERROR_WIN_NO_RECOVERY_PROGRAM, ++ MD_ERROR_WIN_SERVICE_NOT_IN_EXE, ++ MD_ERROR_WIN_NOT_SAFEBOOT_SERVICE, ++ MD_ERROR_WIN_END_OF_MEDIA, ++ MD_ERROR_WIN_FILEMARK_DETECTED, ++ MD_ERROR_WIN_BEGINNING_OF_MEDIA, ++ MD_ERROR_WIN_SETMARK_DETECTED, ++ MD_ERROR_WIN_NO_DATA_DETECTED, ++ MD_ERROR_WIN_PARTITION_FAILURE, ++ MD_ERROR_WIN_INVALID_BLOCK_LENGTH, ++ MD_ERROR_WIN_DEVICE_NOT_PARTITIONED, ++ MD_ERROR_WIN_UNABLE_TO_LOCK_MEDIA, ++ MD_ERROR_WIN_UNABLE_TO_UNLOAD_MEDIA, ++ MD_ERROR_WIN_MEDIA_CHANGED, ++ MD_ERROR_WIN_BUS_RESET, ++ MD_ERROR_WIN_NO_MEDIA_IN_DRIVE, ++ MD_ERROR_WIN_NO_UNICODE_TRANSLATION, ++ MD_ERROR_WIN_DLL_INIT_FAILED, ++ MD_ERROR_WIN_SHUTDOWN_IN_PROGRESS, ++ MD_ERROR_WIN_NO_SHUTDOWN_IN_PROGRESS, ++ MD_ERROR_WIN_IO_DEVICE, ++ MD_ERROR_WIN_SERIAL_NO_DEVICE, ++ MD_ERROR_WIN_IRQ_BUSY, ++ MD_ERROR_WIN_MORE_WRITES, ++ MD_ERROR_WIN_COUNTER_TIMEOUT, ++ MD_ERROR_WIN_FLOPPY_ID_MARK_NOT_FOUND, ++ MD_ERROR_WIN_FLOPPY_WRONG_CYLINDER, ++ MD_ERROR_WIN_FLOPPY_UNKNOWN_ERROR, ++ MD_ERROR_WIN_FLOPPY_BAD_REGISTERS, ++ MD_ERROR_WIN_DISK_RECALIBRATE_FAILED, ++ MD_ERROR_WIN_DISK_OPERATION_FAILED, ++ MD_ERROR_WIN_DISK_RESET_FAILED, ++ MD_ERROR_WIN_EOM_OVERFLOW, ++ MD_ERROR_WIN_NOT_ENOUGH_SERVER_MEMORY, ++ MD_ERROR_WIN_POSSIBLE_DEADLOCK, ++ MD_ERROR_WIN_MAPPED_ALIGNMENT, ++ MD_ERROR_WIN_SET_POWER_STATE_VETOED, ++ MD_ERROR_WIN_SET_POWER_STATE_FAILED, ++ MD_ERROR_WIN_TOO_MANY_LINKS, ++ MD_ERROR_WIN_OLD_WIN_VERSION, ++ MD_ERROR_WIN_APP_WRONG_OS, ++ MD_ERROR_WIN_SINGLE_INSTANCE_APP, ++ MD_ERROR_WIN_RMODE_APP, ++ MD_ERROR_WIN_INVALID_DLL, ++ MD_ERROR_WIN_NO_ASSOCIATION, ++ MD_ERROR_WIN_DDE_FAIL, ++ MD_ERROR_WIN_DLL_NOT_FOUND, ++ MD_ERROR_WIN_NO_MORE_USER_HANDLES, ++ MD_ERROR_WIN_MESSAGE_SYNC_ONLY, ++ MD_ERROR_WIN_SOURCE_ELEMENT_EMPTY, ++ MD_ERROR_WIN_DESTINATION_ELEMENT_FULL, ++ MD_ERROR_WIN_ILLEGAL_ELEMENT_ADDRESS, ++ MD_ERROR_WIN_MAGAZINE_NOT_PRESENT, ++ MD_ERROR_WIN_DEVICE_REINITIALIZATION_NEEDED, ++ MD_ERROR_WIN_DEVICE_REQUIRES_CLEANING, ++ MD_ERROR_WIN_DEVICE_DOOR_OPEN, ++ MD_ERROR_WIN_DEVICE_NOT_CONNECTED, ++ MD_ERROR_WIN_NOT_FOUND, ++ MD_ERROR_WIN_NO_MATCH, ++ MD_ERROR_WIN_SET_NOT_FOUND, ++ MD_ERROR_WIN_POINT_NOT_FOUND, ++ MD_ERROR_WIN_NO_TRACKING_SERVICE, ++ MD_ERROR_WIN_NO_VOLUME_ID, ++ MD_ERROR_WIN_UNABLE_TO_REMOVE_REPLACED, ++ MD_ERROR_WIN_UNABLE_TO_MOVE_REPLACEMENT, ++ MD_ERROR_WIN_UNABLE_TO_MOVE_REPLACEMENT_2, ++ MD_ERROR_WIN_JOURNAL_DELETE_IN_PROGRESS, ++ MD_ERROR_WIN_JOURNAL_NOT_ACTIVE, ++ MD_ERROR_WIN_POTENTIAL_FILE_FOUND, ++ MD_ERROR_WIN_JOURNAL_ENTRY_DELETED, ++ MD_ERROR_WIN_VRF_CFG_AND_IO_ENABLED, ++ MD_ERROR_WIN_PARTITION_TERMINATING, ++ MD_ERROR_WIN_SHUTDOWN_IS_SCHEDULED, ++ MD_ERROR_WIN_SHUTDOWN_USERS_LOGGED_ON, ++ MD_ERROR_WIN_BAD_DEVICE, ++ MD_ERROR_WIN_CONNECTION_UNAVAIL, ++ MD_ERROR_WIN_DEVICE_ALREADY_REMEMBERED, ++ MD_ERROR_WIN_NO_NET_OR_BAD_PATH, ++ MD_ERROR_WIN_BAD_PROVIDER, ++ MD_ERROR_WIN_CANNOT_OPEN_PROFILE, ++ MD_ERROR_WIN_BAD_PROFILE, ++ MD_ERROR_WIN_NOT_CONTAINER, ++ MD_ERROR_WIN_EXTENDED_ERROR, ++ MD_ERROR_WIN_INVALID_GROUPNAME, ++ MD_ERROR_WIN_INVALID_COMPUTERNAME, ++ MD_ERROR_WIN_INVALID_EVENTNAME, ++ MD_ERROR_WIN_INVALID_DOMAINNAME, ++ MD_ERROR_WIN_INVALID_SERVICENAME, ++ MD_ERROR_WIN_INVALID_NETNAME, ++ MD_ERROR_WIN_INVALID_SHARENAME, ++ MD_ERROR_WIN_INVALID_PASSWORDNAME, ++ MD_ERROR_WIN_INVALID_MESSAGENAME, ++ MD_ERROR_WIN_INVALID_MESSAGEDEST, ++ MD_ERROR_WIN_SESSION_CREDENTIAL_CONFLICT, ++ MD_ERROR_WIN_REMOTE_SESSION_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_DUP_DOMAINNAME, ++ MD_ERROR_WIN_NO_NETWORK, ++ MD_ERROR_WIN_CANCELLED, ++ MD_ERROR_WIN_USER_MAPPED_FILE, ++ MD_ERROR_WIN_CONNECTION_REFUSED, ++ MD_ERROR_WIN_GRACEFUL_DISCONNECT, ++ MD_ERROR_WIN_ADDRESS_ALREADY_ASSOCIATED, ++ MD_ERROR_WIN_ADDRESS_NOT_ASSOCIATED, ++ MD_ERROR_WIN_CONNECTION_INVALID, ++ MD_ERROR_WIN_CONNECTION_ACTIVE, ++ MD_ERROR_WIN_NETWORK_UNREACHABLE, ++ MD_ERROR_WIN_HOST_UNREACHABLE, ++ MD_ERROR_WIN_PROTOCOL_UNREACHABLE, ++ MD_ERROR_WIN_PORT_UNREACHABLE, ++ MD_ERROR_WIN_REQUEST_ABORTED, ++ MD_ERROR_WIN_CONNECTION_ABORTED, ++ MD_ERROR_WIN_RETRY, ++ MD_ERROR_WIN_CONNECTION_COUNT_LIMIT, ++ MD_ERROR_WIN_LOGIN_TIME_RESTRICTION, ++ MD_ERROR_WIN_LOGIN_WKSTA_RESTRICTION, ++ MD_ERROR_WIN_INCORRECT_ADDRESS, ++ MD_ERROR_WIN_ALREADY_REGISTERED, ++ MD_ERROR_WIN_SERVICE_NOT_FOUND, ++ MD_ERROR_WIN_NOT_AUTHENTICATED, ++ MD_ERROR_WIN_NOT_LOGGED_ON, ++ MD_ERROR_WIN_CONTINUE, ++ MD_ERROR_WIN_ALREADY_INITIALIZED, ++ MD_ERROR_WIN_NO_MORE_DEVICES, ++ MD_ERROR_WIN_NO_SUCH_SITE, ++ MD_ERROR_WIN_DOMAIN_CONTROLLER_EXISTS, ++ MD_ERROR_WIN_ONLY_IF_CONNECTED, ++ MD_ERROR_WIN_OVERRIDE_NOCHANGES, ++ MD_ERROR_WIN_BAD_USER_PROFILE, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_SBS, ++ MD_ERROR_WIN_SERVER_SHUTDOWN_IN_PROGRESS, ++ MD_ERROR_WIN_HOST_DOWN, ++ MD_ERROR_WIN_NON_ACCOUNT_SID, ++ MD_ERROR_WIN_NON_DOMAIN_SID, ++ MD_ERROR_WIN_APPHELP_BLOCK, ++ MD_ERROR_WIN_ACCESS_DISABLED_BY_POLICY, ++ MD_ERROR_WIN_REG_NAT_CONSUMPTION, ++ MD_ERROR_WIN_CSCSHARE_OFFLINE, ++ MD_ERROR_WIN_PKINIT_FAILURE, ++ MD_ERROR_WIN_SMARTCARD_SUBSYSTEM_FAILURE, ++ MD_ERROR_WIN_DOWNGRADE_DETECTED, ++ MD_ERROR_WIN_MACHINE_LOCKED, ++ MD_ERROR_WIN_SMB_GUEST_LOGON_BLOCKED, ++ MD_ERROR_WIN_CALLBACK_SUPPLIED_INVALID_DATA, ++ MD_ERROR_WIN_SYNC_FOREGROUND_REFRESH_REQUIRED, ++ MD_ERROR_WIN_DRIVER_BLOCKED, ++ MD_ERROR_WIN_INVALID_IMPORT_OF_NON_DLL, ++ MD_ERROR_WIN_ACCESS_DISABLED_WEBBLADE, ++ MD_ERROR_WIN_ACCESS_DISABLED_WEBBLADE_TAMPER, ++ MD_ERROR_WIN_RECOVERY_FAILURE, ++ MD_ERROR_WIN_ALREADY_FIBER, ++ MD_ERROR_WIN_ALREADY_THREAD, ++ MD_ERROR_WIN_STACK_BUFFER_OVERRUN, ++ MD_ERROR_WIN_PARAMETER_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_DEBUGGER_INACTIVE, ++ MD_ERROR_WIN_DELAY_LOAD_FAILED, ++ MD_ERROR_WIN_VDM_DISALLOWED, ++ MD_ERROR_WIN_UNIDENTIFIED_ERROR, ++ MD_ERROR_WIN_INVALID_CRUNTIME_PARAMETER, ++ MD_ERROR_WIN_BEYOND_VDL, ++ MD_ERROR_WIN_INCOMPATIBLE_SERVICE_SID_TYPE, ++ MD_ERROR_WIN_DRIVER_PROCESS_TERMINATED, ++ MD_ERROR_WIN_IMPLEMENTATION_LIMIT, ++ MD_ERROR_WIN_PROCESS_IS_PROTECTED, ++ MD_ERROR_WIN_SERVICE_NOTIFY_CLIENT_LAGGING, ++ MD_ERROR_WIN_DISK_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_CONTENT_BLOCKED, ++ MD_ERROR_WIN_INCOMPATIBLE_SERVICE_PRIVILEGE, ++ MD_ERROR_WIN_APP_HANG, ++ MD_ERROR_WIN_INVALID_LABEL, ++ MD_ERROR_WIN_NOT_ALL_ASSIGNED, ++ MD_ERROR_WIN_SOME_NOT_MAPPED, ++ MD_ERROR_WIN_NO_QUOTAS_FOR_ACCOUNT, ++ MD_ERROR_WIN_LOCAL_USER_SESSION_KEY, ++ MD_ERROR_WIN_NULL_LM_PASSWORD, ++ MD_ERROR_WIN_UNKNOWN_REVISION, ++ MD_ERROR_WIN_REVISION_MISMATCH, ++ MD_ERROR_WIN_INVALID_OWNER, ++ MD_ERROR_WIN_INVALID_PRIMARY_GROUP, ++ MD_ERROR_WIN_NO_IMPERSONATION_TOKEN, ++ MD_ERROR_WIN_CANT_DISABLE_MANDATORY, ++ MD_ERROR_WIN_NO_LOGON_SERVERS, ++ MD_ERROR_WIN_NO_SUCH_LOGON_SESSION, ++ MD_ERROR_WIN_NO_SUCH_PRIVILEGE, ++ MD_ERROR_WIN_PRIVILEGE_NOT_HELD, ++ MD_ERROR_WIN_INVALID_ACCOUNT_NAME, ++ MD_ERROR_WIN_USER_EXISTS, ++ MD_ERROR_WIN_NO_SUCH_USER, ++ MD_ERROR_WIN_GROUP_EXISTS, ++ MD_ERROR_WIN_NO_SUCH_GROUP, ++ MD_ERROR_WIN_MEMBER_IN_GROUP, ++ MD_ERROR_WIN_MEMBER_NOT_IN_GROUP, ++ MD_ERROR_WIN_LAST_ADMIN, ++ MD_ERROR_WIN_WRONG_PASSWORD, ++ MD_ERROR_WIN_ILL_FORMED_PASSWORD, ++ MD_ERROR_WIN_PASSWORD_RESTRICTION, ++ MD_ERROR_WIN_LOGON_FAILURE, ++ MD_ERROR_WIN_ACCOUNT_RESTRICTION, ++ MD_ERROR_WIN_INVALID_LOGON_HOURS, ++ MD_ERROR_WIN_INVALID_WORKSTATION, ++ MD_ERROR_WIN_PASSWORD_EXPIRED, ++ MD_ERROR_WIN_ACCOUNT_DISABLED, ++ MD_ERROR_WIN_NONE_MAPPED, ++ MD_ERROR_WIN_TOO_MANY_LUIDS_REQUESTED, ++ MD_ERROR_WIN_LUIDS_EXHAUSTED, ++ MD_ERROR_WIN_INVALID_SUB_AUTHORITY, ++ MD_ERROR_WIN_INVALID_ACL, ++ MD_ERROR_WIN_INVALID_SID, ++ MD_ERROR_WIN_INVALID_SECURITY_DESCR, ++ MD_ERROR_WIN_BAD_INHERITANCE_ACL, ++ MD_ERROR_WIN_SERVER_DISABLED, ++ MD_ERROR_WIN_SERVER_NOT_DISABLED, ++ MD_ERROR_WIN_INVALID_ID_AUTHORITY, ++ MD_ERROR_WIN_ALLOTTED_SPACE_EXCEEDED, ++ MD_ERROR_WIN_INVALID_GROUP_ATTRIBUTES, ++ MD_ERROR_WIN_BAD_IMPERSONATION_LEVEL, ++ MD_ERROR_WIN_CANT_OPEN_ANONYMOUS, ++ MD_ERROR_WIN_BAD_VALIDATION_CLASS, ++ MD_ERROR_WIN_BAD_TOKEN_TYPE, ++ MD_ERROR_WIN_NO_SECURITY_ON_OBJECT, ++ MD_ERROR_WIN_CANT_ACCESS_DOMAIN_INFO, ++ MD_ERROR_WIN_INVALID_SERVER_STATE, ++ MD_ERROR_WIN_INVALID_DOMAIN_STATE, ++ MD_ERROR_WIN_INVALID_DOMAIN_ROLE, ++ MD_ERROR_WIN_NO_SUCH_DOMAIN, ++ MD_ERROR_WIN_DOMAIN_EXISTS, ++ MD_ERROR_WIN_DOMAIN_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_INTERNAL_DB_CORRUPTION, ++ MD_ERROR_WIN_INTERNAL_ERROR, ++ MD_ERROR_WIN_GENERIC_NOT_MAPPED, ++ MD_ERROR_WIN_BAD_DESCRIPTOR_FORMAT, ++ MD_ERROR_WIN_NOT_LOGON_PROCESS, ++ MD_ERROR_WIN_LOGON_SESSION_EXISTS, ++ MD_ERROR_WIN_NO_SUCH_PACKAGE, ++ MD_ERROR_WIN_BAD_LOGON_SESSION_STATE, ++ MD_ERROR_WIN_LOGON_SESSION_COLLISION, ++ MD_ERROR_WIN_INVALID_LOGON_TYPE, ++ MD_ERROR_WIN_CANNOT_IMPERSONATE, ++ MD_ERROR_WIN_RXACT_INVALID_STATE, ++ MD_ERROR_WIN_RXACT_COMMIT_FAILURE, ++ MD_ERROR_WIN_SPECIAL_ACCOUNT, ++ MD_ERROR_WIN_SPECIAL_GROUP, ++ MD_ERROR_WIN_SPECIAL_USER, ++ MD_ERROR_WIN_MEMBERS_PRIMARY_GROUP, ++ MD_ERROR_WIN_TOKEN_ALREADY_IN_USE, ++ MD_ERROR_WIN_NO_SUCH_ALIAS, ++ MD_ERROR_WIN_MEMBER_NOT_IN_ALIAS, ++ MD_ERROR_WIN_MEMBER_IN_ALIAS, ++ MD_ERROR_WIN_ALIAS_EXISTS, ++ MD_ERROR_WIN_LOGON_NOT_GRANTED, ++ MD_ERROR_WIN_TOO_MANY_SECRETS, ++ MD_ERROR_WIN_SECRET_TOO_LONG, ++ MD_ERROR_WIN_INTERNAL_DB_ERROR, ++ MD_ERROR_WIN_TOO_MANY_CONTEXT_IDS, ++ MD_ERROR_WIN_LOGON_TYPE_NOT_GRANTED, ++ MD_ERROR_WIN_NT_CROSS_ENCRYPTION_REQUIRED, ++ MD_ERROR_WIN_NO_SUCH_MEMBER, ++ MD_ERROR_WIN_INVALID_MEMBER, ++ MD_ERROR_WIN_TOO_MANY_SIDS, ++ MD_ERROR_WIN_LM_CROSS_ENCRYPTION_REQUIRED, ++ MD_ERROR_WIN_NO_INHERITANCE, ++ MD_ERROR_WIN_FILE_CORRUPT, ++ MD_ERROR_WIN_DISK_CORRUPT, ++ MD_ERROR_WIN_NO_USER_SESSION_KEY, ++ MD_ERROR_WIN_LICENSE_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_WRONG_TARGET_NAME, ++ MD_ERROR_WIN_MUTUAL_AUTH_FAILED, ++ MD_ERROR_WIN_TIME_SKEW, ++ MD_ERROR_WIN_CURRENT_DOMAIN_NOT_ALLOWED, ++ MD_ERROR_WIN_INVALID_WINDOW_HANDLE, ++ MD_ERROR_WIN_INVALID_MENU_HANDLE, ++ MD_ERROR_WIN_INVALID_CURSOR_HANDLE, ++ MD_ERROR_WIN_INVALID_ACCEL_HANDLE, ++ MD_ERROR_WIN_INVALID_HOOK_HANDLE, ++ MD_ERROR_WIN_INVALID_DWP_HANDLE, ++ MD_ERROR_WIN_TLW_WITH_WSCHILD, ++ MD_ERROR_WIN_CANNOT_FIND_WND_CLASS, ++ MD_ERROR_WIN_WINDOW_OF_OTHER_THREAD, ++ MD_ERROR_WIN_HOTKEY_ALREADY_REGISTERED, ++ MD_ERROR_WIN_CLASS_ALREADY_EXISTS, ++ MD_ERROR_WIN_CLASS_DOES_NOT_EXIST, ++ MD_ERROR_WIN_CLASS_HAS_WINDOWS, ++ MD_ERROR_WIN_INVALID_INDEX, ++ MD_ERROR_WIN_INVALID_ICON_HANDLE, ++ MD_ERROR_WIN_PRIVATE_DIALOG_INDEX, ++ MD_ERROR_WIN_LISTBOX_ID_NOT_FOUND, ++ MD_ERROR_WIN_NO_WILDCARD_CHARACTERS, ++ MD_ERROR_WIN_CLIPBOARD_NOT_OPEN, ++ MD_ERROR_WIN_HOTKEY_NOT_REGISTERED, ++ MD_ERROR_WIN_WINDOW_NOT_DIALOG, ++ MD_ERROR_WIN_CONTROL_ID_NOT_FOUND, ++ MD_ERROR_WIN_INVALID_COMBOBOX_MESSAGE, ++ MD_ERROR_WIN_WINDOW_NOT_COMBOBOX, ++ MD_ERROR_WIN_INVALID_EDIT_HEIGHT, ++ MD_ERROR_WIN_DC_NOT_FOUND, ++ MD_ERROR_WIN_INVALID_HOOK_FILTER, ++ MD_ERROR_WIN_INVALID_FILTER_PROC, ++ MD_ERROR_WIN_HOOK_NEEDS_HMOD, ++ MD_ERROR_WIN_GLOBAL_ONLY_HOOK, ++ MD_ERROR_WIN_JOURNAL_HOOK_SET, ++ MD_ERROR_WIN_HOOK_NOT_INSTALLED, ++ MD_ERROR_WIN_INVALID_LB_MESSAGE, ++ MD_ERROR_WIN_SETCOUNT_ON_BAD_LB, ++ MD_ERROR_WIN_LB_WITHOUT_TABSTOPS, ++ MD_ERROR_WIN_DESTROY_OBJECT_OF_OTHER_THREAD, ++ MD_ERROR_WIN_CHILD_WINDOW_MENU, ++ MD_ERROR_WIN_NO_SYSTEM_MENU, ++ MD_ERROR_WIN_INVALID_MSGBOX_STYLE, ++ MD_ERROR_WIN_INVALID_SPI_VALUE, ++ MD_ERROR_WIN_SCREEN_ALREADY_LOCKED, ++ MD_ERROR_WIN_HWNDS_HAVE_DIFF_PARENT, ++ MD_ERROR_WIN_NOT_CHILD_WINDOW, ++ MD_ERROR_WIN_INVALID_GW_COMMAND, ++ MD_ERROR_WIN_INVALID_THREAD_ID, ++ MD_ERROR_WIN_NON_MDICHILD_WINDOW, ++ MD_ERROR_WIN_POPUP_ALREADY_ACTIVE, ++ MD_ERROR_WIN_NO_SCROLLBARS, ++ MD_ERROR_WIN_INVALID_SCROLLBAR_RANGE, ++ MD_ERROR_WIN_INVALID_SHOWWIN_COMMAND, ++ MD_ERROR_WIN_NO_SYSTEM_RESOURCES, ++ MD_ERROR_WIN_NONPAGED_SYSTEM_RESOURCES, ++ MD_ERROR_WIN_PAGED_SYSTEM_RESOURCES, ++ MD_ERROR_WIN_WORKING_SET_QUOTA, ++ MD_ERROR_WIN_PAGEFILE_QUOTA, ++ MD_ERROR_WIN_COMMITMENT_LIMIT, ++ MD_ERROR_WIN_MENU_ITEM_NOT_FOUND, ++ MD_ERROR_WIN_INVALID_KEYBOARD_HANDLE, ++ MD_ERROR_WIN_HOOK_TYPE_NOT_ALLOWED, ++ MD_ERROR_WIN_REQUIRES_INTERACTIVE_WINDOWSTATION, ++ MD_ERROR_WIN_TIMEOUT, ++ MD_ERROR_WIN_INVALID_MONITOR_HANDLE, ++ MD_ERROR_WIN_INCORRECT_SIZE, ++ MD_ERROR_WIN_SYMLINK_CLASS_DISABLED, ++ MD_ERROR_WIN_SYMLINK_NOT_SUPPORTED, ++ MD_ERROR_WIN_XML_PARSE_ERROR, ++ MD_ERROR_WIN_XMLDSIG_ERROR, ++ MD_ERROR_WIN_RESTART_APPLICATION, ++ MD_ERROR_WIN_WRONG_COMPARTMENT, ++ MD_ERROR_WIN_AUTHIP_FAILURE, ++ MD_ERROR_WIN_NO_NVRAM_RESOURCES, ++ MD_ERROR_WIN_NOT_GUI_PROCESS, ++ MD_ERROR_WIN_EVENTLOG_FILE_CORRUPT, ++ MD_ERROR_WIN_EVENTLOG_CANT_START, ++ MD_ERROR_WIN_LOG_FILE_FULL, ++ MD_ERROR_WIN_EVENTLOG_FILE_CHANGED, ++ MD_ERROR_WIN_CONTAINER_ASSIGNED, ++ MD_ERROR_WIN_JOB_NO_CONTAINER, ++ MD_ERROR_WIN_INVALID_TASK_NAME, ++ MD_ERROR_WIN_INVALID_TASK_INDEX, ++ MD_ERROR_WIN_THREAD_ALREADY_IN_TASK, ++ MD_ERROR_WIN_INSTALL_SERVICE_FAILURE, ++ MD_ERROR_WIN_INSTALL_USEREXIT, ++ MD_ERROR_WIN_INSTALL_FAILURE, ++ MD_ERROR_WIN_INSTALL_SUSPEND, ++ MD_ERROR_WIN_UNKNOWN_PRODUCT, ++ MD_ERROR_WIN_UNKNOWN_FEATURE, ++ MD_ERROR_WIN_UNKNOWN_COMPONENT, ++ MD_ERROR_WIN_UNKNOWN_PROPERTY, ++ MD_ERROR_WIN_INVALID_HANDLE_STATE, ++ MD_ERROR_WIN_BAD_CONFIGURATION, ++ MD_ERROR_WIN_INDEX_ABSENT, ++ MD_ERROR_WIN_INSTALL_SOURCE_ABSENT, ++ MD_ERROR_WIN_INSTALL_PACKAGE_VERSION, ++ MD_ERROR_WIN_PRODUCT_UNINSTALLED, ++ MD_ERROR_WIN_BAD_QUERY_SYNTAX, ++ MD_ERROR_WIN_INVALID_FIELD, ++ MD_ERROR_WIN_DEVICE_REMOVED, ++ MD_ERROR_WIN_INSTALL_ALREADY_RUNNING, ++ MD_ERROR_WIN_INSTALL_PACKAGE_OPEN_FAILED, ++ MD_ERROR_WIN_INSTALL_PACKAGE_INVALID, ++ MD_ERROR_WIN_INSTALL_UI_FAILURE, ++ MD_ERROR_WIN_INSTALL_LOG_FAILURE, ++ MD_ERROR_WIN_INSTALL_LANGUAGE_UNSUPPORTED, ++ MD_ERROR_WIN_INSTALL_TRANSFORM_FAILURE, ++ MD_ERROR_WIN_INSTALL_PACKAGE_REJECTED, ++ MD_ERROR_WIN_FUNCTION_NOT_CALLED, ++ MD_ERROR_WIN_FUNCTION_FAILED, ++ MD_ERROR_WIN_INVALID_TABLE, ++ MD_ERROR_WIN_DATATYPE_MISMATCH, ++ MD_ERROR_WIN_UNSUPPORTED_TYPE, ++ MD_ERROR_WIN_CREATE_FAILED, ++ MD_ERROR_WIN_INSTALL_TEMP_UNWRITABLE, ++ MD_ERROR_WIN_INSTALL_PLATFORM_UNSUPPORTED, ++ MD_ERROR_WIN_INSTALL_NOTUSED, ++ MD_ERROR_WIN_PATCH_PACKAGE_OPEN_FAILED, ++ MD_ERROR_WIN_PATCH_PACKAGE_INVALID, ++ MD_ERROR_WIN_PATCH_PACKAGE_UNSUPPORTED, ++ MD_ERROR_WIN_PRODUCT_VERSION, ++ MD_ERROR_WIN_INVALID_COMMAND_LINE, ++ MD_ERROR_WIN_INSTALL_REMOTE_DISALLOWED, ++ MD_ERROR_WIN_SUCCESS_REBOOT_INITIATED, ++ MD_ERROR_WIN_PATCH_TARGET_NOT_FOUND, ++ MD_ERROR_WIN_PATCH_PACKAGE_REJECTED, ++ MD_ERROR_WIN_INSTALL_TRANSFORM_REJECTED, ++ MD_ERROR_WIN_INSTALL_REMOTE_PROHIBITED, ++ MD_ERROR_WIN_PATCH_REMOVAL_UNSUPPORTED, ++ MD_ERROR_WIN_UNKNOWN_PATCH, ++ MD_ERROR_WIN_PATCH_NO_SEQUENCE, ++ MD_ERROR_WIN_PATCH_REMOVAL_DISALLOWED, ++ MD_ERROR_WIN_INVALID_PATCH_XML, ++ MD_ERROR_WIN_PATCH_MANAGED_ADVERTISED_PRODUCT, ++ MD_ERROR_WIN_INSTALL_SERVICE_SAFEBOOT, ++ MD_ERROR_WIN_FAIL_FAST_EXCEPTION, ++ MD_ERROR_WIN_INSTALL_REJECTED, ++ MD_ERROR_WIN_DYNAMIC_CODE_BLOCKED, ++ MD_ERROR_WIN_NOT_SAME_OBJECT, ++ MD_ERROR_WIN_STRICT_CFG_VIOLATION, ++ MD_ERROR_WIN_SET_CONTEXT_DENIED, ++ MD_ERROR_WIN_CROSS_PARTITION_VIOLATION, ++ MD_ERROR_WIN_RETURN_ADDRESS_HIJACK_ATTEMPT, ++ MD_ERROR_WIN_INVALID_USER_BUFFER, ++ MD_ERROR_WIN_UNRECOGNIZED_MEDIA, ++ MD_ERROR_WIN_NO_TRUST_LSA_SECRET, ++ MD_ERROR_WIN_NO_TRUST_SAM_ACCOUNT, ++ MD_ERROR_WIN_TRUSTED_DOMAIN_FAILURE, ++ MD_ERROR_WIN_TRUSTED_RELATIONSHIP_FAILURE, ++ MD_ERROR_WIN_TRUST_FAILURE, ++ MD_ERROR_WIN_NETLOGON_NOT_STARTED, ++ MD_ERROR_WIN_ACCOUNT_EXPIRED, ++ MD_ERROR_WIN_REDIRECTOR_HAS_OPEN_HANDLES, ++ MD_ERROR_WIN_PRINTER_DRIVER_ALREADY_INSTALLED, ++ MD_ERROR_WIN_UNKNOWN_PORT, ++ MD_ERROR_WIN_UNKNOWN_PRINTER_DRIVER, ++ MD_ERROR_WIN_UNKNOWN_PRINTPROCESSOR, ++ MD_ERROR_WIN_INVALID_SEPARATOR_FILE, ++ MD_ERROR_WIN_INVALID_PRIORITY, ++ MD_ERROR_WIN_INVALID_PRINTER_NAME, ++ MD_ERROR_WIN_PRINTER_ALREADY_EXISTS, ++ MD_ERROR_WIN_INVALID_PRINTER_COMMAND, ++ MD_ERROR_WIN_INVALID_DATATYPE, ++ MD_ERROR_WIN_INVALID_ENVIRONMENT, ++ MD_ERROR_WIN_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, ++ MD_ERROR_WIN_NOLOGON_WORKSTATION_TRUST_ACCOUNT, ++ MD_ERROR_WIN_NOLOGON_SERVER_TRUST_ACCOUNT, ++ MD_ERROR_WIN_DOMAIN_TRUST_INCONSISTENT, ++ MD_ERROR_WIN_SERVER_HAS_OPEN_HANDLES, ++ MD_ERROR_WIN_RESOURCE_DATA_NOT_FOUND, ++ MD_ERROR_WIN_RESOURCE_TYPE_NOT_FOUND, ++ MD_ERROR_WIN_RESOURCE_NAME_NOT_FOUND, ++ MD_ERROR_WIN_RESOURCE_LANG_NOT_FOUND, ++ MD_ERROR_WIN_NOT_ENOUGH_QUOTA, ++ MD_ERROR_WIN_INVALID_TIME, ++ MD_ERROR_WIN_INVALID_FORM_NAME, ++ MD_ERROR_WIN_INVALID_FORM_SIZE, ++ MD_ERROR_WIN_ALREADY_WAITING, ++ MD_ERROR_WIN_PRINTER_DELETED, ++ MD_ERROR_WIN_INVALID_PRINTER_STATE, ++ MD_ERROR_WIN_PASSWORD_MUST_CHANGE, ++ MD_ERROR_WIN_DOMAIN_CONTROLLER_NOT_FOUND, ++ MD_ERROR_WIN_ACCOUNT_LOCKED_OUT, ++ MD_ERROR_WIN_NO_SITENAME, ++ MD_ERROR_WIN_CANT_ACCESS_FILE, ++ MD_ERROR_WIN_CANT_RESOLVE_FILENAME, ++ MD_ERROR_WIN_KM_DRIVER_BLOCKED, ++ MD_ERROR_WIN_CONTEXT_EXPIRED, ++ MD_ERROR_WIN_PER_USER_TRUST_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_ALL_USER_TRUST_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_USER_DELETE_TRUST_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_AUTHENTICATION_FIREWALL_FAILED, ++ MD_ERROR_WIN_REMOTE_PRINT_CONNECTIONS_BLOCKED, ++ MD_ERROR_WIN_NTLM_BLOCKED, ++ MD_ERROR_WIN_PASSWORD_CHANGE_REQUIRED, ++ MD_ERROR_WIN_LOST_MODE_LOGON_RESTRICTION, ++ MD_ERROR_WIN_INVALID_PIXEL_FORMAT, ++ MD_ERROR_WIN_BAD_DRIVER, ++ MD_ERROR_WIN_INVALID_WINDOW_STYLE, ++ MD_ERROR_WIN_METAFILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_TRANSFORM_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLIPPING_NOT_SUPPORTED, ++ MD_ERROR_WIN_INVALID_CMM, ++ MD_ERROR_WIN_INVALID_PROFILE, ++ MD_ERROR_WIN_TAG_NOT_FOUND, ++ MD_ERROR_WIN_TAG_NOT_PRESENT, ++ MD_ERROR_WIN_DUPLICATE_TAG, ++ MD_ERROR_WIN_PROFILE_NOT_ASSOCIATED_WITH_DEVICE, ++ MD_ERROR_WIN_PROFILE_NOT_FOUND, ++ MD_ERROR_WIN_INVALID_COLORSPACE, ++ MD_ERROR_WIN_ICM_NOT_ENABLED, ++ MD_ERROR_WIN_DELETING_ICM_XFORM, ++ MD_ERROR_WIN_INVALID_TRANSFORM, ++ MD_ERROR_WIN_COLORSPACE_MISMATCH, ++ MD_ERROR_WIN_INVALID_COLORINDEX, ++ MD_ERROR_WIN_PROFILE_DOES_NOT_MATCH_DEVICE, ++ MD_ERROR_WIN_CONNECTED_OTHER_PASSWORD, ++ MD_ERROR_WIN_CONNECTED_OTHER_PASSWORD_DEFAULT, ++ MD_ERROR_WIN_BAD_USERNAME, ++ MD_ERROR_WIN_NOT_CONNECTED, ++ MD_ERROR_WIN_OPEN_FILES, ++ MD_ERROR_WIN_ACTIVE_CONNECTIONS, ++ MD_ERROR_WIN_DEVICE_IN_USE, ++ MD_ERROR_WIN_UNKNOWN_PRINT_MONITOR, ++ MD_ERROR_WIN_PRINTER_DRIVER_IN_USE, ++ MD_ERROR_WIN_SPOOL_FILE_NOT_FOUND, ++ MD_ERROR_WIN_SPL_NO_STARTDOC, ++ MD_ERROR_WIN_SPL_NO_ADDJOB, ++ MD_ERROR_WIN_PRINT_PROCESSOR_ALREADY_INSTALLED, ++ MD_ERROR_WIN_PRINT_MONITOR_ALREADY_INSTALLED, ++ MD_ERROR_WIN_INVALID_PRINT_MONITOR, ++ MD_ERROR_WIN_PRINT_MONITOR_IN_USE, ++ MD_ERROR_WIN_PRINTER_HAS_JOBS_QUEUED, ++ MD_ERROR_WIN_SUCCESS_REBOOT_REQUIRED, ++ MD_ERROR_WIN_SUCCESS_RESTART_REQUIRED, ++ MD_ERROR_WIN_PRINTER_NOT_FOUND, ++ MD_ERROR_WIN_PRINTER_DRIVER_WARNED, ++ MD_ERROR_WIN_PRINTER_DRIVER_BLOCKED, ++ MD_ERROR_WIN_PRINTER_DRIVER_PACKAGE_IN_USE, ++ MD_ERROR_WIN_CORE_DRIVER_PACKAGE_NOT_FOUND, ++ MD_ERROR_WIN_FAIL_REBOOT_REQUIRED, ++ MD_ERROR_WIN_FAIL_REBOOT_INITIATED, ++ MD_ERROR_WIN_PRINTER_DRIVER_DOWNLOAD_NEEDED, ++ MD_ERROR_WIN_PRINT_JOB_RESTART_REQUIRED, ++ MD_ERROR_WIN_INVALID_PRINTER_DRIVER_MANIFEST, ++ MD_ERROR_WIN_PRINTER_NOT_SHAREABLE, ++ MD_ERROR_WIN_REQUEST_PAUSED, ++ MD_ERROR_WIN_APPEXEC_CONDITION_NOT_SATISFIED, ++ MD_ERROR_WIN_APPEXEC_HANDLE_INVALIDATED, ++ MD_ERROR_WIN_APPEXEC_INVALID_HOST_GENERATION, ++ MD_ERROR_WIN_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION, ++ MD_ERROR_WIN_APPEXEC_INVALID_HOST_STATE, ++ MD_ERROR_WIN_APPEXEC_NO_DONOR, ++ MD_ERROR_WIN_APPEXEC_HOST_ID_MISMATCH, ++ MD_ERROR_WIN_APPEXEC_UNKNOWN_USER, ++ MD_ERROR_WIN_IO_REISSUE_AS_CACHED, ++ MD_ERROR_WIN_WINS_INTERNAL, ++ MD_ERROR_WIN_CAN_NOT_DEL_LOCAL_WINS, ++ MD_ERROR_WIN_STATIC_INIT, ++ MD_ERROR_WIN_INC_BACKUP, ++ MD_ERROR_WIN_FULL_BACKUP, ++ MD_ERROR_WIN_REC_NON_EXISTENT, ++ MD_ERROR_WIN_RPL_NOT_ALLOWED, ++ MD_ERROR_WIN_DHCP_ADDRESS_CONFLICT, ++ MD_ERROR_WIN_WMI_GUID_NOT_FOUND, ++ MD_ERROR_WIN_WMI_INSTANCE_NOT_FOUND, ++ MD_ERROR_WIN_WMI_ITEMID_NOT_FOUND, ++ MD_ERROR_WIN_WMI_TRY_AGAIN, ++ MD_ERROR_WIN_WMI_DP_NOT_FOUND, ++ MD_ERROR_WIN_WMI_UNRESOLVED_INSTANCE_REF, ++ MD_ERROR_WIN_WMI_ALREADY_ENABLED, ++ MD_ERROR_WIN_WMI_GUID_DISCONNECTED, ++ MD_ERROR_WIN_WMI_SERVER_UNAVAILABLE, ++ MD_ERROR_WIN_WMI_DP_FAILED, ++ MD_ERROR_WIN_WMI_INVALID_MOF, ++ MD_ERROR_WIN_WMI_INVALID_REGINFO, ++ MD_ERROR_WIN_WMI_ALREADY_DISABLED, ++ MD_ERROR_WIN_WMI_READ_ONLY, ++ MD_ERROR_WIN_WMI_SET_FAILURE, ++ MD_ERROR_WIN_NOT_APPCONTAINER, ++ MD_ERROR_WIN_APPCONTAINER_REQUIRED, ++ MD_ERROR_WIN_NOT_SUPPORTED_IN_APPCONTAINER, ++ MD_ERROR_WIN_INVALID_PACKAGE_SID_LENGTH, ++ MD_ERROR_WIN_INVALID_MEDIA, ++ MD_ERROR_WIN_INVALID_LIBRARY, ++ MD_ERROR_WIN_INVALID_MEDIA_POOL, ++ MD_ERROR_WIN_DRIVE_MEDIA_MISMATCH, ++ MD_ERROR_WIN_MEDIA_OFFLINE, ++ MD_ERROR_WIN_LIBRARY_OFFLINE, ++ MD_ERROR_WIN_EMPTY, ++ MD_ERROR_WIN_NOT_EMPTY, ++ MD_ERROR_WIN_MEDIA_UNAVAILABLE, ++ MD_ERROR_WIN_RESOURCE_DISABLED, ++ MD_ERROR_WIN_INVALID_CLEANER, ++ MD_ERROR_WIN_UNABLE_TO_CLEAN, ++ MD_ERROR_WIN_OBJECT_NOT_FOUND, ++ MD_ERROR_WIN_DATABASE_FAILURE, ++ MD_ERROR_WIN_DATABASE_FULL, ++ MD_ERROR_WIN_MEDIA_INCOMPATIBLE, ++ MD_ERROR_WIN_RESOURCE_NOT_PRESENT, ++ MD_ERROR_WIN_INVALID_OPERATION, ++ MD_ERROR_WIN_MEDIA_NOT_AVAILABLE, ++ MD_ERROR_WIN_DEVICE_NOT_AVAILABLE, ++ MD_ERROR_WIN_REQUEST_REFUSED, ++ MD_ERROR_WIN_INVALID_DRIVE_OBJECT, ++ MD_ERROR_WIN_LIBRARY_FULL, ++ MD_ERROR_WIN_MEDIUM_NOT_ACCESSIBLE, ++ MD_ERROR_WIN_UNABLE_TO_LOAD_MEDIUM, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_DRIVE, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_SLOT, ++ MD_ERROR_WIN_UNABLE_TO_INVENTORY_TRANSPORT, ++ MD_ERROR_WIN_TRANSPORT_FULL, ++ MD_ERROR_WIN_CONTROLLING_IEPORT, ++ MD_ERROR_WIN_UNABLE_TO_EJECT_MOUNTED_MEDIA, ++ MD_ERROR_WIN_CLEANER_SLOT_SET, ++ MD_ERROR_WIN_CLEANER_SLOT_NOT_SET, ++ MD_ERROR_WIN_CLEANER_CARTRIDGE_SPENT, ++ MD_ERROR_WIN_UNEXPECTED_OMID, ++ MD_ERROR_WIN_CANT_DELETE_LAST_ITEM, ++ MD_ERROR_WIN_MESSAGE_EXCEEDS_MAX_SIZE, ++ MD_ERROR_WIN_VOLUME_CONTAINS_SYS_FILES, ++ MD_ERROR_WIN_INDIGENOUS_TYPE, ++ MD_ERROR_WIN_NO_SUPPORTING_DRIVES, ++ MD_ERROR_WIN_CLEANER_CARTRIDGE_INSTALLED, ++ MD_ERROR_WIN_IEPORT_FULL, ++ MD_ERROR_WIN_FILE_OFFLINE, ++ MD_ERROR_WIN_REMOTE_STORAGE_NOT_ACTIVE, ++ MD_ERROR_WIN_REMOTE_STORAGE_MEDIA_ERROR, ++ MD_ERROR_WIN_NOT_A_REPARSE_POINT, ++ MD_ERROR_WIN_REPARSE_ATTRIBUTE_CONFLICT, ++ MD_ERROR_WIN_INVALID_REPARSE_DATA, ++ MD_ERROR_WIN_REPARSE_TAG_INVALID, ++ MD_ERROR_WIN_REPARSE_TAG_MISMATCH, ++ MD_ERROR_WIN_REPARSE_POINT_ENCOUNTERED, ++ MD_ERROR_WIN_APP_DATA_NOT_FOUND, ++ MD_ERROR_WIN_APP_DATA_EXPIRED, ++ MD_ERROR_WIN_APP_DATA_CORRUPT, ++ MD_ERROR_WIN_APP_DATA_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_APP_DATA_REBOOT_REQUIRED, ++ MD_ERROR_WIN_SECUREBOOT_ROLLBACK_DETECTED, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_VIOLATION, ++ MD_ERROR_WIN_SECUREBOOT_INVALID_POLICY, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_NOT_SIGNED, ++ MD_ERROR_WIN_SECUREBOOT_NOT_ENABLED, ++ MD_ERROR_WIN_SECUREBOOT_FILE_REPLACED, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_NOT_AUTHORIZED, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_UNKNOWN, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION, ++ MD_ERROR_WIN_SECUREBOOT_PLATFORM_ID_MISMATCH, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_ROLLBACK_DETECTED, ++ MD_ERROR_WIN_SECUREBOOT_POLICY_UPGRADE_MISMATCH, ++ MD_ERROR_WIN_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING, ++ MD_ERROR_WIN_SECUREBOOT_NOT_BASE_POLICY, ++ MD_ERROR_WIN_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY, ++ MD_ERROR_WIN_OFFLOAD_READ_FLT_NOT_SUPPORTED, ++ MD_ERROR_WIN_OFFLOAD_WRITE_FLT_NOT_SUPPORTED, ++ MD_ERROR_WIN_OFFLOAD_READ_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_OFFLOAD_WRITE_FILE_NOT_SUPPORTED, ++ MD_ERROR_WIN_ALREADY_HAS_STREAM_ID, ++ MD_ERROR_WIN_SMR_GARBAGE_COLLECTION_REQUIRED, ++ MD_ERROR_WIN_WOF_WIM_HEADER_CORRUPT, ++ MD_ERROR_WIN_WOF_WIM_RESOURCE_TABLE_CORRUPT, ++ MD_ERROR_WIN_WOF_FILE_RESOURCE_TABLE_CORRUPT, ++ MD_ERROR_WIN_VOLUME_NOT_SIS_ENABLED, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_ROLLBACK_DETECTED, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_POLICY_VIOLATION, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_INVALID_POLICY, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_TOO_MANY_POLICIES, ++ MD_ERROR_WIN_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED, ++ MD_ERROR_WIN_VSM_NOT_INITIALIZED, ++ MD_ERROR_WIN_VSM_DMA_PROTECTION_NOT_IN_USE, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_AUTHORIZED, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_INVALID, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_ACTIVE, ++ MD_ERROR_WIN_PLATFORM_MANIFEST_NOT_SIGNED, ++ MD_ERROR_WIN_DEPENDENT_RESOURCE_EXISTS, ++ MD_ERROR_WIN_DEPENDENCY_NOT_FOUND, ++ MD_ERROR_WIN_DEPENDENCY_ALREADY_EXISTS, ++ MD_ERROR_WIN_RESOURCE_NOT_ONLINE, ++ MD_ERROR_WIN_HOST_NODE_NOT_AVAILABLE, ++ MD_ERROR_WIN_RESOURCE_NOT_AVAILABLE, ++ MD_ERROR_WIN_RESOURCE_NOT_FOUND, ++ MD_ERROR_WIN_SHUTDOWN_CLUSTER, ++ MD_ERROR_WIN_CANT_EVICT_ACTIVE_NODE, ++ MD_ERROR_WIN_OBJECT_ALREADY_EXISTS, ++ MD_ERROR_WIN_OBJECT_IN_LIST, ++ MD_ERROR_WIN_GROUP_NOT_AVAILABLE, ++ MD_ERROR_WIN_GROUP_NOT_FOUND, ++ MD_ERROR_WIN_GROUP_NOT_ONLINE, ++ MD_ERROR_WIN_HOST_NODE_NOT_RESOURCE_OWNER, ++ MD_ERROR_WIN_HOST_NODE_NOT_GROUP_OWNER, ++ MD_ERROR_WIN_RESMON_CREATE_FAILED, ++ MD_ERROR_WIN_RESMON_ONLINE_FAILED, ++ MD_ERROR_WIN_RESOURCE_ONLINE, ++ MD_ERROR_WIN_QUORUM_RESOURCE, ++ MD_ERROR_WIN_NOT_QUORUM_CAPABLE, ++ MD_ERROR_WIN_CLUSTER_SHUTTING_DOWN, ++ MD_ERROR_WIN_INVALID_STATE, ++ MD_ERROR_WIN_RESOURCE_PROPERTIES_STORED, ++ MD_ERROR_WIN_NOT_QUORUM_CLASS, ++ MD_ERROR_WIN_CORE_RESOURCE, ++ MD_ERROR_WIN_QUORUM_RESOURCE_ONLINE_FAILED, ++ MD_ERROR_WIN_QUORUMLOG_OPEN_FAILED, ++ MD_ERROR_WIN_CLUSTERLOG_CORRUPT, ++ MD_ERROR_WIN_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE, ++ MD_ERROR_WIN_CLUSTERLOG_EXCEEDS_MAXSIZE, ++ MD_ERROR_WIN_CLUSTERLOG_CHKPOINT_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTERLOG_NOT_ENOUGH_SPACE, ++ MD_ERROR_WIN_QUORUM_OWNER_ALIVE, ++ MD_ERROR_WIN_NETWORK_NOT_AVAILABLE, ++ MD_ERROR_WIN_NODE_NOT_AVAILABLE, ++ MD_ERROR_WIN_ALL_NODES_NOT_AVAILABLE, ++ MD_ERROR_WIN_RESOURCE_FAILED, ++ MD_ERROR_WIN_CLUSTER_INVALID_NODE, ++ MD_ERROR_WIN_CLUSTER_NODE_EXISTS, ++ MD_ERROR_WIN_CLUSTER_JOIN_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_LOCAL_NODE_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_NETWORK_EXISTS, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_NETINTERFACE_EXISTS, ++ MD_ERROR_WIN_CLUSTER_NETINTERFACE_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_INVALID_REQUEST, ++ MD_ERROR_WIN_CLUSTER_INVALID_NETWORK_PROVIDER, ++ MD_ERROR_WIN_CLUSTER_NODE_DOWN, ++ MD_ERROR_WIN_CLUSTER_NODE_UNREACHABLE, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_MEMBER, ++ MD_ERROR_WIN_CLUSTER_JOIN_NOT_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_INVALID_NETWORK, ++ MD_ERROR_WIN_CLUSTER_NODE_UP, ++ MD_ERROR_WIN_CLUSTER_IPADDR_IN_USE, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_PAUSED, ++ MD_ERROR_WIN_CLUSTER_NO_SECURITY_CONTEXT, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_INTERNAL, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_UP, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_DOWN, ++ MD_ERROR_WIN_CLUSTER_NETWORK_ALREADY_ONLINE, ++ MD_ERROR_WIN_CLUSTER_NETWORK_ALREADY_OFFLINE, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_MEMBER, ++ MD_ERROR_WIN_CLUSTER_LAST_INTERNAL_NETWORK, ++ MD_ERROR_WIN_CLUSTER_NETWORK_HAS_DEPENDENTS, ++ MD_ERROR_WIN_INVALID_OPERATION_ON_QUORUM, ++ MD_ERROR_WIN_DEPENDENCY_NOT_ALLOWED, ++ MD_ERROR_WIN_CLUSTER_NODE_PAUSED, ++ MD_ERROR_WIN_NODE_CANT_HOST_RESOURCE, ++ MD_ERROR_WIN_CLUSTER_NODE_NOT_READY, ++ MD_ERROR_WIN_CLUSTER_NODE_SHUTTING_DOWN, ++ MD_ERROR_WIN_CLUSTER_JOIN_ABORTED, ++ MD_ERROR_WIN_CLUSTER_INCOMPATIBLE_VERSIONS, ++ MD_ERROR_WIN_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED, ++ MD_ERROR_WIN_CLUSTER_SYSTEM_CONFIG_CHANGED, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_TYPE_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_RESTYPE_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLUSTER_RESNAME_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_NO_RPC_PACKAGES_REGISTERED, ++ MD_ERROR_WIN_CLUSTER_OWNER_NOT_IN_PREFLIST, ++ MD_ERROR_WIN_CLUSTER_DATABASE_SEQMISMATCH, ++ MD_ERROR_WIN_RESMON_INVALID_STATE, ++ MD_ERROR_WIN_CLUSTER_GUM_NOT_LOCKER, ++ MD_ERROR_WIN_QUORUM_DISK_NOT_FOUND, ++ MD_ERROR_WIN_DATABASE_BACKUP_CORRUPT, ++ MD_ERROR_WIN_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT, ++ MD_ERROR_WIN_RESOURCE_PROPERTY_UNCHANGEABLE, ++ MD_ERROR_WIN_NO_ADMIN_ACCESS_POINT, ++ MD_ERROR_WIN_CLUSTER_MEMBERSHIP_INVALID_STATE, ++ MD_ERROR_WIN_CLUSTER_QUORUMLOG_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_MEMBERSHIP_HALT, ++ MD_ERROR_WIN_CLUSTER_INSTANCE_ID_MISMATCH, ++ MD_ERROR_WIN_CLUSTER_NETWORK_NOT_FOUND_FOR_IP, ++ MD_ERROR_WIN_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH, ++ MD_ERROR_WIN_CLUSTER_EVICT_WITHOUT_CLEANUP, ++ MD_ERROR_WIN_CLUSTER_PARAMETER_MISMATCH, ++ MD_ERROR_WIN_NODE_CANNOT_BE_CLUSTERED, ++ MD_ERROR_WIN_CLUSTER_WRONG_OS_VERSION, ++ MD_ERROR_WIN_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME, ++ MD_ERROR_WIN_CLUSCFG_ALREADY_COMMITTED, ++ MD_ERROR_WIN_CLUSCFG_ROLLBACK_FAILED, ++ MD_ERROR_WIN_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT, ++ MD_ERROR_WIN_CLUSTER_OLD_VERSION, ++ MD_ERROR_WIN_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME, ++ MD_ERROR_WIN_CLUSTER_NO_NET_ADAPTERS, ++ MD_ERROR_WIN_CLUSTER_POISONED, ++ MD_ERROR_WIN_CLUSTER_GROUP_MOVING, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_TYPE_BUSY, ++ MD_ERROR_WIN_RESOURCE_CALL_TIMED_OUT, ++ MD_ERROR_WIN_INVALID_CLUSTER_IPV6_ADDRESS, ++ MD_ERROR_WIN_CLUSTER_INTERNAL_INVALID_FUNCTION, ++ MD_ERROR_WIN_CLUSTER_PARAMETER_OUT_OF_BOUNDS, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_SEND, ++ MD_ERROR_WIN_CLUSTER_REGISTRY_INVALID_FUNCTION, ++ MD_ERROR_WIN_CLUSTER_INVALID_STRING_TERMINATION, ++ MD_ERROR_WIN_CLUSTER_INVALID_STRING_FORMAT, ++ MD_ERROR_WIN_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_NULL_DATA, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_READ, ++ MD_ERROR_WIN_CLUSTER_PARTIAL_WRITE, ++ MD_ERROR_WIN_CLUSTER_CANT_DESERIALIZE_DATA, ++ MD_ERROR_WIN_DEPENDENT_RESOURCE_PROPERTY_CONFLICT, ++ MD_ERROR_WIN_CLUSTER_NO_QUORUM, ++ MD_ERROR_WIN_CLUSTER_INVALID_IPV6_NETWORK, ++ MD_ERROR_WIN_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK, ++ MD_ERROR_WIN_QUORUM_NOT_ALLOWED_IN_THIS_GROUP, ++ MD_ERROR_WIN_DEPENDENCY_TREE_TOO_COMPLEX, ++ MD_ERROR_WIN_EXCEPTION_IN_RESOURCE_CALL, ++ MD_ERROR_WIN_CLUSTER_RHS_FAILED_INITIALIZATION, ++ MD_ERROR_WIN_CLUSTER_NOT_INSTALLED, ++ MD_ERROR_WIN_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODE, ++ MD_ERROR_WIN_CLUSTER_MAX_NODES_IN_CLUSTER, ++ MD_ERROR_WIN_CLUSTER_TOO_MANY_NODES, ++ MD_ERROR_WIN_CLUSTER_OBJECT_ALREADY_USED, ++ MD_ERROR_WIN_NONCORE_GROUPS_FOUND, ++ MD_ERROR_WIN_FILE_SHARE_RESOURCE_CONFLICT, ++ MD_ERROR_WIN_CLUSTER_EVICT_INVALID_REQUEST, ++ MD_ERROR_WIN_CLUSTER_SINGLETON_RESOURCE, ++ MD_ERROR_WIN_CLUSTER_GROUP_SINGLETON_RESOURCE, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_PROVIDER_FAILED, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_CONFIGURATION_ERROR, ++ MD_ERROR_WIN_CLUSTER_GROUP_BUSY, ++ MD_ERROR_WIN_CLUSTER_NOT_SHARED_VOLUME, ++ MD_ERROR_WIN_CLUSTER_INVALID_SECURITY_DESCRIPTOR, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUMES_IN_USE, ++ MD_ERROR_WIN_CLUSTER_USE_SHARED_VOLUMES_API, ++ MD_ERROR_WIN_CLUSTER_BACKUP_IN_PROGRESS, ++ MD_ERROR_WIN_NON_CSV_PATH, ++ MD_ERROR_WIN_CSV_VOLUME_NOT_LOCAL, ++ MD_ERROR_WIN_CLUSTER_WATCHDOG_TERMINATING, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODES, ++ MD_ERROR_WIN_CLUSTER_INVALID_NODE_WEIGHT, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_CALL, ++ MD_ERROR_WIN_RESMON_SYSTEM_RESOURCES_LACKING, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATION, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCE, ++ MD_ERROR_WIN_CLUSTER_GROUP_QUEUED, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_LOCKED_STATUS, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWED, ++ MD_ERROR_WIN_CLUSTER_NODE_DRAIN_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_DISK_NOT_CONNECTED, ++ MD_ERROR_WIN_DISK_NOT_CSV_CAPABLE, ++ MD_ERROR_WIN_RESOURCE_NOT_IN_AVAILABLE_STORAGE, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_REDIRECTED, ++ MD_ERROR_WIN_CLUSTER_SHARED_VOLUME_NOT_REDIRECTED, ++ MD_ERROR_WIN_CLUSTER_CANNOT_RETURN_PROPERTIES, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMES, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODE, ++ MD_ERROR_WIN_CLUSTER_AFFINITY_CONFLICT, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINE, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_INCOMPATIBLE_VERSIONS, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_FIX_QUORUM_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_RESTART_REQUIRED, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_IN_PROGRESS, ++ MD_ERROR_WIN_CLUSTER_UPGRADE_INCOMPLETE, ++ MD_ERROR_WIN_CLUSTER_NODE_IN_GRACE_PERIOD, ++ MD_ERROR_WIN_CLUSTER_CSV_IO_PAUSE_TIMEOUT, ++ MD_ERROR_WIN_NODE_NOT_ACTIVE_CLUSTER_MEMBER, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_NOT_MONITORED, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_DOES_NOT_SUPPORT_UNMONITORED, ++ MD_ERROR_WIN_CLUSTER_RESOURCE_IS_REPLICATED, ++ MD_ERROR_WIN_CLUSTER_NODE_ISOLATED, ++ MD_ERROR_WIN_CLUSTER_NODE_QUARANTINED, ++ MD_ERROR_WIN_CLUSTER_DATABASE_UPDATE_CONDITION_FAILED, ++ MD_ERROR_WIN_CLUSTER_SPACE_DEGRADED, ++ MD_ERROR_WIN_CLUSTER_TOKEN_DELEGATION_NOT_SUPPORTED, ++ MD_ERROR_WIN_CLUSTER_CSV_INVALID_HANDLE, ++ MD_ERROR_WIN_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR, ++ MD_ERROR_WIN_GROUPSET_NOT_AVAILABLE, ++ MD_ERROR_WIN_GROUPSET_NOT_FOUND, ++ MD_ERROR_WIN_GROUPSET_CANT_PROVIDE, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_PARENT_NOT_FOUND, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_INVALID_HIERARCHY, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_FAILED_S2D_VALIDATION, ++ MD_ERROR_WIN_CLUSTER_FAULT_DOMAIN_S2D_CONNECTIVITY_LOSS, ++ MD_ERROR_WIN_CLUSTER_INVALID_INFRASTRUCTURE_FILESERVER_NAME, ++ MD_ERROR_WIN_CLUSTERSET_MANAGEMENT_CLUSTER_UNREACHABLE, ++ MD_ERROR_WIN_ENCRYPTION_FAILED, ++ MD_ERROR_WIN_DECRYPTION_FAILED, ++ MD_ERROR_WIN_FILE_ENCRYPTED, ++ MD_ERROR_WIN_NO_RECOVERY_POLICY, ++ MD_ERROR_WIN_NO_EFS, ++ MD_ERROR_WIN_WRONG_EFS, ++ MD_ERROR_WIN_NO_USER_KEYS, ++ MD_ERROR_WIN_FILE_NOT_ENCRYPTED, ++ MD_ERROR_WIN_NOT_EXPORT_FORMAT, ++ MD_ERROR_WIN_FILE_READ_ONLY, ++ MD_ERROR_WIN_DIR_EFS_DISALLOWED, ++ MD_ERROR_WIN_EFS_SERVER_NOT_TRUSTED, ++ MD_ERROR_WIN_BAD_RECOVERY_POLICY, ++ MD_ERROR_WIN_EFS_ALG_BLOB_TOO_BIG, ++ MD_ERROR_WIN_VOLUME_NOT_SUPPORT_EFS, ++ MD_ERROR_WIN_EFS_DISABLED, ++ MD_ERROR_WIN_EFS_VERSION_NOT_SUPPORT, ++ MD_ERROR_WIN_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, ++ MD_ERROR_WIN_CS_ENCRYPTION_UNSUPPORTED_SERVER, ++ MD_ERROR_WIN_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, ++ MD_ERROR_WIN_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, ++ MD_ERROR_WIN_CS_ENCRYPTION_FILE_NOT_CSE, ++ MD_ERROR_WIN_ENCRYPTION_POLICY_DENIES_OPERATION, ++ MD_ERROR_WIN_WIP_ENCRYPTION_FAILED, ++ MD_ERROR_WIN_NO_BROWSER_SERVERS_FOUND, ++ MD_ERROR_WIN_CLUSTER_OBJECT_IS_CLUSTER_SET_VM, ++ MD_ERROR_WIN_LOG_SECTOR_INVALID, ++ MD_ERROR_WIN_LOG_SECTOR_PARITY_INVALID, ++ MD_ERROR_WIN_LOG_SECTOR_REMAPPED, ++ MD_ERROR_WIN_LOG_BLOCK_INCOMPLETE, ++ MD_ERROR_WIN_LOG_INVALID_RANGE, ++ MD_ERROR_WIN_LOG_BLOCKS_EXHAUSTED, ++ MD_ERROR_WIN_LOG_READ_CONTEXT_INVALID, ++ MD_ERROR_WIN_LOG_RESTART_INVALID, ++ MD_ERROR_WIN_LOG_BLOCK_VERSION, ++ MD_ERROR_WIN_LOG_BLOCK_INVALID, ++ MD_ERROR_WIN_LOG_READ_MODE_INVALID, ++ MD_ERROR_WIN_LOG_NO_RESTART, ++ MD_ERROR_WIN_LOG_METADATA_CORRUPT, ++ MD_ERROR_WIN_LOG_METADATA_INVALID, ++ MD_ERROR_WIN_LOG_METADATA_INCONSISTENT, ++ MD_ERROR_WIN_LOG_RESERVATION_INVALID, ++ MD_ERROR_WIN_LOG_CANT_DELETE, ++ MD_ERROR_WIN_LOG_CONTAINER_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_LOG_START_OF_LOG, ++ MD_ERROR_WIN_LOG_POLICY_ALREADY_INSTALLED, ++ MD_ERROR_WIN_LOG_POLICY_NOT_INSTALLED, ++ MD_ERROR_WIN_LOG_POLICY_INVALID, ++ MD_ERROR_WIN_LOG_POLICY_CONFLICT, ++ MD_ERROR_WIN_LOG_PINNED_ARCHIVE_TAIL, ++ MD_ERROR_WIN_LOG_RECORD_NONEXISTENT, ++ MD_ERROR_WIN_LOG_RECORDS_RESERVED_INVALID, ++ MD_ERROR_WIN_LOG_SPACE_RESERVED_INVALID, ++ MD_ERROR_WIN_LOG_TAIL_INVALID, ++ MD_ERROR_WIN_LOG_FULL, ++ MD_ERROR_WIN_COULD_NOT_RESIZE_LOG, ++ MD_ERROR_WIN_LOG_MULTIPLEXED, ++ MD_ERROR_WIN_LOG_DEDICATED, ++ MD_ERROR_WIN_LOG_ARCHIVE_NOT_IN_PROGRESS, ++ MD_ERROR_WIN_LOG_ARCHIVE_IN_PROGRESS, ++ MD_ERROR_WIN_LOG_EPHEMERAL, ++ MD_ERROR_WIN_LOG_NOT_ENOUGH_CONTAINERS, ++ MD_ERROR_WIN_LOG_CLIENT_ALREADY_REGISTERED, ++ MD_ERROR_WIN_LOG_CLIENT_NOT_REGISTERED, ++ MD_ERROR_WIN_LOG_FULL_HANDLER_IN_PROGRESS, ++ MD_ERROR_WIN_LOG_CONTAINER_READ_FAILED, ++ MD_ERROR_WIN_LOG_CONTAINER_WRITE_FAILED, ++ MD_ERROR_WIN_LOG_CONTAINER_OPEN_FAILED, ++ MD_ERROR_WIN_LOG_CONTAINER_STATE_INVALID, ++ MD_ERROR_WIN_LOG_STATE_INVALID, ++ MD_ERROR_WIN_LOG_PINNED, ++ MD_ERROR_WIN_LOG_METADATA_FLUSH_FAILED, ++ MD_ERROR_WIN_LOG_INCONSISTENT_SECURITY, ++ MD_ERROR_WIN_LOG_APPENDED_FLUSH_FAILED, ++ MD_ERROR_WIN_LOG_PINNED_RESERVATION, ++ MD_ERROR_WIN_INVALID_TRANSACTION, ++ MD_ERROR_WIN_TRANSACTION_NOT_ACTIVE, ++ MD_ERROR_WIN_TRANSACTION_REQUEST_NOT_VALID, ++ MD_ERROR_WIN_TRANSACTION_NOT_REQUESTED, ++ MD_ERROR_WIN_TRANSACTION_ALREADY_ABORTED, ++ MD_ERROR_WIN_TRANSACTION_ALREADY_COMMITTED, ++ MD_ERROR_WIN_TM_INITIALIZATION_FAILED, ++ MD_ERROR_WIN_RESOURCEMANAGER_READ_ONLY, ++ MD_ERROR_WIN_TRANSACTION_NOT_JOINED, ++ MD_ERROR_WIN_TRANSACTION_SUPERIOR_EXISTS, ++ MD_ERROR_WIN_CRM_PROTOCOL_ALREADY_EXISTS, ++ MD_ERROR_WIN_TRANSACTION_PROPAGATION_FAILED, ++ MD_ERROR_WIN_CRM_PROTOCOL_NOT_FOUND, ++ MD_ERROR_WIN_TRANSACTION_INVALID_MARSHALL_BUFFER, ++ MD_ERROR_WIN_CURRENT_TRANSACTION_NOT_VALID, ++ MD_ERROR_WIN_TRANSACTION_NOT_FOUND, ++ MD_ERROR_WIN_RESOURCEMANAGER_NOT_FOUND, ++ MD_ERROR_WIN_ENLISTMENT_NOT_FOUND, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_NOT_FOUND, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_NOT_ONLINE, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, ++ MD_ERROR_WIN_TRANSACTION_NOT_ROOT, ++ MD_ERROR_WIN_TRANSACTION_OBJECT_EXPIRED, ++ MD_ERROR_WIN_TRANSACTION_RESPONSE_NOT_ENLISTED, ++ MD_ERROR_WIN_TRANSACTION_RECORD_TOO_LONG, ++ MD_ERROR_WIN_IMPLICIT_TRANSACTION_NOT_SUPPORTED, ++ MD_ERROR_WIN_TRANSACTION_INTEGRITY_VIOLATED, ++ MD_ERROR_WIN_TRANSACTIONMANAGER_IDENTITY_MISMATCH, ++ MD_ERROR_WIN_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT, ++ MD_ERROR_WIN_TRANSACTION_MUST_WRITETHROUGH, ++ MD_ERROR_WIN_TRANSACTION_NO_SUPERIOR, ++ MD_ERROR_WIN_HEURISTIC_DAMAGE_POSSIBLE, ++ MD_ERROR_WIN_TRANSACTIONAL_CONFLICT, ++ MD_ERROR_WIN_RM_NOT_ACTIVE, ++ MD_ERROR_WIN_RM_METADATA_CORRUPT, ++ MD_ERROR_WIN_DIRECTORY_NOT_RM, ++ MD_ERROR_WIN_TRANSACTIONS_UNSUPPORTED_REMOTE, ++ MD_ERROR_WIN_LOG_RESIZE_INVALID_SIZE, ++ MD_ERROR_WIN_OBJECT_NO_LONGER_EXISTS, ++ MD_ERROR_WIN_STREAM_MINIVERSION_NOT_FOUND, ++ MD_ERROR_WIN_STREAM_MINIVERSION_NOT_VALID, ++ MD_ERROR_WIN_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, ++ MD_ERROR_WIN_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, ++ MD_ERROR_WIN_CANT_CREATE_MORE_STREAM_MINIVERSIONS, ++ MD_ERROR_WIN_REMOTE_FILE_VERSION_MISMATCH, ++ MD_ERROR_WIN_HANDLE_NO_LONGER_VALID, ++ MD_ERROR_WIN_NO_TXF_METADATA, ++ MD_ERROR_WIN_LOG_CORRUPTION_DETECTED, ++ MD_ERROR_WIN_CANT_RECOVER_WITH_HANDLE_OPEN, ++ MD_ERROR_WIN_RM_DISCONNECTED, ++ MD_ERROR_WIN_ENLISTMENT_NOT_SUPERIOR, ++ MD_ERROR_WIN_RECOVERY_NOT_NEEDED, ++ MD_ERROR_WIN_RM_ALREADY_STARTED, ++ MD_ERROR_WIN_FILE_IDENTITY_NOT_PERSISTENT, ++ MD_ERROR_WIN_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, ++ MD_ERROR_WIN_CANT_CROSS_RM_BOUNDARY, ++ MD_ERROR_WIN_TXF_DIR_NOT_EMPTY, ++ MD_ERROR_WIN_INDOUBT_TRANSACTIONS_EXIST, ++ MD_ERROR_WIN_TM_VOLATILE, ++ MD_ERROR_WIN_ROLLBACK_TIMER_EXPIRED, ++ MD_ERROR_WIN_TXF_ATTRIBUTE_CORRUPT, ++ MD_ERROR_WIN_EFS_NOT_ALLOWED_IN_TRANSACTION, ++ MD_ERROR_WIN_TRANSACTIONAL_OPEN_NOT_ALLOWED, ++ MD_ERROR_WIN_LOG_GROWTH_FAILED, ++ MD_ERROR_WIN_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, ++ MD_ERROR_WIN_TXF_METADATA_ALREADY_PRESENT, ++ MD_ERROR_WIN_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, ++ MD_ERROR_WIN_TRANSACTION_REQUIRED_PROMOTION, ++ MD_ERROR_WIN_CANNOT_EXECUTE_FILE_IN_TRANSACTION, ++ MD_ERROR_WIN_TRANSACTIONS_NOT_FROZEN, ++ MD_ERROR_WIN_TRANSACTION_FREEZE_IN_PROGRESS, ++ MD_ERROR_WIN_NOT_SNAPSHOT_VOLUME, ++ MD_ERROR_WIN_NO_SAVEPOINT_WITH_OPEN_FILES, ++ MD_ERROR_WIN_DATA_LOST_REPAIR, ++ MD_ERROR_WIN_SPARSE_NOT_ALLOWED_IN_TRANSACTION, ++ MD_ERROR_WIN_TM_IDENTITY_MISMATCH, ++ MD_ERROR_WIN_FLOATED_SECTION, ++ MD_ERROR_WIN_CANNOT_ACCEPT_TRANSACTED_WORK, ++ MD_ERROR_WIN_CANNOT_ABORT_TRANSACTIONS, ++ MD_ERROR_WIN_BAD_CLUSTERS, ++ MD_ERROR_WIN_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION, ++ MD_ERROR_WIN_VOLUME_DIRTY, ++ MD_ERROR_WIN_NO_LINK_TRACKING_IN_TRANSACTION, ++ MD_ERROR_WIN_OPERATION_NOT_SUPPORTED_IN_TRANSACTION, ++ MD_ERROR_WIN_EXPIRED_HANDLE, ++ MD_ERROR_WIN_TRANSACTION_NOT_ENLISTED, ++ MD_ERROR_WIN_CTX_WINSTATION_NAME_INVALID, ++ MD_ERROR_WIN_CTX_INVALID_PD, ++ MD_ERROR_WIN_CTX_PD_NOT_FOUND, ++ MD_ERROR_WIN_CTX_WD_NOT_FOUND, ++ MD_ERROR_WIN_CTX_CANNOT_MAKE_EVENTLOG_ENTRY, ++ MD_ERROR_WIN_CTX_SERVICE_NAME_COLLISION, ++ MD_ERROR_WIN_CTX_CLOSE_PENDING, ++ MD_ERROR_WIN_CTX_NO_OUTBUF, ++ MD_ERROR_WIN_CTX_MODEM_INF_NOT_FOUND, ++ MD_ERROR_WIN_CTX_INVALID_MODEMNAME, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_ERROR, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_TIMEOUT, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_NO_CARRIER, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_NO_DIALTONE, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_BUSY, ++ MD_ERROR_WIN_CTX_MODEM_RESPONSE_VOICE, ++ MD_ERROR_WIN_CTX_TD_ERROR, ++ MD_ERROR_WIN_CTX_WINSTATION_NOT_FOUND, ++ MD_ERROR_WIN_CTX_WINSTATION_ALREADY_EXISTS, ++ MD_ERROR_WIN_CTX_WINSTATION_BUSY, ++ MD_ERROR_WIN_CTX_BAD_VIDEO_MODE, ++ MD_ERROR_WIN_CTX_GRAPHICS_INVALID, ++ MD_ERROR_WIN_CTX_LOGON_DISABLED, ++ MD_ERROR_WIN_CTX_NOT_CONSOLE, ++ MD_ERROR_WIN_CTX_CLIENT_QUERY_TIMEOUT, ++ MD_ERROR_WIN_CTX_CONSOLE_DISCONNECT, ++ MD_ERROR_WIN_CTX_CONSOLE_CONNECT, ++ MD_ERROR_WIN_CTX_SHADOW_DENIED, ++ MD_ERROR_WIN_CTX_WINSTATION_ACCESS_DENIED, ++ MD_ERROR_WIN_CTX_INVALID_WD, ++ MD_ERROR_WIN_CTX_SHADOW_INVALID, ++ MD_ERROR_WIN_CTX_SHADOW_DISABLED, ++ MD_ERROR_WIN_CTX_CLIENT_LICENSE_IN_USE, ++ MD_ERROR_WIN_CTX_CLIENT_LICENSE_NOT_SET, ++ MD_ERROR_WIN_CTX_LICENSE_NOT_AVAILABLE, ++ MD_ERROR_WIN_CTX_LICENSE_CLIENT_INVALID, ++ MD_ERROR_WIN_CTX_LICENSE_EXPIRED, ++ MD_ERROR_WIN_CTX_SHADOW_NOT_RUNNING, ++ MD_ERROR_WIN_CTX_SHADOW_ENDED_BY_MODE_CHANGE, ++ MD_ERROR_WIN_ACTIVATION_COUNT_EXCEEDED, ++ MD_ERROR_WIN_CTX_WINSTATIONS_DISABLED, ++ MD_ERROR_WIN_CTX_ENCRYPTION_LEVEL_REQUIRED, ++ MD_ERROR_WIN_CTX_SESSION_IN_USE, ++ MD_ERROR_WIN_CTX_NO_FORCE_LOGOFF, ++ MD_ERROR_WIN_CTX_ACCOUNT_RESTRICTION, ++ MD_ERROR_WIN_RDP_PROTOCOL_ERROR, ++ MD_ERROR_WIN_CTX_CDM_CONNECT, ++ MD_ERROR_WIN_CTX_CDM_DISCONNECT, ++ MD_ERROR_WIN_CTX_SECURITY_LAYER_ERROR, ++ MD_ERROR_WIN_TS_INCOMPATIBLE_SESSIONS, ++ MD_ERROR_WIN_TS_VIDEO_SUBSYSTEM_ERROR, ++ MD_ERROR_WIN_DS_NOT_INSTALLED, ++ MD_ERROR_WIN_DS_MEMBERSHIP_EVALUATED_LOCALLY, ++ MD_ERROR_WIN_DS_NO_ATTRIBUTE_OR_VALUE, ++ MD_ERROR_WIN_DS_INVALID_ATTRIBUTE_SYNTAX, ++ MD_ERROR_WIN_DS_ATTRIBUTE_TYPE_UNDEFINED, ++ MD_ERROR_WIN_DS_ATTRIBUTE_OR_VALUE_EXISTS, ++ MD_ERROR_WIN_DS_BUSY, ++ MD_ERROR_WIN_DS_UNAVAILABLE, ++ MD_ERROR_WIN_DS_NO_RIDS_ALLOCATED, ++ MD_ERROR_WIN_DS_NO_MORE_RIDS, ++ MD_ERROR_WIN_DS_INCORRECT_ROLE_OWNER, ++ MD_ERROR_WIN_DS_RIDMGR_INIT_ERROR, ++ MD_ERROR_WIN_DS_OBJ_CLASS_VIOLATION, ++ MD_ERROR_WIN_DS_CANT_ON_NON_LEAF, ++ MD_ERROR_WIN_DS_CANT_ON_RDN, ++ MD_ERROR_WIN_DS_CANT_MOD_OBJ_CLASS, ++ MD_ERROR_WIN_DS_CROSS_DOM_MOVE_ERROR, ++ MD_ERROR_WIN_DS_GC_NOT_AVAILABLE, ++ MD_ERROR_WIN_SHARED_POLICY, ++ MD_ERROR_WIN_POLICY_OBJECT_NOT_FOUND, ++ MD_ERROR_WIN_POLICY_ONLY_IN_DS, ++ MD_ERROR_WIN_PROMOTION_ACTIVE, ++ MD_ERROR_WIN_NO_PROMOTION_ACTIVE, ++ MD_ERROR_WIN_DS_OPERATIONS_ERROR, ++ MD_ERROR_WIN_DS_PROTOCOL_ERROR, ++ MD_ERROR_WIN_DS_TIMELIMIT_EXCEEDED, ++ MD_ERROR_WIN_DS_SIZELIMIT_EXCEEDED, ++ MD_ERROR_WIN_DS_ADMIN_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_DS_COMPARE_FALSE, ++ MD_ERROR_WIN_DS_COMPARE_TRUE, ++ MD_ERROR_WIN_DS_AUTH_METHOD_NOT_SUPPORTED, ++ MD_ERROR_WIN_DS_STRONG_AUTH_REQUIRED, ++ MD_ERROR_WIN_DS_INAPPROPRIATE_AUTH, ++ MD_ERROR_WIN_DS_AUTH_UNKNOWN, ++ MD_ERROR_WIN_DS_REFERRAL, ++ MD_ERROR_WIN_DS_UNAVAILABLE_CRIT_EXTENSION, ++ MD_ERROR_WIN_DS_CONFIDENTIALITY_REQUIRED, ++ MD_ERROR_WIN_DS_INAPPROPRIATE_MATCHING, ++ MD_ERROR_WIN_DS_CONSTRAINT_VIOLATION, ++ MD_ERROR_WIN_DS_NO_SUCH_OBJECT, ++ MD_ERROR_WIN_DS_ALIAS_PROBLEM, ++ MD_ERROR_WIN_DS_INVALID_DN_SYNTAX, ++ MD_ERROR_WIN_DS_IS_LEAF, ++ MD_ERROR_WIN_DS_ALIAS_DEREF_PROBLEM, ++ MD_ERROR_WIN_DS_UNWILLING_TO_PERFORM, ++ MD_ERROR_WIN_DS_LOOP_DETECT, ++ MD_ERROR_WIN_DS_NAMING_VIOLATION, ++ MD_ERROR_WIN_DS_OBJECT_RESULTS_TOO_LARGE, ++ MD_ERROR_WIN_DS_AFFECTS_MULTIPLE_DSAS, ++ MD_ERROR_WIN_DS_SERVER_DOWN, ++ MD_ERROR_WIN_DS_LOCAL_ERROR, ++ MD_ERROR_WIN_DS_ENCODING_ERROR, ++ MD_ERROR_WIN_DS_DECODING_ERROR, ++ MD_ERROR_WIN_DS_FILTER_UNKNOWN, ++ MD_ERROR_WIN_DS_PARAM_ERROR, ++ MD_ERROR_WIN_DS_NOT_SUPPORTED, ++ MD_ERROR_WIN_DS_NO_RESULTS_RETURNED, ++ MD_ERROR_WIN_DS_CONTROL_NOT_FOUND, ++ MD_ERROR_WIN_DS_CLIENT_LOOP, ++ MD_ERROR_WIN_DS_REFERRAL_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_DS_SORT_CONTROL_MISSING, ++ MD_ERROR_WIN_DS_OFFSET_RANGE_ERROR, ++ MD_ERROR_WIN_DS_RIDMGR_DISABLED, ++ MD_ERROR_WIN_DS_ROOT_MUST_BE_NC, ++ MD_ERROR_WIN_DS_ADD_REPLICA_INHIBITED, ++ MD_ERROR_WIN_DS_ATT_NOT_DEF_IN_SCHEMA, ++ MD_ERROR_WIN_DS_MAX_OBJ_SIZE_EXCEEDED, ++ MD_ERROR_WIN_DS_OBJ_STRING_NAME_EXISTS, ++ MD_ERROR_WIN_DS_NO_RDN_DEFINED_IN_SCHEMA, ++ MD_ERROR_WIN_DS_RDN_DOESNT_MATCH_SCHEMA, ++ MD_ERROR_WIN_DS_NO_REQUESTED_ATTS_FOUND, ++ MD_ERROR_WIN_DS_USER_BUFFER_TO_SMALL, ++ MD_ERROR_WIN_DS_ATT_IS_NOT_ON_OBJ, ++ MD_ERROR_WIN_DS_ILLEGAL_MOD_OPERATION, ++ MD_ERROR_WIN_DS_OBJ_TOO_LARGE, ++ MD_ERROR_WIN_DS_BAD_INSTANCE_TYPE, ++ MD_ERROR_WIN_DS_MASTERDSA_REQUIRED, ++ MD_ERROR_WIN_DS_OBJECT_CLASS_REQUIRED, ++ MD_ERROR_WIN_DS_MISSING_REQUIRED_ATT, ++ MD_ERROR_WIN_DS_ATT_NOT_DEF_FOR_CLASS, ++ MD_ERROR_WIN_DS_ATT_ALREADY_EXISTS, ++ MD_ERROR_WIN_DS_CANT_ADD_ATT_VALUES, ++ MD_ERROR_WIN_DS_SINGLE_VALUE_CONSTRAINT, ++ MD_ERROR_WIN_DS_RANGE_CONSTRAINT, ++ MD_ERROR_WIN_DS_ATT_VAL_ALREADY_EXISTS, ++ MD_ERROR_WIN_DS_CANT_REM_MISSING_ATT, ++ MD_ERROR_WIN_DS_CANT_REM_MISSING_ATT_VAL, ++ MD_ERROR_WIN_DS_ROOT_CANT_BE_SUBREF, ++ MD_ERROR_WIN_DS_NO_CHAINING, ++ MD_ERROR_WIN_DS_NO_CHAINED_EVAL, ++ MD_ERROR_WIN_DS_NO_PARENT_OBJECT, ++ MD_ERROR_WIN_DS_PARENT_IS_AN_ALIAS, ++ MD_ERROR_WIN_DS_CANT_MIX_MASTER_AND_REPS, ++ MD_ERROR_WIN_DS_CHILDREN_EXIST, ++ MD_ERROR_WIN_DS_OBJ_NOT_FOUND, ++ MD_ERROR_WIN_DS_ALIASED_OBJ_MISSING, ++ MD_ERROR_WIN_DS_BAD_NAME_SYNTAX, ++ MD_ERROR_WIN_DS_ALIAS_POINTS_TO_ALIAS, ++ MD_ERROR_WIN_DS_CANT_DEREF_ALIAS, ++ MD_ERROR_WIN_DS_OUT_OF_SCOPE, ++ MD_ERROR_WIN_DS_OBJECT_BEING_REMOVED, ++ MD_ERROR_WIN_DS_CANT_DELETE_DSA_OBJ, ++ MD_ERROR_WIN_DS_GENERIC_ERROR, ++ MD_ERROR_WIN_DS_DSA_MUST_BE_INT_MASTER, ++ MD_ERROR_WIN_DS_CLASS_NOT_DSA, ++ MD_ERROR_WIN_DS_INSUFF_ACCESS_RIGHTS, ++ MD_ERROR_WIN_DS_ILLEGAL_SUPERIOR, ++ MD_ERROR_WIN_DS_ATTRIBUTE_OWNED_BY_SAM, ++ MD_ERROR_WIN_DS_NAME_TOO_MANY_PARTS, ++ MD_ERROR_WIN_DS_NAME_TOO_LONG, ++ MD_ERROR_WIN_DS_NAME_VALUE_TOO_LONG, ++ MD_ERROR_WIN_DS_NAME_UNPARSEABLE, ++ MD_ERROR_WIN_DS_NAME_TYPE_UNKNOWN, ++ MD_ERROR_WIN_DS_NOT_AN_OBJECT, ++ MD_ERROR_WIN_DS_SEC_DESC_TOO_SHORT, ++ MD_ERROR_WIN_DS_SEC_DESC_INVALID, ++ MD_ERROR_WIN_DS_NO_DELETED_NAME, ++ MD_ERROR_WIN_DS_SUBREF_MUST_HAVE_PARENT, ++ MD_ERROR_WIN_DS_NCNAME_MUST_BE_NC, ++ MD_ERROR_WIN_DS_CANT_ADD_SYSTEM_ONLY, ++ MD_ERROR_WIN_DS_CLASS_MUST_BE_CONCRETE, ++ MD_ERROR_WIN_DS_INVALID_DMD, ++ MD_ERROR_WIN_DS_OBJ_GUID_EXISTS, ++ MD_ERROR_WIN_DS_NOT_ON_BACKLINK, ++ MD_ERROR_WIN_DS_NO_CROSSREF_FOR_NC, ++ MD_ERROR_WIN_DS_SHUTTING_DOWN, ++ MD_ERROR_WIN_DS_UNKNOWN_OPERATION, ++ MD_ERROR_WIN_DS_INVALID_ROLE_OWNER, ++ MD_ERROR_WIN_DS_COULDNT_CONTACT_FSMO, ++ MD_ERROR_WIN_DS_CROSS_NC_DN_RENAME, ++ MD_ERROR_WIN_DS_CANT_MOD_SYSTEM_ONLY, ++ MD_ERROR_WIN_DS_REPLICATOR_ONLY, ++ MD_ERROR_WIN_DS_OBJ_CLASS_NOT_DEFINED, ++ MD_ERROR_WIN_DS_OBJ_CLASS_NOT_SUBCLASS, ++ MD_ERROR_WIN_DS_NAME_REFERENCE_INVALID, ++ MD_ERROR_WIN_DS_CROSS_REF_EXISTS, ++ MD_ERROR_WIN_DS_CANT_DEL_MASTER_CROSSREF, ++ MD_ERROR_WIN_DS_SUBTREE_NOTIFY_NOT_NC_HEAD, ++ MD_ERROR_WIN_DS_NOTIFY_FILTER_TOO_COMPLEX, ++ MD_ERROR_WIN_DS_DUP_RDN, ++ MD_ERROR_WIN_DS_DUP_OID, ++ MD_ERROR_WIN_DS_DUP_MAPI_ID, ++ MD_ERROR_WIN_DS_DUP_SCHEMA_ID_GUID, ++ MD_ERROR_WIN_DS_DUP_LDAP_DISPLAY_NAME, ++ MD_ERROR_WIN_DS_SEMANTIC_ATT_TEST, ++ MD_ERROR_WIN_DS_SYNTAX_MISMATCH, ++ MD_ERROR_WIN_DS_EXISTS_IN_MUST_HAVE, ++ MD_ERROR_WIN_DS_EXISTS_IN_MAY_HAVE, ++ MD_ERROR_WIN_DS_NONEXISTENT_MAY_HAVE, ++ MD_ERROR_WIN_DS_NONEXISTENT_MUST_HAVE, ++ MD_ERROR_WIN_DS_AUX_CLS_TEST_FAIL, ++ MD_ERROR_WIN_DS_NONEXISTENT_POSS_SUP, ++ MD_ERROR_WIN_DS_SUB_CLS_TEST_FAIL, ++ MD_ERROR_WIN_DS_BAD_RDN_ATT_ID_SYNTAX, ++ MD_ERROR_WIN_DS_EXISTS_IN_AUX_CLS, ++ MD_ERROR_WIN_DS_EXISTS_IN_SUB_CLS, ++ MD_ERROR_WIN_DS_EXISTS_IN_POSS_SUP, ++ MD_ERROR_WIN_DS_RECALCSCHEMA_FAILED, ++ MD_ERROR_WIN_DS_TREE_DELETE_NOT_FINISHED, ++ MD_ERROR_WIN_DS_CANT_DELETE, ++ MD_ERROR_WIN_DS_ATT_SCHEMA_REQ_ID, ++ MD_ERROR_WIN_DS_BAD_ATT_SCHEMA_SYNTAX, ++ MD_ERROR_WIN_DS_CANT_CACHE_ATT, ++ MD_ERROR_WIN_DS_CANT_CACHE_CLASS, ++ MD_ERROR_WIN_DS_CANT_REMOVE_ATT_CACHE, ++ MD_ERROR_WIN_DS_CANT_REMOVE_CLASS_CACHE, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_DN, ++ MD_ERROR_WIN_DS_MISSING_SUPREF, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_INSTANCE, ++ MD_ERROR_WIN_DS_CODE_INCONSISTENCY, ++ MD_ERROR_WIN_DS_DATABASE_ERROR, ++ MD_ERROR_WIN_DS_GOVERNSID_MISSING, ++ MD_ERROR_WIN_DS_MISSING_EXPECTED_ATT, ++ MD_ERROR_WIN_DS_NCNAME_MISSING_CR_REF, ++ MD_ERROR_WIN_DS_SECURITY_CHECKING_ERROR, ++ MD_ERROR_WIN_DS_SCHEMA_NOT_LOADED, ++ MD_ERROR_WIN_DS_SCHEMA_ALLOC_FAILED, ++ MD_ERROR_WIN_DS_ATT_SCHEMA_REQ_SYNTAX, ++ MD_ERROR_WIN_DS_GCVERIFY_ERROR, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_MISMATCH, ++ MD_ERROR_WIN_DS_CANT_FIND_DSA_OBJ, ++ MD_ERROR_WIN_DS_CANT_FIND_EXPECTED_NC, ++ MD_ERROR_WIN_DS_CANT_FIND_NC_IN_CACHE, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_CHILD, ++ MD_ERROR_WIN_DS_SECURITY_ILLEGAL_MODIFY, ++ MD_ERROR_WIN_DS_CANT_REPLACE_HIDDEN_REC, ++ MD_ERROR_WIN_DS_BAD_HIERARCHY_FILE, ++ MD_ERROR_WIN_DS_BUILD_HIERARCHY_TABLE_FAILED, ++ MD_ERROR_WIN_DS_CONFIG_PARAM_MISSING, ++ MD_ERROR_WIN_DS_COUNTING_AB_INDICES_FAILED, ++ MD_ERROR_WIN_DS_HIERARCHY_TABLE_MALLOC_FAILED, ++ MD_ERROR_WIN_DS_INTERNAL_FAILURE, ++ MD_ERROR_WIN_DS_UNKNOWN_ERROR, ++ MD_ERROR_WIN_DS_ROOT_REQUIRES_CLASS_TOP, ++ MD_ERROR_WIN_DS_REFUSING_FSMO_ROLES, ++ MD_ERROR_WIN_DS_MISSING_FSMO_SETTINGS, ++ MD_ERROR_WIN_DS_UNABLE_TO_SURRENDER_ROLES, ++ MD_ERROR_WIN_DS_DRA_GENERIC, ++ MD_ERROR_WIN_DS_DRA_INVALID_PARAMETER, ++ MD_ERROR_WIN_DS_DRA_BUSY, ++ MD_ERROR_WIN_DS_DRA_BAD_DN, ++ MD_ERROR_WIN_DS_DRA_BAD_NC, ++ MD_ERROR_WIN_DS_DRA_DN_EXISTS, ++ MD_ERROR_WIN_DS_DRA_INTERNAL_ERROR, ++ MD_ERROR_WIN_DS_DRA_INCONSISTENT_DIT, ++ MD_ERROR_WIN_DS_DRA_CONNECTION_FAILED, ++ MD_ERROR_WIN_DS_DRA_BAD_INSTANCE_TYPE, ++ MD_ERROR_WIN_DS_DRA_OUT_OF_MEM, ++ MD_ERROR_WIN_DS_DRA_MAIL_PROBLEM, ++ MD_ERROR_WIN_DS_DRA_REF_ALREADY_EXISTS, ++ MD_ERROR_WIN_DS_DRA_REF_NOT_FOUND, ++ MD_ERROR_WIN_DS_DRA_OBJ_IS_REP_SOURCE, ++ MD_ERROR_WIN_DS_DRA_DB_ERROR, ++ MD_ERROR_WIN_DS_DRA_NO_REPLICA, ++ MD_ERROR_WIN_DS_DRA_ACCESS_DENIED, ++ MD_ERROR_WIN_DS_DRA_NOT_SUPPORTED, ++ MD_ERROR_WIN_DS_DRA_RPC_CANCELLED, ++ MD_ERROR_WIN_DS_DRA_SOURCE_DISABLED, ++ MD_ERROR_WIN_DS_DRA_SINK_DISABLED, ++ MD_ERROR_WIN_DS_DRA_NAME_COLLISION, ++ MD_ERROR_WIN_DS_DRA_SOURCE_REINSTALLED, ++ MD_ERROR_WIN_DS_DRA_MISSING_PARENT, ++ MD_ERROR_WIN_DS_DRA_PREEMPTED, ++ MD_ERROR_WIN_DS_DRA_ABANDON_SYNC, ++ MD_ERROR_WIN_DS_DRA_SHUTDOWN, ++ MD_ERROR_WIN_DS_DRA_INCOMPATIBLE_PARTIAL_SET, ++ MD_ERROR_WIN_DS_DRA_SOURCE_IS_PARTIAL_REPLICA, ++ MD_ERROR_WIN_DS_DRA_EXTN_CONNECTION_FAILED, ++ MD_ERROR_WIN_DS_INSTALL_SCHEMA_MISMATCH, ++ MD_ERROR_WIN_DS_DUP_LINK_ID, ++ MD_ERROR_WIN_DS_NAME_ERROR_RESOLVING, ++ MD_ERROR_WIN_DS_NAME_ERROR_NOT_FOUND, ++ MD_ERROR_WIN_DS_NAME_ERROR_NOT_UNIQUE, ++ MD_ERROR_WIN_DS_NAME_ERROR_NO_MAPPING, ++ MD_ERROR_WIN_DS_NAME_ERROR_DOMAIN_ONLY, ++ MD_ERROR_WIN_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING, ++ MD_ERROR_WIN_DS_CONSTRUCTED_ATT_MOD, ++ MD_ERROR_WIN_DS_WRONG_OM_OBJ_CLASS, ++ MD_ERROR_WIN_DS_DRA_REPL_PENDING, ++ MD_ERROR_WIN_DS_DS_REQUIRED, ++ MD_ERROR_WIN_DS_INVALID_LDAP_DISPLAY_NAME, ++ MD_ERROR_WIN_DS_NON_BASE_SEARCH, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_ATTS, ++ MD_ERROR_WIN_DS_BACKLINK_WITHOUT_LINK, ++ MD_ERROR_WIN_DS_EPOCH_MISMATCH, ++ MD_ERROR_WIN_DS_SRC_NAME_MISMATCH, ++ MD_ERROR_WIN_DS_SRC_AND_DST_NC_IDENTICAL, ++ MD_ERROR_WIN_DS_DST_NC_MISMATCH, ++ MD_ERROR_WIN_DS_NOT_AUTHORITIVE_FOR_DST_NC, ++ MD_ERROR_WIN_DS_SRC_GUID_MISMATCH, ++ MD_ERROR_WIN_DS_CANT_MOVE_DELETED_OBJECT, ++ MD_ERROR_WIN_DS_PDC_OPERATION_IN_PROGRESS, ++ MD_ERROR_WIN_DS_CROSS_DOMAIN_CLEANUP_REQD, ++ MD_ERROR_WIN_DS_ILLEGAL_XDOM_MOVE_OPERATION, ++ MD_ERROR_WIN_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS, ++ MD_ERROR_WIN_DS_NC_MUST_HAVE_NC_PARENT, ++ MD_ERROR_WIN_DS_CR_IMPOSSIBLE_TO_VALIDATE, ++ MD_ERROR_WIN_DS_DST_DOMAIN_NOT_NATIVE, ++ MD_ERROR_WIN_DS_MISSING_INFRASTRUCTURE_CONTAINER, ++ MD_ERROR_WIN_DS_CANT_MOVE_ACCOUNT_GROUP, ++ MD_ERROR_WIN_DS_CANT_MOVE_RESOURCE_GROUP, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG, ++ MD_ERROR_WIN_DS_NO_TREE_DELETE_ABOVE_NC, ++ MD_ERROR_WIN_DS_COULDNT_LOCK_TREE_FOR_DELETE, ++ MD_ERROR_WIN_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE, ++ MD_ERROR_WIN_DS_SAM_INIT_FAILURE, ++ MD_ERROR_WIN_DS_SENSITIVE_GROUP_VIOLATION, ++ MD_ERROR_WIN_DS_CANT_MOD_PRIMARYGROUPID, ++ MD_ERROR_WIN_DS_ILLEGAL_BASE_SCHEMA_MOD, ++ MD_ERROR_WIN_DS_NONSAFE_SCHEMA_CHANGE, ++ MD_ERROR_WIN_DS_SCHEMA_UPDATE_DISALLOWED, ++ MD_ERROR_WIN_DS_CANT_CREATE_UNDER_SCHEMA, ++ MD_ERROR_WIN_DS_INSTALL_NO_SRC_SCH_VERSION, ++ MD_ERROR_WIN_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE, ++ MD_ERROR_WIN_DS_INVALID_GROUP_TYPE, ++ MD_ERROR_WIN_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, ++ MD_ERROR_WIN_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, ++ MD_ERROR_WIN_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, ++ MD_ERROR_WIN_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, ++ MD_ERROR_WIN_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, ++ MD_ERROR_WIN_DS_HAVE_PRIMARY_MEMBERS, ++ MD_ERROR_WIN_DS_STRING_SD_CONVERSION_FAILED, ++ MD_ERROR_WIN_DS_NAMING_MASTER_GC, ++ MD_ERROR_WIN_DS_DNS_LOOKUP_FAILURE, ++ MD_ERROR_WIN_DS_COULDNT_UPDATE_SPNS, ++ MD_ERROR_WIN_DS_CANT_RETRIEVE_SD, ++ MD_ERROR_WIN_DS_KEY_NOT_UNIQUE, ++ MD_ERROR_WIN_DS_WRONG_LINKED_ATT_SYNTAX, ++ MD_ERROR_WIN_DS_SAM_NEED_BOOTKEY_PASSWORD, ++ MD_ERROR_WIN_DS_SAM_NEED_BOOTKEY_FLOPPY, ++ MD_ERROR_WIN_DS_CANT_START, ++ MD_ERROR_WIN_DS_INIT_FAILURE, ++ MD_ERROR_WIN_DS_NO_PKT_PRIVACY_ON_CONNECTION, ++ MD_ERROR_WIN_DS_SOURCE_DOMAIN_IN_FOREST, ++ MD_ERROR_WIN_DS_DESTINATION_DOMAIN_NOT_IN_FOREST, ++ MD_ERROR_WIN_DS_DESTINATION_AUDITING_NOT_ENABLED, ++ MD_ERROR_WIN_DS_CANT_FIND_DC_FOR_SRC_DOMAIN, ++ MD_ERROR_WIN_DS_SRC_OBJ_NOT_GROUP_OR_USER, ++ MD_ERROR_WIN_DS_SRC_SID_EXISTS_IN_FOREST, ++ MD_ERROR_WIN_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH, ++ MD_ERROR_WIN_SAM_INIT_FAILURE, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_INFO_SHIP, ++ MD_ERROR_WIN_DS_DRA_SCHEMA_CONFLICT, ++ MD_ERROR_WIN_DS_DRA_EARLIER_SCHEMA_CONFLICT, ++ MD_ERROR_WIN_DS_DRA_OBJ_NC_MISMATCH, ++ MD_ERROR_WIN_DS_NC_STILL_HAS_DSAS, ++ MD_ERROR_WIN_DS_GC_REQUIRED, ++ MD_ERROR_WIN_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, ++ MD_ERROR_WIN_DS_NO_FPO_IN_UNIVERSAL_GROUPS, ++ MD_ERROR_WIN_DS_CANT_ADD_TO_GC, ++ MD_ERROR_WIN_DS_NO_CHECKPOINT_WITH_PDC, ++ MD_ERROR_WIN_DS_SOURCE_AUDITING_NOT_ENABLED, ++ MD_ERROR_WIN_DS_CANT_CREATE_IN_NONDOMAIN_NC, ++ MD_ERROR_WIN_DS_INVALID_NAME_FOR_SPN, ++ MD_ERROR_WIN_DS_FILTER_USES_CONTRUCTED_ATTRS, ++ MD_ERROR_WIN_DS_UNICODEPWD_NOT_IN_QUOTES, ++ MD_ERROR_WIN_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, ++ MD_ERROR_WIN_DS_MUST_BE_RUN_ON_DST_DC, ++ MD_ERROR_WIN_DS_SRC_DC_MUST_BE_SP4_OR_GREATER, ++ MD_ERROR_WIN_DS_CANT_TREE_DELETE_CRITICAL_OBJ, ++ MD_ERROR_WIN_DS_INIT_FAILURE_CONSOLE, ++ MD_ERROR_WIN_DS_SAM_INIT_FAILURE_CONSOLE, ++ MD_ERROR_WIN_DS_FOREST_VERSION_TOO_HIGH, ++ MD_ERROR_WIN_DS_DOMAIN_VERSION_TOO_HIGH, ++ MD_ERROR_WIN_DS_FOREST_VERSION_TOO_LOW, ++ MD_ERROR_WIN_DS_DOMAIN_VERSION_TOO_LOW, ++ MD_ERROR_WIN_DS_INCOMPATIBLE_VERSION, ++ MD_ERROR_WIN_DS_LOW_DSA_VERSION, ++ MD_ERROR_WIN_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN, ++ MD_ERROR_WIN_DS_NOT_SUPPORTED_SORT_ORDER, ++ MD_ERROR_WIN_DS_NAME_NOT_UNIQUE, ++ MD_ERROR_WIN_DS_MACHINE_ACCOUNT_CREATED_PRENT4, ++ MD_ERROR_WIN_DS_OUT_OF_VERSION_STORE, ++ MD_ERROR_WIN_DS_INCOMPATIBLE_CONTROLS_USED, ++ MD_ERROR_WIN_DS_NO_REF_DOMAIN, ++ MD_ERROR_WIN_DS_RESERVED_LINK_ID, ++ MD_ERROR_WIN_DS_LINK_ID_NOT_AVAILABLE, ++ MD_ERROR_WIN_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, ++ MD_ERROR_WIN_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE, ++ MD_ERROR_WIN_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC, ++ MD_ERROR_WIN_DS_MODIFYDN_DISALLOWED_BY_FLAG, ++ MD_ERROR_WIN_DS_MODIFYDN_WRONG_GRANDPARENT, ++ MD_ERROR_WIN_DS_NAME_ERROR_TRUST_REFERRAL, ++ MD_ERROR_WIN_NOT_SUPPORTED_ON_STANDARD_SERVER, ++ MD_ERROR_WIN_DS_CANT_ACCESS_REMOTE_PART_OF_AD, ++ MD_ERROR_WIN_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2, ++ MD_ERROR_WIN_DS_THREAD_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_DS_NOT_CLOSEST, ++ MD_ERROR_WIN_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF, ++ MD_ERROR_WIN_DS_SINGLE_USER_MODE_FAILED, ++ MD_ERROR_WIN_DS_NTDSCRIPT_SYNTAX_ERROR, ++ MD_ERROR_WIN_DS_NTDSCRIPT_PROCESS_ERROR, ++ MD_ERROR_WIN_DS_DIFFERENT_REPL_EPOCHS, ++ MD_ERROR_WIN_DS_DRS_EXTENSIONS_CHANGED, ++ MD_ERROR_WIN_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR, ++ MD_ERROR_WIN_DS_NO_MSDS_INTID, ++ MD_ERROR_WIN_DS_DUP_MSDS_INTID, ++ MD_ERROR_WIN_DS_EXISTS_IN_RDNATTID, ++ MD_ERROR_WIN_DS_AUTHORIZATION_FAILED, ++ MD_ERROR_WIN_DS_INVALID_SCRIPT, ++ MD_ERROR_WIN_DS_REMOTE_CROSSREF_OP_FAILED, ++ MD_ERROR_WIN_DS_CROSS_REF_BUSY, ++ MD_ERROR_WIN_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN, ++ MD_ERROR_WIN_DS_CANT_DEMOTE_WITH_WRITEABLE_NC, ++ MD_ERROR_WIN_DS_DUPLICATE_ID_FOUND, ++ MD_ERROR_WIN_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT, ++ MD_ERROR_WIN_DS_GROUP_CONVERSION_ERROR, ++ MD_ERROR_WIN_DS_CANT_MOVE_APP_BASIC_GROUP, ++ MD_ERROR_WIN_DS_CANT_MOVE_APP_QUERY_GROUP, ++ MD_ERROR_WIN_DS_ROLE_NOT_VERIFIED, ++ MD_ERROR_WIN_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL, ++ MD_ERROR_WIN_DS_DOMAIN_RENAME_IN_PROGRESS, ++ MD_ERROR_WIN_DS_EXISTING_AD_CHILD_NC, ++ MD_ERROR_WIN_DS_REPL_LIFETIME_EXCEEDED, ++ MD_ERROR_WIN_DS_DISALLOWED_IN_SYSTEM_CONTAINER, ++ MD_ERROR_WIN_DS_LDAP_SEND_QUEUE_FULL, ++ MD_ERROR_WIN_DS_DRA_OUT_SCHEDULE_WINDOW, ++ MD_ERROR_WIN_DS_POLICY_NOT_KNOWN, ++ MD_ERROR_WIN_NO_SITE_SETTINGS_OBJECT, ++ MD_ERROR_WIN_NO_SECRETS, ++ MD_ERROR_WIN_NO_WRITABLE_DC_FOUND, ++ MD_ERROR_WIN_DS_NO_SERVER_OBJECT, ++ MD_ERROR_WIN_DS_NO_NTDSA_OBJECT, ++ MD_ERROR_WIN_DS_NON_ASQ_SEARCH, ++ MD_ERROR_WIN_DS_AUDIT_FAILURE, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG_SUBTREE, ++ MD_ERROR_WIN_DS_INVALID_SEARCH_FLAG_TUPLE, ++ MD_ERROR_WIN_DS_HIERARCHY_TABLE_TOO_DEEP, ++ MD_ERROR_WIN_DS_DRA_CORRUPT_UTD_VECTOR, ++ MD_ERROR_WIN_DS_DRA_SECRETS_DENIED, ++ MD_ERROR_WIN_DS_RESERVED_MAPI_ID, ++ MD_ERROR_WIN_DS_MAPI_ID_NOT_AVAILABLE, ++ MD_ERROR_WIN_DS_DRA_MISSING_KRBTGT_SECRET, ++ MD_ERROR_WIN_DS_DOMAIN_NAME_EXISTS_IN_FOREST, ++ MD_ERROR_WIN_DS_FLAT_NAME_EXISTS_IN_FOREST, ++ MD_ERROR_WIN_INVALID_USER_PRINCIPAL_NAME, ++ MD_ERROR_WIN_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS, ++ MD_ERROR_WIN_DS_OID_NOT_FOUND, ++ MD_ERROR_WIN_DS_DRA_RECYCLED_TARGET, ++ MD_ERROR_WIN_DS_DISALLOWED_NC_REDIRECT, ++ MD_ERROR_WIN_DS_HIGH_ADLDS_FFL, ++ MD_ERROR_WIN_DS_HIGH_DSA_VERSION, ++ MD_ERROR_WIN_DS_LOW_ADLDS_FFL, ++ MD_ERROR_WIN_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATION, ++ MD_ERROR_WIN_DS_UNDELETE_SAM_VALIDATION_FAILED, ++ MD_ERROR_WIN_INCORRECT_ACCOUNT_TYPE, ++ MD_ERROR_WIN_DS_SPN_VALUE_NOT_UNIQUE_IN_FOREST, ++ MD_ERROR_WIN_DS_UPN_VALUE_NOT_UNIQUE_IN_FOREST, ++ MD_ERROR_WIN_DS_MISSING_FOREST_TRUST, ++ MD_ERROR_WIN_DS_VALUE_KEY_NOT_UNIQUE, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_EXISTS, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_IN_USE, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_EXISTS, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_IN_USE, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_EXISTS, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_EXISTS, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_EXISTS, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_IN_USE, ++ MD_ERROR_WIN_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_EXISTS, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_NOT_FOUND, ++ MD_ERROR_WIN_IPSEC_MM_FILTER_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_TRANSPORT_FILTER_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_TUNNEL_FILTER_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_MM_POLICY_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_MM_AUTH_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_QM_POLICY_PENDING_DELETION, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_BEGIN, ++ MD_ERROR_WIN_IPSEC_IKE_AUTH_FAIL, ++ MD_ERROR_WIN_IPSEC_IKE_ATTRIB_FAIL, ++ MD_ERROR_WIN_IPSEC_IKE_NEGOTIATION_PENDING, ++ MD_ERROR_WIN_IPSEC_IKE_GENERAL_PROCESSING_ERROR, ++ MD_ERROR_WIN_IPSEC_IKE_TIMED_OUT, ++ MD_ERROR_WIN_IPSEC_IKE_NO_CERT, ++ MD_ERROR_WIN_IPSEC_IKE_SA_DELETED, ++ MD_ERROR_WIN_IPSEC_IKE_SA_REAPED, ++ MD_ERROR_WIN_IPSEC_IKE_MM_ACQUIRE_DROP, ++ MD_ERROR_WIN_IPSEC_IKE_QM_ACQUIRE_DROP, ++ MD_ERROR_WIN_IPSEC_IKE_QUEUE_DROP_MM, ++ MD_ERROR_WIN_IPSEC_IKE_QUEUE_DROP_NO_MM, ++ MD_ERROR_WIN_IPSEC_IKE_DROP_NO_RESPONSE, ++ MD_ERROR_WIN_IPSEC_IKE_MM_DELAY_DROP, ++ MD_ERROR_WIN_IPSEC_IKE_QM_DELAY_DROP, ++ MD_ERROR_WIN_IPSEC_IKE_ERROR, ++ MD_ERROR_WIN_IPSEC_IKE_CRL_FAILED, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_KEY_USAGE, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_CERT_TYPE, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PRIVATE_KEY, ++ MD_ERROR_WIN_IPSEC_IKE_SIMULTANEOUS_REKEY, ++ MD_ERROR_WIN_IPSEC_IKE_DH_FAIL, ++ MD_ERROR_WIN_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZED, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HEADER, ++ MD_ERROR_WIN_IPSEC_IKE_NO_POLICY, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SIGNATURE, ++ MD_ERROR_WIN_IPSEC_IKE_KERBEROS_ERROR, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PUBLIC_KEY, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_SA, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_PROP, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_TRANS, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_KE, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_ID, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_CERT, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_CERT_REQ, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_HASH, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_SIG, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NONCE, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NOTIFY, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_DELETE, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_VENDOR, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_PAYLOAD, ++ MD_ERROR_WIN_IPSEC_IKE_LOAD_SOFT_SA, ++ MD_ERROR_WIN_IPSEC_IKE_SOFT_SA_TORN_DOWN, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_COOKIE, ++ MD_ERROR_WIN_IPSEC_IKE_NO_PEER_CERT, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_CRL_FAILED, ++ MD_ERROR_WIN_IPSEC_IKE_POLICY_CHANGE, ++ MD_ERROR_WIN_IPSEC_IKE_NO_MM_POLICY, ++ MD_ERROR_WIN_IPSEC_IKE_NOTCBPRIV, ++ MD_ERROR_WIN_IPSEC_IKE_SECLOADFAIL, ++ MD_ERROR_WIN_IPSEC_IKE_FAILSSPINIT, ++ MD_ERROR_WIN_IPSEC_IKE_FAILQUERYSSP, ++ MD_ERROR_WIN_IPSEC_IKE_SRVACQFAIL, ++ MD_ERROR_WIN_IPSEC_IKE_SRVQUERYCRED, ++ MD_ERROR_WIN_IPSEC_IKE_GETSPIFAIL, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_FILTER, ++ MD_ERROR_WIN_IPSEC_IKE_OUT_OF_MEMORY, ++ MD_ERROR_WIN_IPSEC_IKE_ADD_UPDATE_KEY_FAILED, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_POLICY, ++ MD_ERROR_WIN_IPSEC_IKE_UNKNOWN_DOI, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SITUATION, ++ MD_ERROR_WIN_IPSEC_IKE_DH_FAILURE, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_GROUP, ++ MD_ERROR_WIN_IPSEC_IKE_ENCRYPT, ++ MD_ERROR_WIN_IPSEC_IKE_DECRYPT, ++ MD_ERROR_WIN_IPSEC_IKE_POLICY_MATCH, ++ MD_ERROR_WIN_IPSEC_IKE_UNSUPPORTED_ID, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH_ALG, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_HASH_SIZE, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_ENCRYPT_ALG, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_AUTH_ALG, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_SIG, ++ MD_ERROR_WIN_IPSEC_IKE_LOAD_FAILED, ++ MD_ERROR_WIN_IPSEC_IKE_RPC_DELETE, ++ MD_ERROR_WIN_IPSEC_IKE_BENIGN_REINIT, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_MAJOR_VERSION, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_CERT_KEYLEN, ++ MD_ERROR_WIN_IPSEC_IKE_MM_LIMIT, ++ MD_ERROR_WIN_IPSEC_IKE_NEGOTIATION_DISABLED, ++ MD_ERROR_WIN_IPSEC_IKE_QM_LIMIT, ++ MD_ERROR_WIN_IPSEC_IKE_MM_EXPIRED, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_MM_ASSUMED_INVALID, ++ MD_ERROR_WIN_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH, ++ MD_ERROR_WIN_IPSEC_IKE_UNEXPECTED_MESSAGE_ID, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_AUTH_PAYLOAD, ++ MD_ERROR_WIN_IPSEC_IKE_DOS_COOKIE_SENT, ++ MD_ERROR_WIN_IPSEC_IKE_SHUTTING_DOWN, ++ MD_ERROR_WIN_IPSEC_IKE_CGA_AUTH_FAILED, ++ MD_ERROR_WIN_IPSEC_IKE_PROCESS_ERR_NATOA, ++ MD_ERROR_WIN_IPSEC_IKE_INVALID_MM_FOR_QM, ++ MD_ERROR_WIN_IPSEC_IKE_QM_EXPIRED, ++ MD_ERROR_WIN_IPSEC_IKE_TOO_MANY_FILTERS, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_END, ++ MD_ERROR_WIN_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL, ++ MD_ERROR_WIN_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE, ++ MD_ERROR_WIN_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING, ++ MD_ERROR_WIN_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING, ++ MD_ERROR_WIN_IPSEC_IKE_COEXISTENCE_SUPPRESS, ++ MD_ERROR_WIN_IPSEC_IKE_RATELIMIT_DROP, ++ MD_ERROR_WIN_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE, ++ MD_ERROR_WIN_IPSEC_IKE_AUTHORIZATION_FAILURE, ++ MD_ERROR_WIN_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE, ++ MD_ERROR_WIN_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY, ++ MD_ERROR_WIN_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE, ++ MD_ERROR_WIN_IPSEC_IKE_NEG_STATUS_EXTENDED_END, ++ MD_ERROR_WIN_IPSEC_BAD_SPI, ++ MD_ERROR_WIN_IPSEC_SA_LIFETIME_EXPIRED, ++ MD_ERROR_WIN_IPSEC_WRONG_SA, ++ MD_ERROR_WIN_IPSEC_REPLAY_CHECK_FAILED, ++ MD_ERROR_WIN_IPSEC_INVALID_PACKET, ++ MD_ERROR_WIN_IPSEC_INTEGRITY_CHECK_FAILED, ++ MD_ERROR_WIN_IPSEC_CLEAR_TEXT_DROP, ++ MD_ERROR_WIN_IPSEC_AUTH_FIREWALL_DROP, ++ MD_ERROR_WIN_IPSEC_THROTTLE_DROP, ++ MD_ERROR_WIN_IPSEC_DOSP_BLOCK, ++ MD_ERROR_WIN_IPSEC_DOSP_RECEIVED_MULTICAST, ++ MD_ERROR_WIN_IPSEC_DOSP_INVALID_PACKET, ++ MD_ERROR_WIN_IPSEC_DOSP_STATE_LOOKUP_FAILED, ++ MD_ERROR_WIN_IPSEC_DOSP_MAX_ENTRIES, ++ MD_ERROR_WIN_IPSEC_DOSP_KEYMOD_NOT_ALLOWED, ++ MD_ERROR_WIN_IPSEC_DOSP_NOT_INSTALLED, ++ MD_ERROR_WIN_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES, ++ MD_ERROR_WIN_SXS_SECTION_NOT_FOUND, ++ MD_ERROR_WIN_SXS_CANT_GEN_ACTCTX, ++ MD_ERROR_WIN_SXS_INVALID_ACTCTXDATA_FORMAT, ++ MD_ERROR_WIN_SXS_ASSEMBLY_NOT_FOUND, ++ MD_ERROR_WIN_SXS_MANIFEST_FORMAT_ERROR, ++ MD_ERROR_WIN_SXS_MANIFEST_PARSE_ERROR, ++ MD_ERROR_WIN_SXS_ACTIVATION_CONTEXT_DISABLED, ++ MD_ERROR_WIN_SXS_KEY_NOT_FOUND, ++ MD_ERROR_WIN_SXS_VERSION_CONFLICT, ++ MD_ERROR_WIN_SXS_WRONG_SECTION_TYPE, ++ MD_ERROR_WIN_SXS_THREAD_QUERIES_DISABLED, ++ MD_ERROR_WIN_SXS_PROCESS_DEFAULT_ALREADY_SET, ++ MD_ERROR_WIN_SXS_UNKNOWN_ENCODING_GROUP, ++ MD_ERROR_WIN_SXS_UNKNOWN_ENCODING, ++ MD_ERROR_WIN_SXS_INVALID_XML_NAMESPACE_URI, ++ MD_ERROR_WIN_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED, ++ MD_ERROR_WIN_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED, ++ MD_ERROR_WIN_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE, ++ MD_ERROR_WIN_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE, ++ MD_ERROR_WIN_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE, ++ MD_ERROR_WIN_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT, ++ MD_ERROR_WIN_SXS_DUPLICATE_DLL_NAME, ++ MD_ERROR_WIN_SXS_DUPLICATE_WINDOWCLASS_NAME, ++ MD_ERROR_WIN_SXS_DUPLICATE_CLSID, ++ MD_ERROR_WIN_SXS_DUPLICATE_IID, ++ MD_ERROR_WIN_SXS_DUPLICATE_TLBID, ++ MD_ERROR_WIN_SXS_DUPLICATE_PROGID, ++ MD_ERROR_WIN_SXS_DUPLICATE_ASSEMBLY_NAME, ++ MD_ERROR_WIN_SXS_FILE_HASH_MISMATCH, ++ MD_ERROR_WIN_SXS_POLICY_PARSE_ERROR, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGQUOTE, ++ MD_ERROR_WIN_SXS_XML_E_COMMENTSYNTAX, ++ MD_ERROR_WIN_SXS_XML_E_BADSTARTNAMECHAR, ++ MD_ERROR_WIN_SXS_XML_E_BADNAMECHAR, ++ MD_ERROR_WIN_SXS_XML_E_BADCHARINSTRING, ++ MD_ERROR_WIN_SXS_XML_E_XMLDECLSYNTAX, ++ MD_ERROR_WIN_SXS_XML_E_BADCHARDATA, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGWHITESPACE, ++ MD_ERROR_WIN_SXS_XML_E_EXPECTINGTAGEND, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGSEMICOLON, ++ MD_ERROR_WIN_SXS_XML_E_UNBALANCEDPAREN, ++ MD_ERROR_WIN_SXS_XML_E_INTERNALERROR, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTED_WHITESPACE, ++ MD_ERROR_WIN_SXS_XML_E_INCOMPLETE_ENCODING, ++ MD_ERROR_WIN_SXS_XML_E_MISSING_PAREN, ++ MD_ERROR_WIN_SXS_XML_E_EXPECTINGCLOSEQUOTE, ++ MD_ERROR_WIN_SXS_XML_E_MULTIPLE_COLONS, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_DECIMAL, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_HEXIDECIMAL, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_UNICODE, ++ MD_ERROR_WIN_SXS_XML_E_WHITESPACEORQUESTIONMARK, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTEDENDTAG, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDTAG, ++ MD_ERROR_WIN_SXS_XML_E_DUPLICATEATTRIBUTE, ++ MD_ERROR_WIN_SXS_XML_E_MULTIPLEROOTS, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDATROOTLEVEL, ++ MD_ERROR_WIN_SXS_XML_E_BADXMLDECL, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGROOT, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTEDEOF, ++ MD_ERROR_WIN_SXS_XML_E_BADPEREFINSUBSET, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDSTARTTAG, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDENDTAG, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDSTRING, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDCOMMENT, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDDECL, ++ MD_ERROR_WIN_SXS_XML_E_UNCLOSEDCDATA, ++ MD_ERROR_WIN_SXS_XML_E_RESERVEDNAMESPACE, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDENCODING, ++ MD_ERROR_WIN_SXS_XML_E_INVALIDSWITCH, ++ MD_ERROR_WIN_SXS_XML_E_BADXMLCASE, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_STANDALONE, ++ MD_ERROR_WIN_SXS_XML_E_UNEXPECTED_STANDALONE, ++ MD_ERROR_WIN_SXS_XML_E_INVALID_VERSION, ++ MD_ERROR_WIN_SXS_XML_E_MISSINGEQUALS, ++ MD_ERROR_WIN_SXS_PROTECTION_RECOVERY_FAILED, ++ MD_ERROR_WIN_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT, ++ MD_ERROR_WIN_SXS_PROTECTION_CATALOG_NOT_VALID, ++ MD_ERROR_WIN_SXS_UNTRANSLATABLE_HRESULT, ++ MD_ERROR_WIN_SXS_PROTECTION_CATALOG_FILE_MISSING, ++ MD_ERROR_WIN_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE, ++ MD_ERROR_WIN_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME, ++ MD_ERROR_WIN_SXS_ASSEMBLY_MISSING, ++ MD_ERROR_WIN_SXS_CORRUPT_ACTIVATION_STACK, ++ MD_ERROR_WIN_SXS_CORRUPTION, ++ MD_ERROR_WIN_SXS_EARLY_DEACTIVATION, ++ MD_ERROR_WIN_SXS_INVALID_DEACTIVATION, ++ MD_ERROR_WIN_SXS_MULTIPLE_DEACTIVATION, ++ MD_ERROR_WIN_SXS_PROCESS_TERMINATION_REQUESTED, ++ MD_ERROR_WIN_SXS_RELEASE_ACTIVATION_CONTEXT, ++ MD_ERROR_WIN_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, ++ MD_ERROR_WIN_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, ++ MD_ERROR_WIN_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, ++ MD_ERROR_WIN_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, ++ MD_ERROR_WIN_SXS_IDENTITY_PARSE_ERROR, ++ MD_ERROR_WIN_MALFORMED_SUBSTITUTION_STRING, ++ MD_ERROR_WIN_SXS_INCORRECT_PUBLIC_KEY_TOKEN, ++ MD_ERROR_WIN_UNMAPPED_SUBSTITUTION_STRING, ++ MD_ERROR_WIN_SXS_ASSEMBLY_NOT_LOCKED, ++ MD_ERROR_WIN_SXS_COMPONENT_STORE_CORRUPT, ++ MD_ERROR_WIN_ADVANCED_INSTALLER_FAILED, ++ MD_ERROR_WIN_XML_ENCODING_MISMATCH, ++ MD_ERROR_WIN_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, ++ MD_ERROR_WIN_SXS_IDENTITIES_DIFFERENT, ++ MD_ERROR_WIN_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, ++ MD_ERROR_WIN_SXS_FILE_NOT_PART_OF_ASSEMBLY, ++ MD_ERROR_WIN_SXS_MANIFEST_TOO_BIG, ++ MD_ERROR_WIN_SXS_SETTING_NOT_REGISTERED, ++ MD_ERROR_WIN_SXS_TRANSACTION_CLOSURE_INCOMPLETE, ++ MD_ERROR_WIN_SMI_PRIMITIVE_INSTALLER_FAILED, ++ MD_ERROR_WIN_GENERIC_COMMAND_FAILED, ++ MD_ERROR_WIN_SXS_FILE_HASH_MISSING, ++ MD_ERROR_WIN_SXS_DUPLICATE_ACTIVATABLE_CLASS, ++ MD_ERROR_WIN_EVT_INVALID_CHANNEL_PATH, ++ MD_ERROR_WIN_EVT_INVALID_QUERY, ++ MD_ERROR_WIN_EVT_PUBLISHER_METADATA_NOT_FOUND, ++ MD_ERROR_WIN_EVT_EVENT_TEMPLATE_NOT_FOUND, ++ MD_ERROR_WIN_EVT_INVALID_PUBLISHER_NAME, ++ MD_ERROR_WIN_EVT_INVALID_EVENT_DATA, ++ MD_ERROR_WIN_EVT_CHANNEL_NOT_FOUND, ++ MD_ERROR_WIN_EVT_MALFORMED_XML_TEXT, ++ MD_ERROR_WIN_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL, ++ MD_ERROR_WIN_EVT_CONFIGURATION_ERROR, ++ MD_ERROR_WIN_EVT_QUERY_RESULT_STALE, ++ MD_ERROR_WIN_EVT_QUERY_RESULT_INVALID_POSITION, ++ MD_ERROR_WIN_EVT_NON_VALIDATING_MSXML, ++ MD_ERROR_WIN_EVT_FILTER_ALREADYSCOPED, ++ MD_ERROR_WIN_EVT_FILTER_NOTELTSET, ++ MD_ERROR_WIN_EVT_FILTER_INVARG, ++ MD_ERROR_WIN_EVT_FILTER_INVTEST, ++ MD_ERROR_WIN_EVT_FILTER_INVTYPE, ++ MD_ERROR_WIN_EVT_FILTER_PARSEERR, ++ MD_ERROR_WIN_EVT_FILTER_UNSUPPORTEDOP, ++ MD_ERROR_WIN_EVT_FILTER_UNEXPECTEDTOKEN, ++ MD_ERROR_WIN_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL, ++ MD_ERROR_WIN_EVT_INVALID_CHANNEL_PROPERTY_VALUE, ++ MD_ERROR_WIN_EVT_INVALID_PUBLISHER_PROPERTY_VALUE, ++ MD_ERROR_WIN_EVT_CHANNEL_CANNOT_ACTIVATE, ++ MD_ERROR_WIN_EVT_FILTER_TOO_COMPLEX, ++ MD_ERROR_WIN_EVT_MESSAGE_NOT_FOUND, ++ MD_ERROR_WIN_EVT_MESSAGE_ID_NOT_FOUND, ++ MD_ERROR_WIN_EVT_UNRESOLVED_VALUE_INSERT, ++ MD_ERROR_WIN_EVT_UNRESOLVED_PARAMETER_INSERT, ++ MD_ERROR_WIN_EVT_MAX_INSERTS_REACHED, ++ MD_ERROR_WIN_EVT_EVENT_DEFINITION_NOT_FOUND, ++ MD_ERROR_WIN_EVT_MESSAGE_LOCALE_NOT_FOUND, ++ MD_ERROR_WIN_EVT_VERSION_TOO_OLD, ++ MD_ERROR_WIN_EVT_VERSION_TOO_NEW, ++ MD_ERROR_WIN_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY, ++ MD_ERROR_WIN_EVT_PUBLISHER_DISABLED, ++ MD_ERROR_WIN_EVT_FILTER_OUT_OF_RANGE, ++ MD_ERROR_WIN_EC_SUBSCRIPTION_CANNOT_ACTIVATE, ++ MD_ERROR_WIN_EC_LOG_DISABLED, ++ MD_ERROR_WIN_EC_CIRCULAR_FORWARDING, ++ MD_ERROR_WIN_EC_CREDSTORE_FULL, ++ MD_ERROR_WIN_EC_CRED_NOT_FOUND, ++ MD_ERROR_WIN_EC_NO_ACTIVE_CHANNEL, ++ MD_ERROR_WIN_MUI_FILE_NOT_FOUND, ++ MD_ERROR_WIN_MUI_INVALID_FILE, ++ MD_ERROR_WIN_MUI_INVALID_RC_CONFIG, ++ MD_ERROR_WIN_MUI_INVALID_LOCALE_NAME, ++ MD_ERROR_WIN_MUI_INVALID_ULTIMATEFALLBACK_NAME, ++ MD_ERROR_WIN_MUI_FILE_NOT_LOADED, ++ MD_ERROR_WIN_RESOURCE_ENUM_USER_STOP, ++ MD_ERROR_WIN_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED, ++ MD_ERROR_WIN_MUI_INTLSETTINGS_INVALID_LOCALE_NAME, ++ MD_ERROR_WIN_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE, ++ MD_ERROR_WIN_MRM_INVALID_PRICONFIG, ++ MD_ERROR_WIN_MRM_INVALID_FILE_TYPE, ++ MD_ERROR_WIN_MRM_UNKNOWN_QUALIFIER, ++ MD_ERROR_WIN_MRM_INVALID_QUALIFIER_VALUE, ++ MD_ERROR_WIN_MRM_NO_CANDIDATE, ++ MD_ERROR_WIN_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE, ++ MD_ERROR_WIN_MRM_RESOURCE_TYPE_MISMATCH, ++ MD_ERROR_WIN_MRM_DUPLICATE_MAP_NAME, ++ MD_ERROR_WIN_MRM_DUPLICATE_ENTRY, ++ MD_ERROR_WIN_MRM_INVALID_RESOURCE_IDENTIFIER, ++ MD_ERROR_WIN_MRM_FILEPATH_TOO_LONG, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_DIRECTORY_TYPE, ++ MD_ERROR_WIN_MRM_INVALID_PRI_FILE, ++ MD_ERROR_WIN_MRM_NAMED_RESOURCE_NOT_FOUND, ++ MD_ERROR_WIN_MRM_MAP_NOT_FOUND, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_PROFILE_TYPE, ++ MD_ERROR_WIN_MRM_INVALID_QUALIFIER_OPERATOR, ++ MD_ERROR_WIN_MRM_INDETERMINATE_QUALIFIER_VALUE, ++ MD_ERROR_WIN_MRM_AUTOMERGE_ENABLED, ++ MD_ERROR_WIN_MRM_TOO_MANY_RESOURCES, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGE, ++ MD_ERROR_WIN_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILE, ++ MD_ERROR_WIN_MRM_NO_CURRENT_VIEW_ON_THREAD, ++ MD_ERROR_WIN_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXIST, ++ MD_ERROR_WIN_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENT, ++ MD_ERROR_WIN_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCE, ++ MD_ERROR_WIN_MRM_GENERATION_COUNT_MISMATCH, ++ MD_ERROR_WIN_PRI_MERGE_VERSION_MISMATCH, ++ MD_ERROR_WIN_PRI_MERGE_MISSING_SCHEMA, ++ MD_ERROR_WIN_PRI_MERGE_LOAD_FILE_FAILED, ++ MD_ERROR_WIN_PRI_MERGE_ADD_FILE_FAILED, ++ MD_ERROR_WIN_PRI_MERGE_WRITE_FILE_FAILED, ++ MD_ERROR_WIN_PRI_MERGE_MULTIPLE_PACKAGE_FAMILIES_NOT_ALLOWED, ++ MD_ERROR_WIN_PRI_MERGE_MULTIPLE_MAIN_PACKAGES_NOT_ALLOWED, ++ MD_ERROR_WIN_PRI_MERGE_BUNDLE_PACKAGES_NOT_ALLOWED, ++ MD_ERROR_WIN_PRI_MERGE_MAIN_PACKAGE_REQUIRED, ++ MD_ERROR_WIN_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED, ++ MD_ERROR_WIN_PRI_MERGE_INVALID_FILE_NAME, ++ MD_ERROR_WIN_MRM_PACKAGE_NOT_FOUND, ++ MD_ERROR_WIN_MRM_MISSING_DEFAULT_LANGUAGE, ++ MD_ERROR_WIN_MCA_INVALID_CAPABILITIES_STRING, ++ MD_ERROR_WIN_MCA_INVALID_VCP_VERSION, ++ MD_ERROR_WIN_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION, ++ MD_ERROR_WIN_MCA_MCCS_VERSION_MISMATCH, ++ MD_ERROR_WIN_MCA_UNSUPPORTED_MCCS_VERSION, ++ MD_ERROR_WIN_MCA_INTERNAL_ERROR, ++ MD_ERROR_WIN_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED, ++ MD_ERROR_WIN_MCA_UNSUPPORTED_COLOR_TEMPERATURE, ++ MD_ERROR_WIN_AMBIGUOUS_SYSTEM_DEVICE, ++ MD_ERROR_WIN_SYSTEM_DEVICE_NOT_FOUND, ++ MD_ERROR_WIN_HASH_NOT_SUPPORTED, ++ MD_ERROR_WIN_HASH_NOT_PRESENT, ++ MD_ERROR_WIN_SECONDARY_IC_PROVIDER_NOT_REGISTERED, ++ MD_ERROR_WIN_GPIO_CLIENT_INFORMATION_INVALID, ++ MD_ERROR_WIN_GPIO_VERSION_NOT_SUPPORTED, ++ MD_ERROR_WIN_GPIO_INVALID_REGISTRATION_PACKET, ++ MD_ERROR_WIN_GPIO_OPERATION_DENIED, ++ MD_ERROR_WIN_GPIO_INCOMPATIBLE_CONNECT_MODE, ++ MD_ERROR_WIN_GPIO_INTERRUPT_ALREADY_UNMASKED, ++ MD_ERROR_WIN_CANNOT_SWITCH_RUNLEVEL, ++ MD_ERROR_WIN_INVALID_RUNLEVEL_SETTING, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_TIMEOUT, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_AGENT_TIMEOUT, ++ MD_ERROR_WIN_RUNLEVEL_SWITCH_IN_PROGRESS, ++ MD_ERROR_WIN_SERVICES_FAILED_AUTOSTART, ++ MD_ERROR_WIN_COM_TASK_STOP_PENDING, ++ MD_ERROR_WIN_INSTALL_OPEN_PACKAGE_FAILED, ++ MD_ERROR_WIN_INSTALL_PACKAGE_NOT_FOUND, ++ MD_ERROR_WIN_INSTALL_INVALID_PACKAGE, ++ MD_ERROR_WIN_INSTALL_RESOLVE_DEPENDENCY_FAILED, ++ MD_ERROR_WIN_INSTALL_OUT_OF_DISK_SPACE, ++ MD_ERROR_WIN_INSTALL_NETWORK_FAILURE, ++ MD_ERROR_WIN_INSTALL_REGISTRATION_FAILURE, ++ MD_ERROR_WIN_INSTALL_DEREGISTRATION_FAILURE, ++ MD_ERROR_WIN_INSTALL_CANCEL, ++ MD_ERROR_WIN_INSTALL_FAILED, ++ MD_ERROR_WIN_REMOVE_FAILED, ++ MD_ERROR_WIN_PACKAGE_ALREADY_EXISTS, ++ MD_ERROR_WIN_NEEDS_REMEDIATION, ++ MD_ERROR_WIN_INSTALL_PREREQUISITE_FAILED, ++ MD_ERROR_WIN_PACKAGE_REPOSITORY_CORRUPTED, ++ MD_ERROR_WIN_INSTALL_POLICY_FAILURE, ++ MD_ERROR_WIN_PACKAGE_UPDATING, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_POLICY, ++ MD_ERROR_WIN_PACKAGES_IN_USE, ++ MD_ERROR_WIN_RECOVERY_FILE_CORRUPT, ++ MD_ERROR_WIN_INVALID_STAGED_SIGNATURE, ++ MD_ERROR_WIN_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED, ++ MD_ERROR_WIN_INSTALL_PACKAGE_DOWNGRADE, ++ MD_ERROR_WIN_SYSTEM_NEEDS_REMEDIATION, ++ MD_ERROR_WIN_APPX_INTEGRITY_FAILURE_CLR_NGEN, ++ MD_ERROR_WIN_RESILIENCY_FILE_CORRUPT, ++ MD_ERROR_WIN_INSTALL_FIREWALL_SERVICE_NOT_RUNNING, ++ MD_ERROR_WIN_PACKAGE_MOVE_FAILED, ++ MD_ERROR_WIN_INSTALL_VOLUME_NOT_EMPTY, ++ MD_ERROR_WIN_INSTALL_VOLUME_OFFLINE, ++ MD_ERROR_WIN_INSTALL_VOLUME_CORRUPT, ++ MD_ERROR_WIN_NEEDS_REGISTRATION, ++ MD_ERROR_WIN_INSTALL_WRONG_PROCESSOR_ARCHITECTURE, ++ MD_ERROR_WIN_DEV_SIDELOAD_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE, ++ MD_ERROR_WIN_PACKAGE_NOT_SUPPORTED_ON_FILESYSTEM, ++ MD_ERROR_WIN_PACKAGE_MOVE_BLOCKED_BY_STREAMING, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_APPLICATIONID_NOT_UNIQUE, ++ MD_ERROR_WIN_PACKAGE_STAGING_ONHOLD, ++ MD_ERROR_WIN_INSTALL_INVALID_RELATED_SET_UPDATE, ++ MD_ERROR_WIN_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_USER_LOG_OFF, ++ MD_ERROR_WIN_PROVISION_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_PROVISIONED, ++ MD_ERROR_WIN_PACKAGES_REPUTATION_CHECK_FAILED, ++ MD_ERROR_WIN_PACKAGES_REPUTATION_CHECK_TIMEDOUT, ++ MD_ERROR_WIN_DEPLOYMENT_OPTION_NOT_SUPPORTED, ++ MD_ERROR_WIN_APPINSTALLER_ACTIVATION_BLOCKED, ++ MD_ERROR_WIN_REGISTRATION_FROM_REMOTE_DRIVE_NOT_SUPPORTED, ++ MD_ERROR_WIN_APPX_RAW_DATA_WRITE_FAILED, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_PACKAGE, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_MACHINE, ++ MD_ERROR_WIN_DEPLOYMENT_BLOCKED_BY_PROFILE_POLICY, ++ MD_ERROR_WIN_DEPLOYMENT_FAILED_CONFLICTING_MUTABLE_PACKAGE_DIRECTORY, ++ MD_ERROR_WIN_SINGLETON_RESOURCE_INSTALLED_IN_ACTIVE_USER, ++ MD_ERROR_WIN_DIFFERENT_VERSION_OF_PACKAGED_SERVICE_INSTALLED, ++ MD_ERROR_WIN_SERVICE_EXISTS_AS_NON_PACKAGED_SERVICE, ++ MD_ERROR_WIN_PACKAGED_SERVICE_REQUIRES_ADMIN_PRIVILEGES, ++ MD_ERROR_WIN_REDIRECTION_TO_DEFAULT_ACCOUNT_NOT_ALLOWED, ++ MD_ERROR_WIN_PACKAGE_LACKS_CAPABILITY_TO_DEPLOY_ON_HOST, ++ MD_ERROR_WIN_UNSIGNED_PACKAGE_INVALID_CONTENT, ++ MD_ERROR_WIN_UNSIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE, ++ MD_ERROR_WIN_SIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE, ++ MD_ERROR_WIN_PACKAGE_EXTERNAL_LOCATION_NOT_ALLOWED, ++ MD_ERROR_WIN_INSTALL_FULLTRUST_HOSTRUNTIME_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY, ++ MD_ERROR_WIN_STATE_LOAD_STORE_FAILED, ++ MD_ERROR_WIN_STATE_GET_VERSION_FAILED, ++ MD_ERROR_WIN_STATE_SET_VERSION_FAILED, ++ MD_ERROR_WIN_STATE_STRUCTURED_RESET_FAILED, ++ MD_ERROR_WIN_STATE_OPEN_CONTAINER_FAILED, ++ MD_ERROR_WIN_STATE_CREATE_CONTAINER_FAILED, ++ MD_ERROR_WIN_STATE_DELETE_CONTAINER_FAILED, ++ MD_ERROR_WIN_STATE_READ_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_WRITE_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_DELETE_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_QUERY_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_READ_COMPOSITE_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_WRITE_COMPOSITE_SETTING_FAILED, ++ MD_ERROR_WIN_STATE_ENUMERATE_CONTAINER_FAILED, ++ MD_ERROR_WIN_STATE_ENUMERATE_SETTINGS_FAILED, ++ MD_ERROR_WIN_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED, ++ MD_ERROR_WIN_API_UNAVAILABLE, ++}; ++ ++// The content of this array was created from winerror.h in the 10 SDK ++// (version 10.0.19041.0) with the following script: ++// ++// egrep -o '#define ERROR_[A-Z_0-9]+\s+[0-9]+L' winerror.h ++// | tr -d '\r' ++// | sed -r 's@#define (ERROR_[A-Z_0-9]+)\s+([0-9]+)L@\2 \1@' ++// | sort -n | sed -r 's@([0-9]+) ([A-Z_0-9]+)@ "\2",@' ++static const char* kWinErrorStrings[] = { ++ "ERROR_SUCCESS", ++ "ERROR_INVALID_FUNCTION", ++ "ERROR_FILE_NOT_FOUND", ++ "ERROR_PATH_NOT_FOUND", ++ "ERROR_TOO_MANY_OPEN_FILES", ++ "ERROR_ACCESS_DENIED", ++ "ERROR_INVALID_HANDLE", ++ "ERROR_ARENA_TRASHED", ++ "ERROR_NOT_ENOUGH_MEMORY", ++ "ERROR_INVALID_BLOCK", ++ "ERROR_BAD_ENVIRONMENT", ++ "ERROR_BAD_FORMAT", ++ "ERROR_INVALID_ACCESS", ++ "ERROR_INVALID_DATA", ++ "ERROR_OUTOFMEMORY", ++ "ERROR_INVALID_DRIVE", ++ "ERROR_CURRENT_DIRECTORY", ++ "ERROR_NOT_SAME_DEVICE", ++ "ERROR_NO_MORE_FILES", ++ "ERROR_WRITE_PROTECT", ++ "ERROR_BAD_UNIT", ++ "ERROR_NOT_READY", ++ "ERROR_BAD_COMMAND", ++ "ERROR_CRC", ++ "ERROR_BAD_LENGTH", ++ "ERROR_SEEK", ++ "ERROR_NOT_DOS_DISK", ++ "ERROR_SECTOR_NOT_FOUND", ++ "ERROR_OUT_OF_PAPER", ++ "ERROR_WRITE_FAULT", ++ "ERROR_READ_FAULT", ++ "ERROR_GEN_FAILURE", ++ "ERROR_SHARING_VIOLATION", ++ "ERROR_LOCK_VIOLATION", ++ "ERROR_WRONG_DISK", ++ "ERROR_SHARING_BUFFER_EXCEEDED", ++ "ERROR_HANDLE_EOF", ++ "ERROR_HANDLE_DISK_FULL", ++ "ERROR_NOT_SUPPORTED", ++ "ERROR_REM_NOT_LIST", ++ "ERROR_DUP_NAME", ++ "ERROR_BAD_NETPATH", ++ "ERROR_NETWORK_BUSY", ++ "ERROR_DEV_NOT_EXIST", ++ "ERROR_TOO_MANY_CMDS", ++ "ERROR_ADAP_HDW_ERR", ++ "ERROR_BAD_NET_RESP", ++ "ERROR_UNEXP_NET_ERR", ++ "ERROR_BAD_REM_ADAP", ++ "ERROR_PRINTQ_FULL", ++ "ERROR_NO_SPOOL_SPACE", ++ "ERROR_PRINT_CANCELLED", ++ "ERROR_NETNAME_DELETED", ++ "ERROR_NETWORK_ACCESS_DENIED", ++ "ERROR_BAD_DEV_TYPE", ++ "ERROR_BAD_NET_NAME", ++ "ERROR_TOO_MANY_NAMES", ++ "ERROR_TOO_MANY_SESS", ++ "ERROR_SHARING_PAUSED", ++ "ERROR_REQ_NOT_ACCEP", ++ "ERROR_REDIR_PAUSED", ++ "ERROR_FILE_EXISTS", ++ "ERROR_CANNOT_MAKE", ++ "ERROR_FAIL_I24", ++ "ERROR_OUT_OF_STRUCTURES", ++ "ERROR_ALREADY_ASSIGNED", ++ "ERROR_INVALID_PASSWORD", ++ "ERROR_INVALID_PARAMETER", ++ "ERROR_NET_WRITE_FAULT", ++ "ERROR_NO_PROC_SLOTS", ++ "ERROR_TOO_MANY_SEMAPHORES", ++ "ERROR_EXCL_SEM_ALREADY_OWNED", ++ "ERROR_SEM_IS_SET", ++ "ERROR_TOO_MANY_SEM_REQUESTS", ++ "ERROR_INVALID_AT_INTERRUPT_TIME", ++ "ERROR_SEM_OWNER_DIED", ++ "ERROR_SEM_USER_LIMIT", ++ "ERROR_DISK_CHANGE", ++ "ERROR_DRIVE_LOCKED", ++ "ERROR_BROKEN_PIPE", ++ "ERROR_OPEN_FAILED", ++ "ERROR_BUFFER_OVERFLOW", ++ "ERROR_DISK_FULL", ++ "ERROR_NO_MORE_SEARCH_HANDLES", ++ "ERROR_INVALID_TARGET_HANDLE", ++ "ERROR_INVALID_CATEGORY", ++ "ERROR_INVALID_VERIFY_SWITCH", ++ "ERROR_BAD_DRIVER_LEVEL", ++ "ERROR_CALL_NOT_IMPLEMENTED", ++ "ERROR_SEM_TIMEOUT", ++ "ERROR_INSUFFICIENT_BUFFER", ++ "ERROR_INVALID_NAME", ++ "ERROR_INVALID_LEVEL", ++ "ERROR_NO_VOLUME_LABEL", ++ "ERROR_MOD_NOT_FOUND", ++ "ERROR_PROC_NOT_FOUND", ++ "ERROR_WAIT_NO_CHILDREN", ++ "ERROR_CHILD_NOT_COMPLETE", ++ "ERROR_DIRECT_ACCESS_HANDLE", ++ "ERROR_NEGATIVE_SEEK", ++ "ERROR_SEEK_ON_DEVICE", ++ "ERROR_IS_JOIN_TARGET", ++ "ERROR_IS_JOINED", ++ "ERROR_IS_SUBSTED", ++ "ERROR_NOT_JOINED", ++ "ERROR_NOT_SUBSTED", ++ "ERROR_JOIN_TO_JOIN", ++ "ERROR_SUBST_TO_SUBST", ++ "ERROR_JOIN_TO_SUBST", ++ "ERROR_SUBST_TO_JOIN", ++ "ERROR_BUSY_DRIVE", ++ "ERROR_SAME_DRIVE", ++ "ERROR_DIR_NOT_ROOT", ++ "ERROR_DIR_NOT_EMPTY", ++ "ERROR_IS_SUBST_PATH", ++ "ERROR_IS_JOIN_PATH", ++ "ERROR_PATH_BUSY", ++ "ERROR_IS_SUBST_TARGET", ++ "ERROR_SYSTEM_TRACE", ++ "ERROR_INVALID_EVENT_COUNT", ++ "ERROR_TOO_MANY_MUXWAITERS", ++ "ERROR_INVALID_LIST_FORMAT", ++ "ERROR_LABEL_TOO_LONG", ++ "ERROR_TOO_MANY_TCBS", ++ "ERROR_SIGNAL_REFUSED", ++ "ERROR_DISCARDED", ++ "ERROR_NOT_LOCKED", ++ "ERROR_BAD_THREADID_ADDR", ++ "ERROR_BAD_ARGUMENTS", ++ "ERROR_BAD_PATHNAME", ++ "ERROR_SIGNAL_PENDING", ++ "ERROR_MAX_THRDS_REACHED", ++ "ERROR_LOCK_FAILED", ++ "ERROR_BUSY", ++ "ERROR_DEVICE_SUPPORT_IN_PROGRESS", ++ "ERROR_CANCEL_VIOLATION", ++ "ERROR_ATOMIC_LOCKS_NOT_SUPPORTED", ++ "ERROR_INVALID_SEGMENT_NUMBER", ++ "ERROR_INVALID_ORDINAL", ++ "ERROR_ALREADY_EXISTS", ++ "ERROR_INVALID_FLAG_NUMBER", ++ "ERROR_SEM_NOT_FOUND", ++ "ERROR_INVALID_STARTING_CODESEG", ++ "ERROR_INVALID_STACKSEG", ++ "ERROR_INVALID_MODULETYPE", ++ "ERROR_INVALID_EXE_SIGNATURE", ++ "ERROR_EXE_MARKED_INVALID", ++ "ERROR_BAD_EXE_FORMAT", ++ "ERROR_INVALID_MINALLOCSIZE", ++ "ERROR_DYNLINK_FROM_INVALID_RING", ++ "ERROR_IOPL_NOT_ENABLED", ++ "ERROR_INVALID_SEGDPL", ++ "ERROR_RING2SEG_MUST_BE_MOVABLE", ++ "ERROR_RELOC_CHAIN_XEEDS_SEGLIM", ++ "ERROR_INFLOOP_IN_RELOC_CHAIN", ++ "ERROR_ENVVAR_NOT_FOUND", ++ "ERROR_NO_SIGNAL_SENT", ++ "ERROR_FILENAME_EXCED_RANGE", ++ "ERROR_RING2_STACK_IN_USE", ++ "ERROR_META_EXPANSION_TOO_LONG", ++ "ERROR_INVALID_SIGNAL_NUMBER", ++ "ERROR_THREAD_1_INACTIVE", ++ "ERROR_LOCKED", ++ "ERROR_TOO_MANY_MODULES", ++ "ERROR_NESTING_NOT_ALLOWED", ++ "ERROR_EXE_MACHINE_TYPE_MISMATCH", ++ "ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY", ++ "ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY", ++ "ERROR_FILE_CHECKED_OUT", ++ "ERROR_CHECKOUT_REQUIRED", ++ "ERROR_BAD_FILE_TYPE", ++ "ERROR_FILE_TOO_LARGE", ++ "ERROR_FORMS_AUTH_REQUIRED", ++ "ERROR_VIRUS_INFECTED", ++ "ERROR_VIRUS_DELETED", ++ "ERROR_PIPE_LOCAL", ++ "ERROR_BAD_PIPE", ++ "ERROR_PIPE_BUSY", ++ "ERROR_NO_DATA", ++ "ERROR_PIPE_NOT_CONNECTED", ++ "ERROR_MORE_DATA", ++ "ERROR_NO_WORK_DONE", ++ "ERROR_VC_DISCONNECTED", ++ "ERROR_INVALID_EA_NAME", ++ "ERROR_EA_LIST_INCONSISTENT", ++ "ERROR_NO_MORE_ITEMS", ++ "ERROR_CANNOT_COPY", ++ "ERROR_DIRECTORY", ++ "ERROR_EAS_DIDNT_FIT", ++ "ERROR_EA_FILE_CORRUPT", ++ "ERROR_EA_TABLE_FULL", ++ "ERROR_INVALID_EA_HANDLE", ++ "ERROR_EAS_NOT_SUPPORTED", ++ "ERROR_NOT_OWNER", ++ "ERROR_TOO_MANY_POSTS", ++ "ERROR_PARTIAL_COPY", ++ "ERROR_OPLOCK_NOT_GRANTED", ++ "ERROR_INVALID_OPLOCK_PROTOCOL", ++ "ERROR_DISK_TOO_FRAGMENTED", ++ "ERROR_DELETE_PENDING", ++ "ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING", ++ "ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME", ++ "ERROR_SECURITY_STREAM_IS_INCONSISTENT", ++ "ERROR_INVALID_LOCK_RANGE", ++ "ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT", ++ "ERROR_NOTIFICATION_GUID_ALREADY_DEFINED", ++ "ERROR_INVALID_EXCEPTION_HANDLER", ++ "ERROR_DUPLICATE_PRIVILEGES", ++ "ERROR_NO_RANGES_PROCESSED", ++ "ERROR_NOT_ALLOWED_ON_SYSTEM_FILE", ++ "ERROR_DISK_RESOURCES_EXHAUSTED", ++ "ERROR_INVALID_TOKEN", ++ "ERROR_DEVICE_FEATURE_NOT_SUPPORTED", ++ "ERROR_MR_MID_NOT_FOUND", ++ "ERROR_SCOPE_NOT_FOUND", ++ "ERROR_UNDEFINED_SCOPE", ++ "ERROR_INVALID_CAP", ++ "ERROR_DEVICE_UNREACHABLE", ++ "ERROR_DEVICE_NO_RESOURCES", ++ "ERROR_DATA_CHECKSUM_ERROR", ++ "ERROR_INTERMIXED_KERNEL_EA_OPERATION", ++ "ERROR_FILE_LEVEL_TRIM_NOT_SUPPORTED", ++ "ERROR_OFFSET_ALIGNMENT_VIOLATION", ++ "ERROR_INVALID_FIELD_IN_PARAMETER_LIST", ++ "ERROR_OPERATION_IN_PROGRESS", ++ "ERROR_BAD_DEVICE_PATH", ++ "ERROR_TOO_MANY_DESCRIPTORS", ++ "ERROR_SCRUB_DATA_DISABLED", ++ "ERROR_NOT_REDUNDANT_STORAGE", ++ "ERROR_RESIDENT_FILE_NOT_SUPPORTED", ++ "ERROR_COMPRESSED_FILE_NOT_SUPPORTED", ++ "ERROR_DIRECTORY_NOT_SUPPORTED", ++ "ERROR_NOT_READ_FROM_COPY", ++ "ERROR_FT_WRITE_FAILURE", ++ "ERROR_FT_DI_SCAN_REQUIRED", ++ "ERROR_INVALID_KERNEL_INFO_VERSION", ++ "ERROR_INVALID_PEP_INFO_VERSION", ++ "ERROR_OBJECT_NOT_EXTERNALLY_BACKED", ++ "ERROR_EXTERNAL_BACKING_PROVIDER_UNKNOWN", ++ "ERROR_COMPRESSION_NOT_BENEFICIAL", ++ "ERROR_STORAGE_TOPOLOGY_ID_MISMATCH", ++ "ERROR_BLOCKED_BY_PARENTAL_CONTROLS", ++ "ERROR_BLOCK_TOO_MANY_REFERENCES", ++ "ERROR_MARKED_TO_DISALLOW_WRITES", ++ "ERROR_ENCLAVE_FAILURE", ++ "ERROR_FAIL_NOACTION_REBOOT", ++ "ERROR_FAIL_SHUTDOWN", ++ "ERROR_FAIL_RESTART", ++ "ERROR_MAX_SESSIONS_REACHED", ++ "ERROR_NETWORK_ACCESS_DENIED_EDP", ++ "ERROR_DEVICE_HINT_NAME_BUFFER_TOO_SMALL", ++ "ERROR_EDP_POLICY_DENIES_OPERATION", ++ "ERROR_EDP_DPL_POLICY_CANT_BE_SATISFIED", ++ "ERROR_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT", ++ "ERROR_DEVICE_IN_MAINTENANCE", ++ "ERROR_NOT_SUPPORTED_ON_DAX", ++ "ERROR_DAX_MAPPING_EXISTS", ++ "ERROR_CLOUD_FILE_PROVIDER_NOT_RUNNING", ++ "ERROR_CLOUD_FILE_METADATA_CORRUPT", ++ "ERROR_CLOUD_FILE_METADATA_TOO_LARGE", ++ "ERROR_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE", ++ "ERROR_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH", ++ "ERROR_CHILD_PROCESS_BLOCKED", ++ "ERROR_STORAGE_LOST_DATA_PERSISTENCE", ++ "ERROR_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE", ++ "ERROR_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT", ++ "ERROR_FILE_SYSTEM_VIRTUALIZATION_BUSY", ++ "ERROR_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN", ++ "ERROR_GDI_HANDLE_LEAK", ++ "ERROR_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS", ++ "ERROR_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED", ++ "ERROR_NOT_A_CLOUD_FILE", ++ "ERROR_CLOUD_FILE_NOT_IN_SYNC", ++ "ERROR_CLOUD_FILE_ALREADY_CONNECTED", ++ "ERROR_CLOUD_FILE_NOT_SUPPORTED", ++ "ERROR_CLOUD_FILE_INVALID_REQUEST", ++ "ERROR_CLOUD_FILE_READ_ONLY_VOLUME", ++ "ERROR_CLOUD_FILE_CONNECTED_PROVIDER_ONLY", ++ "ERROR_CLOUD_FILE_VALIDATION_FAILED", ++ "ERROR_SMB1_NOT_AVAILABLE", ++ "ERROR_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION", ++ "ERROR_CLOUD_FILE_AUTHENTICATION_FAILED", ++ "ERROR_CLOUD_FILE_INSUFFICIENT_RESOURCES", ++ "ERROR_CLOUD_FILE_NETWORK_UNAVAILABLE", ++ "ERROR_CLOUD_FILE_UNSUCCESSFUL", ++ "ERROR_CLOUD_FILE_NOT_UNDER_SYNC_ROOT", ++ "ERROR_CLOUD_FILE_IN_USE", ++ "ERROR_CLOUD_FILE_PINNED", ++ "ERROR_CLOUD_FILE_REQUEST_ABORTED", ++ "ERROR_CLOUD_FILE_PROPERTY_CORRUPT", ++ "ERROR_CLOUD_FILE_ACCESS_DENIED", ++ "ERROR_CLOUD_FILE_INCOMPATIBLE_HARDLINKS", ++ "ERROR_CLOUD_FILE_PROPERTY_LOCK_CONFLICT", ++ "ERROR_CLOUD_FILE_REQUEST_CANCELED", ++ "ERROR_EXTERNAL_SYSKEY_NOT_SUPPORTED", ++ "ERROR_THREAD_MODE_ALREADY_BACKGROUND", ++ "ERROR_THREAD_MODE_NOT_BACKGROUND", ++ "ERROR_PROCESS_MODE_ALREADY_BACKGROUND", ++ "ERROR_PROCESS_MODE_NOT_BACKGROUND", ++ "ERROR_CLOUD_FILE_PROVIDER_TERMINATED", ++ "ERROR_NOT_A_CLOUD_SYNC_ROOT", ++ "ERROR_FILE_PROTECTED_UNDER_DPL", ++ "ERROR_VOLUME_NOT_CLUSTER_ALIGNED", ++ "ERROR_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND", ++ "ERROR_APPX_FILE_NOT_ENCRYPTED", ++ "ERROR_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED", ++ "ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET", ++ "ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE", ++ "ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER", ++ "ERROR_LINUX_SUBSYSTEM_NOT_PRESENT", ++ "ERROR_FT_READ_FAILURE", ++ "ERROR_STORAGE_RESERVE_ID_INVALID", ++ "ERROR_STORAGE_RESERVE_DOES_NOT_EXIST", ++ "ERROR_STORAGE_RESERVE_ALREADY_EXISTS", ++ "ERROR_STORAGE_RESERVE_NOT_EMPTY", ++ "ERROR_NOT_A_DAX_VOLUME", ++ "ERROR_NOT_DAX_MAPPABLE", ++ "ERROR_TIME_SENSITIVE_THREAD", ++ "ERROR_DPL_NOT_SUPPORTED_FOR_USER", ++ "ERROR_CASE_DIFFERING_NAMES_IN_DIR", ++ "ERROR_FILE_NOT_SUPPORTED", ++ "ERROR_CLOUD_FILE_REQUEST_TIMEOUT", ++ "ERROR_NO_TASK_QUEUE", ++ "ERROR_SRC_SRV_DLL_LOAD_FAILED", ++ "ERROR_NOT_SUPPORTED_WITH_BTT", ++ "ERROR_ENCRYPTION_DISABLED", ++ "ERROR_ENCRYPTING_METADATA_DISALLOWED", ++ "ERROR_CANT_CLEAR_ENCRYPTION_FLAG", ++ "ERROR_NO_SUCH_DEVICE", ++ "ERROR_CLOUD_FILE_DEHYDRATION_DISALLOWED", ++ "ERROR_FILE_SNAP_IN_PROGRESS", ++ "ERROR_FILE_SNAP_USER_SECTION_NOT_SUPPORTED", ++ "ERROR_FILE_SNAP_MODIFY_NOT_SUPPORTED", ++ "ERROR_FILE_SNAP_IO_NOT_COORDINATED", ++ "ERROR_FILE_SNAP_UNEXPECTED_ERROR", ++ "ERROR_FILE_SNAP_INVALID_PARAMETER", ++ "ERROR_UNSATISFIED_DEPENDENCIES", ++ "ERROR_CASE_SENSITIVE_PATH", ++ "ERROR_UNEXPECTED_NTCACHEMANAGER_ERROR", ++ "ERROR_LINUX_SUBSYSTEM_UPDATE_REQUIRED", ++ "ERROR_DLP_POLICY_WARNS_AGAINST_OPERATION", ++ "ERROR_DLP_POLICY_DENIES_OPERATION", ++ "ERROR_DLP_POLICY_SILENTLY_FAIL", ++ "ERROR_CAPAUTHZ_NOT_DEVUNLOCKED", ++ "ERROR_CAPAUTHZ_CHANGE_TYPE", ++ "ERROR_CAPAUTHZ_NOT_PROVISIONED", ++ "ERROR_CAPAUTHZ_NOT_AUTHORIZED", ++ "ERROR_CAPAUTHZ_NO_POLICY", ++ "ERROR_CAPAUTHZ_DB_CORRUPTED", ++ "ERROR_CAPAUTHZ_SCCD_INVALID_CATALOG", ++ "ERROR_CAPAUTHZ_SCCD_NO_AUTH_ENTITY", ++ "ERROR_CAPAUTHZ_SCCD_PARSE_ERROR", ++ "ERROR_CAPAUTHZ_SCCD_DEV_MODE_REQUIRED", ++ "ERROR_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCH", ++ "ERROR_CIMFS_IMAGE_CORRUPT", ++ "ERROR_PNP_QUERY_REMOVE_DEVICE_TIMEOUT", ++ "ERROR_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUT", ++ "ERROR_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUT", ++ "ERROR_DEVICE_HARDWARE_ERROR", ++ "ERROR_INVALID_ADDRESS", ++ "ERROR_HAS_SYSTEM_CRITICAL_FILES", ++ "ERROR_USER_PROFILE_LOAD", ++ "ERROR_ARITHMETIC_OVERFLOW", ++ "ERROR_PIPE_CONNECTED", ++ "ERROR_PIPE_LISTENING", ++ "ERROR_VERIFIER_STOP", ++ "ERROR_ABIOS_ERROR", ++ "ERROR_WX86_WARNING", ++ "ERROR_WX86_ERROR", ++ "ERROR_TIMER_NOT_CANCELED", ++ "ERROR_UNWIND", ++ "ERROR_BAD_STACK", ++ "ERROR_INVALID_UNWIND_TARGET", ++ "ERROR_INVALID_PORT_ATTRIBUTES", ++ "ERROR_PORT_MESSAGE_TOO_LONG", ++ "ERROR_INVALID_QUOTA_LOWER", ++ "ERROR_DEVICE_ALREADY_ATTACHED", ++ "ERROR_INSTRUCTION_MISALIGNMENT", ++ "ERROR_PROFILING_NOT_STARTED", ++ "ERROR_PROFILING_NOT_STOPPED", ++ "ERROR_COULD_NOT_INTERPRET", ++ "ERROR_PROFILING_AT_LIMIT", ++ "ERROR_CANT_WAIT", ++ "ERROR_CANT_TERMINATE_SELF", ++ "ERROR_UNEXPECTED_MM_CREATE_ERR", ++ "ERROR_UNEXPECTED_MM_MAP_ERROR", ++ "ERROR_UNEXPECTED_MM_EXTEND_ERR", ++ "ERROR_BAD_FUNCTION_TABLE", ++ "ERROR_NO_GUID_TRANSLATION", ++ "ERROR_INVALID_LDT_SIZE", ++ "ERROR_INVALID_LDT_OFFSET", ++ "ERROR_INVALID_LDT_DESCRIPTOR", ++ "ERROR_TOO_MANY_THREADS", ++ "ERROR_THREAD_NOT_IN_PROCESS", ++ "ERROR_PAGEFILE_QUOTA_EXCEEDED", ++ "ERROR_LOGON_SERVER_CONFLICT", ++ "ERROR_SYNCHRONIZATION_REQUIRED", ++ "ERROR_NET_OPEN_FAILED", ++ "ERROR_IO_PRIVILEGE_FAILED", ++ "ERROR_CONTROL_C_EXIT", ++ "ERROR_MISSING_SYSTEMFILE", ++ "ERROR_UNHANDLED_EXCEPTION", ++ "ERROR_APP_INIT_FAILURE", ++ "ERROR_PAGEFILE_CREATE_FAILED", ++ "ERROR_INVALID_IMAGE_HASH", ++ "ERROR_NO_PAGEFILE", ++ "ERROR_ILLEGAL_FLOAT_CONTEXT", ++ "ERROR_NO_EVENT_PAIR", ++ "ERROR_DOMAIN_CTRLR_CONFIG_ERROR", ++ "ERROR_ILLEGAL_CHARACTER", ++ "ERROR_UNDEFINED_CHARACTER", ++ "ERROR_FLOPPY_VOLUME", ++ "ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT", ++ "ERROR_BACKUP_CONTROLLER", ++ "ERROR_MUTANT_LIMIT_EXCEEDED", ++ "ERROR_FS_DRIVER_REQUIRED", ++ "ERROR_CANNOT_LOAD_REGISTRY_FILE", ++ "ERROR_DEBUG_ATTACH_FAILED", ++ "ERROR_SYSTEM_PROCESS_TERMINATED", ++ "ERROR_DATA_NOT_ACCEPTED", ++ "ERROR_VDM_HARD_ERROR", ++ "ERROR_DRIVER_CANCEL_TIMEOUT", ++ "ERROR_REPLY_MESSAGE_MISMATCH", ++ "ERROR_LOST_WRITEBEHIND_DATA", ++ "ERROR_CLIENT_SERVER_PARAMETERS_INVALID", ++ "ERROR_NOT_TINY_STREAM", ++ "ERROR_STACK_OVERFLOW_READ", ++ "ERROR_CONVERT_TO_LARGE", ++ "ERROR_FOUND_OUT_OF_SCOPE", ++ "ERROR_ALLOCATE_BUCKET", ++ "ERROR_MARSHALL_OVERFLOW", ++ "ERROR_INVALID_VARIANT", ++ "ERROR_BAD_COMPRESSION_BUFFER", ++ "ERROR_AUDIT_FAILED", ++ "ERROR_TIMER_RESOLUTION_NOT_SET", ++ "ERROR_INSUFFICIENT_LOGON_INFO", ++ "ERROR_BAD_DLL_ENTRYPOINT", ++ "ERROR_BAD_SERVICE_ENTRYPOINT", ++ "ERROR_IP_ADDRESS_CONFLICT1", ++ "ERROR_IP_ADDRESS_CONFLICT2", ++ "ERROR_REGISTRY_QUOTA_LIMIT", ++ "ERROR_NO_CALLBACK_ACTIVE", ++ "ERROR_PWD_TOO_SHORT", ++ "ERROR_PWD_TOO_RECENT", ++ "ERROR_PWD_HISTORY_CONFLICT", ++ "ERROR_UNSUPPORTED_COMPRESSION", ++ "ERROR_INVALID_HW_PROFILE", ++ "ERROR_INVALID_PLUGPLAY_DEVICE_PATH", ++ "ERROR_QUOTA_LIST_INCONSISTENT", ++ "ERROR_EVALUATION_EXPIRATION", ++ "ERROR_ILLEGAL_DLL_RELOCATION", ++ "ERROR_DLL_INIT_FAILED_LOGOFF", ++ "ERROR_VALIDATE_CONTINUE", ++ "ERROR_NO_MORE_MATCHES", ++ "ERROR_RANGE_LIST_CONFLICT", ++ "ERROR_SERVER_SID_MISMATCH", ++ "ERROR_CANT_ENABLE_DENY_ONLY", ++ "ERROR_FLOAT_MULTIPLE_FAULTS", ++ "ERROR_FLOAT_MULTIPLE_TRAPS", ++ "ERROR_NOINTERFACE", ++ "ERROR_DRIVER_FAILED_SLEEP", ++ "ERROR_CORRUPT_SYSTEM_FILE", ++ "ERROR_COMMITMENT_MINIMUM", ++ "ERROR_PNP_RESTART_ENUMERATION", ++ "ERROR_SYSTEM_IMAGE_BAD_SIGNATURE", ++ "ERROR_PNP_REBOOT_REQUIRED", ++ "ERROR_INSUFFICIENT_POWER", ++ "ERROR_MULTIPLE_FAULT_VIOLATION", ++ "ERROR_SYSTEM_SHUTDOWN", ++ "ERROR_PORT_NOT_SET", ++ "ERROR_DS_VERSION_CHECK_FAILURE", ++ "ERROR_RANGE_NOT_FOUND", ++ "ERROR_NOT_SAFE_MODE_DRIVER", ++ "ERROR_FAILED_DRIVER_ENTRY", ++ "ERROR_DEVICE_ENUMERATION_ERROR", ++ "ERROR_MOUNT_POINT_NOT_RESOLVED", ++ "ERROR_INVALID_DEVICE_OBJECT_PARAMETER", ++ "ERROR_MCA_OCCURED", ++ "ERROR_DRIVER_DATABASE_ERROR", ++ "ERROR_SYSTEM_HIVE_TOO_LARGE", ++ "ERROR_DRIVER_FAILED_PRIOR_UNLOAD", ++ "ERROR_VOLSNAP_PREPARE_HIBERNATE", ++ "ERROR_HIBERNATION_FAILURE", ++ "ERROR_PWD_TOO_LONG", ++ "ERROR_FILE_SYSTEM_LIMITATION", ++ "ERROR_ASSERTION_FAILURE", ++ "ERROR_ACPI_ERROR", ++ "ERROR_WOW_ASSERTION", ++ "ERROR_PNP_BAD_MPS_TABLE", ++ "ERROR_PNP_TRANSLATION_FAILED", ++ "ERROR_PNP_IRQ_TRANSLATION_FAILED", ++ "ERROR_PNP_INVALID_ID", ++ "ERROR_WAKE_SYSTEM_DEBUGGER", ++ "ERROR_HANDLES_CLOSED", ++ "ERROR_EXTRANEOUS_INFORMATION", ++ "ERROR_RXACT_COMMIT_NECESSARY", ++ "ERROR_MEDIA_CHECK", ++ "ERROR_GUID_SUBSTITUTION_MADE", ++ "ERROR_STOPPED_ON_SYMLINK", ++ "ERROR_LONGJUMP", ++ "ERROR_PLUGPLAY_QUERY_VETOED", ++ "ERROR_UNWIND_CONSOLIDATE", ++ "ERROR_REGISTRY_HIVE_RECOVERED", ++ "ERROR_DLL_MIGHT_BE_INSECURE", ++ "ERROR_DLL_MIGHT_BE_INCOMPATIBLE", ++ "ERROR_DBG_EXCEPTION_NOT_HANDLED", ++ "ERROR_DBG_REPLY_LATER", ++ "ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE", ++ "ERROR_DBG_TERMINATE_THREAD", ++ "ERROR_DBG_TERMINATE_PROCESS", ++ "ERROR_DBG_CONTROL_C", ++ "ERROR_DBG_PRINTEXCEPTION_C", ++ "ERROR_DBG_RIPEXCEPTION", ++ "ERROR_DBG_CONTROL_BREAK", ++ "ERROR_DBG_COMMAND_EXCEPTION", ++ "ERROR_OBJECT_NAME_EXISTS", ++ "ERROR_THREAD_WAS_SUSPENDED", ++ "ERROR_IMAGE_NOT_AT_BASE", ++ "ERROR_RXACT_STATE_CREATED", ++ "ERROR_SEGMENT_NOTIFICATION", ++ "ERROR_BAD_CURRENT_DIRECTORY", ++ "ERROR_FT_READ_RECOVERY_FROM_BACKUP", ++ "ERROR_FT_WRITE_RECOVERY", ++ "ERROR_IMAGE_MACHINE_TYPE_MISMATCH", ++ "ERROR_RECEIVE_PARTIAL", ++ "ERROR_RECEIVE_EXPEDITED", ++ "ERROR_RECEIVE_PARTIAL_EXPEDITED", ++ "ERROR_EVENT_DONE", ++ "ERROR_EVENT_PENDING", ++ "ERROR_CHECKING_FILE_SYSTEM", ++ "ERROR_FATAL_APP_EXIT", ++ "ERROR_PREDEFINED_HANDLE", ++ "ERROR_WAS_UNLOCKED", ++ "ERROR_SERVICE_NOTIFICATION", ++ "ERROR_WAS_LOCKED", ++ "ERROR_LOG_HARD_ERROR", ++ "ERROR_ALREADY_WIN32", ++ "ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE", ++ "ERROR_NO_YIELD_PERFORMED", ++ "ERROR_TIMER_RESUME_IGNORED", ++ "ERROR_ARBITRATION_UNHANDLED", ++ "ERROR_CARDBUS_NOT_SUPPORTED", ++ "ERROR_MP_PROCESSOR_MISMATCH", ++ "ERROR_HIBERNATED", ++ "ERROR_RESUME_HIBERNATION", ++ "ERROR_FIRMWARE_UPDATED", ++ "ERROR_DRIVERS_LEAKING_LOCKED_PAGES", ++ "ERROR_WAKE_SYSTEM", ++ "ERROR_WAIT_1", ++ "ERROR_WAIT_2", ++ "ERROR_WAIT_3", ++ "ERROR_WAIT_63", ++ "ERROR_ABANDONED_WAIT_0", ++ "ERROR_ABANDONED_WAIT_63", ++ "ERROR_USER_APC", ++ "ERROR_KERNEL_APC", ++ "ERROR_ALERTED", ++ "ERROR_ELEVATION_REQUIRED", ++ "ERROR_REPARSE", ++ "ERROR_OPLOCK_BREAK_IN_PROGRESS", ++ "ERROR_VOLUME_MOUNTED", ++ "ERROR_RXACT_COMMITTED", ++ "ERROR_NOTIFY_CLEANUP", ++ "ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED", ++ "ERROR_PAGE_FAULT_TRANSITION", ++ "ERROR_PAGE_FAULT_DEMAND_ZERO", ++ "ERROR_PAGE_FAULT_COPY_ON_WRITE", ++ "ERROR_PAGE_FAULT_GUARD_PAGE", ++ "ERROR_PAGE_FAULT_PAGING_FILE", ++ "ERROR_CACHE_PAGE_LOCKED", ++ "ERROR_CRASH_DUMP", ++ "ERROR_BUFFER_ALL_ZEROS", ++ "ERROR_REPARSE_OBJECT", ++ "ERROR_RESOURCE_REQUIREMENTS_CHANGED", ++ "ERROR_TRANSLATION_COMPLETE", ++ "ERROR_NOTHING_TO_TERMINATE", ++ "ERROR_PROCESS_NOT_IN_JOB", ++ "ERROR_PROCESS_IN_JOB", ++ "ERROR_VOLSNAP_HIBERNATE_READY", ++ "ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY", ++ "ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED", ++ "ERROR_INTERRUPT_STILL_CONNECTED", ++ "ERROR_WAIT_FOR_OPLOCK", ++ "ERROR_DBG_EXCEPTION_HANDLED", ++ "ERROR_DBG_CONTINUE", ++ "ERROR_CALLBACK_POP_STACK", ++ "ERROR_COMPRESSION_DISABLED", ++ "ERROR_CANTFETCHBACKWARDS", ++ "ERROR_CANTSCROLLBACKWARDS", ++ "ERROR_ROWSNOTRELEASED", ++ "ERROR_BAD_ACCESSOR_FLAGS", ++ "ERROR_ERRORS_ENCOUNTERED", ++ "ERROR_NOT_CAPABLE", ++ "ERROR_REQUEST_OUT_OF_SEQUENCE", ++ "ERROR_VERSION_PARSE_ERROR", ++ "ERROR_BADSTARTPOSITION", ++ "ERROR_MEMORY_HARDWARE", ++ "ERROR_DISK_REPAIR_DISABLED", ++ "ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE", ++ "ERROR_SYSTEM_POWERSTATE_TRANSITION", ++ "ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION", ++ "ERROR_MCA_EXCEPTION", ++ "ERROR_ACCESS_AUDIT_BY_POLICY", ++ "ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY", ++ "ERROR_ABANDON_HIBERFILE", ++ "ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED", ++ "ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR", ++ "ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR", ++ "ERROR_BAD_MCFG_TABLE", ++ "ERROR_DISK_REPAIR_REDIRECTED", ++ "ERROR_DISK_REPAIR_UNSUCCESSFUL", ++ "ERROR_CORRUPT_LOG_OVERFULL", ++ "ERROR_CORRUPT_LOG_CORRUPTED", ++ "ERROR_CORRUPT_LOG_UNAVAILABLE", ++ "ERROR_CORRUPT_LOG_DELETED_FULL", ++ "ERROR_CORRUPT_LOG_CLEARED", ++ "ERROR_ORPHAN_NAME_EXHAUSTED", ++ "ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE", ++ "ERROR_CANNOT_GRANT_REQUESTED_OPLOCK", ++ "ERROR_CANNOT_BREAK_OPLOCK", ++ "ERROR_OPLOCK_HANDLE_CLOSED", ++ "ERROR_NO_ACE_CONDITION", ++ "ERROR_INVALID_ACE_CONDITION", ++ "ERROR_FILE_HANDLE_REVOKED", ++ "ERROR_IMAGE_AT_DIFFERENT_BASE", ++ "ERROR_ENCRYPTED_IO_NOT_POSSIBLE", ++ "ERROR_FILE_METADATA_OPTIMIZATION_IN_PROGRESS", ++ "ERROR_QUOTA_ACTIVITY", ++ "ERROR_HANDLE_REVOKED", ++ "ERROR_CALLBACK_INVOKE_INLINE", ++ "ERROR_CPU_SET_INVALID", ++ "ERROR_ENCLAVE_NOT_TERMINATED", ++ "ERROR_ENCLAVE_VIOLATION", ++ "ERROR_EA_ACCESS_DENIED", ++ "ERROR_OPERATION_ABORTED", ++ "ERROR_IO_INCOMPLETE", ++ "ERROR_IO_PENDING", ++ "ERROR_NOACCESS", ++ "ERROR_SWAPERROR", ++ "ERROR_STACK_OVERFLOW", ++ "ERROR_INVALID_MESSAGE", ++ "ERROR_CAN_NOT_COMPLETE", ++ "ERROR_INVALID_FLAGS", ++ "ERROR_UNRECOGNIZED_VOLUME", ++ "ERROR_FILE_INVALID", ++ "ERROR_FULLSCREEN_MODE", ++ "ERROR_NO_TOKEN", ++ "ERROR_BADDB", ++ "ERROR_BADKEY", ++ "ERROR_CANTOPEN", ++ "ERROR_CANTREAD", ++ "ERROR_CANTWRITE", ++ "ERROR_REGISTRY_RECOVERED", ++ "ERROR_REGISTRY_CORRUPT", ++ "ERROR_REGISTRY_IO_FAILED", ++ "ERROR_NOT_REGISTRY_FILE", ++ "ERROR_KEY_DELETED", ++ "ERROR_NO_LOG_SPACE", ++ "ERROR_KEY_HAS_CHILDREN", ++ "ERROR_CHILD_MUST_BE_VOLATILE", ++ "ERROR_NOTIFY_ENUM_DIR", ++ "ERROR_DEPENDENT_SERVICES_RUNNING", ++ "ERROR_INVALID_SERVICE_CONTROL", ++ "ERROR_SERVICE_REQUEST_TIMEOUT", ++ "ERROR_SERVICE_NO_THREAD", ++ "ERROR_SERVICE_DATABASE_LOCKED", ++ "ERROR_SERVICE_ALREADY_RUNNING", ++ "ERROR_INVALID_SERVICE_ACCOUNT", ++ "ERROR_SERVICE_DISABLED", ++ "ERROR_CIRCULAR_DEPENDENCY", ++ "ERROR_SERVICE_DOES_NOT_EXIST", ++ "ERROR_SERVICE_CANNOT_ACCEPT_CTRL", ++ "ERROR_SERVICE_NOT_ACTIVE", ++ "ERROR_FAILED_SERVICE_CONTROLLER_CONNECT", ++ "ERROR_EXCEPTION_IN_SERVICE", ++ "ERROR_DATABASE_DOES_NOT_EXIST", ++ "ERROR_SERVICE_SPECIFIC_ERROR", ++ "ERROR_PROCESS_ABORTED", ++ "ERROR_SERVICE_DEPENDENCY_FAIL", ++ "ERROR_SERVICE_LOGON_FAILED", ++ "ERROR_SERVICE_START_HANG", ++ "ERROR_INVALID_SERVICE_LOCK", ++ "ERROR_SERVICE_MARKED_FOR_DELETE", ++ "ERROR_SERVICE_EXISTS", ++ "ERROR_ALREADY_RUNNING_LKG", ++ "ERROR_SERVICE_DEPENDENCY_DELETED", ++ "ERROR_BOOT_ALREADY_ACCEPTED", ++ "ERROR_SERVICE_NEVER_STARTED", ++ "ERROR_DUPLICATE_SERVICE_NAME", ++ "ERROR_DIFFERENT_SERVICE_ACCOUNT", ++ "ERROR_CANNOT_DETECT_DRIVER_FAILURE", ++ "ERROR_CANNOT_DETECT_PROCESS_ABORT", ++ "ERROR_NO_RECOVERY_PROGRAM", ++ "ERROR_SERVICE_NOT_IN_EXE", ++ "ERROR_NOT_SAFEBOOT_SERVICE", ++ "ERROR_END_OF_MEDIA", ++ "ERROR_FILEMARK_DETECTED", ++ "ERROR_BEGINNING_OF_MEDIA", ++ "ERROR_SETMARK_DETECTED", ++ "ERROR_NO_DATA_DETECTED", ++ "ERROR_PARTITION_FAILURE", ++ "ERROR_INVALID_BLOCK_LENGTH", ++ "ERROR_DEVICE_NOT_PARTITIONED", ++ "ERROR_UNABLE_TO_LOCK_MEDIA", ++ "ERROR_UNABLE_TO_UNLOAD_MEDIA", ++ "ERROR_MEDIA_CHANGED", ++ "ERROR_BUS_RESET", ++ "ERROR_NO_MEDIA_IN_DRIVE", ++ "ERROR_NO_UNICODE_TRANSLATION", ++ "ERROR_DLL_INIT_FAILED", ++ "ERROR_SHUTDOWN_IN_PROGRESS", ++ "ERROR_NO_SHUTDOWN_IN_PROGRESS", ++ "ERROR_IO_DEVICE", ++ "ERROR_SERIAL_NO_DEVICE", ++ "ERROR_IRQ_BUSY", ++ "ERROR_MORE_WRITES", ++ "ERROR_COUNTER_TIMEOUT", ++ "ERROR_FLOPPY_ID_MARK_NOT_FOUND", ++ "ERROR_FLOPPY_WRONG_CYLINDER", ++ "ERROR_FLOPPY_UNKNOWN_ERROR", ++ "ERROR_FLOPPY_BAD_REGISTERS", ++ "ERROR_DISK_RECALIBRATE_FAILED", ++ "ERROR_DISK_OPERATION_FAILED", ++ "ERROR_DISK_RESET_FAILED", ++ "ERROR_EOM_OVERFLOW", ++ "ERROR_NOT_ENOUGH_SERVER_MEMORY", ++ "ERROR_POSSIBLE_DEADLOCK", ++ "ERROR_MAPPED_ALIGNMENT", ++ "ERROR_SET_POWER_STATE_VETOED", ++ "ERROR_SET_POWER_STATE_FAILED", ++ "ERROR_TOO_MANY_LINKS", ++ "ERROR_OLD_WIN_VERSION", ++ "ERROR_APP_WRONG_OS", ++ "ERROR_SINGLE_INSTANCE_APP", ++ "ERROR_RMODE_APP", ++ "ERROR_INVALID_DLL", ++ "ERROR_NO_ASSOCIATION", ++ "ERROR_DDE_FAIL", ++ "ERROR_DLL_NOT_FOUND", ++ "ERROR_NO_MORE_USER_HANDLES", ++ "ERROR_MESSAGE_SYNC_ONLY", ++ "ERROR_SOURCE_ELEMENT_EMPTY", ++ "ERROR_DESTINATION_ELEMENT_FULL", ++ "ERROR_ILLEGAL_ELEMENT_ADDRESS", ++ "ERROR_MAGAZINE_NOT_PRESENT", ++ "ERROR_DEVICE_REINITIALIZATION_NEEDED", ++ "ERROR_DEVICE_REQUIRES_CLEANING", ++ "ERROR_DEVICE_DOOR_OPEN", ++ "ERROR_DEVICE_NOT_CONNECTED", ++ "ERROR_NOT_FOUND", ++ "ERROR_NO_MATCH", ++ "ERROR_SET_NOT_FOUND", ++ "ERROR_POINT_NOT_FOUND", ++ "ERROR_NO_TRACKING_SERVICE", ++ "ERROR_NO_VOLUME_ID", ++ "ERROR_UNABLE_TO_REMOVE_REPLACED", ++ "ERROR_UNABLE_TO_MOVE_REPLACEMENT", ++ "ERROR_UNABLE_TO_MOVE_REPLACEMENT_2", ++ "ERROR_JOURNAL_DELETE_IN_PROGRESS", ++ "ERROR_JOURNAL_NOT_ACTIVE", ++ "ERROR_POTENTIAL_FILE_FOUND", ++ "ERROR_JOURNAL_ENTRY_DELETED", ++ "ERROR_VRF_CFG_AND_IO_ENABLED", ++ "ERROR_PARTITION_TERMINATING", ++ "ERROR_SHUTDOWN_IS_SCHEDULED", ++ "ERROR_SHUTDOWN_USERS_LOGGED_ON", ++ "ERROR_BAD_DEVICE", ++ "ERROR_CONNECTION_UNAVAIL", ++ "ERROR_DEVICE_ALREADY_REMEMBERED", ++ "ERROR_NO_NET_OR_BAD_PATH", ++ "ERROR_BAD_PROVIDER", ++ "ERROR_CANNOT_OPEN_PROFILE", ++ "ERROR_BAD_PROFILE", ++ "ERROR_NOT_CONTAINER", ++ "ERROR_EXTENDED_ERROR", ++ "ERROR_INVALID_GROUPNAME", ++ "ERROR_INVALID_COMPUTERNAME", ++ "ERROR_INVALID_EVENTNAME", ++ "ERROR_INVALID_DOMAINNAME", ++ "ERROR_INVALID_SERVICENAME", ++ "ERROR_INVALID_NETNAME", ++ "ERROR_INVALID_SHARENAME", ++ "ERROR_INVALID_PASSWORDNAME", ++ "ERROR_INVALID_MESSAGENAME", ++ "ERROR_INVALID_MESSAGEDEST", ++ "ERROR_SESSION_CREDENTIAL_CONFLICT", ++ "ERROR_REMOTE_SESSION_LIMIT_EXCEEDED", ++ "ERROR_DUP_DOMAINNAME", ++ "ERROR_NO_NETWORK", ++ "ERROR_CANCELLED", ++ "ERROR_USER_MAPPED_FILE", ++ "ERROR_CONNECTION_REFUSED", ++ "ERROR_GRACEFUL_DISCONNECT", ++ "ERROR_ADDRESS_ALREADY_ASSOCIATED", ++ "ERROR_ADDRESS_NOT_ASSOCIATED", ++ "ERROR_CONNECTION_INVALID", ++ "ERROR_CONNECTION_ACTIVE", ++ "ERROR_NETWORK_UNREACHABLE", ++ "ERROR_HOST_UNREACHABLE", ++ "ERROR_PROTOCOL_UNREACHABLE", ++ "ERROR_PORT_UNREACHABLE", ++ "ERROR_REQUEST_ABORTED", ++ "ERROR_CONNECTION_ABORTED", ++ "ERROR_RETRY", ++ "ERROR_CONNECTION_COUNT_LIMIT", ++ "ERROR_LOGIN_TIME_RESTRICTION", ++ "ERROR_LOGIN_WKSTA_RESTRICTION", ++ "ERROR_INCORRECT_ADDRESS", ++ "ERROR_ALREADY_REGISTERED", ++ "ERROR_SERVICE_NOT_FOUND", ++ "ERROR_NOT_AUTHENTICATED", ++ "ERROR_NOT_LOGGED_ON", ++ "ERROR_CONTINUE", ++ "ERROR_ALREADY_INITIALIZED", ++ "ERROR_NO_MORE_DEVICES", ++ "ERROR_NO_SUCH_SITE", ++ "ERROR_DOMAIN_CONTROLLER_EXISTS", ++ "ERROR_ONLY_IF_CONNECTED", ++ "ERROR_OVERRIDE_NOCHANGES", ++ "ERROR_BAD_USER_PROFILE", ++ "ERROR_NOT_SUPPORTED_ON_SBS", ++ "ERROR_SERVER_SHUTDOWN_IN_PROGRESS", ++ "ERROR_HOST_DOWN", ++ "ERROR_NON_ACCOUNT_SID", ++ "ERROR_NON_DOMAIN_SID", ++ "ERROR_APPHELP_BLOCK", ++ "ERROR_ACCESS_DISABLED_BY_POLICY", ++ "ERROR_REG_NAT_CONSUMPTION", ++ "ERROR_CSCSHARE_OFFLINE", ++ "ERROR_PKINIT_FAILURE", ++ "ERROR_SMARTCARD_SUBSYSTEM_FAILURE", ++ "ERROR_DOWNGRADE_DETECTED", ++ "ERROR_MACHINE_LOCKED", ++ "ERROR_SMB_GUEST_LOGON_BLOCKED", ++ "ERROR_CALLBACK_SUPPLIED_INVALID_DATA", ++ "ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED", ++ "ERROR_DRIVER_BLOCKED", ++ "ERROR_INVALID_IMPORT_OF_NON_DLL", ++ "ERROR_ACCESS_DISABLED_WEBBLADE", ++ "ERROR_ACCESS_DISABLED_WEBBLADE_TAMPER", ++ "ERROR_RECOVERY_FAILURE", ++ "ERROR_ALREADY_FIBER", ++ "ERROR_ALREADY_THREAD", ++ "ERROR_STACK_BUFFER_OVERRUN", ++ "ERROR_PARAMETER_QUOTA_EXCEEDED", ++ "ERROR_DEBUGGER_INACTIVE", ++ "ERROR_DELAY_LOAD_FAILED", ++ "ERROR_VDM_DISALLOWED", ++ "ERROR_UNIDENTIFIED_ERROR", ++ "ERROR_INVALID_CRUNTIME_PARAMETER", ++ "ERROR_BEYOND_VDL", ++ "ERROR_INCOMPATIBLE_SERVICE_SID_TYPE", ++ "ERROR_DRIVER_PROCESS_TERMINATED", ++ "ERROR_IMPLEMENTATION_LIMIT", ++ "ERROR_PROCESS_IS_PROTECTED", ++ "ERROR_SERVICE_NOTIFY_CLIENT_LAGGING", ++ "ERROR_DISK_QUOTA_EXCEEDED", ++ "ERROR_CONTENT_BLOCKED", ++ "ERROR_INCOMPATIBLE_SERVICE_PRIVILEGE", ++ "ERROR_APP_HANG", ++ "ERROR_INVALID_LABEL", ++ "ERROR_NOT_ALL_ASSIGNED", ++ "ERROR_SOME_NOT_MAPPED", ++ "ERROR_NO_QUOTAS_FOR_ACCOUNT", ++ "ERROR_LOCAL_USER_SESSION_KEY", ++ "ERROR_NULL_LM_PASSWORD", ++ "ERROR_UNKNOWN_REVISION", ++ "ERROR_REVISION_MISMATCH", ++ "ERROR_INVALID_OWNER", ++ "ERROR_INVALID_PRIMARY_GROUP", ++ "ERROR_NO_IMPERSONATION_TOKEN", ++ "ERROR_CANT_DISABLE_MANDATORY", ++ "ERROR_NO_LOGON_SERVERS", ++ "ERROR_NO_SUCH_LOGON_SESSION", ++ "ERROR_NO_SUCH_PRIVILEGE", ++ "ERROR_PRIVILEGE_NOT_HELD", ++ "ERROR_INVALID_ACCOUNT_NAME", ++ "ERROR_USER_EXISTS", ++ "ERROR_NO_SUCH_USER", ++ "ERROR_GROUP_EXISTS", ++ "ERROR_NO_SUCH_GROUP", ++ "ERROR_MEMBER_IN_GROUP", ++ "ERROR_MEMBER_NOT_IN_GROUP", ++ "ERROR_LAST_ADMIN", ++ "ERROR_WRONG_PASSWORD", ++ "ERROR_ILL_FORMED_PASSWORD", ++ "ERROR_PASSWORD_RESTRICTION", ++ "ERROR_LOGON_FAILURE", ++ "ERROR_ACCOUNT_RESTRICTION", ++ "ERROR_INVALID_LOGON_HOURS", ++ "ERROR_INVALID_WORKSTATION", ++ "ERROR_PASSWORD_EXPIRED", ++ "ERROR_ACCOUNT_DISABLED", ++ "ERROR_NONE_MAPPED", ++ "ERROR_TOO_MANY_LUIDS_REQUESTED", ++ "ERROR_LUIDS_EXHAUSTED", ++ "ERROR_INVALID_SUB_AUTHORITY", ++ "ERROR_INVALID_ACL", ++ "ERROR_INVALID_SID", ++ "ERROR_INVALID_SECURITY_DESCR", ++ "ERROR_BAD_INHERITANCE_ACL", ++ "ERROR_SERVER_DISABLED", ++ "ERROR_SERVER_NOT_DISABLED", ++ "ERROR_INVALID_ID_AUTHORITY", ++ "ERROR_ALLOTTED_SPACE_EXCEEDED", ++ "ERROR_INVALID_GROUP_ATTRIBUTES", ++ "ERROR_BAD_IMPERSONATION_LEVEL", ++ "ERROR_CANT_OPEN_ANONYMOUS", ++ "ERROR_BAD_VALIDATION_CLASS", ++ "ERROR_BAD_TOKEN_TYPE", ++ "ERROR_NO_SECURITY_ON_OBJECT", ++ "ERROR_CANT_ACCESS_DOMAIN_INFO", ++ "ERROR_INVALID_SERVER_STATE", ++ "ERROR_INVALID_DOMAIN_STATE", ++ "ERROR_INVALID_DOMAIN_ROLE", ++ "ERROR_NO_SUCH_DOMAIN", ++ "ERROR_DOMAIN_EXISTS", ++ "ERROR_DOMAIN_LIMIT_EXCEEDED", ++ "ERROR_INTERNAL_DB_CORRUPTION", ++ "ERROR_INTERNAL_ERROR", ++ "ERROR_GENERIC_NOT_MAPPED", ++ "ERROR_BAD_DESCRIPTOR_FORMAT", ++ "ERROR_NOT_LOGON_PROCESS", ++ "ERROR_LOGON_SESSION_EXISTS", ++ "ERROR_NO_SUCH_PACKAGE", ++ "ERROR_BAD_LOGON_SESSION_STATE", ++ "ERROR_LOGON_SESSION_COLLISION", ++ "ERROR_INVALID_LOGON_TYPE", ++ "ERROR_CANNOT_IMPERSONATE", ++ "ERROR_RXACT_INVALID_STATE", ++ "ERROR_RXACT_COMMIT_FAILURE", ++ "ERROR_SPECIAL_ACCOUNT", ++ "ERROR_SPECIAL_GROUP", ++ "ERROR_SPECIAL_USER", ++ "ERROR_MEMBERS_PRIMARY_GROUP", ++ "ERROR_TOKEN_ALREADY_IN_USE", ++ "ERROR_NO_SUCH_ALIAS", ++ "ERROR_MEMBER_NOT_IN_ALIAS", ++ "ERROR_MEMBER_IN_ALIAS", ++ "ERROR_ALIAS_EXISTS", ++ "ERROR_LOGON_NOT_GRANTED", ++ "ERROR_TOO_MANY_SECRETS", ++ "ERROR_SECRET_TOO_LONG", ++ "ERROR_INTERNAL_DB_ERROR", ++ "ERROR_TOO_MANY_CONTEXT_IDS", ++ "ERROR_LOGON_TYPE_NOT_GRANTED", ++ "ERROR_NT_CROSS_ENCRYPTION_REQUIRED", ++ "ERROR_NO_SUCH_MEMBER", ++ "ERROR_INVALID_MEMBER", ++ "ERROR_TOO_MANY_SIDS", ++ "ERROR_LM_CROSS_ENCRYPTION_REQUIRED", ++ "ERROR_NO_INHERITANCE", ++ "ERROR_FILE_CORRUPT", ++ "ERROR_DISK_CORRUPT", ++ "ERROR_NO_USER_SESSION_KEY", ++ "ERROR_LICENSE_QUOTA_EXCEEDED", ++ "ERROR_WRONG_TARGET_NAME", ++ "ERROR_MUTUAL_AUTH_FAILED", ++ "ERROR_TIME_SKEW", ++ "ERROR_CURRENT_DOMAIN_NOT_ALLOWED", ++ "ERROR_INVALID_WINDOW_HANDLE", ++ "ERROR_INVALID_MENU_HANDLE", ++ "ERROR_INVALID_CURSOR_HANDLE", ++ "ERROR_INVALID_ACCEL_HANDLE", ++ "ERROR_INVALID_HOOK_HANDLE", ++ "ERROR_INVALID_DWP_HANDLE", ++ "ERROR_TLW_WITH_WSCHILD", ++ "ERROR_CANNOT_FIND_WND_CLASS", ++ "ERROR_WINDOW_OF_OTHER_THREAD", ++ "ERROR_HOTKEY_ALREADY_REGISTERED", ++ "ERROR_CLASS_ALREADY_EXISTS", ++ "ERROR_CLASS_DOES_NOT_EXIST", ++ "ERROR_CLASS_HAS_WINDOWS", ++ "ERROR_INVALID_INDEX", ++ "ERROR_INVALID_ICON_HANDLE", ++ "ERROR_PRIVATE_DIALOG_INDEX", ++ "ERROR_LISTBOX_ID_NOT_FOUND", ++ "ERROR_NO_WILDCARD_CHARACTERS", ++ "ERROR_CLIPBOARD_NOT_OPEN", ++ "ERROR_HOTKEY_NOT_REGISTERED", ++ "ERROR_WINDOW_NOT_DIALOG", ++ "ERROR_CONTROL_ID_NOT_FOUND", ++ "ERROR_INVALID_COMBOBOX_MESSAGE", ++ "ERROR_WINDOW_NOT_COMBOBOX", ++ "ERROR_INVALID_EDIT_HEIGHT", ++ "ERROR_DC_NOT_FOUND", ++ "ERROR_INVALID_HOOK_FILTER", ++ "ERROR_INVALID_FILTER_PROC", ++ "ERROR_HOOK_NEEDS_HMOD", ++ "ERROR_GLOBAL_ONLY_HOOK", ++ "ERROR_JOURNAL_HOOK_SET", ++ "ERROR_HOOK_NOT_INSTALLED", ++ "ERROR_INVALID_LB_MESSAGE", ++ "ERROR_SETCOUNT_ON_BAD_LB", ++ "ERROR_LB_WITHOUT_TABSTOPS", ++ "ERROR_DESTROY_OBJECT_OF_OTHER_THREAD", ++ "ERROR_CHILD_WINDOW_MENU", ++ "ERROR_NO_SYSTEM_MENU", ++ "ERROR_INVALID_MSGBOX_STYLE", ++ "ERROR_INVALID_SPI_VALUE", ++ "ERROR_SCREEN_ALREADY_LOCKED", ++ "ERROR_HWNDS_HAVE_DIFF_PARENT", ++ "ERROR_NOT_CHILD_WINDOW", ++ "ERROR_INVALID_GW_COMMAND", ++ "ERROR_INVALID_THREAD_ID", ++ "ERROR_NON_MDICHILD_WINDOW", ++ "ERROR_POPUP_ALREADY_ACTIVE", ++ "ERROR_NO_SCROLLBARS", ++ "ERROR_INVALID_SCROLLBAR_RANGE", ++ "ERROR_INVALID_SHOWWIN_COMMAND", ++ "ERROR_NO_SYSTEM_RESOURCES", ++ "ERROR_NONPAGED_SYSTEM_RESOURCES", ++ "ERROR_PAGED_SYSTEM_RESOURCES", ++ "ERROR_WORKING_SET_QUOTA", ++ "ERROR_PAGEFILE_QUOTA", ++ "ERROR_COMMITMENT_LIMIT", ++ "ERROR_MENU_ITEM_NOT_FOUND", ++ "ERROR_INVALID_KEYBOARD_HANDLE", ++ "ERROR_HOOK_TYPE_NOT_ALLOWED", ++ "ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION", ++ "ERROR_TIMEOUT", ++ "ERROR_INVALID_MONITOR_HANDLE", ++ "ERROR_INCORRECT_SIZE", ++ "ERROR_SYMLINK_CLASS_DISABLED", ++ "ERROR_SYMLINK_NOT_SUPPORTED", ++ "ERROR_XML_PARSE_ERROR", ++ "ERROR_XMLDSIG_ERROR", ++ "ERROR_RESTART_APPLICATION", ++ "ERROR_WRONG_COMPARTMENT", ++ "ERROR_AUTHIP_FAILURE", ++ "ERROR_NO_NVRAM_RESOURCES", ++ "ERROR_NOT_GUI_PROCESS", ++ "ERROR_EVENTLOG_FILE_CORRUPT", ++ "ERROR_EVENTLOG_CANT_START", ++ "ERROR_LOG_FILE_FULL", ++ "ERROR_EVENTLOG_FILE_CHANGED", ++ "ERROR_CONTAINER_ASSIGNED", ++ "ERROR_JOB_NO_CONTAINER", ++ "ERROR_INVALID_TASK_NAME", ++ "ERROR_INVALID_TASK_INDEX", ++ "ERROR_THREAD_ALREADY_IN_TASK", ++ "ERROR_INSTALL_SERVICE_FAILURE", ++ "ERROR_INSTALL_USEREXIT", ++ "ERROR_INSTALL_FAILURE", ++ "ERROR_INSTALL_SUSPEND", ++ "ERROR_UNKNOWN_PRODUCT", ++ "ERROR_UNKNOWN_FEATURE", ++ "ERROR_UNKNOWN_COMPONENT", ++ "ERROR_UNKNOWN_PROPERTY", ++ "ERROR_INVALID_HANDLE_STATE", ++ "ERROR_BAD_CONFIGURATION", ++ "ERROR_INDEX_ABSENT", ++ "ERROR_INSTALL_SOURCE_ABSENT", ++ "ERROR_INSTALL_PACKAGE_VERSION", ++ "ERROR_PRODUCT_UNINSTALLED", ++ "ERROR_BAD_QUERY_SYNTAX", ++ "ERROR_INVALID_FIELD", ++ "ERROR_DEVICE_REMOVED", ++ "ERROR_INSTALL_ALREADY_RUNNING", ++ "ERROR_INSTALL_PACKAGE_OPEN_FAILED", ++ "ERROR_INSTALL_PACKAGE_INVALID", ++ "ERROR_INSTALL_UI_FAILURE", ++ "ERROR_INSTALL_LOG_FAILURE", ++ "ERROR_INSTALL_LANGUAGE_UNSUPPORTED", ++ "ERROR_INSTALL_TRANSFORM_FAILURE", ++ "ERROR_INSTALL_PACKAGE_REJECTED", ++ "ERROR_FUNCTION_NOT_CALLED", ++ "ERROR_FUNCTION_FAILED", ++ "ERROR_INVALID_TABLE", ++ "ERROR_DATATYPE_MISMATCH", ++ "ERROR_UNSUPPORTED_TYPE", ++ "ERROR_CREATE_FAILED", ++ "ERROR_INSTALL_TEMP_UNWRITABLE", ++ "ERROR_INSTALL_PLATFORM_UNSUPPORTED", ++ "ERROR_INSTALL_NOTUSED", ++ "ERROR_PATCH_PACKAGE_OPEN_FAILED", ++ "ERROR_PATCH_PACKAGE_INVALID", ++ "ERROR_PATCH_PACKAGE_UNSUPPORTED", ++ "ERROR_PRODUCT_VERSION", ++ "ERROR_INVALID_COMMAND_LINE", ++ "ERROR_INSTALL_REMOTE_DISALLOWED", ++ "ERROR_SUCCESS_REBOOT_INITIATED", ++ "ERROR_PATCH_TARGET_NOT_FOUND", ++ "ERROR_PATCH_PACKAGE_REJECTED", ++ "ERROR_INSTALL_TRANSFORM_REJECTED", ++ "ERROR_INSTALL_REMOTE_PROHIBITED", ++ "ERROR_PATCH_REMOVAL_UNSUPPORTED", ++ "ERROR_UNKNOWN_PATCH", ++ "ERROR_PATCH_NO_SEQUENCE", ++ "ERROR_PATCH_REMOVAL_DISALLOWED", ++ "ERROR_INVALID_PATCH_XML", ++ "ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT", ++ "ERROR_INSTALL_SERVICE_SAFEBOOT", ++ "ERROR_FAIL_FAST_EXCEPTION", ++ "ERROR_INSTALL_REJECTED", ++ "ERROR_DYNAMIC_CODE_BLOCKED", ++ "ERROR_NOT_SAME_OBJECT", ++ "ERROR_STRICT_CFG_VIOLATION", ++ "ERROR_SET_CONTEXT_DENIED", ++ "ERROR_CROSS_PARTITION_VIOLATION", ++ "ERROR_RETURN_ADDRESS_HIJACK_ATTEMPT", ++ "ERROR_INVALID_USER_BUFFER", ++ "ERROR_UNRECOGNIZED_MEDIA", ++ "ERROR_NO_TRUST_LSA_SECRET", ++ "ERROR_NO_TRUST_SAM_ACCOUNT", ++ "ERROR_TRUSTED_DOMAIN_FAILURE", ++ "ERROR_TRUSTED_RELATIONSHIP_FAILURE", ++ "ERROR_TRUST_FAILURE", ++ "ERROR_NETLOGON_NOT_STARTED", ++ "ERROR_ACCOUNT_EXPIRED", ++ "ERROR_REDIRECTOR_HAS_OPEN_HANDLES", ++ "ERROR_PRINTER_DRIVER_ALREADY_INSTALLED", ++ "ERROR_UNKNOWN_PORT", ++ "ERROR_UNKNOWN_PRINTER_DRIVER", ++ "ERROR_UNKNOWN_PRINTPROCESSOR", ++ "ERROR_INVALID_SEPARATOR_FILE", ++ "ERROR_INVALID_PRIORITY", ++ "ERROR_INVALID_PRINTER_NAME", ++ "ERROR_PRINTER_ALREADY_EXISTS", ++ "ERROR_INVALID_PRINTER_COMMAND", ++ "ERROR_INVALID_DATATYPE", ++ "ERROR_INVALID_ENVIRONMENT", ++ "ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT", ++ "ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT", ++ "ERROR_NOLOGON_SERVER_TRUST_ACCOUNT", ++ "ERROR_DOMAIN_TRUST_INCONSISTENT", ++ "ERROR_SERVER_HAS_OPEN_HANDLES", ++ "ERROR_RESOURCE_DATA_NOT_FOUND", ++ "ERROR_RESOURCE_TYPE_NOT_FOUND", ++ "ERROR_RESOURCE_NAME_NOT_FOUND", ++ "ERROR_RESOURCE_LANG_NOT_FOUND", ++ "ERROR_NOT_ENOUGH_QUOTA", ++ "ERROR_INVALID_TIME", ++ "ERROR_INVALID_FORM_NAME", ++ "ERROR_INVALID_FORM_SIZE", ++ "ERROR_ALREADY_WAITING", ++ "ERROR_PRINTER_DELETED", ++ "ERROR_INVALID_PRINTER_STATE", ++ "ERROR_PASSWORD_MUST_CHANGE", ++ "ERROR_DOMAIN_CONTROLLER_NOT_FOUND", ++ "ERROR_ACCOUNT_LOCKED_OUT", ++ "ERROR_NO_SITENAME", ++ "ERROR_CANT_ACCESS_FILE", ++ "ERROR_CANT_RESOLVE_FILENAME", ++ "ERROR_KM_DRIVER_BLOCKED", ++ "ERROR_CONTEXT_EXPIRED", ++ "ERROR_PER_USER_TRUST_QUOTA_EXCEEDED", ++ "ERROR_ALL_USER_TRUST_QUOTA_EXCEEDED", ++ "ERROR_USER_DELETE_TRUST_QUOTA_EXCEEDED", ++ "ERROR_AUTHENTICATION_FIREWALL_FAILED", ++ "ERROR_REMOTE_PRINT_CONNECTIONS_BLOCKED", ++ "ERROR_NTLM_BLOCKED", ++ "ERROR_PASSWORD_CHANGE_REQUIRED", ++ "ERROR_LOST_MODE_LOGON_RESTRICTION", ++ "ERROR_INVALID_PIXEL_FORMAT", ++ "ERROR_BAD_DRIVER", ++ "ERROR_INVALID_WINDOW_STYLE", ++ "ERROR_METAFILE_NOT_SUPPORTED", ++ "ERROR_TRANSFORM_NOT_SUPPORTED", ++ "ERROR_CLIPPING_NOT_SUPPORTED", ++ "ERROR_INVALID_CMM", ++ "ERROR_INVALID_PROFILE", ++ "ERROR_TAG_NOT_FOUND", ++ "ERROR_TAG_NOT_PRESENT", ++ "ERROR_DUPLICATE_TAG", ++ "ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE", ++ "ERROR_PROFILE_NOT_FOUND", ++ "ERROR_INVALID_COLORSPACE", ++ "ERROR_ICM_NOT_ENABLED", ++ "ERROR_DELETING_ICM_XFORM", ++ "ERROR_INVALID_TRANSFORM", ++ "ERROR_COLORSPACE_MISMATCH", ++ "ERROR_INVALID_COLORINDEX", ++ "ERROR_PROFILE_DOES_NOT_MATCH_DEVICE", ++ "ERROR_CONNECTED_OTHER_PASSWORD", ++ "ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT", ++ "ERROR_BAD_USERNAME", ++ "ERROR_NOT_CONNECTED", ++ "ERROR_OPEN_FILES", ++ "ERROR_ACTIVE_CONNECTIONS", ++ "ERROR_DEVICE_IN_USE", ++ "ERROR_UNKNOWN_PRINT_MONITOR", ++ "ERROR_PRINTER_DRIVER_IN_USE", ++ "ERROR_SPOOL_FILE_NOT_FOUND", ++ "ERROR_SPL_NO_STARTDOC", ++ "ERROR_SPL_NO_ADDJOB", ++ "ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED", ++ "ERROR_PRINT_MONITOR_ALREADY_INSTALLED", ++ "ERROR_INVALID_PRINT_MONITOR", ++ "ERROR_PRINT_MONITOR_IN_USE", ++ "ERROR_PRINTER_HAS_JOBS_QUEUED", ++ "ERROR_SUCCESS_REBOOT_REQUIRED", ++ "ERROR_SUCCESS_RESTART_REQUIRED", ++ "ERROR_PRINTER_NOT_FOUND", ++ "ERROR_PRINTER_DRIVER_WARNED", ++ "ERROR_PRINTER_DRIVER_BLOCKED", ++ "ERROR_PRINTER_DRIVER_PACKAGE_IN_USE", ++ "ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND", ++ "ERROR_FAIL_REBOOT_REQUIRED", ++ "ERROR_FAIL_REBOOT_INITIATED", ++ "ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED", ++ "ERROR_PRINT_JOB_RESTART_REQUIRED", ++ "ERROR_INVALID_PRINTER_DRIVER_MANIFEST", ++ "ERROR_PRINTER_NOT_SHAREABLE", ++ "ERROR_REQUEST_PAUSED", ++ "ERROR_APPEXEC_CONDITION_NOT_SATISFIED", ++ "ERROR_APPEXEC_HANDLE_INVALIDATED", ++ "ERROR_APPEXEC_INVALID_HOST_GENERATION", ++ "ERROR_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION", ++ "ERROR_APPEXEC_INVALID_HOST_STATE", ++ "ERROR_APPEXEC_NO_DONOR", ++ "ERROR_APPEXEC_HOST_ID_MISMATCH", ++ "ERROR_APPEXEC_UNKNOWN_USER", ++ "ERROR_IO_REISSUE_AS_CACHED", ++ "ERROR_WINS_INTERNAL", ++ "ERROR_CAN_NOT_DEL_LOCAL_WINS", ++ "ERROR_STATIC_INIT", ++ "ERROR_INC_BACKUP", ++ "ERROR_FULL_BACKUP", ++ "ERROR_REC_NON_EXISTENT", ++ "ERROR_RPL_NOT_ALLOWED", ++ "ERROR_DHCP_ADDRESS_CONFLICT", ++ "ERROR_WMI_GUID_NOT_FOUND", ++ "ERROR_WMI_INSTANCE_NOT_FOUND", ++ "ERROR_WMI_ITEMID_NOT_FOUND", ++ "ERROR_WMI_TRY_AGAIN", ++ "ERROR_WMI_DP_NOT_FOUND", ++ "ERROR_WMI_UNRESOLVED_INSTANCE_REF", ++ "ERROR_WMI_ALREADY_ENABLED", ++ "ERROR_WMI_GUID_DISCONNECTED", ++ "ERROR_WMI_SERVER_UNAVAILABLE", ++ "ERROR_WMI_DP_FAILED", ++ "ERROR_WMI_INVALID_MOF", ++ "ERROR_WMI_INVALID_REGINFO", ++ "ERROR_WMI_ALREADY_DISABLED", ++ "ERROR_WMI_READ_ONLY", ++ "ERROR_WMI_SET_FAILURE", ++ "ERROR_NOT_APPCONTAINER", ++ "ERROR_APPCONTAINER_REQUIRED", ++ "ERROR_NOT_SUPPORTED_IN_APPCONTAINER", ++ "ERROR_INVALID_PACKAGE_SID_LENGTH", ++ "ERROR_INVALID_MEDIA", ++ "ERROR_INVALID_LIBRARY", ++ "ERROR_INVALID_MEDIA_POOL", ++ "ERROR_DRIVE_MEDIA_MISMATCH", ++ "ERROR_MEDIA_OFFLINE", ++ "ERROR_LIBRARY_OFFLINE", ++ "ERROR_EMPTY", ++ "ERROR_NOT_EMPTY", ++ "ERROR_MEDIA_UNAVAILABLE", ++ "ERROR_RESOURCE_DISABLED", ++ "ERROR_INVALID_CLEANER", ++ "ERROR_UNABLE_TO_CLEAN", ++ "ERROR_OBJECT_NOT_FOUND", ++ "ERROR_DATABASE_FAILURE", ++ "ERROR_DATABASE_FULL", ++ "ERROR_MEDIA_INCOMPATIBLE", ++ "ERROR_RESOURCE_NOT_PRESENT", ++ "ERROR_INVALID_OPERATION", ++ "ERROR_MEDIA_NOT_AVAILABLE", ++ "ERROR_DEVICE_NOT_AVAILABLE", ++ "ERROR_REQUEST_REFUSED", ++ "ERROR_INVALID_DRIVE_OBJECT", ++ "ERROR_LIBRARY_FULL", ++ "ERROR_MEDIUM_NOT_ACCESSIBLE", ++ "ERROR_UNABLE_TO_LOAD_MEDIUM", ++ "ERROR_UNABLE_TO_INVENTORY_DRIVE", ++ "ERROR_UNABLE_TO_INVENTORY_SLOT", ++ "ERROR_UNABLE_TO_INVENTORY_TRANSPORT", ++ "ERROR_TRANSPORT_FULL", ++ "ERROR_CONTROLLING_IEPORT", ++ "ERROR_UNABLE_TO_EJECT_MOUNTED_MEDIA", ++ "ERROR_CLEANER_SLOT_SET", ++ "ERROR_CLEANER_SLOT_NOT_SET", ++ "ERROR_CLEANER_CARTRIDGE_SPENT", ++ "ERROR_UNEXPECTED_OMID", ++ "ERROR_CANT_DELETE_LAST_ITEM", ++ "ERROR_MESSAGE_EXCEEDS_MAX_SIZE", ++ "ERROR_VOLUME_CONTAINS_SYS_FILES", ++ "ERROR_INDIGENOUS_TYPE", ++ "ERROR_NO_SUPPORTING_DRIVES", ++ "ERROR_CLEANER_CARTRIDGE_INSTALLED", ++ "ERROR_IEPORT_FULL", ++ "ERROR_FILE_OFFLINE", ++ "ERROR_REMOTE_STORAGE_NOT_ACTIVE", ++ "ERROR_REMOTE_STORAGE_MEDIA_ERROR", ++ "ERROR_NOT_A_REPARSE_POINT", ++ "ERROR_REPARSE_ATTRIBUTE_CONFLICT", ++ "ERROR_INVALID_REPARSE_DATA", ++ "ERROR_REPARSE_TAG_INVALID", ++ "ERROR_REPARSE_TAG_MISMATCH", ++ "ERROR_REPARSE_POINT_ENCOUNTERED", ++ "ERROR_APP_DATA_NOT_FOUND", ++ "ERROR_APP_DATA_EXPIRED", ++ "ERROR_APP_DATA_CORRUPT", ++ "ERROR_APP_DATA_LIMIT_EXCEEDED", ++ "ERROR_APP_DATA_REBOOT_REQUIRED", ++ "ERROR_SECUREBOOT_ROLLBACK_DETECTED", ++ "ERROR_SECUREBOOT_POLICY_VIOLATION", ++ "ERROR_SECUREBOOT_INVALID_POLICY", ++ "ERROR_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND", ++ "ERROR_SECUREBOOT_POLICY_NOT_SIGNED", ++ "ERROR_SECUREBOOT_NOT_ENABLED", ++ "ERROR_SECUREBOOT_FILE_REPLACED", ++ "ERROR_SECUREBOOT_POLICY_NOT_AUTHORIZED", ++ "ERROR_SECUREBOOT_POLICY_UNKNOWN", ++ "ERROR_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION", ++ "ERROR_SECUREBOOT_PLATFORM_ID_MISMATCH", ++ "ERROR_SECUREBOOT_POLICY_ROLLBACK_DETECTED", ++ "ERROR_SECUREBOOT_POLICY_UPGRADE_MISMATCH", ++ "ERROR_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING", ++ "ERROR_SECUREBOOT_NOT_BASE_POLICY", ++ "ERROR_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY", ++ "ERROR_OFFLOAD_READ_FLT_NOT_SUPPORTED", ++ "ERROR_OFFLOAD_WRITE_FLT_NOT_SUPPORTED", ++ "ERROR_OFFLOAD_READ_FILE_NOT_SUPPORTED", ++ "ERROR_OFFLOAD_WRITE_FILE_NOT_SUPPORTED", ++ "ERROR_ALREADY_HAS_STREAM_ID", ++ "ERROR_SMR_GARBAGE_COLLECTION_REQUIRED", ++ "ERROR_WOF_WIM_HEADER_CORRUPT", ++ "ERROR_WOF_WIM_RESOURCE_TABLE_CORRUPT", ++ "ERROR_WOF_FILE_RESOURCE_TABLE_CORRUPT", ++ "ERROR_VOLUME_NOT_SIS_ENABLED", ++ "ERROR_SYSTEM_INTEGRITY_ROLLBACK_DETECTED", ++ "ERROR_SYSTEM_INTEGRITY_POLICY_VIOLATION", ++ "ERROR_SYSTEM_INTEGRITY_INVALID_POLICY", ++ "ERROR_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED", ++ "ERROR_SYSTEM_INTEGRITY_TOO_MANY_POLICIES", ++ "ERROR_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED", ++ "ERROR_VSM_NOT_INITIALIZED", ++ "ERROR_VSM_DMA_PROTECTION_NOT_IN_USE", ++ "ERROR_PLATFORM_MANIFEST_NOT_AUTHORIZED", ++ "ERROR_PLATFORM_MANIFEST_INVALID", ++ "ERROR_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED", ++ "ERROR_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED", ++ "ERROR_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND", ++ "ERROR_PLATFORM_MANIFEST_NOT_ACTIVE", ++ "ERROR_PLATFORM_MANIFEST_NOT_SIGNED", ++ "ERROR_DEPENDENT_RESOURCE_EXISTS", ++ "ERROR_DEPENDENCY_NOT_FOUND", ++ "ERROR_DEPENDENCY_ALREADY_EXISTS", ++ "ERROR_RESOURCE_NOT_ONLINE", ++ "ERROR_HOST_NODE_NOT_AVAILABLE", ++ "ERROR_RESOURCE_NOT_AVAILABLE", ++ "ERROR_RESOURCE_NOT_FOUND", ++ "ERROR_SHUTDOWN_CLUSTER", ++ "ERROR_CANT_EVICT_ACTIVE_NODE", ++ "ERROR_OBJECT_ALREADY_EXISTS", ++ "ERROR_OBJECT_IN_LIST", ++ "ERROR_GROUP_NOT_AVAILABLE", ++ "ERROR_GROUP_NOT_FOUND", ++ "ERROR_GROUP_NOT_ONLINE", ++ "ERROR_HOST_NODE_NOT_RESOURCE_OWNER", ++ "ERROR_HOST_NODE_NOT_GROUP_OWNER", ++ "ERROR_RESMON_CREATE_FAILED", ++ "ERROR_RESMON_ONLINE_FAILED", ++ "ERROR_RESOURCE_ONLINE", ++ "ERROR_QUORUM_RESOURCE", ++ "ERROR_NOT_QUORUM_CAPABLE", ++ "ERROR_CLUSTER_SHUTTING_DOWN", ++ "ERROR_INVALID_STATE", ++ "ERROR_RESOURCE_PROPERTIES_STORED", ++ "ERROR_NOT_QUORUM_CLASS", ++ "ERROR_CORE_RESOURCE", ++ "ERROR_QUORUM_RESOURCE_ONLINE_FAILED", ++ "ERROR_QUORUMLOG_OPEN_FAILED", ++ "ERROR_CLUSTERLOG_CORRUPT", ++ "ERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE", ++ "ERROR_CLUSTERLOG_EXCEEDS_MAXSIZE", ++ "ERROR_CLUSTERLOG_CHKPOINT_NOT_FOUND", ++ "ERROR_CLUSTERLOG_NOT_ENOUGH_SPACE", ++ "ERROR_QUORUM_OWNER_ALIVE", ++ "ERROR_NETWORK_NOT_AVAILABLE", ++ "ERROR_NODE_NOT_AVAILABLE", ++ "ERROR_ALL_NODES_NOT_AVAILABLE", ++ "ERROR_RESOURCE_FAILED", ++ "ERROR_CLUSTER_INVALID_NODE", ++ "ERROR_CLUSTER_NODE_EXISTS", ++ "ERROR_CLUSTER_JOIN_IN_PROGRESS", ++ "ERROR_CLUSTER_NODE_NOT_FOUND", ++ "ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND", ++ "ERROR_CLUSTER_NETWORK_EXISTS", ++ "ERROR_CLUSTER_NETWORK_NOT_FOUND", ++ "ERROR_CLUSTER_NETINTERFACE_EXISTS", ++ "ERROR_CLUSTER_NETINTERFACE_NOT_FOUND", ++ "ERROR_CLUSTER_INVALID_REQUEST", ++ "ERROR_CLUSTER_INVALID_NETWORK_PROVIDER", ++ "ERROR_CLUSTER_NODE_DOWN", ++ "ERROR_CLUSTER_NODE_UNREACHABLE", ++ "ERROR_CLUSTER_NODE_NOT_MEMBER", ++ "ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS", ++ "ERROR_CLUSTER_INVALID_NETWORK", ++ "ERROR_CLUSTER_NODE_UP", ++ "ERROR_CLUSTER_IPADDR_IN_USE", ++ "ERROR_CLUSTER_NODE_NOT_PAUSED", ++ "ERROR_CLUSTER_NO_SECURITY_CONTEXT", ++ "ERROR_CLUSTER_NETWORK_NOT_INTERNAL", ++ "ERROR_CLUSTER_NODE_ALREADY_UP", ++ "ERROR_CLUSTER_NODE_ALREADY_DOWN", ++ "ERROR_CLUSTER_NETWORK_ALREADY_ONLINE", ++ "ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE", ++ "ERROR_CLUSTER_NODE_ALREADY_MEMBER", ++ "ERROR_CLUSTER_LAST_INTERNAL_NETWORK", ++ "ERROR_CLUSTER_NETWORK_HAS_DEPENDENTS", ++ "ERROR_INVALID_OPERATION_ON_QUORUM", ++ "ERROR_DEPENDENCY_NOT_ALLOWED", ++ "ERROR_CLUSTER_NODE_PAUSED", ++ "ERROR_NODE_CANT_HOST_RESOURCE", ++ "ERROR_CLUSTER_NODE_NOT_READY", ++ "ERROR_CLUSTER_NODE_SHUTTING_DOWN", ++ "ERROR_CLUSTER_JOIN_ABORTED", ++ "ERROR_CLUSTER_INCOMPATIBLE_VERSIONS", ++ "ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED", ++ "ERROR_CLUSTER_SYSTEM_CONFIG_CHANGED", ++ "ERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUND", ++ "ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED", ++ "ERROR_CLUSTER_RESNAME_NOT_FOUND", ++ "ERROR_CLUSTER_NO_RPC_PACKAGES_REGISTERED", ++ "ERROR_CLUSTER_OWNER_NOT_IN_PREFLIST", ++ "ERROR_CLUSTER_DATABASE_SEQMISMATCH", ++ "ERROR_RESMON_INVALID_STATE", ++ "ERROR_CLUSTER_GUM_NOT_LOCKER", ++ "ERROR_QUORUM_DISK_NOT_FOUND", ++ "ERROR_DATABASE_BACKUP_CORRUPT", ++ "ERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT", ++ "ERROR_RESOURCE_PROPERTY_UNCHANGEABLE", ++ "ERROR_NO_ADMIN_ACCESS_POINT", ++ "ERROR_CLUSTER_MEMBERSHIP_INVALID_STATE", ++ "ERROR_CLUSTER_QUORUMLOG_NOT_FOUND", ++ "ERROR_CLUSTER_MEMBERSHIP_HALT", ++ "ERROR_CLUSTER_INSTANCE_ID_MISMATCH", ++ "ERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP", ++ "ERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH", ++ "ERROR_CLUSTER_EVICT_WITHOUT_CLEANUP", ++ "ERROR_CLUSTER_PARAMETER_MISMATCH", ++ "ERROR_NODE_CANNOT_BE_CLUSTERED", ++ "ERROR_CLUSTER_WRONG_OS_VERSION", ++ "ERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME", ++ "ERROR_CLUSCFG_ALREADY_COMMITTED", ++ "ERROR_CLUSCFG_ROLLBACK_FAILED", ++ "ERROR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT", ++ "ERROR_CLUSTER_OLD_VERSION", ++ "ERROR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME", ++ "ERROR_CLUSTER_NO_NET_ADAPTERS", ++ "ERROR_CLUSTER_POISONED", ++ "ERROR_CLUSTER_GROUP_MOVING", ++ "ERROR_CLUSTER_RESOURCE_TYPE_BUSY", ++ "ERROR_RESOURCE_CALL_TIMED_OUT", ++ "ERROR_INVALID_CLUSTER_IPV6_ADDRESS", ++ "ERROR_CLUSTER_INTERNAL_INVALID_FUNCTION", ++ "ERROR_CLUSTER_PARAMETER_OUT_OF_BOUNDS", ++ "ERROR_CLUSTER_PARTIAL_SEND", ++ "ERROR_CLUSTER_REGISTRY_INVALID_FUNCTION", ++ "ERROR_CLUSTER_INVALID_STRING_TERMINATION", ++ "ERROR_CLUSTER_INVALID_STRING_FORMAT", ++ "ERROR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS", ++ "ERROR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS", ++ "ERROR_CLUSTER_NULL_DATA", ++ "ERROR_CLUSTER_PARTIAL_READ", ++ "ERROR_CLUSTER_PARTIAL_WRITE", ++ "ERROR_CLUSTER_CANT_DESERIALIZE_DATA", ++ "ERROR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT", ++ "ERROR_CLUSTER_NO_QUORUM", ++ "ERROR_CLUSTER_INVALID_IPV6_NETWORK", ++ "ERROR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK", ++ "ERROR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP", ++ "ERROR_DEPENDENCY_TREE_TOO_COMPLEX", ++ "ERROR_EXCEPTION_IN_RESOURCE_CALL", ++ "ERROR_CLUSTER_RHS_FAILED_INITIALIZATION", ++ "ERROR_CLUSTER_NOT_INSTALLED", ++ "ERROR_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODE", ++ "ERROR_CLUSTER_MAX_NODES_IN_CLUSTER", ++ "ERROR_CLUSTER_TOO_MANY_NODES", ++ "ERROR_CLUSTER_OBJECT_ALREADY_USED", ++ "ERROR_NONCORE_GROUPS_FOUND", ++ "ERROR_FILE_SHARE_RESOURCE_CONFLICT", ++ "ERROR_CLUSTER_EVICT_INVALID_REQUEST", ++ "ERROR_CLUSTER_SINGLETON_RESOURCE", ++ "ERROR_CLUSTER_GROUP_SINGLETON_RESOURCE", ++ "ERROR_CLUSTER_RESOURCE_PROVIDER_FAILED", ++ "ERROR_CLUSTER_RESOURCE_CONFIGURATION_ERROR", ++ "ERROR_CLUSTER_GROUP_BUSY", ++ "ERROR_CLUSTER_NOT_SHARED_VOLUME", ++ "ERROR_CLUSTER_INVALID_SECURITY_DESCRIPTOR", ++ "ERROR_CLUSTER_SHARED_VOLUMES_IN_USE", ++ "ERROR_CLUSTER_USE_SHARED_VOLUMES_API", ++ "ERROR_CLUSTER_BACKUP_IN_PROGRESS", ++ "ERROR_NON_CSV_PATH", ++ "ERROR_CSV_VOLUME_NOT_LOCAL", ++ "ERROR_CLUSTER_WATCHDOG_TERMINATING", ++ "ERROR_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODES", ++ "ERROR_CLUSTER_INVALID_NODE_WEIGHT", ++ "ERROR_CLUSTER_RESOURCE_VETOED_CALL", ++ "ERROR_RESMON_SYSTEM_RESOURCES_LACKING", ++ "ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATION", ++ "ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCE", ++ "ERROR_CLUSTER_GROUP_QUEUED", ++ "ERROR_CLUSTER_RESOURCE_LOCKED_STATUS", ++ "ERROR_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWED", ++ "ERROR_CLUSTER_NODE_DRAIN_IN_PROGRESS", ++ "ERROR_CLUSTER_DISK_NOT_CONNECTED", ++ "ERROR_DISK_NOT_CSV_CAPABLE", ++ "ERROR_RESOURCE_NOT_IN_AVAILABLE_STORAGE", ++ "ERROR_CLUSTER_SHARED_VOLUME_REDIRECTED", ++ "ERROR_CLUSTER_SHARED_VOLUME_NOT_REDIRECTED", ++ "ERROR_CLUSTER_CANNOT_RETURN_PROPERTIES", ++ "ERROR_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMES", ++ "ERROR_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODE", ++ "ERROR_CLUSTER_AFFINITY_CONFLICT", ++ "ERROR_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINE", ++ "ERROR_CLUSTER_UPGRADE_INCOMPATIBLE_VERSIONS", ++ "ERROR_CLUSTER_UPGRADE_FIX_QUORUM_NOT_SUPPORTED", ++ "ERROR_CLUSTER_UPGRADE_RESTART_REQUIRED", ++ "ERROR_CLUSTER_UPGRADE_IN_PROGRESS", ++ "ERROR_CLUSTER_UPGRADE_INCOMPLETE", ++ "ERROR_CLUSTER_NODE_IN_GRACE_PERIOD", ++ "ERROR_CLUSTER_CSV_IO_PAUSE_TIMEOUT", ++ "ERROR_NODE_NOT_ACTIVE_CLUSTER_MEMBER", ++ "ERROR_CLUSTER_RESOURCE_NOT_MONITORED", ++ "ERROR_CLUSTER_RESOURCE_DOES_NOT_SUPPORT_UNMONITORED", ++ "ERROR_CLUSTER_RESOURCE_IS_REPLICATED", ++ "ERROR_CLUSTER_NODE_ISOLATED", ++ "ERROR_CLUSTER_NODE_QUARANTINED", ++ "ERROR_CLUSTER_DATABASE_UPDATE_CONDITION_FAILED", ++ "ERROR_CLUSTER_SPACE_DEGRADED", ++ "ERROR_CLUSTER_TOKEN_DELEGATION_NOT_SUPPORTED", ++ "ERROR_CLUSTER_CSV_INVALID_HANDLE", ++ "ERROR_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR", ++ "ERROR_GROUPSET_NOT_AVAILABLE", ++ "ERROR_GROUPSET_NOT_FOUND", ++ "ERROR_GROUPSET_CANT_PROVIDE", ++ "ERROR_CLUSTER_FAULT_DOMAIN_PARENT_NOT_FOUND", ++ "ERROR_CLUSTER_FAULT_DOMAIN_INVALID_HIERARCHY", ++ "ERROR_CLUSTER_FAULT_DOMAIN_FAILED_S2D_VALIDATION", ++ "ERROR_CLUSTER_FAULT_DOMAIN_S2D_CONNECTIVITY_LOSS", ++ "ERROR_CLUSTER_INVALID_INFRASTRUCTURE_FILESERVER_NAME", ++ "ERROR_CLUSTERSET_MANAGEMENT_CLUSTER_UNREACHABLE", ++ "ERROR_ENCRYPTION_FAILED", ++ "ERROR_DECRYPTION_FAILED", ++ "ERROR_FILE_ENCRYPTED", ++ "ERROR_NO_RECOVERY_POLICY", ++ "ERROR_NO_EFS", ++ "ERROR_WRONG_EFS", ++ "ERROR_NO_USER_KEYS", ++ "ERROR_FILE_NOT_ENCRYPTED", ++ "ERROR_NOT_EXPORT_FORMAT", ++ "ERROR_FILE_READ_ONLY", ++ "ERROR_DIR_EFS_DISALLOWED", ++ "ERROR_EFS_SERVER_NOT_TRUSTED", ++ "ERROR_BAD_RECOVERY_POLICY", ++ "ERROR_EFS_ALG_BLOB_TOO_BIG", ++ "ERROR_VOLUME_NOT_SUPPORT_EFS", ++ "ERROR_EFS_DISABLED", ++ "ERROR_EFS_VERSION_NOT_SUPPORT", ++ "ERROR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE", ++ "ERROR_CS_ENCRYPTION_UNSUPPORTED_SERVER", ++ "ERROR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE", ++ "ERROR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE", ++ "ERROR_CS_ENCRYPTION_FILE_NOT_CSE", ++ "ERROR_ENCRYPTION_POLICY_DENIES_OPERATION", ++ "ERROR_WIP_ENCRYPTION_FAILED", ++ "ERROR_NO_BROWSER_SERVERS_FOUND", ++ "ERROR_CLUSTER_OBJECT_IS_CLUSTER_SET_VM", ++ "ERROR_LOG_SECTOR_INVALID", ++ "ERROR_LOG_SECTOR_PARITY_INVALID", ++ "ERROR_LOG_SECTOR_REMAPPED", ++ "ERROR_LOG_BLOCK_INCOMPLETE", ++ "ERROR_LOG_INVALID_RANGE", ++ "ERROR_LOG_BLOCKS_EXHAUSTED", ++ "ERROR_LOG_READ_CONTEXT_INVALID", ++ "ERROR_LOG_RESTART_INVALID", ++ "ERROR_LOG_BLOCK_VERSION", ++ "ERROR_LOG_BLOCK_INVALID", ++ "ERROR_LOG_READ_MODE_INVALID", ++ "ERROR_LOG_NO_RESTART", ++ "ERROR_LOG_METADATA_CORRUPT", ++ "ERROR_LOG_METADATA_INVALID", ++ "ERROR_LOG_METADATA_INCONSISTENT", ++ "ERROR_LOG_RESERVATION_INVALID", ++ "ERROR_LOG_CANT_DELETE", ++ "ERROR_LOG_CONTAINER_LIMIT_EXCEEDED", ++ "ERROR_LOG_START_OF_LOG", ++ "ERROR_LOG_POLICY_ALREADY_INSTALLED", ++ "ERROR_LOG_POLICY_NOT_INSTALLED", ++ "ERROR_LOG_POLICY_INVALID", ++ "ERROR_LOG_POLICY_CONFLICT", ++ "ERROR_LOG_PINNED_ARCHIVE_TAIL", ++ "ERROR_LOG_RECORD_NONEXISTENT", ++ "ERROR_LOG_RECORDS_RESERVED_INVALID", ++ "ERROR_LOG_SPACE_RESERVED_INVALID", ++ "ERROR_LOG_TAIL_INVALID", ++ "ERROR_LOG_FULL", ++ "ERROR_COULD_NOT_RESIZE_LOG", ++ "ERROR_LOG_MULTIPLEXED", ++ "ERROR_LOG_DEDICATED", ++ "ERROR_LOG_ARCHIVE_NOT_IN_PROGRESS", ++ "ERROR_LOG_ARCHIVE_IN_PROGRESS", ++ "ERROR_LOG_EPHEMERAL", ++ "ERROR_LOG_NOT_ENOUGH_CONTAINERS", ++ "ERROR_LOG_CLIENT_ALREADY_REGISTERED", ++ "ERROR_LOG_CLIENT_NOT_REGISTERED", ++ "ERROR_LOG_FULL_HANDLER_IN_PROGRESS", ++ "ERROR_LOG_CONTAINER_READ_FAILED", ++ "ERROR_LOG_CONTAINER_WRITE_FAILED", ++ "ERROR_LOG_CONTAINER_OPEN_FAILED", ++ "ERROR_LOG_CONTAINER_STATE_INVALID", ++ "ERROR_LOG_STATE_INVALID", ++ "ERROR_LOG_PINNED", ++ "ERROR_LOG_METADATA_FLUSH_FAILED", ++ "ERROR_LOG_INCONSISTENT_SECURITY", ++ "ERROR_LOG_APPENDED_FLUSH_FAILED", ++ "ERROR_LOG_PINNED_RESERVATION", ++ "ERROR_INVALID_TRANSACTION", ++ "ERROR_TRANSACTION_NOT_ACTIVE", ++ "ERROR_TRANSACTION_REQUEST_NOT_VALID", ++ "ERROR_TRANSACTION_NOT_REQUESTED", ++ "ERROR_TRANSACTION_ALREADY_ABORTED", ++ "ERROR_TRANSACTION_ALREADY_COMMITTED", ++ "ERROR_TM_INITIALIZATION_FAILED", ++ "ERROR_RESOURCEMANAGER_READ_ONLY", ++ "ERROR_TRANSACTION_NOT_JOINED", ++ "ERROR_TRANSACTION_SUPERIOR_EXISTS", ++ "ERROR_CRM_PROTOCOL_ALREADY_EXISTS", ++ "ERROR_TRANSACTION_PROPAGATION_FAILED", ++ "ERROR_CRM_PROTOCOL_NOT_FOUND", ++ "ERROR_TRANSACTION_INVALID_MARSHALL_BUFFER", ++ "ERROR_CURRENT_TRANSACTION_NOT_VALID", ++ "ERROR_TRANSACTION_NOT_FOUND", ++ "ERROR_RESOURCEMANAGER_NOT_FOUND", ++ "ERROR_ENLISTMENT_NOT_FOUND", ++ "ERROR_TRANSACTIONMANAGER_NOT_FOUND", ++ "ERROR_TRANSACTIONMANAGER_NOT_ONLINE", ++ "ERROR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION", ++ "ERROR_TRANSACTION_NOT_ROOT", ++ "ERROR_TRANSACTION_OBJECT_EXPIRED", ++ "ERROR_TRANSACTION_RESPONSE_NOT_ENLISTED", ++ "ERROR_TRANSACTION_RECORD_TOO_LONG", ++ "ERROR_IMPLICIT_TRANSACTION_NOT_SUPPORTED", ++ "ERROR_TRANSACTION_INTEGRITY_VIOLATED", ++ "ERROR_TRANSACTIONMANAGER_IDENTITY_MISMATCH", ++ "ERROR_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT", ++ "ERROR_TRANSACTION_MUST_WRITETHROUGH", ++ "ERROR_TRANSACTION_NO_SUPERIOR", ++ "ERROR_HEURISTIC_DAMAGE_POSSIBLE", ++ "ERROR_TRANSACTIONAL_CONFLICT", ++ "ERROR_RM_NOT_ACTIVE", ++ "ERROR_RM_METADATA_CORRUPT", ++ "ERROR_DIRECTORY_NOT_RM", ++ "ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE", ++ "ERROR_LOG_RESIZE_INVALID_SIZE", ++ "ERROR_OBJECT_NO_LONGER_EXISTS", ++ "ERROR_STREAM_MINIVERSION_NOT_FOUND", ++ "ERROR_STREAM_MINIVERSION_NOT_VALID", ++ "ERROR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION", ++ "ERROR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT", ++ "ERROR_CANT_CREATE_MORE_STREAM_MINIVERSIONS", ++ "ERROR_REMOTE_FILE_VERSION_MISMATCH", ++ "ERROR_HANDLE_NO_LONGER_VALID", ++ "ERROR_NO_TXF_METADATA", ++ "ERROR_LOG_CORRUPTION_DETECTED", ++ "ERROR_CANT_RECOVER_WITH_HANDLE_OPEN", ++ "ERROR_RM_DISCONNECTED", ++ "ERROR_ENLISTMENT_NOT_SUPERIOR", ++ "ERROR_RECOVERY_NOT_NEEDED", ++ "ERROR_RM_ALREADY_STARTED", ++ "ERROR_FILE_IDENTITY_NOT_PERSISTENT", ++ "ERROR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY", ++ "ERROR_CANT_CROSS_RM_BOUNDARY", ++ "ERROR_TXF_DIR_NOT_EMPTY", ++ "ERROR_INDOUBT_TRANSACTIONS_EXIST", ++ "ERROR_TM_VOLATILE", ++ "ERROR_ROLLBACK_TIMER_EXPIRED", ++ "ERROR_TXF_ATTRIBUTE_CORRUPT", ++ "ERROR_EFS_NOT_ALLOWED_IN_TRANSACTION", ++ "ERROR_TRANSACTIONAL_OPEN_NOT_ALLOWED", ++ "ERROR_LOG_GROWTH_FAILED", ++ "ERROR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE", ++ "ERROR_TXF_METADATA_ALREADY_PRESENT", ++ "ERROR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET", ++ "ERROR_TRANSACTION_REQUIRED_PROMOTION", ++ "ERROR_CANNOT_EXECUTE_FILE_IN_TRANSACTION", ++ "ERROR_TRANSACTIONS_NOT_FROZEN", ++ "ERROR_TRANSACTION_FREEZE_IN_PROGRESS", ++ "ERROR_NOT_SNAPSHOT_VOLUME", ++ "ERROR_NO_SAVEPOINT_WITH_OPEN_FILES", ++ "ERROR_DATA_LOST_REPAIR", ++ "ERROR_SPARSE_NOT_ALLOWED_IN_TRANSACTION", ++ "ERROR_TM_IDENTITY_MISMATCH", ++ "ERROR_FLOATED_SECTION", ++ "ERROR_CANNOT_ACCEPT_TRANSACTED_WORK", ++ "ERROR_CANNOT_ABORT_TRANSACTIONS", ++ "ERROR_BAD_CLUSTERS", ++ "ERROR_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION", ++ "ERROR_VOLUME_DIRTY", ++ "ERROR_NO_LINK_TRACKING_IN_TRANSACTION", ++ "ERROR_OPERATION_NOT_SUPPORTED_IN_TRANSACTION", ++ "ERROR_EXPIRED_HANDLE", ++ "ERROR_TRANSACTION_NOT_ENLISTED", ++ "ERROR_CTX_WINSTATION_NAME_INVALID", ++ "ERROR_CTX_INVALID_PD", ++ "ERROR_CTX_PD_NOT_FOUND", ++ "ERROR_CTX_WD_NOT_FOUND", ++ "ERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY", ++ "ERROR_CTX_SERVICE_NAME_COLLISION", ++ "ERROR_CTX_CLOSE_PENDING", ++ "ERROR_CTX_NO_OUTBUF", ++ "ERROR_CTX_MODEM_INF_NOT_FOUND", ++ "ERROR_CTX_INVALID_MODEMNAME", ++ "ERROR_CTX_MODEM_RESPONSE_ERROR", ++ "ERROR_CTX_MODEM_RESPONSE_TIMEOUT", ++ "ERROR_CTX_MODEM_RESPONSE_NO_CARRIER", ++ "ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE", ++ "ERROR_CTX_MODEM_RESPONSE_BUSY", ++ "ERROR_CTX_MODEM_RESPONSE_VOICE", ++ "ERROR_CTX_TD_ERROR", ++ "ERROR_CTX_WINSTATION_NOT_FOUND", ++ "ERROR_CTX_WINSTATION_ALREADY_EXISTS", ++ "ERROR_CTX_WINSTATION_BUSY", ++ "ERROR_CTX_BAD_VIDEO_MODE", ++ "ERROR_CTX_GRAPHICS_INVALID", ++ "ERROR_CTX_LOGON_DISABLED", ++ "ERROR_CTX_NOT_CONSOLE", ++ "ERROR_CTX_CLIENT_QUERY_TIMEOUT", ++ "ERROR_CTX_CONSOLE_DISCONNECT", ++ "ERROR_CTX_CONSOLE_CONNECT", ++ "ERROR_CTX_SHADOW_DENIED", ++ "ERROR_CTX_WINSTATION_ACCESS_DENIED", ++ "ERROR_CTX_INVALID_WD", ++ "ERROR_CTX_SHADOW_INVALID", ++ "ERROR_CTX_SHADOW_DISABLED", ++ "ERROR_CTX_CLIENT_LICENSE_IN_USE", ++ "ERROR_CTX_CLIENT_LICENSE_NOT_SET", ++ "ERROR_CTX_LICENSE_NOT_AVAILABLE", ++ "ERROR_CTX_LICENSE_CLIENT_INVALID", ++ "ERROR_CTX_LICENSE_EXPIRED", ++ "ERROR_CTX_SHADOW_NOT_RUNNING", ++ "ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE", ++ "ERROR_ACTIVATION_COUNT_EXCEEDED", ++ "ERROR_CTX_WINSTATIONS_DISABLED", ++ "ERROR_CTX_ENCRYPTION_LEVEL_REQUIRED", ++ "ERROR_CTX_SESSION_IN_USE", ++ "ERROR_CTX_NO_FORCE_LOGOFF", ++ "ERROR_CTX_ACCOUNT_RESTRICTION", ++ "ERROR_RDP_PROTOCOL_ERROR", ++ "ERROR_CTX_CDM_CONNECT", ++ "ERROR_CTX_CDM_DISCONNECT", ++ "ERROR_CTX_SECURITY_LAYER_ERROR", ++ "ERROR_TS_INCOMPATIBLE_SESSIONS", ++ "ERROR_TS_VIDEO_SUBSYSTEM_ERROR", ++ "ERROR_DS_NOT_INSTALLED", ++ "ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY", ++ "ERROR_DS_NO_ATTRIBUTE_OR_VALUE", ++ "ERROR_DS_INVALID_ATTRIBUTE_SYNTAX", ++ "ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED", ++ "ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS", ++ "ERROR_DS_BUSY", ++ "ERROR_DS_UNAVAILABLE", ++ "ERROR_DS_NO_RIDS_ALLOCATED", ++ "ERROR_DS_NO_MORE_RIDS", ++ "ERROR_DS_INCORRECT_ROLE_OWNER", ++ "ERROR_DS_RIDMGR_INIT_ERROR", ++ "ERROR_DS_OBJ_CLASS_VIOLATION", ++ "ERROR_DS_CANT_ON_NON_LEAF", ++ "ERROR_DS_CANT_ON_RDN", ++ "ERROR_DS_CANT_MOD_OBJ_CLASS", ++ "ERROR_DS_CROSS_DOM_MOVE_ERROR", ++ "ERROR_DS_GC_NOT_AVAILABLE", ++ "ERROR_SHARED_POLICY", ++ "ERROR_POLICY_OBJECT_NOT_FOUND", ++ "ERROR_POLICY_ONLY_IN_DS", ++ "ERROR_PROMOTION_ACTIVE", ++ "ERROR_NO_PROMOTION_ACTIVE", ++ "ERROR_DS_OPERATIONS_ERROR", ++ "ERROR_DS_PROTOCOL_ERROR", ++ "ERROR_DS_TIMELIMIT_EXCEEDED", ++ "ERROR_DS_SIZELIMIT_EXCEEDED", ++ "ERROR_DS_ADMIN_LIMIT_EXCEEDED", ++ "ERROR_DS_COMPARE_FALSE", ++ "ERROR_DS_COMPARE_TRUE", ++ "ERROR_DS_AUTH_METHOD_NOT_SUPPORTED", ++ "ERROR_DS_STRONG_AUTH_REQUIRED", ++ "ERROR_DS_INAPPROPRIATE_AUTH", ++ "ERROR_DS_AUTH_UNKNOWN", ++ "ERROR_DS_REFERRAL", ++ "ERROR_DS_UNAVAILABLE_CRIT_EXTENSION", ++ "ERROR_DS_CONFIDENTIALITY_REQUIRED", ++ "ERROR_DS_INAPPROPRIATE_MATCHING", ++ "ERROR_DS_CONSTRAINT_VIOLATION", ++ "ERROR_DS_NO_SUCH_OBJECT", ++ "ERROR_DS_ALIAS_PROBLEM", ++ "ERROR_DS_INVALID_DN_SYNTAX", ++ "ERROR_DS_IS_LEAF", ++ "ERROR_DS_ALIAS_DEREF_PROBLEM", ++ "ERROR_DS_UNWILLING_TO_PERFORM", ++ "ERROR_DS_LOOP_DETECT", ++ "ERROR_DS_NAMING_VIOLATION", ++ "ERROR_DS_OBJECT_RESULTS_TOO_LARGE", ++ "ERROR_DS_AFFECTS_MULTIPLE_DSAS", ++ "ERROR_DS_SERVER_DOWN", ++ "ERROR_DS_LOCAL_ERROR", ++ "ERROR_DS_ENCODING_ERROR", ++ "ERROR_DS_DECODING_ERROR", ++ "ERROR_DS_FILTER_UNKNOWN", ++ "ERROR_DS_PARAM_ERROR", ++ "ERROR_DS_NOT_SUPPORTED", ++ "ERROR_DS_NO_RESULTS_RETURNED", ++ "ERROR_DS_CONTROL_NOT_FOUND", ++ "ERROR_DS_CLIENT_LOOP", ++ "ERROR_DS_REFERRAL_LIMIT_EXCEEDED", ++ "ERROR_DS_SORT_CONTROL_MISSING", ++ "ERROR_DS_OFFSET_RANGE_ERROR", ++ "ERROR_DS_RIDMGR_DISABLED", ++ "ERROR_DS_ROOT_MUST_BE_NC", ++ "ERROR_DS_ADD_REPLICA_INHIBITED", ++ "ERROR_DS_ATT_NOT_DEF_IN_SCHEMA", ++ "ERROR_DS_MAX_OBJ_SIZE_EXCEEDED", ++ "ERROR_DS_OBJ_STRING_NAME_EXISTS", ++ "ERROR_DS_NO_RDN_DEFINED_IN_SCHEMA", ++ "ERROR_DS_RDN_DOESNT_MATCH_SCHEMA", ++ "ERROR_DS_NO_REQUESTED_ATTS_FOUND", ++ "ERROR_DS_USER_BUFFER_TO_SMALL", ++ "ERROR_DS_ATT_IS_NOT_ON_OBJ", ++ "ERROR_DS_ILLEGAL_MOD_OPERATION", ++ "ERROR_DS_OBJ_TOO_LARGE", ++ "ERROR_DS_BAD_INSTANCE_TYPE", ++ "ERROR_DS_MASTERDSA_REQUIRED", ++ "ERROR_DS_OBJECT_CLASS_REQUIRED", ++ "ERROR_DS_MISSING_REQUIRED_ATT", ++ "ERROR_DS_ATT_NOT_DEF_FOR_CLASS", ++ "ERROR_DS_ATT_ALREADY_EXISTS", ++ "ERROR_DS_CANT_ADD_ATT_VALUES", ++ "ERROR_DS_SINGLE_VALUE_CONSTRAINT", ++ "ERROR_DS_RANGE_CONSTRAINT", ++ "ERROR_DS_ATT_VAL_ALREADY_EXISTS", ++ "ERROR_DS_CANT_REM_MISSING_ATT", ++ "ERROR_DS_CANT_REM_MISSING_ATT_VAL", ++ "ERROR_DS_ROOT_CANT_BE_SUBREF", ++ "ERROR_DS_NO_CHAINING", ++ "ERROR_DS_NO_CHAINED_EVAL", ++ "ERROR_DS_NO_PARENT_OBJECT", ++ "ERROR_DS_PARENT_IS_AN_ALIAS", ++ "ERROR_DS_CANT_MIX_MASTER_AND_REPS", ++ "ERROR_DS_CHILDREN_EXIST", ++ "ERROR_DS_OBJ_NOT_FOUND", ++ "ERROR_DS_ALIASED_OBJ_MISSING", ++ "ERROR_DS_BAD_NAME_SYNTAX", ++ "ERROR_DS_ALIAS_POINTS_TO_ALIAS", ++ "ERROR_DS_CANT_DEREF_ALIAS", ++ "ERROR_DS_OUT_OF_SCOPE", ++ "ERROR_DS_OBJECT_BEING_REMOVED", ++ "ERROR_DS_CANT_DELETE_DSA_OBJ", ++ "ERROR_DS_GENERIC_ERROR", ++ "ERROR_DS_DSA_MUST_BE_INT_MASTER", ++ "ERROR_DS_CLASS_NOT_DSA", ++ "ERROR_DS_INSUFF_ACCESS_RIGHTS", ++ "ERROR_DS_ILLEGAL_SUPERIOR", ++ "ERROR_DS_ATTRIBUTE_OWNED_BY_SAM", ++ "ERROR_DS_NAME_TOO_MANY_PARTS", ++ "ERROR_DS_NAME_TOO_LONG", ++ "ERROR_DS_NAME_VALUE_TOO_LONG", ++ "ERROR_DS_NAME_UNPARSEABLE", ++ "ERROR_DS_NAME_TYPE_UNKNOWN", ++ "ERROR_DS_NOT_AN_OBJECT", ++ "ERROR_DS_SEC_DESC_TOO_SHORT", ++ "ERROR_DS_SEC_DESC_INVALID", ++ "ERROR_DS_NO_DELETED_NAME", ++ "ERROR_DS_SUBREF_MUST_HAVE_PARENT", ++ "ERROR_DS_NCNAME_MUST_BE_NC", ++ "ERROR_DS_CANT_ADD_SYSTEM_ONLY", ++ "ERROR_DS_CLASS_MUST_BE_CONCRETE", ++ "ERROR_DS_INVALID_DMD", ++ "ERROR_DS_OBJ_GUID_EXISTS", ++ "ERROR_DS_NOT_ON_BACKLINK", ++ "ERROR_DS_NO_CROSSREF_FOR_NC", ++ "ERROR_DS_SHUTTING_DOWN", ++ "ERROR_DS_UNKNOWN_OPERATION", ++ "ERROR_DS_INVALID_ROLE_OWNER", ++ "ERROR_DS_COULDNT_CONTACT_FSMO", ++ "ERROR_DS_CROSS_NC_DN_RENAME", ++ "ERROR_DS_CANT_MOD_SYSTEM_ONLY", ++ "ERROR_DS_REPLICATOR_ONLY", ++ "ERROR_DS_OBJ_CLASS_NOT_DEFINED", ++ "ERROR_DS_OBJ_CLASS_NOT_SUBCLASS", ++ "ERROR_DS_NAME_REFERENCE_INVALID", ++ "ERROR_DS_CROSS_REF_EXISTS", ++ "ERROR_DS_CANT_DEL_MASTER_CROSSREF", ++ "ERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD", ++ "ERROR_DS_NOTIFY_FILTER_TOO_COMPLEX", ++ "ERROR_DS_DUP_RDN", ++ "ERROR_DS_DUP_OID", ++ "ERROR_DS_DUP_MAPI_ID", ++ "ERROR_DS_DUP_SCHEMA_ID_GUID", ++ "ERROR_DS_DUP_LDAP_DISPLAY_NAME", ++ "ERROR_DS_SEMANTIC_ATT_TEST", ++ "ERROR_DS_SYNTAX_MISMATCH", ++ "ERROR_DS_EXISTS_IN_MUST_HAVE", ++ "ERROR_DS_EXISTS_IN_MAY_HAVE", ++ "ERROR_DS_NONEXISTENT_MAY_HAVE", ++ "ERROR_DS_NONEXISTENT_MUST_HAVE", ++ "ERROR_DS_AUX_CLS_TEST_FAIL", ++ "ERROR_DS_NONEXISTENT_POSS_SUP", ++ "ERROR_DS_SUB_CLS_TEST_FAIL", ++ "ERROR_DS_BAD_RDN_ATT_ID_SYNTAX", ++ "ERROR_DS_EXISTS_IN_AUX_CLS", ++ "ERROR_DS_EXISTS_IN_SUB_CLS", ++ "ERROR_DS_EXISTS_IN_POSS_SUP", ++ "ERROR_DS_RECALCSCHEMA_FAILED", ++ "ERROR_DS_TREE_DELETE_NOT_FINISHED", ++ "ERROR_DS_CANT_DELETE", ++ "ERROR_DS_ATT_SCHEMA_REQ_ID", ++ "ERROR_DS_BAD_ATT_SCHEMA_SYNTAX", ++ "ERROR_DS_CANT_CACHE_ATT", ++ "ERROR_DS_CANT_CACHE_CLASS", ++ "ERROR_DS_CANT_REMOVE_ATT_CACHE", ++ "ERROR_DS_CANT_REMOVE_CLASS_CACHE", ++ "ERROR_DS_CANT_RETRIEVE_DN", ++ "ERROR_DS_MISSING_SUPREF", ++ "ERROR_DS_CANT_RETRIEVE_INSTANCE", ++ "ERROR_DS_CODE_INCONSISTENCY", ++ "ERROR_DS_DATABASE_ERROR", ++ "ERROR_DS_GOVERNSID_MISSING", ++ "ERROR_DS_MISSING_EXPECTED_ATT", ++ "ERROR_DS_NCNAME_MISSING_CR_REF", ++ "ERROR_DS_SECURITY_CHECKING_ERROR", ++ "ERROR_DS_SCHEMA_NOT_LOADED", ++ "ERROR_DS_SCHEMA_ALLOC_FAILED", ++ "ERROR_DS_ATT_SCHEMA_REQ_SYNTAX", ++ "ERROR_DS_GCVERIFY_ERROR", ++ "ERROR_DS_DRA_SCHEMA_MISMATCH", ++ "ERROR_DS_CANT_FIND_DSA_OBJ", ++ "ERROR_DS_CANT_FIND_EXPECTED_NC", ++ "ERROR_DS_CANT_FIND_NC_IN_CACHE", ++ "ERROR_DS_CANT_RETRIEVE_CHILD", ++ "ERROR_DS_SECURITY_ILLEGAL_MODIFY", ++ "ERROR_DS_CANT_REPLACE_HIDDEN_REC", ++ "ERROR_DS_BAD_HIERARCHY_FILE", ++ "ERROR_DS_BUILD_HIERARCHY_TABLE_FAILED", ++ "ERROR_DS_CONFIG_PARAM_MISSING", ++ "ERROR_DS_COUNTING_AB_INDICES_FAILED", ++ "ERROR_DS_HIERARCHY_TABLE_MALLOC_FAILED", ++ "ERROR_DS_INTERNAL_FAILURE", ++ "ERROR_DS_UNKNOWN_ERROR", ++ "ERROR_DS_ROOT_REQUIRES_CLASS_TOP", ++ "ERROR_DS_REFUSING_FSMO_ROLES", ++ "ERROR_DS_MISSING_FSMO_SETTINGS", ++ "ERROR_DS_UNABLE_TO_SURRENDER_ROLES", ++ "ERROR_DS_DRA_GENERIC", ++ "ERROR_DS_DRA_INVALID_PARAMETER", ++ "ERROR_DS_DRA_BUSY", ++ "ERROR_DS_DRA_BAD_DN", ++ "ERROR_DS_DRA_BAD_NC", ++ "ERROR_DS_DRA_DN_EXISTS", ++ "ERROR_DS_DRA_INTERNAL_ERROR", ++ "ERROR_DS_DRA_INCONSISTENT_DIT", ++ "ERROR_DS_DRA_CONNECTION_FAILED", ++ "ERROR_DS_DRA_BAD_INSTANCE_TYPE", ++ "ERROR_DS_DRA_OUT_OF_MEM", ++ "ERROR_DS_DRA_MAIL_PROBLEM", ++ "ERROR_DS_DRA_REF_ALREADY_EXISTS", ++ "ERROR_DS_DRA_REF_NOT_FOUND", ++ "ERROR_DS_DRA_OBJ_IS_REP_SOURCE", ++ "ERROR_DS_DRA_DB_ERROR", ++ "ERROR_DS_DRA_NO_REPLICA", ++ "ERROR_DS_DRA_ACCESS_DENIED", ++ "ERROR_DS_DRA_NOT_SUPPORTED", ++ "ERROR_DS_DRA_RPC_CANCELLED", ++ "ERROR_DS_DRA_SOURCE_DISABLED", ++ "ERROR_DS_DRA_SINK_DISABLED", ++ "ERROR_DS_DRA_NAME_COLLISION", ++ "ERROR_DS_DRA_SOURCE_REINSTALLED", ++ "ERROR_DS_DRA_MISSING_PARENT", ++ "ERROR_DS_DRA_PREEMPTED", ++ "ERROR_DS_DRA_ABANDON_SYNC", ++ "ERROR_DS_DRA_SHUTDOWN", ++ "ERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SET", ++ "ERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA", ++ "ERROR_DS_DRA_EXTN_CONNECTION_FAILED", ++ "ERROR_DS_INSTALL_SCHEMA_MISMATCH", ++ "ERROR_DS_DUP_LINK_ID", ++ "ERROR_DS_NAME_ERROR_RESOLVING", ++ "ERROR_DS_NAME_ERROR_NOT_FOUND", ++ "ERROR_DS_NAME_ERROR_NOT_UNIQUE", ++ "ERROR_DS_NAME_ERROR_NO_MAPPING", ++ "ERROR_DS_NAME_ERROR_DOMAIN_ONLY", ++ "ERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING", ++ "ERROR_DS_CONSTRUCTED_ATT_MOD", ++ "ERROR_DS_WRONG_OM_OBJ_CLASS", ++ "ERROR_DS_DRA_REPL_PENDING", ++ "ERROR_DS_DS_REQUIRED", ++ "ERROR_DS_INVALID_LDAP_DISPLAY_NAME", ++ "ERROR_DS_NON_BASE_SEARCH", ++ "ERROR_DS_CANT_RETRIEVE_ATTS", ++ "ERROR_DS_BACKLINK_WITHOUT_LINK", ++ "ERROR_DS_EPOCH_MISMATCH", ++ "ERROR_DS_SRC_NAME_MISMATCH", ++ "ERROR_DS_SRC_AND_DST_NC_IDENTICAL", ++ "ERROR_DS_DST_NC_MISMATCH", ++ "ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC", ++ "ERROR_DS_SRC_GUID_MISMATCH", ++ "ERROR_DS_CANT_MOVE_DELETED_OBJECT", ++ "ERROR_DS_PDC_OPERATION_IN_PROGRESS", ++ "ERROR_DS_CROSS_DOMAIN_CLEANUP_REQD", ++ "ERROR_DS_ILLEGAL_XDOM_MOVE_OPERATION", ++ "ERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS", ++ "ERROR_DS_NC_MUST_HAVE_NC_PARENT", ++ "ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE", ++ "ERROR_DS_DST_DOMAIN_NOT_NATIVE", ++ "ERROR_DS_MISSING_INFRASTRUCTURE_CONTAINER", ++ "ERROR_DS_CANT_MOVE_ACCOUNT_GROUP", ++ "ERROR_DS_CANT_MOVE_RESOURCE_GROUP", ++ "ERROR_DS_INVALID_SEARCH_FLAG", ++ "ERROR_DS_NO_TREE_DELETE_ABOVE_NC", ++ "ERROR_DS_COULDNT_LOCK_TREE_FOR_DELETE", ++ "ERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE", ++ "ERROR_DS_SAM_INIT_FAILURE", ++ "ERROR_DS_SENSITIVE_GROUP_VIOLATION", ++ "ERROR_DS_CANT_MOD_PRIMARYGROUPID", ++ "ERROR_DS_ILLEGAL_BASE_SCHEMA_MOD", ++ "ERROR_DS_NONSAFE_SCHEMA_CHANGE", ++ "ERROR_DS_SCHEMA_UPDATE_DISALLOWED", ++ "ERROR_DS_CANT_CREATE_UNDER_SCHEMA", ++ "ERROR_DS_INSTALL_NO_SRC_SCH_VERSION", ++ "ERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE", ++ "ERROR_DS_INVALID_GROUP_TYPE", ++ "ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN", ++ "ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN", ++ "ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER", ++ "ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER", ++ "ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER", ++ "ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER", ++ "ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER", ++ "ERROR_DS_HAVE_PRIMARY_MEMBERS", ++ "ERROR_DS_STRING_SD_CONVERSION_FAILED", ++ "ERROR_DS_NAMING_MASTER_GC", ++ "ERROR_DS_DNS_LOOKUP_FAILURE", ++ "ERROR_DS_COULDNT_UPDATE_SPNS", ++ "ERROR_DS_CANT_RETRIEVE_SD", ++ "ERROR_DS_KEY_NOT_UNIQUE", ++ "ERROR_DS_WRONG_LINKED_ATT_SYNTAX", ++ "ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD", ++ "ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY", ++ "ERROR_DS_CANT_START", ++ "ERROR_DS_INIT_FAILURE", ++ "ERROR_DS_NO_PKT_PRIVACY_ON_CONNECTION", ++ "ERROR_DS_SOURCE_DOMAIN_IN_FOREST", ++ "ERROR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST", ++ "ERROR_DS_DESTINATION_AUDITING_NOT_ENABLED", ++ "ERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN", ++ "ERROR_DS_SRC_OBJ_NOT_GROUP_OR_USER", ++ "ERROR_DS_SRC_SID_EXISTS_IN_FOREST", ++ "ERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH", ++ "ERROR_SAM_INIT_FAILURE", ++ "ERROR_DS_DRA_SCHEMA_INFO_SHIP", ++ "ERROR_DS_DRA_SCHEMA_CONFLICT", ++ "ERROR_DS_DRA_EARLIER_SCHEMA_CONFLICT", ++ "ERROR_DS_DRA_OBJ_NC_MISMATCH", ++ "ERROR_DS_NC_STILL_HAS_DSAS", ++ "ERROR_DS_GC_REQUIRED", ++ "ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY", ++ "ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS", ++ "ERROR_DS_CANT_ADD_TO_GC", ++ "ERROR_DS_NO_CHECKPOINT_WITH_PDC", ++ "ERROR_DS_SOURCE_AUDITING_NOT_ENABLED", ++ "ERROR_DS_CANT_CREATE_IN_NONDOMAIN_NC", ++ "ERROR_DS_INVALID_NAME_FOR_SPN", ++ "ERROR_DS_FILTER_USES_CONTRUCTED_ATTRS", ++ "ERROR_DS_UNICODEPWD_NOT_IN_QUOTES", ++ "ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED", ++ "ERROR_DS_MUST_BE_RUN_ON_DST_DC", ++ "ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER", ++ "ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ", ++ "ERROR_DS_INIT_FAILURE_CONSOLE", ++ "ERROR_DS_SAM_INIT_FAILURE_CONSOLE", ++ "ERROR_DS_FOREST_VERSION_TOO_HIGH", ++ "ERROR_DS_DOMAIN_VERSION_TOO_HIGH", ++ "ERROR_DS_FOREST_VERSION_TOO_LOW", ++ "ERROR_DS_DOMAIN_VERSION_TOO_LOW", ++ "ERROR_DS_INCOMPATIBLE_VERSION", ++ "ERROR_DS_LOW_DSA_VERSION", ++ "ERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN", ++ "ERROR_DS_NOT_SUPPORTED_SORT_ORDER", ++ "ERROR_DS_NAME_NOT_UNIQUE", ++ "ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4", ++ "ERROR_DS_OUT_OF_VERSION_STORE", ++ "ERROR_DS_INCOMPATIBLE_CONTROLS_USED", ++ "ERROR_DS_NO_REF_DOMAIN", ++ "ERROR_DS_RESERVED_LINK_ID", ++ "ERROR_DS_LINK_ID_NOT_AVAILABLE", ++ "ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER", ++ "ERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE", ++ "ERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC", ++ "ERROR_DS_MODIFYDN_DISALLOWED_BY_FLAG", ++ "ERROR_DS_MODIFYDN_WRONG_GRANDPARENT", ++ "ERROR_DS_NAME_ERROR_TRUST_REFERRAL", ++ "ERROR_NOT_SUPPORTED_ON_STANDARD_SERVER", ++ "ERROR_DS_CANT_ACCESS_REMOTE_PART_OF_AD", ++ "ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2", ++ "ERROR_DS_THREAD_LIMIT_EXCEEDED", ++ "ERROR_DS_NOT_CLOSEST", ++ "ERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF", ++ "ERROR_DS_SINGLE_USER_MODE_FAILED", ++ "ERROR_DS_NTDSCRIPT_SYNTAX_ERROR", ++ "ERROR_DS_NTDSCRIPT_PROCESS_ERROR", ++ "ERROR_DS_DIFFERENT_REPL_EPOCHS", ++ "ERROR_DS_DRS_EXTENSIONS_CHANGED", ++ "ERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR", ++ "ERROR_DS_NO_MSDS_INTID", ++ "ERROR_DS_DUP_MSDS_INTID", ++ "ERROR_DS_EXISTS_IN_RDNATTID", ++ "ERROR_DS_AUTHORIZATION_FAILED", ++ "ERROR_DS_INVALID_SCRIPT", ++ "ERROR_DS_REMOTE_CROSSREF_OP_FAILED", ++ "ERROR_DS_CROSS_REF_BUSY", ++ "ERROR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN", ++ "ERROR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC", ++ "ERROR_DS_DUPLICATE_ID_FOUND", ++ "ERROR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT", ++ "ERROR_DS_GROUP_CONVERSION_ERROR", ++ "ERROR_DS_CANT_MOVE_APP_BASIC_GROUP", ++ "ERROR_DS_CANT_MOVE_APP_QUERY_GROUP", ++ "ERROR_DS_ROLE_NOT_VERIFIED", ++ "ERROR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL", ++ "ERROR_DS_DOMAIN_RENAME_IN_PROGRESS", ++ "ERROR_DS_EXISTING_AD_CHILD_NC", ++ "ERROR_DS_REPL_LIFETIME_EXCEEDED", ++ "ERROR_DS_DISALLOWED_IN_SYSTEM_CONTAINER", ++ "ERROR_DS_LDAP_SEND_QUEUE_FULL", ++ "ERROR_DS_DRA_OUT_SCHEDULE_WINDOW", ++ "ERROR_DS_POLICY_NOT_KNOWN", ++ "ERROR_NO_SITE_SETTINGS_OBJECT", ++ "ERROR_NO_SECRETS", ++ "ERROR_NO_WRITABLE_DC_FOUND", ++ "ERROR_DS_NO_SERVER_OBJECT", ++ "ERROR_DS_NO_NTDSA_OBJECT", ++ "ERROR_DS_NON_ASQ_SEARCH", ++ "ERROR_DS_AUDIT_FAILURE", ++ "ERROR_DS_INVALID_SEARCH_FLAG_SUBTREE", ++ "ERROR_DS_INVALID_SEARCH_FLAG_TUPLE", ++ "ERROR_DS_HIERARCHY_TABLE_TOO_DEEP", ++ "ERROR_DS_DRA_CORRUPT_UTD_VECTOR", ++ "ERROR_DS_DRA_SECRETS_DENIED", ++ "ERROR_DS_RESERVED_MAPI_ID", ++ "ERROR_DS_MAPI_ID_NOT_AVAILABLE", ++ "ERROR_DS_DRA_MISSING_KRBTGT_SECRET", ++ "ERROR_DS_DOMAIN_NAME_EXISTS_IN_FOREST", ++ "ERROR_DS_FLAT_NAME_EXISTS_IN_FOREST", ++ "ERROR_INVALID_USER_PRINCIPAL_NAME", ++ "ERROR_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS", ++ "ERROR_DS_OID_NOT_FOUND", ++ "ERROR_DS_DRA_RECYCLED_TARGET", ++ "ERROR_DS_DISALLOWED_NC_REDIRECT", ++ "ERROR_DS_HIGH_ADLDS_FFL", ++ "ERROR_DS_HIGH_DSA_VERSION", ++ "ERROR_DS_LOW_ADLDS_FFL", ++ "ERROR_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATION", ++ "ERROR_DS_UNDELETE_SAM_VALIDATION_FAILED", ++ "ERROR_INCORRECT_ACCOUNT_TYPE", ++ "ERROR_DS_SPN_VALUE_NOT_UNIQUE_IN_FOREST", ++ "ERROR_DS_UPN_VALUE_NOT_UNIQUE_IN_FOREST", ++ "ERROR_DS_MISSING_FOREST_TRUST", ++ "ERROR_DS_VALUE_KEY_NOT_UNIQUE", ++ "ERROR_IPSEC_QM_POLICY_EXISTS", ++ "ERROR_IPSEC_QM_POLICY_NOT_FOUND", ++ "ERROR_IPSEC_QM_POLICY_IN_USE", ++ "ERROR_IPSEC_MM_POLICY_EXISTS", ++ "ERROR_IPSEC_MM_POLICY_NOT_FOUND", ++ "ERROR_IPSEC_MM_POLICY_IN_USE", ++ "ERROR_IPSEC_MM_FILTER_EXISTS", ++ "ERROR_IPSEC_MM_FILTER_NOT_FOUND", ++ "ERROR_IPSEC_TRANSPORT_FILTER_EXISTS", ++ "ERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUND", ++ "ERROR_IPSEC_MM_AUTH_EXISTS", ++ "ERROR_IPSEC_MM_AUTH_NOT_FOUND", ++ "ERROR_IPSEC_MM_AUTH_IN_USE", ++ "ERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND", ++ "ERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND", ++ "ERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND", ++ "ERROR_IPSEC_TUNNEL_FILTER_EXISTS", ++ "ERROR_IPSEC_TUNNEL_FILTER_NOT_FOUND", ++ "ERROR_IPSEC_MM_FILTER_PENDING_DELETION", ++ "ERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETION", ++ "ERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETION", ++ "ERROR_IPSEC_MM_POLICY_PENDING_DELETION", ++ "ERROR_IPSEC_MM_AUTH_PENDING_DELETION", ++ "ERROR_IPSEC_QM_POLICY_PENDING_DELETION", ++ "ERROR_IPSEC_IKE_NEG_STATUS_BEGIN", ++ "ERROR_IPSEC_IKE_AUTH_FAIL", ++ "ERROR_IPSEC_IKE_ATTRIB_FAIL", ++ "ERROR_IPSEC_IKE_NEGOTIATION_PENDING", ++ "ERROR_IPSEC_IKE_GENERAL_PROCESSING_ERROR", ++ "ERROR_IPSEC_IKE_TIMED_OUT", ++ "ERROR_IPSEC_IKE_NO_CERT", ++ "ERROR_IPSEC_IKE_SA_DELETED", ++ "ERROR_IPSEC_IKE_SA_REAPED", ++ "ERROR_IPSEC_IKE_MM_ACQUIRE_DROP", ++ "ERROR_IPSEC_IKE_QM_ACQUIRE_DROP", ++ "ERROR_IPSEC_IKE_QUEUE_DROP_MM", ++ "ERROR_IPSEC_IKE_QUEUE_DROP_NO_MM", ++ "ERROR_IPSEC_IKE_DROP_NO_RESPONSE", ++ "ERROR_IPSEC_IKE_MM_DELAY_DROP", ++ "ERROR_IPSEC_IKE_QM_DELAY_DROP", ++ "ERROR_IPSEC_IKE_ERROR", ++ "ERROR_IPSEC_IKE_CRL_FAILED", ++ "ERROR_IPSEC_IKE_INVALID_KEY_USAGE", ++ "ERROR_IPSEC_IKE_INVALID_CERT_TYPE", ++ "ERROR_IPSEC_IKE_NO_PRIVATE_KEY", ++ "ERROR_IPSEC_IKE_SIMULTANEOUS_REKEY", ++ "ERROR_IPSEC_IKE_DH_FAIL", ++ "ERROR_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZED", ++ "ERROR_IPSEC_IKE_INVALID_HEADER", ++ "ERROR_IPSEC_IKE_NO_POLICY", ++ "ERROR_IPSEC_IKE_INVALID_SIGNATURE", ++ "ERROR_IPSEC_IKE_KERBEROS_ERROR", ++ "ERROR_IPSEC_IKE_NO_PUBLIC_KEY", ++ "ERROR_IPSEC_IKE_PROCESS_ERR", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_SA", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_PROP", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_TRANS", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_KE", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_ID", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_CERT", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQ", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_HASH", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_SIG", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_NONCE", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_NOTIFY", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_DELETE", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_VENDOR", ++ "ERROR_IPSEC_IKE_INVALID_PAYLOAD", ++ "ERROR_IPSEC_IKE_LOAD_SOFT_SA", ++ "ERROR_IPSEC_IKE_SOFT_SA_TORN_DOWN", ++ "ERROR_IPSEC_IKE_INVALID_COOKIE", ++ "ERROR_IPSEC_IKE_NO_PEER_CERT", ++ "ERROR_IPSEC_IKE_PEER_CRL_FAILED", ++ "ERROR_IPSEC_IKE_POLICY_CHANGE", ++ "ERROR_IPSEC_IKE_NO_MM_POLICY", ++ "ERROR_IPSEC_IKE_NOTCBPRIV", ++ "ERROR_IPSEC_IKE_SECLOADFAIL", ++ "ERROR_IPSEC_IKE_FAILSSPINIT", ++ "ERROR_IPSEC_IKE_FAILQUERYSSP", ++ "ERROR_IPSEC_IKE_SRVACQFAIL", ++ "ERROR_IPSEC_IKE_SRVQUERYCRED", ++ "ERROR_IPSEC_IKE_GETSPIFAIL", ++ "ERROR_IPSEC_IKE_INVALID_FILTER", ++ "ERROR_IPSEC_IKE_OUT_OF_MEMORY", ++ "ERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED", ++ "ERROR_IPSEC_IKE_INVALID_POLICY", ++ "ERROR_IPSEC_IKE_UNKNOWN_DOI", ++ "ERROR_IPSEC_IKE_INVALID_SITUATION", ++ "ERROR_IPSEC_IKE_DH_FAILURE", ++ "ERROR_IPSEC_IKE_INVALID_GROUP", ++ "ERROR_IPSEC_IKE_ENCRYPT", ++ "ERROR_IPSEC_IKE_DECRYPT", ++ "ERROR_IPSEC_IKE_POLICY_MATCH", ++ "ERROR_IPSEC_IKE_UNSUPPORTED_ID", ++ "ERROR_IPSEC_IKE_INVALID_HASH", ++ "ERROR_IPSEC_IKE_INVALID_HASH_ALG", ++ "ERROR_IPSEC_IKE_INVALID_HASH_SIZE", ++ "ERROR_IPSEC_IKE_INVALID_ENCRYPT_ALG", ++ "ERROR_IPSEC_IKE_INVALID_AUTH_ALG", ++ "ERROR_IPSEC_IKE_INVALID_SIG", ++ "ERROR_IPSEC_IKE_LOAD_FAILED", ++ "ERROR_IPSEC_IKE_RPC_DELETE", ++ "ERROR_IPSEC_IKE_BENIGN_REINIT", ++ "ERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY", ++ "ERROR_IPSEC_IKE_INVALID_MAJOR_VERSION", ++ "ERROR_IPSEC_IKE_INVALID_CERT_KEYLEN", ++ "ERROR_IPSEC_IKE_MM_LIMIT", ++ "ERROR_IPSEC_IKE_NEGOTIATION_DISABLED", ++ "ERROR_IPSEC_IKE_QM_LIMIT", ++ "ERROR_IPSEC_IKE_MM_EXPIRED", ++ "ERROR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID", ++ "ERROR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH", ++ "ERROR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID", ++ "ERROR_IPSEC_IKE_INVALID_AUTH_PAYLOAD", ++ "ERROR_IPSEC_IKE_DOS_COOKIE_SENT", ++ "ERROR_IPSEC_IKE_SHUTTING_DOWN", ++ "ERROR_IPSEC_IKE_CGA_AUTH_FAILED", ++ "ERROR_IPSEC_IKE_PROCESS_ERR_NATOA", ++ "ERROR_IPSEC_IKE_INVALID_MM_FOR_QM", ++ "ERROR_IPSEC_IKE_QM_EXPIRED", ++ "ERROR_IPSEC_IKE_TOO_MANY_FILTERS", ++ "ERROR_IPSEC_IKE_NEG_STATUS_END", ++ "ERROR_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL", ++ "ERROR_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE", ++ "ERROR_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING", ++ "ERROR_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING", ++ "ERROR_IPSEC_IKE_COEXISTENCE_SUPPRESS", ++ "ERROR_IPSEC_IKE_RATELIMIT_DROP", ++ "ERROR_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE", ++ "ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE", ++ "ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE", ++ "ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY", ++ "ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE", ++ "ERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_END", ++ "ERROR_IPSEC_BAD_SPI", ++ "ERROR_IPSEC_SA_LIFETIME_EXPIRED", ++ "ERROR_IPSEC_WRONG_SA", ++ "ERROR_IPSEC_REPLAY_CHECK_FAILED", ++ "ERROR_IPSEC_INVALID_PACKET", ++ "ERROR_IPSEC_INTEGRITY_CHECK_FAILED", ++ "ERROR_IPSEC_CLEAR_TEXT_DROP", ++ "ERROR_IPSEC_AUTH_FIREWALL_DROP", ++ "ERROR_IPSEC_THROTTLE_DROP", ++ "ERROR_IPSEC_DOSP_BLOCK", ++ "ERROR_IPSEC_DOSP_RECEIVED_MULTICAST", ++ "ERROR_IPSEC_DOSP_INVALID_PACKET", ++ "ERROR_IPSEC_DOSP_STATE_LOOKUP_FAILED", ++ "ERROR_IPSEC_DOSP_MAX_ENTRIES", ++ "ERROR_IPSEC_DOSP_KEYMOD_NOT_ALLOWED", ++ "ERROR_IPSEC_DOSP_NOT_INSTALLED", ++ "ERROR_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES", ++ "ERROR_SXS_SECTION_NOT_FOUND", ++ "ERROR_SXS_CANT_GEN_ACTCTX", ++ "ERROR_SXS_INVALID_ACTCTXDATA_FORMAT", ++ "ERROR_SXS_ASSEMBLY_NOT_FOUND", ++ "ERROR_SXS_MANIFEST_FORMAT_ERROR", ++ "ERROR_SXS_MANIFEST_PARSE_ERROR", ++ "ERROR_SXS_ACTIVATION_CONTEXT_DISABLED", ++ "ERROR_SXS_KEY_NOT_FOUND", ++ "ERROR_SXS_VERSION_CONFLICT", ++ "ERROR_SXS_WRONG_SECTION_TYPE", ++ "ERROR_SXS_THREAD_QUERIES_DISABLED", ++ "ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET", ++ "ERROR_SXS_UNKNOWN_ENCODING_GROUP", ++ "ERROR_SXS_UNKNOWN_ENCODING", ++ "ERROR_SXS_INVALID_XML_NAMESPACE_URI", ++ "ERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED", ++ "ERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED", ++ "ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE", ++ "ERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE", ++ "ERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE", ++ "ERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT", ++ "ERROR_SXS_DUPLICATE_DLL_NAME", ++ "ERROR_SXS_DUPLICATE_WINDOWCLASS_NAME", ++ "ERROR_SXS_DUPLICATE_CLSID", ++ "ERROR_SXS_DUPLICATE_IID", ++ "ERROR_SXS_DUPLICATE_TLBID", ++ "ERROR_SXS_DUPLICATE_PROGID", ++ "ERROR_SXS_DUPLICATE_ASSEMBLY_NAME", ++ "ERROR_SXS_FILE_HASH_MISMATCH", ++ "ERROR_SXS_POLICY_PARSE_ERROR", ++ "ERROR_SXS_XML_E_MISSINGQUOTE", ++ "ERROR_SXS_XML_E_COMMENTSYNTAX", ++ "ERROR_SXS_XML_E_BADSTARTNAMECHAR", ++ "ERROR_SXS_XML_E_BADNAMECHAR", ++ "ERROR_SXS_XML_E_BADCHARINSTRING", ++ "ERROR_SXS_XML_E_XMLDECLSYNTAX", ++ "ERROR_SXS_XML_E_BADCHARDATA", ++ "ERROR_SXS_XML_E_MISSINGWHITESPACE", ++ "ERROR_SXS_XML_E_EXPECTINGTAGEND", ++ "ERROR_SXS_XML_E_MISSINGSEMICOLON", ++ "ERROR_SXS_XML_E_UNBALANCEDPAREN", ++ "ERROR_SXS_XML_E_INTERNALERROR", ++ "ERROR_SXS_XML_E_UNEXPECTED_WHITESPACE", ++ "ERROR_SXS_XML_E_INCOMPLETE_ENCODING", ++ "ERROR_SXS_XML_E_MISSING_PAREN", ++ "ERROR_SXS_XML_E_EXPECTINGCLOSEQUOTE", ++ "ERROR_SXS_XML_E_MULTIPLE_COLONS", ++ "ERROR_SXS_XML_E_INVALID_DECIMAL", ++ "ERROR_SXS_XML_E_INVALID_HEXIDECIMAL", ++ "ERROR_SXS_XML_E_INVALID_UNICODE", ++ "ERROR_SXS_XML_E_WHITESPACEORQUESTIONMARK", ++ "ERROR_SXS_XML_E_UNEXPECTEDENDTAG", ++ "ERROR_SXS_XML_E_UNCLOSEDTAG", ++ "ERROR_SXS_XML_E_DUPLICATEATTRIBUTE", ++ "ERROR_SXS_XML_E_MULTIPLEROOTS", ++ "ERROR_SXS_XML_E_INVALIDATROOTLEVEL", ++ "ERROR_SXS_XML_E_BADXMLDECL", ++ "ERROR_SXS_XML_E_MISSINGROOT", ++ "ERROR_SXS_XML_E_UNEXPECTEDEOF", ++ "ERROR_SXS_XML_E_BADPEREFINSUBSET", ++ "ERROR_SXS_XML_E_UNCLOSEDSTARTTAG", ++ "ERROR_SXS_XML_E_UNCLOSEDENDTAG", ++ "ERROR_SXS_XML_E_UNCLOSEDSTRING", ++ "ERROR_SXS_XML_E_UNCLOSEDCOMMENT", ++ "ERROR_SXS_XML_E_UNCLOSEDDECL", ++ "ERROR_SXS_XML_E_UNCLOSEDCDATA", ++ "ERROR_SXS_XML_E_RESERVEDNAMESPACE", ++ "ERROR_SXS_XML_E_INVALIDENCODING", ++ "ERROR_SXS_XML_E_INVALIDSWITCH", ++ "ERROR_SXS_XML_E_BADXMLCASE", ++ "ERROR_SXS_XML_E_INVALID_STANDALONE", ++ "ERROR_SXS_XML_E_UNEXPECTED_STANDALONE", ++ "ERROR_SXS_XML_E_INVALID_VERSION", ++ "ERROR_SXS_XML_E_MISSINGEQUALS", ++ "ERROR_SXS_PROTECTION_RECOVERY_FAILED", ++ "ERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT", ++ "ERROR_SXS_PROTECTION_CATALOG_NOT_VALID", ++ "ERROR_SXS_UNTRANSLATABLE_HRESULT", ++ "ERROR_SXS_PROTECTION_CATALOG_FILE_MISSING", ++ "ERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE", ++ "ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME", ++ "ERROR_SXS_ASSEMBLY_MISSING", ++ "ERROR_SXS_CORRUPT_ACTIVATION_STACK", ++ "ERROR_SXS_CORRUPTION", ++ "ERROR_SXS_EARLY_DEACTIVATION", ++ "ERROR_SXS_INVALID_DEACTIVATION", ++ "ERROR_SXS_MULTIPLE_DEACTIVATION", ++ "ERROR_SXS_PROCESS_TERMINATION_REQUESTED", ++ "ERROR_SXS_RELEASE_ACTIVATION_CONTEXT", ++ "ERROR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY", ++ "ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE", ++ "ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME", ++ "ERROR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE", ++ "ERROR_SXS_IDENTITY_PARSE_ERROR", ++ "ERROR_MALFORMED_SUBSTITUTION_STRING", ++ "ERROR_SXS_INCORRECT_PUBLIC_KEY_TOKEN", ++ "ERROR_UNMAPPED_SUBSTITUTION_STRING", ++ "ERROR_SXS_ASSEMBLY_NOT_LOCKED", ++ "ERROR_SXS_COMPONENT_STORE_CORRUPT", ++ "ERROR_ADVANCED_INSTALLER_FAILED", ++ "ERROR_XML_ENCODING_MISMATCH", ++ "ERROR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT", ++ "ERROR_SXS_IDENTITIES_DIFFERENT", ++ "ERROR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT", ++ "ERROR_SXS_FILE_NOT_PART_OF_ASSEMBLY", ++ "ERROR_SXS_MANIFEST_TOO_BIG", ++ "ERROR_SXS_SETTING_NOT_REGISTERED", ++ "ERROR_SXS_TRANSACTION_CLOSURE_INCOMPLETE", ++ "ERROR_SMI_PRIMITIVE_INSTALLER_FAILED", ++ "ERROR_GENERIC_COMMAND_FAILED", ++ "ERROR_SXS_FILE_HASH_MISSING", ++ "ERROR_SXS_DUPLICATE_ACTIVATABLE_CLASS", ++ "ERROR_EVT_INVALID_CHANNEL_PATH", ++ "ERROR_EVT_INVALID_QUERY", ++ "ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND", ++ "ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND", ++ "ERROR_EVT_INVALID_PUBLISHER_NAME", ++ "ERROR_EVT_INVALID_EVENT_DATA", ++ "ERROR_EVT_CHANNEL_NOT_FOUND", ++ "ERROR_EVT_MALFORMED_XML_TEXT", ++ "ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL", ++ "ERROR_EVT_CONFIGURATION_ERROR", ++ "ERROR_EVT_QUERY_RESULT_STALE", ++ "ERROR_EVT_QUERY_RESULT_INVALID_POSITION", ++ "ERROR_EVT_NON_VALIDATING_MSXML", ++ "ERROR_EVT_FILTER_ALREADYSCOPED", ++ "ERROR_EVT_FILTER_NOTELTSET", ++ "ERROR_EVT_FILTER_INVARG", ++ "ERROR_EVT_FILTER_INVTEST", ++ "ERROR_EVT_FILTER_INVTYPE", ++ "ERROR_EVT_FILTER_PARSEERR", ++ "ERROR_EVT_FILTER_UNSUPPORTEDOP", ++ "ERROR_EVT_FILTER_UNEXPECTEDTOKEN", ++ "ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL", ++ "ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE", ++ "ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE", ++ "ERROR_EVT_CHANNEL_CANNOT_ACTIVATE", ++ "ERROR_EVT_FILTER_TOO_COMPLEX", ++ "ERROR_EVT_MESSAGE_NOT_FOUND", ++ "ERROR_EVT_MESSAGE_ID_NOT_FOUND", ++ "ERROR_EVT_UNRESOLVED_VALUE_INSERT", ++ "ERROR_EVT_UNRESOLVED_PARAMETER_INSERT", ++ "ERROR_EVT_MAX_INSERTS_REACHED", ++ "ERROR_EVT_EVENT_DEFINITION_NOT_FOUND", ++ "ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND", ++ "ERROR_EVT_VERSION_TOO_OLD", ++ "ERROR_EVT_VERSION_TOO_NEW", ++ "ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY", ++ "ERROR_EVT_PUBLISHER_DISABLED", ++ "ERROR_EVT_FILTER_OUT_OF_RANGE", ++ "ERROR_EC_SUBSCRIPTION_CANNOT_ACTIVATE", ++ "ERROR_EC_LOG_DISABLED", ++ "ERROR_EC_CIRCULAR_FORWARDING", ++ "ERROR_EC_CREDSTORE_FULL", ++ "ERROR_EC_CRED_NOT_FOUND", ++ "ERROR_EC_NO_ACTIVE_CHANNEL", ++ "ERROR_MUI_FILE_NOT_FOUND", ++ "ERROR_MUI_INVALID_FILE", ++ "ERROR_MUI_INVALID_RC_CONFIG", ++ "ERROR_MUI_INVALID_LOCALE_NAME", ++ "ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME", ++ "ERROR_MUI_FILE_NOT_LOADED", ++ "ERROR_RESOURCE_ENUM_USER_STOP", ++ "ERROR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED", ++ "ERROR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME", ++ "ERROR_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE", ++ "ERROR_MRM_INVALID_PRICONFIG", ++ "ERROR_MRM_INVALID_FILE_TYPE", ++ "ERROR_MRM_UNKNOWN_QUALIFIER", ++ "ERROR_MRM_INVALID_QUALIFIER_VALUE", ++ "ERROR_MRM_NO_CANDIDATE", ++ "ERROR_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE", ++ "ERROR_MRM_RESOURCE_TYPE_MISMATCH", ++ "ERROR_MRM_DUPLICATE_MAP_NAME", ++ "ERROR_MRM_DUPLICATE_ENTRY", ++ "ERROR_MRM_INVALID_RESOURCE_IDENTIFIER", ++ "ERROR_MRM_FILEPATH_TOO_LONG", ++ "ERROR_MRM_UNSUPPORTED_DIRECTORY_TYPE", ++ "ERROR_MRM_INVALID_PRI_FILE", ++ "ERROR_MRM_NAMED_RESOURCE_NOT_FOUND", ++ "ERROR_MRM_MAP_NOT_FOUND", ++ "ERROR_MRM_UNSUPPORTED_PROFILE_TYPE", ++ "ERROR_MRM_INVALID_QUALIFIER_OPERATOR", ++ "ERROR_MRM_INDETERMINATE_QUALIFIER_VALUE", ++ "ERROR_MRM_AUTOMERGE_ENABLED", ++ "ERROR_MRM_TOO_MANY_RESOURCES", ++ "ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGE", ++ "ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILE", ++ "ERROR_MRM_NO_CURRENT_VIEW_ON_THREAD", ++ "ERROR_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXIST", ++ "ERROR_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENT", ++ "ERROR_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCE", ++ "ERROR_MRM_GENERATION_COUNT_MISMATCH", ++ "ERROR_PRI_MERGE_VERSION_MISMATCH", ++ "ERROR_PRI_MERGE_MISSING_SCHEMA", ++ "ERROR_PRI_MERGE_LOAD_FILE_FAILED", ++ "ERROR_PRI_MERGE_ADD_FILE_FAILED", ++ "ERROR_PRI_MERGE_WRITE_FILE_FAILED", ++ "ERROR_PRI_MERGE_MULTIPLE_PACKAGE_FAMILIES_NOT_ALLOWED", ++ "ERROR_PRI_MERGE_MULTIPLE_MAIN_PACKAGES_NOT_ALLOWED", ++ "ERROR_PRI_MERGE_BUNDLE_PACKAGES_NOT_ALLOWED", ++ "ERROR_PRI_MERGE_MAIN_PACKAGE_REQUIRED", ++ "ERROR_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED", ++ "ERROR_PRI_MERGE_INVALID_FILE_NAME", ++ "ERROR_MRM_PACKAGE_NOT_FOUND", ++ "ERROR_MRM_MISSING_DEFAULT_LANGUAGE", ++ "ERROR_MCA_INVALID_CAPABILITIES_STRING", ++ "ERROR_MCA_INVALID_VCP_VERSION", ++ "ERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION", ++ "ERROR_MCA_MCCS_VERSION_MISMATCH", ++ "ERROR_MCA_UNSUPPORTED_MCCS_VERSION", ++ "ERROR_MCA_INTERNAL_ERROR", ++ "ERROR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED", ++ "ERROR_MCA_UNSUPPORTED_COLOR_TEMPERATURE", ++ "ERROR_AMBIGUOUS_SYSTEM_DEVICE", ++ "ERROR_SYSTEM_DEVICE_NOT_FOUND", ++ "ERROR_HASH_NOT_SUPPORTED", ++ "ERROR_HASH_NOT_PRESENT", ++ "ERROR_SECONDARY_IC_PROVIDER_NOT_REGISTERED", ++ "ERROR_GPIO_CLIENT_INFORMATION_INVALID", ++ "ERROR_GPIO_VERSION_NOT_SUPPORTED", ++ "ERROR_GPIO_INVALID_REGISTRATION_PACKET", ++ "ERROR_GPIO_OPERATION_DENIED", ++ "ERROR_GPIO_INCOMPATIBLE_CONNECT_MODE", ++ "ERROR_GPIO_INTERRUPT_ALREADY_UNMASKED", ++ "ERROR_CANNOT_SWITCH_RUNLEVEL", ++ "ERROR_INVALID_RUNLEVEL_SETTING", ++ "ERROR_RUNLEVEL_SWITCH_TIMEOUT", ++ "ERROR_RUNLEVEL_SWITCH_AGENT_TIMEOUT", ++ "ERROR_RUNLEVEL_SWITCH_IN_PROGRESS", ++ "ERROR_SERVICES_FAILED_AUTOSTART", ++ "ERROR_COM_TASK_STOP_PENDING", ++ "ERROR_INSTALL_OPEN_PACKAGE_FAILED", ++ "ERROR_INSTALL_PACKAGE_NOT_FOUND", ++ "ERROR_INSTALL_INVALID_PACKAGE", ++ "ERROR_INSTALL_RESOLVE_DEPENDENCY_FAILED", ++ "ERROR_INSTALL_OUT_OF_DISK_SPACE", ++ "ERROR_INSTALL_NETWORK_FAILURE", ++ "ERROR_INSTALL_REGISTRATION_FAILURE", ++ "ERROR_INSTALL_DEREGISTRATION_FAILURE", ++ "ERROR_INSTALL_CANCEL", ++ "ERROR_INSTALL_FAILED", ++ "ERROR_REMOVE_FAILED", ++ "ERROR_PACKAGE_ALREADY_EXISTS", ++ "ERROR_NEEDS_REMEDIATION", ++ "ERROR_INSTALL_PREREQUISITE_FAILED", ++ "ERROR_PACKAGE_REPOSITORY_CORRUPTED", ++ "ERROR_INSTALL_POLICY_FAILURE", ++ "ERROR_PACKAGE_UPDATING", ++ "ERROR_DEPLOYMENT_BLOCKED_BY_POLICY", ++ "ERROR_PACKAGES_IN_USE", ++ "ERROR_RECOVERY_FILE_CORRUPT", ++ "ERROR_INVALID_STAGED_SIGNATURE", ++ "ERROR_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED", ++ "ERROR_INSTALL_PACKAGE_DOWNGRADE", ++ "ERROR_SYSTEM_NEEDS_REMEDIATION", ++ "ERROR_APPX_INTEGRITY_FAILURE_CLR_NGEN", ++ "ERROR_RESILIENCY_FILE_CORRUPT", ++ "ERROR_INSTALL_FIREWALL_SERVICE_NOT_RUNNING", ++ "ERROR_PACKAGE_MOVE_FAILED", ++ "ERROR_INSTALL_VOLUME_NOT_EMPTY", ++ "ERROR_INSTALL_VOLUME_OFFLINE", ++ "ERROR_INSTALL_VOLUME_CORRUPT", ++ "ERROR_NEEDS_REGISTRATION", ++ "ERROR_INSTALL_WRONG_PROCESSOR_ARCHITECTURE", ++ "ERROR_DEV_SIDELOAD_LIMIT_EXCEEDED", ++ "ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE", ++ "ERROR_PACKAGE_NOT_SUPPORTED_ON_FILESYSTEM", ++ "ERROR_PACKAGE_MOVE_BLOCKED_BY_STREAMING", ++ "ERROR_INSTALL_OPTIONAL_PACKAGE_APPLICATIONID_NOT_UNIQUE", ++ "ERROR_PACKAGE_STAGING_ONHOLD", ++ "ERROR_INSTALL_INVALID_RELATED_SET_UPDATE", ++ "ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY", ++ "ERROR_DEPLOYMENT_BLOCKED_BY_USER_LOG_OFF", ++ "ERROR_PROVISION_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_PROVISIONED", ++ "ERROR_PACKAGES_REPUTATION_CHECK_FAILED", ++ "ERROR_PACKAGES_REPUTATION_CHECK_TIMEDOUT", ++ "ERROR_DEPLOYMENT_OPTION_NOT_SUPPORTED", ++ "ERROR_APPINSTALLER_ACTIVATION_BLOCKED", ++ "ERROR_REGISTRATION_FROM_REMOTE_DRIVE_NOT_SUPPORTED", ++ "ERROR_APPX_RAW_DATA_WRITE_FAILED", ++ "ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_PACKAGE", ++ "ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_MACHINE", ++ "ERROR_DEPLOYMENT_BLOCKED_BY_PROFILE_POLICY", ++ "ERROR_DEPLOYMENT_FAILED_CONFLICTING_MUTABLE_PACKAGE_DIRECTORY", ++ "ERROR_SINGLETON_RESOURCE_INSTALLED_IN_ACTIVE_USER", ++ "ERROR_DIFFERENT_VERSION_OF_PACKAGED_SERVICE_INSTALLED", ++ "ERROR_SERVICE_EXISTS_AS_NON_PACKAGED_SERVICE", ++ "ERROR_PACKAGED_SERVICE_REQUIRES_ADMIN_PRIVILEGES", ++ "ERROR_REDIRECTION_TO_DEFAULT_ACCOUNT_NOT_ALLOWED", ++ "ERROR_PACKAGE_LACKS_CAPABILITY_TO_DEPLOY_ON_HOST", ++ "ERROR_UNSIGNED_PACKAGE_INVALID_CONTENT", ++ "ERROR_UNSIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE", ++ "ERROR_SIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE", ++ "ERROR_PACKAGE_EXTERNAL_LOCATION_NOT_ALLOWED", ++ "ERROR_INSTALL_FULLTRUST_HOSTRUNTIME_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY", ++ "ERROR_STATE_LOAD_STORE_FAILED", ++ "ERROR_STATE_GET_VERSION_FAILED", ++ "ERROR_STATE_SET_VERSION_FAILED", ++ "ERROR_STATE_STRUCTURED_RESET_FAILED", ++ "ERROR_STATE_OPEN_CONTAINER_FAILED", ++ "ERROR_STATE_CREATE_CONTAINER_FAILED", ++ "ERROR_STATE_DELETE_CONTAINER_FAILED", ++ "ERROR_STATE_READ_SETTING_FAILED", ++ "ERROR_STATE_WRITE_SETTING_FAILED", ++ "ERROR_STATE_DELETE_SETTING_FAILED", ++ "ERROR_STATE_QUERY_SETTING_FAILED", ++ "ERROR_STATE_READ_COMPOSITE_SETTING_FAILED", ++ "ERROR_STATE_WRITE_COMPOSITE_SETTING_FAILED", ++ "ERROR_STATE_ENUMERATE_CONTAINER_FAILED", ++ "ERROR_STATE_ENUMERATE_SETTINGS_FAILED", ++ "ERROR_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED", ++ "ERROR_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED", ++ "ERROR_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED", ++ "ERROR_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED", ++ "ERROR_API_UNAVAILABLE", ++}; ++ ++const char* WinErrorToString(uint16_t error) { ++ auto itr = std::find(std::begin(kWinErrorValues), ++ std::end(kWinErrorValues), ++ error); ++ if (itr == std::end(kWinErrorValues)) { ++ return nullptr; ++ } ++ ++ return kWinErrorStrings[itr - std::begin(kWinErrorValues)]; + } + + } // namespace google_breakpad +diff --git a/src/processor/symbolic_constants_win.h b/src/processor/symbolic_constants_win.h +--- a/src/processor/symbolic_constants_win.h ++++ b/src/processor/symbolic_constants_win.h +@@ -31,24 +31,31 @@ + // + // Provides a means to convert NTSTATUS codes to strings. + // + // Author: Ben Wagner + + #ifndef GOOGLE_BREAKPAD_PROCESSOR_SYMBOLIC_CONSTANTS_WIN_H_ + #define GOOGLE_BREAKPAD_PROCESSOR_SYMBOLIC_CONSTANTS_WIN_H_ + ++#include <stdint.h> + #include <string> + + #include "common/using_std_string.h" + #include "google_breakpad/common/breakpad_types.h" + + namespace google_breakpad { + +-/* Converts a NTSTATUS code to a reason string. */ +-string NTStatusToString(uint32_t ntstatus); ++/* Converts an NTSTATUS code to its string representation. Returns nullptr if ++ * no entry corresponds to the code. */ ++const char* NTStatusToString(uint32_t ntstatus); + +-/* Converts a FAST_FAIL code to a reason string. */ +-string FastFailToString(uint32_t fast_fail_code); ++/* Converts a FAST_FAIL code to its string representation. Returns nullptr if ++ * no entry corresponds to the code. */ ++const char* FastFailToString(uint32_t fast_fail_code); ++ ++/* Converts an ERROR code to its string representation. Returns nullptr if ++ * no entry corresponds to the code. */ ++const char* WinErrorToString(uint16_t error); + + } // namespace google_breakpad + + #endif // GOOGLE_BREAKPAD_PROCESSOR_SYMBOLIC_CONSTANTS_WIN_H_ diff --git a/toolkit/crashreporter/breakpad-patches/23-si-user-si-kernel-siginfo.patch b/toolkit/crashreporter/breakpad-patches/23-si-user-si-kernel-siginfo.patch new file mode 100644 index 0000000000..9e779f7dd8 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/23-si-user-si-kernel-siginfo.patch @@ -0,0 +1,76 @@ +diff --git a/src/google_breakpad/common/minidump_exception_linux.h b/src/google_breakpad/common/minidump_exception_linux.h +--- a/src/google_breakpad/common/minidump_exception_linux.h ++++ b/src/google_breakpad/common/minidump_exception_linux.h +@@ -83,16 +83,20 @@ typedef enum { + MD_EXCEPTION_CODE_LIN_DUMP_REQUESTED = 0xFFFFFFFF /* No exception, + dump requested. */ + } MDExceptionCodeLinux; + + /* For (MDException).exception_flags. These values come from + * asm-generic/siginfo.h. + */ + typedef enum { ++ /* Generic */ ++ MD_EXCEPTION_FLAG_LIN_SI_USER = 0, ++ MD_EXCEPTION_FLAG_LIN_SI_KERNEL = 0x80, ++ + /* SIGILL */ + MD_EXCEPTION_FLAG_LIN_ILL_ILLOPC = 1, + MD_EXCEPTION_FLAG_LIN_ILL_ILLOPN = 2, + MD_EXCEPTION_FLAG_LIN_ILL_ILLADR = 3, + MD_EXCEPTION_FLAG_LIN_ILL_ILLTRP = 4, + MD_EXCEPTION_FLAG_LIN_ILL_PRVOPC = 5, + MD_EXCEPTION_FLAG_LIN_ILL_PRVREG = 6, + MD_EXCEPTION_FLAG_LIN_ILL_COPROC = 7, +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1401,16 +1401,22 @@ string MinidumpProcessor::GetCrashReason + reason = "SIGTRAP"; + break; + case MD_EXCEPTION_CODE_LIN_SIGABRT: + reason = "SIGABRT"; + break; + case MD_EXCEPTION_CODE_LIN_SIGBUS: + reason = "SIGBUS / "; + switch (exception_flags) { ++ case MD_EXCEPTION_FLAG_LIN_SI_USER: ++ reason.append("SI_USER"); ++ break; ++ case MD_EXCEPTION_FLAG_LIN_SI_KERNEL: ++ reason.append("SI_KERNEL"); ++ break; + case MD_EXCEPTION_FLAG_LIN_BUS_ADRALN: + reason.append("BUS_ADRALN"); + break; + case MD_EXCEPTION_FLAG_LIN_BUS_ADRERR: + reason.append("BUS_ADRERR"); + break; + case MD_EXCEPTION_FLAG_LIN_BUS_OBJERR: + reason.append("BUS_OBJERR"); +@@ -1462,18 +1468,24 @@ string MinidumpProcessor::GetCrashReason + break; + case MD_EXCEPTION_CODE_LIN_SIGKILL: + reason = "SIGKILL"; + break; + case MD_EXCEPTION_CODE_LIN_SIGUSR1: + reason = "SIGUSR1"; + break; + case MD_EXCEPTION_CODE_LIN_SIGSEGV: +- reason = "SIGSEGV /"; ++ reason = "SIGSEGV / "; + switch (exception_flags) { ++ case MD_EXCEPTION_FLAG_LIN_SI_USER: ++ reason.append("SI_USER"); ++ break; ++ case MD_EXCEPTION_FLAG_LIN_SI_KERNEL: ++ reason.append("SI_KERNEL"); ++ break; + case MD_EXCEPTION_FLAG_LIN_SEGV_MAPERR: + reason.append("SEGV_MAPERR"); + break; + case MD_EXCEPTION_FLAG_LIN_SEGV_ACCERR: + reason.append("SEGV_ACCERR"); + break; + case MD_EXCEPTION_FLAG_LIN_SEGV_BNDERR: + reason.append("SEGV_BNDERR"); diff --git a/toolkit/crashreporter/breakpad-patches/24-macos-exc-resource.patch b/toolkit/crashreporter/breakpad-patches/24-macos-exc-resource.patch new file mode 100644 index 0000000000..29cf116048 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/24-macos-exc-resource.patch @@ -0,0 +1,155 @@ +diff --git a/src/google_breakpad/common/minidump_exception_mac.h b/src/google_breakpad/common/minidump_exception_mac.h +--- a/src/google_breakpad/common/minidump_exception_mac.h ++++ b/src/google_breakpad/common/minidump_exception_mac.h +@@ -62,16 +62,18 @@ typedef enum { + MD_EXCEPTION_MAC_BREAKPOINT = 6, /* code is CPU-specific */ + /* EXC_BREAKPOINT */ + MD_EXCEPTION_MAC_SYSCALL = 7, + /* EXC_SYSCALL */ + MD_EXCEPTION_MAC_MACH_SYSCALL = 8, + /* EXC_MACH_SYSCALL */ + MD_EXCEPTION_MAC_RPC_ALERT = 9, + /* EXC_RPC_ALERT */ ++ MD_EXCEPTION_MAC_RESOURCE = 11, ++ /* EXC_RESOURCE */ + MD_EXCEPTION_MAC_SIMULATED = 0x43507378 + /* Fake exception code used by Crashpad's SimulateCrash ('CPsx'). */ + } MDExceptionMac; + + /* For (MDException).exception_flags. Breakpad minidump extension for Mac OS X + * support. Based on Darwin/Mac OS X' mach/ppc/exception.h and + * mach/i386/exception.h. This is what Mac OS X calls a "code". */ + typedef enum { +@@ -201,9 +203,42 @@ typedef enum { + /* EXC_I386_PGFLT = 14: should not occur in user space */ + /* EXC_I386_EXTERRFLT = 16: mapped to EXC_ARITHMETIC/EXC_I386_EXTERR */ + MD_EXCEPTION_CODE_MAC_X86_ALIGNMENT_FAULT = 17 + /* EXC_ALIGNFLT (for vector operations) */ + /* EXC_I386_ENOEXTFLT = 32: should be handled by the kernel */ + /* EXC_I386_ENDPERR = 33: should not occur */ + } MDExceptionCodeMac; + ++// The following definitions were taken from Darwin/XNU kernel sources. ++// See https://github.com/apple/darwin-xnu/blob/main/osfmk/kern/exc_resource.h ++ ++typedef enum MDMacExcResourceType { ++ MD_MAC_EXC_RESOURCE_TYPE_CPU = 1, ++ MD_MAC_EXC_RESOURCE_TYPE_WAKEUPS = 2, ++ MD_MAC_EXC_RESOURCE_TYPE_MEMORY = 3, ++ MD_MAC_EXC_RESOURCE_TYPE_IO = 4, ++ MD_MAC_EXC_RESOURCE_TYPE_THREADS = 5 ++} MDMacExcResourceType; ++ ++typedef enum MDMacExcResourceFlavorCpu { ++ MD_MAC_EXC_RESOURCE_FLAVOR_CPU_MONITOR = 1, ++ MD_MAC_EXC_RESOURCE_FLAVOR_CPU_MONITOR_FATAL = 2 ++} MDMacExcResourceFlavorCpu; ++ ++typedef enum MDMacExcResourceFlavorWakeup { ++ MD_MAC_EXC_RESOURCE_FLAVOR_WAKEUPS_MONITOR = 1, ++} MDMacExcResourceFlavorWakeup; ++ ++typedef enum MDMacExcResourceFlavorMemory { ++ MD_MAC_EXC_RESOURCE_FLAVOR_HIGH_WATERMARK = 1, ++} MDMacExcResourceFlavorMemory; ++ ++typedef enum MDMacExcResourceIOFlavor { ++ MD_MAC_EXC_RESOURCE_FLAVOR_IO_PHYSICAL_WRITES = 1, ++ MD_MAC_EXC_RESOURCE_FLAVOR_IO_LOGICAL_WRITES = 2, ++} MDMacExcResourceIOFlavor; ++ ++typedef enum MDMacExcResourceThreadsFlavor { ++ MD_MAC_EXC_RESOURCE_FLAVOR_THREADS_HIGH_WATERMARK = 1, ++} MDMacExcResourceThreadsFlavor; ++ + #endif /* GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_MAC_OSX_H__ */ +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1143,16 +1143,86 @@ string MinidumpProcessor::GetCrashReason + case MD_EXCEPTION_MAC_MACH_SYSCALL: + reason = "EXC_MACH_SYSCALL / "; + reason.append(flags_string); + break; + case MD_EXCEPTION_MAC_RPC_ALERT: + reason = "EXC_RPC_ALERT / "; + reason.append(flags_string); + break; ++ case MD_EXCEPTION_MAC_RESOURCE: ++ reason = "EXC_RESOURCE / "; ++ { ++ uint32_t type = (exception_flags >> 29) & 0x7ULL; ++ uint32_t flavor = (exception_flags >> 26) & 0x7ULL; ++ char flavor_string[6] = {}; ++ switch (type) { ++ case MD_MAC_EXC_RESOURCE_TYPE_CPU: ++ reason.append("RESOURCE_TYPE_CPU / "); ++ switch (flavor) { ++ case MD_MAC_EXC_RESOURCE_FLAVOR_CPU_MONITOR: ++ reason.append("FLAVOR_CPU_MONITOR"); ++ break; ++ case MD_MAC_EXC_RESOURCE_FLAVOR_CPU_MONITOR_FATAL: ++ reason.append("FLAVOR_CPU_MONITOR_FATAL"); ++ break; ++ default: ++ snprintf(flavor_string, sizeof(flavor_string), "%#3x", flavor); ++ reason.append(flavor_string); ++ break; ++ } ++ break; ++ case MD_MAC_EXC_RESOURCE_TYPE_WAKEUPS: ++ reason.append("RESOURCE_TYPE_WAKEUPS / "); ++ if (flavor == MD_MAC_EXC_RESOURCE_FLAVOR_WAKEUPS_MONITOR) { ++ reason.append("FLAVOR_WAKEUPS_MONITOR"); ++ } else { ++ snprintf(flavor_string, sizeof(flavor_string), "%#3x", flavor); ++ reason.append(flavor_string); ++ } ++ break; ++ case MD_MAC_EXC_RESOURCE_TYPE_MEMORY: ++ reason.append("RESOURCE_TYPE_MEMORY / "); ++ if (flavor == MD_MAC_EXC_RESOURCE_FLAVOR_HIGH_WATERMARK) { ++ reason.append("FLAVOR_HIGH_WATERMARK"); ++ } else { ++ snprintf(flavor_string, sizeof(flavor_string), "%#3x", flavor); ++ reason.append(flavor_string); ++ } ++ break; ++ case MD_MAC_EXC_RESOURCE_TYPE_IO: ++ reason.append("EXC_RESOURCE_TYPE_IO / "); ++ switch (flavor) { ++ case MD_MAC_EXC_RESOURCE_FLAVOR_IO_PHYSICAL_WRITES: ++ reason.append("FLAVOR_IO_PHYSICAL_WRITES"); ++ break; ++ case MD_MAC_EXC_RESOURCE_FLAVOR_IO_LOGICAL_WRITES: ++ reason.append("FLAVOR_IO_LOGICAL_WRITES"); ++ break; ++ default: ++ snprintf(flavor_string, sizeof(flavor_string), "%#3x", flavor); ++ reason.append(flavor_string); ++ break; ++ } ++ break; ++ case MD_MAC_EXC_RESOURCE_TYPE_THREADS: ++ reason.append("EXC_RESOURCE_TYPE_THREADS / "); ++ if (flavor == MD_MAC_EXC_RESOURCE_FLAVOR_THREADS_HIGH_WATERMARK) { ++ reason.append("FLAVOR_THREADS_HIGH_WATERMARK"); ++ } else { ++ snprintf(flavor_string, sizeof(flavor_string), "%#3x", flavor); ++ reason.append(flavor_string); ++ } ++ break; ++ default: ++ reason.append(flags_string); ++ break; ++ } ++ } ++ break; + case MD_EXCEPTION_MAC_SIMULATED: + reason = "Simulated Exception"; + break; + } + break; + } + + case MD_OS_WIN32_NT: diff --git a/toolkit/crashreporter/breakpad-patches/25-macos-exc-guard.patch b/toolkit/crashreporter/breakpad-patches/25-macos-exc-guard.patch new file mode 100644 index 0000000000..512c8d8ebd --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/25-macos-exc-guard.patch @@ -0,0 +1,349 @@ +diff --git a/src/google_breakpad/common/minidump_exception_mac.h b/src/google_breakpad/common/minidump_exception_mac.h +--- a/src/google_breakpad/common/minidump_exception_mac.h ++++ b/src/google_breakpad/common/minidump_exception_mac.h +@@ -64,16 +64,18 @@ typedef enum { + MD_EXCEPTION_MAC_SYSCALL = 7, + /* EXC_SYSCALL */ + MD_EXCEPTION_MAC_MACH_SYSCALL = 8, + /* EXC_MACH_SYSCALL */ + MD_EXCEPTION_MAC_RPC_ALERT = 9, + /* EXC_RPC_ALERT */ + MD_EXCEPTION_MAC_RESOURCE = 11, + /* EXC_RESOURCE */ ++ MD_EXCEPTION_MAC_GUARD = 12, ++ /* EXC_GUARD */ + MD_EXCEPTION_MAC_SIMULATED = 0x43507378 + /* Fake exception code used by Crashpad's SimulateCrash ('CPsx'). */ + } MDExceptionMac; + + /* For (MDException).exception_flags. Breakpad minidump extension for Mac OS X + * support. Based on Darwin/Mac OS X' mach/ppc/exception.h and + * mach/i386/exception.h. This is what Mac OS X calls a "code". */ + typedef enum { +@@ -236,9 +238,77 @@ typedef enum MDMacExcResourceIOFlavor { + MD_MAC_EXC_RESOURCE_FLAVOR_IO_PHYSICAL_WRITES = 1, + MD_MAC_EXC_RESOURCE_FLAVOR_IO_LOGICAL_WRITES = 2, + } MDMacExcResourceIOFlavor; + + typedef enum MDMacExcResourceThreadsFlavor { + MD_MAC_EXC_RESOURCE_FLAVOR_THREADS_HIGH_WATERMARK = 1, + } MDMacExcResourceThreadsFlavor; + ++// See https://github.com/apple/darwin-xnu/blob/main/osfmk/kern/exc_guard.h ++ ++typedef enum MDMacExcGuardType { ++ MD_MAC_EXC_GUARD_TYPE_NONE = 0x0, ++ MD_MAC_EXC_GUARD_TYPE_MACH_PORT = 0x1, ++ MD_MAC_EXC_GUARD_TYPE_FD = 0x2, ++ MD_MAC_EXC_GUARD_TYPE_USER = 0x3, ++ MD_MAC_EXC_GUARD_TYPE_VN = 0x4, ++ MD_MAC_EXC_GUARD_TYPE_VIRT_MEMORY = 0x5 ++} MDMacExcGuardType; ++ ++// See https://github.com/apple/darwin-xnu/osfmk/mach/port.h ++ ++typedef enum MDMacExcGuardMachPortFlavor { ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_DESTROY = 1u << 0, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MOD_REFS = 1u << 1, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SET_CONTEXT = 1u << 2, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_UNGUARDED = 1u << 3, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INCORRECT_GUARD = 1u << 4, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_IMMOVABLE = 1u << 5, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_STRICT_REPLY = 1u << 6, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MSG_FILTERED = 1u << 7, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_RIGHT = 1u << 8, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_NAME = 1u << 9, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_VALUE = 1u << 10, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_ARGUMENT = 1u << 11, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RIGHT_EXISTS = 1u << 12, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_NO_SPACE = 1u << 13, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_FAILURE = 1u << 14, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_RESOURCE = 1u << 15, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_REPLY = 1u << 16, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_VOUCHER = 1u << 17, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_RIGHT = 1u << 18, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RCV_INVALID_NAME = 1u << 19, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RCV_GUARDED_DESC = 1u << 20, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MOD_REFS_NON_FATAL = 1u << 21, ++ MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_IMMOVABLE_NON_FATAL = 1u << 22, ++} MDMacExcGuardMachPortFlavor; ++ ++// See https://github.com/apple/darwin-xnu/blob/main/bsd/sys/guarded.h ++ ++typedef enum MDMacExcGuardFDFlavor { ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_CLOSE = 1u << 0, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_DUP = 1u << 1, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_NOCLOEXEC = 1u << 2, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_SOCKET_IPC = 1u << 3, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_FILEPORT = 1u << 4, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_MISMATCH = 1u << 5, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_WRITE = 1u << 6 ++} MDMacExcGuardFDFlavor; ++ ++ ++typedef enum MDMacExcGuardVNFlavor { ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_RENAME_TO = 1u << 0, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_RENAME_FROM = 1u << 1, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_UNLINK = 1u << 2, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_WRITE_OTHER = 1u << 3, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_TRUNC_OTHER = 1u << 4, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_LINK = 1u << 5, ++ MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_EXCHDATA = 1u << 6, ++} MDMacExcGuardVNFlavor; ++ ++// See https://github.com/apple/darwin-xnu/osfmk/mach/vm_statistics.h ++ ++typedef enum MDMacExcGuardVirtMemoryFlavor { ++ MD_MAC_EXC_GUARD_VIRT_MEMORY_FLAVOR_GUARD_EXC_DEALLOC_GAP = 1u << 0 ++} MDMacExcGuardVirtMemoryFlavor; ++ + #endif /* GOOGLE_BREAKPAD_COMMON_MINIDUMP_EXCEPTION_MAC_OSX_H__ */ +diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc +--- a/src/processor/minidump_processor.cc ++++ b/src/processor/minidump_processor.cc +@@ -1213,16 +1213,245 @@ string MinidumpProcessor::GetCrashReason + } + break; + default: + reason.append(flags_string); + break; + } + } + break; ++ case MD_EXCEPTION_MAC_GUARD: ++ reason = "EXC_GUARD / "; ++ { ++ uint32_t type = (exception_flags >> 29) & 0x7ULL; ++ uint32_t flavor = exception_flags & 0x1FFFFFFFULL; ++ switch (type) { ++ case MD_MAC_EXC_GUARD_TYPE_NONE: ++ reason.append("GUARD_TYPE_NONE"); ++ break; ++ case MD_MAC_EXC_GUARD_TYPE_MACH_PORT: ++ reason.append("GUARD_TYPE_MACH_PORT"); ++ ++ if (flavor) { ++ std::vector<std::string> flavors; ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_DESTROY) { ++ flavors.push_back("GUARD_EXC_DESTROY"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MOD_REFS) { ++ flavors.push_back("GUARD_EXC_MOD_REFS"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SET_CONTEXT) { ++ flavors.push_back("GUARD_EXC_SET_CONTEXT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SET_CONTEXT) { ++ flavors.push_back("GUARD_EXC_SET_CONTEXT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_UNGUARDED) { ++ flavors.push_back("GUARD_EXC_UNGUARDED"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INCORRECT_GUARD) { ++ flavors.push_back("GUARD_EXC_INCORRECT_GUARD"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_IMMOVABLE) { ++ flavors.push_back("GUARD_EXC_IMMOVABLE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_STRICT_REPLY) { ++ flavors.push_back("GUARD_EXC_STRICT_REPLY"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MSG_FILTERED) { ++ flavors.push_back("GUARD_EXC_MSG_FILTERED"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_RIGHT) { ++ flavors.push_back("GUARD_EXC_INVALID_RIGHT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_NAME) { ++ flavors.push_back("GUARD_EXC_INVALID_NAME"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_VALUE) { ++ flavors.push_back("GUARD_EXC_INVALID_VALUE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_INVALID_ARGUMENT) { ++ flavors.push_back("GUARD_EXC_INVALID_ARGUMENT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RIGHT_EXISTS) { ++ flavors.push_back("GUARD_EXC_RIGHT_EXISTS"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_NO_SPACE) { ++ flavors.push_back("GUARD_EXC_KERN_NO_SPACE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_FAILURE) { ++ flavors.push_back("GUARD_EXC_KERN_FAILURE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_KERN_RESOURCE) { ++ flavors.push_back("GUARD_EXC_KERN_RESOURCE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_REPLY) { ++ flavors.push_back("GUARD_EXC_SEND_INVALID_REPLY"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_VOUCHER) { ++ flavors.push_back("GUARD_EXC_SEND_INVALID_VOUCHER"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_SEND_INVALID_RIGHT) { ++ flavors.push_back("GUARD_EXC_SEND_INVALID_RIGHT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RCV_INVALID_NAME) { ++ flavors.push_back("GUARD_EXC_RCV_INVALID_NAME"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_RCV_GUARDED_DESC) { ++ flavors.push_back("GUARD_EXC_RCV_GUARDED_DESC"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_MOD_REFS_NON_FATAL) { ++ flavors.push_back("GUARD_EXC_MOD_REFS_NON_FATAL"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_MACH_PORT_FLAVOR_GUARD_EXC_IMMOVABLE_NON_FATAL) { ++ flavors.push_back("GUARD_EXC_IMMOVABLE_NON_FATAL"); ++ } ++ ++ reason.append(" / "); ++ for (size_t i = 0; i < flavors.size(); i++) { ++ if (i > 0) { ++ reason.append(" | "); ++ } ++ ++ reason.append(flavors[i]); ++ } ++ } ++ ++ break; ++ case MD_MAC_EXC_GUARD_TYPE_FD: ++ reason.append("GUARD_TYPE_FD"); ++ ++ if (flavor) { ++ std::vector<std::string> flavors; ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_CLOSE) { ++ flavors.push_back("GUARD_EXC_CLOSE"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_DUP) { ++ flavors.push_back("GUARD_EXC_DUP"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_NOCLOEXEC) { ++ flavors.push_back("GUARD_EXC_NOCLOEXEC"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_SOCKET_IPC) { ++ flavors.push_back("GUARD_EXC_SOCKET_IPC"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_FILEPORT) { ++ flavors.push_back("GUARD_EXC_FILEPORT"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_MISMATCH) { ++ flavors.push_back("GUARD_EXC_MISMATCH"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_WRITE) { ++ flavors.push_back("GUARD_EXC_WRITE"); ++ } ++ ++ reason.append(" / "); ++ for (size_t i = 0; i < flavors.size(); i++) { ++ if (i > 0) { ++ reason.append(" | "); ++ } ++ ++ reason.append(flavors[i]); ++ } ++ } ++ ++ break; ++ case MD_MAC_EXC_GUARD_TYPE_USER: ++ reason.append("GUARD_TYPE_USER"); ++ break; ++ case MD_MAC_EXC_GUARD_TYPE_VN: ++ reason.append("GUARD_TYPE_VN"); ++ ++ if (flavor) { ++ std::vector<std::string> flavors; ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_RENAME_TO) { ++ flavors.push_back("GUARD_EXC_RENAME_TO"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_RENAME_FROM) { ++ flavors.push_back("GUARD_EXC_RENAME_FROM"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_UNLINK) { ++ flavors.push_back("GUARD_EXC_UNLINK"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_WRITE_OTHER) { ++ flavors.push_back("GUARD_EXC_WRITE_OTHER"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_TRUNC_OTHER) { ++ flavors.push_back("GUARD_EXC_TRUNC_OTHER"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_LINK) { ++ flavors.push_back("GUARD_EXC_LINK"); ++ } ++ ++ if (flavor & MD_MAC_EXC_GUARD_FD_FLAVOR_GUARD_EXC_EXCHDATA) { ++ flavors.push_back("GUARD_EXC_EXCHDATA"); ++ } ++ ++ reason.append(" / "); ++ for (size_t i = 0; i < flavors.size(); i++) { ++ if (i > 0) { ++ reason.append(" | "); ++ } ++ ++ reason.append(flavors[i]); ++ } ++ } ++ ++ break; ++ case MD_MAC_EXC_GUARD_TYPE_VIRT_MEMORY: ++ reason.append("GUARD_TYPE_VIRT_MEMORY"); ++ ++ if (flavor & MD_MAC_EXC_GUARD_VIRT_MEMORY_FLAVOR_GUARD_EXC_DEALLOC_GAP) { ++ reason.append(" / GUARD_EXC_DEALLOC_GAP"); ++ } ++ ++ break; ++ default: ++ reason.append(flags_string); ++ break; ++ } ++ } ++ break; + case MD_EXCEPTION_MAC_SIMULATED: + reason = "Simulated Exception"; + break; + } + break; + } + + case MD_OS_WIN32_NT: diff --git a/toolkit/crashreporter/breakpad-patches/26-print-thread-tid.patch b/toolkit/crashreporter/breakpad-patches/26-print-thread-tid.patch new file mode 100644 index 0000000000..f81ca774bd --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/26-print-thread-tid.patch @@ -0,0 +1,44 @@ +diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc +--- a/src/processor/stackwalk_common.cc ++++ b/src/processor/stackwalk_common.cc +@@ -879,18 +879,19 @@ void PrintProcessState(const ProcessStat + } + + // If the thread that requested the dump is known, print it first. + int requesting_thread = process_state.requesting_thread(); + if (requesting_thread != -1) { + const CallStack* requesting_thread_callstack = + process_state.threads()->at(requesting_thread); + printf("\n" +- "Thread %d (%s)", ++ "Thread %d tid %u (%s)", + requesting_thread, ++ requesting_thread_callstack->tid(), + process_state.crashed() ? "crashed" : + "requested dump, did not crash"); + if (!requesting_thread_callstack->name().empty()) { + printf(" - %s", requesting_thread_callstack->name().c_str()); + } + PrintStack(requesting_thread_callstack, cpu, + output_stack_contents, + process_state.thread_memory_regions()->at(requesting_thread), +@@ -899,17 +900,17 @@ void PrintProcessState(const ProcessStat + + // Print all of the threads in the dump. + int thread_count = process_state.threads()->size(); + for (int thread_index = 0; thread_index < thread_count; ++thread_index) { + if (thread_index != requesting_thread) { + // Don't print the crash thread again, it was already printed. + const CallStack* callstack = process_state.threads()->at(thread_index); + printf("\n" +- "Thread %d", thread_index); ++ "Thread %d tid %u", thread_index, callstack->tid()); + if (!callstack->name().empty()) { + printf(" - %s", callstack->name().c_str()); + } + printf("\n"); + PrintStack(callstack, cpu, + output_stack_contents, + process_state.thread_memory_regions()->at(thread_index), + process_state.modules(), resolver); + diff --git a/toolkit/crashreporter/breakpad-patches/27-fix-unified-builds-bug-1733547.patch b/toolkit/crashreporter/breakpad-patches/27-fix-unified-builds-bug-1733547.patch new file mode 100644 index 0000000000..5afc50316e --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/27-fix-unified-builds-bug-1733547.patch @@ -0,0 +1,22 @@ +diff --git a/src/processor/stack_frame_symbolizer.cc b/src/processor/stack_frame_symbolizer.cc +--- a/src/processor/stack_frame_symbolizer.cc ++++ b/src/processor/stack_frame_symbolizer.cc +@@ -124,17 +124,16 @@ StackFrameSymbolizer::SymbolizerResult S + + case SymbolSupplier::INTERRUPT: + return kInterrupt; + + default: + BPLOG(ERROR) << "Unknown SymbolResult enum: " << symbol_result; + return kError; + } +- return kError; + } + + WindowsFrameInfo* StackFrameSymbolizer::FindWindowsFrameInfo( + const StackFrame* frame) { + return resolver_ ? resolver_->FindWindowsFrameInfo(frame) : NULL; + } + + CFIFrameInfo* StackFrameSymbolizer::FindCFIFrameInfo( + diff --git a/toolkit/crashreporter/breakpad-patches/28-no-garbage-in-code-ids.patch b/toolkit/crashreporter/breakpad-patches/28-no-garbage-in-code-ids.patch new file mode 100644 index 0000000000..64f791d01e --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/28-no-garbage-in-code-ids.patch @@ -0,0 +1,34 @@ +diff --git a/src/common/linux/file_id.cc b/src/common/linux/file_id.cc +--- a/src/common/linux/file_id.cc ++++ b/src/common/linux/file_id.cc +@@ -115,28 +115,27 @@ static bool FindElfBuildIDNote(const voi + + return false; + } + + // Attempt to locate the .text section of an ELF binary and generate + // a simple hash by XORing the first page worth of bytes into |identifier|. + static bool HashElfTextSection(const void* elf_mapped_base, + wasteful_vector<uint8_t>& identifier) { +- identifier.resize(kMDGUIDSize); +- + void* text_section; + size_t text_size; + if (!FindElfSection(elf_mapped_base, ".text", SHT_PROGBITS, + (const void**)&text_section, &text_size) || + text_size == 0) { + return false; + } + + // Only provide |kMDGUIDSize| bytes to keep identifiers produced by this + // function backwards-compatible. ++ identifier.resize(kMDGUIDSize); + my_memset(&identifier[0], 0, kMDGUIDSize); + const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section); + const uint8_t* ptr_end = ptr + std::min(text_size, static_cast<size_t>(4096)); + while (ptr < ptr_end) { + for (unsigned i = 0; i < kMDGUIDSize; i++) + identifier[i] ^= ptr[i]; + ptr += kMDGUIDSize; + } + diff --git a/toolkit/crashreporter/breakpad-patches/29-cpu-context-packing.patch b/toolkit/crashreporter/breakpad-patches/29-cpu-context-packing.patch new file mode 100644 index 0000000000..f6ef0c4d29 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/29-cpu-context-packing.patch @@ -0,0 +1,118 @@ +diff --git a/src/google_breakpad/common/minidump_cpu_arm64.h b/src/google_breakpad/common/minidump_cpu_arm64.h +--- a/src/google_breakpad/common/minidump_cpu_arm64.h ++++ b/src/google_breakpad/common/minidump_cpu_arm64.h +@@ -86,16 +86,20 @@ typedef struct { + #define MD_CONTEXT_ARM64_INTEGER (MD_CONTEXT_ARM64 | 0x00000002) + #define MD_CONTEXT_ARM64_FLOATING_POINT (MD_CONTEXT_ARM64 | 0x00000004) + #define MD_CONTEXT_ARM64_DEBUG (MD_CONTEXT_ARM64 | 0x00000008) + #define MD_CONTEXT_ARM64_FULL (MD_CONTEXT_ARM64_CONTROL | \ + MD_CONTEXT_ARM64_INTEGER | \ + MD_CONTEXT_ARM64_FLOATING_POINT) + #define MD_CONTEXT_ARM64_ALL (MD_CONTEXT_ARM64_FULL | MD_CONTEXT_ARM64_DEBUG) + ++/* Use the same 32-bit alignment when accessing these structures from 64-bit ++ * code as is used natively in 32-bit code. */ ++#pragma pack(push, 4) ++ + typedef struct { + /* Determines which fields of this struct are populated */ + uint32_t context_flags; + + /* CPSR (flags, basically): 32 bits: + bit 31 - N (negative) + bit 30 - Z (zero) + bit 29 - C (carry) +@@ -125,20 +129,16 @@ typedef struct { + typedef struct { + uint32_t fpsr; /* FPU status register */ + uint32_t fpcr; /* FPU control register */ + + /* 32 128-bit floating point registers, d0 .. d31. */ + uint128_struct regs[MD_FLOATINGSAVEAREA_ARM64_FPR_COUNT]; + } MDFloatingSaveAreaARM64_Old; + +-/* Use the same 32-bit alignment when accessing this structure from 64-bit code +- * as is used natively in 32-bit code. */ +-#pragma pack(push, 4) +- + typedef struct { + /* The next field determines the layout of the structure, and which parts + * of it are populated + */ + uint64_t context_flags; + + /* 33 64-bit integer registers, x0 .. x31 + the PC + * Note the following fixed uses: +diff --git a/src/google_breakpad/common/minidump_cpu_ppc.h b/src/google_breakpad/common/minidump_cpu_ppc.h +--- a/src/google_breakpad/common/minidump_cpu_ppc.h ++++ b/src/google_breakpad/common/minidump_cpu_ppc.h +@@ -73,16 +73,20 @@ + /* + * Breakpad minidump extension for PowerPC support. Based on Darwin/Mac OS X' + * mach/ppc/_types.h + */ + + #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_PPC_H__ + #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_PPC_H__ + ++/* Use the same 32-bit alignment when accessing these structures from 64-bit ++ * code as is used natively in 32-bit code. */ ++#pragma pack(push, 4) ++ + #define MD_FLOATINGSAVEAREA_PPC_FPR_COUNT 32 + + typedef struct { + /* fpregs is a double[32] in mach/ppc/_types.h, but a uint64_t is used + * here for precise sizing. */ + uint64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT]; + uint32_t fpscr_pad; + uint32_t fpscr; /* Status/control */ +@@ -99,25 +103,16 @@ typedef struct { + uint32_t save_pad5[4]; + uint32_t save_vrvalid; /* Indicates which vector registers are saved */ + uint32_t save_pad6[7]; + } MDVectorSaveAreaPPC; /* ppc_vector_state */ + + + #define MD_CONTEXT_PPC_GPR_COUNT 32 + +-/* Use the same 32-bit alignment when accessing this structure from 64-bit code +- * as is used natively in 32-bit code. #pragma pack is a MSVC extension +- * supported by gcc. */ +-#if defined(__SUNPRO_C) || defined(__SUNPRO_CC) +-#pragma pack(4) +-#else +-#pragma pack(push, 4) +-#endif +- + typedef struct { + /* context_flags is not present in ppc_thread_state, but it aids + * identification of MDRawContextPPC among other raw context types, + * and it guarantees alignment when we get to float_save. */ + uint32_t context_flags; + + uint32_t srr0; /* Machine status save/restore: stores pc + * (instruction) */ +@@ -140,21 +135,17 @@ typedef struct { + MDVectorSaveAreaPPC vector_save; + } MDRawContextPPC; /* Based on ppc_thread_state */ + + /* Indices into gpr for registers with a dedicated or conventional purpose. */ + enum MDPPCRegisterNumbers { + MD_CONTEXT_PPC_REG_SP = 1 + }; + +-#if defined(__SUNPRO_C) || defined(__SUNPRO_CC) +-#pragma pack(0) +-#else + #pragma pack(pop) +-#endif + + /* For (MDRawContextPPC).context_flags. These values indicate the type of + * context stored in the structure. MD_CONTEXT_PPC is Breakpad-defined. Its + * value was chosen to avoid likely conflicts with MD_CONTEXT_* for other + * CPUs. */ + #define MD_CONTEXT_PPC 0x20000000 + #define MD_CONTEXT_PPC_BASE (MD_CONTEXT_PPC | 0x00000001) + #define MD_CONTEXT_PPC_FLOATING_POINT (MD_CONTEXT_PPC | 0x00000008) + diff --git a/toolkit/crashreporter/breakpad-patches/30-sign-compare.patch b/toolkit/crashreporter/breakpad-patches/30-sign-compare.patch new file mode 100644 index 0000000000..5fbf075810 --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/30-sign-compare.patch @@ -0,0 +1,11 @@ +--- a/src/client/windows/crash_generation/crash_generation_server.cc ++++ b/src/client/windows/crash_generation/crash_generation_server.cc +@@ -954,7 +954,7 @@ bool CrashGenerationServer::GenerateDump(const ClientInfo& client, + } + + // Allocate AppMemory instances for exception context. +- for (int i = 0; i < kExceptionAppMemoryRegions; i++) { ++ for (size_t i = 0; i < kExceptionAppMemoryRegions; i++) { + AppMemory app_memory; + app_memory.ptr = reinterpret_cast<ULONG64>(nullptr); + app_memory.length = 0; diff --git a/toolkit/crashreporter/breakpad-patches/README b/toolkit/crashreporter/breakpad-patches/README new file mode 100644 index 0000000000..b3f23b255f --- /dev/null +++ b/toolkit/crashreporter/breakpad-patches/README @@ -0,0 +1,4 @@ +Do not land local patches to Breakpad without the approval of +Ted Mielczarek <ted@mielczarek.org> + +All local patches must be in the process of being upstreamed.
\ No newline at end of file |