diff options
Diffstat (limited to 'toolkit/crashreporter/breakpad-patches')
11 files changed, 8405 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/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 |